+1

.gitignore

··· 1 1 + .research/ 1 2 # See https://help.github.com/articles/ignoring-files/ for more about ignoring files. 2 3 .env 3 4 # dependencies

+2

.tangled/workflows/deploy-wisp.yml

··· 49 49 - name: Build docs 50 50 command: | 51 51 cd docs 52 52 + export PATH="$HOME/.nix-profile/bin:$PATH" 53 53 + bun install 52 54 bun run build 53 55 - name: Deploy to Wisp.place 54 56 command: |

+2 -1

.tangled/workflows/test.yml

··· 7 7 dependencies: 8 8 nixpkgs: 9 9 - git 10 10 + - findutils 10 11 github:NixOS/nixpkgs/nixpkgs-unstable: 11 12 - bun 12 13 ··· 16 17 export PATH="$HOME/.nix-profile/bin:$PATH" 17 18 18 19 # have to regenerate otherwise it wont install necessary dependencies to run 19 19 - rm -rf bun.lock package-lock.json 20 20 + find . -type f \( -name "bun.lock" -o -name "package-lock.json" \) -delete 20 21 bun install 21 22 22 23 - name: run all tests

+9 -8

apps/hosting-service/package.json

··· 10 10 "backfill": "tsx src/index.ts --backfill" 11 11 }, 12 12 "dependencies": { 13 13 - "@wisp/lexicons": "workspace:*", 14 14 - "@wisp/constants": "workspace:*", 15 15 - "@wisp/observability": "workspace:*", 16 16 - "@wisp/atproto-utils": "workspace:*", 17 17 - "@wisp/database": "workspace:*", 18 18 - "@wisp/fs-utils": "workspace:*", 19 19 - "@wisp/safe-fetch": "workspace:*", 20 13 "@atproto/api": "^0.17.4", 21 14 "@atproto/identity": "^0.4.9", 22 15 "@atproto/lexicon": "^0.5.2", 23 16 "@atproto/sync": "^0.1.36", 24 17 "@atproto/xrpc": "^0.7.5", 25 18 "@hono/node-server": "^1.19.6", 19 19 + "@wisp/atproto-utils": "workspace:*", 20 20 + "@wisp/constants": "workspace:*", 21 21 + "@wisp/database": "workspace:*", 22 22 + "@wisp/fs-utils": "workspace:*", 23 23 + "@wisp/lexicons": "workspace:*", 24 24 + "@wisp/observability": "workspace:*", 25 25 + "@wisp/safe-fetch": "workspace:*", 26 26 "hono": "^4.10.4", 27 27 "mime-types": "^2.1.35", 28 28 "multiformats": "^13.4.1", 29 29 - "postgres": "^3.4.5" 29 29 + "postgres": "^3.4.5", 30 30 + "tiered-storage": "1.0.3" 30 31 }, 31 32 "devDependencies": { 32 33 "@types/bun": "^1.3.1",

+34 -4

apps/hosting-service/src/index.ts

··· 4 4 import { createLogger, initializeGrafanaExporters } from '@wisp/observability'; 5 5 import { mkdirSync, existsSync } from 'fs'; 6 6 import { backfillCache } from './lib/backfill'; 7 7 - import { startDomainCacheCleanup, stopDomainCacheCleanup, setCacheOnlyMode } from './lib/db'; 7 7 + import { startDomainCacheCleanup, stopDomainCacheCleanup, setCacheOnlyMode, closeDatabase } from './lib/db'; 8 8 + import { storage, getStorageConfig } from './lib/storage'; 8 9 9 10 // Initialize Grafana exporters if configured 10 11 initializeGrafanaExporters({ ··· 50 51 51 52 firehose.start(); 52 53 54 54 + // Optional: Bootstrap hot cache from warm tier on startup 55 55 + const BOOTSTRAP_HOT_ON_STARTUP = process.env.BOOTSTRAP_HOT_ON_STARTUP === 'true'; 56 56 + const BOOTSTRAP_HOT_LIMIT = process.env.BOOTSTRAP_HOT_LIMIT ? parseInt(process.env.BOOTSTRAP_HOT_LIMIT) : 100; 57 57 + 58 58 + if (BOOTSTRAP_HOT_ON_STARTUP) { 59 59 + console.log(`🔥 Bootstrapping hot cache (top ${BOOTSTRAP_HOT_LIMIT} items)...`); 60 60 + storage.bootstrapHot(BOOTSTRAP_HOT_LIMIT) 61 61 + .then((loaded: number) => { 62 62 + console.log(`✅ Bootstrapped ${loaded} items into hot cache`); 63 63 + }) 64 64 + .catch((err: unknown) => { 65 65 + console.error('❌ Hot cache bootstrap error:', err); 66 66 + }); 67 67 + } 68 68 + 53 69 // Run backfill if requested 54 70 if (backfillOnStartup) { 55 71 console.log('🔄 Backfill requested, starting cache backfill...'); ··· 78 94 port: PORT, 79 95 }); 80 96 97 97 + // Get storage configuration for display 98 98 + const storageConfig = getStorageConfig(); 99 99 + 81 100 console.log(` 82 82 - Wisp Hosting Service 101 101 + Wisp Hosting Service with Tiered Storage 83 102 84 103 Server: http://localhost:${PORT} 85 104 Health: http://localhost:${PORT}/health 86 86 - Cache: ${CACHE_DIR} 87 87 - Firehose: Connected to Firehose 88 105 Cache-Only: ${CACHE_ONLY_MODE ? 'ENABLED (no DB writes)' : 'DISABLED'} 89 106 Backfill: ${backfillOnStartup ? `ENABLED (concurrency: ${BACKFILL_CONCURRENCY || 10})` : 'DISABLED'} 107 107 + 108 108 + Tiered Storage Configuration: 109 109 + Hot Cache: ${storageConfig.hotCacheSize} (${storageConfig.hotCacheCount} items max) 110 110 + Warm Cache: ${storageConfig.warmCacheSize} (${storageConfig.warmEvictionPolicy} eviction) 111 111 + Cold Storage: S3 - ${storageConfig.s3Bucket} 112 112 + S3 Region: ${storageConfig.s3Region} 113 113 + S3 Endpoint: ${storageConfig.s3Endpoint} 114 114 + S3 Prefix: ${storageConfig.s3Prefix} 115 115 + Metadata Bucket: ${storageConfig.metadataBucket} 116 116 + 117 117 + Firehose: Connecting... 90 118 `); 91 119 92 120 // Graceful shutdown ··· 94 122 console.log('\n🛑 Shutting down...'); 95 123 firehose.stop(); 96 124 stopDomainCacheCleanup(); 125 125 + await closeDatabase(); 97 126 server.close(); 98 127 process.exit(0); 99 128 }); ··· 102 131 console.log('\n🛑 Shutting down...'); 103 132 firehose.stop(); 104 133 stopDomainCacheCleanup(); 134 134 + await closeDatabase(); 105 135 server.close(); 106 136 process.exit(0); 107 137 });

+1 -1

apps/hosting-service/src/lib/backfill.ts

··· 69 69 const processSite = async () => { 70 70 try { 71 71 // Check if already cached 72 72 - if (skipExisting && isCached(site.did, site.rkey)) { 72 72 + if (skipExisting && await isCached(site.did, site.rkey)) { 73 73 stats.skipped++; 74 74 processed++; 75 75 logger.debug(`Skipping already cached site`, { did: site.did, rkey: site.rkey });

+35 -43

apps/hosting-service/src/lib/cache.ts

··· 1 1 - // In-memory LRU cache for file contents and metadata 1 1 + /** 2 2 + * Cache management for wisp-hosting-service 3 3 + * 4 4 + * With tiered storage, most caching is handled transparently. 5 5 + * This module tracks sites being cached and manages rewritten HTML cache. 6 6 + */ 2 7 8 8 + import { storage } from './storage'; 9 9 + 10 10 + // In-memory LRU cache for rewritten HTML (for path rewriting in subdomain routes) 3 11 interface CacheEntry<T> { 4 12 value: T; 5 13 size: number; ··· 96 104 return true; 97 105 } 98 106 99 99 - // Invalidate all entries for a specific site 100 100 - invalidateSite(did: string, rkey: string): number { 101 101 - const prefix = `${did}:${rkey}:`; 102 102 - let count = 0; 103 103 - 104 104 - for (const key of Array.from(this.cache.keys())) { 105 105 - if (key.startsWith(prefix)) { 106 106 - this.delete(key); 107 107 - count++; 108 108 - } 109 109 - } 110 110 - 111 111 - return count; 112 112 - } 113 113 - 114 114 - // Get cache size 115 107 size(): number { 116 108 return this.cache.size; 117 109 } ··· 127 119 return { ...this.stats }; 128 120 } 129 121 130 130 - // Get cache hit rate 131 122 getHitRate(): number { 132 123 const total = this.stats.hits + this.stats.misses; 133 124 return total === 0 ? 0 : (this.stats.hits / total) * 100; 134 125 } 135 126 } 136 127 137 137 - // File metadata cache entry 138 138 - export interface FileMetadata { 139 139 - encoding?: 'gzip'; 140 140 - mimeType: string; 141 141 - } 142 142 - 143 143 - // Global cache instances 144 144 - const FILE_CACHE_SIZE = 100 * 1024 * 1024; // 100MB 145 145 - const FILE_CACHE_COUNT = 500; 146 146 - const METADATA_CACHE_COUNT = 2000; 147 147 - 148 148 - export const fileCache = new LRUCache<Buffer>(FILE_CACHE_SIZE, FILE_CACHE_COUNT); 149 149 - export const metadataCache = new LRUCache<FileMetadata>(1024 * 1024, METADATA_CACHE_COUNT); // 1MB for metadata 128 128 + // Rewritten HTML cache: stores HTML after path rewriting for subdomain routes 150 129 export const rewrittenHtmlCache = new LRUCache<Buffer>(50 * 1024 * 1024, 200); // 50MB for rewritten HTML 151 130 152 152 - // Helper to generate cache keys 131 131 + // Helper to generate cache keys for rewritten HTML 153 132 export function getCacheKey(did: string, rkey: string, filePath: string, suffix?: string): string { 154 133 const base = `${did}:${rkey}:${filePath}`; 155 134 return suffix ? `${base}:${suffix}` : base; 156 135 } 157 136 158 158 - // Invalidate all caches for a site 159 159 - export function invalidateSiteCache(did: string, rkey: string): void { 160 160 - const fileCount = fileCache.invalidateSite(did, rkey); 161 161 - const metaCount = metadataCache.invalidateSite(did, rkey); 162 162 - const htmlCount = rewrittenHtmlCache.invalidateSite(did, rkey); 137 137 + /** 138 138 + * Invalidate site cache via tiered storage 139 139 + * Also invalidates locally cached rewritten HTML 140 140 + */ 141 141 + export async function invalidateSiteCache(did: string, rkey: string): Promise<void> { 142 142 + // Invalidate in tiered storage 143 143 + const prefix = `${did}/${rkey}/`; 144 144 + const deleted = await storage.invalidate(prefix); 163 145 164 164 - console.log(`[Cache] Invalidated site ${did}:${rkey} - ${fileCount} files, ${metaCount} metadata, ${htmlCount} HTML`); 146 146 + // Invalidate rewritten HTML cache for this site 147 147 + const sitePrefix = `${did}:${rkey}:`; 148 148 + let htmlCount = 0; 149 149 + const cacheKeys = Array.from((rewrittenHtmlCache as any).cache?.keys() || []) as string[]; 150 150 + for (const key of cacheKeys) { 151 151 + if (key.startsWith(sitePrefix)) { 152 152 + rewrittenHtmlCache.delete(key); 153 153 + htmlCount++; 154 154 + } 155 155 + } 156 156 + 157 157 + console.log(`[Cache] Invalidated site ${did}:${rkey} - ${deleted} files in tiered storage, ${htmlCount} rewritten HTML`); 165 158 } 166 159 167 160 // Track sites currently being cached (to prevent serving stale cache during updates) ··· 183 176 } 184 177 185 178 // Get overall cache statistics 186 186 - export function getCacheStats() { 179 179 + export async function getCacheStats() { 180 180 + const tieredStats = await storage.getStats(); 181 181 + 187 182 return { 188 188 - files: fileCache.getStats(), 189 189 - fileHitRate: fileCache.getHitRate(), 190 190 - metadata: metadataCache.getStats(), 191 191 - metadataHitRate: metadataCache.getHitRate(), 183 183 + tieredStorage: tieredStats, 192 184 rewrittenHtml: rewrittenHtmlCache.getStats(), 193 185 rewrittenHtmlHitRate: rewrittenHtmlCache.getHitRate(), 194 186 sitesBeingCached: sitesBeingCached.size,

+32 -1

apps/hosting-service/src/lib/db.ts

··· 183 183 return hashNum & 0x7FFFFFFFFFFFFFFFn; 184 184 } 185 185 186 186 + // Track active locks for cleanup on shutdown 187 187 + const activeLocks = new Set<string>(); 188 188 + 186 189 /** 187 190 * Acquire a distributed lock using PostgreSQL advisory locks 188 191 * Returns true if lock was acquired, false if already held by another instance ··· 193 196 194 197 try { 195 198 const result = await sql`SELECT pg_try_advisory_lock(${Number(lockId)}) as acquired`; 196 196 - return result[0]?.acquired === true; 199 199 + const acquired = result[0]?.acquired === true; 200 200 + if (acquired) { 201 201 + activeLocks.add(key); 202 202 + } 203 203 + return acquired; 197 204 } catch (err) { 198 205 console.error('Failed to acquire lock', { key, error: err }); 199 206 return false; ··· 208 215 209 216 try { 210 217 await sql`SELECT pg_advisory_unlock(${Number(lockId)})`; 218 218 + activeLocks.delete(key); 211 219 } catch (err) { 212 220 console.error('Failed to release lock', { key, error: err }); 221 221 + // Still remove from tracking even if unlock fails 222 222 + activeLocks.delete(key); 223 223 + } 224 224 + } 225 225 + 226 226 + /** 227 227 + * Close all database connections 228 228 + * Call this during graceful shutdown 229 229 + */ 230 230 + export async function closeDatabase(): Promise<void> { 231 231 + try { 232 232 + // Release all active advisory locks before closing connections 233 233 + if (activeLocks.size > 0) { 234 234 + console.log(`[DB] Releasing ${activeLocks.size} active advisory locks before shutdown`); 235 235 + for (const key of activeLocks) { 236 236 + await releaseLock(key); 237 237 + } 238 238 + } 239 239 + 240 240 + await sql.end({ timeout: 5 }); 241 241 + console.log('[DB] Database connections closed'); 242 242 + } catch (err) { 243 243 + console.error('[DB] Error closing database connections:', err); 213 244 } 214 245 } 215 246

+64 -76

apps/hosting-service/src/lib/file-serving.ts

··· 7 7 import { lookup } from 'mime-types'; 8 8 import type { Record as WispSettings } from '@wisp/lexicons/types/place/wisp/settings'; 9 9 import { shouldCompressMimeType } from '@wisp/atproto-utils/compression'; 10 10 - import { fileCache, metadataCache, rewrittenHtmlCache, getCacheKey, isSiteBeingCached } from './cache'; 10 10 + import { rewrittenHtmlCache, getCacheKey, isSiteBeingCached } from './cache'; 11 11 import { getCachedFilePath, getCachedSettings } from './utils'; 12 12 import { loadRedirectRules, matchRedirectRule, parseCookies, parseQueryString } from './redirects'; 13 13 import { rewriteHtmlPaths, isHtmlContent } from './html-rewriter'; 14 14 import { generate404Page, generateDirectoryListing, siteUpdatingResponse } from './page-generators'; 15 15 import { getIndexFiles, applyCustomHeaders, fileExists } from './request-utils'; 16 16 import { getRedirectRulesFromCache, setRedirectRulesInCache } from './site-cache'; 17 17 + import { storage } from './storage'; 18 18 + 19 19 + /** 20 20 + * Helper to retrieve a file with metadata from tiered storage 21 21 + */ 22 22 + async function getFileWithMetadata(did: string, rkey: string, filePath: string) { 23 23 + const key = `${did}/${rkey}/${filePath}`; 24 24 + return await storage.getWithMetadata(key); 25 25 + } 17 26 18 27 /** 19 28 * Helper to serve files from cache (for custom domains and subdomains) ··· 176 185 177 186 // Not a directory, try to serve as a file 178 187 const fileRequestPath: string = requestPath || indexFiles[0] || 'index.html'; 179 179 - const cacheKey = getCacheKey(did, rkey, fileRequestPath); 180 180 - const cachedFile = getCachedFilePath(did, rkey, fileRequestPath); 181 188 182 182 - // Check in-memory cache first 183 183 - let content = fileCache.get(cacheKey); 184 184 - let meta = metadataCache.get(cacheKey); 189 189 + // Retrieve from tiered storage 190 190 + const result = await getFileWithMetadata(did, rkey, fileRequestPath); 185 191 186 186 - if (!content && await fileExists(cachedFile)) { 187 187 - // Read from disk and cache 188 188 - content = await readFile(cachedFile); 189 189 - fileCache.set(cacheKey, content, content.length); 192 192 + if (result) { 193 193 + const content = Buffer.from(result.data); 194 194 + const meta = result.metadata.customMetadata as { encoding?: string; mimeType?: string } | undefined; 190 195 191 191 - const metaFile = `${cachedFile}.meta`; 192 192 - if (await fileExists(metaFile)) { 193 193 - const metaJson = await readFile(metaFile, 'utf-8'); 194 194 - meta = JSON.parse(metaJson); 195 195 - metadataCache.set(cacheKey, meta!, JSON.stringify(meta).length); 196 196 - } 197 197 - } 198 198 - 199 199 - if (content) { 200 196 // Build headers with caching 201 201 - const headers: Record<string, string> = {}; 197 197 + const headers: Record<string, string> = { 198 198 + 'X-Cache-Tier': result.source, 199 199 + }; 202 200 203 203 - if (meta && meta.encoding === 'gzip' && meta.mimeType) { 201 201 + if (meta?.encoding === 'gzip' && meta.mimeType) { 204 202 const shouldServeCompressed = shouldCompressMimeType(meta.mimeType); 205 203 206 204 if (!shouldServeCompressed) { ··· 233 231 } 234 232 235 233 // Non-compressed files 236 236 - const mimeType = lookup(cachedFile) || 'application/octet-stream'; 234 234 + const mimeType = meta?.mimeType || lookup(fileRequestPath) || 'application/octet-stream'; 237 235 headers['Content-Type'] = mimeType; 238 236 headers['Cache-Control'] = mimeType.startsWith('text/html') 239 237 ? 'public, max-age=300' ··· 246 244 if (!fileRequestPath.includes('.')) { 247 245 for (const indexFileName of indexFiles) { 248 246 const indexPath = fileRequestPath ? `${fileRequestPath}/${indexFileName}` : indexFileName; 249 249 - const indexCacheKey = getCacheKey(did, rkey, indexPath); 250 250 - const indexFile = getCachedFilePath(did, rkey, indexPath); 251 247 252 252 - let indexContent = fileCache.get(indexCacheKey); 253 253 - let indexMeta = metadataCache.get(indexCacheKey); 248 248 + const indexResult = await getFileWithMetadata(did, rkey, indexPath); 254 249 255 255 - if (!indexContent && await fileExists(indexFile)) { 256 256 - indexContent = await readFile(indexFile); 257 257 - fileCache.set(indexCacheKey, indexContent, indexContent.length); 250 250 + if (indexResult) { 251 251 + const indexContent = Buffer.from(indexResult.data); 252 252 + const indexMeta = indexResult.metadata.customMetadata as { encoding?: string; mimeType?: string } | undefined; 258 253 259 259 - const indexMetaFile = `${indexFile}.meta`; 260 260 - if (await fileExists(indexMetaFile)) { 261 261 - const metaJson = await readFile(indexMetaFile, 'utf-8'); 262 262 - indexMeta = JSON.parse(metaJson); 263 263 - metadataCache.set(indexCacheKey, indexMeta!, JSON.stringify(indexMeta).length); 264 264 - } 265 265 - } 266 266 - 267 267 - if (indexContent) { 268 254 const headers: Record<string, string> = { 269 255 'Content-Type': 'text/html; charset=utf-8', 270 256 'Cache-Control': 'public, max-age=300', 257 257 + 'X-Cache-Tier': indexResult.source, 271 258 }; 272 259 273 273 - if (indexMeta && indexMeta.encoding === 'gzip') { 260 260 + if (indexMeta?.encoding === 'gzip') { 274 261 headers['Content-Encoding'] = 'gzip'; 275 262 } 276 263 ··· 556 543 557 544 // Not a directory, try to serve as a file 558 545 const fileRequestPath: string = requestPath || indexFiles[0] || 'index.html'; 559 559 - const cacheKey = getCacheKey(did, rkey, fileRequestPath); 560 560 - const cachedFile = getCachedFilePath(did, rkey, fileRequestPath); 561 546 562 547 // Check for rewritten HTML in cache first (if it's HTML) 563 548 const mimeTypeGuess = lookup(fileRequestPath) || 'application/octet-stream'; ··· 565 550 const rewrittenKey = getCacheKey(did, rkey, fileRequestPath, `rewritten:${basePath}`); 566 551 const rewrittenContent = rewrittenHtmlCache.get(rewrittenKey); 567 552 if (rewrittenContent) { 553 553 + console.log(`[HTML Rewrite] Serving from rewritten cache: ${rewrittenKey}`); 568 554 const headers: Record<string, string> = { 569 555 'Content-Type': 'text/html; charset=utf-8', 570 556 'Content-Encoding': 'gzip', 571 557 'Cache-Control': 'public, max-age=300', 558 558 + 'X-Cache-Tier': 'local', // Rewritten HTML is stored locally 572 559 }; 573 560 applyCustomHeaders(headers, fileRequestPath, settings); 574 561 return new Response(rewrittenContent, { headers }); 575 562 } 576 563 } 577 564 578 578 - // Check in-memory file cache 579 579 - let content = fileCache.get(cacheKey); 580 580 - let meta = metadataCache.get(cacheKey); 565 565 + // Retrieve from tiered storage 566 566 + const result = await getFileWithMetadata(did, rkey, fileRequestPath); 581 567 582 582 - if (!content && await fileExists(cachedFile)) { 583 583 - // Read from disk and cache 584 584 - content = await readFile(cachedFile); 585 585 - fileCache.set(cacheKey, content, content.length); 568 568 + if (result) { 569 569 + const content = Buffer.from(result.data); 570 570 + const meta = result.metadata.customMetadata as { encoding?: string; mimeType?: string } | undefined; 571 571 + const mimeType = meta?.mimeType || lookup(fileRequestPath) || 'application/octet-stream'; 572 572 + const isGzipped = meta?.encoding === 'gzip'; 586 573 587 587 - const metaFile = `${cachedFile}.meta`; 588 588 - if (await fileExists(metaFile)) { 589 589 - const metaJson = await readFile(metaFile, 'utf-8'); 590 590 - meta = JSON.parse(metaJson); 591 591 - metadataCache.set(cacheKey, meta!, JSON.stringify(meta).length); 592 592 - } 593 593 - } 594 594 - 595 595 - if (content) { 596 596 - const mimeType = meta?.mimeType || lookup(cachedFile) || 'application/octet-stream'; 597 597 - const isGzipped = meta?.encoding === 'gzip'; 574 574 + console.log(`[File Serve] Serving ${fileRequestPath}, mimeType: ${mimeType}, isHTML: ${isHtmlContent(fileRequestPath, mimeType)}, basePath: ${basePath}`); 598 575 599 576 // Check if this is HTML content that needs rewriting 600 577 if (isHtmlContent(fileRequestPath, mimeType)) { 578 578 + console.log(`[HTML Rewrite] Processing ${fileRequestPath}, basePath: ${basePath}, mimeType: ${mimeType}, isGzipped: ${isGzipped}`); 601 579 let htmlContent: string; 602 580 if (isGzipped) { 603 581 // Verify content is actually gzipped ··· 612 590 } else { 613 591 htmlContent = content.toString('utf-8'); 614 592 } 593 593 + // Check for <base> tag which can override paths 594 594 + const baseTagMatch = htmlContent.match(/<base\s+[^>]*href=["'][^"']+["'][^>]*>/i); 595 595 + if (baseTagMatch) { 596 596 + console.warn(`[HTML Rewrite] WARNING: <base> tag found: ${baseTagMatch[0]} - this may override path rewrites`); 597 597 + } 598 598 + 599 599 + // Find src/href attributes (quoted and unquoted) to debug 600 600 + const allMatches = htmlContent.match(/(?:src|href)\s*=\s*["']?\/[^"'\s>]+/g); 601 601 + console.log(`[HTML Rewrite] Found ${allMatches ? allMatches.length : 0} local path attrs`); 602 602 + if (allMatches && allMatches.length > 0) { 603 603 + console.log(`[HTML Rewrite] Sample paths: ${allMatches.slice(0, 5).join(', ')}`); 604 604 + } 605 605 + 615 606 const rewritten = rewriteHtmlPaths(htmlContent, basePath, fileRequestPath); 616 607 608 608 + const rewrittenMatches = rewritten.match(/(?:src|href)\s*=\s*["']?\/[^"'\s>]+/g); 609 609 + console.log(`[HTML Rewrite] After rewrite, found ${rewrittenMatches ? rewrittenMatches.length : 0} local paths`); 610 610 + if (rewrittenMatches && rewrittenMatches.length > 0) { 611 611 + console.log(`[HTML Rewrite] Sample rewritten: ${rewrittenMatches.slice(0, 5).join(', ')}`); 612 612 + } 613 613 + 617 614 // Recompress and cache the rewritten HTML 618 615 const { gzipSync } = await import('zlib'); 619 616 const recompressed = gzipSync(Buffer.from(rewritten, 'utf-8')); ··· 625 622 'Content-Type': 'text/html; charset=utf-8', 626 623 'Content-Encoding': 'gzip', 627 624 'Cache-Control': 'public, max-age=300', 625 625 + 'X-Cache-Tier': result.source, 628 626 }; 629 627 applyCustomHeaders(htmlHeaders, fileRequestPath, settings); 630 628 return new Response(recompressed, { headers: htmlHeaders }); ··· 634 632 const headers: Record<string, string> = { 635 633 'Content-Type': mimeType, 636 634 'Cache-Control': 'public, max-age=31536000, immutable', 635 635 + 'X-Cache-Tier': result.source, 637 636 }; 638 637 639 638 if (isGzipped) { ··· 663 662 if (!fileRequestPath.includes('.')) { 664 663 for (const indexFileName of indexFiles) { 665 664 const indexPath = fileRequestPath ? `${fileRequestPath}/${indexFileName}` : indexFileName; 666 666 - const indexCacheKey = getCacheKey(did, rkey, indexPath); 667 667 - const indexFile = getCachedFilePath(did, rkey, indexPath); 668 665 669 666 // Check for rewritten index file in cache 670 667 const rewrittenKey = getCacheKey(did, rkey, indexPath, `rewritten:${basePath}`); ··· 674 671 'Content-Type': 'text/html; charset=utf-8', 675 672 'Content-Encoding': 'gzip', 676 673 'Cache-Control': 'public, max-age=300', 674 674 + 'X-Cache-Tier': 'local', // Rewritten HTML is stored locally 677 675 }; 678 676 applyCustomHeaders(headers, indexPath, settings); 679 677 return new Response(rewrittenContent, { headers }); 680 678 } 681 679 682 682 - let indexContent = fileCache.get(indexCacheKey); 683 683 - let indexMeta = metadataCache.get(indexCacheKey); 680 680 + const indexResult = await getFileWithMetadata(did, rkey, indexPath); 684 681 685 685 - if (!indexContent && await fileExists(indexFile)) { 686 686 - indexContent = await readFile(indexFile); 687 687 - fileCache.set(indexCacheKey, indexContent, indexContent.length); 688 688 - 689 689 - const indexMetaFile = `${indexFile}.meta`; 690 690 - if (await fileExists(indexMetaFile)) { 691 691 - const metaJson = await readFile(indexMetaFile, 'utf-8'); 692 692 - indexMeta = JSON.parse(metaJson); 693 693 - metadataCache.set(indexCacheKey, indexMeta!, JSON.stringify(indexMeta).length); 694 694 - } 695 695 - } 696 696 - 697 697 - if (indexContent) { 682 682 + if (indexResult) { 683 683 + const indexContent = Buffer.from(indexResult.data); 684 684 + const indexMeta = indexResult.metadata.customMetadata as { encoding?: string; mimeType?: string } | undefined; 698 685 const isGzipped = indexMeta?.encoding === 'gzip'; 699 686 700 687 let htmlContent: string; ··· 722 709 'Content-Type': 'text/html; charset=utf-8', 723 710 'Content-Encoding': 'gzip', 724 711 'Cache-Control': 'public, max-age=300', 712 712 + 'X-Cache-Tier': indexResult.source, 725 713 }; 726 714 applyCustomHeaders(headers, indexPath, settings); 727 715 return new Response(recompressed, { headers });

+46 -35

apps/hosting-service/src/lib/firehose.ts

··· 1 1 - import { existsSync, rmSync } from 'fs' 1 1 + import { existsSync } from 'fs' 2 2 import { 3 3 getPdsForDid, 4 4 downloadAndCacheSite, ··· 13 13 import { invalidateSiteCache, markSiteAsBeingCached, unmarkSiteAsBeingCached } from './cache' 14 14 import { clearRedirectRulesCache } from './site-cache' 15 15 16 16 - const CACHE_DIR = './cache/sites' 16 16 + const CACHE_DIR = process.env.CACHE_DIR || './cache/sites' 17 17 18 18 export class FirehoseWorker { 19 19 private firehose: Firehose | null = null 20 20 private idResolver: IdResolver 21 21 private isShuttingDown = false 22 22 private lastEventTime = Date.now() 23 23 + private eventCount = 0 23 24 private cacheCleanupInterval: NodeJS.Timeout | null = null 25 25 + private healthCheckInterval: NodeJS.Timeout | null = null 24 26 25 27 constructor( 26 28 private logger?: (msg: string, data?: Record<string, unknown>) => void ··· 47 49 48 50 this.log('IdResolver cache cleared') 49 51 }, 60 * 60 * 1000) // Every hour 52 52 + 53 53 + // Health check: log if no events received for 30 seconds 54 54 + this.healthCheckInterval = setInterval(() => { 55 55 + if (this.isShuttingDown) return 56 56 + 57 57 + const timeSinceLastEvent = Date.now() - this.lastEventTime 58 58 + if (timeSinceLastEvent > 30000 && this.eventCount === 0) { 59 59 + this.log('Warning: No firehose events received in the last 30 seconds', { 60 60 + timeSinceLastEvent, 61 61 + eventsReceived: this.eventCount 62 62 + }) 63 63 + } else if (timeSinceLastEvent > 60000) { 64 64 + this.log('Firehose status check', { 65 65 + timeSinceLastEvent, 66 66 + eventsReceived: this.eventCount 67 67 + }) 68 68 + } 69 69 + }, 30000) // Every 30 seconds 50 70 } 51 71 52 72 start() { ··· 61 81 if (this.cacheCleanupInterval) { 62 82 clearInterval(this.cacheCleanupInterval) 63 83 this.cacheCleanupInterval = null 84 84 + } 85 85 + 86 86 + if (this.healthCheckInterval) { 87 87 + clearInterval(this.healthCheckInterval) 88 88 + this.healthCheckInterval = null 64 89 } 65 90 66 91 if (this.firehose) { ··· 80 105 filterCollections: ['place.wisp.fs', 'place.wisp.settings'], 81 106 handleEvent: async (evt: any) => { 82 107 this.lastEventTime = Date.now() 108 108 + this.eventCount++ 109 109 + 110 110 + if (this.eventCount === 1) { 111 111 + this.log('First firehose event received - connection established', { 112 112 + eventType: evt.event, 113 113 + collection: evt.collection 114 114 + }) 115 115 + } 83 116 84 117 // Watch for write events 85 118 if (evt.event === 'create' || evt.event === 'update') { ··· 189 222 } 190 223 }) 191 224 192 192 - this.firehose.start() 193 193 - this.log('Firehose started') 225 225 + this.firehose.start().catch((err: unknown) => { 226 226 + this.log('Fatal firehose error', { 227 227 + error: err instanceof Error ? err.message : String(err) 228 228 + }) 229 229 + console.error('Fatal firehose error:', err) 230 230 + }) 231 231 + this.log('Firehose starting') 194 232 } 195 233 196 234 private async handleCreateOrUpdate( ··· 250 288 } 251 289 252 290 // Invalidate in-memory caches before updating 253 253 - invalidateSiteCache(did, site) 291 291 + await invalidateSiteCache(did, site) 254 292 255 293 // Mark site as being cached to prevent serving stale content during update 256 294 markSiteAsBeingCached(did, site) ··· 340 378 }) 341 379 } 342 380 343 343 - // Invalidate in-memory caches 344 344 - invalidateSiteCache(did, site) 345 345 - 346 346 - // Delete disk cache 347 347 - this.deleteCache(did, site) 381 381 + // Invalidate all caches (tiered storage invalidation is handled by invalidateSiteCache) 382 382 + await invalidateSiteCache(did, site) 348 383 349 384 this.log('Successfully processed delete', { did, site }) 350 385 } ··· 353 388 this.log('Processing settings change', { did, rkey }) 354 389 355 390 // Invalidate in-memory caches (includes metadata which stores settings) 356 356 - invalidateSiteCache(did, rkey) 391 391 + await invalidateSiteCache(did, rkey) 357 392 358 393 // Check if site is already cached 359 394 const cacheDir = `${CACHE_DIR}/${did}/${rkey}` ··· 413 448 } 414 449 415 450 this.log('Successfully processed settings change', { did, rkey }) 416 416 - } 417 417 - 418 418 - private deleteCache(did: string, site: string) { 419 419 - const cacheDir = `${CACHE_DIR}/${did}/${site}` 420 420 - 421 421 - if (!existsSync(cacheDir)) { 422 422 - this.log('Cache directory does not exist, nothing to delete', { 423 423 - did, 424 424 - site 425 425 - }) 426 426 - return 427 427 - } 428 428 - 429 429 - try { 430 430 - rmSync(cacheDir, { recursive: true, force: true }) 431 431 - this.log('Cache deleted', { did, site, path: cacheDir }) 432 432 - } catch (err) { 433 433 - this.log('Failed to delete cache', { 434 434 - did, 435 435 - site, 436 436 - path: cacheDir, 437 437 - error: err instanceof Error ? err.message : String(err) 438 438 - }) 439 439 - } 440 451 } 441 452 442 453 getHealth() {

+16

apps/hosting-service/src/lib/html-rewriter.ts

··· 189 189 `\\b${attr}[ \\t]{0,5}=[ \\t]{0,5}'([^']*)'`, 190 190 'gi' 191 191 ) 192 192 + // Unquoted attributes (valid in HTML5 for values without spaces/special chars) 193 193 + // Match: attr=value where value starts immediately (no quotes) and continues until space or > 194 194 + // Use negative lookahead to ensure we don't match quoted attributes 195 195 + const unquotedRegex = new RegExp( 196 196 + `\\b${attr}[ \\t]{0,5}=[ \\t]{0,5}(?!["'])([^\\s>]+)`, 197 197 + 'gi' 198 198 + ) 192 199 193 200 rewritten = rewritten.replace(doubleQuoteRegex, (match, value) => { 194 201 const rewrittenValue = rewritePath( ··· 206 213 documentPath 207 214 ) 208 215 return `${attr}='${rewrittenValue}'` 216 216 + }) 217 217 + 218 218 + rewritten = rewritten.replace(unquotedRegex, (match, value) => { 219 219 + const rewrittenValue = rewritePath( 220 220 + value, 221 221 + normalizedBase, 222 222 + documentPath 223 223 + ) 224 224 + return `${attr}=${rewrittenValue}` 209 225 }) 210 226 } 211 227 }

+1 -1

apps/hosting-service/src/lib/site-cache.ts

··· 42 42 * Returns true if site is successfully cached, false otherwise 43 43 */ 44 44 export async function ensureSiteCached(did: string, rkey: string): Promise<boolean> { 45 45 - if (isCached(did, rkey)) { 45 45 + if (await isCached(did, rkey)) { 46 46 return true; 47 47 } 48 48

+270

apps/hosting-service/src/lib/storage.ts

··· 1 1 + /** 2 2 + * Tiered storage configuration for wisp-hosting-service 3 3 + * 4 4 + * Implements a three-tier caching strategy: 5 5 + * - Hot (Memory): Instant access for frequently used files (index.html, CSS, JS) 6 6 + * - Warm (Disk): Local cache with eviction policy 7 7 + * - Cold (S3/R2): Object storage as source of truth (optional) 8 8 + * 9 9 + * When S3 is not configured, falls back to disk-only mode (warm tier acts as source of truth). 10 10 + * In cache-only mode (non-master nodes), S3 writes are skipped even if configured. 11 11 + */ 12 12 + 13 13 + import { 14 14 + TieredStorage, 15 15 + MemoryStorageTier, 16 16 + DiskStorageTier, 17 17 + S3StorageTier, 18 18 + type StorageTier, 19 19 + type StorageMetadata, 20 20 + } from 'tiered-storage'; 21 21 + 22 22 + const CACHE_DIR = process.env.CACHE_DIR || './cache/sites'; 23 23 + const HOT_CACHE_SIZE = parseInt(process.env.HOT_CACHE_SIZE || '104857600', 10); // 100MB default 24 24 + const HOT_CACHE_COUNT = parseInt(process.env.HOT_CACHE_COUNT || '500', 10); 25 25 + const WARM_CACHE_SIZE = parseInt(process.env.WARM_CACHE_SIZE || '10737418240', 10); // 10GB default 26 26 + const WARM_EVICTION_POLICY = (process.env.WARM_EVICTION_POLICY || 'lru') as 'lru' | 'fifo' | 'size'; 27 27 + 28 28 + // Cache-only mode: skip S3 writes (non-master nodes) 29 29 + // This is the same flag used to skip database writes 30 30 + const CACHE_ONLY_MODE = process.env.CACHE_ONLY_MODE === 'true'; 31 31 + 32 32 + // S3/Cold tier configuration (optional) 33 33 + const S3_BUCKET = process.env.S3_BUCKET || ''; 34 34 + const S3_METADATA_BUCKET = process.env.S3_METADATA_BUCKET; 35 35 + const S3_REGION = process.env.S3_REGION || 'us-east-1'; 36 36 + const S3_ENDPOINT = process.env.S3_ENDPOINT; 37 37 + const S3_FORCE_PATH_STYLE = process.env.S3_FORCE_PATH_STYLE !== 'false'; 38 38 + const AWS_ACCESS_KEY_ID = process.env.AWS_ACCESS_KEY_ID; 39 39 + const AWS_SECRET_ACCESS_KEY = process.env.AWS_SECRET_ACCESS_KEY; 40 40 + const S3_PREFIX = process.env.S3_PREFIX || 'sites/'; 41 41 + 42 42 + // Identity serializers for raw binary data (no JSON transformation) 43 43 + // Files are stored as-is without any encoding/decoding 44 44 + const identitySerialize = async (data: unknown): Promise<Uint8Array> => { 45 45 + if (data instanceof Uint8Array) return data; 46 46 + if (data instanceof ArrayBuffer) return new Uint8Array(data); 47 47 + if (Buffer.isBuffer(data)) return new Uint8Array(data); 48 48 + // For other types, fall back to JSON (shouldn't happen with file storage) 49 49 + return new TextEncoder().encode(JSON.stringify(data)); 50 50 + }; 51 51 + 52 52 + const identityDeserialize = async (data: Uint8Array): Promise<unknown> => { 53 53 + // Return as-is for binary file storage 54 54 + return data; 55 55 + }; 56 56 + 57 57 + /** 58 58 + * Read-only wrapper for S3 tier in cache-only mode. 59 59 + * Allows reads from S3 but skips all writes (for non-master nodes). 60 60 + */ 61 61 + class ReadOnlyS3Tier implements StorageTier { 62 62 + private static hasLoggedWriteSkip = false; 63 63 + 64 64 + constructor(private tier: StorageTier) {} 65 65 + 66 66 + // Read operations - pass through to underlying tier 67 67 + async get(key: string) { 68 68 + return this.tier.get(key); 69 69 + } 70 70 + 71 71 + async getWithMetadata(key: string) { 72 72 + return this.tier.getWithMetadata?.(key) ?? null; 73 73 + } 74 74 + 75 75 + async getStream(key: string) { 76 76 + return this.tier.getStream?.(key) ?? null; 77 77 + } 78 78 + 79 79 + async exists(key: string) { 80 80 + return this.tier.exists(key); 81 81 + } 82 82 + 83 83 + async getMetadata(key: string) { 84 84 + return this.tier.getMetadata(key); 85 85 + } 86 86 + 87 87 + async *listKeys(prefix?: string) { 88 88 + yield* this.tier.listKeys(prefix); 89 89 + } 90 90 + 91 91 + async getStats() { 92 92 + return this.tier.getStats(); 93 93 + } 94 94 + 95 95 + // Write operations - no-op in cache-only mode 96 96 + async set(key: string, _data: Uint8Array, _metadata: StorageMetadata) { 97 97 + this.logWriteSkip('set', key); 98 98 + } 99 99 + 100 100 + async setStream(key: string, _stream: NodeJS.ReadableStream, _metadata: StorageMetadata) { 101 101 + this.logWriteSkip('setStream', key); 102 102 + } 103 103 + 104 104 + async setMetadata(key: string, _metadata: StorageMetadata) { 105 105 + this.logWriteSkip('setMetadata', key); 106 106 + } 107 107 + 108 108 + async delete(key: string) { 109 109 + this.logWriteSkip('delete', key); 110 110 + } 111 111 + 112 112 + async deleteMany(keys: string[]) { 113 113 + this.logWriteSkip('deleteMany', `${keys.length} keys`); 114 114 + } 115 115 + 116 116 + async clear() { 117 117 + this.logWriteSkip('clear', 'all keys'); 118 118 + } 119 119 + 120 120 + private logWriteSkip(operation: string, key: string) { 121 121 + // Only log once to avoid spam 122 122 + if (!ReadOnlyS3Tier.hasLoggedWriteSkip) { 123 123 + console.log(`[Storage] Cache-only mode: skipping S3 writes (operation: ${operation})`); 124 124 + ReadOnlyS3Tier.hasLoggedWriteSkip = true; 125 125 + } 126 126 + } 127 127 + } 128 128 + 129 129 + /** 130 130 + * Initialize tiered storage 131 131 + * Must be called before serving requests 132 132 + */ 133 133 + function initializeStorage(): TieredStorage<Uint8Array> { 134 134 + // Determine cold tier: S3 if configured, otherwise disk acts as cold 135 135 + let coldTier: StorageTier; 136 136 + let warmTier: StorageTier | undefined; 137 137 + 138 138 + const diskTier = new DiskStorageTier({ 139 139 + directory: CACHE_DIR, 140 140 + maxSizeBytes: WARM_CACHE_SIZE, 141 141 + evictionPolicy: WARM_EVICTION_POLICY, 142 142 + encodeColons: false, // Preserve colons for readable DID paths on Unix/macOS 143 143 + }); 144 144 + 145 145 + if (S3_BUCKET) { 146 146 + // Full three-tier setup with S3 as cold storage 147 147 + const s3Tier = new S3StorageTier({ 148 148 + bucket: S3_BUCKET, 149 149 + metadataBucket: S3_METADATA_BUCKET, 150 150 + region: S3_REGION, 151 151 + endpoint: S3_ENDPOINT, 152 152 + forcePathStyle: S3_FORCE_PATH_STYLE, 153 153 + credentials: 154 154 + AWS_ACCESS_KEY_ID && AWS_SECRET_ACCESS_KEY 155 155 + ? { accessKeyId: AWS_ACCESS_KEY_ID, secretAccessKey: AWS_SECRET_ACCESS_KEY } 156 156 + : undefined, 157 157 + prefix: S3_PREFIX, 158 158 + }); 159 159 + 160 160 + // In cache-only mode, wrap S3 tier to make it read-only 161 161 + coldTier = CACHE_ONLY_MODE ? new ReadOnlyS3Tier(s3Tier) : s3Tier; 162 162 + warmTier = diskTier; 163 163 + 164 164 + if (CACHE_ONLY_MODE) { 165 165 + console.log('[Storage] Cache-only mode: S3 as read-only cold tier (no writes), disk as warm tier'); 166 166 + } else { 167 167 + console.log('[Storage] Using S3 as cold tier, disk as warm tier'); 168 168 + } 169 169 + } else { 170 170 + // Disk-only mode: disk tier acts as source of truth (cold) 171 171 + coldTier = diskTier; 172 172 + warmTier = undefined; 173 173 + console.log('[Storage] S3 not configured - using disk-only mode (disk as cold tier)'); 174 174 + } 175 175 + 176 176 + const storage = new TieredStorage<Uint8Array>({ 177 177 + tiers: { 178 178 + // Hot tier: In-memory LRU for instant serving 179 179 + hot: new MemoryStorageTier({ 180 180 + maxSizeBytes: HOT_CACHE_SIZE, 181 181 + maxItems: HOT_CACHE_COUNT, 182 182 + }), 183 183 + 184 184 + // Warm tier: Disk-based cache (only when S3 is configured) 185 185 + warm: warmTier, 186 186 + 187 187 + // Cold tier: S3/R2 as source of truth, or disk in disk-only mode 188 188 + cold: coldTier, 189 189 + }, 190 190 + 191 191 + // Placement rules: determine which tiers each file goes to 192 192 + placementRules: [ 193 193 + // Metadata is critical: frequently accessed for cache validity checks 194 194 + { 195 195 + pattern: '**/.metadata.json', 196 196 + tiers: ['hot', 'warm', 'cold'], 197 197 + }, 198 198 + 199 199 + // index.html is critical: write to all tiers for instant serving 200 200 + { 201 201 + pattern: '**/index.html', 202 202 + tiers: ['hot', 'warm', 'cold'], 203 203 + }, 204 204 + { 205 205 + pattern: 'index.html', 206 206 + tiers: ['hot', 'warm', 'cold'], 207 207 + }, 208 208 + 209 209 + // CSS and JS: eligible for hot tier if accessed frequently 210 210 + { 211 211 + pattern: '**/*.{css,js}', 212 212 + tiers: ['hot', 'warm', 'cold'], 213 213 + }, 214 214 + 215 215 + // Media files: never needed in memory, skip hot tier 216 216 + { 217 217 + pattern: '**/*.{jpg,jpeg,png,gif,webp,svg,ico,mp4,webm,mp3,woff,woff2,ttf,eot}', 218 218 + tiers: ['warm', 'cold'], 219 219 + }, 220 220 + 221 221 + // Default: everything else goes to warm and cold 222 222 + { 223 223 + pattern: '**', 224 224 + tiers: ['warm', 'cold'], 225 225 + }, 226 226 + ], 227 227 + 228 228 + // IMPORTANT: Compression is disabled at the tiered-storage level 229 229 + // Text files (HTML, CSS, JS, JSON) are pre-compressed with gzip at the app level 230 230 + // Binary files (images, video) are stored uncompressed as they're already compressed 231 231 + // The file's compression state is tracked in customMetadata.encoding 232 232 + compression: false, 233 233 + 234 234 + // TTL for cache entries (14 days) 235 235 + defaultTTL: 14 * 24 * 60 * 60 * 1000, 236 236 + 237 237 + // Eager promotion: promote data to upper tiers on read 238 238 + // This ensures frequently accessed files end up in hot tier 239 239 + promotionStrategy: 'eager', 240 240 + 241 241 + // Identity serialization: store raw binary without JSON transformation 242 242 + serialization: { 243 243 + serialize: identitySerialize, 244 244 + deserialize: identityDeserialize, 245 245 + }, 246 246 + }); 247 247 + 248 248 + return storage; 249 249 + } 250 250 + 251 251 + // Export singleton instance 252 252 + export const storage = initializeStorage(); 253 253 + 254 254 + /** 255 255 + * Get storage configuration summary for logging 256 256 + */ 257 257 + export function getStorageConfig() { 258 258 + return { 259 259 + cacheDir: CACHE_DIR, 260 260 + hotCacheSize: `${(HOT_CACHE_SIZE / 1024 / 1024).toFixed(0)}MB`, 261 261 + hotCacheCount: HOT_CACHE_COUNT, 262 262 + warmCacheSize: `${(WARM_CACHE_SIZE / 1024 / 1024 / 1024).toFixed(1)}GB`, 263 263 + warmEvictionPolicy: WARM_EVICTION_POLICY, 264 264 + s3Bucket: S3_BUCKET, 265 265 + s3Region: S3_REGION, 266 266 + s3Endpoint: S3_ENDPOINT || '(default AWS S3)', 267 267 + s3Prefix: S3_PREFIX, 268 268 + metadataBucket: S3_METADATA_BUCKET || '(embedded in data bucket)', 269 269 + }; 270 270 + }

+69 -152

apps/hosting-service/src/lib/utils.ts

··· 4 4 import type { Record as WispSettings } from '@wisp/lexicons/types/place/wisp/settings'; 5 5 import { existsSync, mkdirSync, readFileSync, rmSync } from 'fs'; 6 6 import { writeFile, readFile, rename } from 'fs/promises'; 7 7 + import { Readable } from 'stream'; 7 8 import { safeFetchJson, safeFetchBlob } from '@wisp/safe-fetch'; 8 9 import { CID } from 'multiformats'; 9 10 import { extractBlobCid } from '@wisp/atproto-utils'; 10 11 import { sanitizePath, collectFileCidsFromEntries, countFilesInDirectory } from '@wisp/fs-utils'; 11 12 import { shouldCompressMimeType } from '@wisp/atproto-utils/compression'; 12 13 import { MAX_BLOB_SIZE, MAX_FILE_COUNT, MAX_SITE_SIZE } from '@wisp/constants'; 14 14 + import { storage } from './storage'; 13 15 14 16 // Re-export shared utilities for local usage and tests 15 17 export { extractBlobCid, sanitizePath }; ··· 395 397 const existingMetadata = await getCacheMetadata(did, rkey); 396 398 const existingFileCids = existingMetadata?.fileCids || {}; 397 399 398 398 - // Use a temporary directory with timestamp to avoid collisions 399 399 - const tempSuffix = `.tmp-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`; 400 400 - const tempDir = `${CACHE_DIR}/${did}/${rkey}${tempSuffix}`; 401 401 - const finalDir = `${CACHE_DIR}/${did}/${rkey}`; 402 402 - 403 403 - try { 404 404 - // Collect file CIDs from the new record (using expanded root) 405 405 - const newFileCids: Record<string, string> = {}; 406 406 - collectFileCidsFromEntries(expandedRoot.entries, '', newFileCids); 400 400 + // Collect file CIDs from the new record (using expanded root) 401 401 + const newFileCids: Record<string, string> = {}; 402 402 + collectFileCidsFromEntries(expandedRoot.entries, '', newFileCids); 407 403 408 408 - // Fetch site settings (optional) 409 409 - const settings = await fetchSiteSettings(did, rkey); 404 404 + // Fetch site settings (optional) 405 405 + const settings = await fetchSiteSettings(did, rkey); 410 406 411 411 - // Download/copy files to temporary directory (with incremental logic, using expanded root) 412 412 - await cacheFiles(did, rkey, expandedRoot.entries, pdsEndpoint, '', tempSuffix, existingFileCids, finalDir); 413 413 - await saveCacheMetadata(did, rkey, recordCid, tempSuffix, newFileCids, settings); 407 407 + // Download files directly to tiered storage (with incremental logic) 408 408 + await cacheFiles(did, rkey, expandedRoot.entries, pdsEndpoint, '', existingFileCids); 409 409 + await saveCacheMetadata(did, rkey, recordCid, newFileCids, settings); 414 410 415 415 - // Atomically replace old cache with new cache 416 416 - // On POSIX systems (Linux/macOS), rename is atomic 417 417 - if (existsSync(finalDir)) { 418 418 - // Rename old directory to backup 419 419 - const backupDir = `${finalDir}.old-${Date.now()}`; 420 420 - await rename(finalDir, backupDir); 421 421 - 422 422 - try { 423 423 - // Rename new directory to final location 424 424 - await rename(tempDir, finalDir); 425 425 - 426 426 - // Clean up old backup 427 427 - rmSync(backupDir, { recursive: true, force: true }); 428 428 - } catch (err) { 429 429 - // If rename failed, restore backup 430 430 - if (existsSync(backupDir) && !existsSync(finalDir)) { 431 431 - await rename(backupDir, finalDir); 432 432 - } 433 433 - throw err; 434 434 - } 435 435 - } else { 436 436 - // No existing cache, just rename temp to final 437 437 - await rename(tempDir, finalDir); 438 438 - } 439 439 - 440 440 - console.log('Successfully cached site atomically', did, rkey); 441 441 - } catch (err) { 442 442 - // Clean up temp directory on failure 443 443 - if (existsSync(tempDir)) { 444 444 - rmSync(tempDir, { recursive: true, force: true }); 445 445 - } 446 446 - throw err; 447 447 - } 411 411 + console.log('Successfully cached site', did, rkey); 448 412 } 449 413 450 414 ··· 454 418 entries: Entry[], 455 419 pdsEndpoint: string, 456 420 pathPrefix: string, 457 457 - dirSuffix: string = '', 458 458 - existingFileCids: Record<string, string> = {}, 459 459 - existingCacheDir?: string 421 421 + existingFileCids: Record<string, string> = {} 460 422 ): Promise<void> { 461 461 - // Collect file tasks, separating unchanged files from new/changed files 423 423 + // Collect file download tasks (skip unchanged files) 462 424 const downloadTasks: Array<() => Promise<void>> = []; 463 463 - const copyTasks: Array<() => Promise<void>> = []; 464 425 465 426 function collectFileTasks( 466 427 entries: Entry[], ··· 477 438 const cid = extractBlobCid(fileNode.blob); 478 439 479 440 // Check if file is unchanged (same CID as existing cache) 480 480 - if (cid && existingFileCids[currentPath] === cid && existingCacheDir) { 481 481 - // File unchanged - copy from existing cache instead of downloading 482 482 - copyTasks.push(() => copyExistingFile( 483 483 - did, 484 484 - site, 485 485 - currentPath, 486 486 - dirSuffix, 487 487 - existingCacheDir 488 488 - )); 441 441 + if (cid && existingFileCids[currentPath] === cid) { 442 442 + // File unchanged - skip download (already in tiered storage) 443 443 + console.log(`Skipping unchanged file: ${currentPath}`); 489 444 } else { 490 445 // File new or changed - download it 491 446 downloadTasks.push(() => cacheFileBlob( ··· 496 451 pdsEndpoint, 497 452 fileNode.encoding, 498 453 fileNode.mimeType, 499 499 - fileNode.base64, 500 500 - dirSuffix 454 454 + fileNode.base64 501 455 )); 502 456 } 503 457 } ··· 506 460 507 461 collectFileTasks(entries, pathPrefix); 508 462 509 509 - console.log(`[Incremental Update] Files to copy: ${copyTasks.length}, Files to download: ${downloadTasks.length}`); 463 463 + console.log(`[Incremental Update] Files to download: ${downloadTasks.length}`); 510 464 511 511 - // Copy unchanged files in parallel (fast local operations) - increased limit for better performance 512 512 - const copyLimit = 50; 513 513 - for (let i = 0; i < copyTasks.length; i += copyLimit) { 514 514 - const batch = copyTasks.slice(i, i + copyLimit); 515 515 - await Promise.all(batch.map(task => task())); 516 516 - if (copyTasks.length > copyLimit) { 517 517 - console.log(`[Cache Progress] Copied ${Math.min(i + copyLimit, copyTasks.length)}/${copyTasks.length} unchanged files`); 518 518 - } 519 519 - } 520 520 - 521 521 - // Download new/changed files concurrently - increased from 3 to 20 for much better performance 465 465 + // Download new/changed files concurrently 522 466 const downloadLimit = 20; 523 467 let successCount = 0; 524 468 let failureCount = 0; ··· 547 491 } 548 492 } 549 493 550 550 - /** 551 551 - * Copy an unchanged file from existing cache to new cache location 552 552 - */ 553 553 - async function copyExistingFile( 554 554 - did: string, 555 555 - site: string, 556 556 - filePath: string, 557 557 - dirSuffix: string, 558 558 - existingCacheDir: string 559 559 - ): Promise<void> { 560 560 - const { copyFile } = await import('fs/promises'); 561 561 - 562 562 - const sourceFile = `${existingCacheDir}/${filePath}`; 563 563 - const destFile = `${CACHE_DIR}/${did}/${site}${dirSuffix}/${filePath}`; 564 564 - const destDir = destFile.substring(0, destFile.lastIndexOf('/')); 565 565 - 566 566 - // Create destination directory if needed 567 567 - if (destDir && !existsSync(destDir)) { 568 568 - mkdirSync(destDir, { recursive: true }); 569 569 - } 570 570 - 571 571 - try { 572 572 - // Copy the file 573 573 - await copyFile(sourceFile, destFile); 574 574 - 575 575 - // Copy metadata file if it exists 576 576 - const sourceMetaFile = `${sourceFile}.meta`; 577 577 - const destMetaFile = `${destFile}.meta`; 578 578 - if (existsSync(sourceMetaFile)) { 579 579 - await copyFile(sourceMetaFile, destMetaFile); 580 580 - } 581 581 - } catch (err) { 582 582 - console.error(`Failed to copy cached file ${filePath}, will attempt download:`, err); 583 583 - throw err; 584 584 - } 585 585 - } 586 586 - 587 494 async function cacheFileBlob( 588 495 did: string, 589 496 site: string, ··· 592 499 pdsEndpoint: string, 593 500 encoding?: 'gzip', 594 501 mimeType?: string, 595 595 - base64?: boolean, 596 596 - dirSuffix: string = '' 502 502 + base64?: boolean 597 503 ): Promise<void> { 598 504 const cid = extractBlobCid(blobRef); 599 505 if (!cid) { ··· 616 522 content = Buffer.from(base64String, 'base64'); 617 523 } 618 524 619 619 - const cacheFile = `${CACHE_DIR}/${did}/${site}${dirSuffix}/${filePath}`; 620 620 - const fileDir = cacheFile.substring(0, cacheFile.lastIndexOf('/')); 621 621 - 622 622 - if (fileDir && !existsSync(fileDir)) { 623 623 - mkdirSync(fileDir, { recursive: true }); 624 624 - } 625 625 - 626 525 // Use the shared function to determine if this should remain compressed 627 526 const shouldStayCompressed = shouldCompressMimeType(mimeType); 628 527 ··· 640 539 } 641 540 } 642 541 643 643 - await writeFile(cacheFile, content); 542 542 + // Write to tiered storage with metadata 543 543 + const stream = Readable.from([content]); 544 544 + const key = `${did}/${site}/${filePath}`; 545 545 + 546 546 + // Build metadata object, only including defined values 547 547 + const customMetadata: Record<string, string> = {}; 548 548 + if (encoding) customMetadata.encoding = encoding; 549 549 + if (mimeType) customMetadata.mimeType = mimeType; 550 550 + 551 551 + await storage.setStream(key, stream, { 552 552 + size: content.length, 553 553 + skipTiers: ['hot'], // Don't put in memory on ingest, only on access 554 554 + metadata: customMetadata, 555 555 + }); 644 556 645 645 - // Store metadata only if file is still compressed 557 557 + // Log completion 646 558 if (encoding === 'gzip' && mimeType) { 647 647 - const metaFile = `${cacheFile}.meta`; 648 648 - await writeFile(metaFile, JSON.stringify({ encoding, mimeType })); 649 559 console.log('Cached file', filePath, content.length, 'bytes (gzipped,', mimeType + ')'); 650 560 } else { 651 561 console.log('Cached file', filePath, content.length, 'bytes'); ··· 658 568 return `${CACHE_DIR}/${did}/${site}/${sanitizedPath}`; 659 569 } 660 570 661 661 - export function isCached(did: string, site: string): boolean { 662 662 - return existsSync(`${CACHE_DIR}/${did}/${site}`); 571 571 + /** 572 572 + * Check if a site exists in any tier of the cache (without checking metadata) 573 573 + * This is a quick existence check - for actual retrieval, use storage.get() 574 574 + */ 575 575 + export async function isCached(did: string, site: string): Promise<boolean> { 576 576 + // Check if any file exists for this site by checking for the index.html 577 577 + // If index.html exists, the site is cached 578 578 + const indexKey = `${did}/${site}/index.html`; 579 579 + return await storage.exists(indexKey); 663 580 } 664 581 665 665 - async function saveCacheMetadata(did: string, rkey: string, recordCid: string, dirSuffix: string = '', fileCids?: Record<string, string>, settings?: WispSettings | null): Promise<void> { 582 582 + async function saveCacheMetadata(did: string, rkey: string, recordCid: string, fileCids?: Record<string, string>, settings?: WispSettings | null): Promise<void> { 666 583 const metadata: CacheMetadata = { 667 584 recordCid, 668 585 cachedAt: Date.now(), ··· 672 589 settings: settings || undefined 673 590 }; 674 591 675 675 - const metadataPath = `${CACHE_DIR}/${did}/${rkey}${dirSuffix}/.metadata.json`; 676 676 - const metadataDir = metadataPath.substring(0, metadataPath.lastIndexOf('/')); 677 677 - 678 678 - if (!existsSync(metadataDir)) { 679 679 - mkdirSync(metadataDir, { recursive: true }); 680 680 - } 681 681 - 682 682 - await writeFile(metadataPath, JSON.stringify(metadata, null, 2)); 592 592 + // Store through tiered storage for persistence to S3/cold tier 593 593 + const metadataKey = `${did}/${rkey}/.metadata.json`; 594 594 + const metadataBytes = new TextEncoder().encode(JSON.stringify(metadata, null, 2)); 595 595 + await storage.set(metadataKey, metadataBytes); 683 596 } 684 597 685 598 async function getCacheMetadata(did: string, rkey: string): Promise<CacheMetadata | null> { 686 599 try { 687 687 - const metadataPath = `${CACHE_DIR}/${did}/${rkey}/.metadata.json`; 688 688 - if (!existsSync(metadataPath)) return null; 600 600 + // Retrieve metadata from tiered storage 601 601 + const metadataKey = `${did}/${rkey}/.metadata.json`; 602 602 + const data = await storage.get(metadataKey); 689 603 690 690 - const content = await readFile(metadataPath, 'utf-8'); 691 691 - return JSON.parse(content) as CacheMetadata; 604 604 + if (!data) return null; 605 605 + 606 606 + // Deserialize from Uint8Array to JSON (storage uses identity serialization) 607 607 + const jsonString = new TextDecoder().decode(data as Uint8Array); 608 608 + return JSON.parse(jsonString) as CacheMetadata; 692 609 } catch (err) { 693 610 console.error('Failed to read cache metadata', err); 694 611 return null; ··· 722 639 } 723 640 724 641 export async function updateCacheMetadataSettings(did: string, rkey: string, settings: WispSettings | null): Promise<void> { 725 725 - const metadataPath = `${CACHE_DIR}/${did}/${rkey}/.metadata.json`; 726 726 - 727 727 - if (!existsSync(metadataPath)) { 728 728 - console.warn('Metadata file does not exist, cannot update settings', { did, rkey }); 729 729 - return; 730 730 - } 731 731 - 732 642 try { 733 733 - // Read existing metadata 734 734 - const content = await readFile(metadataPath, 'utf-8'); 735 735 - const metadata = JSON.parse(content) as CacheMetadata; 643 643 + // Read existing metadata from tiered storage 644 644 + const metadata = await getCacheMetadata(did, rkey); 645 645 + 646 646 + if (!metadata) { 647 647 + console.warn('Metadata does not exist, cannot update settings', { did, rkey }); 648 648 + return; 649 649 + } 736 650 737 651 // Update settings field 738 652 // Store null explicitly to cache "no settings" state and avoid repeated fetches 739 653 metadata.settings = settings ?? null; 740 654 741 741 - // Write back to disk 742 742 - await writeFile(metadataPath, JSON.stringify(metadata, null, 2), 'utf-8'); 655 655 + // Write back through tiered storage 656 656 + // Convert to Uint8Array since storage is typed for binary data 657 657 + const metadataKey = `${did}/${rkey}/.metadata.json`; 658 658 + const metadataBytes = new TextEncoder().encode(JSON.stringify(metadata, null, 2)); 659 659 + await storage.set(metadataKey, metadataBytes); 743 660 console.log('Updated metadata settings', { did, rkey, hasSettings: !!settings }); 744 661 } catch (err) { 745 662 console.error('Failed to update metadata settings', err);

+4 -1

apps/hosting-service/src/server.ts

··· 80 80 return c.text('Invalid identifier', 400); 81 81 } 82 82 83 83 + console.log(`[Server] sites.wisp.place request: identifier=${identifier}, site=${site}, filePath=${filePath}`); 84 84 + 83 85 // Check if site is currently being cached - return updating response early 84 86 if (isSiteBeingCached(did, site)) { 85 87 return siteUpdatingResponse(); ··· 93 95 94 96 // Serve with HTML path rewriting to handle absolute paths 95 97 const basePath = `/${identifier}/${site}/`; 98 98 + console.log(`[Server] Serving with basePath: ${basePath}`); 96 99 const headers = extractHeaders(c.req.raw.headers); 97 100 return serveFromCacheWithRewrite(did, site, filePath, basePath, c.req.url, headers); 98 101 } ··· 227 230 228 231 app.get('/__internal__/observability/cache', async (c) => { 229 232 const { getCacheStats } = await import('./lib/cache'); 230 230 - const stats = getCacheStats(); 233 233 + const stats = await getCacheStats(); 231 234 return c.json({ cache: stats }); 232 235 }); 233 236

+4 -4

apps/main-app/public/acceptable-use/acceptable-use.tsx

··· 6 6 7 7 function AcceptableUsePage() { 8 8 return ( 9 9 - <div className="min-h-screen bg-background"> 9 9 + <div className="w-full min-h-screen bg-background flex flex-col"> 10 10 {/* Header */} 11 11 - <header className="border-b border-border/40 bg-background/80 backdrop-blur-sm sticky top-0 z-50"> 12 12 - <div className="container mx-auto px-4 py-4 flex items-center justify-between"> 11 11 + <header className="w-full border-b border-border/40 bg-background/80 backdrop-blur-sm sticky top-0 z-50"> 12 12 + <div className="max-w-6xl w-full mx-auto px-4 h-16 flex items-center justify-between"> 13 13 <div className="flex items-center gap-2"> 14 14 <img src="/transparent-full-size-ico.png" alt="wisp.place" className="w-8 h-8" /> 15 15 <span className="text-xl font-semibold text-foreground"> ··· 326 326 </div> 327 327 328 328 {/* Footer */} 329 329 - <footer className="border-t border-border/40 bg-muted/20 mt-12"> 329 329 + <footer className="border-t border-border/40 bg-muted/20 mt-auto"> 330 330 <div className="container mx-auto px-4 py-8"> 331 331 <div className="text-center text-sm text-muted-foreground"> 332 332 <p>

+1 -1

apps/main-app/public/components/ui/checkbox.tsx

··· 12 12 <CheckboxPrimitive.Root 13 13 data-slot="checkbox" 14 14 className={cn( 15 15 - "peer border-input dark:bg-input/30 data-[state=checked]:bg-primary data-[state=checked]:text-primary-foreground dark:data-[state=checked]:bg-primary data-[state=checked]:border-primary focus-visible:border-ring focus-visible:ring-ring/50 aria-invalid:ring-destructive/20 dark:aria-invalid:ring-destructive/40 aria-invalid:border-destructive size-4 shrink-0 rounded-[4px] border shadow-xs transition-shadow outline-none focus-visible:ring-[3px] disabled:cursor-not-allowed disabled:opacity-50", 15 15 + "peer border-border bg-background dark:bg-input/30 data-[state=checked]:bg-primary data-[state=checked]:text-primary-foreground dark:data-[state=checked]:bg-primary data-[state=checked]:border-primary focus-visible:border-ring focus-visible:ring-ring/50 aria-invalid:ring-destructive/20 dark:aria-invalid:ring-destructive/40 aria-invalid:border-destructive size-4 shrink-0 rounded-[4px] border shadow-xs transition-shadow outline-none focus-visible:ring-[3px] disabled:cursor-not-allowed disabled:opacity-50", 16 16 className 17 17 )} 18 18 {...props}

+6 -6

apps/main-app/public/editor/editor.tsx

··· 302 302 return ( 303 303 <div className="w-full min-h-screen bg-background"> 304 304 {/* Header Skeleton */} 305 305 - <header className="border-b border-border/40 bg-background/80 backdrop-blur-sm sticky top-0 z-50"> 306 306 - <div className="container mx-auto px-4 py-4 flex items-center justify-between"> 305 305 + <header className="w-full border-b border-border/40 bg-background/80 backdrop-blur-sm sticky top-0 z-50"> 306 306 + <div className="max-w-6xl w-full mx-auto px-4 h-16 flex items-center justify-between"> 307 307 <div className="flex items-center gap-2"> 308 308 <img src="/transparent-full-size-ico.png" alt="wisp.place" className="w-8 h-8" /> 309 309 <span className="text-xl font-semibold text-foreground"> ··· 366 366 } 367 367 368 368 return ( 369 369 - <div className="w-full min-h-screen bg-background"> 369 369 + <div className="w-full min-h-screen bg-background flex flex-col"> 370 370 {/* Header */} 371 371 - <header className="border-b border-border/40 bg-background/80 backdrop-blur-sm sticky top-0 z-50"> 372 372 - <div className="container mx-auto px-4 py-4 flex items-center justify-between"> 371 371 + <header className="w-full border-b border-border/40 bg-background/80 backdrop-blur-sm sticky top-0 z-50"> 372 372 + <div className="max-w-6xl w-full mx-auto px-4 h-16 flex items-center justify-between"> 373 373 <div className="flex items-center gap-2"> 374 374 <img src="/transparent-full-size-ico.png" alt="wisp.place" className="w-8 h-8" /> 375 375 <span className="text-xl font-semibold text-foreground"> ··· 454 454 </div> 455 455 456 456 {/* Footer */} 457 457 - <footer className="border-t border-border/40 bg-muted/20 mt-12"> 457 457 + <footer className="border-t border-border/40 bg-muted/20 mt-auto"> 458 458 <div className="container mx-auto px-4 py-8"> 459 459 <div className="text-center text-sm text-muted-foreground"> 460 460 <p>

+74 -66

apps/main-app/public/index.tsx

··· 88 88 89 89 const handleKeyDown = (e: React.KeyboardEvent<HTMLInputElement>) => { 90 90 const navigationKeys = ['ArrowDown', 'ArrowUp', 'PageDown', 'PageUp', 'Enter', 'Escape'] 91 91 - 91 91 + 92 92 // Mark that we should preserve the index for navigation keys 93 93 if (navigationKeys.includes(e.key)) { 94 94 preserveIndexRef.current = true ··· 142 142 setIndex(-1) 143 143 setIsOpen(false) 144 144 onSelect?.(handle) 145 145 - 145 145 + 146 146 // Auto-submit the form if enabled 147 147 if (autoSubmit && inputRef.current) { 148 148 const form = inputRef.current.closest('form') ··· 236 236 height: 'calc(1.5rem + 12px)', 237 237 borderRadius: '4px', 238 238 cursor: 'pointer', 239 239 - backgroundColor: i === index ? 'hsl(var(--accent) / 0.5)' : 'transparent', 239 239 + backgroundColor: i === index ? 'color-mix(in oklch, var(--accent) 50%, transparent)' : 'transparent', 240 240 transition: 'background-color 0.1s' 241 241 }} 242 242 onMouseEnter={() => setIndex(i)} ··· 246 246 width: '1.5rem', 247 247 height: '1.5rem', 248 248 borderRadius: '50%', 249 249 - backgroundColor: 'hsl(var(--muted))', 249 249 + backgroundColor: 'var(--muted)', 250 250 overflow: 'hidden', 251 251 flexShrink: 0 252 252 }} ··· 255 255 <img 256 256 src={actor.avatar} 257 257 alt="" 258 258 + loading="lazy" 258 259 style={{ 259 260 display: 'block', 260 261 width: '100%', ··· 359 360 360 361 return ( 361 362 <> 362 362 - <div className="min-h-screen"> 363 363 + <div className="w-full min-h-screen flex flex-col"> 363 364 {/* Header */} 364 364 - <header className="border-b border-border/40 bg-background/80 backdrop-blur-sm sticky top-0 z-50"> 365 365 - <div className="container mx-auto px-4 py-4 flex items-center justify-between"> 365 365 + <header className="w-full border-b border-border/40 bg-background/80 backdrop-blur-sm sticky top-0 z-50"> 366 366 + <div className="max-w-6xl w-full mx-auto px-4 h-16 flex items-center justify-between"> 366 367 <div className="flex items-center gap-2"> 367 368 <img src="/transparent-full-size-ico.png" alt="wisp.place" className="w-8 h-8" /> 368 368 - <span className="text-xl font-semibold text-foreground"> 369 369 + <span className="text-lg font-semibold text-foreground"> 369 370 wisp.place 370 371 </span> 371 372 </div> 372 372 - <div className="flex items-center gap-3"> 373 373 + <div className="flex items-center gap-4"> 374 374 + <a 375 375 + href="https://docs.wisp.place" 376 376 + target="_blank" 377 377 + rel="noopener noreferrer" 378 378 + className="text-sm text-muted-foreground hover:text-foreground transition-colors" 379 379 + > 380 380 + Read the Docs 381 381 + </a> 373 382 <Button 374 374 - variant="ghost" 383 383 + variant="outline" 375 384 size="sm" 385 385 + className="btn-hover-lift" 376 386 onClick={() => setShowForm(true)} 377 387 > 378 388 Sign In 379 389 </Button> 380 380 - <Button 381 381 - size="sm" 382 382 - className="bg-accent text-accent-foreground hover:bg-accent/90" 383 383 - asChild 384 384 - > 385 385 - <a href="https://docs.wisp.place" target="_blank" rel="noopener noreferrer"> 386 386 - Read the Docs 387 387 - </a> 388 388 - </Button> 389 390 </div> 390 391 </div> 391 392 </header> 392 393 393 394 {/* Hero Section */} 394 394 - <section className="container mx-auto px-4 py-20 md:py-32"> 395 395 + <section className="container mx-auto px-4 py-24 md:py-36"> 395 396 <div className="max-w-4xl mx-auto text-center"> 396 396 - <div className="inline-flex items-center gap-2 px-4 py-2 rounded-full bg-accent/10 border border-accent/20 mb-8"> 397 397 - <span className="w-2 h-2 bg-accent rounded-full animate-pulse"></span> 398 398 - <span className="text-sm text-foreground"> 399 399 - Built on AT Protocol 400 400 - </span> 401 401 - </div> 402 402 - 403 403 - <h1 className="text-5xl md:text-7xl font-bold text-balance mb-6 leading-tight"> 404 404 - Your Website.Your Control. Lightning Fast. 397 397 + {/* Main Headline */} 398 398 + <h1 className="animate-fade-in-up animate-delay-100 text-5xl md:text-7xl font-bold mb-2 leading-tight tracking-tight"> 399 399 + Deploy Anywhere. 400 400 + </h1> 401 401 + <h1 className="animate-fade-in-up animate-delay-200 text-5xl md:text-7xl font-bold mb-8 leading-tight tracking-tight text-gradient-animate"> 402 402 + For Free. Forever. 405 403 </h1> 406 404 407 407 - <p className="text-xl md:text-2xl text-muted-foreground text-balance mb-10 leading-relaxed max-w-3xl mx-auto"> 408 408 - Host static sites in your AT Protocol account. You 409 409 - keep ownership and control. We just serve them fast 410 410 - through our CDN. 405 405 + {/* Subheadline */} 406 406 + <p className="animate-fade-in-up animate-delay-300 text-lg md:text-xl text-muted-foreground mb-12 leading-relaxed max-w-2xl mx-auto"> 407 407 + The easiest way to deploy and orchestrate static sites. 408 408 + Push updates instantly. Host on our infrastructure or yours. 409 409 + All powered by AT Protocol. 411 410 </p> 412 411 413 413 - <div className="max-w-md mx-auto relative"> 412 412 + {/* CTA Buttons */} 413 413 + <div className="animate-fade-in-up animate-delay-400 max-w-lg mx-auto relative"> 414 414 <div 415 415 - className={`transition-all duration-500 ease-in-out ${ 416 416 - showForm 417 417 - ? 'opacity-0 -translate-y-5 pointer-events-none' 418 418 - : 'opacity-100 translate-y-0' 419 419 - }`} 415 415 + className={`transition-all duration-500 ease-in-out ${showForm 416 416 + ? 'opacity-0 -translate-y-5 pointer-events-none absolute inset-0' 417 417 + : 'opacity-100 translate-y-0' 418 418 + }`} 420 419 > 421 421 - <Button 422 422 - size="lg" 423 423 - className="bg-primary text-primary-foreground hover:bg-primary/90 text-lg px-8 py-6 w-full" 424 424 - onClick={() => setShowForm(true)} 425 425 - > 426 426 - Log in with AT Proto 427 427 - <ArrowRight className="ml-2 w-5 h-5" /> 428 428 - </Button> 420 420 + <div className="flex flex-col sm:flex-row gap-3 justify-center"> 421 421 + <Button 422 422 + size="lg" 423 423 + className="bg-foreground text-background hover:bg-foreground/90 text-base px-6 py-5 btn-hover-lift" 424 424 + onClick={() => setShowForm(true)} 425 425 + > 426 426 + <span className="mr-2 font-bold">@</span> 427 427 + Deploy with AT 428 428 + </Button> 429 429 + <Button 430 430 + variant="outline" 431 431 + size="lg" 432 432 + className="text-base px-6 py-5 btn-hover-lift" 433 433 + asChild 434 434 + > 435 435 + <a href="https://docs.wisp.place/cli/" target="_blank" rel="noopener noreferrer"> 436 436 + <span className="font-mono mr-2 text-muted-foreground">&gt;_</span> 437 437 + Install wisp-cli 438 438 + </a> 439 439 + </Button> 440 440 + </div> 429 441 </div> 430 442 431 443 <div 432 432 - className={`transition-all duration-500 ease-in-out absolute inset-0 ${ 433 433 - showForm 434 434 - ? 'opacity-100 translate-y-0' 435 435 - : 'opacity-0 translate-y-5 pointer-events-none' 436 436 - }`} 444 444 + className={`transition-all duration-500 ease-in-out ${showForm 445 445 + ? 'opacity-100 translate-y-0' 446 446 + : 'opacity-0 translate-y-5 pointer-events-none absolute inset-0' 447 447 + }`} 437 448 > 438 449 <form 439 450 onSubmit={async (e) => { ··· 494 505 </ActorTypeahead> 495 506 <button 496 507 type="submit" 497 497 - className="w-full bg-accent hover:bg-accent/90 text-accent-foreground font-semibold py-4 px-6 text-lg rounded-lg inline-flex items-center justify-center transition-colors" 508 508 + className="w-full bg-foreground text-background hover:bg-foreground/90 font-semibold py-4 px-6 text-lg rounded-lg inline-flex items-center justify-center transition-colors btn-hover-lift" 498 509 > 499 510 Continue 500 511 <ArrowRight className="ml-2 w-5 h-5" /> ··· 518 529 </div> 519 530 <div> 520 531 <h3 className="text-xl font-semibold mb-2"> 521 521 - Upload your static site 532 532 + Drop in your files 522 533 </h3> 523 534 <p className="text-muted-foreground"> 524 524 - Your HTML, CSS, and JavaScript files are 525 525 - stored in your AT Protocol account as 526 526 - gzipped blobs and a manifest record. 535 535 + Upload your site through our dashboard or push with the CLI. 536 536 + Everything gets stored directly in your AT Protocol account. 527 537 </p> 528 538 </div> 529 539 </div> ··· 533 543 </div> 534 544 <div> 535 545 <h3 className="text-xl font-semibold mb-2"> 536 536 - We serve it globally 546 546 + We handle the rest 537 547 </h3> 538 548 <p className="text-muted-foreground"> 539 539 - Wisp.place reads your site from your 540 540 - account and delivers it through our CDN 541 541 - for fast loading anywhere. 549 549 + Your site goes live instantly on our global CDN. 550 550 + Custom domains, HTTPS, caching—all automatic. 542 551 </p> 543 552 </div> 544 553 </div> ··· 548 557 </div> 549 558 <div> 550 559 <h3 className="text-xl font-semibold mb-2"> 551 551 - You stay in control 560 560 + Push updates instantly 552 561 </h3> 553 562 <p className="text-muted-foreground"> 554 554 - Update or remove your site anytime 555 555 - through your AT Protocol account. No 556 556 - lock-in, no middleman ownership. 563 563 + Ship changes in seconds. Update through the dashboard, 564 564 + run wisp-cli deploy, or wire up your CI/CD pipeline. 557 565 </p> 558 566 </div> 559 567 </div> ··· 686 694 </section> 687 695 688 696 {/* Footer */} 689 689 - <footer className="border-t border-border/40 bg-muted/20"> 697 697 + <footer className="border-t border-border/40 bg-muted/20 mt-auto"> 690 698 <div className="container mx-auto px-4 py-8"> 691 699 <div className="text-center text-sm text-muted-foreground"> 692 700 <p>

+16 -19

apps/main-app/public/onboarding/onboarding.tsx

··· 161 161 return ( 162 162 <div className="w-full min-h-screen bg-background"> 163 163 {/* Header */} 164 164 - <header className="border-b border-border/40 bg-background/80 backdrop-blur-sm sticky top-0 z-50"> 165 165 - <div className="container mx-auto px-4 py-4 flex items-center justify-between"> 164 164 + <header className="w-full border-b border-border/40 bg-background/80 backdrop-blur-sm sticky top-0 z-50"> 165 165 + <div className="max-w-6xl w-full mx-auto px-4 h-16 flex items-center justify-between"> 166 166 <div className="flex items-center gap-2"> 167 167 <div className="w-8 h-8 bg-primary rounded-lg flex items-center justify-center"> 168 168 <Globe className="w-5 h-5 text-primary-foreground" /> ··· 179 179 <div className="mb-8"> 180 180 <div className="flex items-center justify-center gap-2 mb-4"> 181 181 <div 182 182 - className={`w-8 h-8 rounded-full flex items-center justify-center ${ 183 183 - step === 'domain' 184 184 - ? 'bg-primary text-primary-foreground' 185 185 - : 'bg-green-500 text-white' 186 186 - }`} 182 182 + className={`w-8 h-8 rounded-full flex items-center justify-center ${step === 'domain' 183 183 + ? 'bg-primary text-primary-foreground' 184 184 + : 'bg-green-500 text-white' 185 185 + }`} 187 186 > 188 187 {step === 'domain' ? ( 189 188 '1' ··· 193 192 </div> 194 193 <div className="w-16 h-0.5 bg-border"></div> 195 194 <div 196 196 - className={`w-8 h-8 rounded-full flex items-center justify-center ${ 197 197 - step === 'upload' 198 198 - ? 'bg-primary text-primary-foreground' 199 199 - : step === 'domain' 200 200 - ? 'bg-muted text-muted-foreground' 201 201 - : 'bg-green-500 text-white' 202 202 - }`} 195 195 + className={`w-8 h-8 rounded-full flex items-center justify-center ${step === 'upload' 196 196 + ? 'bg-primary text-primary-foreground' 197 197 + : step === 'domain' 198 198 + ? 'bg-muted text-muted-foreground' 199 199 + : 'bg-green-500 text-white' 200 200 + }`} 203 201 > 204 202 {step === 'complete' ? ( 205 203 <CheckCircle2 className="w-5 h-5" /> ··· 258 256 {!isCheckingAvailability && 259 257 isAvailable !== null && ( 260 258 <div 261 261 - className={`absolute right-3 top-1/2 -translate-y-1/2 ${ 262 262 - isAvailable 263 263 - ? 'text-green-500' 264 264 - : 'text-red-500' 265 265 - }`} 259 259 + className={`absolute right-3 top-1/2 -translate-y-1/2 ${isAvailable 260 260 + ? 'text-green-500' 261 261 + : 'text-red-500' 262 262 + }`} 266 263 > 267 264 {isAvailable ? '✓' : '✗'} 268 265 </div>

+212 -39

apps/main-app/public/styles/global.css

··· 6 6 :root { 7 7 color-scheme: light; 8 8 9 9 - /* Warm beige background inspired by Sunset design #E9DDD8 */ 10 10 - --background: oklch(0.90 0.012 35); 11 11 - /* Very dark brown text for strong contrast #2A2420 */ 12 12 - --foreground: oklch(0.18 0.01 30); 9 9 + /* Warm beige background inspired by Sunset design */ 10 10 + --background: oklch(0.92 0.012 35); 11 11 + /* Very dark brown text for strong contrast */ 12 12 + --foreground: oklch(0.15 0.015 30); 13 13 14 14 - /* Slightly lighter card background */ 15 15 - --card: oklch(0.93 0.01 35); 16 16 - --card-foreground: oklch(0.18 0.01 30); 14 14 + /* Slightly lighter card background for elevation */ 15 15 + --card: oklch(0.95 0.008 35); 16 16 + --card-foreground: oklch(0.15 0.015 30); 17 17 18 18 - --popover: oklch(0.93 0.01 35); 19 19 - --popover-foreground: oklch(0.18 0.01 30); 18 18 + --popover: oklch(0.96 0.006 35); 19 19 + --popover-foreground: oklch(0.15 0.015 30); 20 20 21 21 - /* Dark brown primary inspired by #645343 */ 22 22 - --primary: oklch(0.35 0.02 35); 23 23 - --primary-foreground: oklch(0.95 0.01 35); 21 21 + /* Dark brown primary - darker for better contrast */ 22 22 + --primary: oklch(0.30 0.025 35); 23 23 + --primary-foreground: oklch(0.96 0.008 35); 24 24 25 25 - /* Bright pink accent for links #FFAAD2 */ 26 26 - --accent: oklch(0.78 0.15 345); 27 27 - --accent-foreground: oklch(0.18 0.01 30); 25 25 + /* Deeper pink accent for better visibility */ 26 26 + --accent: oklch(0.65 0.18 345); 27 27 + --accent-foreground: oklch(0.15 0.015 30); 28 28 29 29 - /* Medium taupe secondary inspired by #867D76 */ 30 30 - --secondary: oklch(0.52 0.015 30); 31 31 - --secondary-foreground: oklch(0.95 0.01 35); 29 29 + /* Darker taupe secondary for better contrast */ 30 30 + --secondary: oklch(0.85 0.012 30); 31 31 + --secondary-foreground: oklch(0.25 0.02 30); 32 32 33 33 - /* Light warm muted background */ 33 33 + /* Muted areas with better distinction */ 34 34 --muted: oklch(0.88 0.01 35); 35 35 - --muted-foreground: oklch(0.42 0.015 30); 35 35 + --muted-foreground: oklch(0.35 0.02 30); 36 36 37 37 - --border: oklch(0.75 0.015 30); 38 38 - --input: oklch(0.92 0.01 35); 39 39 - --ring: oklch(0.72 0.08 15); 37 37 + /* Significantly darker border for visibility */ 38 38 + --border: oklch(0.65 0.02 30); 39 39 + /* Input backgrounds lighter than cards */ 40 40 + --input: oklch(0.97 0.005 35); 41 41 + --ring: oklch(0.55 0.12 345); 40 42 41 41 - --destructive: oklch(0.577 0.245 27.325); 42 42 - --destructive-foreground: oklch(0.985 0 0); 43 43 + --destructive: oklch(0.50 0.20 25); 44 44 + --destructive-foreground: oklch(0.98 0 0); 43 45 44 44 - --chart-1: oklch(0.78 0.15 345); 46 46 + --chart-1: oklch(0.65 0.18 345); 45 47 --chart-2: oklch(0.32 0.04 285); 46 46 - --chart-3: oklch(0.56 0.08 220); 47 47 - --chart-4: oklch(0.85 0.02 130); 48 48 - --chart-5: oklch(0.93 0.03 85); 48 48 + --chart-3: oklch(0.50 0.10 220); 49 49 + --chart-4: oklch(0.70 0.08 130); 50 50 + --chart-5: oklch(0.75 0.06 85); 49 51 50 52 --radius: 0.75rem; 51 51 - --sidebar: oklch(0.985 0 0); 52 52 - --sidebar-foreground: oklch(0.145 0 0); 53 53 - --sidebar-primary: oklch(0.205 0 0); 54 54 - --sidebar-primary-foreground: oklch(0.985 0 0); 55 55 - --sidebar-accent: oklch(0.97 0 0); 56 56 - --sidebar-accent-foreground: oklch(0.205 0 0); 57 57 - --sidebar-border: oklch(0.922 0 0); 58 58 - --sidebar-ring: oklch(0.708 0 0); 53 53 + --sidebar: oklch(0.94 0.008 35); 54 54 + --sidebar-foreground: oklch(0.15 0.015 30); 55 55 + --sidebar-primary: oklch(0.30 0.025 35); 56 56 + --sidebar-primary-foreground: oklch(0.96 0.008 35); 57 57 + --sidebar-accent: oklch(0.90 0.01 35); 58 58 + --sidebar-accent-foreground: oklch(0.20 0.02 30); 59 59 + --sidebar-border: oklch(0.65 0.02 30); 60 60 + --sidebar-ring: oklch(0.55 0.12 345); 59 61 } 60 62 61 63 .dark { ··· 160 162 * { 161 163 @apply border-border outline-ring/50; 162 164 } 165 165 + 166 166 + html { 167 167 + scrollbar-gutter: stable; 168 168 + } 169 169 + 163 170 body { 164 171 @apply bg-background text-foreground; 165 172 } 166 173 } 167 174 168 175 @keyframes arrow-bounce { 169 169 - 0%, 100% { 176 176 + 177 177 + 0%, 178 178 + 100% { 170 179 transform: translateX(0); 171 180 } 181 181 + 172 182 50% { 173 183 transform: translateX(4px); 174 184 } ··· 189 199 border-radius: 0.5rem; 190 200 padding: 1rem; 191 201 overflow-x: auto; 192 192 - border: 1px solid hsl(var(--border)); 202 202 + border: 1px solid var(--border); 193 203 } 194 204 195 205 .shiki-wrapper pre { 196 206 margin: 0 !important; 197 207 padding: 0 !important; 198 208 } 209 209 + 210 210 + /* ========== Landing Page Animations ========== */ 211 211 + 212 212 + /* Animated gradient for headline text */ 213 213 + @keyframes gradient-shift { 214 214 + 215 215 + 0%, 216 216 + 100% { 217 217 + background-position: 0% 50%; 218 218 + } 219 219 + 220 220 + 50% { 221 221 + background-position: 100% 50%; 222 222 + } 223 223 + } 224 224 + 225 225 + .text-gradient-animate { 226 226 + background: linear-gradient(90deg, 227 227 + oklch(0.55 0.22 350), 228 228 + oklch(0.60 0.24 10), 229 229 + oklch(0.55 0.22 350)); 230 230 + background-size: 200% auto; 231 231 + -webkit-background-clip: text; 232 232 + background-clip: text; 233 233 + -webkit-text-fill-color: transparent; 234 234 + animation: gradient-shift 4s ease-in-out infinite; 235 235 + } 236 236 + 237 237 + .dark .text-gradient-animate { 238 238 + background: linear-gradient(90deg, 239 239 + oklch(0.75 0.12 295), 240 240 + oklch(0.85 0.10 5), 241 241 + oklch(0.75 0.12 295)); 242 242 + background-size: 200% auto; 243 243 + -webkit-background-clip: text; 244 244 + background-clip: text; 245 245 + -webkit-text-fill-color: transparent; 246 246 + } 247 247 + 248 248 + /* Floating/breathing animation for hero elements */ 249 249 + @keyframes float { 250 250 + 251 251 + 0%, 252 252 + 100% { 253 253 + transform: translateY(0); 254 254 + } 255 255 + 256 256 + 50% { 257 257 + transform: translateY(-8px); 258 258 + } 259 259 + } 260 260 + 261 261 + .animate-float { 262 262 + animation: float 3s ease-in-out infinite; 263 263 + } 264 264 + 265 265 + .animate-float-delayed { 266 266 + animation: float 3s ease-in-out infinite; 267 267 + animation-delay: 0.5s; 268 268 + } 269 269 + 270 270 + /* Staggered fade-in animation */ 271 271 + @keyframes fade-in-up { 272 272 + from { 273 273 + opacity: 0; 274 274 + transform: translateY(20px); 275 275 + } 276 276 + 277 277 + to { 278 278 + opacity: 1; 279 279 + transform: translateY(0); 280 280 + } 281 281 + } 282 282 + 283 283 + .animate-fade-in-up { 284 284 + animation: fade-in-up 0.6s ease-out forwards; 285 285 + opacity: 0; 286 286 + } 287 287 + 288 288 + .animate-delay-100 { 289 289 + animation-delay: 0.1s; 290 290 + } 291 291 + 292 292 + .animate-delay-200 { 293 293 + animation-delay: 0.2s; 294 294 + } 295 295 + 296 296 + .animate-delay-300 { 297 297 + animation-delay: 0.3s; 298 298 + } 299 299 + 300 300 + .animate-delay-400 { 301 301 + animation-delay: 0.4s; 302 302 + } 303 303 + 304 304 + .animate-delay-500 { 305 305 + animation-delay: 0.5s; 306 306 + } 307 307 + 308 308 + .animate-delay-600 { 309 309 + animation-delay: 0.6s; 310 310 + } 311 311 + 312 312 + /* Terminal cursor blink */ 313 313 + @keyframes cursor-blink { 314 314 + 315 315 + 0%, 316 316 + 50% { 317 317 + opacity: 1; 318 318 + } 319 319 + 320 320 + 51%, 321 321 + 100% { 322 322 + opacity: 0; 323 323 + } 324 324 + } 325 325 + 326 326 + .animate-cursor-blink { 327 327 + animation: cursor-blink 1s step-end infinite; 328 328 + } 329 329 + 330 330 + /* Button hover scale effect */ 331 331 + .btn-hover-lift { 332 332 + transition: all 0.2s ease-out; 333 333 + } 334 334 + 335 335 + .btn-hover-lift:hover { 336 336 + transform: translateY(-2px); 337 337 + box-shadow: 0 4px 12px rgba(0, 0, 0, 0.15); 338 338 + } 339 339 + 340 340 + .btn-hover-lift:active { 341 341 + transform: translateY(0); 342 342 + } 343 343 + 344 344 + /* Subtle pulse for feature dots */ 345 345 + @keyframes dot-pulse { 346 346 + 347 347 + 0%, 348 348 + 100% { 349 349 + transform: scale(1); 350 350 + opacity: 1; 351 351 + } 352 352 + 353 353 + 50% { 354 354 + transform: scale(1.2); 355 355 + opacity: 0.8; 356 356 + } 357 357 + } 358 358 + 359 359 + .animate-dot-pulse { 360 360 + animation: dot-pulse 2s ease-in-out infinite; 361 361 + } 362 362 + 363 363 + .animate-dot-pulse-delayed-1 { 364 364 + animation: dot-pulse 2s ease-in-out infinite; 365 365 + animation-delay: 0.3s; 366 366 + } 367 367 + 368 368 + .animate-dot-pulse-delayed-2 { 369 369 + animation: dot-pulse 2s ease-in-out infinite; 370 370 + animation-delay: 0.6s; 371 371 + }

+23 -3

apps/main-app/src/index.ts

··· 12 12 cleanupExpiredSessions, 13 13 rotateKeysIfNeeded 14 14 } from './lib/oauth-client' 15 15 - import { getCookieSecret } from './lib/db' 15 15 + import { getCookieSecret, closeDatabase } from './lib/db' 16 16 import { authRoutes } from './routes/auth' 17 17 import { wispRoutes } from './routes/wisp' 18 18 import { domainRoutes } from './routes/domain' ··· 61 61 setInterval(runMaintenance, 60 * 60 * 1000) 62 62 63 63 // Start DNS verification worker (runs every 10 minutes) 64 64 + // Can be disabled via DISABLE_DNS_WORKER=true environment variable 64 65 const dnsVerifier = new DNSVerificationWorker( 65 66 10 * 60 * 1000, // 10 minutes 66 67 (msg, data) => { ··· 68 69 } 69 70 ) 70 71 71 71 - dnsVerifier.start() 72 72 - logger.info('DNS Verifier Started - checking custom domains every 10 minutes') 72 72 + if (Bun.env.DISABLE_DNS_WORKER !== 'true') { 73 73 + dnsVerifier.start() 74 74 + logger.info('DNS Verifier Started - checking custom domains every 10 minutes') 75 75 + } else { 76 76 + logger.info('DNS Verifier disabled via DISABLE_DNS_WORKER environment variable') 77 77 + } 73 78 74 79 export const app = new Elysia({ 75 80 serve: { ··· 200 205 console.log( 201 206 `🦊 Elysia is running at ${app.server?.hostname}:${app.server?.port}` 202 207 ) 208 208 + 209 209 + // Graceful shutdown 210 210 + process.on('SIGINT', async () => { 211 211 + console.log('\n🛑 Shutting down...') 212 212 + dnsVerifier.stop() 213 213 + await closeDatabase() 214 214 + process.exit(0) 215 215 + }) 216 216 + 217 217 + process.on('SIGTERM', async () => { 218 218 + console.log('\n🛑 Shutting down...') 219 219 + dnsVerifier.stop() 220 220 + await closeDatabase() 221 221 + process.exit(0) 222 222 + })

+13

apps/main-app/src/lib/db.ts

··· 526 526 console.log('[CookieSecret] Generated new cookie signing secret'); 527 527 return secret; 528 528 }; 529 529 + 530 530 + /** 531 531 + * Close database connection 532 532 + * Call this during graceful shutdown 533 533 + */ 534 534 + export const closeDatabase = async (): Promise<void> => { 535 535 + try { 536 536 + await db.end(); 537 537 + console.log('[DB] Database connection closed'); 538 538 + } catch (err) { 539 539 + console.error('[DB] Error closing database connection:', err); 540 540 + } 541 541 + };

+10 -16

apps/main-app/src/routes/wisp.ts

··· 39 39 40 40 const logger = createLogger('main-app') 41 41 42 42 - function isValidSiteName(siteName: string): boolean { 42 42 + export function isValidSiteName(siteName: string): boolean { 43 43 if (!siteName || typeof siteName !== 'string') return false; 44 44 45 45 // Length check (AT Protocol rkey limit) ··· 183 183 continue; 184 184 } 185 185 186 186 - console.log(`Processing file ${i + 1}/${fileArray.length}:`, file.name, file.size, 'bytes'); 186 186 + // Use webkitRelativePath when available (directory uploads), fallback to name for regular file uploads 187 187 + const webkitPath = 'webkitRelativePath' in file ? String(file.webkitRelativePath) : ''; 188 188 + const filePath = webkitPath || file.name; 189 189 + 187 190 updateJobProgress(jobId, { 188 191 filesProcessed: i + 1, 189 189 - currentFile: file.name 192 192 + currentFile: filePath 190 193 }); 191 194 192 195 // Skip files that match ignore patterns 193 193 - const normalizedPath = file.name.replace(/^[^\/]*\//, ''); 196 196 + const normalizedPath = filePath.replace(/^[^\/]*\//, ''); 194 197 195 198 if (shouldIgnore(ignoreMatcher, normalizedPath)) { 196 196 - console.log(`Skipping ignored file: ${file.name}`); 197 199 skippedFiles.push({ 198 198 - name: file.name, 200 200 + name: filePath, 199 201 reason: 'matched ignore pattern' 200 202 }); 201 203 continue; ··· 205 207 const maxSize = MAX_FILE_SIZE; 206 208 if (file.size > maxSize) { 207 209 skippedFiles.push({ 208 208 - name: file.name, 210 210 + name: filePath, 209 211 reason: `file too large (${(file.size / 1024 / 1024).toFixed(2)}MB, max 100MB)` 210 212 }); 211 213 continue; ··· 238 240 // Text files: compress AND base64 encode 239 241 finalContent = Buffer.from(compressedContent.toString('base64'), 'binary'); 240 242 base64Encoded = true; 241 241 - const compressionRatio = (compressedContent.length / originalContent.length * 100).toFixed(1); 242 242 - console.log(`Compressing+base64 ${file.name}: ${originalContent.length} -> ${compressedContent.length} bytes (${compressionRatio}%), base64: ${finalContent.length} bytes`); 243 243 - logger.info(`Compressing+base64 ${file.name}: ${originalContent.length} -> ${compressedContent.length} bytes (${compressionRatio}%), base64: ${finalContent.length} bytes`); 244 243 } else { 245 244 // Audio files: just compress, no base64 246 245 finalContent = compressedContent; 247 247 - const compressionRatio = (compressedContent.length / originalContent.length * 100).toFixed(1); 248 248 - console.log(`Compressing ${file.name}: ${originalContent.length} -> ${compressedContent.length} bytes (${compressionRatio}%)`); 249 249 - logger.info(`Compressing ${file.name}: ${originalContent.length} -> ${compressedContent.length} bytes (${compressionRatio}%)`); 250 246 } 251 247 } else { 252 248 // Binary files: upload directly 253 249 finalContent = originalContent; 254 254 - console.log(`Uploading ${file.name} directly: ${originalContent.length} bytes (no compression)`); 255 255 - logger.info(`Uploading ${file.name} directly: ${originalContent.length} bytes (binary)`); 256 250 } 257 251 258 252 uploadedFiles.push({ 259 259 - name: file.name, 253 253 + name: filePath, 260 254 content: finalContent, 261 255 mimeType: originalMimeType, 262 256 size: finalContent.length,

+59

backup.nix

··· 1 1 + { 2 2 + inputs.nixpkgs.url = "github:nixos/nixpkgs/nixpkgs-unstable"; 3 3 + inputs.nci.url = "github:90-008/nix-cargo-integration"; 4 4 + inputs.nci.inputs.nixpkgs.follows = "nixpkgs"; 5 5 + inputs.parts.url = "github:hercules-ci/flake-parts"; 6 6 + inputs.parts.inputs.nixpkgs-lib.follows = "nixpkgs"; 7 7 + inputs.fenix = { 8 8 + url = "github:nix-community/fenix"; 9 9 + inputs.nixpkgs.follows = "nixpkgs"; 10 10 + }; 11 11 + 12 12 + outputs = inputs @ { 13 13 + parts, 14 14 + nci, 15 15 + ... 16 16 + }: 17 17 + parts.lib.mkFlake {inherit inputs;} { 18 18 + systems = ["x86_64-linux" "aarch64-darwin"]; 19 19 + imports = [ 20 20 + nci.flakeModule 21 21 + ./crates.nix 22 22 + ]; 23 23 + perSystem = { 24 24 + pkgs, 25 25 + config, 26 26 + ... 27 27 + }: let 28 28 + crateOutputs = config.nci.outputs."wisp-cli"; 29 29 + mkRenamedPackage = name: pkg: isWindows: pkgs.runCommand name {} '' 30 30 + mkdir -p $out/bin 31 31 + if [ -f ${pkg}/bin/wisp-cli.exe ]; then 32 32 + cp ${pkg}/bin/wisp-cli.exe $out/bin/${name} 33 33 + elif [ -f ${pkg}/bin/wisp-cli ]; then 34 34 + cp ${pkg}/bin/wisp-cli $out/bin/${name} 35 35 + else 36 36 + echo "Error: Could not find wisp-cli binary in ${pkg}/bin/" 37 37 + ls -la ${pkg}/bin/ || true 38 38 + exit 1 39 39 + fi 40 40 + ''; 41 41 + in { 42 42 + devShells.default = crateOutputs.devShell; 43 43 + packages.default = crateOutputs.packages.release; 44 44 + packages.wisp-cli-x86_64-linux = mkRenamedPackage "wisp-cli-x86_64-linux" crateOutputs.packages.release false; 45 45 + packages.wisp-cli-aarch64-linux = mkRenamedPackage "wisp-cli-aarch64-linux" crateOutputs.allTargets."aarch64-unknown-linux-gnu".packages.release false; 46 46 + packages.wisp-cli-x86_64-windows = mkRenamedPackage "wisp-cli-x86_64-windows.exe" crateOutputs.allTargets."x86_64-pc-windows-gnu".packages.release true; 47 47 + packages.wisp-cli-aarch64-darwin = mkRenamedPackage "wisp-cli-aarch64-darwin" crateOutputs.allTargets."aarch64-apple-darwin".packages.release false; 48 48 + packages.all = pkgs.symlinkJoin { 49 49 + name = "wisp-cli-all"; 50 50 + paths = [ 51 51 + config.packages.wisp-cli-x86_64-linux 52 52 + config.packages.wisp-cli-aarch64-linux 53 53 + config.packages.wisp-cli-x86_64-windows 54 54 + config.packages.wisp-cli-aarch64-darwin 55 55 + ]; 56 56 + }; 57 57 + }; 58 58 + }; 59 59 + }

+236 -4

bun.lock

··· 11 11 "elysia": "^1.4.18", 12 12 "tailwindcss": "^4.1.17", 13 13 }, 14 14 + "devDependencies": { 15 15 + "@types/bun": "^1.3.5", 16 16 + }, 14 17 }, 15 18 "apps/hosting-service": { 16 19 "name": "wisp-hosting-service", ··· 33 36 "mime-types": "^2.1.35", 34 37 "multiformats": "^13.4.1", 35 38 "postgres": "^3.4.5", 39 39 + "tiered-storage": "1.0.3", 36 40 }, 37 41 "devDependencies": { 38 42 "@types/bun": "^1.3.1", ··· 259 263 260 264 "@atproto/xrpc-server": ["@atproto/xrpc-server@0.9.6", "", { "dependencies": { "@atproto/common": "^0.4.12", "@atproto/crypto": "^0.4.4", "@atproto/lexicon": "^0.5.1", "@atproto/ws-client": "^0.0.2", "@atproto/xrpc": "^0.7.5", "cbor-x": "^1.5.1", "express": "^4.17.2", "http-errors": "^2.0.0", "mime-types": "^2.1.35", "rate-limiter-flexible": "^2.4.1", "uint8arrays": "3.0.0", "ws": "^8.12.0", "zod": "^3.23.8" } }, "sha512-N/wPK0VEk8lZLkVsfG1wlkINQnBLO2fzWT+xclOjYl5lJwDi5xgiiyEQJAyZN49d6cmbsONu0SuOVw9pa5xLCw=="], 261 265 266 266 + "@aws-crypto/crc32": ["@aws-crypto/crc32@5.2.0", "", { "dependencies": { "@aws-crypto/util": "^5.2.0", "@aws-sdk/types": "^3.222.0", "tslib": "^2.6.2" } }, "sha512-nLbCWqQNgUiwwtFsen1AdzAtvuLRsQS8rYgMuxCrdKf9kOssamGLuPwyTY9wyYblNr9+1XM8v6zoDTPPSIeANg=="], 267 267 + 268 268 + "@aws-crypto/crc32c": ["@aws-crypto/crc32c@5.2.0", "", { "dependencies": { "@aws-crypto/util": "^5.2.0", "@aws-sdk/types": "^3.222.0", "tslib": "^2.6.2" } }, "sha512-+iWb8qaHLYKrNvGRbiYRHSdKRWhto5XlZUEBwDjYNf+ly5SVYG6zEoYIdxvf5R3zyeP16w4PLBn3rH1xc74Rag=="], 269 269 + 270 270 + "@aws-crypto/sha1-browser": ["@aws-crypto/sha1-browser@5.2.0", "", { "dependencies": { "@aws-crypto/supports-web-crypto": "^5.2.0", "@aws-crypto/util": "^5.2.0", "@aws-sdk/types": "^3.222.0", "@aws-sdk/util-locate-window": "^3.0.0", "@smithy/util-utf8": "^2.0.0", "tslib": "^2.6.2" } }, "sha512-OH6lveCFfcDjX4dbAvCFSYUjJZjDr/3XJ3xHtjn3Oj5b9RjojQo8npoLeA/bNwkOkrSQ0wgrHzXk4tDRxGKJeg=="], 271 271 + 272 272 + "@aws-crypto/sha256-browser": ["@aws-crypto/sha256-browser@5.2.0", "", { "dependencies": { "@aws-crypto/sha256-js": "^5.2.0", "@aws-crypto/supports-web-crypto": "^5.2.0", "@aws-crypto/util": "^5.2.0", "@aws-sdk/types": "^3.222.0", "@aws-sdk/util-locate-window": "^3.0.0", "@smithy/util-utf8": "^2.0.0", "tslib": "^2.6.2" } }, "sha512-AXfN/lGotSQwu6HNcEsIASo7kWXZ5HYWvfOmSNKDsEqC4OashTp8alTmaz+F7TC2L083SFv5RdB+qU3Vs1kZqw=="], 273 273 + 274 274 + "@aws-crypto/sha256-js": ["@aws-crypto/sha256-js@5.2.0", "", { "dependencies": { "@aws-crypto/util": "^5.2.0", "@aws-sdk/types": "^3.222.0", "tslib": "^2.6.2" } }, "sha512-FFQQyu7edu4ufvIZ+OadFpHHOt+eSTBaYaki44c+akjg7qZg9oOQeLlk77F6tSYqjDAFClrHJk9tMf0HdVyOvA=="], 275 275 + 276 276 + "@aws-crypto/supports-web-crypto": ["@aws-crypto/supports-web-crypto@5.2.0", "", { "dependencies": { "tslib": "^2.6.2" } }, "sha512-iAvUotm021kM33eCdNfwIN//F77/IADDSs58i+MDaOqFrVjZo9bAal0NK7HurRuWLLpF1iLX7gbWrjHjeo+YFg=="], 277 277 + 278 278 + "@aws-crypto/util": ["@aws-crypto/util@5.2.0", "", { "dependencies": { "@aws-sdk/types": "^3.222.0", "@smithy/util-utf8": "^2.0.0", "tslib": "^2.6.2" } }, "sha512-4RkU9EsI6ZpBve5fseQlGNUWKMa1RLPQ1dnjnQoe07ldfIzcsGb5hC5W0Dm7u423KWzawlrpbjXBrXCEv9zazQ=="], 279 279 + 280 280 + "@aws-sdk/client-s3": ["@aws-sdk/client-s3@3.962.0", "", { "dependencies": { "@aws-crypto/sha1-browser": "5.2.0", "@aws-crypto/sha256-browser": "5.2.0", "@aws-crypto/sha256-js": "5.2.0", "@aws-sdk/core": "3.957.0", "@aws-sdk/credential-provider-node": "3.962.0", "@aws-sdk/middleware-bucket-endpoint": "3.957.0", "@aws-sdk/middleware-expect-continue": "3.957.0", "@aws-sdk/middleware-flexible-checksums": "3.957.0", "@aws-sdk/middleware-host-header": "3.957.0", "@aws-sdk/middleware-location-constraint": "3.957.0", "@aws-sdk/middleware-logger": "3.957.0", "@aws-sdk/middleware-recursion-detection": "3.957.0", "@aws-sdk/middleware-sdk-s3": "3.957.0", "@aws-sdk/middleware-ssec": "3.957.0", "@aws-sdk/middleware-user-agent": "3.957.0", "@aws-sdk/region-config-resolver": "3.957.0", "@aws-sdk/signature-v4-multi-region": "3.957.0", "@aws-sdk/types": "3.957.0", "@aws-sdk/util-endpoints": "3.957.0", "@aws-sdk/util-user-agent-browser": "3.957.0", "@aws-sdk/util-user-agent-node": "3.957.0", "@smithy/config-resolver": "^4.4.5", "@smithy/core": "^3.20.0", "@smithy/eventstream-serde-browser": "^4.2.7", "@smithy/eventstream-serde-config-resolver": "^4.3.7", "@smithy/eventstream-serde-node": "^4.2.7", "@smithy/fetch-http-handler": "^5.3.8", "@smithy/hash-blob-browser": "^4.2.8", "@smithy/hash-node": "^4.2.7", "@smithy/hash-stream-node": "^4.2.7", "@smithy/invalid-dependency": "^4.2.7", "@smithy/md5-js": "^4.2.7", "@smithy/middleware-content-length": "^4.2.7", "@smithy/middleware-endpoint": "^4.4.1", "@smithy/middleware-retry": "^4.4.17", "@smithy/middleware-serde": "^4.2.8", "@smithy/middleware-stack": "^4.2.7", "@smithy/node-config-provider": "^4.3.7", "@smithy/node-http-handler": "^4.4.7", "@smithy/protocol-http": "^5.3.7", "@smithy/smithy-client": "^4.10.2", "@smithy/types": "^4.11.0", "@smithy/url-parser": "^4.2.7", "@smithy/util-base64": "^4.3.0", "@smithy/util-body-length-browser": "^4.2.0", "@smithy/util-body-length-node": "^4.2.1", "@smithy/util-defaults-mode-browser": "^4.3.16", "@smithy/util-defaults-mode-node": "^4.2.19", "@smithy/util-endpoints": "^3.2.7", "@smithy/util-middleware": "^4.2.7", "@smithy/util-retry": "^4.2.7", "@smithy/util-stream": "^4.5.8", "@smithy/util-utf8": "^4.2.0", "@smithy/util-waiter": "^4.2.7", "tslib": "^2.6.2" } }, "sha512-I2/1McBZCcM3PfM4ck8D6gnZR3K7+yl1fGkwTq/3ThEn9tdLjNwcdgTbPfxfX6LoecLrH9Ekoo+D9nmQ0T261w=="], 281 281 + 282 282 + "@aws-sdk/client-sso": ["@aws-sdk/client-sso@3.958.0", "", { "dependencies": { "@aws-crypto/sha256-browser": "5.2.0", "@aws-crypto/sha256-js": "5.2.0", "@aws-sdk/core": "3.957.0", "@aws-sdk/middleware-host-header": "3.957.0", "@aws-sdk/middleware-logger": "3.957.0", "@aws-sdk/middleware-recursion-detection": "3.957.0", "@aws-sdk/middleware-user-agent": "3.957.0", "@aws-sdk/region-config-resolver": "3.957.0", "@aws-sdk/types": "3.957.0", "@aws-sdk/util-endpoints": "3.957.0", "@aws-sdk/util-user-agent-browser": "3.957.0", "@aws-sdk/util-user-agent-node": "3.957.0", "@smithy/config-resolver": "^4.4.5", "@smithy/core": "^3.20.0", "@smithy/fetch-http-handler": "^5.3.8", "@smithy/hash-node": "^4.2.7", "@smithy/invalid-dependency": "^4.2.7", "@smithy/middleware-content-length": "^4.2.7", "@smithy/middleware-endpoint": "^4.4.1", "@smithy/middleware-retry": "^4.4.17", "@smithy/middleware-serde": "^4.2.8", "@smithy/middleware-stack": "^4.2.7", "@smithy/node-config-provider": "^4.3.7", "@smithy/node-http-handler": "^4.4.7", "@smithy/protocol-http": "^5.3.7", "@smithy/smithy-client": "^4.10.2", "@smithy/types": "^4.11.0", "@smithy/url-parser": "^4.2.7", "@smithy/util-base64": "^4.3.0", "@smithy/util-body-length-browser": "^4.2.0", "@smithy/util-body-length-node": "^4.2.1", "@smithy/util-defaults-mode-browser": "^4.3.16", "@smithy/util-defaults-mode-node": "^4.2.19", "@smithy/util-endpoints": "^3.2.7", "@smithy/util-middleware": "^4.2.7", "@smithy/util-retry": "^4.2.7", "@smithy/util-utf8": "^4.2.0", "tslib": "^2.6.2" } }, "sha512-6qNCIeaMzKzfqasy2nNRuYnMuaMebCcCPP4J2CVGkA8QYMbIVKPlkn9bpB20Vxe6H/r3jtCCLQaOJjVTx/6dXg=="], 283 283 + 284 284 + "@aws-sdk/core": ["@aws-sdk/core@3.957.0", "", { "dependencies": { "@aws-sdk/types": "3.957.0", "@aws-sdk/xml-builder": "3.957.0", "@smithy/core": "^3.20.0", "@smithy/node-config-provider": "^4.3.7", "@smithy/property-provider": "^4.2.7", "@smithy/protocol-http": "^5.3.7", "@smithy/signature-v4": "^5.3.7", "@smithy/smithy-client": "^4.10.2", "@smithy/types": "^4.11.0", "@smithy/util-base64": "^4.3.0", "@smithy/util-middleware": "^4.2.7", "@smithy/util-utf8": "^4.2.0", "tslib": "^2.6.2" } }, "sha512-DrZgDnF1lQZv75a52nFWs6MExihJF2GZB6ETZRqr6jMwhrk2kbJPUtvgbifwcL7AYmVqHQDJBrR/MqkwwFCpiw=="], 285 285 + 286 286 + "@aws-sdk/crc64-nvme": ["@aws-sdk/crc64-nvme@3.957.0", "", { "dependencies": { "@smithy/types": "^4.11.0", "tslib": "^2.6.2" } }, "sha512-qSwSfI+qBU9HDsd6/4fM9faCxYJx2yDuHtj+NVOQ6XYDWQzFab/hUdwuKZ77Pi6goLF1pBZhJ2azaC2w7LbnTA=="], 287 287 + 288 288 + "@aws-sdk/credential-provider-env": ["@aws-sdk/credential-provider-env@3.957.0", "", { "dependencies": { "@aws-sdk/core": "3.957.0", "@aws-sdk/types": "3.957.0", "@smithy/property-provider": "^4.2.7", "@smithy/types": "^4.11.0", "tslib": "^2.6.2" } }, "sha512-475mkhGaWCr+Z52fOOVb/q2VHuNvqEDixlYIkeaO6xJ6t9qR0wpLt4hOQaR6zR1wfZV0SlE7d8RErdYq/PByog=="], 289 289 + 290 290 + "@aws-sdk/credential-provider-http": ["@aws-sdk/credential-provider-http@3.957.0", "", { "dependencies": { "@aws-sdk/core": "3.957.0", "@aws-sdk/types": "3.957.0", "@smithy/fetch-http-handler": "^5.3.8", "@smithy/node-http-handler": "^4.4.7", "@smithy/property-provider": "^4.2.7", "@smithy/protocol-http": "^5.3.7", "@smithy/smithy-client": "^4.10.2", "@smithy/types": "^4.11.0", "@smithy/util-stream": "^4.5.8", "tslib": "^2.6.2" } }, "sha512-8dS55QHRxXgJlHkEYaCGZIhieCs9NU1HU1BcqQ4RfUdSsfRdxxktqUKgCnBnOOn0oD3PPA8cQOCAVgIyRb3Rfw=="], 291 291 + 292 292 + "@aws-sdk/credential-provider-ini": ["@aws-sdk/credential-provider-ini@3.962.0", "", { "dependencies": { "@aws-sdk/core": "3.957.0", "@aws-sdk/credential-provider-env": "3.957.0", "@aws-sdk/credential-provider-http": "3.957.0", "@aws-sdk/credential-provider-login": "3.962.0", "@aws-sdk/credential-provider-process": "3.957.0", "@aws-sdk/credential-provider-sso": "3.958.0", "@aws-sdk/credential-provider-web-identity": "3.958.0", "@aws-sdk/nested-clients": "3.958.0", "@aws-sdk/types": "3.957.0", "@smithy/credential-provider-imds": "^4.2.7", "@smithy/property-provider": "^4.2.7", "@smithy/shared-ini-file-loader": "^4.4.2", "@smithy/types": "^4.11.0", "tslib": "^2.6.2" } }, "sha512-h0kVnXLW2d3nxbcrR/Pfg3W/+YoCguasWz7/3nYzVqmdKarGrpJzaFdoZtLgvDSZ8VgWUC4lWOTcsDMV0UNqUQ=="], 293 293 + 294 294 + "@aws-sdk/credential-provider-login": ["@aws-sdk/credential-provider-login@3.962.0", "", { "dependencies": { "@aws-sdk/core": "3.957.0", "@aws-sdk/nested-clients": "3.958.0", "@aws-sdk/types": "3.957.0", "@smithy/property-provider": "^4.2.7", "@smithy/protocol-http": "^5.3.7", "@smithy/shared-ini-file-loader": "^4.4.2", "@smithy/types": "^4.11.0", "tslib": "^2.6.2" } }, "sha512-kHYH6Av2UifG3mPkpPUNRh/PuX6adaAcpmsclJdHdxlixMCRdh8GNeEihq480DC0GmfqdpoSf1w2CLmLLPIS6w=="], 295 295 + 296 296 + "@aws-sdk/credential-provider-node": ["@aws-sdk/credential-provider-node@3.962.0", "", { "dependencies": { "@aws-sdk/credential-provider-env": "3.957.0", "@aws-sdk/credential-provider-http": "3.957.0", "@aws-sdk/credential-provider-ini": "3.962.0", "@aws-sdk/credential-provider-process": "3.957.0", "@aws-sdk/credential-provider-sso": "3.958.0", "@aws-sdk/credential-provider-web-identity": "3.958.0", "@aws-sdk/types": "3.957.0", "@smithy/credential-provider-imds": "^4.2.7", "@smithy/property-provider": "^4.2.7", "@smithy/shared-ini-file-loader": "^4.4.2", "@smithy/types": "^4.11.0", "tslib": "^2.6.2" } }, "sha512-CS78NsWRxLa+nWqeWBEYMZTLacMFIXs1C5WJuM9kD05LLiWL32ksljoPsvNN24Bc7rCSQIIMx/U3KGvkDVZMVg=="], 297 297 + 298 298 + "@aws-sdk/credential-provider-process": ["@aws-sdk/credential-provider-process@3.957.0", "", { "dependencies": { "@aws-sdk/core": "3.957.0", "@aws-sdk/types": "3.957.0", "@smithy/property-provider": "^4.2.7", "@smithy/shared-ini-file-loader": "^4.4.2", "@smithy/types": "^4.11.0", "tslib": "^2.6.2" } }, "sha512-/KIz9kadwbeLy6SKvT79W81Y+hb/8LMDyeloA2zhouE28hmne+hLn0wNCQXAAupFFlYOAtZR2NTBs7HBAReJlg=="], 299 299 + 300 300 + "@aws-sdk/credential-provider-sso": ["@aws-sdk/credential-provider-sso@3.958.0", "", { "dependencies": { "@aws-sdk/client-sso": "3.958.0", "@aws-sdk/core": "3.957.0", "@aws-sdk/token-providers": "3.958.0", "@aws-sdk/types": "3.957.0", "@smithy/property-provider": "^4.2.7", "@smithy/shared-ini-file-loader": "^4.4.2", "@smithy/types": "^4.11.0", "tslib": "^2.6.2" } }, "sha512-CBYHJ5ufp8HC4q+o7IJejCUctJXWaksgpmoFpXerbjAso7/Fg7LLUu9inXVOxlHKLlvYekDXjIUBXDJS2WYdgg=="], 301 301 + 302 302 + "@aws-sdk/credential-provider-web-identity": ["@aws-sdk/credential-provider-web-identity@3.958.0", "", { "dependencies": { "@aws-sdk/core": "3.957.0", "@aws-sdk/nested-clients": "3.958.0", "@aws-sdk/types": "3.957.0", "@smithy/property-provider": "^4.2.7", "@smithy/shared-ini-file-loader": "^4.4.2", "@smithy/types": "^4.11.0", "tslib": "^2.6.2" } }, "sha512-dgnvwjMq5Y66WozzUzxNkCFap+umHUtqMMKlr8z/vl9NYMLem/WUbWNpFFOVFWquXikc+ewtpBMR4KEDXfZ+KA=="], 303 303 + 304 304 + "@aws-sdk/lib-storage": ["@aws-sdk/lib-storage@3.962.0", "", { "dependencies": { "@smithy/abort-controller": "^4.2.7", "@smithy/middleware-endpoint": "^4.4.1", "@smithy/smithy-client": "^4.10.2", "buffer": "5.6.0", "events": "3.3.0", "stream-browserify": "3.0.0", "tslib": "^2.6.2" }, "peerDependencies": { "@aws-sdk/client-s3": "^3.962.0" } }, "sha512-Ai5gWRQkzsUMQ6NPoZZoiLXoQ6/yPRcR4oracIVjyWcu48TfBpsRgbqY/5zNOM55ag1wPX9TtJJGOhK3TNk45g=="], 305 305 + 306 306 + "@aws-sdk/middleware-bucket-endpoint": ["@aws-sdk/middleware-bucket-endpoint@3.957.0", "", { "dependencies": { "@aws-sdk/types": "3.957.0", "@aws-sdk/util-arn-parser": "3.957.0", "@smithy/node-config-provider": "^4.3.7", "@smithy/protocol-http": "^5.3.7", "@smithy/types": "^4.11.0", "@smithy/util-config-provider": "^4.2.0", "tslib": "^2.6.2" } }, "sha512-iczcn/QRIBSpvsdAS/rbzmoBpleX1JBjXvCynMbDceVLBIcVrwT1hXECrhtIC2cjh4HaLo9ClAbiOiWuqt+6MA=="], 307 307 + 308 308 + "@aws-sdk/middleware-expect-continue": ["@aws-sdk/middleware-expect-continue@3.957.0", "", { "dependencies": { "@aws-sdk/types": "3.957.0", "@smithy/protocol-http": "^5.3.7", "@smithy/types": "^4.11.0", "tslib": "^2.6.2" } }, "sha512-AlbK3OeVNwZZil0wlClgeI/ISlOt/SPUxBsIns876IFaVu/Pj3DgImnYhpcJuFRek4r4XM51xzIaGQXM6GDHGg=="], 309 309 + 310 310 + "@aws-sdk/middleware-flexible-checksums": ["@aws-sdk/middleware-flexible-checksums@3.957.0", "", { "dependencies": { "@aws-crypto/crc32": "5.2.0", "@aws-crypto/crc32c": "5.2.0", "@aws-crypto/util": "5.2.0", "@aws-sdk/core": "3.957.0", "@aws-sdk/crc64-nvme": "3.957.0", "@aws-sdk/types": "3.957.0", "@smithy/is-array-buffer": "^4.2.0", "@smithy/node-config-provider": "^4.3.7", "@smithy/protocol-http": "^5.3.7", "@smithy/types": "^4.11.0", "@smithy/util-middleware": "^4.2.7", "@smithy/util-stream": "^4.5.8", "@smithy/util-utf8": "^4.2.0", "tslib": "^2.6.2" } }, "sha512-iJpeVR5V8se1hl2pt+k8bF/e9JO4KWgPCMjg8BtRspNtKIUGy7j6msYvbDixaKZaF2Veg9+HoYcOhwnZumjXSA=="], 311 311 + 312 312 + "@aws-sdk/middleware-host-header": ["@aws-sdk/middleware-host-header@3.957.0", "", { "dependencies": { "@aws-sdk/types": "3.957.0", "@smithy/protocol-http": "^5.3.7", "@smithy/types": "^4.11.0", "tslib": "^2.6.2" } }, "sha512-BBgKawVyfQZglEkNTuBBdC3azlyqNXsvvN4jPkWAiNYcY0x1BasaJFl+7u/HisfULstryweJq/dAvIZIxzlZaA=="], 313 313 + 314 314 + "@aws-sdk/middleware-location-constraint": ["@aws-sdk/middleware-location-constraint@3.957.0", "", { "dependencies": { "@aws-sdk/types": "3.957.0", "@smithy/types": "^4.11.0", "tslib": "^2.6.2" } }, "sha512-y8/W7TOQpmDJg/fPYlqAhwA4+I15LrS7TwgUEoxogtkD8gfur9wFMRLT8LCyc9o4NMEcAnK50hSb4+wB0qv6tQ=="], 315 315 + 316 316 + "@aws-sdk/middleware-logger": ["@aws-sdk/middleware-logger@3.957.0", "", { "dependencies": { "@aws-sdk/types": "3.957.0", "@smithy/types": "^4.11.0", "tslib": "^2.6.2" } }, "sha512-w1qfKrSKHf9b5a8O76yQ1t69u6NWuBjr5kBX+jRWFx/5mu6RLpqERXRpVJxfosbep7k3B+DSB5tZMZ82GKcJtQ=="], 317 317 + 318 318 + "@aws-sdk/middleware-recursion-detection": ["@aws-sdk/middleware-recursion-detection@3.957.0", "", { "dependencies": { "@aws-sdk/types": "3.957.0", "@aws/lambda-invoke-store": "^0.2.2", "@smithy/protocol-http": "^5.3.7", "@smithy/types": "^4.11.0", "tslib": "^2.6.2" } }, "sha512-D2H/WoxhAZNYX+IjkKTdOhOkWQaK0jjJrDBj56hKjU5c9ltQiaX/1PqJ4dfjHntEshJfu0w+E6XJ+/6A6ILBBA=="], 319 319 + 320 320 + "@aws-sdk/middleware-sdk-s3": ["@aws-sdk/middleware-sdk-s3@3.957.0", "", { "dependencies": { "@aws-sdk/core": "3.957.0", "@aws-sdk/types": "3.957.0", "@aws-sdk/util-arn-parser": "3.957.0", "@smithy/core": "^3.20.0", "@smithy/node-config-provider": "^4.3.7", "@smithy/protocol-http": "^5.3.7", "@smithy/signature-v4": "^5.3.7", "@smithy/smithy-client": "^4.10.2", "@smithy/types": "^4.11.0", "@smithy/util-config-provider": "^4.2.0", "@smithy/util-middleware": "^4.2.7", "@smithy/util-stream": "^4.5.8", "@smithy/util-utf8": "^4.2.0", "tslib": "^2.6.2" } }, "sha512-5B2qY2nR2LYpxoQP0xUum5A1UNvH2JQpLHDH1nWFNF/XetV7ipFHksMxPNhtJJ6ARaWhQIDXfOUj0jcnkJxXUg=="], 321 321 + 322 322 + "@aws-sdk/middleware-ssec": ["@aws-sdk/middleware-ssec@3.957.0", "", { "dependencies": { "@aws-sdk/types": "3.957.0", "@smithy/types": "^4.11.0", "tslib": "^2.6.2" } }, "sha512-qwkmrK0lizdjNt5qxl4tHYfASh8DFpHXM1iDVo+qHe+zuslfMqQEGRkzxS8tJq/I+8F0c6v3IKOveKJAfIvfqQ=="], 323 323 + 324 324 + "@aws-sdk/middleware-user-agent": ["@aws-sdk/middleware-user-agent@3.957.0", "", { "dependencies": { "@aws-sdk/core": "3.957.0", "@aws-sdk/types": "3.957.0", "@aws-sdk/util-endpoints": "3.957.0", "@smithy/core": "^3.20.0", "@smithy/protocol-http": "^5.3.7", "@smithy/types": "^4.11.0", "tslib": "^2.6.2" } }, "sha512-50vcHu96XakQnIvlKJ1UoltrFODjsq2KvtTgHiPFteUS884lQnK5VC/8xd1Msz/1ONpLMzdCVproCQqhDTtMPQ=="], 325 325 + 326 326 + "@aws-sdk/nested-clients": ["@aws-sdk/nested-clients@3.958.0", "", { "dependencies": { "@aws-crypto/sha256-browser": "5.2.0", "@aws-crypto/sha256-js": "5.2.0", "@aws-sdk/core": "3.957.0", "@aws-sdk/middleware-host-header": "3.957.0", "@aws-sdk/middleware-logger": "3.957.0", "@aws-sdk/middleware-recursion-detection": "3.957.0", "@aws-sdk/middleware-user-agent": "3.957.0", "@aws-sdk/region-config-resolver": "3.957.0", "@aws-sdk/types": "3.957.0", "@aws-sdk/util-endpoints": "3.957.0", "@aws-sdk/util-user-agent-browser": "3.957.0", "@aws-sdk/util-user-agent-node": "3.957.0", "@smithy/config-resolver": "^4.4.5", "@smithy/core": "^3.20.0", "@smithy/fetch-http-handler": "^5.3.8", "@smithy/hash-node": "^4.2.7", "@smithy/invalid-dependency": "^4.2.7", "@smithy/middleware-content-length": "^4.2.7", "@smithy/middleware-endpoint": "^4.4.1", "@smithy/middleware-retry": "^4.4.17", "@smithy/middleware-serde": "^4.2.8", "@smithy/middleware-stack": "^4.2.7", "@smithy/node-config-provider": "^4.3.7", "@smithy/node-http-handler": "^4.4.7", "@smithy/protocol-http": "^5.3.7", "@smithy/smithy-client": "^4.10.2", "@smithy/types": "^4.11.0", "@smithy/url-parser": "^4.2.7", "@smithy/util-base64": "^4.3.0", "@smithy/util-body-length-browser": "^4.2.0", "@smithy/util-body-length-node": "^4.2.1", "@smithy/util-defaults-mode-browser": "^4.3.16", "@smithy/util-defaults-mode-node": "^4.2.19", "@smithy/util-endpoints": "^3.2.7", "@smithy/util-middleware": "^4.2.7", "@smithy/util-retry": "^4.2.7", "@smithy/util-utf8": "^4.2.0", "tslib": "^2.6.2" } }, "sha512-/KuCcS8b5TpQXkYOrPLYytrgxBhv81+5pChkOlhegbeHttjM69pyUpQVJqyfDM/A7wPLnDrzCAnk4zaAOkY0Nw=="], 327 327 + 328 328 + "@aws-sdk/region-config-resolver": ["@aws-sdk/region-config-resolver@3.957.0", "", { "dependencies": { "@aws-sdk/types": "3.957.0", "@smithy/config-resolver": "^4.4.5", "@smithy/node-config-provider": "^4.3.7", "@smithy/types": "^4.11.0", "tslib": "^2.6.2" } }, "sha512-V8iY3blh8l2iaOqXWW88HbkY5jDoWjH56jonprG/cpyqqCnprvpMUZWPWYJoI8rHRf2bqzZeql1slxG6EnKI7A=="], 329 329 + 330 330 + "@aws-sdk/signature-v4-multi-region": ["@aws-sdk/signature-v4-multi-region@3.957.0", "", { "dependencies": { "@aws-sdk/middleware-sdk-s3": "3.957.0", "@aws-sdk/types": "3.957.0", "@smithy/protocol-http": "^5.3.7", "@smithy/signature-v4": "^5.3.7", "@smithy/types": "^4.11.0", "tslib": "^2.6.2" } }, "sha512-t6UfP1xMUigMMzHcb7vaZcjv7dA2DQkk9C/OAP1dKyrE0vb4lFGDaTApi17GN6Km9zFxJthEMUbBc7DL0hq1Bg=="], 331 331 + 332 332 + "@aws-sdk/token-providers": ["@aws-sdk/token-providers@3.958.0", "", { "dependencies": { "@aws-sdk/core": "3.957.0", "@aws-sdk/nested-clients": "3.958.0", "@aws-sdk/types": "3.957.0", "@smithy/property-provider": "^4.2.7", "@smithy/shared-ini-file-loader": "^4.4.2", "@smithy/types": "^4.11.0", "tslib": "^2.6.2" } }, "sha512-UCj7lQXODduD1myNJQkV+LYcGYJ9iiMggR8ow8Hva1g3A/Na5imNXzz6O67k7DAee0TYpy+gkNw+SizC6min8Q=="], 333 333 + 334 334 + "@aws-sdk/types": ["@aws-sdk/types@3.957.0", "", { "dependencies": { "@smithy/types": "^4.11.0", "tslib": "^2.6.2" } }, "sha512-wzWC2Nrt859ABk6UCAVY/WYEbAd7FjkdrQL6m24+tfmWYDNRByTJ9uOgU/kw9zqLCAwb//CPvrJdhqjTznWXAg=="], 335 335 + 336 336 + "@aws-sdk/util-arn-parser": ["@aws-sdk/util-arn-parser@3.957.0", "", { "dependencies": { "tslib": "^2.6.2" } }, "sha512-Aj6m+AyrhWyg8YQ4LDPg2/gIfGHCEcoQdBt5DeSFogN5k9mmJPOJ+IAmNSWmWRjpOxEy6eY813RNDI6qS97M0g=="], 337 337 + 338 338 + "@aws-sdk/util-endpoints": ["@aws-sdk/util-endpoints@3.957.0", "", { "dependencies": { "@aws-sdk/types": "3.957.0", "@smithy/types": "^4.11.0", "@smithy/url-parser": "^4.2.7", "@smithy/util-endpoints": "^3.2.7", "tslib": "^2.6.2" } }, "sha512-xwF9K24mZSxcxKS3UKQFeX/dPYkEps9wF1b+MGON7EvnbcucrJGyQyK1v1xFPn1aqXkBTFi+SZaMRx5E5YCVFw=="], 339 339 + 340 340 + "@aws-sdk/util-locate-window": ["@aws-sdk/util-locate-window@3.957.0", "", { "dependencies": { "tslib": "^2.6.2" } }, "sha512-nhmgKHnNV9K+i9daumaIz8JTLsIIML9PE/HUks5liyrjUzenjW/aHoc7WJ9/Td/gPZtayxFnXQSJRb/fDlBuJw=="], 341 341 + 342 342 + "@aws-sdk/util-user-agent-browser": ["@aws-sdk/util-user-agent-browser@3.957.0", "", { "dependencies": { "@aws-sdk/types": "3.957.0", "@smithy/types": "^4.11.0", "bowser": "^2.11.0", "tslib": "^2.6.2" } }, "sha512-exueuwxef0lUJRnGaVkNSC674eAiWU07ORhxBnevFFZEKisln+09Qrtw823iyv5I1N8T+wKfh95xvtWQrNKNQw=="], 343 343 + 344 344 + "@aws-sdk/util-user-agent-node": ["@aws-sdk/util-user-agent-node@3.957.0", "", { "dependencies": { "@aws-sdk/middleware-user-agent": "3.957.0", "@aws-sdk/types": "3.957.0", "@smithy/node-config-provider": "^4.3.7", "@smithy/types": "^4.11.0", "tslib": "^2.6.2" }, "peerDependencies": { "aws-crt": ">=1.0.0" }, "optionalPeers": ["aws-crt"] }, "sha512-ycbYCwqXk4gJGp0Oxkzf2KBeeGBdTxz559D41NJP8FlzSej1Gh7Rk40Zo6AyTfsNWkrl/kVi1t937OIzC5t+9Q=="], 345 345 + 346 346 + "@aws-sdk/xml-builder": ["@aws-sdk/xml-builder@3.957.0", "", { "dependencies": { "@smithy/types": "^4.11.0", "fast-xml-parser": "5.2.5", "tslib": "^2.6.2" } }, "sha512-Ai5iiQqS8kJ5PjzMhWcLKN0G2yasAkvpnPlq2EnqlIMdB48HsizElt62qcktdxp4neRMyGkFq4NzgmDbXnhRiA=="], 347 347 + 348 348 + "@aws/lambda-invoke-store": ["@aws/lambda-invoke-store@0.2.2", "", {}, "sha512-C0NBLsIqzDIae8HFw9YIrIBsbc0xTiOtt7fAukGPnqQ/+zZNaq+4jhuccltK0QuWHBnNm/a6kLIRA6GFiM10eg=="], 349 349 + 262 350 "@badrap/valita": ["@badrap/valita@0.4.6", "", {}, "sha512-4kdqcjyxo/8RQ8ayjms47HCWZIF5981oE5nIenbfThKDxWXtEHKipAOWlflpPJzZx9y/JWYQkp18Awr7VuepFg=="], 263 351 264 352 "@borewit/text-codec": ["@borewit/text-codec@0.1.1", "", {}, "sha512-5L/uBxmjaCIX5h8Z+uu+kA9BQLkc/Wl06UGR5ajNRxu+/XjonB5i8JpgFMrPj3LXTCPA0pv8yxUvbUi+QthGGA=="], ··· 541 629 542 630 "@sinclair/typebox": ["@sinclair/typebox@0.34.41", "", {}, "sha512-6gS8pZzSXdyRHTIqoqSVknxolr1kzfy4/CeDnrzsVz8TTIWUbOBr6gnzOmTYJ3eXQNh4IYHIGi5aIL7sOZ2G/g=="], 543 631 632 632 + "@smithy/abort-controller": ["@smithy/abort-controller@4.2.7", "", { "dependencies": { "@smithy/types": "^4.11.0", "tslib": "^2.6.2" } }, "sha512-rzMY6CaKx2qxrbYbqjXWS0plqEy7LOdKHS0bg4ixJ6aoGDPNUcLWk/FRNuCILh7GKLG9TFUXYYeQQldMBBwuyw=="], 633 633 + 634 634 + "@smithy/chunked-blob-reader": ["@smithy/chunked-blob-reader@5.2.0", "", { "dependencies": { "tslib": "^2.6.2" } }, "sha512-WmU0TnhEAJLWvfSeMxBNe5xtbselEO8+4wG0NtZeL8oR21WgH1xiO37El+/Y+H/Ie4SCwBy3MxYWmOYaGgZueA=="], 635 635 + 636 636 + "@smithy/chunked-blob-reader-native": ["@smithy/chunked-blob-reader-native@4.2.1", "", { "dependencies": { "@smithy/util-base64": "^4.3.0", "tslib": "^2.6.2" } }, "sha512-lX9Ay+6LisTfpLid2zZtIhSEjHMZoAR5hHCR4H7tBz/Zkfr5ea8RcQ7Tk4mi0P76p4cN+Btz16Ffno7YHpKXnQ=="], 637 637 + 638 638 + "@smithy/config-resolver": ["@smithy/config-resolver@4.4.5", "", { "dependencies": { "@smithy/node-config-provider": "^4.3.7", "@smithy/types": "^4.11.0", "@smithy/util-config-provider": "^4.2.0", "@smithy/util-endpoints": "^3.2.7", "@smithy/util-middleware": "^4.2.7", "tslib": "^2.6.2" } }, "sha512-HAGoUAFYsUkoSckuKbCPayECeMim8pOu+yLy1zOxt1sifzEbrsRpYa+mKcMdiHKMeiqOibyPG0sFJnmaV/OGEg=="], 639 639 + 640 640 + "@smithy/core": ["@smithy/core@3.20.0", "", { "dependencies": { "@smithy/middleware-serde": "^4.2.8", "@smithy/protocol-http": "^5.3.7", "@smithy/types": "^4.11.0", "@smithy/util-base64": "^4.3.0", "@smithy/util-body-length-browser": "^4.2.0", "@smithy/util-middleware": "^4.2.7", "@smithy/util-stream": "^4.5.8", "@smithy/util-utf8": "^4.2.0", "@smithy/uuid": "^1.1.0", "tslib": "^2.6.2" } }, "sha512-WsSHCPq/neD5G/MkK4csLI5Y5Pkd9c1NMfpYEKeghSGaD4Ja1qLIohRQf2D5c1Uy5aXp76DeKHkzWZ9KAlHroQ=="], 641 641 + 642 642 + "@smithy/credential-provider-imds": ["@smithy/credential-provider-imds@4.2.7", "", { "dependencies": { "@smithy/node-config-provider": "^4.3.7", "@smithy/property-provider": "^4.2.7", "@smithy/types": "^4.11.0", "@smithy/url-parser": "^4.2.7", "tslib": "^2.6.2" } }, "sha512-CmduWdCiILCRNbQWFR0OcZlUPVtyE49Sr8yYL0rZQ4D/wKxiNzBNS/YHemvnbkIWj623fplgkexUd/c9CAKdoA=="], 643 643 + 644 644 + "@smithy/eventstream-codec": ["@smithy/eventstream-codec@4.2.7", "", { "dependencies": { "@aws-crypto/crc32": "5.2.0", "@smithy/types": "^4.11.0", "@smithy/util-hex-encoding": "^4.2.0", "tslib": "^2.6.2" } }, "sha512-DrpkEoM3j9cBBWhufqBwnbbn+3nf1N9FP6xuVJ+e220jbactKuQgaZwjwP5CP1t+O94brm2JgVMD2atMGX3xIQ=="], 645 645 + 646 646 + "@smithy/eventstream-serde-browser": ["@smithy/eventstream-serde-browser@4.2.7", "", { "dependencies": { "@smithy/eventstream-serde-universal": "^4.2.7", "@smithy/types": "^4.11.0", "tslib": "^2.6.2" } }, "sha512-ujzPk8seYoDBmABDE5YqlhQZAXLOrtxtJLrbhHMKjBoG5b4dK4i6/mEU+6/7yXIAkqOO8sJ6YxZl+h0QQ1IJ7g=="], 647 647 + 648 648 + "@smithy/eventstream-serde-config-resolver": ["@smithy/eventstream-serde-config-resolver@4.3.7", "", { "dependencies": { "@smithy/types": "^4.11.0", "tslib": "^2.6.2" } }, "sha512-x7BtAiIPSaNaWuzm24Q/mtSkv+BrISO/fmheiJ39PKRNH3RmH2Hph/bUKSOBOBC9unqfIYDhKTHwpyZycLGPVQ=="], 649 649 + 650 650 + "@smithy/eventstream-serde-node": ["@smithy/eventstream-serde-node@4.2.7", "", { "dependencies": { "@smithy/eventstream-serde-universal": "^4.2.7", "@smithy/types": "^4.11.0", "tslib": "^2.6.2" } }, "sha512-roySCtHC5+pQq5lK4be1fZ/WR6s/AxnPaLfCODIPArtN2du8s5Ot4mKVK3pPtijL/L654ws592JHJ1PbZFF6+A=="], 651 651 + 652 652 + "@smithy/eventstream-serde-universal": ["@smithy/eventstream-serde-universal@4.2.7", "", { "dependencies": { "@smithy/eventstream-codec": "^4.2.7", "@smithy/types": "^4.11.0", "tslib": "^2.6.2" } }, "sha512-QVD+g3+icFkThoy4r8wVFZMsIP08taHVKjE6Jpmz8h5CgX/kk6pTODq5cht0OMtcapUx+xrPzUTQdA+TmO0m1g=="], 653 653 + 654 654 + "@smithy/fetch-http-handler": ["@smithy/fetch-http-handler@5.3.8", "", { "dependencies": { "@smithy/protocol-http": "^5.3.7", "@smithy/querystring-builder": "^4.2.7", "@smithy/types": "^4.11.0", "@smithy/util-base64": "^4.3.0", "tslib": "^2.6.2" } }, "sha512-h/Fi+o7mti4n8wx1SR6UHWLaakwHRx29sizvp8OOm7iqwKGFneT06GCSFhml6Bha5BT6ot5pj3CYZnCHhGC2Rg=="], 655 655 + 656 656 + "@smithy/hash-blob-browser": ["@smithy/hash-blob-browser@4.2.8", "", { "dependencies": { "@smithy/chunked-blob-reader": "^5.2.0", "@smithy/chunked-blob-reader-native": "^4.2.1", "@smithy/types": "^4.11.0", "tslib": "^2.6.2" } }, "sha512-07InZontqsM1ggTCPSRgI7d8DirqRrnpL7nIACT4PW0AWrgDiHhjGZzbAE5UtRSiU0NISGUYe7/rri9ZeWyDpw=="], 657 657 + 658 658 + "@smithy/hash-node": ["@smithy/hash-node@4.2.7", "", { "dependencies": { "@smithy/types": "^4.11.0", "@smithy/util-buffer-from": "^4.2.0", "@smithy/util-utf8": "^4.2.0", "tslib": "^2.6.2" } }, "sha512-PU/JWLTBCV1c8FtB8tEFnY4eV1tSfBc7bDBADHfn1K+uRbPgSJ9jnJp0hyjiFN2PMdPzxsf1Fdu0eo9fJ760Xw=="], 659 659 + 660 660 + "@smithy/hash-stream-node": ["@smithy/hash-stream-node@4.2.7", "", { "dependencies": { "@smithy/types": "^4.11.0", "@smithy/util-utf8": "^4.2.0", "tslib": "^2.6.2" } }, "sha512-ZQVoAwNYnFMIbd4DUc517HuwNelJUY6YOzwqrbcAgCnVn+79/OK7UjwA93SPpdTOpKDVkLIzavWm/Ck7SmnDPQ=="], 661 661 + 662 662 + "@smithy/invalid-dependency": ["@smithy/invalid-dependency@4.2.7", "", { "dependencies": { "@smithy/types": "^4.11.0", "tslib": "^2.6.2" } }, "sha512-ncvgCr9a15nPlkhIUx3CU4d7E7WEuVJOV7fS7nnK2hLtPK9tYRBkMHQbhXU1VvvKeBm/O0x26OEoBq+ngFpOEQ=="], 663 663 + 664 664 + "@smithy/is-array-buffer": ["@smithy/is-array-buffer@4.2.0", "", { "dependencies": { "tslib": "^2.6.2" } }, "sha512-DZZZBvC7sjcYh4MazJSGiWMI2L7E0oCiRHREDzIxi/M2LY79/21iXt6aPLHge82wi5LsuRF5A06Ds3+0mlh6CQ=="], 665 665 + 666 666 + "@smithy/md5-js": ["@smithy/md5-js@4.2.7", "", { "dependencies": { "@smithy/types": "^4.11.0", "@smithy/util-utf8": "^4.2.0", "tslib": "^2.6.2" } }, "sha512-Wv6JcUxtOLTnxvNjDnAiATUsk8gvA6EeS8zzHig07dotpByYsLot+m0AaQEniUBjx97AC41MQR4hW0baraD1Xw=="], 667 667 + 668 668 + "@smithy/middleware-content-length": ["@smithy/middleware-content-length@4.2.7", "", { "dependencies": { "@smithy/protocol-http": "^5.3.7", "@smithy/types": "^4.11.0", "tslib": "^2.6.2" } }, "sha512-GszfBfCcvt7kIbJ41LuNa5f0wvQCHhnGx/aDaZJCCT05Ld6x6U2s0xsc/0mBFONBZjQJp2U/0uSJ178OXOwbhg=="], 669 669 + 670 670 + "@smithy/middleware-endpoint": ["@smithy/middleware-endpoint@4.4.1", "", { "dependencies": { "@smithy/core": "^3.20.0", "@smithy/middleware-serde": "^4.2.8", "@smithy/node-config-provider": "^4.3.7", "@smithy/shared-ini-file-loader": "^4.4.2", "@smithy/types": "^4.11.0", "@smithy/url-parser": "^4.2.7", "@smithy/util-middleware": "^4.2.7", "tslib": "^2.6.2" } }, "sha512-gpLspUAoe6f1M6H0u4cVuFzxZBrsGZmjx2O9SigurTx4PbntYa4AJ+o0G0oGm1L2oSX6oBhcGHwrfJHup2JnJg=="], 671 671 + 672 672 + "@smithy/middleware-retry": ["@smithy/middleware-retry@4.4.17", "", { "dependencies": { "@smithy/node-config-provider": "^4.3.7", "@smithy/protocol-http": "^5.3.7", "@smithy/service-error-classification": "^4.2.7", "@smithy/smithy-client": "^4.10.2", "@smithy/types": "^4.11.0", "@smithy/util-middleware": "^4.2.7", "@smithy/util-retry": "^4.2.7", "@smithy/uuid": "^1.1.0", "tslib": "^2.6.2" } }, "sha512-MqbXK6Y9uq17h+4r0ogu/sBT6V/rdV+5NvYL7ZV444BKfQygYe8wAhDrVXagVebN6w2RE0Fm245l69mOsPGZzg=="], 673 673 + 674 674 + "@smithy/middleware-serde": ["@smithy/middleware-serde@4.2.8", "", { "dependencies": { "@smithy/protocol-http": "^5.3.7", "@smithy/types": "^4.11.0", "tslib": "^2.6.2" } }, "sha512-8rDGYen5m5+NV9eHv9ry0sqm2gI6W7mc1VSFMtn6Igo25S507/HaOX9LTHAS2/J32VXD0xSzrY0H5FJtOMS4/w=="], 675 675 + 676 676 + "@smithy/middleware-stack": ["@smithy/middleware-stack@4.2.7", "", { "dependencies": { "@smithy/types": "^4.11.0", "tslib": "^2.6.2" } }, "sha512-bsOT0rJ+HHlZd9crHoS37mt8qRRN/h9jRve1SXUhVbkRzu0QaNYZp1i1jha4n098tsvROjcwfLlfvcFuJSXEsw=="], 677 677 + 678 678 + "@smithy/node-config-provider": ["@smithy/node-config-provider@4.3.7", "", { "dependencies": { "@smithy/property-provider": "^4.2.7", "@smithy/shared-ini-file-loader": "^4.4.2", "@smithy/types": "^4.11.0", "tslib": "^2.6.2" } }, "sha512-7r58wq8sdOcrwWe+klL9y3bc4GW1gnlfnFOuL7CXa7UzfhzhxKuzNdtqgzmTV+53lEp9NXh5hY/S4UgjLOzPfw=="], 679 679 + 680 680 + "@smithy/node-http-handler": ["@smithy/node-http-handler@4.4.7", "", { "dependencies": { "@smithy/abort-controller": "^4.2.7", "@smithy/protocol-http": "^5.3.7", "@smithy/querystring-builder": "^4.2.7", "@smithy/types": "^4.11.0", "tslib": "^2.6.2" } }, "sha512-NELpdmBOO6EpZtWgQiHjoShs1kmweaiNuETUpuup+cmm/xJYjT4eUjfhrXRP4jCOaAsS3c3yPsP3B+K+/fyPCQ=="], 681 681 + 682 682 + "@smithy/property-provider": ["@smithy/property-provider@4.2.7", "", { "dependencies": { "@smithy/types": "^4.11.0", "tslib": "^2.6.2" } }, "sha512-jmNYKe9MGGPoSl/D7JDDs1C8b3dC8f/w78LbaVfoTtWy4xAd5dfjaFG9c9PWPihY4ggMQNQSMtzU77CNgAJwmA=="], 683 683 + 684 684 + "@smithy/protocol-http": ["@smithy/protocol-http@5.3.7", "", { "dependencies": { "@smithy/types": "^4.11.0", "tslib": "^2.6.2" } }, "sha512-1r07pb994I20dD/c2seaZhoCuNYm0rWrvBxhCQ70brNh11M5Ml2ew6qJVo0lclB3jMIXirD4s2XRXRe7QEi0xA=="], 685 685 + 686 686 + "@smithy/querystring-builder": ["@smithy/querystring-builder@4.2.7", "", { "dependencies": { "@smithy/types": "^4.11.0", "@smithy/util-uri-escape": "^4.2.0", "tslib": "^2.6.2" } }, "sha512-eKONSywHZxK4tBxe2lXEysh8wbBdvDWiA+RIuaxZSgCMmA0zMgoDpGLJhnyj+c0leOQprVnXOmcB4m+W9Rw7sg=="], 687 687 + 688 688 + "@smithy/querystring-parser": ["@smithy/querystring-parser@4.2.7", "", { "dependencies": { "@smithy/types": "^4.11.0", "tslib": "^2.6.2" } }, "sha512-3X5ZvzUHmlSTHAXFlswrS6EGt8fMSIxX/c3Rm1Pni3+wYWB6cjGocmRIoqcQF9nU5OgGmL0u7l9m44tSUpfj9w=="], 689 689 + 690 690 + "@smithy/service-error-classification": ["@smithy/service-error-classification@4.2.7", "", { "dependencies": { "@smithy/types": "^4.11.0" } }, "sha512-YB7oCbukqEb2Dlh3340/8g8vNGbs/QsNNRms+gv3N2AtZz9/1vSBx6/6tpwQpZMEJFs7Uq8h4mmOn48ZZ72MkA=="], 691 691 + 692 692 + "@smithy/shared-ini-file-loader": ["@smithy/shared-ini-file-loader@4.4.2", "", { "dependencies": { "@smithy/types": "^4.11.0", "tslib": "^2.6.2" } }, "sha512-M7iUUff/KwfNunmrgtqBfvZSzh3bmFgv/j/t1Y1dQ+8dNo34br1cqVEqy6v0mYEgi0DkGO7Xig0AnuOaEGVlcg=="], 693 693 + 694 694 + "@smithy/signature-v4": ["@smithy/signature-v4@5.3.7", "", { "dependencies": { "@smithy/is-array-buffer": "^4.2.0", "@smithy/protocol-http": "^5.3.7", "@smithy/types": "^4.11.0", "@smithy/util-hex-encoding": "^4.2.0", "@smithy/util-middleware": "^4.2.7", "@smithy/util-uri-escape": "^4.2.0", "@smithy/util-utf8": "^4.2.0", "tslib": "^2.6.2" } }, "sha512-9oNUlqBlFZFOSdxgImA6X5GFuzE7V2H7VG/7E70cdLhidFbdtvxxt81EHgykGK5vq5D3FafH//X+Oy31j3CKOg=="], 695 695 + 696 696 + "@smithy/smithy-client": ["@smithy/smithy-client@4.10.2", "", { "dependencies": { "@smithy/core": "^3.20.0", "@smithy/middleware-endpoint": "^4.4.1", "@smithy/middleware-stack": "^4.2.7", "@smithy/protocol-http": "^5.3.7", "@smithy/types": "^4.11.0", "@smithy/util-stream": "^4.5.8", "tslib": "^2.6.2" } }, "sha512-D5z79xQWpgrGpAHb054Fn2CCTQZpog7JELbVQ6XAvXs5MNKWf28U9gzSBlJkOyMl9LA1TZEjRtwvGXfP0Sl90g=="], 697 697 + 698 698 + "@smithy/types": ["@smithy/types@4.11.0", "", { "dependencies": { "tslib": "^2.6.2" } }, "sha512-mlrmL0DRDVe3mNrjTcVcZEgkFmufITfUAPBEA+AHYiIeYyJebso/He1qLbP3PssRe22KUzLRpQSdBPbXdgZ2VA=="], 699 699 + 700 700 + "@smithy/url-parser": ["@smithy/url-parser@4.2.7", "", { "dependencies": { "@smithy/querystring-parser": "^4.2.7", "@smithy/types": "^4.11.0", "tslib": "^2.6.2" } }, "sha512-/RLtVsRV4uY3qPWhBDsjwahAtt3x2IsMGnP5W1b2VZIe+qgCqkLxI1UOHDZp1Q1QSOrdOR32MF3Ph2JfWT1VHg=="], 701 701 + 702 702 + "@smithy/util-base64": ["@smithy/util-base64@4.3.0", "", { "dependencies": { "@smithy/util-buffer-from": "^4.2.0", "@smithy/util-utf8": "^4.2.0", "tslib": "^2.6.2" } }, "sha512-GkXZ59JfyxsIwNTWFnjmFEI8kZpRNIBfxKjv09+nkAWPt/4aGaEWMM04m4sxgNVWkbt2MdSvE3KF/PfX4nFedQ=="], 703 703 + 704 704 + "@smithy/util-body-length-browser": ["@smithy/util-body-length-browser@4.2.0", "", { "dependencies": { "tslib": "^2.6.2" } }, "sha512-Fkoh/I76szMKJnBXWPdFkQJl2r9SjPt3cMzLdOB6eJ4Pnpas8hVoWPYemX/peO0yrrvldgCUVJqOAjUrOLjbxg=="], 705 705 + 706 706 + "@smithy/util-body-length-node": ["@smithy/util-body-length-node@4.2.1", "", { "dependencies": { "tslib": "^2.6.2" } }, "sha512-h53dz/pISVrVrfxV1iqXlx5pRg3V2YWFcSQyPyXZRrZoZj4R4DeWRDo1a7dd3CPTcFi3kE+98tuNyD2axyZReA=="], 707 707 + 708 708 + "@smithy/util-buffer-from": ["@smithy/util-buffer-from@4.2.0", "", { "dependencies": { "@smithy/is-array-buffer": "^4.2.0", "tslib": "^2.6.2" } }, "sha512-kAY9hTKulTNevM2nlRtxAG2FQ3B2OR6QIrPY3zE5LqJy1oxzmgBGsHLWTcNhWXKchgA0WHW+mZkQrng/pgcCew=="], 709 709 + 710 710 + "@smithy/util-config-provider": ["@smithy/util-config-provider@4.2.0", "", { "dependencies": { "tslib": "^2.6.2" } }, "sha512-YEjpl6XJ36FTKmD+kRJJWYvrHeUvm5ykaUS5xK+6oXffQPHeEM4/nXlZPe+Wu0lsgRUcNZiliYNh/y7q9c2y6Q=="], 711 711 + 712 712 + "@smithy/util-defaults-mode-browser": ["@smithy/util-defaults-mode-browser@4.3.16", "", { "dependencies": { "@smithy/property-provider": "^4.2.7", "@smithy/smithy-client": "^4.10.2", "@smithy/types": "^4.11.0", "tslib": "^2.6.2" } }, "sha512-/eiSP3mzY3TsvUOYMeL4EqUX6fgUOj2eUOU4rMMgVbq67TiRLyxT7Xsjxq0bW3OwuzK009qOwF0L2OgJqperAQ=="], 713 713 + 714 714 + "@smithy/util-defaults-mode-node": ["@smithy/util-defaults-mode-node@4.2.19", "", { "dependencies": { "@smithy/config-resolver": "^4.4.5", "@smithy/credential-provider-imds": "^4.2.7", "@smithy/node-config-provider": "^4.3.7", "@smithy/property-provider": "^4.2.7", "@smithy/smithy-client": "^4.10.2", "@smithy/types": "^4.11.0", "tslib": "^2.6.2" } }, "sha512-3a4+4mhf6VycEJyHIQLypRbiwG6aJvbQAeRAVXydMmfweEPnLLabRbdyo/Pjw8Rew9vjsh5WCdhmDaHkQnhhhA=="], 715 715 + 716 716 + "@smithy/util-endpoints": ["@smithy/util-endpoints@3.2.7", "", { "dependencies": { "@smithy/node-config-provider": "^4.3.7", "@smithy/types": "^4.11.0", "tslib": "^2.6.2" } }, "sha512-s4ILhyAvVqhMDYREeTS68R43B1V5aenV5q/V1QpRQJkCXib5BPRo4s7uNdzGtIKxaPHCfU/8YkvPAEvTpxgspg=="], 717 717 + 718 718 + "@smithy/util-hex-encoding": ["@smithy/util-hex-encoding@4.2.0", "", { "dependencies": { "tslib": "^2.6.2" } }, "sha512-CCQBwJIvXMLKxVbO88IukazJD9a4kQ9ZN7/UMGBjBcJYvatpWk+9g870El4cB8/EJxfe+k+y0GmR9CAzkF+Nbw=="], 719 719 + 720 720 + "@smithy/util-middleware": ["@smithy/util-middleware@4.2.7", "", { "dependencies": { "@smithy/types": "^4.11.0", "tslib": "^2.6.2" } }, "sha512-i1IkpbOae6NvIKsEeLLM9/2q4X+M90KV3oCFgWQI4q0Qz+yUZvsr+gZPdAEAtFhWQhAHpTsJO8DRJPuwVyln+w=="], 721 721 + 722 722 + "@smithy/util-retry": ["@smithy/util-retry@4.2.7", "", { "dependencies": { "@smithy/service-error-classification": "^4.2.7", "@smithy/types": "^4.11.0", "tslib": "^2.6.2" } }, "sha512-SvDdsQyF5CIASa4EYVT02LukPHVzAgUA4kMAuZ97QJc2BpAqZfA4PINB8/KOoCXEw9tsuv/jQjMeaHFvxdLNGg=="], 723 723 + 724 724 + "@smithy/util-stream": ["@smithy/util-stream@4.5.8", "", { "dependencies": { "@smithy/fetch-http-handler": "^5.3.8", "@smithy/node-http-handler": "^4.4.7", "@smithy/types": "^4.11.0", "@smithy/util-base64": "^4.3.0", "@smithy/util-buffer-from": "^4.2.0", "@smithy/util-hex-encoding": "^4.2.0", "@smithy/util-utf8": "^4.2.0", "tslib": "^2.6.2" } }, "sha512-ZnnBhTapjM0YPGUSmOs0Mcg/Gg87k503qG4zU2v/+Js2Gu+daKOJMeqcQns8ajepY8tgzzfYxl6kQyZKml6O2w=="], 725 725 + 726 726 + "@smithy/util-uri-escape": ["@smithy/util-uri-escape@4.2.0", "", { "dependencies": { "tslib": "^2.6.2" } }, "sha512-igZpCKV9+E/Mzrpq6YacdTQ0qTiLm85gD6N/IrmyDvQFA4UnU3d5g3m8tMT/6zG/vVkWSU+VxeUyGonL62DuxA=="], 727 727 + 728 728 + "@smithy/util-utf8": ["@smithy/util-utf8@4.2.0", "", { "dependencies": { "@smithy/util-buffer-from": "^4.2.0", "tslib": "^2.6.2" } }, "sha512-zBPfuzoI8xyBtR2P6WQj63Rz8i3AmfAaJLuNG8dWsfvPe8lO4aCPYLn879mEgHndZH1zQ2oXmG8O1GGzzaoZiw=="], 729 729 + 730 730 + "@smithy/util-waiter": ["@smithy/util-waiter@4.2.7", "", { "dependencies": { "@smithy/abort-controller": "^4.2.7", "@smithy/types": "^4.11.0", "tslib": "^2.6.2" } }, "sha512-vHJFXi9b7kUEpHWUCY3Twl+9NPOZvQ0SAi+Ewtn48mbiJk4JY9MZmKQjGB4SCvVb9WPiSphZJYY6RIbs+grrzw=="], 731 731 + 732 732 + "@smithy/uuid": ["@smithy/uuid@1.1.0", "", { "dependencies": { "tslib": "^2.6.2" } }, "sha512-4aUIteuyxtBUhVdiQqcDhKFitwfd9hqoSDYY2KRXiWtgoWJ9Bmise+KfEPDiVHWeJepvF8xJO9/9+WDIciMFFw=="], 733 733 + 544 734 "@standard-schema/spec": ["@standard-schema/spec@1.0.0", "", {}, "sha512-m2bOd0f2RT9k8QJx1JN85cZYyH1RqFBdlwtkSlf4tBDYLCiiZnv1fIIwacK6cqwXavOydf0NPToMQgpKq+dVlA=="], 545 735 546 736 "@tailwindcss/cli": ["@tailwindcss/cli@4.1.17", "", { "dependencies": { "@parcel/watcher": "^2.5.1", "@tailwindcss/node": "4.1.17", "@tailwindcss/oxide": "4.1.17", "enhanced-resolve": "^5.18.3", "mri": "^1.2.0", "picocolors": "^1.1.1", "tailwindcss": "4.1.17" }, "bin": { "tailwindcss": "dist/index.mjs" } }, "sha512-jUIxcyUNlCC2aNPnyPEWU/L2/ik3pB4fF3auKGXr8AvN3T3OFESVctFKOBoPZQaZJIeUpPn1uCLp0MRxuek8gg=="], ··· 583 773 584 774 "@ts-morph/common": ["@ts-morph/common@0.25.0", "", { "dependencies": { "minimatch": "^9.0.4", "path-browserify": "^1.0.1", "tinyglobby": "^0.2.9" } }, "sha512-kMnZz+vGGHi4GoHnLmMhGNjm44kGtKUXGnOvrKmMwAuvNjM/PgKVGfUnL7IDvK7Jb2QQ82jq3Zmp04Gy+r3Dkg=="], 585 775 586 586 - "@types/bun": ["@types/bun@1.3.3", "", { "dependencies": { "bun-types": "1.3.3" } }, "sha512-ogrKbJ2X5N0kWLLFKeytG0eHDleBYtngtlbu9cyBKFtNL3cnpDZkNdQj8flVf6WTZUX5ulI9AY1oa7ljhSrp+g=="], 776 776 + "@types/bun": ["@types/bun@1.3.5", "", { "dependencies": { "bun-types": "1.3.5" } }, "sha512-RnygCqNrd3srIPEWBd5LFeUYG7plCoH2Yw9WaZGyNmdTEei+gWaHqydbaIRkIkcbXwhBT94q78QljxN0Sk838w=="], 587 777 588 778 "@types/mime-types": ["@types/mime-types@2.1.4", "", {}, "sha512-lfU4b34HOri+kAY5UheuFMWPDOI+OPceBSHZKp69gEyTL/mmJ4cnU6Y/rlme3UL3GyOn6Y42hyIEw0/q8sWx5w=="], 589 779 ··· 641 831 642 832 "body-parser": ["body-parser@1.20.4", "", { "dependencies": { "bytes": "~3.1.2", "content-type": "~1.0.5", "debug": "2.6.9", "depd": "2.0.0", "destroy": "~1.2.0", "http-errors": "~2.0.1", "iconv-lite": "~0.4.24", "on-finished": "~2.4.1", "qs": "~6.14.0", "raw-body": "~2.5.3", "type-is": "~1.6.18", "unpipe": "~1.0.0" } }, "sha512-ZTgYYLMOXY9qKU/57FAo8F+HA2dGX7bqGc71txDRC1rS4frdFI5R7NhluHxH6M0YItAP0sHB4uqAOcYKxO6uGA=="], 643 833 834 834 + "bowser": ["bowser@2.13.1", "", {}, "sha512-OHawaAbjwx6rqICCKgSG0SAnT05bzd7ppyKLVUITZpANBaaMFBAsaNkto3LoQ31tyFP5kNujE8Cdx85G9VzOkw=="], 835 835 + 644 836 "brace-expansion": ["brace-expansion@2.0.2", "", { "dependencies": { "balanced-match": "^1.0.0" } }, "sha512-Jt0vHyM+jmUBqojB7E1NIYadt0vI0Qxjxd2TErW94wDz+E2LAm5vKMXXwg6ZZBTHPuUlDgQHKXvjGBdfcF1ZDQ=="], 645 837 646 838 "braces": ["braces@3.0.3", "", { "dependencies": { "fill-range": "^7.1.1" } }, "sha512-yQbXgO/OSZVD2IsiLlro+7Hf6Q18EJrKSEsdoMzKePKXct3gvD8oLcOQdIzGupr5Fj+EDe8gO/lxc1BzfMpxvA=="], 647 839 648 648 - "buffer": ["buffer@6.0.3", "", { "dependencies": { "base64-js": "^1.3.1", "ieee754": "^1.2.1" } }, "sha512-FTiCpNxtwiZZHEZbcbTIcZjERVICn9yq/pDFkTl95/AxzD1naBctN7YO68riM/gLSDY7sdrMby8hofADYuuqOA=="], 840 840 + "buffer": ["buffer@5.6.0", "", { "dependencies": { "base64-js": "^1.0.2", "ieee754": "^1.1.4" } }, "sha512-/gDYp/UtU0eA1ys8bOs9J6a+E/KWIY+DZ+Q2WESNUA0jFRsJOc0SNUO6xJ5SGA1xueg3NL65W6s+NY5l9cunuw=="], 649 841 650 842 "bun": ["bun@1.3.3", "", { "optionalDependencies": { "@oven/bun-darwin-aarch64": "1.3.3", "@oven/bun-darwin-x64": "1.3.3", "@oven/bun-darwin-x64-baseline": "1.3.3", "@oven/bun-linux-aarch64": "1.3.3", "@oven/bun-linux-aarch64-musl": "1.3.3", "@oven/bun-linux-x64": "1.3.3", "@oven/bun-linux-x64-baseline": "1.3.3", "@oven/bun-linux-x64-musl": "1.3.3", "@oven/bun-linux-x64-musl-baseline": "1.3.3", "@oven/bun-windows-x64": "1.3.3", "@oven/bun-windows-x64-baseline": "1.3.3" }, "os": [ "linux", "win32", "darwin", ], "cpu": [ "x64", "arm64", ], "bin": { "bun": "bin/bun.exe", "bunx": "bin/bunx.exe" } }, "sha512-2hJ4ocTZ634/Ptph4lysvO+LbbRZq8fzRvMwX0/CqaLBxrF2UB5D1LdMB8qGcdtCer4/VR9Bx5ORub0yn+yzmw=="], 651 843 ··· 746 938 "fast-decode-uri-component": ["fast-decode-uri-component@1.0.1", "", {}, "sha512-WKgKWg5eUxvRZGwW8FvfbaH7AXSh2cL+3j5fMGzUMCxWBJ3dV3a7Wz8y2f/uQ0e3B6WmodD3oS54jTQ9HVTIIg=="], 747 939 748 940 "fast-redact": ["fast-redact@3.5.0", "", {}, "sha512-dwsoQlS7h9hMeYUq1W++23NDcBLV4KqONnITDV9DjfS3q1SgDGVrBdvvTLUotWtPSD7asWDV9/CmsZPy8Hf70A=="], 941 941 + 942 942 + "fast-xml-parser": ["fast-xml-parser@5.2.5", "", { "dependencies": { "strnum": "^2.1.0" }, "bin": { "fxparser": "src/cli/cli.js" } }, "sha512-pfX9uG9Ki0yekDHx2SiuRIyFdyAr1kMIMitPvb0YBo8SUfKvia7w7FIyd/l6av85pFYRhZscS75MwMnbvY+hcQ=="], 749 943 750 944 "fdir": ["fdir@6.5.0", "", { "peerDependencies": { "picomatch": "^3 || ^4" }, "optionalPeers": ["picomatch"] }, "sha512-tIbYtZbucOs0BRGqPJkshJUYdL+SDH7dVM8gjy+ERp3WAUjLEFJE+02kanyHtwjWOnwrKYBiwAmM0p4kLJAnXg=="], 751 945 ··· 957 1151 958 1152 "react-style-singleton": ["react-style-singleton@2.2.3", "", { "dependencies": { "get-nonce": "^1.0.0", "tslib": "^2.0.0" }, "peerDependencies": { "@types/react": "*", "react": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-b6jSvxvVnyptAiLjbkWLE/lOnR4lfTtDAl+eUC7RZy+QQWc6wRzIV2CE6xBuMmDxc2qIihtDCZD5NPOFl7fRBQ=="], 959 1153 960 960 - "readable-stream": ["readable-stream@4.7.0", "", { "dependencies": { "abort-controller": "^3.0.0", "buffer": "^6.0.3", "events": "^3.3.0", "process": "^0.11.10", "string_decoder": "^1.3.0" } }, "sha512-oIGGmcpTLwPga8Bn6/Z75SVaH1z5dUut2ibSyAMVhmUggWpmDn2dapB0n7f8nwaSiRtepAsfJyfXIO5DCVAODg=="], 1154 1154 + "readable-stream": ["readable-stream@3.6.2", "", { "dependencies": { "inherits": "^2.0.3", "string_decoder": "^1.1.1", "util-deprecate": "^1.0.1" } }, "sha512-9u/sniCrY3D5WdsERHzHE4G2YCXqoG5FTHUiCC4SIbr6XcLZBY05ya9EKjYek9O5xOAwjGq+1JdGBAS7Q9ScoA=="], 961 1155 962 1156 "real-require": ["real-require@0.2.0", "", {}, "sha512-57frrGM/OCTLqLOAh0mhVA9VBMHd+9U7Zb2THMGdBUoZVOtGbJzjxsYGDJ3A9AYYCP4hn6y1TVbaOfzWtm5GFg=="], 963 1157 ··· 1001 1195 1002 1196 "statuses": ["statuses@2.0.2", "", {}, "sha512-DvEy55V3DB7uknRo+4iOGT5fP1slR8wQohVdknigZPMpMstaKJQWhwiYBACJE3Ul2pTnATihhBYnRhZQHGBiRw=="], 1003 1197 1198 1198 + "stream-browserify": ["stream-browserify@3.0.0", "", { "dependencies": { "inherits": "~2.0.4", "readable-stream": "^3.5.0" } }, "sha512-H73RAHsVBapbim0tU2JwwOiXUj+fikfiaoYAKHF3VJfA0pe2BCzkhAHBlLG6REzE+2WNZcxOXjK7lkso+9euLA=="], 1199 1199 + 1004 1200 "string-width": ["string-width@4.2.3", "", { "dependencies": { "emoji-regex": "^8.0.0", "is-fullwidth-code-point": "^3.0.0", "strip-ansi": "^6.0.1" } }, "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g=="], 1005 1201 1006 1202 "string_decoder": ["string_decoder@1.3.0", "", { "dependencies": { "safe-buffer": "~5.2.0" } }, "sha512-hkRX8U1WjJFd8LsDJ2yQ/wWWxaopEsABU1XfkM8A+j0+85JAGppt16cr1Whg6KIbb4okU6Mql6BOj+uup/wKeA=="], 1007 1203 1008 1204 "strip-ansi": ["strip-ansi@6.0.1", "", { "dependencies": { "ansi-regex": "^5.0.1" } }, "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A=="], 1009 1205 1206 1206 + "strnum": ["strnum@2.1.2", "", {}, "sha512-l63NF9y/cLROq/yqKXSLtcMeeyOfnSQlfMSlzFt/K73oIaD8DGaQWd7Z34X9GPiKqP5rbSh84Hl4bOlLcjiSrQ=="], 1207 1207 + 1010 1208 "strtok3": ["strtok3@10.3.4", "", { "dependencies": { "@tokenizer/token": "^0.3.0" } }, "sha512-KIy5nylvC5le1OdaaoCJ07L+8iQzJHGH6pWDuzS+d07Cu7n1MZ2x26P8ZKIWfbK02+XIL8Mp4RkWeqdUCrDMfg=="], 1011 1209 1012 1210 "supports-color": ["supports-color@7.2.0", "", { "dependencies": { "has-flag": "^4.0.0" } }, "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw=="], ··· 1020 1218 "tapable": ["tapable@2.3.0", "", {}, "sha512-g9ljZiwki/LfxmQADO3dEY1CbpmXT5Hm2fJ+QaGKwSXUylMybePR7/67YW7jOrrvjEgL1Fmz5kzyAjWVWLlucg=="], 1021 1219 1022 1220 "thread-stream": ["thread-stream@2.7.0", "", { "dependencies": { "real-require": "^0.2.0" } }, "sha512-qQiRWsU/wvNolI6tbbCKd9iKaTnCXsTwVxhhKM6nctPdujTyztjlbUkUTUymidWcMnZ5pWR0ej4a0tjsW021vw=="], 1221 1221 + 1222 1222 + "tiered-storage": ["tiered-storage@1.0.3", "", { "dependencies": { "@aws-sdk/client-s3": "^3.500.0", "@aws-sdk/lib-storage": "^3.500.0", "hono": "^4.10.7", "mime-types": "^3.0.2", "tiny-lru": "^11.0.0" } }, "sha512-ntJCsWWYHSQWIDbObMfnJ8xw7cRSJCPzfbrjoY4hu0YIRizCthRWg8kCvJOgsgC+Upt259YHmfNwEr1wLv6Rxw=="], 1223 1223 + 1224 1224 + "tiny-lru": ["tiny-lru@11.4.5", "", {}, "sha512-hkcz3FjNJfKXjV4mjQ1OrXSLAehg8Hw+cEZclOVT+5c/cWQWImQ9wolzTjth+dmmDe++p3bme3fTxz6Q4Etsqw=="], 1023 1225 1024 1226 "tinyglobby": ["tinyglobby@0.2.15", "", { "dependencies": { "fdir": "^6.5.0", "picomatch": "^4.0.3" } }, "sha512-j2Zq4NyQYG5XMST4cbs02Ak8iJUdxRM0XI5QyxXuZOzKOINmWurp3smXu3y5wDcJrptwpSjgXHzIQxR0omXljQ=="], 1025 1227 ··· 1060 1262 "use-callback-ref": ["use-callback-ref@1.3.3", "", { "dependencies": { "tslib": "^2.0.0" }, "peerDependencies": { "@types/react": "*", "react": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-jQL3lRnocaFtu3V00JToYz/4QkNWswxijDaCVNZRiRTO3HQDLsdu1ZtmIUvV4yPp+rvWm5j0y0TG/S61cuijTg=="], 1061 1263 1062 1264 "use-sidecar": ["use-sidecar@1.1.3", "", { "dependencies": { "detect-node-es": "^1.1.0", "tslib": "^2.0.0" }, "peerDependencies": { "@types/react": "*", "react": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-Fedw0aZvkhynoPYlA5WXrMCAMm+nSWdZt6lzJQ7Ok8S6Q+VsHmHpRWndVRJ8Be0ZbkfPc5LRYH+5XrzXcEeLRQ=="], 1265 1265 + 1266 1266 + "util-deprecate": ["util-deprecate@1.0.2", "", {}, "sha512-EPD5q1uXyFxJpCrLnCc1nHnq3gOa6DZBocAIiI2TaSCA7VCJ1UJDMagCzIkXNsUYfD1daK//LTEQ8xiIbrHtcw=="], 1063 1267 1064 1268 "utils-merge": ["utils-merge@1.0.1", "", {}, "sha512-pMZTvIkT1d+TFGvDOqodOclx0QWkkgi6Tdoa8gC8ffGAAqz9pzPTZWAybbsHHoED/ztMtkv/VoYTYyShUn81hA=="], 1065 1269 ··· 1115 1319 1116 1320 "@atproto/sync/multiformats": ["multiformats@9.9.0", "", {}, "sha512-HoMUjhH9T8DDBNT+6xzkrd9ga/XiBI4xLr58LJACwK6G3HTOPeMz4nB4KJs33L2BelrIJa7P0VuNaVF3hMYfjg=="], 1117 1321 1322 1322 + "@aws-crypto/sha1-browser/@smithy/util-utf8": ["@smithy/util-utf8@2.3.0", "", { "dependencies": { "@smithy/util-buffer-from": "^2.2.0", "tslib": "^2.6.2" } }, "sha512-R8Rdn8Hy72KKcebgLiv8jQcQkXoLMOGGv5uI1/k0l+snqkOzQ1R0ChUBCxWMlBsFMekWjq0wRudIweFs7sKT5A=="], 1323 1323 + 1324 1324 + "@aws-crypto/sha256-browser/@smithy/util-utf8": ["@smithy/util-utf8@2.3.0", "", { "dependencies": { "@smithy/util-buffer-from": "^2.2.0", "tslib": "^2.6.2" } }, "sha512-R8Rdn8Hy72KKcebgLiv8jQcQkXoLMOGGv5uI1/k0l+snqkOzQ1R0ChUBCxWMlBsFMekWjq0wRudIweFs7sKT5A=="], 1325 1325 + 1326 1326 + "@aws-crypto/util/@smithy/util-utf8": ["@smithy/util-utf8@2.3.0", "", { "dependencies": { "@smithy/util-buffer-from": "^2.2.0", "tslib": "^2.6.2" } }, "sha512-R8Rdn8Hy72KKcebgLiv8jQcQkXoLMOGGv5uI1/k0l+snqkOzQ1R0ChUBCxWMlBsFMekWjq0wRudIweFs7sKT5A=="], 1327 1327 + 1118 1328 "@ipld/dag-cbor/multiformats": ["multiformats@9.9.0", "", {}, "sha512-HoMUjhH9T8DDBNT+6xzkrd9ga/XiBI4xLr58LJACwK6G3HTOPeMz4nB4KJs33L2BelrIJa7P0VuNaVF3hMYfjg=="], 1119 1329 1120 1330 "@opentelemetry/core/@opentelemetry/semantic-conventions": ["@opentelemetry/semantic-conventions@1.28.0", "", {}, "sha512-lp4qAiMTD4sNWW4DbKLBkfiMZ4jbAboJIGOQr5DvciMRI494OapieI9qiODpOt0XBr1LjIDy1xAGAnVs5supTA=="], ··· 1267 1477 1268 1478 "@tokenizer/inflate/debug": ["debug@4.4.3", "", { "dependencies": { "ms": "^2.1.3" } }, "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA=="], 1269 1479 1270 1270 - "@types/bun/bun-types": ["bun-types@1.3.3", "", { "dependencies": { "@types/node": "*" } }, "sha512-z3Xwlg7j2l9JY27x5Qn3Wlyos8YAp0kKRlrePAOjgjMGS5IG6E7Jnlx736vH9UVI4wUICwwhC9anYL++XeOgTQ=="], 1480 1480 + "@types/bun/bun-types": ["bun-types@1.3.5", "", { "dependencies": { "@types/node": "*" } }, "sha512-inmAYe2PFLs0SUbFOWSVD24sg1jFlMPxOjOSSCYqUgn4Hsc3rDc7dFvfVYjFPNHtov6kgUeulV4SxbuIV/stPw=="], 1271 1481 1272 1482 "@wisp/main-app/@atproto/api": ["@atproto/api@0.17.7", "", { "dependencies": { "@atproto/common-web": "^0.4.3", "@atproto/lexicon": "^0.5.1", "@atproto/syntax": "^0.4.1", "@atproto/xrpc": "^0.7.5", "await-lock": "^2.2.2", "multiformats": "^9.9.0", "tlds": "^1.234.0", "zod": "^3.23.8" } }, "sha512-V+OJBZq9chcrD21xk1bUa6oc5DSKfQj5DmUPf5rmZncqL1w9ZEbS38H5cMyqqdhfgo2LWeDRdZHD0rvNyJsIaw=="], 1483 1483 + 1484 1484 + "@wisp/observability/bun-types": ["bun-types@1.3.5", "", { "dependencies": { "@types/node": "*" } }, "sha512-inmAYe2PFLs0SUbFOWSVD24sg1jFlMPxOjOSSCYqUgn4Hsc3rDc7dFvfVYjFPNHtov6kgUeulV4SxbuIV/stPw=="], 1273 1485 1274 1486 "express/cookie": ["cookie@0.7.2", "", {}, "sha512-yki5XnKuf750l50uGTllt6kKILY4nQ1eNIQatoXEByZ5dWgnKqbnqmTrBE5B4N7lrMJKQ2ytWMiTO2o0v6Ew/w=="], 1275 1487 ··· 1279 1491 1280 1492 "node-gyp-build-optional-packages/detect-libc": ["detect-libc@2.1.2", "", {}, "sha512-Btj2BOOO83o3WyH59e8MgXsxEQVcarkUOpEYrubB0urwnN10yQ364rsiByU11nZlqWYZm05i/of7io4mzihBtQ=="], 1281 1493 1494 1494 + "pino-abstract-transport/readable-stream": ["readable-stream@4.7.0", "", { "dependencies": { "abort-controller": "^3.0.0", "buffer": "^6.0.3", "events": "^3.3.0", "process": "^0.11.10", "string_decoder": "^1.3.0" } }, "sha512-oIGGmcpTLwPga8Bn6/Z75SVaH1z5dUut2ibSyAMVhmUggWpmDn2dapB0n7f8nwaSiRtepAsfJyfXIO5DCVAODg=="], 1495 1495 + 1282 1496 "require-in-the-middle/debug": ["debug@4.4.3", "", { "dependencies": { "ms": "^2.1.3" } }, "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA=="], 1283 1497 1284 1498 "send/http-errors": ["http-errors@2.0.0", "", { "dependencies": { "depd": "2.0.0", "inherits": "2.0.4", "setprototypeof": "1.2.0", "statuses": "2.0.1", "toidentifier": "1.0.1" } }, "sha512-FtwrG/euBzaEjYeRqOgly7G0qviiXoJWnvEH2Z1plBdXgbyjv34pHTSb9zoeHMyDy33+DWy5Wt9Wo+TURtOYSQ=="], ··· 1288 1502 "send/statuses": ["statuses@2.0.1", "", {}, "sha512-RwNA9Z/7PrK06rYLIzFMlaF+l73iwpzsqRIFgbMLbTcLD6cOao82TaWefPXQvB2fOC4AjuYSEndS7N/mTCbkdQ=="], 1289 1503 1290 1504 "serve-static/send": ["send@0.19.0", "", { "dependencies": { "debug": "2.6.9", "depd": "2.0.0", "destroy": "1.2.0", "encodeurl": "~1.0.2", "escape-html": "~1.0.3", "etag": "~1.8.1", "fresh": "0.5.2", "http-errors": "2.0.0", "mime": "1.6.0", "ms": "2.1.3", "on-finished": "2.4.1", "range-parser": "~1.2.1", "statuses": "2.0.1" } }, "sha512-dW41u5VfLXu8SJh5bwRmyYUbAoSB3c9uQh6L8h/KtsFREPWpbX1lrljJo186Jc4nmci/sGUZ9a0a0J2zgfq2hw=="], 1505 1505 + 1506 1506 + "tiered-storage/mime-types": ["mime-types@3.0.2", "", { "dependencies": { "mime-db": "^1.54.0" } }, "sha512-Lbgzdk0h4juoQ9fCKXW4by0UJqj+nOOrI9MJ1sSj4nI8aI2eo1qmvQEie4VD1glsS250n15LsWsYtCugiStS5A=="], 1291 1507 1292 1508 "tinyglobby/picomatch": ["picomatch@4.0.3", "", {}, "sha512-5gTmgEY/sqK6gFXLIsQNH19lWb4ebPDLA4SdLP7dsWkIXHWlG66oPuVvXSGFPppYZz8ZDZq0dYYrbHfBCVUb1Q=="], 1293 1509 ··· 1301 1517 1302 1518 "@atproto/sync/@atproto/xrpc-server/@atproto/ws-client": ["@atproto/ws-client@0.0.3", "", { "dependencies": { "@atproto/common": "^0.5.0", "ws": "^8.12.0" } }, "sha512-eKqkTWBk6zuMY+6gs02eT7mS8Btewm8/qaL/Dp00NDCqpNC+U59MWvQsOWT3xkNGfd9Eip+V6VI4oyPvAfsfTA=="], 1303 1519 1520 1520 + "@aws-crypto/sha1-browser/@smithy/util-utf8/@smithy/util-buffer-from": ["@smithy/util-buffer-from@2.2.0", "", { "dependencies": { "@smithy/is-array-buffer": "^2.2.0", "tslib": "^2.6.2" } }, "sha512-IJdWBbTcMQ6DA0gdNhh/BwrLkDR+ADW5Kr1aZmd4k3DIF6ezMV4R2NIAmT08wQJ3yUK82thHWmC/TnK/wpMMIA=="], 1521 1521 + 1522 1522 + "@aws-crypto/sha256-browser/@smithy/util-utf8/@smithy/util-buffer-from": ["@smithy/util-buffer-from@2.2.0", "", { "dependencies": { "@smithy/is-array-buffer": "^2.2.0", "tslib": "^2.6.2" } }, "sha512-IJdWBbTcMQ6DA0gdNhh/BwrLkDR+ADW5Kr1aZmd4k3DIF6ezMV4R2NIAmT08wQJ3yUK82thHWmC/TnK/wpMMIA=="], 1523 1523 + 1524 1524 + "@aws-crypto/util/@smithy/util-utf8/@smithy/util-buffer-from": ["@smithy/util-buffer-from@2.2.0", "", { "dependencies": { "@smithy/is-array-buffer": "^2.2.0", "tslib": "^2.6.2" } }, "sha512-IJdWBbTcMQ6DA0gdNhh/BwrLkDR+ADW5Kr1aZmd4k3DIF6ezMV4R2NIAmT08wQJ3yUK82thHWmC/TnK/wpMMIA=="], 1525 1525 + 1304 1526 "@opentelemetry/exporter-logs-otlp-grpc/@opentelemetry/otlp-transformer/@opentelemetry/resources": ["@opentelemetry/resources@2.0.0", "", { "dependencies": { "@opentelemetry/core": "2.0.0", "@opentelemetry/semantic-conventions": "^1.29.0" }, "peerDependencies": { "@opentelemetry/api": ">=1.3.0 <1.10.0" } }, "sha512-rnZr6dML2z4IARI4zPGQV4arDikF/9OXZQzrC01dLmn0CZxU5U5OLd/m1T7YkGRj5UitjeoCtg/zorlgMQcdTg=="], 1305 1527 1306 1528 "@opentelemetry/exporter-logs-otlp-grpc/@opentelemetry/otlp-transformer/@opentelemetry/sdk-metrics": ["@opentelemetry/sdk-metrics@2.0.0", "", { "dependencies": { "@opentelemetry/core": "2.0.0", "@opentelemetry/resources": "2.0.0" }, "peerDependencies": { "@opentelemetry/api": ">=1.9.0 <1.10.0" } }, "sha512-Bvy8QDjO05umd0+j+gDeWcTaVa1/R2lDj/eOvjzpm8VQj1K1vVZJuyjThpV5/lSHyYW2JaHF2IQ7Z8twJFAhjA=="], ··· 1337 1559 1338 1560 "@wisp/main-app/@atproto/api/multiformats": ["multiformats@9.9.0", "", {}, "sha512-HoMUjhH9T8DDBNT+6xzkrd9ga/XiBI4xLr58LJACwK6G3HTOPeMz4nB4KJs33L2BelrIJa7P0VuNaVF3hMYfjg=="], 1339 1561 1562 1562 + "pino-abstract-transport/readable-stream/buffer": ["buffer@6.0.3", "", { "dependencies": { "base64-js": "^1.3.1", "ieee754": "^1.2.1" } }, "sha512-FTiCpNxtwiZZHEZbcbTIcZjERVICn9yq/pDFkTl95/AxzD1naBctN7YO68riM/gLSDY7sdrMby8hofADYuuqOA=="], 1563 1563 + 1340 1564 "require-in-the-middle/debug/ms": ["ms@2.1.3", "", {}, "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA=="], 1341 1565 1342 1566 "serve-static/send/encodeurl": ["encodeurl@1.0.2", "", {}, "sha512-TPJXq8JqFaVYm2CWmPvnP2Iyo4ZSM7/QKcSmuMLDObfpH5fi7RUGmd/rTDf+rut/saiDiQEeVTNgAmJEdAOx0w=="], ··· 1347 1571 1348 1572 "serve-static/send/statuses": ["statuses@2.0.1", "", {}, "sha512-RwNA9Z/7PrK06rYLIzFMlaF+l73iwpzsqRIFgbMLbTcLD6cOao82TaWefPXQvB2fOC4AjuYSEndS7N/mTCbkdQ=="], 1349 1573 1574 1574 + "tiered-storage/mime-types/mime-db": ["mime-db@1.54.0", "", {}, "sha512-aU5EJuIN2WDemCcAp2vFBfp/m4EAhWJnUNSSw0ixs7/kXbd6Pg64EmwJkNdFhB8aWt1sH2CTXrLxo/iAGV3oPQ=="], 1575 1575 + 1350 1576 "tsx/esbuild/@esbuild/aix-ppc64": ["@esbuild/aix-ppc64@0.27.1", "", { "os": "aix", "cpu": "ppc64" }, "sha512-HHB50pdsBX6k47S4u5g/CaLjqS3qwaOVE5ILsq64jyzgMhLuCuZ8rGzM9yhsAjfjkbgUPMzZEPa7DAp7yz6vuA=="], 1351 1577 1352 1578 "tsx/esbuild/@esbuild/android-arm": ["@esbuild/android-arm@0.27.1", "", { "os": "android", "cpu": "arm" }, "sha512-kFqa6/UcaTbGm/NncN9kzVOODjhZW8e+FRdSeypWe6j33gzclHtwlANs26JrupOntlcWmB0u8+8HZo8s7thHvg=="], ··· 1400 1626 "tsx/esbuild/@esbuild/win32-x64": ["@esbuild/win32-x64@0.27.1", "", { "os": "win32", "cpu": "x64" }, "sha512-d5X6RMYv6taIymSk8JBP+nxv8DQAMY6A51GPgusqLdK9wBz5wWIXy1KjTck6HnjE9hqJzJRdk+1p/t5soSbCtw=="], 1401 1627 1402 1628 "wisp-hosting-service/@atproto/api/multiformats": ["multiformats@9.9.0", "", {}, "sha512-HoMUjhH9T8DDBNT+6xzkrd9ga/XiBI4xLr58LJACwK6G3HTOPeMz4nB4KJs33L2BelrIJa7P0VuNaVF3hMYfjg=="], 1629 1629 + 1630 1630 + "@aws-crypto/sha1-browser/@smithy/util-utf8/@smithy/util-buffer-from/@smithy/is-array-buffer": ["@smithy/is-array-buffer@2.2.0", "", { "dependencies": { "tslib": "^2.6.2" } }, "sha512-GGP3O9QFD24uGeAXYUjwSTXARoqpZykHadOmA8G5vfJPK0/DC67qa//0qvqrJzL1xc8WQWX7/yc7fwudjPHPhA=="], 1631 1631 + 1632 1632 + "@aws-crypto/sha256-browser/@smithy/util-utf8/@smithy/util-buffer-from/@smithy/is-array-buffer": ["@smithy/is-array-buffer@2.2.0", "", { "dependencies": { "tslib": "^2.6.2" } }, "sha512-GGP3O9QFD24uGeAXYUjwSTXARoqpZykHadOmA8G5vfJPK0/DC67qa//0qvqrJzL1xc8WQWX7/yc7fwudjPHPhA=="], 1633 1633 + 1634 1634 + "@aws-crypto/util/@smithy/util-utf8/@smithy/util-buffer-from/@smithy/is-array-buffer": ["@smithy/is-array-buffer@2.2.0", "", { "dependencies": { "tslib": "^2.6.2" } }, "sha512-GGP3O9QFD24uGeAXYUjwSTXARoqpZykHadOmA8G5vfJPK0/DC67qa//0qvqrJzL1xc8WQWX7/yc7fwudjPHPhA=="], 1403 1635 } 1404 1636 }

+370 -503

cli/Cargo.lock

··· 3 3 version = 4 4 4 5 5 [[package]] 6 6 - name = "abnf" 7 7 - version = "0.13.0" 8 8 - source = "registry+https://github.com/rust-lang/crates.io-index" 9 9 - checksum = "087113bd50d9adce24850eed5d0476c7d199d532fce8fab5173650331e09033a" 10 10 - dependencies = [ 11 11 - "abnf-core", 12 12 - "nom", 13 13 - ] 14 14 - 15 15 - [[package]] 16 16 - name = "abnf-core" 17 17 - version = "0.5.0" 18 18 - source = "registry+https://github.com/rust-lang/crates.io-index" 19 19 - checksum = "c44e09c43ae1c368fb91a03a566472d0087c26cf7e1b9e8e289c14ede681dd7d" 20 20 - dependencies = [ 21 21 - "nom", 22 22 - ] 23 23 - 24 24 - [[package]] 25 6 name = "addr2line" 26 7 version = "0.25.1" 27 8 source = "registry+https://github.com/rust-lang/crates.io-index" ··· 71 52 dependencies = [ 72 53 "alloc-no-stdlib", 73 54 ] 55 55 + 56 56 + [[package]] 57 57 + name = "allocator-api2" 58 58 + version = "0.2.21" 59 59 + source = "registry+https://github.com/rust-lang/crates.io-index" 60 60 + checksum = "683d7910e743518b0e34f1186f92494becacb047c7b6bf616c96772180fef923" 74 61 75 62 [[package]] 76 63 name = "android_system_properties" ··· 139 126 140 127 [[package]] 141 128 name = "async-compression" 142 142 - version = "0.4.34" 129 129 + version = "0.4.36" 143 130 source = "registry+https://github.com/rust-lang/crates.io-index" 144 144 - checksum = "0e86f6d3dc9dc4352edeea6b8e499e13e3f5dc3b964d7ca5fd411415a3498473" 131 131 + checksum = "98ec5f6c2f8bc326c994cb9e241cc257ddaba9afa8555a43cffbb5dd86efaa37" 145 132 dependencies = [ 146 133 "compression-codecs", 147 134 "compression-core", ··· 158 145 dependencies = [ 159 146 "proc-macro2", 160 147 "quote", 161 161 - "syn 2.0.111", 148 148 + "syn 2.0.113", 149 149 + ] 150 150 + 151 151 + [[package]] 152 152 + name = "atomic-polyfill" 153 153 + version = "1.0.3" 154 154 + source = "registry+https://github.com/rust-lang/crates.io-index" 155 155 + checksum = "8cf2bce30dfe09ef0bfaef228b9d414faaf7e563035494d7fe092dba54b300f4" 156 156 + dependencies = [ 157 157 + "critical-section", 162 158 ] 163 159 164 160 [[package]] ··· 175 171 176 172 [[package]] 177 173 name = "axum" 178 178 - version = "0.8.7" 174 174 + version = "0.8.8" 179 175 source = "registry+https://github.com/rust-lang/crates.io-index" 180 180 - checksum = "5b098575ebe77cb6d14fc7f32749631a6e44edbef6b796f89b020e99ba20d425" 176 176 + checksum = "8b52af3cb4058c895d37317bb27508dccc8e5f2d39454016b297bf4a400597b8" 181 177 dependencies = [ 182 178 "axum-core", 183 179 "bytes", ··· 208 204 209 205 [[package]] 210 206 name = "axum-core" 211 211 - version = "0.5.5" 207 207 + version = "0.5.6" 212 208 source = "registry+https://github.com/rust-lang/crates.io-index" 213 213 - checksum = "59446ce19cd142f8833f856eb31f3eb097812d1479ab224f54d72428ca21ea22" 209 209 + checksum = "08c78f31d7b1291f7ee735c1c6780ccde7785daae9a9206026862dab7d8792d1" 214 210 dependencies = [ 215 211 "bytes", 216 212 "futures-core", ··· 237 233 "miniz_oxide", 238 234 "object", 239 235 "rustc-demangle", 240 240 - "windows-link 0.2.1", 236 236 + "windows-link", 241 237 ] 242 238 243 239 [[package]] ··· 285 281 286 282 [[package]] 287 283 name = "base64ct" 288 288 - version = "1.8.0" 284 284 + version = "1.8.2" 289 285 source = "registry+https://github.com/rust-lang/crates.io-index" 290 290 - checksum = "55248b47b0caf0546f7988906588779981c43bb1bc9d0c44087278f80cdb44ba" 286 286 + checksum = "7d809780667f4410e7c41b07f52439b94d2bdf8528eeedc287fa38d3b7f95d82" 291 287 292 288 [[package]] 293 289 name = "bitflags" ··· 326 322 "proc-macro2", 327 323 "quote", 328 324 "rustversion", 329 329 - "syn 2.0.111", 325 325 + "syn 2.0.113", 330 326 ] 331 327 332 328 [[package]] 333 329 name = "borsh" 334 334 - version = "1.5.7" 330 330 + version = "1.6.0" 335 331 source = "registry+https://github.com/rust-lang/crates.io-index" 336 336 - checksum = "ad8646f98db542e39fc66e68a20b2144f6a732636df7c2354e74645faaa433ce" 332 332 + checksum = "d1da5ab77c1437701eeff7c88d968729e7766172279eab0676857b3d63af7a6f" 337 333 dependencies = [ 338 334 "cfg_aliases", 339 335 ] ··· 370 366 ] 371 367 372 368 [[package]] 373 373 - name = "btree-range-map" 374 374 - version = "0.7.2" 375 375 - source = "registry+https://github.com/rust-lang/crates.io-index" 376 376 - checksum = "1be5c9672446d3800bcbcaabaeba121fe22f1fb25700c4562b22faf76d377c33" 377 377 - dependencies = [ 378 378 - "btree-slab", 379 379 - "cc-traits", 380 380 - "range-traits", 381 381 - "serde", 382 382 - "slab", 383 383 - ] 384 384 - 385 385 - [[package]] 386 386 - name = "btree-slab" 387 387 - version = "0.6.1" 388 388 - source = "registry+https://github.com/rust-lang/crates.io-index" 389 389 - checksum = "7a2b56d3029f075c4fa892428a098425b86cef5c89ae54073137ece416aef13c" 390 390 - dependencies = [ 391 391 - "cc-traits", 392 392 - "slab", 393 393 - "smallvec", 394 394 - ] 395 395 - 396 396 - [[package]] 397 369 name = "buf_redux" 398 370 version = "0.8.4" 399 371 source = "registry+https://github.com/rust-lang/crates.io-index" ··· 405 377 406 378 [[package]] 407 379 name = "bumpalo" 408 408 - version = "3.19.0" 380 380 + version = "3.19.1" 409 381 source = "registry+https://github.com/rust-lang/crates.io-index" 410 410 - checksum = "46c5e41b57b8bba42a04676d81cb89e9ee8e859a1a66f80a5a72e1cb76b34d43" 382 382 + checksum = "5dd9dc738b7a8311c7ade152424974d8115f2cdad61e8dab8dac9f2362298510" 411 383 412 384 [[package]] 413 385 name = "byteorder" ··· 435 407 436 408 [[package]] 437 409 name = "cc" 438 438 - version = "1.2.47" 410 410 + version = "1.2.51" 439 411 source = "registry+https://github.com/rust-lang/crates.io-index" 440 440 - checksum = "cd405d82c84ff7f35739f175f67d8b9fb7687a0e84ccdc78bd3568839827cf07" 412 412 + checksum = "7a0aeaff4ff1a90589618835a598e545176939b97874f7abc7851caa0618f203" 441 413 dependencies = [ 442 414 "find-msvc-tools", 443 415 "shlex", 444 416 ] 445 417 446 418 [[package]] 447 447 - name = "cc-traits" 448 448 - version = "2.0.0" 449 449 - source = "registry+https://github.com/rust-lang/crates.io-index" 450 450 - checksum = "060303ef31ef4a522737e1b1ab68c67916f2a787bb2f4f54f383279adba962b5" 451 451 - dependencies = [ 452 452 - "slab", 453 453 - ] 454 454 - 455 455 - [[package]] 456 419 name = "cesu8" 457 420 version = "1.1.0" 458 421 source = "registry+https://github.com/rust-lang/crates.io-index" ··· 481 444 "num-traits", 482 445 "serde", 483 446 "wasm-bindgen", 484 484 - "windows-link 0.2.1", 447 447 + "windows-link", 485 448 ] 486 449 487 450 [[package]] ··· 533 496 534 497 [[package]] 535 498 name = "clap" 536 536 - version = "4.5.53" 499 499 + version = "4.5.54" 537 500 source = "registry+https://github.com/rust-lang/crates.io-index" 538 538 - checksum = "c9e340e012a1bf4935f5282ed1436d1489548e8f72308207ea5df0e23d2d03f8" 501 501 + checksum = "c6e6ff9dcd79cff5cd969a17a545d79e84ab086e444102a591e288a8aa3ce394" 539 502 dependencies = [ 540 503 "clap_builder", 541 504 "clap_derive", ··· 543 506 544 507 [[package]] 545 508 name = "clap_builder" 546 546 - version = "4.5.53" 509 509 + version = "4.5.54" 547 510 source = "registry+https://github.com/rust-lang/crates.io-index" 548 548 - checksum = "d76b5d13eaa18c901fd2f7fca939fefe3a0727a953561fefdf3b2922b8569d00" 511 511 + checksum = "fa42cf4d2b7a41bc8f663a7cab4031ebafa1bf3875705bfaf8466dc60ab52c00" 549 512 dependencies = [ 550 513 "anstream", 551 514 "anstyle", ··· 562 525 "heck 0.5.0", 563 526 "proc-macro2", 564 527 "quote", 565 565 - "syn 2.0.111", 528 528 + "syn 2.0.113", 566 529 ] 567 530 568 531 [[package]] ··· 572 535 checksum = "a1d728cc89cf3aee9ff92b05e62b19ee65a02b5702cff7d5a377e32c6ae29d8d" 573 536 574 537 [[package]] 538 538 + name = "cobs" 539 539 + version = "0.3.0" 540 540 + source = "registry+https://github.com/rust-lang/crates.io-index" 541 541 + checksum = "0fa961b519f0b462e3a3b4a34b64d119eeaca1d59af726fe450bbba07a9fc0a1" 542 542 + dependencies = [ 543 543 + "thiserror 2.0.17", 544 544 + ] 545 545 + 546 546 + [[package]] 575 547 name = "colorchoice" 576 548 version = "1.0.4" 577 549 source = "registry+https://github.com/rust-lang/crates.io-index" ··· 589 561 590 562 [[package]] 591 563 name = "compression-codecs" 592 592 - version = "0.4.33" 564 564 + version = "0.4.35" 593 565 source = "registry+https://github.com/rust-lang/crates.io-index" 594 594 - checksum = "302266479cb963552d11bd042013a58ef1adc56768016c8b82b4199488f2d4ad" 566 566 + checksum = "b0f7ac3e5b97fdce45e8922fb05cae2c37f7bbd63d30dd94821dacfd8f3f2bf2" 595 567 dependencies = [ 596 568 "compression-core", 597 569 "flate2", ··· 693 665 ] 694 666 695 667 [[package]] 668 668 + name = "critical-section" 669 669 + version = "1.2.0" 670 670 + source = "registry+https://github.com/rust-lang/crates.io-index" 671 671 + checksum = "790eea4361631c5e7d22598ecd5723ff611904e3344ce8720784c93e3d83d40b" 672 672 + 673 673 + [[package]] 696 674 name = "crossbeam-channel" 697 675 version = "0.5.15" 698 676 source = "registry+https://github.com/rust-lang/crates.io-index" ··· 775 753 "proc-macro2", 776 754 "quote", 777 755 "strsim", 778 778 - "syn 2.0.111", 756 756 + "syn 2.0.113", 779 757 ] 780 758 781 759 [[package]] ··· 786 764 dependencies = [ 787 765 "darling_core", 788 766 "quote", 789 789 - "syn 2.0.111", 767 767 + "syn 2.0.113", 790 768 ] 791 769 792 770 [[package]] ··· 826 804 checksum = "8d162beedaa69905488a8da94f5ac3edb4dd4788b732fadb7bd120b2625c1976" 827 805 dependencies = [ 828 806 "data-encoding", 829 829 - "syn 2.0.111", 807 807 + "syn 2.0.113", 830 808 ] 831 809 832 810 [[package]] ··· 857 835 checksum = "ececcb659e7ba858fb4f10388c250a7252eb0a27373f1a72b8748afdd248e587" 858 836 dependencies = [ 859 837 "powerfmt", 860 860 - "serde_core", 861 838 ] 862 839 863 840 [[package]] ··· 877 854 dependencies = [ 878 855 "proc-macro2", 879 856 "quote", 880 880 - "syn 2.0.111", 857 857 + "syn 2.0.113", 881 858 "unicode-xid", 882 859 ] 883 860 ··· 928 905 dependencies = [ 929 906 "proc-macro2", 930 907 "quote", 931 931 - "syn 2.0.111", 908 908 + "syn 2.0.113", 932 909 ] 933 910 934 911 [[package]] 935 935 - name = "dyn-clone" 936 936 - version = "1.0.20" 937 937 - source = "registry+https://github.com/rust-lang/crates.io-index" 938 938 - checksum = "d0881ea181b1df73ff77ffaaf9c7544ecc11e82fba9b5f27b262a3c73a332555" 939 939 - 940 940 - [[package]] 941 912 name = "ecdsa" 942 913 version = "0.16.9" 943 914 source = "registry+https://github.com/rust-lang/crates.io-index" ··· 972 943 ] 973 944 974 945 [[package]] 946 946 + name = "embedded-io" 947 947 + version = "0.4.0" 948 948 + source = "registry+https://github.com/rust-lang/crates.io-index" 949 949 + checksum = "ef1a6892d9eef45c8fa6b9e0086428a2cca8491aca8f787c534a3d6d0bcb3ced" 950 950 + 951 951 + [[package]] 952 952 + name = "embedded-io" 953 953 + version = "0.6.1" 954 954 + source = "registry+https://github.com/rust-lang/crates.io-index" 955 955 + checksum = "edd0f118536f44f5ccd48bcb8b111bdc3de888b58c74639dfb034a357d0f206d" 956 956 + 957 957 + [[package]] 975 958 name = "encode_unicode" 976 959 version = "1.0.0" 977 960 source = "registry+https://github.com/rust-lang/crates.io-index" ··· 995 978 "heck 0.5.0", 996 979 "proc-macro2", 997 980 "quote", 998 998 - "syn 2.0.111", 981 981 + "syn 2.0.113", 999 982 ] 1000 983 1001 984 [[package]] ··· 1044 1027 1045 1028 [[package]] 1046 1029 name = "find-msvc-tools" 1047 1047 - version = "0.1.5" 1030 1030 + version = "0.1.6" 1048 1031 source = "registry+https://github.com/rust-lang/crates.io-index" 1049 1049 - checksum = "3a3076410a55c90011c298b04d0cfa770b00fa04e1e3c97d3f6c9de105a03844" 1032 1032 + checksum = "645cbb3a84e60b7531617d5ae4e57f7e27308f6445f5abf653209ea76dec8dff" 1050 1033 1051 1034 [[package]] 1052 1035 name = "flate2" ··· 1063 1046 version = "1.0.7" 1064 1047 source = "registry+https://github.com/rust-lang/crates.io-index" 1065 1048 checksum = "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1" 1049 1049 + 1050 1050 + [[package]] 1051 1051 + name = "foldhash" 1052 1052 + version = "0.1.5" 1053 1053 + source = "registry+https://github.com/rust-lang/crates.io-index" 1054 1054 + checksum = "d9c4f5dac5e15c24eb999c26181a6ca40b39fe946cbe4c263c7209467bc83af2" 1066 1055 1067 1056 [[package]] 1068 1057 name = "form_urlencoded" ··· 1165 1154 dependencies = [ 1166 1155 "proc-macro2", 1167 1156 "quote", 1168 1168 - "syn 2.0.111", 1157 1157 + "syn 2.0.113", 1169 1158 ] 1170 1159 1171 1160 [[package]] ··· 1200 1189 1201 1190 [[package]] 1202 1191 name = "generator" 1203 1203 - version = "0.8.7" 1192 1192 + version = "0.8.8" 1204 1193 source = "registry+https://github.com/rust-lang/crates.io-index" 1205 1205 - checksum = "605183a538e3e2a9c1038635cc5c2d194e2ee8fd0d1b66b8349fad7dbacce5a2" 1194 1194 + checksum = "52f04ae4152da20c76fe800fa48659201d5cf627c5149ca0b707b69d7eef6cf9" 1206 1195 dependencies = [ 1207 1196 "cc", 1208 1197 "cfg-if", 1209 1198 "libc", 1210 1199 "log", 1211 1200 "rustversion", 1212 1212 - "windows", 1201 1201 + "windows-link", 1202 1202 + "windows-result", 1213 1203 ] 1214 1204 1215 1205 [[package]] ··· 1319 1309 1320 1310 [[package]] 1321 1311 name = "h2" 1322 1322 - version = "0.4.12" 1312 1312 + version = "0.4.13" 1323 1313 source = "registry+https://github.com/rust-lang/crates.io-index" 1324 1324 - checksum = "f3c0b69cfcb4e1b9f1bf2f53f95f766e4661169728ec61cd3fe5a0166f2d1386" 1314 1314 + checksum = "2f44da3a8150a6703ed5d34e164b875fd14c2cdab9af1252a9a1020bde2bdc54" 1325 1315 dependencies = [ 1326 1316 "atomic-waker", 1327 1317 "bytes", ··· 1329 1319 "futures-core", 1330 1320 "futures-sink", 1331 1321 "http", 1332 1332 - "indexmap 2.12.1", 1322 1322 + "indexmap", 1333 1323 "slab", 1334 1324 "tokio", 1335 1325 "tokio-util", ··· 1348 1338 ] 1349 1339 1350 1340 [[package]] 1351 1351 - name = "hashbrown" 1352 1352 - version = "0.12.3" 1341 1341 + name = "hash32" 1342 1342 + version = "0.2.1" 1353 1343 source = "registry+https://github.com/rust-lang/crates.io-index" 1354 1354 - checksum = "8a9ee70c43aaf417c914396645a0fa852624801b24ebb7ae78fe8272889ac888" 1344 1344 + checksum = "b0c35f58762feb77d74ebe43bdbc3210f09be9fe6742234d573bacc26ed92b67" 1345 1345 + dependencies = [ 1346 1346 + "byteorder", 1347 1347 + ] 1355 1348 1356 1349 [[package]] 1357 1350 name = "hashbrown" ··· 1361 1354 1362 1355 [[package]] 1363 1356 name = "hashbrown" 1357 1357 + version = "0.15.5" 1358 1358 + source = "registry+https://github.com/rust-lang/crates.io-index" 1359 1359 + checksum = "9229cfe53dfd69f0609a49f65461bd93001ea1ef889cd5529dd176593f5338a1" 1360 1360 + dependencies = [ 1361 1361 + "allocator-api2", 1362 1362 + "equivalent", 1363 1363 + "foldhash", 1364 1364 + ] 1365 1365 + 1366 1366 + [[package]] 1367 1367 + name = "hashbrown" 1364 1368 version = "0.16.1" 1365 1369 source = "registry+https://github.com/rust-lang/crates.io-index" 1366 1370 checksum = "841d1cc9bed7f9236f321df977030373f4a4163ae1a7dbfe1a51a2c1a51d9100" 1367 1371 1368 1372 [[package]] 1373 1373 + name = "heapless" 1374 1374 + version = "0.7.17" 1375 1375 + source = "registry+https://github.com/rust-lang/crates.io-index" 1376 1376 + checksum = "cdc6457c0eb62c71aac4bc17216026d8410337c4126773b9c5daba343f17964f" 1377 1377 + dependencies = [ 1378 1378 + "atomic-polyfill", 1379 1379 + "hash32", 1380 1380 + "rustc_version", 1381 1381 + "serde", 1382 1382 + "spin 0.9.8", 1383 1383 + "stable_deref_trait", 1384 1384 + ] 1385 1385 + 1386 1386 + [[package]] 1369 1387 name = "heck" 1370 1388 version = "0.4.1" 1371 1389 source = "registry+https://github.com/rust-lang/crates.io-index" ··· 1390 1408 checksum = "7f24254aa9a54b5c858eaee2f5bccdb46aaf0e486a595ed5fd8f86ba55232a70" 1391 1409 1392 1410 [[package]] 1393 1393 - name = "hex_fmt" 1394 1394 - version = "0.3.0" 1395 1395 - source = "registry+https://github.com/rust-lang/crates.io-index" 1396 1396 - checksum = "b07f60793ff0a4d9cef0f18e63b5357e06209987153a64648c972c1e5aff336f" 1397 1397 - 1398 1398 - [[package]] 1399 1411 name = "hickory-proto" 1400 1412 version = "0.24.4" 1401 1413 source = "registry+https://github.com/rust-lang/crates.io-index" ··· 1460 1472 "markup5ever", 1461 1473 "proc-macro2", 1462 1474 "quote", 1463 1463 - "syn 2.0.111", 1475 1475 + "syn 2.0.113", 1464 1476 ] 1465 1477 1466 1478 [[package]] ··· 1556 1568 1557 1569 [[package]] 1558 1570 name = "hyper-util" 1559 1559 - version = "0.1.18" 1571 1571 + version = "0.1.19" 1560 1572 source = "registry+https://github.com/rust-lang/crates.io-index" 1561 1561 - checksum = "52e9a2a24dc5c6821e71a7030e1e14b7b632acac55c40e9d2e082c621261bb56" 1573 1573 + checksum = "727805d60e7938b76b826a6ef209eb70eaa1812794f9424d4a4e2d740662df5f" 1562 1574 dependencies = [ 1563 1575 "base64 0.22.1", 1564 1576 "bytes", ··· 1592 1604 "js-sys", 1593 1605 "log", 1594 1606 "wasm-bindgen", 1595 1595 - "windows-core 0.62.2", 1607 1607 + "windows-core", 1596 1608 ] 1597 1609 1598 1610 [[package]] ··· 1652 1664 1653 1665 [[package]] 1654 1666 name = "icu_properties" 1655 1655 - version = "2.1.1" 1667 1667 + version = "2.1.2" 1656 1668 source = "registry+https://github.com/rust-lang/crates.io-index" 1657 1657 - checksum = "e93fcd3157766c0c8da2f8cff6ce651a31f0810eaa1c51ec363ef790bbb5fb99" 1669 1669 + checksum = "020bfc02fe870ec3a66d93e677ccca0562506e5872c650f893269e08615d74ec" 1658 1670 dependencies = [ 1659 1671 "icu_collections", 1660 1672 "icu_locale_core", ··· 1666 1678 1667 1679 [[package]] 1668 1680 name = "icu_properties_data" 1669 1669 - version = "2.1.1" 1681 1681 + version = "2.1.2" 1670 1682 source = "registry+https://github.com/rust-lang/crates.io-index" 1671 1671 - checksum = "02845b3647bb045f1100ecd6480ff52f34c35f82d9880e029d329c21d1054899" 1683 1683 + checksum = "616c294cf8d725c6afcd8f55abc17c56464ef6211f9ed59cccffe534129c77af" 1672 1684 1673 1685 [[package]] 1674 1686 name = "icu_provider" ··· 1730 1742 1731 1743 [[package]] 1732 1744 name = "indexmap" 1733 1733 - version = "1.9.3" 1734 1734 - source = "registry+https://github.com/rust-lang/crates.io-index" 1735 1735 - checksum = "bd070e393353796e801d209ad339e89596eb4c8d430d18ede6a1cced8fafbd99" 1736 1736 - dependencies = [ 1737 1737 - "autocfg", 1738 1738 - "hashbrown 0.12.3", 1739 1739 - "serde", 1740 1740 - ] 1741 1741 - 1742 1742 - [[package]] 1743 1743 - name = "indexmap" 1744 1745 version = "2.12.1" 1745 1746 source = "registry+https://github.com/rust-lang/crates.io-index" 1746 1747 checksum = "0ad4bb2b565bca0645f4d68c5c9af97fba094e9791da685bf83cb5f3ce74acf2" 1747 1748 dependencies = [ 1748 1749 "equivalent", 1749 1750 "hashbrown 0.16.1", 1750 1750 - "serde", 1751 1751 - "serde_core", 1752 1751 ] 1753 1752 1754 1753 [[package]] ··· 1765 1764 ] 1766 1765 1767 1766 [[package]] 1768 1768 - name = "indoc" 1769 1769 - version = "2.0.7" 1770 1770 - source = "registry+https://github.com/rust-lang/crates.io-index" 1771 1771 - checksum = "79cf5c93f93228cf8efb3ba362535fb11199ac548a09ce117c9b1adc3030d706" 1772 1772 - dependencies = [ 1773 1773 - "rustversion", 1774 1774 - ] 1775 1775 - 1776 1776 - [[package]] 1777 1767 name = "inventory" 1778 1768 version = "0.3.21" 1779 1769 source = "registry+https://github.com/rust-lang/crates.io-index" ··· 1813 1803 1814 1804 [[package]] 1815 1805 name = "iri-string" 1816 1816 - version = "0.7.9" 1806 1806 + version = "0.7.10" 1817 1807 source = "registry+https://github.com/rust-lang/crates.io-index" 1818 1818 - checksum = "4f867b9d1d896b67beb18518eda36fdb77a32ea590de864f1325b294a6d14397" 1808 1808 + checksum = "c91338f0783edbd6195decb37bae672fd3b165faffb89bf7b9e6942f8b1a731a" 1819 1809 dependencies = [ 1820 1810 "memchr", 1821 1811 "serde", ··· 1835 1825 1836 1826 [[package]] 1837 1827 name = "itoa" 1838 1838 - version = "1.0.15" 1828 1828 + version = "1.0.17" 1839 1829 source = "registry+https://github.com/rust-lang/crates.io-index" 1840 1840 - checksum = "4a5f13b858c8d314ee3e8f639011f7ccefe71f97f96e50151fb991f267928e2c" 1830 1830 + checksum = "92ecc6618181def0457392ccd0ee51198e065e016d1d527a7ac1b6dc7c1f09d2" 1841 1831 1842 1832 [[package]] 1843 1833 name = "jacquard" 1844 1844 - version = "0.9.3" 1834 1834 + version = "0.9.5" 1835 1835 + source = "git+https://tangled.org/nonbinary.computer/jacquard#5bcf7f8e87324b8e67fc273c678d0490c9c6d15b" 1845 1836 dependencies = [ 1846 1837 "bytes", 1847 1838 "getrandom 0.2.16", ··· 1870 1861 1871 1862 [[package]] 1872 1863 name = "jacquard-api" 1873 1873 - version = "0.9.2" 1864 1864 + version = "0.9.5" 1865 1865 + source = "git+https://tangled.org/nonbinary.computer/jacquard#5bcf7f8e87324b8e67fc273c678d0490c9c6d15b" 1874 1866 dependencies = [ 1875 1867 "bon", 1876 1868 "bytes", ··· 1880 1872 "miette", 1881 1873 "rustversion", 1882 1874 "serde", 1875 1875 + "serde_bytes", 1883 1876 "serde_ipld_dagcbor", 1884 1877 "thiserror 2.0.17", 1885 1878 "unicode-segmentation", ··· 1887 1880 1888 1881 [[package]] 1889 1882 name = "jacquard-common" 1890 1890 - version = "0.9.2" 1883 1883 + version = "0.9.5" 1884 1884 + source = "git+https://tangled.org/nonbinary.computer/jacquard#5bcf7f8e87324b8e67fc273c678d0490c9c6d15b" 1891 1885 dependencies = [ 1892 1886 "base64 0.22.1", 1893 1887 "bon", 1894 1888 "bytes", 1895 1889 "chrono", 1896 1890 "ciborium", 1891 1891 + "ciborium-io", 1897 1892 "cid", 1898 1893 "futures", 1899 1894 "getrandom 0.2.16", 1900 1895 "getrandom 0.3.4", 1896 1896 + "hashbrown 0.15.5", 1901 1897 "http", 1902 1898 "ipld-core", 1903 1899 "k256", 1904 1904 - "langtag", 1900 1900 + "maitake-sync", 1905 1901 "miette", 1906 1902 "multibase", 1907 1903 "multihash", 1908 1904 "n0-future 0.1.3", 1909 1905 "ouroboros", 1906 1906 + "oxilangtag", 1910 1907 "p256", 1908 1908 + "postcard", 1911 1909 "rand 0.9.2", 1912 1910 "regex", 1911 1911 + "regex-automata", 1913 1912 "regex-lite", 1914 1913 "reqwest", 1915 1914 "serde", 1915 1915 + "serde_bytes", 1916 1916 "serde_html_form", 1917 1917 "serde_ipld_dagcbor", 1918 1918 "serde_json", 1919 1919 "signature", 1920 1920 "smol_str", 1921 1921 + "spin 0.10.0", 1921 1922 "thiserror 2.0.17", 1922 1923 "tokio", 1923 1924 "tokio-tungstenite-wasm", ··· 1928 1929 1929 1930 [[package]] 1930 1931 name = "jacquard-derive" 1931 1931 - version = "0.9.3" 1932 1932 + version = "0.9.5" 1933 1933 + source = "git+https://tangled.org/nonbinary.computer/jacquard#5bcf7f8e87324b8e67fc273c678d0490c9c6d15b" 1932 1934 dependencies = [ 1933 1935 "heck 0.5.0", 1934 1936 "jacquard-lexicon", 1935 1937 "proc-macro2", 1936 1938 "quote", 1937 1937 - "syn 2.0.111", 1939 1939 + "syn 2.0.113", 1938 1940 ] 1939 1941 1940 1942 [[package]] 1941 1943 name = "jacquard-identity" 1942 1942 - version = "0.9.2" 1944 1944 + version = "0.9.5" 1945 1945 + source = "git+https://tangled.org/nonbinary.computer/jacquard#5bcf7f8e87324b8e67fc273c678d0490c9c6d15b" 1943 1946 dependencies = [ 1944 1947 "bon", 1945 1948 "bytes", ··· 1949 1952 "jacquard-common", 1950 1953 "jacquard-lexicon", 1951 1954 "miette", 1952 1952 - "mini-moka", 1955 1955 + "mini-moka-wasm", 1956 1956 + "n0-future 0.1.3", 1953 1957 "percent-encoding", 1954 1958 "reqwest", 1955 1959 "serde", ··· 1964 1968 1965 1969 [[package]] 1966 1970 name = "jacquard-lexicon" 1967 1967 - version = "0.9.2" 1971 1971 + version = "0.9.5" 1972 1972 + source = "git+https://tangled.org/nonbinary.computer/jacquard#5bcf7f8e87324b8e67fc273c678d0490c9c6d15b" 1968 1973 dependencies = [ 1969 1974 "cid", 1970 1975 "dashmap", ··· 1982 1987 "serde_repr", 1983 1988 "serde_with", 1984 1989 "sha2", 1985 1985 - "syn 2.0.111", 1990 1990 + "syn 2.0.113", 1986 1991 "thiserror 2.0.17", 1987 1992 "unicode-segmentation", 1988 1993 ] 1989 1994 1990 1995 [[package]] 1991 1996 name = "jacquard-oauth" 1992 1992 - version = "0.9.2" 1997 1997 + version = "0.9.6" 1998 1998 + source = "git+https://tangled.org/nonbinary.computer/jacquard#5bcf7f8e87324b8e67fc273c678d0490c9c6d15b" 1993 1999 dependencies = [ 1994 2000 "base64 0.22.1", 1995 2001 "bytes", ··· 2077 2083 2078 2084 [[package]] 2079 2085 name = "js-sys" 2080 2080 - version = "0.3.82" 2086 2086 + version = "0.3.83" 2081 2087 source = "registry+https://github.com/rust-lang/crates.io-index" 2082 2082 - checksum = "b011eec8cc36da2aab2d5cff675ec18454fad408585853910a202391cf9f8e65" 2088 2088 + checksum = "464a3709c7f55f1f721e5389aa6ea4e3bc6aba669353300af094b29ffbdde1d8" 2083 2089 dependencies = [ 2084 2090 "once_cell", 2085 2091 "wasm-bindgen", ··· 2098 2104 ] 2099 2105 2100 2106 [[package]] 2101 2101 - name = "langtag" 2102 2102 - version = "0.4.0" 2103 2103 - source = "registry+https://github.com/rust-lang/crates.io-index" 2104 2104 - checksum = "9ecb4c689a30e48ebeaa14237f34037e300dd072e6ad21a9ec72e810ff3c6600" 2105 2105 - dependencies = [ 2106 2106 - "serde", 2107 2107 - "static-regular-grammar", 2108 2108 - "thiserror 1.0.69", 2109 2109 - ] 2110 2110 - 2111 2111 - [[package]] 2112 2107 name = "lazy_static" 2113 2108 version = "1.5.0" 2114 2109 source = "registry+https://github.com/rust-lang/crates.io-index" ··· 2119 2114 2120 2115 [[package]] 2121 2116 name = "libc" 2122 2122 - version = "0.2.177" 2117 2117 + version = "0.2.179" 2123 2118 source = "registry+https://github.com/rust-lang/crates.io-index" 2124 2124 - checksum = "2874a2af47a2325c2001a6e6fad9b16a53b802102b528163885171cf92b15976" 2119 2119 + checksum = "c5a2d376baa530d1238d133232d15e239abad80d05838b4b59354e5268af431f" 2125 2120 2126 2121 [[package]] 2127 2122 name = "libm" ··· 2131 2126 2132 2127 [[package]] 2133 2128 name = "libredox" 2134 2134 - version = "0.1.10" 2129 2129 + version = "0.1.12" 2135 2130 source = "registry+https://github.com/rust-lang/crates.io-index" 2136 2136 - checksum = "416f7e718bdb06000964960ffa43b4335ad4012ae8b99060261aa4a8088d5ccb" 2131 2131 + checksum = "3d0b95e02c851351f877147b7deea7b1afb1df71b63aa5f8270716e0c5720616" 2137 2132 dependencies = [ 2138 2133 "bitflags", 2139 2134 "libc", 2140 2140 - "redox_syscall", 2135 2135 + "redox_syscall 0.7.0", 2141 2136 ] 2142 2137 2143 2138 [[package]] ··· 2169 2164 2170 2165 [[package]] 2171 2166 name = "log" 2172 2172 - version = "0.4.28" 2167 2167 + version = "0.4.29" 2173 2168 source = "registry+https://github.com/rust-lang/crates.io-index" 2174 2174 - checksum = "34080505efa8e45a4b816c349525ebe327ceaa8559756f0356cba97ef3bf7432" 2169 2169 + checksum = "5e5032e24019045c762d3c0f28f5b6b8bbf38563a65908389bf7978758920897" 2175 2170 2176 2171 [[package]] 2177 2172 name = "loom" ··· 2208 2203 checksum = "c41e0c4fef86961ac6d6f8a82609f55f31b05e4fce149ac5710e439df7619ba4" 2209 2204 2210 2205 [[package]] 2206 2206 + name = "maitake-sync" 2207 2207 + version = "0.1.2" 2208 2208 + source = "registry+https://github.com/rust-lang/crates.io-index" 2209 2209 + checksum = "6816ab14147f80234c675b80ed6dc4f440d8a1cefc158e766067aedb84c0bcd5" 2210 2210 + dependencies = [ 2211 2211 + "cordyceps", 2212 2212 + "loom", 2213 2213 + "mycelium-bitfield", 2214 2214 + "pin-project", 2215 2215 + "portable-atomic", 2216 2216 + ] 2217 2217 + 2218 2218 + [[package]] 2211 2219 name = "markup5ever" 2212 2220 version = "0.12.1" 2213 2221 source = "registry+https://github.com/rust-lang/crates.io-index" ··· 2292 2300 dependencies = [ 2293 2301 "proc-macro2", 2294 2302 "quote", 2295 2295 - "syn 2.0.111", 2303 2303 + "syn 2.0.113", 2296 2304 ] 2297 2305 2298 2306 [[package]] ··· 2312 2320 ] 2313 2321 2314 2322 [[package]] 2315 2315 - name = "mini-moka" 2323 2323 + name = "mini-moka-wasm" 2316 2324 version = "0.10.99" 2325 2325 + source = "git+https://tangled.org/nonbinary.computer/jacquard#5bcf7f8e87324b8e67fc273c678d0490c9c6d15b" 2317 2326 dependencies = [ 2318 2327 "crossbeam-channel", 2319 2328 "crossbeam-utils", ··· 2325 2334 ] 2326 2335 2327 2336 [[package]] 2328 2328 - name = "minimal-lexical" 2329 2329 - version = "0.2.1" 2330 2330 - source = "registry+https://github.com/rust-lang/crates.io-index" 2331 2331 - checksum = "68354c5c6bd36d73ff3feceb05efa59b6acb7626617f4962be322a825e61f79a" 2332 2332 - 2333 2333 - [[package]] 2334 2337 name = "miniz_oxide" 2335 2338 version = "0.8.9" 2336 2339 source = "registry+https://github.com/rust-lang/crates.io-index" ··· 2342 2345 2343 2346 [[package]] 2344 2347 name = "mio" 2345 2345 - version = "1.1.0" 2348 2348 + version = "1.1.1" 2346 2349 source = "registry+https://github.com/rust-lang/crates.io-index" 2347 2347 - checksum = "69d83b0086dc8ecf3ce9ae2874b2d1290252e2a30720bea58a5c6639b0092873" 2350 2350 + checksum = "a69bcab0ad47271a0234d9422b131806bf3968021e5dc9328caf2d4cd58557fc" 2348 2351 dependencies = [ 2349 2352 "libc", 2350 2353 "wasi", ··· 2393 2396 ] 2394 2397 2395 2398 [[package]] 2399 2399 + name = "mycelium-bitfield" 2400 2400 + version = "0.1.5" 2401 2401 + source = "registry+https://github.com/rust-lang/crates.io-index" 2402 2402 + checksum = "24e0cc5e2c585acbd15c5ce911dff71e1f4d5313f43345873311c4f5efd741cc" 2403 2403 + 2404 2404 + [[package]] 2396 2405 name = "n0-future" 2397 2406 version = "0.1.3" 2398 2407 source = "registry+https://github.com/rust-lang/crates.io-index" ··· 2447 2456 checksum = "650eef8c711430f1a879fdd01d4745a7deea475becfb90269c06775983bbf086" 2448 2457 2449 2458 [[package]] 2450 2450 - name = "nom" 2451 2451 - version = "7.1.3" 2452 2452 - source = "registry+https://github.com/rust-lang/crates.io-index" 2453 2453 - checksum = "d273983c5a657a70a3e8f2a01329822f3b8c8172b73826411a55751e404a0a4a" 2454 2454 - dependencies = [ 2455 2455 - "memchr", 2456 2456 - "minimal-lexical", 2457 2457 - ] 2458 2458 - 2459 2459 - [[package]] 2460 2459 name = "nu-ansi-term" 2461 2460 version = "0.50.3" 2462 2461 source = "registry+https://github.com/rust-lang/crates.io-index" ··· 2590 2589 2591 2590 [[package]] 2592 2591 name = "openssl-probe" 2593 2593 - version = "0.1.6" 2592 2592 + version = "0.2.0" 2594 2593 source = "registry+https://github.com/rust-lang/crates.io-index" 2595 2595 - checksum = "d05e27ee213611ffe7d6348b942e8f942b37114c00cc03cec254295a4a17852e" 2594 2594 + checksum = "9f50d9b3dabb09ecd771ad0aa242ca6894994c130308ca3d7684634df8037391" 2596 2595 2597 2596 [[package]] 2598 2597 name = "option-ext" ··· 2621 2620 "proc-macro2", 2622 2621 "proc-macro2-diagnostics", 2623 2622 "quote", 2624 2624 - "syn 2.0.111", 2623 2623 + "syn 2.0.113", 2625 2624 ] 2626 2625 2627 2626 [[package]] ··· 2631 2630 checksum = "9c6901729fa79e91a0913333229e9ca5dc725089d1c363b2f4b4760709dc4a52" 2632 2631 2633 2632 [[package]] 2633 2633 + name = "oxilangtag" 2634 2634 + version = "0.1.5" 2635 2635 + source = "registry+https://github.com/rust-lang/crates.io-index" 2636 2636 + checksum = "23f3f87617a86af77fa3691e6350483e7154c2ead9f1261b75130e21ca0f8acb" 2637 2637 + dependencies = [ 2638 2638 + "serde", 2639 2639 + ] 2640 2640 + 2641 2641 + [[package]] 2634 2642 name = "p256" 2635 2643 version = "0.13.2" 2636 2644 source = "registry+https://github.com/rust-lang/crates.io-index" ··· 2676 2684 dependencies = [ 2677 2685 "cfg-if", 2678 2686 "libc", 2679 2679 - "redox_syscall", 2687 2687 + "redox_syscall 0.5.18", 2680 2688 "smallvec", 2681 2681 - "windows-link 0.2.1", 2689 2689 + "windows-link", 2682 2690 ] 2683 2691 2684 2692 [[package]] ··· 2751 2759 dependencies = [ 2752 2760 "proc-macro2", 2753 2761 "quote", 2754 2754 - "syn 2.0.111", 2762 2762 + "syn 2.0.113", 2755 2763 ] 2756 2764 2757 2765 [[package]] ··· 2789 2797 2790 2798 [[package]] 2791 2799 name = "portable-atomic" 2792 2792 - version = "1.11.1" 2800 2800 + version = "1.13.0" 2793 2801 source = "registry+https://github.com/rust-lang/crates.io-index" 2794 2794 - checksum = "f84267b20a16ea918e43c6a88433c2d54fa145c92a811b5b047ccbe153674483" 2802 2802 + checksum = "f89776e4d69bb58bc6993e99ffa1d11f228b839984854c7daeb5d37f87cbe950" 2803 2803 + 2804 2804 + [[package]] 2805 2805 + name = "postcard" 2806 2806 + version = "1.1.3" 2807 2807 + source = "registry+https://github.com/rust-lang/crates.io-index" 2808 2808 + checksum = "6764c3b5dd454e283a30e6dfe78e9b31096d9e32036b5d1eaac7a6119ccb9a24" 2809 2809 + dependencies = [ 2810 2810 + "cobs", 2811 2811 + "embedded-io 0.4.0", 2812 2812 + "embedded-io 0.6.1", 2813 2813 + "heapless", 2814 2814 + "serde", 2815 2815 + ] 2795 2816 2796 2817 [[package]] 2797 2818 name = "potential_utf" ··· 2830 2851 checksum = "479ca8adacdd7ce8f1fb39ce9ecccbfe93a3f1344b3d0d97f20bc0196208f62b" 2831 2852 dependencies = [ 2832 2853 "proc-macro2", 2833 2833 - "syn 2.0.111", 2854 2854 + "syn 2.0.113", 2834 2855 ] 2835 2856 2836 2857 [[package]] ··· 2843 2864 ] 2844 2865 2845 2866 [[package]] 2846 2846 - name = "proc-macro-error" 2847 2847 - version = "1.0.4" 2848 2848 - source = "registry+https://github.com/rust-lang/crates.io-index" 2849 2849 - checksum = "da25490ff9892aab3fcf7c36f08cfb902dd3e71ca0f9f9517bea02a73a5ce38c" 2850 2850 - dependencies = [ 2851 2851 - "proc-macro-error-attr", 2852 2852 - "proc-macro2", 2853 2853 - "quote", 2854 2854 - "syn 1.0.109", 2855 2855 - "version_check", 2856 2856 - ] 2857 2857 - 2858 2858 - [[package]] 2859 2859 - name = "proc-macro-error-attr" 2860 2860 - version = "1.0.4" 2861 2861 - source = "registry+https://github.com/rust-lang/crates.io-index" 2862 2862 - checksum = "a1be40180e52ecc98ad80b184934baf3d0d29f979574e439af5a55274b35f869" 2863 2863 - dependencies = [ 2864 2864 - "proc-macro2", 2865 2865 - "quote", 2866 2866 - "version_check", 2867 2867 - ] 2868 2868 - 2869 2869 - [[package]] 2870 2867 name = "proc-macro2" 2871 2871 - version = "1.0.103" 2868 2868 + version = "1.0.105" 2872 2869 source = "registry+https://github.com/rust-lang/crates.io-index" 2873 2873 - checksum = "5ee95bc4ef87b8d5ba32e8b7714ccc834865276eab0aed5c9958d00ec45f49e8" 2870 2870 + checksum = "535d180e0ecab6268a3e718bb9fd44db66bbbc256257165fc699dadf70d16fe7" 2874 2871 dependencies = [ 2875 2872 "unicode-ident", 2876 2873 ] ··· 2883 2880 dependencies = [ 2884 2881 "proc-macro2", 2885 2882 "quote", 2886 2886 - "syn 2.0.111", 2883 2883 + "syn 2.0.113", 2887 2884 "version_check", 2888 2885 "yansi", 2889 2886 ] ··· 2951 2948 2952 2949 [[package]] 2953 2950 name = "quote" 2954 2954 - version = "1.0.42" 2951 2951 + version = "1.0.43" 2955 2952 source = "registry+https://github.com/rust-lang/crates.io-index" 2956 2956 - checksum = "a338cc41d27e6cc6dce6cefc13a0729dfbb81c262b1f519331575dd80ef3067f" 2953 2953 + checksum = "dc74d9a594b72ae6656596548f56f667211f8a97b3d4c3d467150794690dc40a" 2957 2954 dependencies = [ 2958 2955 "proc-macro2", 2959 2956 ] ··· 3024 3021 ] 3025 3022 3026 3023 [[package]] 3027 3027 - name = "range-traits" 3028 3028 - version = "0.3.2" 3024 3024 + name = "redox_syscall" 3025 3025 + version = "0.5.18" 3029 3026 source = "registry+https://github.com/rust-lang/crates.io-index" 3030 3030 - checksum = "d20581732dd76fa913c7dff1a2412b714afe3573e94d41c34719de73337cc8ab" 3027 3027 + checksum = "ed2bf2547551a7053d6fdfafda3f938979645c44812fbfcda098faae3f1a362d" 3028 3028 + dependencies = [ 3029 3029 + "bitflags", 3030 3030 + ] 3031 3031 3032 3032 [[package]] 3033 3033 name = "redox_syscall" 3034 3034 - version = "0.5.18" 3034 3034 + version = "0.7.0" 3035 3035 source = "registry+https://github.com/rust-lang/crates.io-index" 3036 3036 - checksum = "ed2bf2547551a7053d6fdfafda3f938979645c44812fbfcda098faae3f1a362d" 3036 3036 + checksum = "49f3fe0889e69e2ae9e41f4d6c4c0181701d00e4697b356fb1f74173a5e0ee27" 3037 3037 dependencies = [ 3038 3038 "bitflags", 3039 3039 ] ··· 3047 3047 "getrandom 0.2.16", 3048 3048 "libredox", 3049 3049 "thiserror 2.0.17", 3050 3050 - ] 3051 3051 - 3052 3052 - [[package]] 3053 3053 - name = "ref-cast" 3054 3054 - version = "1.0.25" 3055 3055 - source = "registry+https://github.com/rust-lang/crates.io-index" 3056 3056 - checksum = "f354300ae66f76f1c85c5f84693f0ce81d747e2c3f21a45fef496d89c960bf7d" 3057 3057 - dependencies = [ 3058 3058 - "ref-cast-impl", 3059 3059 - ] 3060 3060 - 3061 3061 - [[package]] 3062 3062 - name = "ref-cast-impl" 3063 3063 - version = "1.0.25" 3064 3064 - source = "registry+https://github.com/rust-lang/crates.io-index" 3065 3065 - checksum = "b7186006dcb21920990093f30e3dea63b7d6e977bf1256be20c3563a5db070da" 3066 3066 - dependencies = [ 3067 3067 - "proc-macro2", 3068 3068 - "quote", 3069 3069 - "syn 2.0.111", 3070 3050 ] 3071 3051 3072 3052 [[package]] ··· 3106 3086 3107 3087 [[package]] 3108 3088 name = "reqwest" 3109 3109 - version = "0.12.24" 3089 3089 + version = "0.12.28" 3110 3090 source = "registry+https://github.com/rust-lang/crates.io-index" 3111 3111 - checksum = "9d0946410b9f7b082a427e4ef5c8ff541a88b357bc6c637c40db3a68ac70a36f" 3091 3091 + checksum = "eddd3ca559203180a307f12d114c268abf583f59b03cb906fd0b3ff8646c1147" 3112 3092 dependencies = [ 3113 3113 - "async-compression", 3114 3093 "base64 0.22.1", 3115 3094 "bytes", 3116 3095 "encoding_rs", ··· 3205 3184 3206 3185 [[package]] 3207 3186 name = "rsa" 3208 3208 - version = "0.9.9" 3187 3187 + version = "0.9.10" 3209 3188 source = "registry+https://github.com/rust-lang/crates.io-index" 3210 3210 - checksum = "40a0376c50d0358279d9d643e4bf7b7be212f1f4ff1da9070a7b54d22ef75c88" 3189 3189 + checksum = "b8573f03f5883dcaebdfcf4725caa1ecb9c15b2ef50c43a07b816e06799bb12d" 3211 3190 dependencies = [ 3212 3191 "const-oid", 3213 3192 "digest", ··· 3236 3215 checksum = "357703d41365b4b27c590e3ed91eabb1b663f07c4c084095e60cbed4362dff0d" 3237 3216 3238 3217 [[package]] 3218 3218 + name = "rustc_version" 3219 3219 + version = "0.4.1" 3220 3220 + source = "registry+https://github.com/rust-lang/crates.io-index" 3221 3221 + checksum = "cfcb3a22ef46e85b45de6ee7e79d063319ebb6594faafcf1c225ea92ab6e9b92" 3222 3222 + dependencies = [ 3223 3223 + "semver", 3224 3224 + ] 3225 3225 + 3226 3226 + [[package]] 3239 3227 name = "rustix" 3240 3240 - version = "1.1.2" 3228 3228 + version = "1.1.3" 3241 3229 source = "registry+https://github.com/rust-lang/crates.io-index" 3242 3242 - checksum = "cd15f8a2c5551a84d56efdc1cd049089e409ac19a3072d5037a17fd70719ff3e" 3230 3230 + checksum = "146c9e247ccc180c1f61615433868c99f3de3ae256a30a43b49f67c2d9171f34" 3243 3231 dependencies = [ 3244 3232 "bitflags", 3245 3233 "errno", ··· 3250 3238 3251 3239 [[package]] 3252 3240 name = "rustls" 3253 3253 - version = "0.23.35" 3241 3241 + version = "0.23.36" 3254 3242 source = "registry+https://github.com/rust-lang/crates.io-index" 3255 3255 - checksum = "533f54bc6a7d4f647e46ad909549eda97bf5afc1585190ef692b4286b198bd8f" 3243 3243 + checksum = "c665f33d38cea657d9614f766881e4d510e0eda4239891eea56b4cadcf01801b" 3256 3244 dependencies = [ 3257 3245 "once_cell", 3258 3246 "ring", ··· 3264 3252 3265 3253 [[package]] 3266 3254 name = "rustls-native-certs" 3267 3267 - version = "0.8.2" 3255 3255 + version = "0.8.3" 3268 3256 source = "registry+https://github.com/rust-lang/crates.io-index" 3269 3269 - checksum = "9980d917ebb0c0536119ba501e90834767bffc3d60641457fd84a1f3fd337923" 3257 3257 + checksum = "612460d5f7bea540c490b2b6395d8e34a953e52b491accd6c86c8164c5932a63" 3270 3258 dependencies = [ 3271 3259 "openssl-probe", 3272 3260 "rustls-pki-types", ··· 3276 3264 3277 3265 [[package]] 3278 3266 name = "rustls-pki-types" 3279 3279 - version = "1.13.0" 3267 3267 + version = "1.13.2" 3280 3268 source = "registry+https://github.com/rust-lang/crates.io-index" 3281 3281 - checksum = "94182ad936a0c91c324cd46c6511b9510ed16af436d7b5bab34beab0afd55f7a" 3269 3269 + checksum = "21e6f2ab2928ca4291b86736a8bd920a277a399bba1589409d72154ff87c1282" 3282 3270 dependencies = [ 3283 3271 "web-time", 3284 3272 "zeroize", ··· 3303 3291 3304 3292 [[package]] 3305 3293 name = "ryu" 3306 3306 - version = "1.0.20" 3294 3294 + version = "1.0.22" 3307 3295 source = "registry+https://github.com/rust-lang/crates.io-index" 3308 3308 - checksum = "28d3b2b1366ec20994f1fd18c3c594f05c5dd4bc44d8bb0c1c632c8d6829481f" 3296 3296 + checksum = "a50f4cf475b65d88e057964e0e9bb1f0aa9bbb2036dc65c64596b42932536984" 3309 3297 3310 3298 [[package]] 3311 3299 name = "safemem" ··· 3332 3320 ] 3333 3321 3334 3322 [[package]] 3335 3335 - name = "schemars" 3336 3336 - version = "0.9.0" 3337 3337 - source = "registry+https://github.com/rust-lang/crates.io-index" 3338 3338 - checksum = "4cd191f9397d57d581cddd31014772520aa448f65ef991055d7f61582c65165f" 3339 3339 - dependencies = [ 3340 3340 - "dyn-clone", 3341 3341 - "ref-cast", 3342 3342 - "serde", 3343 3343 - "serde_json", 3344 3344 - ] 3345 3345 - 3346 3346 - [[package]] 3347 3347 - name = "schemars" 3348 3348 - version = "1.1.0" 3349 3349 - source = "registry+https://github.com/rust-lang/crates.io-index" 3350 3350 - checksum = "9558e172d4e8533736ba97870c4b2cd63f84b382a3d6eb063da41b91cce17289" 3351 3351 - dependencies = [ 3352 3352 - "dyn-clone", 3353 3353 - "ref-cast", 3354 3354 - "serde", 3355 3355 - "serde_json", 3356 3356 - ] 3357 3357 - 3358 3358 - [[package]] 3359 3323 name = "scoped-tls" 3360 3324 version = "1.0.1" 3361 3325 source = "registry+https://github.com/rust-lang/crates.io-index" ··· 3403 3367 "core-foundation-sys", 3404 3368 "libc", 3405 3369 ] 3370 3370 + 3371 3371 + [[package]] 3372 3372 + name = "semver" 3373 3373 + version = "1.0.27" 3374 3374 + source = "registry+https://github.com/rust-lang/crates.io-index" 3375 3375 + checksum = "d767eb0aabc880b29956c35734170f26ed551a859dbd361d140cdbeca61ab1e2" 3406 3376 3407 3377 [[package]] 3408 3378 name = "send_wrapper" ··· 3447 3417 dependencies = [ 3448 3418 "proc-macro2", 3449 3419 "quote", 3450 3450 - "syn 2.0.111", 3420 3420 + "syn 2.0.113", 3451 3421 ] 3452 3422 3453 3423 [[package]] 3454 3424 name = "serde_html_form" 3455 3455 - version = "0.2.8" 3425 3425 + version = "0.3.2" 3456 3426 source = "registry+https://github.com/rust-lang/crates.io-index" 3457 3457 - checksum = "b2f2d7ff8a2140333718bb329f5c40fc5f0865b84c426183ce14c97d2ab8154f" 3427 3427 + checksum = "2acf96b1d9364968fce46ebb548f1c0e1d7eceae27bdff73865d42e6c7369d94" 3458 3428 dependencies = [ 3459 3429 "form_urlencoded", 3460 3460 - "indexmap 2.12.1", 3430 3430 + "indexmap", 3461 3431 "itoa", 3462 3462 - "ryu", 3463 3432 "serde_core", 3464 3433 ] 3465 3434 ··· 3477 3446 3478 3447 [[package]] 3479 3448 name = "serde_json" 3480 3480 - version = "1.0.145" 3449 3449 + version = "1.0.149" 3481 3450 source = "registry+https://github.com/rust-lang/crates.io-index" 3482 3482 - checksum = "402a6f66d8c709116cf22f558eab210f5a50187f702eb4d7e5ef38d9a7f1c79c" 3451 3451 + checksum = "83fc039473c5595ace860d8c4fafa220ff474b3fc6bfdb4293327f1a37e94d86" 3483 3452 dependencies = [ 3484 3453 "itoa", 3485 3454 "memchr", 3486 3486 - "ryu", 3487 3455 "serde", 3488 3456 "serde_core", 3457 3457 + "zmij", 3489 3458 ] 3490 3459 3491 3460 [[package]] ··· 3507 3476 dependencies = [ 3508 3477 "proc-macro2", 3509 3478 "quote", 3510 3510 - "syn 2.0.111", 3479 3479 + "syn 2.0.113", 3511 3480 ] 3512 3481 3513 3482 [[package]] ··· 3524 3493 3525 3494 [[package]] 3526 3495 name = "serde_with" 3527 3527 - version = "3.16.0" 3496 3496 + version = "3.16.1" 3528 3497 source = "registry+https://github.com/rust-lang/crates.io-index" 3529 3529 - checksum = "10574371d41b0d9b2cff89418eda27da52bcaff2cc8741db26382a77c29131f1" 3498 3498 + checksum = "4fa237f2807440d238e0364a218270b98f767a00d3dada77b1c53ae88940e2e7" 3530 3499 dependencies = [ 3531 3500 "base64 0.22.1", 3532 3501 "chrono", 3533 3502 "hex", 3534 3534 - "indexmap 1.9.3", 3535 3535 - "indexmap 2.12.1", 3536 3536 - "schemars 0.9.0", 3537 3537 - "schemars 1.1.0", 3538 3503 "serde_core", 3539 3504 "serde_json", 3540 3505 "serde_with_macros", ··· 3543 3508 3544 3509 [[package]] 3545 3510 name = "serde_with_macros" 3546 3546 - version = "3.16.0" 3511 3511 + version = "3.16.1" 3547 3512 source = "registry+https://github.com/rust-lang/crates.io-index" 3548 3548 - checksum = "08a72d8216842fdd57820dc78d840bef99248e35fb2554ff923319e60f2d686b" 3513 3513 + checksum = "52a8e3ca0ca629121f70ab50f95249e5a6f925cc0f6ffe8256c45b728875706c" 3549 3514 dependencies = [ 3550 3515 "darling", 3551 3516 "proc-macro2", 3552 3517 "quote", 3553 3553 - "syn 2.0.111", 3518 3518 + "syn 2.0.113", 3554 3519 ] 3555 3520 3556 3521 [[package]] ··· 3607 3572 3608 3573 [[package]] 3609 3574 name = "signal-hook-registry" 3610 3610 - version = "1.4.7" 3575 3575 + version = "1.4.8" 3611 3576 source = "registry+https://github.com/rust-lang/crates.io-index" 3612 3612 - checksum = "7664a098b8e616bdfcc2dc0e9ac44eb231eedf41db4e9fe95d8d32ec728dedad" 3577 3577 + checksum = "c4db69cba1110affc0e9f7bcd48bbf87b3f4fc7c61fc9155afd4c469eb3d6c1b" 3613 3578 dependencies = [ 3579 3579 + "errno", 3614 3580 "libc", 3615 3581 ] 3616 3582 ··· 3626 3592 3627 3593 [[package]] 3628 3594 name = "simd-adler32" 3629 3629 - version = "0.3.7" 3595 3595 + version = "0.3.8" 3630 3596 source = "registry+https://github.com/rust-lang/crates.io-index" 3631 3631 - checksum = "d66dc143e6b11c1eddc06d5c423cfc97062865baf299914ab64caa38182078fe" 3597 3597 + checksum = "e320a6c5ad31d271ad523dcf3ad13e2767ad8b1cb8f047f75a8aeaf8da139da2" 3632 3598 3633 3599 [[package]] 3634 3600 name = "siphasher" ··· 3683 3649 version = "0.9.8" 3684 3650 source = "registry+https://github.com/rust-lang/crates.io-index" 3685 3651 checksum = "6980e8d7511241f8acf4aebddbb1ff938df5eebe98691418c4468d0b72a96a67" 3652 3652 + dependencies = [ 3653 3653 + "lock_api", 3654 3654 + ] 3686 3655 3687 3656 [[package]] 3688 3657 name = "spin" ··· 3707 3676 checksum = "6ce2be8dc25455e1f91df71bfa12ad37d7af1092ae736f3a6cd0e37bc7810596" 3708 3677 3709 3678 [[package]] 3710 3710 - name = "static-regular-grammar" 3711 3711 - version = "2.0.2" 3712 3712 - source = "registry+https://github.com/rust-lang/crates.io-index" 3713 3713 - checksum = "4f4a6c40247579acfbb138c3cd7de3dab113ab4ac6227f1b7de7d626ee667957" 3714 3714 - dependencies = [ 3715 3715 - "abnf", 3716 3716 - "btree-range-map", 3717 3717 - "ciborium", 3718 3718 - "hex_fmt", 3719 3719 - "indoc", 3720 3720 - "proc-macro-error", 3721 3721 - "proc-macro2", 3722 3722 - "quote", 3723 3723 - "serde", 3724 3724 - "sha2", 3725 3725 - "syn 2.0.111", 3726 3726 - "thiserror 1.0.69", 3727 3727 - ] 3728 3728 - 3729 3729 - [[package]] 3730 3679 name = "static_assertions" 3731 3680 version = "1.1.0" 3732 3681 source = "registry+https://github.com/rust-lang/crates.io-index" ··· 3780 3729 3781 3730 [[package]] 3782 3731 name = "supports-hyperlinks" 3783 3783 - version = "3.1.0" 3732 3732 + version = "3.2.0" 3784 3733 source = "registry+https://github.com/rust-lang/crates.io-index" 3785 3785 - checksum = "804f44ed3c63152de6a9f90acbea1a110441de43006ea51bcce8f436196a288b" 3734 3734 + checksum = "e396b6523b11ccb83120b115a0b7366de372751aa6edf19844dfb13a6af97e91" 3786 3735 3787 3736 [[package]] 3788 3737 name = "supports-unicode" ··· 3803 3752 3804 3753 [[package]] 3805 3754 name = "syn" 3806 3806 - version = "2.0.111" 3755 3755 + version = "2.0.113" 3807 3756 source = "registry+https://github.com/rust-lang/crates.io-index" 3808 3808 - checksum = "390cc9a294ab71bdb1aa2e99d13be9c753cd2d7bd6560c77118597410c4d2e87" 3757 3757 + checksum = "678faa00651c9eb72dd2020cbdf275d92eccb2400d568e419efdd64838145cb4" 3809 3758 dependencies = [ 3810 3759 "proc-macro2", 3811 3760 "quote", ··· 3829 3778 dependencies = [ 3830 3779 "proc-macro2", 3831 3780 "quote", 3832 3832 - "syn 2.0.111", 3781 3781 + "syn 2.0.113", 3833 3782 ] 3834 3783 3835 3784 [[package]] ··· 3861 3810 3862 3811 [[package]] 3863 3812 name = "tempfile" 3864 3864 - version = "3.23.0" 3813 3813 + version = "3.24.0" 3865 3814 source = "registry+https://github.com/rust-lang/crates.io-index" 3866 3866 - checksum = "2d31c77bdf42a745371d260a26ca7163f1e0924b64afa0b688e61b5a9fa02f16" 3815 3815 + checksum = "655da9c7eb6305c55742045d5a8d2037996d61d8de95806335c7c86ce0f82e9c" 3867 3816 dependencies = [ 3868 3817 "fastrand", 3869 3818 "getrandom 0.3.4", ··· 3929 3878 dependencies = [ 3930 3879 "proc-macro2", 3931 3880 "quote", 3932 3932 - "syn 2.0.111", 3881 3881 + "syn 2.0.113", 3933 3882 ] 3934 3883 3935 3884 [[package]] ··· 3940 3889 dependencies = [ 3941 3890 "proc-macro2", 3942 3891 "quote", 3943 3943 - "syn 2.0.111", 3892 3892 + "syn 2.0.113", 3944 3893 ] 3945 3894 3946 3895 [[package]] ··· 3968 3917 checksum = "91e7d9e3bb61134e77bde20dd4825b97c010155709965fedf0f49bb138e52a9d" 3969 3918 dependencies = [ 3970 3919 "deranged", 3971 3971 - "itoa", 3972 3920 "libc", 3973 3921 "num-conv", 3974 3922 "num_threads", 3975 3923 "powerfmt", 3976 3924 "serde", 3977 3925 "time-core", 3978 3978 - "time-macros", 3979 3926 ] 3980 3927 3981 3928 [[package]] ··· 3983 3930 version = "0.1.6" 3984 3931 source = "registry+https://github.com/rust-lang/crates.io-index" 3985 3932 checksum = "40868e7c1d2f0b8d73e4a8c7f0ff63af4f6d19be117e90bd73eb1d62cf831c6b" 3986 3986 - 3987 3987 - [[package]] 3988 3988 - name = "time-macros" 3989 3989 - version = "0.2.24" 3990 3990 - source = "registry+https://github.com/rust-lang/crates.io-index" 3991 3991 - checksum = "30cfb0125f12d9c277f35663a0a33f8c30190f4e4574868a330595412d34ebf3" 3992 3992 - dependencies = [ 3993 3993 - "num-conv", 3994 3994 - "time-core", 3995 3995 - ] 3996 3933 3997 3934 [[package]] 3998 3935 name = "tiny_http" ··· 4033 3970 4034 3971 [[package]] 4035 3972 name = "tokio" 4036 4036 - version = "1.48.0" 3973 3973 + version = "1.49.0" 4037 3974 source = "registry+https://github.com/rust-lang/crates.io-index" 4038 4038 - checksum = "ff360e02eab121e0bc37a2d3b4d4dc622e6eda3a8e5253d5435ecf5bd4c68408" 3975 3975 + checksum = "72a2903cd7736441aac9df9d7688bd0ce48edccaadf181c3b90be801e81d3d86" 4039 3976 dependencies = [ 4040 3977 "bytes", 4041 3978 "libc", ··· 4056 3993 dependencies = [ 4057 3994 "proc-macro2", 4058 3995 "quote", 4059 4059 - "syn 2.0.111", 3996 3996 + "syn 2.0.113", 4060 3997 ] 4061 3998 4062 3999 [[package]] ··· 4106 4043 4107 4044 [[package]] 4108 4045 name = "tokio-util" 4109 4109 - version = "0.7.17" 4046 4046 + version = "0.7.18" 4110 4047 source = "registry+https://github.com/rust-lang/crates.io-index" 4111 4111 - checksum = "2efa149fe76073d6e8fd97ef4f4eca7b67f599660115591483572e406e165594" 4048 4048 + checksum = "9ae9cec805b01e8fc3fd2fe289f89149a9b66dd16786abd8b19cfa7b48cb0098" 4112 4049 dependencies = [ 4113 4050 "bytes", 4114 4051 "futures-core", ··· 4136 4073 4137 4074 [[package]] 4138 4075 name = "tower-http" 4139 4139 - version = "0.6.7" 4076 4076 + version = "0.6.8" 4140 4077 source = "registry+https://github.com/rust-lang/crates.io-index" 4141 4141 - checksum = "9cf146f99d442e8e68e585f5d798ccd3cad9a7835b917e09728880a862706456" 4078 4078 + checksum = "d4e6559d53cc268e5031cd8429d05415bc4cb4aefc4aa5d6cc35fbf5b924a1f8" 4142 4079 dependencies = [ 4143 4080 "async-compression", 4144 4081 "bitflags", ··· 4177 4114 4178 4115 [[package]] 4179 4116 name = "tracing" 4180 4180 - version = "0.1.41" 4117 4117 + version = "0.1.44" 4181 4118 source = "registry+https://github.com/rust-lang/crates.io-index" 4182 4182 - checksum = "784e0ac535deb450455cbfa28a6f0df145ea1bb7ae51b821cf5e7927fdcfbdd0" 4119 4119 + checksum = "63e71662fa4b2a2c3a26f570f037eb95bb1f85397f3cd8076caed2f026a6d100" 4183 4120 dependencies = [ 4184 4121 "log", 4185 4122 "pin-project-lite", ··· 4189 4126 4190 4127 [[package]] 4191 4128 name = "tracing-attributes" 4192 4192 - version = "0.1.30" 4129 4129 + version = "0.1.31" 4193 4130 source = "registry+https://github.com/rust-lang/crates.io-index" 4194 4194 - checksum = "81383ab64e72a7a8b8e13130c49e3dab29def6d0c7d76a03087b3cf71c5c6903" 4131 4131 + checksum = "7490cfa5ec963746568740651ac6781f701c9c5ea257c58e057f3ba8cf69e8da" 4195 4132 dependencies = [ 4196 4133 "proc-macro2", 4197 4134 "quote", 4198 4198 - "syn 2.0.111", 4135 4135 + "syn 2.0.113", 4199 4136 ] 4200 4137 4201 4138 [[package]] 4202 4139 name = "tracing-core" 4203 4203 - version = "0.1.34" 4140 4140 + version = "0.1.36" 4204 4141 source = "registry+https://github.com/rust-lang/crates.io-index" 4205 4205 - checksum = "b9d12581f227e93f094d3af2ae690a574abb8a2b9b7a96e7cfe9647b2b617678" 4142 4142 + checksum = "db97caf9d906fbde555dd62fa95ddba9eecfd14cb388e4f491a66d74cd5fb79a" 4206 4143 dependencies = [ 4207 4144 "once_cell", 4208 4145 "valuable", ··· 4221 4158 4222 4159 [[package]] 4223 4160 name = "tracing-subscriber" 4224 4224 - version = "0.3.20" 4161 4161 + version = "0.3.22" 4225 4162 source = "registry+https://github.com/rust-lang/crates.io-index" 4226 4226 - checksum = "2054a14f5307d601f88daf0553e1cbf472acc4f2c51afab632431cdcd72124d5" 4163 4163 + checksum = "2f30143827ddab0d256fd843b7a66d164e9f271cfa0dde49142c5ca0ca291f1e" 4227 4164 dependencies = [ 4228 4165 "matchers", 4229 4166 "nu-ansi-term", ··· 4245 4182 dependencies = [ 4246 4183 "proc-macro2", 4247 4184 "quote", 4248 4248 - "syn 2.0.111", 4185 4185 + "syn 2.0.113", 4249 4186 ] 4250 4187 4251 4188 [[package]] ··· 4297 4234 4298 4235 [[package]] 4299 4236 name = "unicase" 4300 4300 - version = "2.8.1" 4237 4237 + version = "2.9.0" 4301 4238 source = "registry+https://github.com/rust-lang/crates.io-index" 4302 4302 - checksum = "75b844d17643ee918803943289730bec8aac480150456169e647ed0b576ba539" 4239 4239 + checksum = "dbc4bc3a9f746d862c45cb89d705aa10f187bb96c76001afab07a0d35ce60142" 4303 4240 4304 4241 [[package]] 4305 4242 name = "unicode-ident" ··· 4351 4288 4352 4289 [[package]] 4353 4290 name = "url" 4354 4354 - version = "2.5.7" 4291 4291 + version = "2.5.8" 4355 4292 source = "registry+https://github.com/rust-lang/crates.io-index" 4356 4356 - checksum = "08bc136a29a3d1758e07a9cca267be308aeebf5cfd5a10f3f67ab2097683ef5b" 4293 4293 + checksum = "ff67a8a4397373c3ef660812acab3268222035010ab8680ec4215f38ba3d0eed" 4357 4294 dependencies = [ 4358 4295 "form_urlencoded", 4359 4296 "idna", 4360 4297 "percent-encoding", 4361 4298 "serde", 4299 4299 + "serde_derive", 4362 4300 ] 4363 4301 4364 4302 [[package]] ··· 4433 4371 4434 4372 [[package]] 4435 4373 name = "wasm-bindgen" 4436 4436 - version = "0.2.105" 4374 4374 + version = "0.2.106" 4437 4375 source = "registry+https://github.com/rust-lang/crates.io-index" 4438 4438 - checksum = "da95793dfc411fbbd93f5be7715b0578ec61fe87cb1a42b12eb625caa5c5ea60" 4376 4376 + checksum = "0d759f433fa64a2d763d1340820e46e111a7a5ab75f993d1852d70b03dbb80fd" 4439 4377 dependencies = [ 4440 4378 "cfg-if", 4441 4379 "once_cell", ··· 4446 4384 4447 4385 [[package]] 4448 4386 name = "wasm-bindgen-futures" 4449 4449 - version = "0.4.55" 4387 4387 + version = "0.4.56" 4450 4388 source = "registry+https://github.com/rust-lang/crates.io-index" 4451 4451 - checksum = "551f88106c6d5e7ccc7cd9a16f312dd3b5d36ea8b4954304657d5dfba115d4a0" 4389 4389 + checksum = "836d9622d604feee9e5de25ac10e3ea5f2d65b41eac0d9ce72eb5deae707ce7c" 4452 4390 dependencies = [ 4453 4391 "cfg-if", 4454 4392 "js-sys", ··· 4459 4397 4460 4398 [[package]] 4461 4399 name = "wasm-bindgen-macro" 4462 4462 - version = "0.2.105" 4400 4400 + version = "0.2.106" 4463 4401 source = "registry+https://github.com/rust-lang/crates.io-index" 4464 4464 - checksum = "04264334509e04a7bf8690f2384ef5265f05143a4bff3889ab7a3269adab59c2" 4402 4402 + checksum = "48cb0d2638f8baedbc542ed444afc0644a29166f1595371af4fecf8ce1e7eeb3" 4465 4403 dependencies = [ 4466 4404 "quote", 4467 4405 "wasm-bindgen-macro-support", ··· 4469 4407 4470 4408 [[package]] 4471 4409 name = "wasm-bindgen-macro-support" 4472 4472 - version = "0.2.105" 4410 4410 + version = "0.2.106" 4473 4411 source = "registry+https://github.com/rust-lang/crates.io-index" 4474 4474 - checksum = "420bc339d9f322e562942d52e115d57e950d12d88983a14c79b86859ee6c7ebc" 4412 4412 + checksum = "cefb59d5cd5f92d9dcf80e4683949f15ca4b511f4ac0a6e14d4e1ac60c6ecd40" 4475 4413 dependencies = [ 4476 4414 "bumpalo", 4477 4415 "proc-macro2", 4478 4416 "quote", 4479 4479 - "syn 2.0.111", 4417 4417 + "syn 2.0.113", 4480 4418 "wasm-bindgen-shared", 4481 4419 ] 4482 4420 4483 4421 [[package]] 4484 4422 name = "wasm-bindgen-shared" 4485 4485 - version = "0.2.105" 4423 4423 + version = "0.2.106" 4486 4424 source = "registry+https://github.com/rust-lang/crates.io-index" 4487 4487 - checksum = "76f218a38c84bcb33c25ec7059b07847d465ce0e0a76b995e134a45adcb6af76" 4425 4425 + checksum = "cbc538057e648b67f72a982e708d485b2efa771e1ac05fec311f9f63e5800db4" 4488 4426 dependencies = [ 4489 4427 "unicode-ident", 4490 4428 ] ··· 4504 4442 4505 4443 [[package]] 4506 4444 name = "web-sys" 4507 4507 - version = "0.3.82" 4445 4445 + version = "0.3.83" 4508 4446 source = "registry+https://github.com/rust-lang/crates.io-index" 4509 4509 - checksum = "3a1f95c0d03a47f4ae1f7a64643a6bb97465d9b740f0fa8f90ea33915c99a9a1" 4447 4447 + checksum = "9b32828d774c412041098d182a8b38b16ea816958e07cf40eec2bc080ae137ac" 4510 4448 dependencies = [ 4511 4449 "js-sys", 4512 4450 "wasm-bindgen", ··· 4552 4490 4553 4491 [[package]] 4554 4492 name = "webpki-roots" 4555 4555 - version = "1.0.4" 4493 4493 + version = "1.0.5" 4556 4494 source = "registry+https://github.com/rust-lang/crates.io-index" 4557 4557 - checksum = "b2878ef029c47c6e8cf779119f20fcf52bde7ad42a731b2a304bc221df17571e" 4495 4495 + checksum = "12bed680863276c63889429bfd6cab3b99943659923822de1c8a39c49e4d722c" 4558 4496 dependencies = [ 4559 4497 "rustls-pki-types", 4560 4498 ] ··· 4575 4513 ] 4576 4514 4577 4515 [[package]] 4578 4578 - name = "windows" 4579 4579 - version = "0.61.3" 4580 4580 - source = "registry+https://github.com/rust-lang/crates.io-index" 4581 4581 - checksum = "9babd3a767a4c1aef6900409f85f5d53ce2544ccdfaa86dad48c91782c6d6893" 4582 4582 - dependencies = [ 4583 4583 - "windows-collections", 4584 4584 - "windows-core 0.61.2", 4585 4585 - "windows-future", 4586 4586 - "windows-link 0.1.3", 4587 4587 - "windows-numerics", 4588 4588 - ] 4589 4589 - 4590 4590 - [[package]] 4591 4591 - name = "windows-collections" 4592 4592 - version = "0.2.0" 4593 4593 - source = "registry+https://github.com/rust-lang/crates.io-index" 4594 4594 - checksum = "3beeceb5e5cfd9eb1d76b381630e82c4241ccd0d27f1a39ed41b2760b255c5e8" 4595 4595 - dependencies = [ 4596 4596 - "windows-core 0.61.2", 4597 4597 - ] 4598 4598 - 4599 4599 - [[package]] 4600 4600 - name = "windows-core" 4601 4601 - version = "0.61.2" 4602 4602 - source = "registry+https://github.com/rust-lang/crates.io-index" 4603 4603 - checksum = "c0fdd3ddb90610c7638aa2b3a3ab2904fb9e5cdbecc643ddb3647212781c4ae3" 4604 4604 - dependencies = [ 4605 4605 - "windows-implement", 4606 4606 - "windows-interface", 4607 4607 - "windows-link 0.1.3", 4608 4608 - "windows-result 0.3.4", 4609 4609 - "windows-strings 0.4.2", 4610 4610 - ] 4611 4611 - 4612 4612 - [[package]] 4613 4516 name = "windows-core" 4614 4517 version = "0.62.2" 4615 4518 source = "registry+https://github.com/rust-lang/crates.io-index" ··· 4617 4520 dependencies = [ 4618 4521 "windows-implement", 4619 4522 "windows-interface", 4620 4620 - "windows-link 0.2.1", 4621 4621 - "windows-result 0.4.1", 4622 4622 - "windows-strings 0.5.1", 4623 4623 - ] 4624 4624 - 4625 4625 - [[package]] 4626 4626 - name = "windows-future" 4627 4627 - version = "0.2.1" 4628 4628 - source = "registry+https://github.com/rust-lang/crates.io-index" 4629 4629 - checksum = "fc6a41e98427b19fe4b73c550f060b59fa592d7d686537eebf9385621bfbad8e" 4630 4630 - dependencies = [ 4631 4631 - "windows-core 0.61.2", 4632 4632 - "windows-link 0.1.3", 4633 4633 - "windows-threading", 4523 4523 + "windows-link", 4524 4524 + "windows-result", 4525 4525 + "windows-strings", 4634 4526 ] 4635 4527 4636 4528 [[package]] ··· 4641 4533 dependencies = [ 4642 4534 "proc-macro2", 4643 4535 "quote", 4644 4644 - "syn 2.0.111", 4536 4536 + "syn 2.0.113", 4645 4537 ] 4646 4538 4647 4539 [[package]] ··· 4652 4544 dependencies = [ 4653 4545 "proc-macro2", 4654 4546 "quote", 4655 4655 - "syn 2.0.111", 4547 4547 + "syn 2.0.113", 4656 4548 ] 4657 4549 4658 4550 [[package]] 4659 4551 name = "windows-link" 4660 4660 - version = "0.1.3" 4661 4661 - source = "registry+https://github.com/rust-lang/crates.io-index" 4662 4662 - checksum = "5e6ad25900d524eaabdbbb96d20b4311e1e7ae1699af4fb28c17ae66c80d798a" 4663 4663 - 4664 4664 - [[package]] 4665 4665 - name = "windows-link" 4666 4552 version = "0.2.1" 4667 4553 source = "registry+https://github.com/rust-lang/crates.io-index" 4668 4554 checksum = "f0805222e57f7521d6a62e36fa9163bc891acd422f971defe97d64e70d0a4fe5" 4669 4555 4670 4556 [[package]] 4671 4671 - name = "windows-numerics" 4672 4672 - version = "0.2.0" 4673 4673 - source = "registry+https://github.com/rust-lang/crates.io-index" 4674 4674 - checksum = "9150af68066c4c5c07ddc0ce30421554771e528bde427614c61038bc2c92c2b1" 4675 4675 - dependencies = [ 4676 4676 - "windows-core 0.61.2", 4677 4677 - "windows-link 0.1.3", 4678 4678 - ] 4679 4679 - 4680 4680 - [[package]] 4681 4557 name = "windows-registry" 4682 4558 version = "0.6.1" 4683 4559 source = "registry+https://github.com/rust-lang/crates.io-index" 4684 4560 checksum = "02752bf7fbdcce7f2a27a742f798510f3e5ad88dbe84871e5168e2120c3d5720" 4685 4561 dependencies = [ 4686 4686 - "windows-link 0.2.1", 4687 4687 - "windows-result 0.4.1", 4688 4688 - "windows-strings 0.5.1", 4689 4689 - ] 4690 4690 - 4691 4691 - [[package]] 4692 4692 - name = "windows-result" 4693 4693 - version = "0.3.4" 4694 4694 - source = "registry+https://github.com/rust-lang/crates.io-index" 4695 4695 - checksum = "56f42bd332cc6c8eac5af113fc0c1fd6a8fd2aa08a0119358686e5160d0586c6" 4696 4696 - dependencies = [ 4697 4697 - "windows-link 0.1.3", 4562 4562 + "windows-link", 4563 4563 + "windows-result", 4564 4564 + "windows-strings", 4698 4565 ] 4699 4566 4700 4567 [[package]] ··· 4703 4570 source = "registry+https://github.com/rust-lang/crates.io-index" 4704 4571 checksum = "7781fa89eaf60850ac3d2da7af8e5242a5ea78d1a11c49bf2910bb5a73853eb5" 4705 4572 dependencies = [ 4706 4706 - "windows-link 0.2.1", 4707 4707 - ] 4708 4708 - 4709 4709 - [[package]] 4710 4710 - name = "windows-strings" 4711 4711 - version = "0.4.2" 4712 4712 - source = "registry+https://github.com/rust-lang/crates.io-index" 4713 4713 - checksum = "56e6c93f3a0c3b36176cb1327a4958a0353d5d166c2a35cb268ace15e91d3b57" 4714 4714 - dependencies = [ 4715 4715 - "windows-link 0.1.3", 4573 4573 + "windows-link", 4716 4574 ] 4717 4575 4718 4576 [[package]] ··· 4721 4579 source = "registry+https://github.com/rust-lang/crates.io-index" 4722 4580 checksum = "7837d08f69c77cf6b07689544538e017c1bfcf57e34b4c0ff58e6c2cd3b37091" 4723 4581 dependencies = [ 4724 4724 - "windows-link 0.2.1", 4582 4582 + "windows-link", 4725 4583 ] 4726 4584 4727 4585 [[package]] ··· 4775 4633 source = "registry+https://github.com/rust-lang/crates.io-index" 4776 4634 checksum = "ae137229bcbd6cdf0f7b80a31df61766145077ddf49416a728b02cb3921ff3fc" 4777 4635 dependencies = [ 4778 4778 - "windows-link 0.2.1", 4636 4636 + "windows-link", 4779 4637 ] 4780 4638 4781 4639 [[package]] ··· 4830 4688 source = "registry+https://github.com/rust-lang/crates.io-index" 4831 4689 checksum = "4945f9f551b88e0d65f3db0bc25c33b8acea4d9e41163edf90dcd0b19f9069f3" 4832 4690 dependencies = [ 4833 4833 - "windows-link 0.2.1", 4691 4691 + "windows-link", 4834 4692 "windows_aarch64_gnullvm 0.53.1", 4835 4693 "windows_aarch64_msvc 0.53.1", 4836 4694 "windows_i686_gnu 0.53.1", ··· 4839 4697 "windows_x86_64_gnu 0.53.1", 4840 4698 "windows_x86_64_gnullvm 0.53.1", 4841 4699 "windows_x86_64_msvc 0.53.1", 4842 4842 - ] 4843 4843 - 4844 4844 - [[package]] 4845 4845 - name = "windows-threading" 4846 4846 - version = "0.1.0" 4847 4847 - source = "registry+https://github.com/rust-lang/crates.io-index" 4848 4848 - checksum = "b66463ad2e0ea3bbf808b7f1d371311c80e115c0b71d60efc142cafbcfb057a6" 4849 4849 - dependencies = [ 4850 4850 - "windows-link 0.1.3", 4851 4700 ] 4852 4701 4853 4702 [[package]] ··· 5078 4927 "tower-http", 5079 4928 "url", 5080 4929 "walkdir", 4930 4930 + "wisp-lexicons", 4931 4931 + ] 4932 4932 + 4933 4933 + [[package]] 4934 4934 + name = "wisp-lexicons" 4935 4935 + version = "0.1.0" 4936 4936 + dependencies = [ 4937 4937 + "jacquard-common", 4938 4938 + "jacquard-derive", 4939 4939 + "jacquard-lexicon", 4940 4940 + "rustversion", 4941 4941 + "serde", 5081 4942 ] 5082 4943 5083 4944 [[package]] ··· 5128 4989 dependencies = [ 5129 4990 "proc-macro2", 5130 4991 "quote", 5131 5131 - "syn 2.0.111", 4992 4992 + "syn 2.0.113", 5132 4993 "synstructure", 5133 4994 ] 5134 4995 5135 4996 [[package]] 5136 4997 name = "zerocopy" 5137 5137 - version = "0.8.30" 4998 4998 + version = "0.8.32" 5138 4999 source = "registry+https://github.com/rust-lang/crates.io-index" 5139 5139 - checksum = "4ea879c944afe8a2b25fef16bb4ba234f47c694565e97383b36f3a878219065c" 5000 5000 + checksum = "1fabae64378cb18147bb18bca364e63bdbe72a0ffe4adf0addfec8aa166b2c56" 5140 5001 dependencies = [ 5141 5002 "zerocopy-derive", 5142 5003 ] 5143 5004 5144 5005 [[package]] 5145 5006 name = "zerocopy-derive" 5146 5146 - version = "0.8.30" 5007 5007 + version = "0.8.32" 5147 5008 source = "registry+https://github.com/rust-lang/crates.io-index" 5148 5148 - checksum = "cf955aa904d6040f70dc8e9384444cb1030aed272ba3cb09bbc4ab9e7c1f34f5" 5009 5009 + checksum = "c9c2d862265a8bb4471d87e033e730f536e2a285cc7cb05dbce09a2a97075f90" 5149 5010 dependencies = [ 5150 5011 "proc-macro2", 5151 5012 "quote", 5152 5152 - "syn 2.0.111", 5013 5013 + "syn 2.0.113", 5153 5014 ] 5154 5015 5155 5016 [[package]] ··· 5169 5030 dependencies = [ 5170 5031 "proc-macro2", 5171 5032 "quote", 5172 5172 - "syn 2.0.111", 5033 5033 + "syn 2.0.113", 5173 5034 "synstructure", 5174 5035 ] 5175 5036 ··· 5212 5073 dependencies = [ 5213 5074 "proc-macro2", 5214 5075 "quote", 5215 5215 - "syn 2.0.111", 5076 5076 + "syn 2.0.113", 5216 5077 ] 5078 5078 + 5079 5079 + [[package]] 5080 5080 + name = "zmij" 5081 5081 + version = "1.0.12" 5082 5082 + source = "registry+https://github.com/rust-lang/crates.io-index" 5083 5083 + checksum = "2fc5a66a20078bf1251bde995aa2fdcc4b800c70b5d92dd2c62abc5c60f679f8"

+8 -7

cli/Cargo.toml

··· 8 8 place_wisp = [] 9 9 10 10 [dependencies] 11 11 - jacquard = { git = "https://tangled.org/nekomimi.pet/jacquard", features = ["loopback"] } 12 12 - jacquard-oauth = { git = "https://tangled.org/nekomimi.pet/jacquard" } 13 13 - jacquard-api = { git = "https://tangled.org/nekomimi.pet/jacquard", features = ["streaming"] } 14 14 - jacquard-common = { git = "https://tangled.org/nekomimi.pet/jacquard", features = ["websocket"] } 15 15 - jacquard-identity = { git = "https://tangled.org/nekomimi.pet/jacquard", features = ["dns"] } 16 16 - jacquard-derive = { git = "https://tangled.org/nekomimi.pet/jacquard" } 17 17 - jacquard-lexicon = { git = "https://tangled.org/nekomimi.pet/jacquard" } 11 11 + jacquard = { git = "https://tangled.org/nonbinary.computer/jacquard", features = ["loopback"] } 12 12 + jacquard-oauth = { git = "https://tangled.org/nonbinary.computer/jacquard" } 13 13 + jacquard-api = { git = "https://tangled.org/nonbinary.computer/jacquard", features = ["streaming"] } 14 14 + jacquard-common = { git = "https://tangled.org/nonbinary.computer/jacquard", features = ["websocket"] } 15 15 + jacquard-identity = { git = "https://tangled.org/nonbinary.computer/jacquard", features = ["dns"] } 16 16 + jacquard-derive = { git = "https://tangled.org/nonbinary.computer/jacquard" } 17 17 + jacquard-lexicon = { git = "https://tangled.org/nonbinary.computer/jacquard" } 18 18 + wisp-lexicons = { path = "crates/lexicons" } 18 19 #jacquard = { path = "../../jacquard/crates/jacquard", features = ["loopback"] } 19 20 #jacquard-oauth = { path = "../../jacquard/crates/jacquard-oauth" } 20 21 #jacquard-api = { path = "../../jacquard/crates/jacquard-api", features = ["streaming"] }

+72 -2

cli/README.md

··· 32 32 33 33 ## Usage 34 34 35 35 + ### Commands 36 36 + 37 37 + The CLI supports three main commands: 38 38 + - **deploy**: Upload a site to your PDS (default command) 39 39 + - **pull**: Download a site from a PDS to a local directory 40 40 + - **serve**: Serve a site locally with real-time firehose updates 41 41 + 35 42 ### Basic Deployment 36 43 37 44 Deploy the current directory: 38 45 39 46 ```bash 40 40 - wisp-cli nekomimi.ppet --path . --site my-site 47 47 + wisp-cli nekomimi.pet --path . --site my-site 41 48 ``` 42 49 43 50 Deploy a specific directory: ··· 46 53 wisp-cli alice.bsky.social --path ./dist/ --site my-site 47 54 ``` 48 55 56 56 + Or use the explicit `deploy` subcommand: 57 57 + 58 58 + ```bash 59 59 + wisp-cli deploy alice.bsky.social --path ./dist/ --site my-site 60 60 + ``` 61 61 + 62 62 + ### Pull a Site 63 63 + 64 64 + Download a site from a PDS to a local directory: 65 65 + 66 66 + ```bash 67 67 + wisp-cli pull alice.bsky.social --site my-site --path ./downloaded-site 68 68 + ``` 69 69 + 70 70 + This will download all files from the site to the specified directory. 71 71 + 72 72 + ### Serve a Site Locally 73 73 + 74 74 + Serve a site locally with real-time updates from the firehose: 75 75 + 76 76 + ```bash 77 77 + wisp-cli serve alice.bsky.social --site my-site --path ./site --port 8080 78 78 + ``` 79 79 + 80 80 + This will: 81 81 + 1. Download the site to the specified path 82 82 + 2. Start a local server on the specified port (default: 8080) 83 83 + 3. Watch the firehose for updates and automatically reload files when changed 84 84 + 49 85 ### Authentication Methods 50 86 51 87 #### OAuth (Recommended) ··· 79 115 80 116 ## Command-Line Options 81 117 118 118 + ### Deploy Command 119 119 + 82 120 ``` 83 83 - wisp-cli [OPTIONS] <INPUT> 121 121 + wisp-cli [deploy] [OPTIONS] <INPUT> 84 122 85 123 Arguments: 86 124 <INPUT> Handle (e.g., alice.bsky.social), DID, or PDS URL ··· 90 128 -s, --site <SITE> Site name (defaults to directory name) 91 129 --store <STORE> Path to auth store file (only used with OAuth) [default: /tmp/wisp-oauth-session.json] 92 130 --password <PASSWORD> App Password for authentication (alternative to OAuth) 131 131 + --directory Enable directory listing mode for paths without index files 132 132 + --spa Enable SPA mode (serve index.html for all routes) 133 133 + -y, --yes Skip confirmation prompts (automatically accept warnings) 93 134 -h, --help Print help 94 135 -V, --version Print version 136 136 + ``` 137 137 + 138 138 + ### Pull Command 139 139 + 140 140 + ``` 141 141 + wisp-cli pull [OPTIONS] --site <SITE> <INPUT> 142 142 + 143 143 + Arguments: 144 144 + <INPUT> Handle (e.g., alice.bsky.social) or DID 145 145 + 146 146 + Options: 147 147 + -s, --site <SITE> Site name (record key) 148 148 + -p, --path <PATH> Output directory for the downloaded site [default: .] 149 149 + -h, --help Print help 150 150 + ``` 151 151 + 152 152 + ### Serve Command 153 153 + 154 154 + ``` 155 155 + wisp-cli serve [OPTIONS] --site <SITE> <INPUT> 156 156 + 157 157 + Arguments: 158 158 + <INPUT> Handle (e.g., alice.bsky.social) or DID 159 159 + 160 160 + Options: 161 161 + -s, --site <SITE> Site name (record key) 162 162 + -p, --path <PATH> Output directory for the site files [default: .] 163 163 + -P, --port <PORT> Port to serve on [default: 8080] 164 164 + -h, --help Print help 95 165 ``` 96 166 97 167 ## How It Works

+15

cli/crates/lexicons/Cargo.toml

··· 1 1 + [package] 2 2 + name = "wisp-lexicons" 3 3 + version = "0.1.0" 4 4 + edition = "2024" 5 5 + 6 6 + [features] 7 7 + default = ["place_wisp"] 8 8 + place_wisp = [] 9 9 + 10 10 + [dependencies] 11 11 + jacquard-common = { git = "https://tangled.org/nonbinary.computer/jacquard" } 12 12 + jacquard-derive = { git = "https://tangled.org/nonbinary.computer/jacquard" } 13 13 + jacquard-lexicon = { git = "https://tangled.org/nonbinary.computer/jacquard" } 14 14 + serde = { version = "1.0", features = ["derive"] } 15 15 + rustversion = "1.0"

+43

cli/crates/lexicons/src/builder_types.rs

··· 1 1 + // @generated by jacquard-lexicon. DO NOT EDIT. 2 2 + // 3 3 + // This file was automatically generated from Lexicon schemas. 4 4 + // Any manual changes will be overwritten on the next regeneration. 5 5 + 6 6 + /// Marker type indicating a builder field has been set 7 7 + pub struct Set<T>(pub T); 8 8 + impl<T> Set<T> { 9 9 + /// Extract the inner value 10 10 + #[inline] 11 11 + pub fn into_inner(self) -> T { 12 12 + self.0 13 13 + } 14 14 + } 15 15 + 16 16 + /// Marker type indicating a builder field has not been set 17 17 + pub struct Unset; 18 18 + /// Trait indicating a builder field is set (has a value) 19 19 + #[rustversion::attr( 20 20 + since(1.78.0), 21 21 + diagnostic::on_unimplemented( 22 22 + message = "the field `{Self}` was not set, but this method requires it to be set", 23 23 + label = "the field `{Self}` was not set" 24 24 + ) 25 25 + )] 26 26 + pub trait IsSet: private::Sealed {} 27 27 + /// Trait indicating a builder field is unset (no value yet) 28 28 + #[rustversion::attr( 29 29 + since(1.78.0), 30 30 + diagnostic::on_unimplemented( 31 31 + message = "the field `{Self}` was already set, but this method requires it to be unset", 32 32 + label = "the field `{Self}` was already set" 33 33 + ) 34 34 + )] 35 35 + pub trait IsUnset: private::Sealed {} 36 36 + impl<T> IsSet for Set<T> {} 37 37 + impl IsUnset for Unset {} 38 38 + mod private { 39 39 + /// Sealed trait to prevent external implementations 40 40 + pub trait Sealed {} 41 41 + impl<T> Sealed for super::Set<T> {} 42 42 + impl Sealed for super::Unset {} 43 43 + }

+11

cli/crates/lexicons/src/lib.rs

··· 1 1 + extern crate alloc; 2 2 + 3 3 + // @generated by jacquard-lexicon. DO NOT EDIT. 4 4 + // 5 5 + // This file was automatically generated from Lexicon schemas. 6 6 + // Any manual changes will be overwritten on the next regeneration. 7 7 + 8 8 + pub mod builder_types; 9 9 + 10 10 + #[cfg(feature = "place_wisp")] 11 11 + pub mod place_wisp;

+1490

cli/crates/lexicons/src/place_wisp/fs.rs

··· 1 1 + // @generated by jacquard-lexicon. DO NOT EDIT. 2 2 + // 3 3 + // Lexicon: place.wisp.fs 4 4 + // 5 5 + // This file was automatically generated from Lexicon schemas. 6 6 + // Any manual changes will be overwritten on the next regeneration. 7 7 + 8 8 + #[jacquard_derive::lexicon] 9 9 + #[derive( 10 10 + serde::Serialize, 11 11 + serde::Deserialize, 12 12 + Debug, 13 13 + Clone, 14 14 + PartialEq, 15 15 + Eq, 16 16 + jacquard_derive::IntoStatic 17 17 + )] 18 18 + #[serde(rename_all = "camelCase")] 19 19 + pub struct Directory<'a> { 20 20 + #[serde(borrow)] 21 21 + pub entries: Vec<crate::place_wisp::fs::Entry<'a>>, 22 22 + #[serde(borrow)] 23 23 + pub r#type: jacquard_common::CowStr<'a>, 24 24 + } 25 25 + 26 26 + pub mod directory_state { 27 27 + 28 28 + pub use crate::builder_types::{Set, Unset, IsSet, IsUnset}; 29 29 + #[allow(unused)] 30 30 + use ::core::marker::PhantomData; 31 31 + mod sealed { 32 32 + pub trait Sealed {} 33 33 + } 34 34 + /// State trait tracking which required fields have been set 35 35 + pub trait State: sealed::Sealed { 36 36 + type Type; 37 37 + type Entries; 38 38 + } 39 39 + /// Empty state - all required fields are unset 40 40 + pub struct Empty(()); 41 41 + impl sealed::Sealed for Empty {} 42 42 + impl State for Empty { 43 43 + type Type = Unset; 44 44 + type Entries = Unset; 45 45 + } 46 46 + ///State transition - sets the `type` field to Set 47 47 + pub struct SetType<S: State = Empty>(PhantomData<fn() -> S>); 48 48 + impl<S: State> sealed::Sealed for SetType<S> {} 49 49 + impl<S: State> State for SetType<S> { 50 50 + type Type = Set<members::r#type>; 51 51 + type Entries = S::Entries; 52 52 + } 53 53 + ///State transition - sets the `entries` field to Set 54 54 + pub struct SetEntries<S: State = Empty>(PhantomData<fn() -> S>); 55 55 + impl<S: State> sealed::Sealed for SetEntries<S> {} 56 56 + impl<S: State> State for SetEntries<S> { 57 57 + type Type = S::Type; 58 58 + type Entries = Set<members::entries>; 59 59 + } 60 60 + /// Marker types for field names 61 61 + #[allow(non_camel_case_types)] 62 62 + pub mod members { 63 63 + ///Marker type for the `type` field 64 64 + pub struct r#type(()); 65 65 + ///Marker type for the `entries` field 66 66 + pub struct entries(()); 67 67 + } 68 68 + } 69 69 + 70 70 + /// Builder for constructing an instance of this type 71 71 + pub struct DirectoryBuilder<'a, S: directory_state::State> { 72 72 + _phantom_state: ::core::marker::PhantomData<fn() -> S>, 73 73 + __unsafe_private_named: ( 74 74 + ::core::option::Option<Vec<crate::place_wisp::fs::Entry<'a>>>, 75 75 + ::core::option::Option<jacquard_common::CowStr<'a>>, 76 76 + ), 77 77 + _phantom: ::core::marker::PhantomData<&'a ()>, 78 78 + } 79 79 + 80 80 + impl<'a> Directory<'a> { 81 81 + /// Create a new builder for this type 82 82 + pub fn new() -> DirectoryBuilder<'a, directory_state::Empty> { 83 83 + DirectoryBuilder::new() 84 84 + } 85 85 + } 86 86 + 87 87 + impl<'a> DirectoryBuilder<'a, directory_state::Empty> { 88 88 + /// Create a new builder with all fields unset 89 89 + pub fn new() -> Self { 90 90 + DirectoryBuilder { 91 91 + _phantom_state: ::core::marker::PhantomData, 92 92 + __unsafe_private_named: (None, None), 93 93 + _phantom: ::core::marker::PhantomData, 94 94 + } 95 95 + } 96 96 + } 97 97 + 98 98 + impl<'a, S> DirectoryBuilder<'a, S> 99 99 + where 100 100 + S: directory_state::State, 101 101 + S::Entries: directory_state::IsUnset, 102 102 + { 103 103 + /// Set the `entries` field (required) 104 104 + pub fn entries( 105 105 + mut self, 106 106 + value: impl Into<Vec<crate::place_wisp::fs::Entry<'a>>>, 107 107 + ) -> DirectoryBuilder<'a, directory_state::SetEntries<S>> { 108 108 + self.__unsafe_private_named.0 = ::core::option::Option::Some(value.into()); 109 109 + DirectoryBuilder { 110 110 + _phantom_state: ::core::marker::PhantomData, 111 111 + __unsafe_private_named: self.__unsafe_private_named, 112 112 + _phantom: ::core::marker::PhantomData, 113 113 + } 114 114 + } 115 115 + } 116 116 + 117 117 + impl<'a, S> DirectoryBuilder<'a, S> 118 118 + where 119 119 + S: directory_state::State, 120 120 + S::Type: directory_state::IsUnset, 121 121 + { 122 122 + /// Set the `type` field (required) 123 123 + pub fn r#type( 124 124 + mut self, 125 125 + value: impl Into<jacquard_common::CowStr<'a>>, 126 126 + ) -> DirectoryBuilder<'a, directory_state::SetType<S>> { 127 127 + self.__unsafe_private_named.1 = ::core::option::Option::Some(value.into()); 128 128 + DirectoryBuilder { 129 129 + _phantom_state: ::core::marker::PhantomData, 130 130 + __unsafe_private_named: self.__unsafe_private_named, 131 131 + _phantom: ::core::marker::PhantomData, 132 132 + } 133 133 + } 134 134 + } 135 135 + 136 136 + impl<'a, S> DirectoryBuilder<'a, S> 137 137 + where 138 138 + S: directory_state::State, 139 139 + S::Type: directory_state::IsSet, 140 140 + S::Entries: directory_state::IsSet, 141 141 + { 142 142 + /// Build the final struct 143 143 + pub fn build(self) -> Directory<'a> { 144 144 + Directory { 145 145 + entries: self.__unsafe_private_named.0.unwrap(), 146 146 + r#type: self.__unsafe_private_named.1.unwrap(), 147 147 + extra_data: Default::default(), 148 148 + } 149 149 + } 150 150 + /// Build the final struct with custom extra_data 151 151 + pub fn build_with_data( 152 152 + self, 153 153 + extra_data: std::collections::BTreeMap< 154 154 + jacquard_common::smol_str::SmolStr, 155 155 + jacquard_common::types::value::Data<'a>, 156 156 + >, 157 157 + ) -> Directory<'a> { 158 158 + Directory { 159 159 + entries: self.__unsafe_private_named.0.unwrap(), 160 160 + r#type: self.__unsafe_private_named.1.unwrap(), 161 161 + extra_data: Some(extra_data), 162 162 + } 163 163 + } 164 164 + } 165 165 + 166 166 + fn lexicon_doc_place_wisp_fs() -> ::jacquard_lexicon::lexicon::LexiconDoc<'static> { 167 167 + ::jacquard_lexicon::lexicon::LexiconDoc { 168 168 + lexicon: ::jacquard_lexicon::lexicon::Lexicon::Lexicon1, 169 169 + id: ::jacquard_common::CowStr::new_static("place.wisp.fs"), 170 170 + revision: None, 171 171 + description: None, 172 172 + defs: { 173 173 + let mut map = ::std::collections::BTreeMap::new(); 174 174 + map.insert( 175 175 + ::jacquard_common::smol_str::SmolStr::new_static("directory"), 176 176 + ::jacquard_lexicon::lexicon::LexUserType::Object(::jacquard_lexicon::lexicon::LexObject { 177 177 + description: None, 178 178 + required: Some( 179 179 + vec![ 180 180 + ::jacquard_common::smol_str::SmolStr::new_static("type"), 181 181 + ::jacquard_common::smol_str::SmolStr::new_static("entries") 182 182 + ], 183 183 + ), 184 184 + nullable: None, 185 185 + properties: { 186 186 + #[allow(unused_mut)] 187 187 + let mut map = ::std::collections::BTreeMap::new(); 188 188 + map.insert( 189 189 + ::jacquard_common::smol_str::SmolStr::new_static("entries"), 190 190 + ::jacquard_lexicon::lexicon::LexObjectProperty::Array(::jacquard_lexicon::lexicon::LexArray { 191 191 + description: None, 192 192 + items: ::jacquard_lexicon::lexicon::LexArrayItem::Ref(::jacquard_lexicon::lexicon::LexRef { 193 193 + description: None, 194 194 + r#ref: ::jacquard_common::CowStr::new_static("#entry"), 195 195 + }), 196 196 + min_length: None, 197 197 + max_length: Some(500usize), 198 198 + }), 199 199 + ); 200 200 + map.insert( 201 201 + ::jacquard_common::smol_str::SmolStr::new_static("type"), 202 202 + ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString { 203 203 + description: None, 204 204 + format: None, 205 205 + default: None, 206 206 + min_length: None, 207 207 + max_length: None, 208 208 + min_graphemes: None, 209 209 + max_graphemes: None, 210 210 + r#enum: None, 211 211 + r#const: None, 212 212 + known_values: None, 213 213 + }), 214 214 + ); 215 215 + map 216 216 + }, 217 217 + }), 218 218 + ); 219 219 + map.insert( 220 220 + ::jacquard_common::smol_str::SmolStr::new_static("entry"), 221 221 + ::jacquard_lexicon::lexicon::LexUserType::Object(::jacquard_lexicon::lexicon::LexObject { 222 222 + description: None, 223 223 + required: Some( 224 224 + vec![ 225 225 + ::jacquard_common::smol_str::SmolStr::new_static("name"), 226 226 + ::jacquard_common::smol_str::SmolStr::new_static("node") 227 227 + ], 228 228 + ), 229 229 + nullable: None, 230 230 + properties: { 231 231 + #[allow(unused_mut)] 232 232 + let mut map = ::std::collections::BTreeMap::new(); 233 233 + map.insert( 234 234 + ::jacquard_common::smol_str::SmolStr::new_static("name"), 235 235 + ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString { 236 236 + description: None, 237 237 + format: None, 238 238 + default: None, 239 239 + min_length: None, 240 240 + max_length: Some(255usize), 241 241 + min_graphemes: None, 242 242 + max_graphemes: None, 243 243 + r#enum: None, 244 244 + r#const: None, 245 245 + known_values: None, 246 246 + }), 247 247 + ); 248 248 + map.insert( 249 249 + ::jacquard_common::smol_str::SmolStr::new_static("node"), 250 250 + ::jacquard_lexicon::lexicon::LexObjectProperty::Union(::jacquard_lexicon::lexicon::LexRefUnion { 251 251 + description: None, 252 252 + refs: vec![ 253 253 + ::jacquard_common::CowStr::new_static("#file"), 254 254 + ::jacquard_common::CowStr::new_static("#directory"), 255 255 + ::jacquard_common::CowStr::new_static("#subfs") 256 256 + ], 257 257 + closed: None, 258 258 + }), 259 259 + ); 260 260 + map 261 261 + }, 262 262 + }), 263 263 + ); 264 264 + map.insert( 265 265 + ::jacquard_common::smol_str::SmolStr::new_static("file"), 266 266 + ::jacquard_lexicon::lexicon::LexUserType::Object(::jacquard_lexicon::lexicon::LexObject { 267 267 + description: None, 268 268 + required: Some( 269 269 + vec![ 270 270 + ::jacquard_common::smol_str::SmolStr::new_static("type"), 271 271 + ::jacquard_common::smol_str::SmolStr::new_static("blob") 272 272 + ], 273 273 + ), 274 274 + nullable: None, 275 275 + properties: { 276 276 + #[allow(unused_mut)] 277 277 + let mut map = ::std::collections::BTreeMap::new(); 278 278 + map.insert( 279 279 + ::jacquard_common::smol_str::SmolStr::new_static("base64"), 280 280 + ::jacquard_lexicon::lexicon::LexObjectProperty::Boolean(::jacquard_lexicon::lexicon::LexBoolean { 281 281 + description: None, 282 282 + default: None, 283 283 + r#const: None, 284 284 + }), 285 285 + ); 286 286 + map.insert( 287 287 + ::jacquard_common::smol_str::SmolStr::new_static("blob"), 288 288 + ::jacquard_lexicon::lexicon::LexObjectProperty::Blob(::jacquard_lexicon::lexicon::LexBlob { 289 289 + description: None, 290 290 + accept: None, 291 291 + max_size: None, 292 292 + }), 293 293 + ); 294 294 + map.insert( 295 295 + ::jacquard_common::smol_str::SmolStr::new_static("encoding"), 296 296 + ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString { 297 297 + description: Some( 298 298 + ::jacquard_common::CowStr::new_static( 299 299 + "Content encoding (e.g., gzip for compressed files)", 300 300 + ), 301 301 + ), 302 302 + format: None, 303 303 + default: None, 304 304 + min_length: None, 305 305 + max_length: None, 306 306 + min_graphemes: None, 307 307 + max_graphemes: None, 308 308 + r#enum: None, 309 309 + r#const: None, 310 310 + known_values: None, 311 311 + }), 312 312 + ); 313 313 + map.insert( 314 314 + ::jacquard_common::smol_str::SmolStr::new_static("mimeType"), 315 315 + ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString { 316 316 + description: Some( 317 317 + ::jacquard_common::CowStr::new_static( 318 318 + "Original MIME type before compression", 319 319 + ), 320 320 + ), 321 321 + format: None, 322 322 + default: None, 323 323 + min_length: None, 324 324 + max_length: None, 325 325 + min_graphemes: None, 326 326 + max_graphemes: None, 327 327 + r#enum: None, 328 328 + r#const: None, 329 329 + known_values: None, 330 330 + }), 331 331 + ); 332 332 + map.insert( 333 333 + ::jacquard_common::smol_str::SmolStr::new_static("type"), 334 334 + ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString { 335 335 + description: None, 336 336 + format: None, 337 337 + default: None, 338 338 + min_length: None, 339 339 + max_length: None, 340 340 + min_graphemes: None, 341 341 + max_graphemes: None, 342 342 + r#enum: None, 343 343 + r#const: None, 344 344 + known_values: None, 345 345 + }), 346 346 + ); 347 347 + map 348 348 + }, 349 349 + }), 350 350 + ); 351 351 + map.insert( 352 352 + ::jacquard_common::smol_str::SmolStr::new_static("main"), 353 353 + ::jacquard_lexicon::lexicon::LexUserType::Record(::jacquard_lexicon::lexicon::LexRecord { 354 354 + description: Some( 355 355 + ::jacquard_common::CowStr::new_static( 356 356 + "Virtual filesystem manifest for a Wisp site", 357 357 + ), 358 358 + ), 359 359 + key: None, 360 360 + record: ::jacquard_lexicon::lexicon::LexRecordRecord::Object(::jacquard_lexicon::lexicon::LexObject { 361 361 + description: None, 362 362 + required: Some( 363 363 + vec![ 364 364 + ::jacquard_common::smol_str::SmolStr::new_static("site"), 365 365 + ::jacquard_common::smol_str::SmolStr::new_static("root"), 366 366 + ::jacquard_common::smol_str::SmolStr::new_static("createdAt") 367 367 + ], 368 368 + ), 369 369 + nullable: None, 370 370 + properties: { 371 371 + #[allow(unused_mut)] 372 372 + let mut map = ::std::collections::BTreeMap::new(); 373 373 + map.insert( 374 374 + ::jacquard_common::smol_str::SmolStr::new_static( 375 375 + "createdAt", 376 376 + ), 377 377 + ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString { 378 378 + description: None, 379 379 + format: Some( 380 380 + ::jacquard_lexicon::lexicon::LexStringFormat::Datetime, 381 381 + ), 382 382 + default: None, 383 383 + min_length: None, 384 384 + max_length: None, 385 385 + min_graphemes: None, 386 386 + max_graphemes: None, 387 387 + r#enum: None, 388 388 + r#const: None, 389 389 + known_values: None, 390 390 + }), 391 391 + ); 392 392 + map.insert( 393 393 + ::jacquard_common::smol_str::SmolStr::new_static( 394 394 + "fileCount", 395 395 + ), 396 396 + ::jacquard_lexicon::lexicon::LexObjectProperty::Integer(::jacquard_lexicon::lexicon::LexInteger { 397 397 + description: None, 398 398 + default: None, 399 399 + minimum: Some(0i64), 400 400 + maximum: Some(1000i64), 401 401 + r#enum: None, 402 402 + r#const: None, 403 403 + }), 404 404 + ); 405 405 + map.insert( 406 406 + ::jacquard_common::smol_str::SmolStr::new_static("root"), 407 407 + ::jacquard_lexicon::lexicon::LexObjectProperty::Ref(::jacquard_lexicon::lexicon::LexRef { 408 408 + description: None, 409 409 + r#ref: ::jacquard_common::CowStr::new_static("#directory"), 410 410 + }), 411 411 + ); 412 412 + map.insert( 413 413 + ::jacquard_common::smol_str::SmolStr::new_static("site"), 414 414 + ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString { 415 415 + description: None, 416 416 + format: None, 417 417 + default: None, 418 418 + min_length: None, 419 419 + max_length: None, 420 420 + min_graphemes: None, 421 421 + max_graphemes: None, 422 422 + r#enum: None, 423 423 + r#const: None, 424 424 + known_values: None, 425 425 + }), 426 426 + ); 427 427 + map 428 428 + }, 429 429 + }), 430 430 + }), 431 431 + ); 432 432 + map.insert( 433 433 + ::jacquard_common::smol_str::SmolStr::new_static("subfs"), 434 434 + ::jacquard_lexicon::lexicon::LexUserType::Object(::jacquard_lexicon::lexicon::LexObject { 435 435 + description: None, 436 436 + required: Some( 437 437 + vec![ 438 438 + ::jacquard_common::smol_str::SmolStr::new_static("type"), 439 439 + ::jacquard_common::smol_str::SmolStr::new_static("subject") 440 440 + ], 441 441 + ), 442 442 + nullable: None, 443 443 + properties: { 444 444 + #[allow(unused_mut)] 445 445 + let mut map = ::std::collections::BTreeMap::new(); 446 446 + map.insert( 447 447 + ::jacquard_common::smol_str::SmolStr::new_static("flat"), 448 448 + ::jacquard_lexicon::lexicon::LexObjectProperty::Boolean(::jacquard_lexicon::lexicon::LexBoolean { 449 449 + description: None, 450 450 + default: None, 451 451 + r#const: None, 452 452 + }), 453 453 + ); 454 454 + map.insert( 455 455 + ::jacquard_common::smol_str::SmolStr::new_static("subject"), 456 456 + ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString { 457 457 + description: Some( 458 458 + ::jacquard_common::CowStr::new_static( 459 459 + "AT-URI pointing to a place.wisp.subfs record containing this subtree.", 460 460 + ), 461 461 + ), 462 462 + format: Some( 463 463 + ::jacquard_lexicon::lexicon::LexStringFormat::AtUri, 464 464 + ), 465 465 + default: None, 466 466 + min_length: None, 467 467 + max_length: None, 468 468 + min_graphemes: None, 469 469 + max_graphemes: None, 470 470 + r#enum: None, 471 471 + r#const: None, 472 472 + known_values: None, 473 473 + }), 474 474 + ); 475 475 + map.insert( 476 476 + ::jacquard_common::smol_str::SmolStr::new_static("type"), 477 477 + ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString { 478 478 + description: None, 479 479 + format: None, 480 480 + default: None, 481 481 + min_length: None, 482 482 + max_length: None, 483 483 + min_graphemes: None, 484 484 + max_graphemes: None, 485 485 + r#enum: None, 486 486 + r#const: None, 487 487 + known_values: None, 488 488 + }), 489 489 + ); 490 490 + map 491 491 + }, 492 492 + }), 493 493 + ); 494 494 + map 495 495 + }, 496 496 + } 497 497 + } 498 498 + 499 499 + impl<'a> ::jacquard_lexicon::schema::LexiconSchema for Directory<'a> { 500 500 + fn nsid() -> &'static str { 501 501 + "place.wisp.fs" 502 502 + } 503 503 + fn def_name() -> &'static str { 504 504 + "directory" 505 505 + } 506 506 + fn lexicon_doc() -> ::jacquard_lexicon::lexicon::LexiconDoc<'static> { 507 507 + lexicon_doc_place_wisp_fs() 508 508 + } 509 509 + fn validate( 510 510 + &self, 511 511 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 512 512 + { 513 513 + let value = &self.entries; 514 514 + #[allow(unused_comparisons)] 515 515 + if value.len() > 500usize { 516 516 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 517 517 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 518 518 + "entries", 519 519 + ), 520 520 + max: 500usize, 521 521 + actual: value.len(), 522 522 + }); 523 523 + } 524 524 + } 525 525 + Ok(()) 526 526 + } 527 527 + } 528 528 + 529 529 + #[jacquard_derive::lexicon] 530 530 + #[derive( 531 531 + serde::Serialize, 532 532 + serde::Deserialize, 533 533 + Debug, 534 534 + Clone, 535 535 + PartialEq, 536 536 + Eq, 537 537 + jacquard_derive::IntoStatic 538 538 + )] 539 539 + #[serde(rename_all = "camelCase")] 540 540 + pub struct Entry<'a> { 541 541 + #[serde(borrow)] 542 542 + pub name: jacquard_common::CowStr<'a>, 543 543 + #[serde(borrow)] 544 544 + pub node: EntryNode<'a>, 545 545 + } 546 546 + 547 547 + pub mod entry_state { 548 548 + 549 549 + pub use crate::builder_types::{Set, Unset, IsSet, IsUnset}; 550 550 + #[allow(unused)] 551 551 + use ::core::marker::PhantomData; 552 552 + mod sealed { 553 553 + pub trait Sealed {} 554 554 + } 555 555 + /// State trait tracking which required fields have been set 556 556 + pub trait State: sealed::Sealed { 557 557 + type Node; 558 558 + type Name; 559 559 + } 560 560 + /// Empty state - all required fields are unset 561 561 + pub struct Empty(()); 562 562 + impl sealed::Sealed for Empty {} 563 563 + impl State for Empty { 564 564 + type Node = Unset; 565 565 + type Name = Unset; 566 566 + } 567 567 + ///State transition - sets the `node` field to Set 568 568 + pub struct SetNode<S: State = Empty>(PhantomData<fn() -> S>); 569 569 + impl<S: State> sealed::Sealed for SetNode<S> {} 570 570 + impl<S: State> State for SetNode<S> { 571 571 + type Node = Set<members::node>; 572 572 + type Name = S::Name; 573 573 + } 574 574 + ///State transition - sets the `name` field to Set 575 575 + pub struct SetName<S: State = Empty>(PhantomData<fn() -> S>); 576 576 + impl<S: State> sealed::Sealed for SetName<S> {} 577 577 + impl<S: State> State for SetName<S> { 578 578 + type Node = S::Node; 579 579 + type Name = Set<members::name>; 580 580 + } 581 581 + /// Marker types for field names 582 582 + #[allow(non_camel_case_types)] 583 583 + pub mod members { 584 584 + ///Marker type for the `node` field 585 585 + pub struct node(()); 586 586 + ///Marker type for the `name` field 587 587 + pub struct name(()); 588 588 + } 589 589 + } 590 590 + 591 591 + /// Builder for constructing an instance of this type 592 592 + pub struct EntryBuilder<'a, S: entry_state::State> { 593 593 + _phantom_state: ::core::marker::PhantomData<fn() -> S>, 594 594 + __unsafe_private_named: ( 595 595 + ::core::option::Option<jacquard_common::CowStr<'a>>, 596 596 + ::core::option::Option<EntryNode<'a>>, 597 597 + ), 598 598 + _phantom: ::core::marker::PhantomData<&'a ()>, 599 599 + } 600 600 + 601 601 + impl<'a> Entry<'a> { 602 602 + /// Create a new builder for this type 603 603 + pub fn new() -> EntryBuilder<'a, entry_state::Empty> { 604 604 + EntryBuilder::new() 605 605 + } 606 606 + } 607 607 + 608 608 + impl<'a> EntryBuilder<'a, entry_state::Empty> { 609 609 + /// Create a new builder with all fields unset 610 610 + pub fn new() -> Self { 611 611 + EntryBuilder { 612 612 + _phantom_state: ::core::marker::PhantomData, 613 613 + __unsafe_private_named: (None, None), 614 614 + _phantom: ::core::marker::PhantomData, 615 615 + } 616 616 + } 617 617 + } 618 618 + 619 619 + impl<'a, S> EntryBuilder<'a, S> 620 620 + where 621 621 + S: entry_state::State, 622 622 + S::Name: entry_state::IsUnset, 623 623 + { 624 624 + /// Set the `name` field (required) 625 625 + pub fn name( 626 626 + mut self, 627 627 + value: impl Into<jacquard_common::CowStr<'a>>, 628 628 + ) -> EntryBuilder<'a, entry_state::SetName<S>> { 629 629 + self.__unsafe_private_named.0 = ::core::option::Option::Some(value.into()); 630 630 + EntryBuilder { 631 631 + _phantom_state: ::core::marker::PhantomData, 632 632 + __unsafe_private_named: self.__unsafe_private_named, 633 633 + _phantom: ::core::marker::PhantomData, 634 634 + } 635 635 + } 636 636 + } 637 637 + 638 638 + impl<'a, S> EntryBuilder<'a, S> 639 639 + where 640 640 + S: entry_state::State, 641 641 + S::Node: entry_state::IsUnset, 642 642 + { 643 643 + /// Set the `node` field (required) 644 644 + pub fn node( 645 645 + mut self, 646 646 + value: impl Into<EntryNode<'a>>, 647 647 + ) -> EntryBuilder<'a, entry_state::SetNode<S>> { 648 648 + self.__unsafe_private_named.1 = ::core::option::Option::Some(value.into()); 649 649 + EntryBuilder { 650 650 + _phantom_state: ::core::marker::PhantomData, 651 651 + __unsafe_private_named: self.__unsafe_private_named, 652 652 + _phantom: ::core::marker::PhantomData, 653 653 + } 654 654 + } 655 655 + } 656 656 + 657 657 + impl<'a, S> EntryBuilder<'a, S> 658 658 + where 659 659 + S: entry_state::State, 660 660 + S::Node: entry_state::IsSet, 661 661 + S::Name: entry_state::IsSet, 662 662 + { 663 663 + /// Build the final struct 664 664 + pub fn build(self) -> Entry<'a> { 665 665 + Entry { 666 666 + name: self.__unsafe_private_named.0.unwrap(), 667 667 + node: self.__unsafe_private_named.1.unwrap(), 668 668 + extra_data: Default::default(), 669 669 + } 670 670 + } 671 671 + /// Build the final struct with custom extra_data 672 672 + pub fn build_with_data( 673 673 + self, 674 674 + extra_data: std::collections::BTreeMap< 675 675 + jacquard_common::smol_str::SmolStr, 676 676 + jacquard_common::types::value::Data<'a>, 677 677 + >, 678 678 + ) -> Entry<'a> { 679 679 + Entry { 680 680 + name: self.__unsafe_private_named.0.unwrap(), 681 681 + node: self.__unsafe_private_named.1.unwrap(), 682 682 + extra_data: Some(extra_data), 683 683 + } 684 684 + } 685 685 + } 686 686 + 687 687 + #[jacquard_derive::open_union] 688 688 + #[derive( 689 689 + serde::Serialize, 690 690 + serde::Deserialize, 691 691 + Debug, 692 692 + Clone, 693 693 + PartialEq, 694 694 + Eq, 695 695 + jacquard_derive::IntoStatic 696 696 + )] 697 697 + #[serde(tag = "$type")] 698 698 + #[serde(bound(deserialize = "'de: 'a"))] 699 699 + pub enum EntryNode<'a> { 700 700 + #[serde(rename = "place.wisp.fs#file")] 701 701 + File(Box<crate::place_wisp::fs::File<'a>>), 702 702 + #[serde(rename = "place.wisp.fs#directory")] 703 703 + Directory(Box<crate::place_wisp::fs::Directory<'a>>), 704 704 + #[serde(rename = "place.wisp.fs#subfs")] 705 705 + Subfs(Box<crate::place_wisp::fs::Subfs<'a>>), 706 706 + } 707 707 + 708 708 + impl<'a> ::jacquard_lexicon::schema::LexiconSchema for Entry<'a> { 709 709 + fn nsid() -> &'static str { 710 710 + "place.wisp.fs" 711 711 + } 712 712 + fn def_name() -> &'static str { 713 713 + "entry" 714 714 + } 715 715 + fn lexicon_doc() -> ::jacquard_lexicon::lexicon::LexiconDoc<'static> { 716 716 + lexicon_doc_place_wisp_fs() 717 717 + } 718 718 + fn validate( 719 719 + &self, 720 720 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 721 721 + { 722 722 + let value = &self.name; 723 723 + #[allow(unused_comparisons)] 724 724 + if <str>::len(value.as_ref()) > 255usize { 725 725 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 726 726 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 727 727 + "name", 728 728 + ), 729 729 + max: 255usize, 730 730 + actual: <str>::len(value.as_ref()), 731 731 + }); 732 732 + } 733 733 + } 734 734 + Ok(()) 735 735 + } 736 736 + } 737 737 + 738 738 + #[jacquard_derive::lexicon] 739 739 + #[derive( 740 740 + serde::Serialize, 741 741 + serde::Deserialize, 742 742 + Debug, 743 743 + Clone, 744 744 + PartialEq, 745 745 + Eq, 746 746 + jacquard_derive::IntoStatic 747 747 + )] 748 748 + #[serde(rename_all = "camelCase")] 749 749 + pub struct File<'a> { 750 750 + /// True if blob content is base64-encoded (used to bypass PDS content sniffing) 751 751 + #[serde(skip_serializing_if = "std::option::Option::is_none")] 752 752 + pub base64: std::option::Option<bool>, 753 753 + /// Content blob ref 754 754 + #[serde(borrow)] 755 755 + pub blob: jacquard_common::types::blob::BlobRef<'a>, 756 756 + /// Content encoding (e.g., gzip for compressed files) 757 757 + #[serde(skip_serializing_if = "std::option::Option::is_none")] 758 758 + #[serde(borrow)] 759 759 + pub encoding: std::option::Option<jacquard_common::CowStr<'a>>, 760 760 + /// Original MIME type before compression 761 761 + #[serde(skip_serializing_if = "std::option::Option::is_none")] 762 762 + #[serde(borrow)] 763 763 + pub mime_type: std::option::Option<jacquard_common::CowStr<'a>>, 764 764 + #[serde(borrow)] 765 765 + pub r#type: jacquard_common::CowStr<'a>, 766 766 + } 767 767 + 768 768 + pub mod file_state { 769 769 + 770 770 + pub use crate::builder_types::{Set, Unset, IsSet, IsUnset}; 771 771 + #[allow(unused)] 772 772 + use ::core::marker::PhantomData; 773 773 + mod sealed { 774 774 + pub trait Sealed {} 775 775 + } 776 776 + /// State trait tracking which required fields have been set 777 777 + pub trait State: sealed::Sealed { 778 778 + type Type; 779 779 + type Blob; 780 780 + } 781 781 + /// Empty state - all required fields are unset 782 782 + pub struct Empty(()); 783 783 + impl sealed::Sealed for Empty {} 784 784 + impl State for Empty { 785 785 + type Type = Unset; 786 786 + type Blob = Unset; 787 787 + } 788 788 + ///State transition - sets the `type` field to Set 789 789 + pub struct SetType<S: State = Empty>(PhantomData<fn() -> S>); 790 790 + impl<S: State> sealed::Sealed for SetType<S> {} 791 791 + impl<S: State> State for SetType<S> { 792 792 + type Type = Set<members::r#type>; 793 793 + type Blob = S::Blob; 794 794 + } 795 795 + ///State transition - sets the `blob` field to Set 796 796 + pub struct SetBlob<S: State = Empty>(PhantomData<fn() -> S>); 797 797 + impl<S: State> sealed::Sealed for SetBlob<S> {} 798 798 + impl<S: State> State for SetBlob<S> { 799 799 + type Type = S::Type; 800 800 + type Blob = Set<members::blob>; 801 801 + } 802 802 + /// Marker types for field names 803 803 + #[allow(non_camel_case_types)] 804 804 + pub mod members { 805 805 + ///Marker type for the `type` field 806 806 + pub struct r#type(()); 807 807 + ///Marker type for the `blob` field 808 808 + pub struct blob(()); 809 809 + } 810 810 + } 811 811 + 812 812 + /// Builder for constructing an instance of this type 813 813 + pub struct FileBuilder<'a, S: file_state::State> { 814 814 + _phantom_state: ::core::marker::PhantomData<fn() -> S>, 815 815 + __unsafe_private_named: ( 816 816 + ::core::option::Option<bool>, 817 817 + ::core::option::Option<jacquard_common::types::blob::BlobRef<'a>>, 818 818 + ::core::option::Option<jacquard_common::CowStr<'a>>, 819 819 + ::core::option::Option<jacquard_common::CowStr<'a>>, 820 820 + ::core::option::Option<jacquard_common::CowStr<'a>>, 821 821 + ), 822 822 + _phantom: ::core::marker::PhantomData<&'a ()>, 823 823 + } 824 824 + 825 825 + impl<'a> File<'a> { 826 826 + /// Create a new builder for this type 827 827 + pub fn new() -> FileBuilder<'a, file_state::Empty> { 828 828 + FileBuilder::new() 829 829 + } 830 830 + } 831 831 + 832 832 + impl<'a> FileBuilder<'a, file_state::Empty> { 833 833 + /// Create a new builder with all fields unset 834 834 + pub fn new() -> Self { 835 835 + FileBuilder { 836 836 + _phantom_state: ::core::marker::PhantomData, 837 837 + __unsafe_private_named: (None, None, None, None, None), 838 838 + _phantom: ::core::marker::PhantomData, 839 839 + } 840 840 + } 841 841 + } 842 842 + 843 843 + impl<'a, S: file_state::State> FileBuilder<'a, S> { 844 844 + /// Set the `base64` field (optional) 845 845 + pub fn base64(mut self, value: impl Into<Option<bool>>) -> Self { 846 846 + self.__unsafe_private_named.0 = value.into(); 847 847 + self 848 848 + } 849 849 + /// Set the `base64` field to an Option value (optional) 850 850 + pub fn maybe_base64(mut self, value: Option<bool>) -> Self { 851 851 + self.__unsafe_private_named.0 = value; 852 852 + self 853 853 + } 854 854 + } 855 855 + 856 856 + impl<'a, S> FileBuilder<'a, S> 857 857 + where 858 858 + S: file_state::State, 859 859 + S::Blob: file_state::IsUnset, 860 860 + { 861 861 + /// Set the `blob` field (required) 862 862 + pub fn blob( 863 863 + mut self, 864 864 + value: impl Into<jacquard_common::types::blob::BlobRef<'a>>, 865 865 + ) -> FileBuilder<'a, file_state::SetBlob<S>> { 866 866 + self.__unsafe_private_named.1 = ::core::option::Option::Some(value.into()); 867 867 + FileBuilder { 868 868 + _phantom_state: ::core::marker::PhantomData, 869 869 + __unsafe_private_named: self.__unsafe_private_named, 870 870 + _phantom: ::core::marker::PhantomData, 871 871 + } 872 872 + } 873 873 + } 874 874 + 875 875 + impl<'a, S: file_state::State> FileBuilder<'a, S> { 876 876 + /// Set the `encoding` field (optional) 877 877 + pub fn encoding( 878 878 + mut self, 879 879 + value: impl Into<Option<jacquard_common::CowStr<'a>>>, 880 880 + ) -> Self { 881 881 + self.__unsafe_private_named.2 = value.into(); 882 882 + self 883 883 + } 884 884 + /// Set the `encoding` field to an Option value (optional) 885 885 + pub fn maybe_encoding(mut self, value: Option<jacquard_common::CowStr<'a>>) -> Self { 886 886 + self.__unsafe_private_named.2 = value; 887 887 + self 888 888 + } 889 889 + } 890 890 + 891 891 + impl<'a, S: file_state::State> FileBuilder<'a, S> { 892 892 + /// Set the `mimeType` field (optional) 893 893 + pub fn mime_type( 894 894 + mut self, 895 895 + value: impl Into<Option<jacquard_common::CowStr<'a>>>, 896 896 + ) -> Self { 897 897 + self.__unsafe_private_named.3 = value.into(); 898 898 + self 899 899 + } 900 900 + /// Set the `mimeType` field to an Option value (optional) 901 901 + pub fn maybe_mime_type( 902 902 + mut self, 903 903 + value: Option<jacquard_common::CowStr<'a>>, 904 904 + ) -> Self { 905 905 + self.__unsafe_private_named.3 = value; 906 906 + self 907 907 + } 908 908 + } 909 909 + 910 910 + impl<'a, S> FileBuilder<'a, S> 911 911 + where 912 912 + S: file_state::State, 913 913 + S::Type: file_state::IsUnset, 914 914 + { 915 915 + /// Set the `type` field (required) 916 916 + pub fn r#type( 917 917 + mut self, 918 918 + value: impl Into<jacquard_common::CowStr<'a>>, 919 919 + ) -> FileBuilder<'a, file_state::SetType<S>> { 920 920 + self.__unsafe_private_named.4 = ::core::option::Option::Some(value.into()); 921 921 + FileBuilder { 922 922 + _phantom_state: ::core::marker::PhantomData, 923 923 + __unsafe_private_named: self.__unsafe_private_named, 924 924 + _phantom: ::core::marker::PhantomData, 925 925 + } 926 926 + } 927 927 + } 928 928 + 929 929 + impl<'a, S> FileBuilder<'a, S> 930 930 + where 931 931 + S: file_state::State, 932 932 + S::Type: file_state::IsSet, 933 933 + S::Blob: file_state::IsSet, 934 934 + { 935 935 + /// Build the final struct 936 936 + pub fn build(self) -> File<'a> { 937 937 + File { 938 938 + base64: self.__unsafe_private_named.0, 939 939 + blob: self.__unsafe_private_named.1.unwrap(), 940 940 + encoding: self.__unsafe_private_named.2, 941 941 + mime_type: self.__unsafe_private_named.3, 942 942 + r#type: self.__unsafe_private_named.4.unwrap(), 943 943 + extra_data: Default::default(), 944 944 + } 945 945 + } 946 946 + /// Build the final struct with custom extra_data 947 947 + pub fn build_with_data( 948 948 + self, 949 949 + extra_data: std::collections::BTreeMap< 950 950 + jacquard_common::smol_str::SmolStr, 951 951 + jacquard_common::types::value::Data<'a>, 952 952 + >, 953 953 + ) -> File<'a> { 954 954 + File { 955 955 + base64: self.__unsafe_private_named.0, 956 956 + blob: self.__unsafe_private_named.1.unwrap(), 957 957 + encoding: self.__unsafe_private_named.2, 958 958 + mime_type: self.__unsafe_private_named.3, 959 959 + r#type: self.__unsafe_private_named.4.unwrap(), 960 960 + extra_data: Some(extra_data), 961 961 + } 962 962 + } 963 963 + } 964 964 + 965 965 + impl<'a> ::jacquard_lexicon::schema::LexiconSchema for File<'a> { 966 966 + fn nsid() -> &'static str { 967 967 + "place.wisp.fs" 968 968 + } 969 969 + fn def_name() -> &'static str { 970 970 + "file" 971 971 + } 972 972 + fn lexicon_doc() -> ::jacquard_lexicon::lexicon::LexiconDoc<'static> { 973 973 + lexicon_doc_place_wisp_fs() 974 974 + } 975 975 + fn validate( 976 976 + &self, 977 977 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 978 978 + Ok(()) 979 979 + } 980 980 + } 981 981 + 982 982 + /// Virtual filesystem manifest for a Wisp site 983 983 + #[jacquard_derive::lexicon] 984 984 + #[derive( 985 985 + serde::Serialize, 986 986 + serde::Deserialize, 987 987 + Debug, 988 988 + Clone, 989 989 + PartialEq, 990 990 + Eq, 991 991 + jacquard_derive::IntoStatic 992 992 + )] 993 993 + #[serde(rename_all = "camelCase")] 994 994 + pub struct Fs<'a> { 995 995 + pub created_at: jacquard_common::types::string::Datetime, 996 996 + #[serde(skip_serializing_if = "std::option::Option::is_none")] 997 997 + pub file_count: std::option::Option<i64>, 998 998 + #[serde(borrow)] 999 999 + pub root: crate::place_wisp::fs::Directory<'a>, 1000 1000 + #[serde(borrow)] 1001 1001 + pub site: jacquard_common::CowStr<'a>, 1002 1002 + } 1003 1003 + 1004 1004 + pub mod fs_state { 1005 1005 + 1006 1006 + pub use crate::builder_types::{Set, Unset, IsSet, IsUnset}; 1007 1007 + #[allow(unused)] 1008 1008 + use ::core::marker::PhantomData; 1009 1009 + mod sealed { 1010 1010 + pub trait Sealed {} 1011 1011 + } 1012 1012 + /// State trait tracking which required fields have been set 1013 1013 + pub trait State: sealed::Sealed { 1014 1014 + type CreatedAt; 1015 1015 + type Site; 1016 1016 + type Root; 1017 1017 + } 1018 1018 + /// Empty state - all required fields are unset 1019 1019 + pub struct Empty(()); 1020 1020 + impl sealed::Sealed for Empty {} 1021 1021 + impl State for Empty { 1022 1022 + type CreatedAt = Unset; 1023 1023 + type Site = Unset; 1024 1024 + type Root = Unset; 1025 1025 + } 1026 1026 + ///State transition - sets the `created_at` field to Set 1027 1027 + pub struct SetCreatedAt<S: State = Empty>(PhantomData<fn() -> S>); 1028 1028 + impl<S: State> sealed::Sealed for SetCreatedAt<S> {} 1029 1029 + impl<S: State> State for SetCreatedAt<S> { 1030 1030 + type CreatedAt = Set<members::created_at>; 1031 1031 + type Site = S::Site; 1032 1032 + type Root = S::Root; 1033 1033 + } 1034 1034 + ///State transition - sets the `site` field to Set 1035 1035 + pub struct SetSite<S: State = Empty>(PhantomData<fn() -> S>); 1036 1036 + impl<S: State> sealed::Sealed for SetSite<S> {} 1037 1037 + impl<S: State> State for SetSite<S> { 1038 1038 + type CreatedAt = S::CreatedAt; 1039 1039 + type Site = Set<members::site>; 1040 1040 + type Root = S::Root; 1041 1041 + } 1042 1042 + ///State transition - sets the `root` field to Set 1043 1043 + pub struct SetRoot<S: State = Empty>(PhantomData<fn() -> S>); 1044 1044 + impl<S: State> sealed::Sealed for SetRoot<S> {} 1045 1045 + impl<S: State> State for SetRoot<S> { 1046 1046 + type CreatedAt = S::CreatedAt; 1047 1047 + type Site = S::Site; 1048 1048 + type Root = Set<members::root>; 1049 1049 + } 1050 1050 + /// Marker types for field names 1051 1051 + #[allow(non_camel_case_types)] 1052 1052 + pub mod members { 1053 1053 + ///Marker type for the `created_at` field 1054 1054 + pub struct created_at(()); 1055 1055 + ///Marker type for the `site` field 1056 1056 + pub struct site(()); 1057 1057 + ///Marker type for the `root` field 1058 1058 + pub struct root(()); 1059 1059 + } 1060 1060 + } 1061 1061 + 1062 1062 + /// Builder for constructing an instance of this type 1063 1063 + pub struct FsBuilder<'a, S: fs_state::State> { 1064 1064 + _phantom_state: ::core::marker::PhantomData<fn() -> S>, 1065 1065 + __unsafe_private_named: ( 1066 1066 + ::core::option::Option<jacquard_common::types::string::Datetime>, 1067 1067 + ::core::option::Option<i64>, 1068 1068 + ::core::option::Option<crate::place_wisp::fs::Directory<'a>>, 1069 1069 + ::core::option::Option<jacquard_common::CowStr<'a>>, 1070 1070 + ), 1071 1071 + _phantom: ::core::marker::PhantomData<&'a ()>, 1072 1072 + } 1073 1073 + 1074 1074 + impl<'a> Fs<'a> { 1075 1075 + /// Create a new builder for this type 1076 1076 + pub fn new() -> FsBuilder<'a, fs_state::Empty> { 1077 1077 + FsBuilder::new() 1078 1078 + } 1079 1079 + } 1080 1080 + 1081 1081 + impl<'a> FsBuilder<'a, fs_state::Empty> { 1082 1082 + /// Create a new builder with all fields unset 1083 1083 + pub fn new() -> Self { 1084 1084 + FsBuilder { 1085 1085 + _phantom_state: ::core::marker::PhantomData, 1086 1086 + __unsafe_private_named: (None, None, None, None), 1087 1087 + _phantom: ::core::marker::PhantomData, 1088 1088 + } 1089 1089 + } 1090 1090 + } 1091 1091 + 1092 1092 + impl<'a, S> FsBuilder<'a, S> 1093 1093 + where 1094 1094 + S: fs_state::State, 1095 1095 + S::CreatedAt: fs_state::IsUnset, 1096 1096 + { 1097 1097 + /// Set the `createdAt` field (required) 1098 1098 + pub fn created_at( 1099 1099 + mut self, 1100 1100 + value: impl Into<jacquard_common::types::string::Datetime>, 1101 1101 + ) -> FsBuilder<'a, fs_state::SetCreatedAt<S>> { 1102 1102 + self.__unsafe_private_named.0 = ::core::option::Option::Some(value.into()); 1103 1103 + FsBuilder { 1104 1104 + _phantom_state: ::core::marker::PhantomData, 1105 1105 + __unsafe_private_named: self.__unsafe_private_named, 1106 1106 + _phantom: ::core::marker::PhantomData, 1107 1107 + } 1108 1108 + } 1109 1109 + } 1110 1110 + 1111 1111 + impl<'a, S: fs_state::State> FsBuilder<'a, S> { 1112 1112 + /// Set the `fileCount` field (optional) 1113 1113 + pub fn file_count(mut self, value: impl Into<Option<i64>>) -> Self { 1114 1114 + self.__unsafe_private_named.1 = value.into(); 1115 1115 + self 1116 1116 + } 1117 1117 + /// Set the `fileCount` field to an Option value (optional) 1118 1118 + pub fn maybe_file_count(mut self, value: Option<i64>) -> Self { 1119 1119 + self.__unsafe_private_named.1 = value; 1120 1120 + self 1121 1121 + } 1122 1122 + } 1123 1123 + 1124 1124 + impl<'a, S> FsBuilder<'a, S> 1125 1125 + where 1126 1126 + S: fs_state::State, 1127 1127 + S::Root: fs_state::IsUnset, 1128 1128 + { 1129 1129 + /// Set the `root` field (required) 1130 1130 + pub fn root( 1131 1131 + mut self, 1132 1132 + value: impl Into<crate::place_wisp::fs::Directory<'a>>, 1133 1133 + ) -> FsBuilder<'a, fs_state::SetRoot<S>> { 1134 1134 + self.__unsafe_private_named.2 = ::core::option::Option::Some(value.into()); 1135 1135 + FsBuilder { 1136 1136 + _phantom_state: ::core::marker::PhantomData, 1137 1137 + __unsafe_private_named: self.__unsafe_private_named, 1138 1138 + _phantom: ::core::marker::PhantomData, 1139 1139 + } 1140 1140 + } 1141 1141 + } 1142 1142 + 1143 1143 + impl<'a, S> FsBuilder<'a, S> 1144 1144 + where 1145 1145 + S: fs_state::State, 1146 1146 + S::Site: fs_state::IsUnset, 1147 1147 + { 1148 1148 + /// Set the `site` field (required) 1149 1149 + pub fn site( 1150 1150 + mut self, 1151 1151 + value: impl Into<jacquard_common::CowStr<'a>>, 1152 1152 + ) -> FsBuilder<'a, fs_state::SetSite<S>> { 1153 1153 + self.__unsafe_private_named.3 = ::core::option::Option::Some(value.into()); 1154 1154 + FsBuilder { 1155 1155 + _phantom_state: ::core::marker::PhantomData, 1156 1156 + __unsafe_private_named: self.__unsafe_private_named, 1157 1157 + _phantom: ::core::marker::PhantomData, 1158 1158 + } 1159 1159 + } 1160 1160 + } 1161 1161 + 1162 1162 + impl<'a, S> FsBuilder<'a, S> 1163 1163 + where 1164 1164 + S: fs_state::State, 1165 1165 + S::CreatedAt: fs_state::IsSet, 1166 1166 + S::Site: fs_state::IsSet, 1167 1167 + S::Root: fs_state::IsSet, 1168 1168 + { 1169 1169 + /// Build the final struct 1170 1170 + pub fn build(self) -> Fs<'a> { 1171 1171 + Fs { 1172 1172 + created_at: self.__unsafe_private_named.0.unwrap(), 1173 1173 + file_count: self.__unsafe_private_named.1, 1174 1174 + root: self.__unsafe_private_named.2.unwrap(), 1175 1175 + site: self.__unsafe_private_named.3.unwrap(), 1176 1176 + extra_data: Default::default(), 1177 1177 + } 1178 1178 + } 1179 1179 + /// Build the final struct with custom extra_data 1180 1180 + pub fn build_with_data( 1181 1181 + self, 1182 1182 + extra_data: std::collections::BTreeMap< 1183 1183 + jacquard_common::smol_str::SmolStr, 1184 1184 + jacquard_common::types::value::Data<'a>, 1185 1185 + >, 1186 1186 + ) -> Fs<'a> { 1187 1187 + Fs { 1188 1188 + created_at: self.__unsafe_private_named.0.unwrap(), 1189 1189 + file_count: self.__unsafe_private_named.1, 1190 1190 + root: self.__unsafe_private_named.2.unwrap(), 1191 1191 + site: self.__unsafe_private_named.3.unwrap(), 1192 1192 + extra_data: Some(extra_data), 1193 1193 + } 1194 1194 + } 1195 1195 + } 1196 1196 + 1197 1197 + impl<'a> Fs<'a> { 1198 1198 + pub fn uri( 1199 1199 + uri: impl Into<jacquard_common::CowStr<'a>>, 1200 1200 + ) -> Result< 1201 1201 + jacquard_common::types::uri::RecordUri<'a, FsRecord>, 1202 1202 + jacquard_common::types::uri::UriError, 1203 1203 + > { 1204 1204 + jacquard_common::types::uri::RecordUri::try_from_uri( 1205 1205 + jacquard_common::types::string::AtUri::new_cow(uri.into())?, 1206 1206 + ) 1207 1207 + } 1208 1208 + } 1209 1209 + 1210 1210 + /// Typed wrapper for GetRecord response with this collection's record type. 1211 1211 + #[derive( 1212 1212 + serde::Serialize, 1213 1213 + serde::Deserialize, 1214 1214 + Debug, 1215 1215 + Clone, 1216 1216 + PartialEq, 1217 1217 + Eq, 1218 1218 + jacquard_derive::IntoStatic 1219 1219 + )] 1220 1220 + #[serde(rename_all = "camelCase")] 1221 1221 + pub struct FsGetRecordOutput<'a> { 1222 1222 + #[serde(skip_serializing_if = "std::option::Option::is_none")] 1223 1223 + #[serde(borrow)] 1224 1224 + pub cid: std::option::Option<jacquard_common::types::string::Cid<'a>>, 1225 1225 + #[serde(borrow)] 1226 1226 + pub uri: jacquard_common::types::string::AtUri<'a>, 1227 1227 + #[serde(borrow)] 1228 1228 + pub value: Fs<'a>, 1229 1229 + } 1230 1230 + 1231 1231 + impl From<FsGetRecordOutput<'_>> for Fs<'_> { 1232 1232 + fn from(output: FsGetRecordOutput<'_>) -> Self { 1233 1233 + use jacquard_common::IntoStatic; 1234 1234 + output.value.into_static() 1235 1235 + } 1236 1236 + } 1237 1237 + 1238 1238 + impl jacquard_common::types::collection::Collection for Fs<'_> { 1239 1239 + const NSID: &'static str = "place.wisp.fs"; 1240 1240 + type Record = FsRecord; 1241 1241 + } 1242 1242 + 1243 1243 + /// Marker type for deserializing records from this collection. 1244 1244 + #[derive(Debug, serde::Serialize, serde::Deserialize)] 1245 1245 + pub struct FsRecord; 1246 1246 + impl jacquard_common::xrpc::XrpcResp for FsRecord { 1247 1247 + const NSID: &'static str = "place.wisp.fs"; 1248 1248 + const ENCODING: &'static str = "application/json"; 1249 1249 + type Output<'de> = FsGetRecordOutput<'de>; 1250 1250 + type Err<'de> = jacquard_common::types::collection::RecordError<'de>; 1251 1251 + } 1252 1252 + 1253 1253 + impl jacquard_common::types::collection::Collection for FsRecord { 1254 1254 + const NSID: &'static str = "place.wisp.fs"; 1255 1255 + type Record = FsRecord; 1256 1256 + } 1257 1257 + 1258 1258 + impl<'a> ::jacquard_lexicon::schema::LexiconSchema for Fs<'a> { 1259 1259 + fn nsid() -> &'static str { 1260 1260 + "place.wisp.fs" 1261 1261 + } 1262 1262 + fn def_name() -> &'static str { 1263 1263 + "main" 1264 1264 + } 1265 1265 + fn lexicon_doc() -> ::jacquard_lexicon::lexicon::LexiconDoc<'static> { 1266 1266 + lexicon_doc_place_wisp_fs() 1267 1267 + } 1268 1268 + fn validate( 1269 1269 + &self, 1270 1270 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 1271 1271 + if let Some(ref value) = self.file_count { 1272 1272 + if *value > 1000i64 { 1273 1273 + return Err(::jacquard_lexicon::validation::ConstraintError::Maximum { 1274 1274 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 1275 1275 + "file_count", 1276 1276 + ), 1277 1277 + max: 1000i64, 1278 1278 + actual: *value, 1279 1279 + }); 1280 1280 + } 1281 1281 + } 1282 1282 + if let Some(ref value) = self.file_count { 1283 1283 + if *value < 0i64 { 1284 1284 + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { 1285 1285 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 1286 1286 + "file_count", 1287 1287 + ), 1288 1288 + min: 0i64, 1289 1289 + actual: *value, 1290 1290 + }); 1291 1291 + } 1292 1292 + } 1293 1293 + Ok(()) 1294 1294 + } 1295 1295 + } 1296 1296 + 1297 1297 + #[jacquard_derive::lexicon] 1298 1298 + #[derive( 1299 1299 + serde::Serialize, 1300 1300 + serde::Deserialize, 1301 1301 + Debug, 1302 1302 + Clone, 1303 1303 + PartialEq, 1304 1304 + Eq, 1305 1305 + jacquard_derive::IntoStatic 1306 1306 + )] 1307 1307 + #[serde(rename_all = "camelCase")] 1308 1308 + pub struct Subfs<'a> { 1309 1309 + /// If true (default), the subfs record's root entries are merged (flattened) into the parent directory, replacing the subfs entry. If false, the subfs entries are placed in a subdirectory with the subfs entry's name. Flat merging is useful for splitting large directories across multiple records while maintaining a flat structure. 1310 1310 + #[serde(skip_serializing_if = "std::option::Option::is_none")] 1311 1311 + pub flat: std::option::Option<bool>, 1312 1312 + /// AT-URI pointing to a place.wisp.subfs record containing this subtree. 1313 1313 + #[serde(borrow)] 1314 1314 + pub subject: jacquard_common::types::string::AtUri<'a>, 1315 1315 + #[serde(borrow)] 1316 1316 + pub r#type: jacquard_common::CowStr<'a>, 1317 1317 + } 1318 1318 + 1319 1319 + pub mod subfs_state { 1320 1320 + 1321 1321 + pub use crate::builder_types::{Set, Unset, IsSet, IsUnset}; 1322 1322 + #[allow(unused)] 1323 1323 + use ::core::marker::PhantomData; 1324 1324 + mod sealed { 1325 1325 + pub trait Sealed {} 1326 1326 + } 1327 1327 + /// State trait tracking which required fields have been set 1328 1328 + pub trait State: sealed::Sealed { 1329 1329 + type Type; 1330 1330 + type Subject; 1331 1331 + } 1332 1332 + /// Empty state - all required fields are unset 1333 1333 + pub struct Empty(()); 1334 1334 + impl sealed::Sealed for Empty {} 1335 1335 + impl State for Empty { 1336 1336 + type Type = Unset; 1337 1337 + type Subject = Unset; 1338 1338 + } 1339 1339 + ///State transition - sets the `type` field to Set 1340 1340 + pub struct SetType<S: State = Empty>(PhantomData<fn() -> S>); 1341 1341 + impl<S: State> sealed::Sealed for SetType<S> {} 1342 1342 + impl<S: State> State for SetType<S> { 1343 1343 + type Type = Set<members::r#type>; 1344 1344 + type Subject = S::Subject; 1345 1345 + } 1346 1346 + ///State transition - sets the `subject` field to Set 1347 1347 + pub struct SetSubject<S: State = Empty>(PhantomData<fn() -> S>); 1348 1348 + impl<S: State> sealed::Sealed for SetSubject<S> {} 1349 1349 + impl<S: State> State for SetSubject<S> { 1350 1350 + type Type = S::Type; 1351 1351 + type Subject = Set<members::subject>; 1352 1352 + } 1353 1353 + /// Marker types for field names 1354 1354 + #[allow(non_camel_case_types)] 1355 1355 + pub mod members { 1356 1356 + ///Marker type for the `type` field 1357 1357 + pub struct r#type(()); 1358 1358 + ///Marker type for the `subject` field 1359 1359 + pub struct subject(()); 1360 1360 + } 1361 1361 + } 1362 1362 + 1363 1363 + /// Builder for constructing an instance of this type 1364 1364 + pub struct SubfsBuilder<'a, S: subfs_state::State> { 1365 1365 + _phantom_state: ::core::marker::PhantomData<fn() -> S>, 1366 1366 + __unsafe_private_named: ( 1367 1367 + ::core::option::Option<bool>, 1368 1368 + ::core::option::Option<jacquard_common::types::string::AtUri<'a>>, 1369 1369 + ::core::option::Option<jacquard_common::CowStr<'a>>, 1370 1370 + ), 1371 1371 + _phantom: ::core::marker::PhantomData<&'a ()>, 1372 1372 + } 1373 1373 + 1374 1374 + impl<'a> Subfs<'a> { 1375 1375 + /// Create a new builder for this type 1376 1376 + pub fn new() -> SubfsBuilder<'a, subfs_state::Empty> { 1377 1377 + SubfsBuilder::new() 1378 1378 + } 1379 1379 + } 1380 1380 + 1381 1381 + impl<'a> SubfsBuilder<'a, subfs_state::Empty> { 1382 1382 + /// Create a new builder with all fields unset 1383 1383 + pub fn new() -> Self { 1384 1384 + SubfsBuilder { 1385 1385 + _phantom_state: ::core::marker::PhantomData, 1386 1386 + __unsafe_private_named: (None, None, None), 1387 1387 + _phantom: ::core::marker::PhantomData, 1388 1388 + } 1389 1389 + } 1390 1390 + } 1391 1391 + 1392 1392 + impl<'a, S: subfs_state::State> SubfsBuilder<'a, S> { 1393 1393 + /// Set the `flat` field (optional) 1394 1394 + pub fn flat(mut self, value: impl Into<Option<bool>>) -> Self { 1395 1395 + self.__unsafe_private_named.0 = value.into(); 1396 1396 + self 1397 1397 + } 1398 1398 + /// Set the `flat` field to an Option value (optional) 1399 1399 + pub fn maybe_flat(mut self, value: Option<bool>) -> Self { 1400 1400 + self.__unsafe_private_named.0 = value; 1401 1401 + self 1402 1402 + } 1403 1403 + } 1404 1404 + 1405 1405 + impl<'a, S> SubfsBuilder<'a, S> 1406 1406 + where 1407 1407 + S: subfs_state::State, 1408 1408 + S::Subject: subfs_state::IsUnset, 1409 1409 + { 1410 1410 + /// Set the `subject` field (required) 1411 1411 + pub fn subject( 1412 1412 + mut self, 1413 1413 + value: impl Into<jacquard_common::types::string::AtUri<'a>>, 1414 1414 + ) -> SubfsBuilder<'a, subfs_state::SetSubject<S>> { 1415 1415 + self.__unsafe_private_named.1 = ::core::option::Option::Some(value.into()); 1416 1416 + SubfsBuilder { 1417 1417 + _phantom_state: ::core::marker::PhantomData, 1418 1418 + __unsafe_private_named: self.__unsafe_private_named, 1419 1419 + _phantom: ::core::marker::PhantomData, 1420 1420 + } 1421 1421 + } 1422 1422 + } 1423 1423 + 1424 1424 + impl<'a, S> SubfsBuilder<'a, S> 1425 1425 + where 1426 1426 + S: subfs_state::State, 1427 1427 + S::Type: subfs_state::IsUnset, 1428 1428 + { 1429 1429 + /// Set the `type` field (required) 1430 1430 + pub fn r#type( 1431 1431 + mut self, 1432 1432 + value: impl Into<jacquard_common::CowStr<'a>>, 1433 1433 + ) -> SubfsBuilder<'a, subfs_state::SetType<S>> { 1434 1434 + self.__unsafe_private_named.2 = ::core::option::Option::Some(value.into()); 1435 1435 + SubfsBuilder { 1436 1436 + _phantom_state: ::core::marker::PhantomData, 1437 1437 + __unsafe_private_named: self.__unsafe_private_named, 1438 1438 + _phantom: ::core::marker::PhantomData, 1439 1439 + } 1440 1440 + } 1441 1441 + } 1442 1442 + 1443 1443 + impl<'a, S> SubfsBuilder<'a, S> 1444 1444 + where 1445 1445 + S: subfs_state::State, 1446 1446 + S::Type: subfs_state::IsSet, 1447 1447 + S::Subject: subfs_state::IsSet, 1448 1448 + { 1449 1449 + /// Build the final struct 1450 1450 + pub fn build(self) -> Subfs<'a> { 1451 1451 + Subfs { 1452 1452 + flat: self.__unsafe_private_named.0, 1453 1453 + subject: self.__unsafe_private_named.1.unwrap(), 1454 1454 + r#type: self.__unsafe_private_named.2.unwrap(), 1455 1455 + extra_data: Default::default(), 1456 1456 + } 1457 1457 + } 1458 1458 + /// Build the final struct with custom extra_data 1459 1459 + pub fn build_with_data( 1460 1460 + self, 1461 1461 + extra_data: std::collections::BTreeMap< 1462 1462 + jacquard_common::smol_str::SmolStr, 1463 1463 + jacquard_common::types::value::Data<'a>, 1464 1464 + >, 1465 1465 + ) -> Subfs<'a> { 1466 1466 + Subfs { 1467 1467 + flat: self.__unsafe_private_named.0, 1468 1468 + subject: self.__unsafe_private_named.1.unwrap(), 1469 1469 + r#type: self.__unsafe_private_named.2.unwrap(), 1470 1470 + extra_data: Some(extra_data), 1471 1471 + } 1472 1472 + } 1473 1473 + } 1474 1474 + 1475 1475 + impl<'a> ::jacquard_lexicon::schema::LexiconSchema for Subfs<'a> { 1476 1476 + fn nsid() -> &'static str { 1477 1477 + "place.wisp.fs" 1478 1478 + } 1479 1479 + fn def_name() -> &'static str { 1480 1480 + "subfs" 1481 1481 + } 1482 1482 + fn lexicon_doc() -> ::jacquard_lexicon::lexicon::LexiconDoc<'static> { 1483 1483 + lexicon_doc_place_wisp_fs() 1484 1484 + } 1485 1485 + fn validate( 1486 1486 + &self, 1487 1487 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 1488 1488 + Ok(()) 1489 1489 + } 1490 1490 + }

+653

cli/crates/lexicons/src/place_wisp/settings.rs

··· 1 1 + // @generated by jacquard-lexicon. DO NOT EDIT. 2 2 + // 3 3 + // Lexicon: place.wisp.settings 4 4 + // 5 5 + // This file was automatically generated from Lexicon schemas. 6 6 + // Any manual changes will be overwritten on the next regeneration. 7 7 + 8 8 + /// Custom HTTP header configuration 9 9 + #[jacquard_derive::lexicon] 10 10 + #[derive( 11 11 + serde::Serialize, 12 12 + serde::Deserialize, 13 13 + Debug, 14 14 + Clone, 15 15 + PartialEq, 16 16 + Eq, 17 17 + jacquard_derive::IntoStatic, 18 18 + Default 19 19 + )] 20 20 + #[serde(rename_all = "camelCase")] 21 21 + pub struct CustomHeader<'a> { 22 22 + /// HTTP header name (e.g., 'Cache-Control', 'X-Frame-Options') 23 23 + #[serde(borrow)] 24 24 + pub name: jacquard_common::CowStr<'a>, 25 25 + /// Optional glob pattern to apply this header to specific paths (e.g., '*.html', '/assets/*'). If not specified, applies to all paths. 26 26 + #[serde(skip_serializing_if = "std::option::Option::is_none")] 27 27 + #[serde(borrow)] 28 28 + pub path: std::option::Option<jacquard_common::CowStr<'a>>, 29 29 + /// HTTP header value 30 30 + #[serde(borrow)] 31 31 + pub value: jacquard_common::CowStr<'a>, 32 32 + } 33 33 + 34 34 + fn lexicon_doc_place_wisp_settings() -> ::jacquard_lexicon::lexicon::LexiconDoc< 35 35 + 'static, 36 36 + > { 37 37 + ::jacquard_lexicon::lexicon::LexiconDoc { 38 38 + lexicon: ::jacquard_lexicon::lexicon::Lexicon::Lexicon1, 39 39 + id: ::jacquard_common::CowStr::new_static("place.wisp.settings"), 40 40 + revision: None, 41 41 + description: None, 42 42 + defs: { 43 43 + let mut map = ::std::collections::BTreeMap::new(); 44 44 + map.insert( 45 45 + ::jacquard_common::smol_str::SmolStr::new_static("customHeader"), 46 46 + ::jacquard_lexicon::lexicon::LexUserType::Object(::jacquard_lexicon::lexicon::LexObject { 47 47 + description: Some( 48 48 + ::jacquard_common::CowStr::new_static( 49 49 + "Custom HTTP header configuration", 50 50 + ), 51 51 + ), 52 52 + required: Some( 53 53 + vec![ 54 54 + ::jacquard_common::smol_str::SmolStr::new_static("name"), 55 55 + ::jacquard_common::smol_str::SmolStr::new_static("value") 56 56 + ], 57 57 + ), 58 58 + nullable: None, 59 59 + properties: { 60 60 + #[allow(unused_mut)] 61 61 + let mut map = ::std::collections::BTreeMap::new(); 62 62 + map.insert( 63 63 + ::jacquard_common::smol_str::SmolStr::new_static("name"), 64 64 + ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString { 65 65 + description: Some( 66 66 + ::jacquard_common::CowStr::new_static( 67 67 + "HTTP header name (e.g., 'Cache-Control', 'X-Frame-Options')", 68 68 + ), 69 69 + ), 70 70 + format: None, 71 71 + default: None, 72 72 + min_length: None, 73 73 + max_length: Some(100usize), 74 74 + min_graphemes: None, 75 75 + max_graphemes: None, 76 76 + r#enum: None, 77 77 + r#const: None, 78 78 + known_values: None, 79 79 + }), 80 80 + ); 81 81 + map.insert( 82 82 + ::jacquard_common::smol_str::SmolStr::new_static("path"), 83 83 + ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString { 84 84 + description: Some( 85 85 + ::jacquard_common::CowStr::new_static( 86 86 + "Optional glob pattern to apply this header to specific paths (e.g., '*.html', '/assets/*'). If not specified, applies to all paths.", 87 87 + ), 88 88 + ), 89 89 + format: None, 90 90 + default: None, 91 91 + min_length: None, 92 92 + max_length: Some(500usize), 93 93 + min_graphemes: None, 94 94 + max_graphemes: None, 95 95 + r#enum: None, 96 96 + r#const: None, 97 97 + known_values: None, 98 98 + }), 99 99 + ); 100 100 + map.insert( 101 101 + ::jacquard_common::smol_str::SmolStr::new_static("value"), 102 102 + ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString { 103 103 + description: Some( 104 104 + ::jacquard_common::CowStr::new_static("HTTP header value"), 105 105 + ), 106 106 + format: None, 107 107 + default: None, 108 108 + min_length: None, 109 109 + max_length: Some(1000usize), 110 110 + min_graphemes: None, 111 111 + max_graphemes: None, 112 112 + r#enum: None, 113 113 + r#const: None, 114 114 + known_values: None, 115 115 + }), 116 116 + ); 117 117 + map 118 118 + }, 119 119 + }), 120 120 + ); 121 121 + map.insert( 122 122 + ::jacquard_common::smol_str::SmolStr::new_static("main"), 123 123 + ::jacquard_lexicon::lexicon::LexUserType::Record(::jacquard_lexicon::lexicon::LexRecord { 124 124 + description: Some( 125 125 + ::jacquard_common::CowStr::new_static( 126 126 + "Configuration settings for a static site hosted on wisp.place", 127 127 + ), 128 128 + ), 129 129 + key: Some(::jacquard_common::CowStr::new_static("any")), 130 130 + record: ::jacquard_lexicon::lexicon::LexRecordRecord::Object(::jacquard_lexicon::lexicon::LexObject { 131 131 + description: None, 132 132 + required: None, 133 133 + nullable: None, 134 134 + properties: { 135 135 + #[allow(unused_mut)] 136 136 + let mut map = ::std::collections::BTreeMap::new(); 137 137 + map.insert( 138 138 + ::jacquard_common::smol_str::SmolStr::new_static( 139 139 + "cleanUrls", 140 140 + ), 141 141 + ::jacquard_lexicon::lexicon::LexObjectProperty::Boolean(::jacquard_lexicon::lexicon::LexBoolean { 142 142 + description: None, 143 143 + default: None, 144 144 + r#const: None, 145 145 + }), 146 146 + ); 147 147 + map.insert( 148 148 + ::jacquard_common::smol_str::SmolStr::new_static( 149 149 + "custom404", 150 150 + ), 151 151 + ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString { 152 152 + description: Some( 153 153 + ::jacquard_common::CowStr::new_static( 154 154 + "Custom 404 error page file path. Incompatible with directoryListing and spaMode.", 155 155 + ), 156 156 + ), 157 157 + format: None, 158 158 + default: None, 159 159 + min_length: None, 160 160 + max_length: Some(500usize), 161 161 + min_graphemes: None, 162 162 + max_graphemes: None, 163 163 + r#enum: None, 164 164 + r#const: None, 165 165 + known_values: None, 166 166 + }), 167 167 + ); 168 168 + map.insert( 169 169 + ::jacquard_common::smol_str::SmolStr::new_static( 170 170 + "directoryListing", 171 171 + ), 172 172 + ::jacquard_lexicon::lexicon::LexObjectProperty::Boolean(::jacquard_lexicon::lexicon::LexBoolean { 173 173 + description: None, 174 174 + default: None, 175 175 + r#const: None, 176 176 + }), 177 177 + ); 178 178 + map.insert( 179 179 + ::jacquard_common::smol_str::SmolStr::new_static("headers"), 180 180 + ::jacquard_lexicon::lexicon::LexObjectProperty::Array(::jacquard_lexicon::lexicon::LexArray { 181 181 + description: Some( 182 182 + ::jacquard_common::CowStr::new_static( 183 183 + "Custom HTTP headers to set on responses", 184 184 + ), 185 185 + ), 186 186 + items: ::jacquard_lexicon::lexicon::LexArrayItem::Ref(::jacquard_lexicon::lexicon::LexRef { 187 187 + description: None, 188 188 + r#ref: ::jacquard_common::CowStr::new_static( 189 189 + "#customHeader", 190 190 + ), 191 191 + }), 192 192 + min_length: None, 193 193 + max_length: Some(50usize), 194 194 + }), 195 195 + ); 196 196 + map.insert( 197 197 + ::jacquard_common::smol_str::SmolStr::new_static( 198 198 + "indexFiles", 199 199 + ), 200 200 + ::jacquard_lexicon::lexicon::LexObjectProperty::Array(::jacquard_lexicon::lexicon::LexArray { 201 201 + description: Some( 202 202 + ::jacquard_common::CowStr::new_static( 203 203 + "Ordered list of files to try when serving a directory. Defaults to ['index.html'] if not specified.", 204 204 + ), 205 205 + ), 206 206 + items: ::jacquard_lexicon::lexicon::LexArrayItem::String(::jacquard_lexicon::lexicon::LexString { 207 207 + description: None, 208 208 + format: None, 209 209 + default: None, 210 210 + min_length: None, 211 211 + max_length: Some(255usize), 212 212 + min_graphemes: None, 213 213 + max_graphemes: None, 214 214 + r#enum: None, 215 215 + r#const: None, 216 216 + known_values: None, 217 217 + }), 218 218 + min_length: None, 219 219 + max_length: Some(10usize), 220 220 + }), 221 221 + ); 222 222 + map.insert( 223 223 + ::jacquard_common::smol_str::SmolStr::new_static("spaMode"), 224 224 + ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString { 225 225 + description: Some( 226 226 + ::jacquard_common::CowStr::new_static( 227 227 + "File to serve for all routes (e.g., 'index.html'). When set, enables SPA mode where all non-file requests are routed to this file. Incompatible with directoryListing and custom404.", 228 228 + ), 229 229 + ), 230 230 + format: None, 231 231 + default: None, 232 232 + min_length: None, 233 233 + max_length: Some(500usize), 234 234 + min_graphemes: None, 235 235 + max_graphemes: None, 236 236 + r#enum: None, 237 237 + r#const: None, 238 238 + known_values: None, 239 239 + }), 240 240 + ); 241 241 + map 242 242 + }, 243 243 + }), 244 244 + }), 245 245 + ); 246 246 + map 247 247 + }, 248 248 + } 249 249 + } 250 250 + 251 251 + impl<'a> ::jacquard_lexicon::schema::LexiconSchema for CustomHeader<'a> { 252 252 + fn nsid() -> &'static str { 253 253 + "place.wisp.settings" 254 254 + } 255 255 + fn def_name() -> &'static str { 256 256 + "customHeader" 257 257 + } 258 258 + fn lexicon_doc() -> ::jacquard_lexicon::lexicon::LexiconDoc<'static> { 259 259 + lexicon_doc_place_wisp_settings() 260 260 + } 261 261 + fn validate( 262 262 + &self, 263 263 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 264 264 + { 265 265 + let value = &self.name; 266 266 + #[allow(unused_comparisons)] 267 267 + if <str>::len(value.as_ref()) > 100usize { 268 268 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 269 269 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 270 270 + "name", 271 271 + ), 272 272 + max: 100usize, 273 273 + actual: <str>::len(value.as_ref()), 274 274 + }); 275 275 + } 276 276 + } 277 277 + if let Some(ref value) = self.path { 278 278 + #[allow(unused_comparisons)] 279 279 + if <str>::len(value.as_ref()) > 500usize { 280 280 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 281 281 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 282 282 + "path", 283 283 + ), 284 284 + max: 500usize, 285 285 + actual: <str>::len(value.as_ref()), 286 286 + }); 287 287 + } 288 288 + } 289 289 + { 290 290 + let value = &self.value; 291 291 + #[allow(unused_comparisons)] 292 292 + if <str>::len(value.as_ref()) > 1000usize { 293 293 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 294 294 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 295 295 + "value", 296 296 + ), 297 297 + max: 1000usize, 298 298 + actual: <str>::len(value.as_ref()), 299 299 + }); 300 300 + } 301 301 + } 302 302 + Ok(()) 303 303 + } 304 304 + } 305 305 + 306 306 + /// Configuration settings for a static site hosted on wisp.place 307 307 + #[jacquard_derive::lexicon] 308 308 + #[derive( 309 309 + serde::Serialize, 310 310 + serde::Deserialize, 311 311 + Debug, 312 312 + Clone, 313 313 + PartialEq, 314 314 + Eq, 315 315 + jacquard_derive::IntoStatic 316 316 + )] 317 317 + #[serde(rename_all = "camelCase")] 318 318 + pub struct Settings<'a> { 319 319 + /// Enable clean URL routing. When enabled, '/about' will attempt to serve '/about.html' or '/about/index.html' automatically. 320 320 + #[serde(skip_serializing_if = "std::option::Option::is_none")] 321 321 + pub clean_urls: std::option::Option<bool>, 322 322 + /// Custom 404 error page file path. Incompatible with directoryListing and spaMode. 323 323 + #[serde(skip_serializing_if = "std::option::Option::is_none")] 324 324 + #[serde(borrow)] 325 325 + pub custom404: std::option::Option<jacquard_common::CowStr<'a>>, 326 326 + /// Enable directory listing mode for paths that resolve to directories without an index file. Incompatible with spaMode. 327 327 + #[serde(skip_serializing_if = "std::option::Option::is_none")] 328 328 + pub directory_listing: std::option::Option<bool>, 329 329 + /// Custom HTTP headers to set on responses 330 330 + #[serde(skip_serializing_if = "std::option::Option::is_none")] 331 331 + #[serde(borrow)] 332 332 + pub headers: std::option::Option<Vec<crate::place_wisp::settings::CustomHeader<'a>>>, 333 333 + /// Ordered list of files to try when serving a directory. Defaults to ['index.html'] if not specified. 334 334 + #[serde(skip_serializing_if = "std::option::Option::is_none")] 335 335 + #[serde(borrow)] 336 336 + pub index_files: std::option::Option<Vec<jacquard_common::CowStr<'a>>>, 337 337 + /// File to serve for all routes (e.g., 'index.html'). When set, enables SPA mode where all non-file requests are routed to this file. Incompatible with directoryListing and custom404. 338 338 + #[serde(skip_serializing_if = "std::option::Option::is_none")] 339 339 + #[serde(borrow)] 340 340 + pub spa_mode: std::option::Option<jacquard_common::CowStr<'a>>, 341 341 + } 342 342 + 343 343 + pub mod settings_state { 344 344 + 345 345 + pub use crate::builder_types::{Set, Unset, IsSet, IsUnset}; 346 346 + #[allow(unused)] 347 347 + use ::core::marker::PhantomData; 348 348 + mod sealed { 349 349 + pub trait Sealed {} 350 350 + } 351 351 + /// State trait tracking which required fields have been set 352 352 + pub trait State: sealed::Sealed {} 353 353 + /// Empty state - all required fields are unset 354 354 + pub struct Empty(()); 355 355 + impl sealed::Sealed for Empty {} 356 356 + impl State for Empty {} 357 357 + /// Marker types for field names 358 358 + #[allow(non_camel_case_types)] 359 359 + pub mod members {} 360 360 + } 361 361 + 362 362 + /// Builder for constructing an instance of this type 363 363 + pub struct SettingsBuilder<'a, S: settings_state::State> { 364 364 + _phantom_state: ::core::marker::PhantomData<fn() -> S>, 365 365 + __unsafe_private_named: ( 366 366 + ::core::option::Option<bool>, 367 367 + ::core::option::Option<jacquard_common::CowStr<'a>>, 368 368 + ::core::option::Option<bool>, 369 369 + ::core::option::Option<Vec<crate::place_wisp::settings::CustomHeader<'a>>>, 370 370 + ::core::option::Option<Vec<jacquard_common::CowStr<'a>>>, 371 371 + ::core::option::Option<jacquard_common::CowStr<'a>>, 372 372 + ), 373 373 + _phantom: ::core::marker::PhantomData<&'a ()>, 374 374 + } 375 375 + 376 376 + impl<'a> Settings<'a> { 377 377 + /// Create a new builder for this type 378 378 + pub fn new() -> SettingsBuilder<'a, settings_state::Empty> { 379 379 + SettingsBuilder::new() 380 380 + } 381 381 + } 382 382 + 383 383 + impl<'a> SettingsBuilder<'a, settings_state::Empty> { 384 384 + /// Create a new builder with all fields unset 385 385 + pub fn new() -> Self { 386 386 + SettingsBuilder { 387 387 + _phantom_state: ::core::marker::PhantomData, 388 388 + __unsafe_private_named: (None, None, None, None, None, None), 389 389 + _phantom: ::core::marker::PhantomData, 390 390 + } 391 391 + } 392 392 + } 393 393 + 394 394 + impl<'a, S: settings_state::State> SettingsBuilder<'a, S> { 395 395 + /// Set the `cleanUrls` field (optional) 396 396 + pub fn clean_urls(mut self, value: impl Into<Option<bool>>) -> Self { 397 397 + self.__unsafe_private_named.0 = value.into(); 398 398 + self 399 399 + } 400 400 + /// Set the `cleanUrls` field to an Option value (optional) 401 401 + pub fn maybe_clean_urls(mut self, value: Option<bool>) -> Self { 402 402 + self.__unsafe_private_named.0 = value; 403 403 + self 404 404 + } 405 405 + } 406 406 + 407 407 + impl<'a, S: settings_state::State> SettingsBuilder<'a, S> { 408 408 + /// Set the `custom404` field (optional) 409 409 + pub fn custom404( 410 410 + mut self, 411 411 + value: impl Into<Option<jacquard_common::CowStr<'a>>>, 412 412 + ) -> Self { 413 413 + self.__unsafe_private_named.1 = value.into(); 414 414 + self 415 415 + } 416 416 + /// Set the `custom404` field to an Option value (optional) 417 417 + pub fn maybe_custom404( 418 418 + mut self, 419 419 + value: Option<jacquard_common::CowStr<'a>>, 420 420 + ) -> Self { 421 421 + self.__unsafe_private_named.1 = value; 422 422 + self 423 423 + } 424 424 + } 425 425 + 426 426 + impl<'a, S: settings_state::State> SettingsBuilder<'a, S> { 427 427 + /// Set the `directoryListing` field (optional) 428 428 + pub fn directory_listing(mut self, value: impl Into<Option<bool>>) -> Self { 429 429 + self.__unsafe_private_named.2 = value.into(); 430 430 + self 431 431 + } 432 432 + /// Set the `directoryListing` field to an Option value (optional) 433 433 + pub fn maybe_directory_listing(mut self, value: Option<bool>) -> Self { 434 434 + self.__unsafe_private_named.2 = value; 435 435 + self 436 436 + } 437 437 + } 438 438 + 439 439 + impl<'a, S: settings_state::State> SettingsBuilder<'a, S> { 440 440 + /// Set the `headers` field (optional) 441 441 + pub fn headers( 442 442 + mut self, 443 443 + value: impl Into<Option<Vec<crate::place_wisp::settings::CustomHeader<'a>>>>, 444 444 + ) -> Self { 445 445 + self.__unsafe_private_named.3 = value.into(); 446 446 + self 447 447 + } 448 448 + /// Set the `headers` field to an Option value (optional) 449 449 + pub fn maybe_headers( 450 450 + mut self, 451 451 + value: Option<Vec<crate::place_wisp::settings::CustomHeader<'a>>>, 452 452 + ) -> Self { 453 453 + self.__unsafe_private_named.3 = value; 454 454 + self 455 455 + } 456 456 + } 457 457 + 458 458 + impl<'a, S: settings_state::State> SettingsBuilder<'a, S> { 459 459 + /// Set the `indexFiles` field (optional) 460 460 + pub fn index_files( 461 461 + mut self, 462 462 + value: impl Into<Option<Vec<jacquard_common::CowStr<'a>>>>, 463 463 + ) -> Self { 464 464 + self.__unsafe_private_named.4 = value.into(); 465 465 + self 466 466 + } 467 467 + /// Set the `indexFiles` field to an Option value (optional) 468 468 + pub fn maybe_index_files( 469 469 + mut self, 470 470 + value: Option<Vec<jacquard_common::CowStr<'a>>>, 471 471 + ) -> Self { 472 472 + self.__unsafe_private_named.4 = value; 473 473 + self 474 474 + } 475 475 + } 476 476 + 477 477 + impl<'a, S: settings_state::State> SettingsBuilder<'a, S> { 478 478 + /// Set the `spaMode` field (optional) 479 479 + pub fn spa_mode( 480 480 + mut self, 481 481 + value: impl Into<Option<jacquard_common::CowStr<'a>>>, 482 482 + ) -> Self { 483 483 + self.__unsafe_private_named.5 = value.into(); 484 484 + self 485 485 + } 486 486 + /// Set the `spaMode` field to an Option value (optional) 487 487 + pub fn maybe_spa_mode(mut self, value: Option<jacquard_common::CowStr<'a>>) -> Self { 488 488 + self.__unsafe_private_named.5 = value; 489 489 + self 490 490 + } 491 491 + } 492 492 + 493 493 + impl<'a, S> SettingsBuilder<'a, S> 494 494 + where 495 495 + S: settings_state::State, 496 496 + { 497 497 + /// Build the final struct 498 498 + pub fn build(self) -> Settings<'a> { 499 499 + Settings { 500 500 + clean_urls: self.__unsafe_private_named.0, 501 501 + custom404: self.__unsafe_private_named.1, 502 502 + directory_listing: self.__unsafe_private_named.2, 503 503 + headers: self.__unsafe_private_named.3, 504 504 + index_files: self.__unsafe_private_named.4, 505 505 + spa_mode: self.__unsafe_private_named.5, 506 506 + extra_data: Default::default(), 507 507 + } 508 508 + } 509 509 + /// Build the final struct with custom extra_data 510 510 + pub fn build_with_data( 511 511 + self, 512 512 + extra_data: std::collections::BTreeMap< 513 513 + jacquard_common::smol_str::SmolStr, 514 514 + jacquard_common::types::value::Data<'a>, 515 515 + >, 516 516 + ) -> Settings<'a> { 517 517 + Settings { 518 518 + clean_urls: self.__unsafe_private_named.0, 519 519 + custom404: self.__unsafe_private_named.1, 520 520 + directory_listing: self.__unsafe_private_named.2, 521 521 + headers: self.__unsafe_private_named.3, 522 522 + index_files: self.__unsafe_private_named.4, 523 523 + spa_mode: self.__unsafe_private_named.5, 524 524 + extra_data: Some(extra_data), 525 525 + } 526 526 + } 527 527 + } 528 528 + 529 529 + impl<'a> Settings<'a> { 530 530 + pub fn uri( 531 531 + uri: impl Into<jacquard_common::CowStr<'a>>, 532 532 + ) -> Result< 533 533 + jacquard_common::types::uri::RecordUri<'a, SettingsRecord>, 534 534 + jacquard_common::types::uri::UriError, 535 535 + > { 536 536 + jacquard_common::types::uri::RecordUri::try_from_uri( 537 537 + jacquard_common::types::string::AtUri::new_cow(uri.into())?, 538 538 + ) 539 539 + } 540 540 + } 541 541 + 542 542 + /// Typed wrapper for GetRecord response with this collection's record type. 543 543 + #[derive( 544 544 + serde::Serialize, 545 545 + serde::Deserialize, 546 546 + Debug, 547 547 + Clone, 548 548 + PartialEq, 549 549 + Eq, 550 550 + jacquard_derive::IntoStatic 551 551 + )] 552 552 + #[serde(rename_all = "camelCase")] 553 553 + pub struct SettingsGetRecordOutput<'a> { 554 554 + #[serde(skip_serializing_if = "std::option::Option::is_none")] 555 555 + #[serde(borrow)] 556 556 + pub cid: std::option::Option<jacquard_common::types::string::Cid<'a>>, 557 557 + #[serde(borrow)] 558 558 + pub uri: jacquard_common::types::string::AtUri<'a>, 559 559 + #[serde(borrow)] 560 560 + pub value: Settings<'a>, 561 561 + } 562 562 + 563 563 + impl From<SettingsGetRecordOutput<'_>> for Settings<'_> { 564 564 + fn from(output: SettingsGetRecordOutput<'_>) -> Self { 565 565 + use jacquard_common::IntoStatic; 566 566 + output.value.into_static() 567 567 + } 568 568 + } 569 569 + 570 570 + impl jacquard_common::types::collection::Collection for Settings<'_> { 571 571 + const NSID: &'static str = "place.wisp.settings"; 572 572 + type Record = SettingsRecord; 573 573 + } 574 574 + 575 575 + /// Marker type for deserializing records from this collection. 576 576 + #[derive(Debug, serde::Serialize, serde::Deserialize)] 577 577 + pub struct SettingsRecord; 578 578 + impl jacquard_common::xrpc::XrpcResp for SettingsRecord { 579 579 + const NSID: &'static str = "place.wisp.settings"; 580 580 + const ENCODING: &'static str = "application/json"; 581 581 + type Output<'de> = SettingsGetRecordOutput<'de>; 582 582 + type Err<'de> = jacquard_common::types::collection::RecordError<'de>; 583 583 + } 584 584 + 585 585 + impl jacquard_common::types::collection::Collection for SettingsRecord { 586 586 + const NSID: &'static str = "place.wisp.settings"; 587 587 + type Record = SettingsRecord; 588 588 + } 589 589 + 590 590 + impl<'a> ::jacquard_lexicon::schema::LexiconSchema for Settings<'a> { 591 591 + fn nsid() -> &'static str { 592 592 + "place.wisp.settings" 593 593 + } 594 594 + fn def_name() -> &'static str { 595 595 + "main" 596 596 + } 597 597 + fn lexicon_doc() -> ::jacquard_lexicon::lexicon::LexiconDoc<'static> { 598 598 + lexicon_doc_place_wisp_settings() 599 599 + } 600 600 + fn validate( 601 601 + &self, 602 602 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 603 603 + if let Some(ref value) = self.custom404 { 604 604 + #[allow(unused_comparisons)] 605 605 + if <str>::len(value.as_ref()) > 500usize { 606 606 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 607 607 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 608 608 + "custom404", 609 609 + ), 610 610 + max: 500usize, 611 611 + actual: <str>::len(value.as_ref()), 612 612 + }); 613 613 + } 614 614 + } 615 615 + if let Some(ref value) = self.headers { 616 616 + #[allow(unused_comparisons)] 617 617 + if value.len() > 50usize { 618 618 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 619 619 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 620 620 + "headers", 621 621 + ), 622 622 + max: 50usize, 623 623 + actual: value.len(), 624 624 + }); 625 625 + } 626 626 + } 627 627 + if let Some(ref value) = self.index_files { 628 628 + #[allow(unused_comparisons)] 629 629 + if value.len() > 10usize { 630 630 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 631 631 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 632 632 + "index_files", 633 633 + ), 634 634 + max: 10usize, 635 635 + actual: value.len(), 636 636 + }); 637 637 + } 638 638 + } 639 639 + if let Some(ref value) = self.spa_mode { 640 640 + #[allow(unused_comparisons)] 641 641 + if <str>::len(value.as_ref()) > 500usize { 642 642 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 643 643 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 644 644 + "spa_mode", 645 645 + ), 646 646 + max: 500usize, 647 647 + actual: <str>::len(value.as_ref()), 648 648 + }); 649 649 + } 650 650 + } 651 651 + Ok(()) 652 652 + } 653 653 + }

+1408

cli/crates/lexicons/src/place_wisp/subfs.rs

··· 1 1 + // @generated by jacquard-lexicon. DO NOT EDIT. 2 2 + // 3 3 + // Lexicon: place.wisp.subfs 4 4 + // 5 5 + // This file was automatically generated from Lexicon schemas. 6 6 + // Any manual changes will be overwritten on the next regeneration. 7 7 + 8 8 + #[jacquard_derive::lexicon] 9 9 + #[derive( 10 10 + serde::Serialize, 11 11 + serde::Deserialize, 12 12 + Debug, 13 13 + Clone, 14 14 + PartialEq, 15 15 + Eq, 16 16 + jacquard_derive::IntoStatic 17 17 + )] 18 18 + #[serde(rename_all = "camelCase")] 19 19 + pub struct Directory<'a> { 20 20 + #[serde(borrow)] 21 21 + pub entries: Vec<crate::place_wisp::subfs::Entry<'a>>, 22 22 + #[serde(borrow)] 23 23 + pub r#type: jacquard_common::CowStr<'a>, 24 24 + } 25 25 + 26 26 + pub mod directory_state { 27 27 + 28 28 + pub use crate::builder_types::{Set, Unset, IsSet, IsUnset}; 29 29 + #[allow(unused)] 30 30 + use ::core::marker::PhantomData; 31 31 + mod sealed { 32 32 + pub trait Sealed {} 33 33 + } 34 34 + /// State trait tracking which required fields have been set 35 35 + pub trait State: sealed::Sealed { 36 36 + type Type; 37 37 + type Entries; 38 38 + } 39 39 + /// Empty state - all required fields are unset 40 40 + pub struct Empty(()); 41 41 + impl sealed::Sealed for Empty {} 42 42 + impl State for Empty { 43 43 + type Type = Unset; 44 44 + type Entries = Unset; 45 45 + } 46 46 + ///State transition - sets the `type` field to Set 47 47 + pub struct SetType<S: State = Empty>(PhantomData<fn() -> S>); 48 48 + impl<S: State> sealed::Sealed for SetType<S> {} 49 49 + impl<S: State> State for SetType<S> { 50 50 + type Type = Set<members::r#type>; 51 51 + type Entries = S::Entries; 52 52 + } 53 53 + ///State transition - sets the `entries` field to Set 54 54 + pub struct SetEntries<S: State = Empty>(PhantomData<fn() -> S>); 55 55 + impl<S: State> sealed::Sealed for SetEntries<S> {} 56 56 + impl<S: State> State for SetEntries<S> { 57 57 + type Type = S::Type; 58 58 + type Entries = Set<members::entries>; 59 59 + } 60 60 + /// Marker types for field names 61 61 + #[allow(non_camel_case_types)] 62 62 + pub mod members { 63 63 + ///Marker type for the `type` field 64 64 + pub struct r#type(()); 65 65 + ///Marker type for the `entries` field 66 66 + pub struct entries(()); 67 67 + } 68 68 + } 69 69 + 70 70 + /// Builder for constructing an instance of this type 71 71 + pub struct DirectoryBuilder<'a, S: directory_state::State> { 72 72 + _phantom_state: ::core::marker::PhantomData<fn() -> S>, 73 73 + __unsafe_private_named: ( 74 74 + ::core::option::Option<Vec<crate::place_wisp::subfs::Entry<'a>>>, 75 75 + ::core::option::Option<jacquard_common::CowStr<'a>>, 76 76 + ), 77 77 + _phantom: ::core::marker::PhantomData<&'a ()>, 78 78 + } 79 79 + 80 80 + impl<'a> Directory<'a> { 81 81 + /// Create a new builder for this type 82 82 + pub fn new() -> DirectoryBuilder<'a, directory_state::Empty> { 83 83 + DirectoryBuilder::new() 84 84 + } 85 85 + } 86 86 + 87 87 + impl<'a> DirectoryBuilder<'a, directory_state::Empty> { 88 88 + /// Create a new builder with all fields unset 89 89 + pub fn new() -> Self { 90 90 + DirectoryBuilder { 91 91 + _phantom_state: ::core::marker::PhantomData, 92 92 + __unsafe_private_named: (None, None), 93 93 + _phantom: ::core::marker::PhantomData, 94 94 + } 95 95 + } 96 96 + } 97 97 + 98 98 + impl<'a, S> DirectoryBuilder<'a, S> 99 99 + where 100 100 + S: directory_state::State, 101 101 + S::Entries: directory_state::IsUnset, 102 102 + { 103 103 + /// Set the `entries` field (required) 104 104 + pub fn entries( 105 105 + mut self, 106 106 + value: impl Into<Vec<crate::place_wisp::subfs::Entry<'a>>>, 107 107 + ) -> DirectoryBuilder<'a, directory_state::SetEntries<S>> { 108 108 + self.__unsafe_private_named.0 = ::core::option::Option::Some(value.into()); 109 109 + DirectoryBuilder { 110 110 + _phantom_state: ::core::marker::PhantomData, 111 111 + __unsafe_private_named: self.__unsafe_private_named, 112 112 + _phantom: ::core::marker::PhantomData, 113 113 + } 114 114 + } 115 115 + } 116 116 + 117 117 + impl<'a, S> DirectoryBuilder<'a, S> 118 118 + where 119 119 + S: directory_state::State, 120 120 + S::Type: directory_state::IsUnset, 121 121 + { 122 122 + /// Set the `type` field (required) 123 123 + pub fn r#type( 124 124 + mut self, 125 125 + value: impl Into<jacquard_common::CowStr<'a>>, 126 126 + ) -> DirectoryBuilder<'a, directory_state::SetType<S>> { 127 127 + self.__unsafe_private_named.1 = ::core::option::Option::Some(value.into()); 128 128 + DirectoryBuilder { 129 129 + _phantom_state: ::core::marker::PhantomData, 130 130 + __unsafe_private_named: self.__unsafe_private_named, 131 131 + _phantom: ::core::marker::PhantomData, 132 132 + } 133 133 + } 134 134 + } 135 135 + 136 136 + impl<'a, S> DirectoryBuilder<'a, S> 137 137 + where 138 138 + S: directory_state::State, 139 139 + S::Type: directory_state::IsSet, 140 140 + S::Entries: directory_state::IsSet, 141 141 + { 142 142 + /// Build the final struct 143 143 + pub fn build(self) -> Directory<'a> { 144 144 + Directory { 145 145 + entries: self.__unsafe_private_named.0.unwrap(), 146 146 + r#type: self.__unsafe_private_named.1.unwrap(), 147 147 + extra_data: Default::default(), 148 148 + } 149 149 + } 150 150 + /// Build the final struct with custom extra_data 151 151 + pub fn build_with_data( 152 152 + self, 153 153 + extra_data: std::collections::BTreeMap< 154 154 + jacquard_common::smol_str::SmolStr, 155 155 + jacquard_common::types::value::Data<'a>, 156 156 + >, 157 157 + ) -> Directory<'a> { 158 158 + Directory { 159 159 + entries: self.__unsafe_private_named.0.unwrap(), 160 160 + r#type: self.__unsafe_private_named.1.unwrap(), 161 161 + extra_data: Some(extra_data), 162 162 + } 163 163 + } 164 164 + } 165 165 + 166 166 + fn lexicon_doc_place_wisp_subfs() -> ::jacquard_lexicon::lexicon::LexiconDoc<'static> { 167 167 + ::jacquard_lexicon::lexicon::LexiconDoc { 168 168 + lexicon: ::jacquard_lexicon::lexicon::Lexicon::Lexicon1, 169 169 + id: ::jacquard_common::CowStr::new_static("place.wisp.subfs"), 170 170 + revision: None, 171 171 + description: None, 172 172 + defs: { 173 173 + let mut map = ::std::collections::BTreeMap::new(); 174 174 + map.insert( 175 175 + ::jacquard_common::smol_str::SmolStr::new_static("directory"), 176 176 + ::jacquard_lexicon::lexicon::LexUserType::Object(::jacquard_lexicon::lexicon::LexObject { 177 177 + description: None, 178 178 + required: Some( 179 179 + vec![ 180 180 + ::jacquard_common::smol_str::SmolStr::new_static("type"), 181 181 + ::jacquard_common::smol_str::SmolStr::new_static("entries") 182 182 + ], 183 183 + ), 184 184 + nullable: None, 185 185 + properties: { 186 186 + #[allow(unused_mut)] 187 187 + let mut map = ::std::collections::BTreeMap::new(); 188 188 + map.insert( 189 189 + ::jacquard_common::smol_str::SmolStr::new_static("entries"), 190 190 + ::jacquard_lexicon::lexicon::LexObjectProperty::Array(::jacquard_lexicon::lexicon::LexArray { 191 191 + description: None, 192 192 + items: ::jacquard_lexicon::lexicon::LexArrayItem::Ref(::jacquard_lexicon::lexicon::LexRef { 193 193 + description: None, 194 194 + r#ref: ::jacquard_common::CowStr::new_static("#entry"), 195 195 + }), 196 196 + min_length: None, 197 197 + max_length: Some(500usize), 198 198 + }), 199 199 + ); 200 200 + map.insert( 201 201 + ::jacquard_common::smol_str::SmolStr::new_static("type"), 202 202 + ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString { 203 203 + description: None, 204 204 + format: None, 205 205 + default: None, 206 206 + min_length: None, 207 207 + max_length: None, 208 208 + min_graphemes: None, 209 209 + max_graphemes: None, 210 210 + r#enum: None, 211 211 + r#const: None, 212 212 + known_values: None, 213 213 + }), 214 214 + ); 215 215 + map 216 216 + }, 217 217 + }), 218 218 + ); 219 219 + map.insert( 220 220 + ::jacquard_common::smol_str::SmolStr::new_static("entry"), 221 221 + ::jacquard_lexicon::lexicon::LexUserType::Object(::jacquard_lexicon::lexicon::LexObject { 222 222 + description: None, 223 223 + required: Some( 224 224 + vec![ 225 225 + ::jacquard_common::smol_str::SmolStr::new_static("name"), 226 226 + ::jacquard_common::smol_str::SmolStr::new_static("node") 227 227 + ], 228 228 + ), 229 229 + nullable: None, 230 230 + properties: { 231 231 + #[allow(unused_mut)] 232 232 + let mut map = ::std::collections::BTreeMap::new(); 233 233 + map.insert( 234 234 + ::jacquard_common::smol_str::SmolStr::new_static("name"), 235 235 + ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString { 236 236 + description: None, 237 237 + format: None, 238 238 + default: None, 239 239 + min_length: None, 240 240 + max_length: Some(255usize), 241 241 + min_graphemes: None, 242 242 + max_graphemes: None, 243 243 + r#enum: None, 244 244 + r#const: None, 245 245 + known_values: None, 246 246 + }), 247 247 + ); 248 248 + map.insert( 249 249 + ::jacquard_common::smol_str::SmolStr::new_static("node"), 250 250 + ::jacquard_lexicon::lexicon::LexObjectProperty::Union(::jacquard_lexicon::lexicon::LexRefUnion { 251 251 + description: None, 252 252 + refs: vec![ 253 253 + ::jacquard_common::CowStr::new_static("#file"), 254 254 + ::jacquard_common::CowStr::new_static("#directory"), 255 255 + ::jacquard_common::CowStr::new_static("#subfs") 256 256 + ], 257 257 + closed: None, 258 258 + }), 259 259 + ); 260 260 + map 261 261 + }, 262 262 + }), 263 263 + ); 264 264 + map.insert( 265 265 + ::jacquard_common::smol_str::SmolStr::new_static("file"), 266 266 + ::jacquard_lexicon::lexicon::LexUserType::Object(::jacquard_lexicon::lexicon::LexObject { 267 267 + description: None, 268 268 + required: Some( 269 269 + vec![ 270 270 + ::jacquard_common::smol_str::SmolStr::new_static("type"), 271 271 + ::jacquard_common::smol_str::SmolStr::new_static("blob") 272 272 + ], 273 273 + ), 274 274 + nullable: None, 275 275 + properties: { 276 276 + #[allow(unused_mut)] 277 277 + let mut map = ::std::collections::BTreeMap::new(); 278 278 + map.insert( 279 279 + ::jacquard_common::smol_str::SmolStr::new_static("base64"), 280 280 + ::jacquard_lexicon::lexicon::LexObjectProperty::Boolean(::jacquard_lexicon::lexicon::LexBoolean { 281 281 + description: None, 282 282 + default: None, 283 283 + r#const: None, 284 284 + }), 285 285 + ); 286 286 + map.insert( 287 287 + ::jacquard_common::smol_str::SmolStr::new_static("blob"), 288 288 + ::jacquard_lexicon::lexicon::LexObjectProperty::Blob(::jacquard_lexicon::lexicon::LexBlob { 289 289 + description: None, 290 290 + accept: None, 291 291 + max_size: None, 292 292 + }), 293 293 + ); 294 294 + map.insert( 295 295 + ::jacquard_common::smol_str::SmolStr::new_static("encoding"), 296 296 + ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString { 297 297 + description: Some( 298 298 + ::jacquard_common::CowStr::new_static( 299 299 + "Content encoding (e.g., gzip for compressed files)", 300 300 + ), 301 301 + ), 302 302 + format: None, 303 303 + default: None, 304 304 + min_length: None, 305 305 + max_length: None, 306 306 + min_graphemes: None, 307 307 + max_graphemes: None, 308 308 + r#enum: None, 309 309 + r#const: None, 310 310 + known_values: None, 311 311 + }), 312 312 + ); 313 313 + map.insert( 314 314 + ::jacquard_common::smol_str::SmolStr::new_static("mimeType"), 315 315 + ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString { 316 316 + description: Some( 317 317 + ::jacquard_common::CowStr::new_static( 318 318 + "Original MIME type before compression", 319 319 + ), 320 320 + ), 321 321 + format: None, 322 322 + default: None, 323 323 + min_length: None, 324 324 + max_length: None, 325 325 + min_graphemes: None, 326 326 + max_graphemes: None, 327 327 + r#enum: None, 328 328 + r#const: None, 329 329 + known_values: None, 330 330 + }), 331 331 + ); 332 332 + map.insert( 333 333 + ::jacquard_common::smol_str::SmolStr::new_static("type"), 334 334 + ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString { 335 335 + description: None, 336 336 + format: None, 337 337 + default: None, 338 338 + min_length: None, 339 339 + max_length: None, 340 340 + min_graphemes: None, 341 341 + max_graphemes: None, 342 342 + r#enum: None, 343 343 + r#const: None, 344 344 + known_values: None, 345 345 + }), 346 346 + ); 347 347 + map 348 348 + }, 349 349 + }), 350 350 + ); 351 351 + map.insert( 352 352 + ::jacquard_common::smol_str::SmolStr::new_static("main"), 353 353 + ::jacquard_lexicon::lexicon::LexUserType::Record(::jacquard_lexicon::lexicon::LexRecord { 354 354 + description: Some( 355 355 + ::jacquard_common::CowStr::new_static( 356 356 + "Virtual filesystem subtree referenced by place.wisp.fs records. When a subfs entry is expanded, its root entries are merged (flattened) into the parent directory, allowing large directories to be split across multiple records while maintaining a flat structure.", 357 357 + ), 358 358 + ), 359 359 + key: None, 360 360 + record: ::jacquard_lexicon::lexicon::LexRecordRecord::Object(::jacquard_lexicon::lexicon::LexObject { 361 361 + description: None, 362 362 + required: Some( 363 363 + vec![ 364 364 + ::jacquard_common::smol_str::SmolStr::new_static("root"), 365 365 + ::jacquard_common::smol_str::SmolStr::new_static("createdAt") 366 366 + ], 367 367 + ), 368 368 + nullable: None, 369 369 + properties: { 370 370 + #[allow(unused_mut)] 371 371 + let mut map = ::std::collections::BTreeMap::new(); 372 372 + map.insert( 373 373 + ::jacquard_common::smol_str::SmolStr::new_static( 374 374 + "createdAt", 375 375 + ), 376 376 + ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString { 377 377 + description: None, 378 378 + format: Some( 379 379 + ::jacquard_lexicon::lexicon::LexStringFormat::Datetime, 380 380 + ), 381 381 + default: None, 382 382 + min_length: None, 383 383 + max_length: None, 384 384 + min_graphemes: None, 385 385 + max_graphemes: None, 386 386 + r#enum: None, 387 387 + r#const: None, 388 388 + known_values: None, 389 389 + }), 390 390 + ); 391 391 + map.insert( 392 392 + ::jacquard_common::smol_str::SmolStr::new_static( 393 393 + "fileCount", 394 394 + ), 395 395 + ::jacquard_lexicon::lexicon::LexObjectProperty::Integer(::jacquard_lexicon::lexicon::LexInteger { 396 396 + description: None, 397 397 + default: None, 398 398 + minimum: Some(0i64), 399 399 + maximum: Some(1000i64), 400 400 + r#enum: None, 401 401 + r#const: None, 402 402 + }), 403 403 + ); 404 404 + map.insert( 405 405 + ::jacquard_common::smol_str::SmolStr::new_static("root"), 406 406 + ::jacquard_lexicon::lexicon::LexObjectProperty::Ref(::jacquard_lexicon::lexicon::LexRef { 407 407 + description: None, 408 408 + r#ref: ::jacquard_common::CowStr::new_static("#directory"), 409 409 + }), 410 410 + ); 411 411 + map 412 412 + }, 413 413 + }), 414 414 + }), 415 415 + ); 416 416 + map.insert( 417 417 + ::jacquard_common::smol_str::SmolStr::new_static("subfs"), 418 418 + ::jacquard_lexicon::lexicon::LexUserType::Object(::jacquard_lexicon::lexicon::LexObject { 419 419 + description: None, 420 420 + required: Some( 421 421 + vec![ 422 422 + ::jacquard_common::smol_str::SmolStr::new_static("type"), 423 423 + ::jacquard_common::smol_str::SmolStr::new_static("subject") 424 424 + ], 425 425 + ), 426 426 + nullable: None, 427 427 + properties: { 428 428 + #[allow(unused_mut)] 429 429 + let mut map = ::std::collections::BTreeMap::new(); 430 430 + map.insert( 431 431 + ::jacquard_common::smol_str::SmolStr::new_static("subject"), 432 432 + ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString { 433 433 + description: Some( 434 434 + ::jacquard_common::CowStr::new_static( 435 435 + "AT-URI pointing to another place.wisp.subfs record for nested subtrees. When expanded, the referenced record's root entries are merged (flattened) into the parent directory, allowing recursive splitting of large directory structures.", 436 436 + ), 437 437 + ), 438 438 + format: Some( 439 439 + ::jacquard_lexicon::lexicon::LexStringFormat::AtUri, 440 440 + ), 441 441 + default: None, 442 442 + min_length: None, 443 443 + max_length: None, 444 444 + min_graphemes: None, 445 445 + max_graphemes: None, 446 446 + r#enum: None, 447 447 + r#const: None, 448 448 + known_values: None, 449 449 + }), 450 450 + ); 451 451 + map.insert( 452 452 + ::jacquard_common::smol_str::SmolStr::new_static("type"), 453 453 + ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString { 454 454 + description: None, 455 455 + format: None, 456 456 + default: None, 457 457 + min_length: None, 458 458 + max_length: None, 459 459 + min_graphemes: None, 460 460 + max_graphemes: None, 461 461 + r#enum: None, 462 462 + r#const: None, 463 463 + known_values: None, 464 464 + }), 465 465 + ); 466 466 + map 467 467 + }, 468 468 + }), 469 469 + ); 470 470 + map 471 471 + }, 472 472 + } 473 473 + } 474 474 + 475 475 + impl<'a> ::jacquard_lexicon::schema::LexiconSchema for Directory<'a> { 476 476 + fn nsid() -> &'static str { 477 477 + "place.wisp.subfs" 478 478 + } 479 479 + fn def_name() -> &'static str { 480 480 + "directory" 481 481 + } 482 482 + fn lexicon_doc() -> ::jacquard_lexicon::lexicon::LexiconDoc<'static> { 483 483 + lexicon_doc_place_wisp_subfs() 484 484 + } 485 485 + fn validate( 486 486 + &self, 487 487 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 488 488 + { 489 489 + let value = &self.entries; 490 490 + #[allow(unused_comparisons)] 491 491 + if value.len() > 500usize { 492 492 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 493 493 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 494 494 + "entries", 495 495 + ), 496 496 + max: 500usize, 497 497 + actual: value.len(), 498 498 + }); 499 499 + } 500 500 + } 501 501 + Ok(()) 502 502 + } 503 503 + } 504 504 + 505 505 + #[jacquard_derive::lexicon] 506 506 + #[derive( 507 507 + serde::Serialize, 508 508 + serde::Deserialize, 509 509 + Debug, 510 510 + Clone, 511 511 + PartialEq, 512 512 + Eq, 513 513 + jacquard_derive::IntoStatic 514 514 + )] 515 515 + #[serde(rename_all = "camelCase")] 516 516 + pub struct Entry<'a> { 517 517 + #[serde(borrow)] 518 518 + pub name: jacquard_common::CowStr<'a>, 519 519 + #[serde(borrow)] 520 520 + pub node: EntryNode<'a>, 521 521 + } 522 522 + 523 523 + pub mod entry_state { 524 524 + 525 525 + pub use crate::builder_types::{Set, Unset, IsSet, IsUnset}; 526 526 + #[allow(unused)] 527 527 + use ::core::marker::PhantomData; 528 528 + mod sealed { 529 529 + pub trait Sealed {} 530 530 + } 531 531 + /// State trait tracking which required fields have been set 532 532 + pub trait State: sealed::Sealed { 533 533 + type Name; 534 534 + type Node; 535 535 + } 536 536 + /// Empty state - all required fields are unset 537 537 + pub struct Empty(()); 538 538 + impl sealed::Sealed for Empty {} 539 539 + impl State for Empty { 540 540 + type Name = Unset; 541 541 + type Node = Unset; 542 542 + } 543 543 + ///State transition - sets the `name` field to Set 544 544 + pub struct SetName<S: State = Empty>(PhantomData<fn() -> S>); 545 545 + impl<S: State> sealed::Sealed for SetName<S> {} 546 546 + impl<S: State> State for SetName<S> { 547 547 + type Name = Set<members::name>; 548 548 + type Node = S::Node; 549 549 + } 550 550 + ///State transition - sets the `node` field to Set 551 551 + pub struct SetNode<S: State = Empty>(PhantomData<fn() -> S>); 552 552 + impl<S: State> sealed::Sealed for SetNode<S> {} 553 553 + impl<S: State> State for SetNode<S> { 554 554 + type Name = S::Name; 555 555 + type Node = Set<members::node>; 556 556 + } 557 557 + /// Marker types for field names 558 558 + #[allow(non_camel_case_types)] 559 559 + pub mod members { 560 560 + ///Marker type for the `name` field 561 561 + pub struct name(()); 562 562 + ///Marker type for the `node` field 563 563 + pub struct node(()); 564 564 + } 565 565 + } 566 566 + 567 567 + /// Builder for constructing an instance of this type 568 568 + pub struct EntryBuilder<'a, S: entry_state::State> { 569 569 + _phantom_state: ::core::marker::PhantomData<fn() -> S>, 570 570 + __unsafe_private_named: ( 571 571 + ::core::option::Option<jacquard_common::CowStr<'a>>, 572 572 + ::core::option::Option<EntryNode<'a>>, 573 573 + ), 574 574 + _phantom: ::core::marker::PhantomData<&'a ()>, 575 575 + } 576 576 + 577 577 + impl<'a> Entry<'a> { 578 578 + /// Create a new builder for this type 579 579 + pub fn new() -> EntryBuilder<'a, entry_state::Empty> { 580 580 + EntryBuilder::new() 581 581 + } 582 582 + } 583 583 + 584 584 + impl<'a> EntryBuilder<'a, entry_state::Empty> { 585 585 + /// Create a new builder with all fields unset 586 586 + pub fn new() -> Self { 587 587 + EntryBuilder { 588 588 + _phantom_state: ::core::marker::PhantomData, 589 589 + __unsafe_private_named: (None, None), 590 590 + _phantom: ::core::marker::PhantomData, 591 591 + } 592 592 + } 593 593 + } 594 594 + 595 595 + impl<'a, S> EntryBuilder<'a, S> 596 596 + where 597 597 + S: entry_state::State, 598 598 + S::Name: entry_state::IsUnset, 599 599 + { 600 600 + /// Set the `name` field (required) 601 601 + pub fn name( 602 602 + mut self, 603 603 + value: impl Into<jacquard_common::CowStr<'a>>, 604 604 + ) -> EntryBuilder<'a, entry_state::SetName<S>> { 605 605 + self.__unsafe_private_named.0 = ::core::option::Option::Some(value.into()); 606 606 + EntryBuilder { 607 607 + _phantom_state: ::core::marker::PhantomData, 608 608 + __unsafe_private_named: self.__unsafe_private_named, 609 609 + _phantom: ::core::marker::PhantomData, 610 610 + } 611 611 + } 612 612 + } 613 613 + 614 614 + impl<'a, S> EntryBuilder<'a, S> 615 615 + where 616 616 + S: entry_state::State, 617 617 + S::Node: entry_state::IsUnset, 618 618 + { 619 619 + /// Set the `node` field (required) 620 620 + pub fn node( 621 621 + mut self, 622 622 + value: impl Into<EntryNode<'a>>, 623 623 + ) -> EntryBuilder<'a, entry_state::SetNode<S>> { 624 624 + self.__unsafe_private_named.1 = ::core::option::Option::Some(value.into()); 625 625 + EntryBuilder { 626 626 + _phantom_state: ::core::marker::PhantomData, 627 627 + __unsafe_private_named: self.__unsafe_private_named, 628 628 + _phantom: ::core::marker::PhantomData, 629 629 + } 630 630 + } 631 631 + } 632 632 + 633 633 + impl<'a, S> EntryBuilder<'a, S> 634 634 + where 635 635 + S: entry_state::State, 636 636 + S::Name: entry_state::IsSet, 637 637 + S::Node: entry_state::IsSet, 638 638 + { 639 639 + /// Build the final struct 640 640 + pub fn build(self) -> Entry<'a> { 641 641 + Entry { 642 642 + name: self.__unsafe_private_named.0.unwrap(), 643 643 + node: self.__unsafe_private_named.1.unwrap(), 644 644 + extra_data: Default::default(), 645 645 + } 646 646 + } 647 647 + /// Build the final struct with custom extra_data 648 648 + pub fn build_with_data( 649 649 + self, 650 650 + extra_data: std::collections::BTreeMap< 651 651 + jacquard_common::smol_str::SmolStr, 652 652 + jacquard_common::types::value::Data<'a>, 653 653 + >, 654 654 + ) -> Entry<'a> { 655 655 + Entry { 656 656 + name: self.__unsafe_private_named.0.unwrap(), 657 657 + node: self.__unsafe_private_named.1.unwrap(), 658 658 + extra_data: Some(extra_data), 659 659 + } 660 660 + } 661 661 + } 662 662 + 663 663 + #[jacquard_derive::open_union] 664 664 + #[derive( 665 665 + serde::Serialize, 666 666 + serde::Deserialize, 667 667 + Debug, 668 668 + Clone, 669 669 + PartialEq, 670 670 + Eq, 671 671 + jacquard_derive::IntoStatic 672 672 + )] 673 673 + #[serde(tag = "$type")] 674 674 + #[serde(bound(deserialize = "'de: 'a"))] 675 675 + pub enum EntryNode<'a> { 676 676 + #[serde(rename = "place.wisp.subfs#file")] 677 677 + File(Box<crate::place_wisp::subfs::File<'a>>), 678 678 + #[serde(rename = "place.wisp.subfs#directory")] 679 679 + Directory(Box<crate::place_wisp::subfs::Directory<'a>>), 680 680 + #[serde(rename = "place.wisp.subfs#subfs")] 681 681 + Subfs(Box<crate::place_wisp::subfs::Subfs<'a>>), 682 682 + } 683 683 + 684 684 + impl<'a> ::jacquard_lexicon::schema::LexiconSchema for Entry<'a> { 685 685 + fn nsid() -> &'static str { 686 686 + "place.wisp.subfs" 687 687 + } 688 688 + fn def_name() -> &'static str { 689 689 + "entry" 690 690 + } 691 691 + fn lexicon_doc() -> ::jacquard_lexicon::lexicon::LexiconDoc<'static> { 692 692 + lexicon_doc_place_wisp_subfs() 693 693 + } 694 694 + fn validate( 695 695 + &self, 696 696 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 697 697 + { 698 698 + let value = &self.name; 699 699 + #[allow(unused_comparisons)] 700 700 + if <str>::len(value.as_ref()) > 255usize { 701 701 + return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 702 702 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 703 703 + "name", 704 704 + ), 705 705 + max: 255usize, 706 706 + actual: <str>::len(value.as_ref()), 707 707 + }); 708 708 + } 709 709 + } 710 710 + Ok(()) 711 711 + } 712 712 + } 713 713 + 714 714 + #[jacquard_derive::lexicon] 715 715 + #[derive( 716 716 + serde::Serialize, 717 717 + serde::Deserialize, 718 718 + Debug, 719 719 + Clone, 720 720 + PartialEq, 721 721 + Eq, 722 722 + jacquard_derive::IntoStatic 723 723 + )] 724 724 + #[serde(rename_all = "camelCase")] 725 725 + pub struct File<'a> { 726 726 + /// True if blob content is base64-encoded (used to bypass PDS content sniffing) 727 727 + #[serde(skip_serializing_if = "std::option::Option::is_none")] 728 728 + pub base64: std::option::Option<bool>, 729 729 + /// Content blob ref 730 730 + #[serde(borrow)] 731 731 + pub blob: jacquard_common::types::blob::BlobRef<'a>, 732 732 + /// Content encoding (e.g., gzip for compressed files) 733 733 + #[serde(skip_serializing_if = "std::option::Option::is_none")] 734 734 + #[serde(borrow)] 735 735 + pub encoding: std::option::Option<jacquard_common::CowStr<'a>>, 736 736 + /// Original MIME type before compression 737 737 + #[serde(skip_serializing_if = "std::option::Option::is_none")] 738 738 + #[serde(borrow)] 739 739 + pub mime_type: std::option::Option<jacquard_common::CowStr<'a>>, 740 740 + #[serde(borrow)] 741 741 + pub r#type: jacquard_common::CowStr<'a>, 742 742 + } 743 743 + 744 744 + pub mod file_state { 745 745 + 746 746 + pub use crate::builder_types::{Set, Unset, IsSet, IsUnset}; 747 747 + #[allow(unused)] 748 748 + use ::core::marker::PhantomData; 749 749 + mod sealed { 750 750 + pub trait Sealed {} 751 751 + } 752 752 + /// State trait tracking which required fields have been set 753 753 + pub trait State: sealed::Sealed { 754 754 + type Blob; 755 755 + type Type; 756 756 + } 757 757 + /// Empty state - all required fields are unset 758 758 + pub struct Empty(()); 759 759 + impl sealed::Sealed for Empty {} 760 760 + impl State for Empty { 761 761 + type Blob = Unset; 762 762 + type Type = Unset; 763 763 + } 764 764 + ///State transition - sets the `blob` field to Set 765 765 + pub struct SetBlob<S: State = Empty>(PhantomData<fn() -> S>); 766 766 + impl<S: State> sealed::Sealed for SetBlob<S> {} 767 767 + impl<S: State> State for SetBlob<S> { 768 768 + type Blob = Set<members::blob>; 769 769 + type Type = S::Type; 770 770 + } 771 771 + ///State transition - sets the `type` field to Set 772 772 + pub struct SetType<S: State = Empty>(PhantomData<fn() -> S>); 773 773 + impl<S: State> sealed::Sealed for SetType<S> {} 774 774 + impl<S: State> State for SetType<S> { 775 775 + type Blob = S::Blob; 776 776 + type Type = Set<members::r#type>; 777 777 + } 778 778 + /// Marker types for field names 779 779 + #[allow(non_camel_case_types)] 780 780 + pub mod members { 781 781 + ///Marker type for the `blob` field 782 782 + pub struct blob(()); 783 783 + ///Marker type for the `type` field 784 784 + pub struct r#type(()); 785 785 + } 786 786 + } 787 787 + 788 788 + /// Builder for constructing an instance of this type 789 789 + pub struct FileBuilder<'a, S: file_state::State> { 790 790 + _phantom_state: ::core::marker::PhantomData<fn() -> S>, 791 791 + __unsafe_private_named: ( 792 792 + ::core::option::Option<bool>, 793 793 + ::core::option::Option<jacquard_common::types::blob::BlobRef<'a>>, 794 794 + ::core::option::Option<jacquard_common::CowStr<'a>>, 795 795 + ::core::option::Option<jacquard_common::CowStr<'a>>, 796 796 + ::core::option::Option<jacquard_common::CowStr<'a>>, 797 797 + ), 798 798 + _phantom: ::core::marker::PhantomData<&'a ()>, 799 799 + } 800 800 + 801 801 + impl<'a> File<'a> { 802 802 + /// Create a new builder for this type 803 803 + pub fn new() -> FileBuilder<'a, file_state::Empty> { 804 804 + FileBuilder::new() 805 805 + } 806 806 + } 807 807 + 808 808 + impl<'a> FileBuilder<'a, file_state::Empty> { 809 809 + /// Create a new builder with all fields unset 810 810 + pub fn new() -> Self { 811 811 + FileBuilder { 812 812 + _phantom_state: ::core::marker::PhantomData, 813 813 + __unsafe_private_named: (None, None, None, None, None), 814 814 + _phantom: ::core::marker::PhantomData, 815 815 + } 816 816 + } 817 817 + } 818 818 + 819 819 + impl<'a, S: file_state::State> FileBuilder<'a, S> { 820 820 + /// Set the `base64` field (optional) 821 821 + pub fn base64(mut self, value: impl Into<Option<bool>>) -> Self { 822 822 + self.__unsafe_private_named.0 = value.into(); 823 823 + self 824 824 + } 825 825 + /// Set the `base64` field to an Option value (optional) 826 826 + pub fn maybe_base64(mut self, value: Option<bool>) -> Self { 827 827 + self.__unsafe_private_named.0 = value; 828 828 + self 829 829 + } 830 830 + } 831 831 + 832 832 + impl<'a, S> FileBuilder<'a, S> 833 833 + where 834 834 + S: file_state::State, 835 835 + S::Blob: file_state::IsUnset, 836 836 + { 837 837 + /// Set the `blob` field (required) 838 838 + pub fn blob( 839 839 + mut self, 840 840 + value: impl Into<jacquard_common::types::blob::BlobRef<'a>>, 841 841 + ) -> FileBuilder<'a, file_state::SetBlob<S>> { 842 842 + self.__unsafe_private_named.1 = ::core::option::Option::Some(value.into()); 843 843 + FileBuilder { 844 844 + _phantom_state: ::core::marker::PhantomData, 845 845 + __unsafe_private_named: self.__unsafe_private_named, 846 846 + _phantom: ::core::marker::PhantomData, 847 847 + } 848 848 + } 849 849 + } 850 850 + 851 851 + impl<'a, S: file_state::State> FileBuilder<'a, S> { 852 852 + /// Set the `encoding` field (optional) 853 853 + pub fn encoding( 854 854 + mut self, 855 855 + value: impl Into<Option<jacquard_common::CowStr<'a>>>, 856 856 + ) -> Self { 857 857 + self.__unsafe_private_named.2 = value.into(); 858 858 + self 859 859 + } 860 860 + /// Set the `encoding` field to an Option value (optional) 861 861 + pub fn maybe_encoding(mut self, value: Option<jacquard_common::CowStr<'a>>) -> Self { 862 862 + self.__unsafe_private_named.2 = value; 863 863 + self 864 864 + } 865 865 + } 866 866 + 867 867 + impl<'a, S: file_state::State> FileBuilder<'a, S> { 868 868 + /// Set the `mimeType` field (optional) 869 869 + pub fn mime_type( 870 870 + mut self, 871 871 + value: impl Into<Option<jacquard_common::CowStr<'a>>>, 872 872 + ) -> Self { 873 873 + self.__unsafe_private_named.3 = value.into(); 874 874 + self 875 875 + } 876 876 + /// Set the `mimeType` field to an Option value (optional) 877 877 + pub fn maybe_mime_type( 878 878 + mut self, 879 879 + value: Option<jacquard_common::CowStr<'a>>, 880 880 + ) -> Self { 881 881 + self.__unsafe_private_named.3 = value; 882 882 + self 883 883 + } 884 884 + } 885 885 + 886 886 + impl<'a, S> FileBuilder<'a, S> 887 887 + where 888 888 + S: file_state::State, 889 889 + S::Type: file_state::IsUnset, 890 890 + { 891 891 + /// Set the `type` field (required) 892 892 + pub fn r#type( 893 893 + mut self, 894 894 + value: impl Into<jacquard_common::CowStr<'a>>, 895 895 + ) -> FileBuilder<'a, file_state::SetType<S>> { 896 896 + self.__unsafe_private_named.4 = ::core::option::Option::Some(value.into()); 897 897 + FileBuilder { 898 898 + _phantom_state: ::core::marker::PhantomData, 899 899 + __unsafe_private_named: self.__unsafe_private_named, 900 900 + _phantom: ::core::marker::PhantomData, 901 901 + } 902 902 + } 903 903 + } 904 904 + 905 905 + impl<'a, S> FileBuilder<'a, S> 906 906 + where 907 907 + S: file_state::State, 908 908 + S::Blob: file_state::IsSet, 909 909 + S::Type: file_state::IsSet, 910 910 + { 911 911 + /// Build the final struct 912 912 + pub fn build(self) -> File<'a> { 913 913 + File { 914 914 + base64: self.__unsafe_private_named.0, 915 915 + blob: self.__unsafe_private_named.1.unwrap(), 916 916 + encoding: self.__unsafe_private_named.2, 917 917 + mime_type: self.__unsafe_private_named.3, 918 918 + r#type: self.__unsafe_private_named.4.unwrap(), 919 919 + extra_data: Default::default(), 920 920 + } 921 921 + } 922 922 + /// Build the final struct with custom extra_data 923 923 + pub fn build_with_data( 924 924 + self, 925 925 + extra_data: std::collections::BTreeMap< 926 926 + jacquard_common::smol_str::SmolStr, 927 927 + jacquard_common::types::value::Data<'a>, 928 928 + >, 929 929 + ) -> File<'a> { 930 930 + File { 931 931 + base64: self.__unsafe_private_named.0, 932 932 + blob: self.__unsafe_private_named.1.unwrap(), 933 933 + encoding: self.__unsafe_private_named.2, 934 934 + mime_type: self.__unsafe_private_named.3, 935 935 + r#type: self.__unsafe_private_named.4.unwrap(), 936 936 + extra_data: Some(extra_data), 937 937 + } 938 938 + } 939 939 + } 940 940 + 941 941 + impl<'a> ::jacquard_lexicon::schema::LexiconSchema for File<'a> { 942 942 + fn nsid() -> &'static str { 943 943 + "place.wisp.subfs" 944 944 + } 945 945 + fn def_name() -> &'static str { 946 946 + "file" 947 947 + } 948 948 + fn lexicon_doc() -> ::jacquard_lexicon::lexicon::LexiconDoc<'static> { 949 949 + lexicon_doc_place_wisp_subfs() 950 950 + } 951 951 + fn validate( 952 952 + &self, 953 953 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 954 954 + Ok(()) 955 955 + } 956 956 + } 957 957 + 958 958 + /// Virtual filesystem subtree referenced by place.wisp.fs records. When a subfs entry is expanded, its root entries are merged (flattened) into the parent directory, allowing large directories to be split across multiple records while maintaining a flat structure. 959 959 + #[jacquard_derive::lexicon] 960 960 + #[derive( 961 961 + serde::Serialize, 962 962 + serde::Deserialize, 963 963 + Debug, 964 964 + Clone, 965 965 + PartialEq, 966 966 + Eq, 967 967 + jacquard_derive::IntoStatic 968 968 + )] 969 969 + #[serde(rename_all = "camelCase")] 970 970 + pub struct SubfsRecord<'a> { 971 971 + pub created_at: jacquard_common::types::string::Datetime, 972 972 + #[serde(skip_serializing_if = "std::option::Option::is_none")] 973 973 + pub file_count: std::option::Option<i64>, 974 974 + #[serde(borrow)] 975 975 + pub root: crate::place_wisp::subfs::Directory<'a>, 976 976 + } 977 977 + 978 978 + pub mod subfs_record_state { 979 979 + 980 980 + pub use crate::builder_types::{Set, Unset, IsSet, IsUnset}; 981 981 + #[allow(unused)] 982 982 + use ::core::marker::PhantomData; 983 983 + mod sealed { 984 984 + pub trait Sealed {} 985 985 + } 986 986 + /// State trait tracking which required fields have been set 987 987 + pub trait State: sealed::Sealed { 988 988 + type Root; 989 989 + type CreatedAt; 990 990 + } 991 991 + /// Empty state - all required fields are unset 992 992 + pub struct Empty(()); 993 993 + impl sealed::Sealed for Empty {} 994 994 + impl State for Empty { 995 995 + type Root = Unset; 996 996 + type CreatedAt = Unset; 997 997 + } 998 998 + ///State transition - sets the `root` field to Set 999 999 + pub struct SetRoot<S: State = Empty>(PhantomData<fn() -> S>); 1000 1000 + impl<S: State> sealed::Sealed for SetRoot<S> {} 1001 1001 + impl<S: State> State for SetRoot<S> { 1002 1002 + type Root = Set<members::root>; 1003 1003 + type CreatedAt = S::CreatedAt; 1004 1004 + } 1005 1005 + ///State transition - sets the `created_at` field to Set 1006 1006 + pub struct SetCreatedAt<S: State = Empty>(PhantomData<fn() -> S>); 1007 1007 + impl<S: State> sealed::Sealed for SetCreatedAt<S> {} 1008 1008 + impl<S: State> State for SetCreatedAt<S> { 1009 1009 + type Root = S::Root; 1010 1010 + type CreatedAt = Set<members::created_at>; 1011 1011 + } 1012 1012 + /// Marker types for field names 1013 1013 + #[allow(non_camel_case_types)] 1014 1014 + pub mod members { 1015 1015 + ///Marker type for the `root` field 1016 1016 + pub struct root(()); 1017 1017 + ///Marker type for the `created_at` field 1018 1018 + pub struct created_at(()); 1019 1019 + } 1020 1020 + } 1021 1021 + 1022 1022 + /// Builder for constructing an instance of this type 1023 1023 + pub struct SubfsRecordBuilder<'a, S: subfs_record_state::State> { 1024 1024 + _phantom_state: ::core::marker::PhantomData<fn() -> S>, 1025 1025 + __unsafe_private_named: ( 1026 1026 + ::core::option::Option<jacquard_common::types::string::Datetime>, 1027 1027 + ::core::option::Option<i64>, 1028 1028 + ::core::option::Option<crate::place_wisp::subfs::Directory<'a>>, 1029 1029 + ), 1030 1030 + _phantom: ::core::marker::PhantomData<&'a ()>, 1031 1031 + } 1032 1032 + 1033 1033 + impl<'a> SubfsRecord<'a> { 1034 1034 + /// Create a new builder for this type 1035 1035 + pub fn new() -> SubfsRecordBuilder<'a, subfs_record_state::Empty> { 1036 1036 + SubfsRecordBuilder::new() 1037 1037 + } 1038 1038 + } 1039 1039 + 1040 1040 + impl<'a> SubfsRecordBuilder<'a, subfs_record_state::Empty> { 1041 1041 + /// Create a new builder with all fields unset 1042 1042 + pub fn new() -> Self { 1043 1043 + SubfsRecordBuilder { 1044 1044 + _phantom_state: ::core::marker::PhantomData, 1045 1045 + __unsafe_private_named: (None, None, None), 1046 1046 + _phantom: ::core::marker::PhantomData, 1047 1047 + } 1048 1048 + } 1049 1049 + } 1050 1050 + 1051 1051 + impl<'a, S> SubfsRecordBuilder<'a, S> 1052 1052 + where 1053 1053 + S: subfs_record_state::State, 1054 1054 + S::CreatedAt: subfs_record_state::IsUnset, 1055 1055 + { 1056 1056 + /// Set the `createdAt` field (required) 1057 1057 + pub fn created_at( 1058 1058 + mut self, 1059 1059 + value: impl Into<jacquard_common::types::string::Datetime>, 1060 1060 + ) -> SubfsRecordBuilder<'a, subfs_record_state::SetCreatedAt<S>> { 1061 1061 + self.__unsafe_private_named.0 = ::core::option::Option::Some(value.into()); 1062 1062 + SubfsRecordBuilder { 1063 1063 + _phantom_state: ::core::marker::PhantomData, 1064 1064 + __unsafe_private_named: self.__unsafe_private_named, 1065 1065 + _phantom: ::core::marker::PhantomData, 1066 1066 + } 1067 1067 + } 1068 1068 + } 1069 1069 + 1070 1070 + impl<'a, S: subfs_record_state::State> SubfsRecordBuilder<'a, S> { 1071 1071 + /// Set the `fileCount` field (optional) 1072 1072 + pub fn file_count(mut self, value: impl Into<Option<i64>>) -> Self { 1073 1073 + self.__unsafe_private_named.1 = value.into(); 1074 1074 + self 1075 1075 + } 1076 1076 + /// Set the `fileCount` field to an Option value (optional) 1077 1077 + pub fn maybe_file_count(mut self, value: Option<i64>) -> Self { 1078 1078 + self.__unsafe_private_named.1 = value; 1079 1079 + self 1080 1080 + } 1081 1081 + } 1082 1082 + 1083 1083 + impl<'a, S> SubfsRecordBuilder<'a, S> 1084 1084 + where 1085 1085 + S: subfs_record_state::State, 1086 1086 + S::Root: subfs_record_state::IsUnset, 1087 1087 + { 1088 1088 + /// Set the `root` field (required) 1089 1089 + pub fn root( 1090 1090 + mut self, 1091 1091 + value: impl Into<crate::place_wisp::subfs::Directory<'a>>, 1092 1092 + ) -> SubfsRecordBuilder<'a, subfs_record_state::SetRoot<S>> { 1093 1093 + self.__unsafe_private_named.2 = ::core::option::Option::Some(value.into()); 1094 1094 + SubfsRecordBuilder { 1095 1095 + _phantom_state: ::core::marker::PhantomData, 1096 1096 + __unsafe_private_named: self.__unsafe_private_named, 1097 1097 + _phantom: ::core::marker::PhantomData, 1098 1098 + } 1099 1099 + } 1100 1100 + } 1101 1101 + 1102 1102 + impl<'a, S> SubfsRecordBuilder<'a, S> 1103 1103 + where 1104 1104 + S: subfs_record_state::State, 1105 1105 + S::Root: subfs_record_state::IsSet, 1106 1106 + S::CreatedAt: subfs_record_state::IsSet, 1107 1107 + { 1108 1108 + /// Build the final struct 1109 1109 + pub fn build(self) -> SubfsRecord<'a> { 1110 1110 + SubfsRecord { 1111 1111 + created_at: self.__unsafe_private_named.0.unwrap(), 1112 1112 + file_count: self.__unsafe_private_named.1, 1113 1113 + root: self.__unsafe_private_named.2.unwrap(), 1114 1114 + extra_data: Default::default(), 1115 1115 + } 1116 1116 + } 1117 1117 + /// Build the final struct with custom extra_data 1118 1118 + pub fn build_with_data( 1119 1119 + self, 1120 1120 + extra_data: std::collections::BTreeMap< 1121 1121 + jacquard_common::smol_str::SmolStr, 1122 1122 + jacquard_common::types::value::Data<'a>, 1123 1123 + >, 1124 1124 + ) -> SubfsRecord<'a> { 1125 1125 + SubfsRecord { 1126 1126 + created_at: self.__unsafe_private_named.0.unwrap(), 1127 1127 + file_count: self.__unsafe_private_named.1, 1128 1128 + root: self.__unsafe_private_named.2.unwrap(), 1129 1129 + extra_data: Some(extra_data), 1130 1130 + } 1131 1131 + } 1132 1132 + } 1133 1133 + 1134 1134 + impl<'a> SubfsRecord<'a> { 1135 1135 + pub fn uri( 1136 1136 + uri: impl Into<jacquard_common::CowStr<'a>>, 1137 1137 + ) -> Result< 1138 1138 + jacquard_common::types::uri::RecordUri<'a, SubfsRecordRecord>, 1139 1139 + jacquard_common::types::uri::UriError, 1140 1140 + > { 1141 1141 + jacquard_common::types::uri::RecordUri::try_from_uri( 1142 1142 + jacquard_common::types::string::AtUri::new_cow(uri.into())?, 1143 1143 + ) 1144 1144 + } 1145 1145 + } 1146 1146 + 1147 1147 + /// Typed wrapper for GetRecord response with this collection's record type. 1148 1148 + #[derive( 1149 1149 + serde::Serialize, 1150 1150 + serde::Deserialize, 1151 1151 + Debug, 1152 1152 + Clone, 1153 1153 + PartialEq, 1154 1154 + Eq, 1155 1155 + jacquard_derive::IntoStatic 1156 1156 + )] 1157 1157 + #[serde(rename_all = "camelCase")] 1158 1158 + pub struct SubfsRecordGetRecordOutput<'a> { 1159 1159 + #[serde(skip_serializing_if = "std::option::Option::is_none")] 1160 1160 + #[serde(borrow)] 1161 1161 + pub cid: std::option::Option<jacquard_common::types::string::Cid<'a>>, 1162 1162 + #[serde(borrow)] 1163 1163 + pub uri: jacquard_common::types::string::AtUri<'a>, 1164 1164 + #[serde(borrow)] 1165 1165 + pub value: SubfsRecord<'a>, 1166 1166 + } 1167 1167 + 1168 1168 + impl From<SubfsRecordGetRecordOutput<'_>> for SubfsRecord<'_> { 1169 1169 + fn from(output: SubfsRecordGetRecordOutput<'_>) -> Self { 1170 1170 + use jacquard_common::IntoStatic; 1171 1171 + output.value.into_static() 1172 1172 + } 1173 1173 + } 1174 1174 + 1175 1175 + impl jacquard_common::types::collection::Collection for SubfsRecord<'_> { 1176 1176 + const NSID: &'static str = "place.wisp.subfs"; 1177 1177 + type Record = SubfsRecordRecord; 1178 1178 + } 1179 1179 + 1180 1180 + /// Marker type for deserializing records from this collection. 1181 1181 + #[derive(Debug, serde::Serialize, serde::Deserialize)] 1182 1182 + pub struct SubfsRecordRecord; 1183 1183 + impl jacquard_common::xrpc::XrpcResp for SubfsRecordRecord { 1184 1184 + const NSID: &'static str = "place.wisp.subfs"; 1185 1185 + const ENCODING: &'static str = "application/json"; 1186 1186 + type Output<'de> = SubfsRecordGetRecordOutput<'de>; 1187 1187 + type Err<'de> = jacquard_common::types::collection::RecordError<'de>; 1188 1188 + } 1189 1189 + 1190 1190 + impl jacquard_common::types::collection::Collection for SubfsRecordRecord { 1191 1191 + const NSID: &'static str = "place.wisp.subfs"; 1192 1192 + type Record = SubfsRecordRecord; 1193 1193 + } 1194 1194 + 1195 1195 + impl<'a> ::jacquard_lexicon::schema::LexiconSchema for SubfsRecord<'a> { 1196 1196 + fn nsid() -> &'static str { 1197 1197 + "place.wisp.subfs" 1198 1198 + } 1199 1199 + fn def_name() -> &'static str { 1200 1200 + "main" 1201 1201 + } 1202 1202 + fn lexicon_doc() -> ::jacquard_lexicon::lexicon::LexiconDoc<'static> { 1203 1203 + lexicon_doc_place_wisp_subfs() 1204 1204 + } 1205 1205 + fn validate( 1206 1206 + &self, 1207 1207 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 1208 1208 + if let Some(ref value) = self.file_count { 1209 1209 + if *value > 1000i64 { 1210 1210 + return Err(::jacquard_lexicon::validation::ConstraintError::Maximum { 1211 1211 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 1212 1212 + "file_count", 1213 1213 + ), 1214 1214 + max: 1000i64, 1215 1215 + actual: *value, 1216 1216 + }); 1217 1217 + } 1218 1218 + } 1219 1219 + if let Some(ref value) = self.file_count { 1220 1220 + if *value < 0i64 { 1221 1221 + return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { 1222 1222 + path: ::jacquard_lexicon::validation::ValidationPath::from_field( 1223 1223 + "file_count", 1224 1224 + ), 1225 1225 + min: 0i64, 1226 1226 + actual: *value, 1227 1227 + }); 1228 1228 + } 1229 1229 + } 1230 1230 + Ok(()) 1231 1231 + } 1232 1232 + } 1233 1233 + 1234 1234 + #[jacquard_derive::lexicon] 1235 1235 + #[derive( 1236 1236 + serde::Serialize, 1237 1237 + serde::Deserialize, 1238 1238 + Debug, 1239 1239 + Clone, 1240 1240 + PartialEq, 1241 1241 + Eq, 1242 1242 + jacquard_derive::IntoStatic 1243 1243 + )] 1244 1244 + #[serde(rename_all = "camelCase")] 1245 1245 + pub struct Subfs<'a> { 1246 1246 + /// AT-URI pointing to another place.wisp.subfs record for nested subtrees. When expanded, the referenced record's root entries are merged (flattened) into the parent directory, allowing recursive splitting of large directory structures. 1247 1247 + #[serde(borrow)] 1248 1248 + pub subject: jacquard_common::types::string::AtUri<'a>, 1249 1249 + #[serde(borrow)] 1250 1250 + pub r#type: jacquard_common::CowStr<'a>, 1251 1251 + } 1252 1252 + 1253 1253 + pub mod subfs_state { 1254 1254 + 1255 1255 + pub use crate::builder_types::{Set, Unset, IsSet, IsUnset}; 1256 1256 + #[allow(unused)] 1257 1257 + use ::core::marker::PhantomData; 1258 1258 + mod sealed { 1259 1259 + pub trait Sealed {} 1260 1260 + } 1261 1261 + /// State trait tracking which required fields have been set 1262 1262 + pub trait State: sealed::Sealed { 1263 1263 + type Subject; 1264 1264 + type Type; 1265 1265 + } 1266 1266 + /// Empty state - all required fields are unset 1267 1267 + pub struct Empty(()); 1268 1268 + impl sealed::Sealed for Empty {} 1269 1269 + impl State for Empty { 1270 1270 + type Subject = Unset; 1271 1271 + type Type = Unset; 1272 1272 + } 1273 1273 + ///State transition - sets the `subject` field to Set 1274 1274 + pub struct SetSubject<S: State = Empty>(PhantomData<fn() -> S>); 1275 1275 + impl<S: State> sealed::Sealed for SetSubject<S> {} 1276 1276 + impl<S: State> State for SetSubject<S> { 1277 1277 + type Subject = Set<members::subject>; 1278 1278 + type Type = S::Type; 1279 1279 + } 1280 1280 + ///State transition - sets the `type` field to Set 1281 1281 + pub struct SetType<S: State = Empty>(PhantomData<fn() -> S>); 1282 1282 + impl<S: State> sealed::Sealed for SetType<S> {} 1283 1283 + impl<S: State> State for SetType<S> { 1284 1284 + type Subject = S::Subject; 1285 1285 + type Type = Set<members::r#type>; 1286 1286 + } 1287 1287 + /// Marker types for field names 1288 1288 + #[allow(non_camel_case_types)] 1289 1289 + pub mod members { 1290 1290 + ///Marker type for the `subject` field 1291 1291 + pub struct subject(()); 1292 1292 + ///Marker type for the `type` field 1293 1293 + pub struct r#type(()); 1294 1294 + } 1295 1295 + } 1296 1296 + 1297 1297 + /// Builder for constructing an instance of this type 1298 1298 + pub struct SubfsBuilder<'a, S: subfs_state::State> { 1299 1299 + _phantom_state: ::core::marker::PhantomData<fn() -> S>, 1300 1300 + __unsafe_private_named: ( 1301 1301 + ::core::option::Option<jacquard_common::types::string::AtUri<'a>>, 1302 1302 + ::core::option::Option<jacquard_common::CowStr<'a>>, 1303 1303 + ), 1304 1304 + _phantom: ::core::marker::PhantomData<&'a ()>, 1305 1305 + } 1306 1306 + 1307 1307 + impl<'a> Subfs<'a> { 1308 1308 + /// Create a new builder for this type 1309 1309 + pub fn new() -> SubfsBuilder<'a, subfs_state::Empty> { 1310 1310 + SubfsBuilder::new() 1311 1311 + } 1312 1312 + } 1313 1313 + 1314 1314 + impl<'a> SubfsBuilder<'a, subfs_state::Empty> { 1315 1315 + /// Create a new builder with all fields unset 1316 1316 + pub fn new() -> Self { 1317 1317 + SubfsBuilder { 1318 1318 + _phantom_state: ::core::marker::PhantomData, 1319 1319 + __unsafe_private_named: (None, None), 1320 1320 + _phantom: ::core::marker::PhantomData, 1321 1321 + } 1322 1322 + } 1323 1323 + } 1324 1324 + 1325 1325 + impl<'a, S> SubfsBuilder<'a, S> 1326 1326 + where 1327 1327 + S: subfs_state::State, 1328 1328 + S::Subject: subfs_state::IsUnset, 1329 1329 + { 1330 1330 + /// Set the `subject` field (required) 1331 1331 + pub fn subject( 1332 1332 + mut self, 1333 1333 + value: impl Into<jacquard_common::types::string::AtUri<'a>>, 1334 1334 + ) -> SubfsBuilder<'a, subfs_state::SetSubject<S>> { 1335 1335 + self.__unsafe_private_named.0 = ::core::option::Option::Some(value.into()); 1336 1336 + SubfsBuilder { 1337 1337 + _phantom_state: ::core::marker::PhantomData, 1338 1338 + __unsafe_private_named: self.__unsafe_private_named, 1339 1339 + _phantom: ::core::marker::PhantomData, 1340 1340 + } 1341 1341 + } 1342 1342 + } 1343 1343 + 1344 1344 + impl<'a, S> SubfsBuilder<'a, S> 1345 1345 + where 1346 1346 + S: subfs_state::State, 1347 1347 + S::Type: subfs_state::IsUnset, 1348 1348 + { 1349 1349 + /// Set the `type` field (required) 1350 1350 + pub fn r#type( 1351 1351 + mut self, 1352 1352 + value: impl Into<jacquard_common::CowStr<'a>>, 1353 1353 + ) -> SubfsBuilder<'a, subfs_state::SetType<S>> { 1354 1354 + self.__unsafe_private_named.1 = ::core::option::Option::Some(value.into()); 1355 1355 + SubfsBuilder { 1356 1356 + _phantom_state: ::core::marker::PhantomData, 1357 1357 + __unsafe_private_named: self.__unsafe_private_named, 1358 1358 + _phantom: ::core::marker::PhantomData, 1359 1359 + } 1360 1360 + } 1361 1361 + } 1362 1362 + 1363 1363 + impl<'a, S> SubfsBuilder<'a, S> 1364 1364 + where 1365 1365 + S: subfs_state::State, 1366 1366 + S::Subject: subfs_state::IsSet, 1367 1367 + S::Type: subfs_state::IsSet, 1368 1368 + { 1369 1369 + /// Build the final struct 1370 1370 + pub fn build(self) -> Subfs<'a> { 1371 1371 + Subfs { 1372 1372 + subject: self.__unsafe_private_named.0.unwrap(), 1373 1373 + r#type: self.__unsafe_private_named.1.unwrap(), 1374 1374 + extra_data: Default::default(), 1375 1375 + } 1376 1376 + } 1377 1377 + /// Build the final struct with custom extra_data 1378 1378 + pub fn build_with_data( 1379 1379 + self, 1380 1380 + extra_data: std::collections::BTreeMap< 1381 1381 + jacquard_common::smol_str::SmolStr, 1382 1382 + jacquard_common::types::value::Data<'a>, 1383 1383 + >, 1384 1384 + ) -> Subfs<'a> { 1385 1385 + Subfs { 1386 1386 + subject: self.__unsafe_private_named.0.unwrap(), 1387 1387 + r#type: self.__unsafe_private_named.1.unwrap(), 1388 1388 + extra_data: Some(extra_data), 1389 1389 + } 1390 1390 + } 1391 1391 + } 1392 1392 + 1393 1393 + impl<'a> ::jacquard_lexicon::schema::LexiconSchema for Subfs<'a> { 1394 1394 + fn nsid() -> &'static str { 1395 1395 + "place.wisp.subfs" 1396 1396 + } 1397 1397 + fn def_name() -> &'static str { 1398 1398 + "subfs" 1399 1399 + } 1400 1400 + fn lexicon_doc() -> ::jacquard_lexicon::lexicon::LexiconDoc<'static> { 1401 1401 + lexicon_doc_place_wisp_subfs() 1402 1402 + } 1403 1403 + fn validate( 1404 1404 + &self, 1405 1405 + ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 1406 1406 + Ok(()) 1407 1407 + } 1408 1408 + }

+8

cli/crates/lexicons/src/place_wisp.rs

··· 1 1 + // @generated by jacquard-lexicon. DO NOT EDIT. 2 2 + // 3 3 + // This file was automatically generated from Lexicon schemas. 4 4 + // Any manual changes will be overwritten on the next regeneration. 5 5 + 6 6 + pub mod fs; 7 7 + pub mod settings; 8 8 + pub mod subfs;

+16

cli/default.nix

··· 1 1 + { 2 2 + rustPlatform, 3 3 + glibc, 4 4 + }: 5 5 + rustPlatform.buildRustPackage { 6 6 + name = "wisp-cli"; 7 7 + src = ./.; 8 8 + cargoLock = { 9 9 + lockFile = ./Cargo.lock; 10 10 + outputHashes = { 11 11 + "jacquard-0.9.5" = "sha256-75bas4VAYFcZAcBspSqS4vlJe8nmFn9ncTgeoT/OvnA="; 12 12 + }; 13 13 + }; 14 14 + buildInputs = [glibc.static]; 15 15 + RUSTFLAGS = ["-C" "target-feature=+crt-static"]; 16 16 + }

+96

cli/flake.lock

··· 1 1 + { 2 2 + "nodes": { 3 3 + "flake-utils": { 4 4 + "inputs": { 5 5 + "systems": "systems" 6 6 + }, 7 7 + "locked": { 8 8 + "lastModified": 1731533236, 9 9 + "narHash": "sha256-l0KFg5HjrsfsO/JpG+r7fRrqm12kzFHyUHqHCVpMMbI=", 10 10 + "owner": "numtide", 11 11 + "repo": "flake-utils", 12 12 + "rev": "11707dc2f618dd54ca8739b309ec4fc024de578b", 13 13 + "type": "github" 14 14 + }, 15 15 + "original": { 16 16 + "owner": "numtide", 17 17 + "repo": "flake-utils", 18 18 + "type": "github" 19 19 + } 20 20 + }, 21 21 + "nixpkgs": { 22 22 + "locked": { 23 23 + "lastModified": 1767640445, 24 24 + "narHash": "sha256-UWYqmD7JFBEDBHWYcqE6s6c77pWdcU/i+bwD6XxMb8A=", 25 25 + "owner": "NixOS", 26 26 + "repo": "nixpkgs", 27 27 + "rev": "9f0c42f8bc7151b8e7e5840fb3bd454ad850d8c5", 28 28 + "type": "github" 29 29 + }, 30 30 + "original": { 31 31 + "owner": "NixOS", 32 32 + "ref": "nixos-unstable", 33 33 + "repo": "nixpkgs", 34 34 + "type": "github" 35 35 + } 36 36 + }, 37 37 + "nixpkgs_2": { 38 38 + "locked": { 39 39 + "lastModified": 1744536153, 40 40 + "narHash": "sha256-awS2zRgF4uTwrOKwwiJcByDzDOdo3Q1rPZbiHQg/N38=", 41 41 + "owner": "NixOS", 42 42 + "repo": "nixpkgs", 43 43 + "rev": "18dd725c29603f582cf1900e0d25f9f1063dbf11", 44 44 + "type": "github" 45 45 + }, 46 46 + "original": { 47 47 + "owner": "NixOS", 48 48 + "ref": "nixpkgs-unstable", 49 49 + "repo": "nixpkgs", 50 50 + "type": "github" 51 51 + } 52 52 + }, 53 53 + "root": { 54 54 + "inputs": { 55 55 + "flake-utils": "flake-utils", 56 56 + "nixpkgs": "nixpkgs", 57 57 + "rust-overlay": "rust-overlay" 58 58 + } 59 59 + }, 60 60 + "rust-overlay": { 61 61 + "inputs": { 62 62 + "nixpkgs": "nixpkgs_2" 63 63 + }, 64 64 + "locked": { 65 65 + "lastModified": 1767667566, 66 66 + "narHash": "sha256-COy+yxZGuhQRVD1r4bWVgeFt1GB+IB1k5WRpDKbLfI8=", 67 67 + "owner": "oxalica", 68 68 + "repo": "rust-overlay", 69 69 + "rev": "056ce5b125ab32ffe78c7d3e394d9da44733c95e", 70 70 + "type": "github" 71 71 + }, 72 72 + "original": { 73 73 + "owner": "oxalica", 74 74 + "repo": "rust-overlay", 75 75 + "type": "github" 76 76 + } 77 77 + }, 78 78 + "systems": { 79 79 + "locked": { 80 80 + "lastModified": 1681028828, 81 81 + "narHash": "sha256-Vy1rq5AaRuLzOxct8nz4T6wlgyUR7zLU309k9mBC768=", 82 82 + "owner": "nix-systems", 83 83 + "repo": "default", 84 84 + "rev": "da67096a3b9bf56a91d16901293e51ba5b49a27e", 85 85 + "type": "github" 86 86 + }, 87 87 + "original": { 88 88 + "owner": "nix-systems", 89 89 + "repo": "default", 90 90 + "type": "github" 91 91 + } 92 92 + } 93 93 + }, 94 94 + "root": "root", 95 95 + "version": 7 96 96 + }

+136

cli/flake.nix

··· 1 1 + { 2 2 + inputs = { 3 3 + nixpkgs.url = "github:NixOS/nixpkgs/nixos-unstable"; 4 4 + rust-overlay.url = "github:oxalica/rust-overlay"; 5 5 + flake-utils.url = "github:numtide/flake-utils"; 6 6 + }; 7 7 + 8 8 + outputs = { self, nixpkgs, rust-overlay, flake-utils }: 9 9 + flake-utils.lib.eachDefaultSystem (system: 10 10 + let 11 11 + overlays = [ (import rust-overlay) ]; 12 12 + pkgs = import nixpkgs { inherit system overlays; }; 13 13 + 14 14 + rustToolchain = pkgs.rust-bin.stable.latest.default.override { 15 15 + targets = [ 16 16 + "x86_64-unknown-linux-musl" 17 17 + "aarch64-unknown-linux-musl" 18 18 + "x86_64-apple-darwin" 19 19 + "aarch64-apple-darwin" 20 20 + ]; 21 21 + }; 22 22 + 23 23 + cargoLockConfig = { 24 24 + lockFile = ./Cargo.lock; 25 25 + outputHashes = { 26 26 + "jacquard-0.9.5" = "sha256-75bas4VAYFcZAcBspSqS4vlJe8nmFn9ncTgeoT/OvnA="; 27 27 + }; 28 28 + }; 29 29 + 30 30 + # Native build for current system 31 31 + native = pkgs.rustPlatform.buildRustPackage { 32 32 + pname = "wisp-cli"; 33 33 + version = "0.4.2"; 34 34 + src = ./.; 35 35 + cargoLock = cargoLockConfig; 36 36 + nativeBuildInputs = [ rustToolchain ]; 37 37 + }; 38 38 + 39 39 + # Cross-compilation targets (Linux from macOS needs zigbuild) 40 40 + linuxTargets = let 41 41 + zigbuildPkgs = pkgs; 42 42 + in { 43 43 + x86_64-linux = pkgs.stdenv.mkDerivation { 44 44 + pname = "wisp-cli-x86_64-linux"; 45 45 + version = "0.4.2"; 46 46 + src = ./.; 47 47 + 48 48 + nativeBuildInputs = [ 49 49 + rustToolchain 50 50 + pkgs.cargo-zigbuild 51 51 + pkgs.zig 52 52 + ]; 53 53 + 54 54 + buildPhase = '' 55 55 + export HOME=$(mktemp -d) 56 56 + cargo zigbuild --release --target x86_64-unknown-linux-musl 57 57 + ''; 58 58 + 59 59 + installPhase = '' 60 60 + mkdir -p $out/bin 61 61 + cp target/x86_64-unknown-linux-musl/release/wisp-cli $out/bin/ 62 62 + ''; 63 63 + 64 64 + # Skip Nix's cargo vendor - we use network 65 65 + dontConfigure = true; 66 66 + dontFixup = true; 67 67 + }; 68 68 + 69 69 + aarch64-linux = pkgs.stdenv.mkDerivation { 70 70 + pname = "wisp-cli-aarch64-linux"; 71 71 + version = "0.4.2"; 72 72 + src = ./.; 73 73 + 74 74 + nativeBuildInputs = [ 75 75 + rustToolchain 76 76 + pkgs.cargo-zigbuild 77 77 + pkgs.zig 78 78 + ]; 79 79 + 80 80 + buildPhase = '' 81 81 + export HOME=$(mktemp -d) 82 82 + cargo zigbuild --release --target aarch64-unknown-linux-musl 83 83 + ''; 84 84 + 85 85 + installPhase = '' 86 86 + mkdir -p $out/bin 87 87 + cp target/aarch64-unknown-linux-musl/release/wisp-cli $out/bin/ 88 88 + ''; 89 89 + 90 90 + dontConfigure = true; 91 91 + dontFixup = true; 92 92 + }; 93 93 + }; 94 94 + 95 95 + in { 96 96 + packages = { 97 97 + default = native; 98 98 + inherit native; 99 99 + 100 100 + # macOS universal binary 101 101 + macos-universal = pkgs.stdenv.mkDerivation { 102 102 + pname = "wisp-cli-macos-universal"; 103 103 + version = "0.4.2"; 104 104 + src = ./.; 105 105 + 106 106 + nativeBuildInputs = [ rustToolchain pkgs.darwin.lipo ]; 107 107 + 108 108 + buildPhase = '' 109 109 + export HOME=$(mktemp -d) 110 110 + cargo build --release --target aarch64-apple-darwin 111 111 + cargo build --release --target x86_64-apple-darwin 112 112 + ''; 113 113 + 114 114 + installPhase = '' 115 115 + mkdir -p $out/bin 116 116 + lipo -create \ 117 117 + target/aarch64-apple-darwin/release/wisp-cli \ 118 118 + target/x86_64-apple-darwin/release/wisp-cli \ 119 119 + -output $out/bin/wisp-cli 120 120 + ''; 121 121 + 122 122 + dontConfigure = true; 123 123 + dontFixup = true; 124 124 + }; 125 125 + } // (if pkgs.stdenv.isDarwin then linuxTargets else {}); 126 126 + 127 127 + devShells.default = pkgs.mkShell { 128 128 + buildInputs = [ 129 129 + rustToolchain 130 130 + pkgs.cargo-zigbuild 131 131 + pkgs.zig 132 132 + ]; 133 133 + }; 134 134 + } 135 135 + ); 136 136 + }

+1 -1

cli/src/blob_map.rs

··· 2 2 use jacquard_common::IntoStatic; 3 3 use std::collections::HashMap; 4 4 5 5 - use crate::place_wisp::fs::{Directory, EntryNode}; 5 5 + use wisp_lexicons::place_wisp::fs::{Directory, EntryNode}; 6 6 7 7 /// Extract blob information from a directory tree 8 8 /// Returns a map of file paths to their blob refs and CIDs

-43

cli/src/builder_types.rs

··· 1 1 - // @generated by jacquard-lexicon. DO NOT EDIT. 2 2 - // 3 3 - // This file was automatically generated from Lexicon schemas. 4 4 - // Any manual changes will be overwritten on the next regeneration. 5 5 - 6 6 - /// Marker type indicating a builder field has been set 7 7 - pub struct Set<T>(pub T); 8 8 - impl<T> Set<T> { 9 9 - /// Extract the inner value 10 10 - #[inline] 11 11 - pub fn into_inner(self) -> T { 12 12 - self.0 13 13 - } 14 14 - } 15 15 - 16 16 - /// Marker type indicating a builder field has not been set 17 17 - pub struct Unset; 18 18 - /// Trait indicating a builder field is set (has a value) 19 19 - #[rustversion::attr( 20 20 - since(1.78.0), 21 21 - diagnostic::on_unimplemented( 22 22 - message = "the field `{Self}` was not set, but this method requires it to be set", 23 23 - label = "the field `{Self}` was not set" 24 24 - ) 25 25 - )] 26 26 - pub trait IsSet: private::Sealed {} 27 27 - /// Trait indicating a builder field is unset (no value yet) 28 28 - #[rustversion::attr( 29 29 - since(1.78.0), 30 30 - diagnostic::on_unimplemented( 31 31 - message = "the field `{Self}` was already set, but this method requires it to be unset", 32 32 - label = "the field `{Self}` was already set" 33 33 - ) 34 34 - )] 35 35 - pub trait IsUnset: private::Sealed {} 36 36 - impl<T> IsSet for Set<T> {} 37 37 - impl IsUnset for Unset {} 38 38 - mod private { 39 39 - /// Sealed trait to prevent external implementations 40 40 - pub trait Sealed {} 41 41 - impl<T> Sealed for super::Set<T> {} 42 42 - impl Sealed for super::Unset {} 43 43 - }

-9

cli/src/lib.rs

··· 1 1 - // @generated by jacquard-lexicon. DO NOT EDIT. 2 2 - // 3 3 - // This file was automatically generated from Lexicon schemas. 4 4 - // Any manual changes will be overwritten on the next regeneration. 5 5 - 6 6 - pub mod builder_types; 7 7 - 8 8 - #[cfg(feature = "place_wisp")] 9 9 - pub mod place_wisp;

+28 -31

cli/src/main.rs

··· 1 1 - mod builder_types; 2 2 - mod place_wisp; 3 1 mod cid; 4 2 mod blob_map; 5 3 mod metadata; ··· 28 26 use futures::stream::{self, StreamExt}; 29 27 use indicatif::{ProgressBar, ProgressStyle, MultiProgress}; 30 28 31 31 - use place_wisp::fs::*; 32 32 - use place_wisp::settings::*; 29 29 + use wisp_lexicons::place_wisp::fs::*; 30 30 + use wisp_lexicons::place_wisp::settings::*; 33 31 34 32 /// Maximum number of concurrent file uploads to the PDS 35 33 const MAX_CONCURRENT_UPLOADS: usize = 2; ··· 43 41 struct Args { 44 42 #[command(subcommand)] 45 43 command: Option<Commands>, 46 46 - 44 44 + 47 45 // Deploy arguments (when no subcommand is specified) 48 46 /// Handle (e.g., alice.bsky.social), DID, or PDS URL 49 49 - #[arg(global = true, conflicts_with = "command")] 50 47 input: Option<CowStr<'static>>, 51 48 52 49 /// Path to the directory containing your static site 53 53 - #[arg(short, long, global = true, conflicts_with = "command")] 50 50 + #[arg(short, long)] 54 51 path: Option<PathBuf>, 55 52 56 53 /// Site name (defaults to directory name) 57 57 - #[arg(short, long, global = true, conflicts_with = "command")] 54 54 + #[arg(short, long)] 58 55 site: Option<String>, 59 56 60 57 /// Path to auth store file 61 61 - #[arg(long, global = true, conflicts_with = "command")] 58 58 + #[arg(long)] 62 59 store: Option<String>, 63 60 64 61 /// App Password for authentication 65 65 - #[arg(long, global = true, conflicts_with = "command")] 62 62 + #[arg(long)] 66 63 password: Option<CowStr<'static>>, 67 64 68 65 /// Enable directory listing mode for paths without index files 69 69 - #[arg(long, global = true, conflicts_with = "command")] 66 66 + #[arg(long)] 70 67 directory: bool, 71 68 72 69 /// Enable SPA mode (serve index.html for all routes) 73 73 - #[arg(long, global = true, conflicts_with = "command")] 70 70 + #[arg(long)] 74 71 spa: bool, 75 72 76 73 /// Skip confirmation prompts (automatically accept warnings) 77 77 - #[arg(short = 'y', long, global = true, conflicts_with = "command")] 74 74 + #[arg(short = 'y', long)] 78 75 yes: bool, 79 76 } 80 77 ··· 124 121 125 122 /// Output directory for the downloaded site 126 123 #[arg(short, long, default_value = ".")] 127 127 - output: PathBuf, 124 124 + path: PathBuf, 128 125 }, 129 126 /// Serve a site locally with real-time firehose updates 130 127 Serve { ··· 137 134 138 135 /// Output directory for the site files 139 136 #[arg(short, long, default_value = ".")] 140 140 - output: PathBuf, 137 137 + path: PathBuf, 141 138 142 139 /// Port to serve on 143 143 - #[arg(short, long, default_value = "8080")] 140 140 + #[arg(short = 'P', long, default_value = "8080")] 144 141 port: u16, 145 142 }, 146 143 } ··· 158 155 run_with_oauth(input, store, path, site, directory, spa, yes).await 159 156 } 160 157 } 161 161 - Some(Commands::Pull { input, site, output }) => { 162 162 - pull::pull_site(input, CowStr::from(site), output).await 158 158 + Some(Commands::Pull { input, site, path }) => { 159 159 + pull::pull_site(input, CowStr::from(site), path).await 163 160 } 164 164 - Some(Commands::Serve { input, site, output, port }) => { 165 165 - serve::serve_site(input, CowStr::from(site), output, port).await 161 161 + Some(Commands::Serve { input, site, path, port }) => { 162 162 + serve::serve_site(input, CowStr::from(site), path, port).await 166 163 } 167 164 None => { 168 165 // Legacy mode: if input is provided, assume deploy command ··· 512 509 let chunk_file_count = subfs_utils::count_files_in_directory(chunk); 513 510 let chunk_size = subfs_utils::estimate_directory_size(chunk); 514 511 515 515 - let chunk_manifest = crate::place_wisp::subfs::SubfsRecord::new() 512 512 + let chunk_manifest = wisp_lexicons::place_wisp::subfs::SubfsRecord::new() 516 513 .root(convert_fs_dir_to_subfs_dir(chunk.clone())) 517 514 .file_count(Some(chunk_file_count as i64)) 518 515 .created_at(Datetime::now()) ··· 535 532 // Each chunk reference MUST have flat: true to merge chunk contents 536 533 println!(" → Creating parent subfs with {} chunk references...", chunk_uris.len()); 537 534 use jacquard_common::CowStr; 538 538 - use crate::place_wisp::fs::{Subfs}; 535 535 + use wisp_lexicons::place_wisp::fs::{Subfs}; 539 536 540 537 // Convert to fs::Subfs (which has the 'flat' field) instead of subfs::Subfs 541 538 let parent_entries_fs: Vec<Entry> = chunk_uris.iter().enumerate().map(|(i, (uri, _))| { ··· 565 562 let parent_tid = Tid::now_0(); 566 563 let parent_rkey = parent_tid.to_string(); 567 564 568 568 - let parent_manifest = crate::place_wisp::subfs::SubfsRecord::new() 565 565 + let parent_manifest = wisp_lexicons::place_wisp::subfs::SubfsRecord::new() 569 566 .root(parent_root_subfs) 570 567 .file_count(Some(largest_dir.file_count as i64)) 571 568 .created_at(Datetime::now()) ··· 584 581 let subfs_tid = Tid::now_0(); 585 582 let subfs_rkey = subfs_tid.to_string(); 586 583 587 587 - let subfs_manifest = crate::place_wisp::subfs::SubfsRecord::new() 584 584 + let subfs_manifest = wisp_lexicons::place_wisp::subfs::SubfsRecord::new() 588 585 .root(convert_fs_dir_to_subfs_dir(largest_dir.directory.clone())) 589 586 .file_count(Some(largest_dir.file_count as i64)) 590 587 .created_at(Datetime::now()) ··· 952 949 953 950 /// Convert fs::Directory to subfs::Directory 954 951 /// They have the same structure, but different types 955 955 - fn convert_fs_dir_to_subfs_dir(fs_dir: place_wisp::fs::Directory<'static>) -> place_wisp::subfs::Directory<'static> { 956 956 - use place_wisp::subfs::{Directory as SubfsDirectory, Entry as SubfsEntry, EntryNode as SubfsEntryNode, File as SubfsFile}; 952 952 + fn convert_fs_dir_to_subfs_dir(fs_dir: wisp_lexicons::place_wisp::fs::Directory<'static>) -> wisp_lexicons::place_wisp::subfs::Directory<'static> { 953 953 + use wisp_lexicons::place_wisp::subfs::{Directory as SubfsDirectory, Entry as SubfsEntry, EntryNode as SubfsEntryNode, File as SubfsFile}; 957 954 958 955 let subfs_entries: Vec<SubfsEntry> = fs_dir.entries.into_iter().map(|entry| { 959 956 let node = match entry.node { 960 960 - place_wisp::fs::EntryNode::File(file) => { 957 957 + wisp_lexicons::place_wisp::fs::EntryNode::File(file) => { 961 958 SubfsEntryNode::File(Box::new(SubfsFile::new() 962 959 .r#type(file.r#type) 963 960 .blob(file.blob) ··· 966 963 .base64(file.base64) 967 964 .build())) 968 965 } 969 969 - place_wisp::fs::EntryNode::Directory(dir) => { 966 966 + wisp_lexicons::place_wisp::fs::EntryNode::Directory(dir) => { 970 967 SubfsEntryNode::Directory(Box::new(convert_fs_dir_to_subfs_dir(*dir))) 971 968 } 972 972 - place_wisp::fs::EntryNode::Subfs(subfs) => { 969 969 + wisp_lexicons::place_wisp::fs::EntryNode::Subfs(subfs) => { 973 970 // Nested subfs in the directory we're converting 974 971 // Note: subfs::Subfs doesn't have the 'flat' field - that's only in fs::Subfs 975 975 - SubfsEntryNode::Subfs(Box::new(place_wisp::subfs::Subfs::new() 972 972 + SubfsEntryNode::Subfs(Box::new(wisp_lexicons::place_wisp::subfs::Subfs::new() 976 973 .r#type(subfs.r#type) 977 974 .subject(subfs.subject) 978 975 .build())) 979 976 } 980 980 - place_wisp::fs::EntryNode::Unknown(unknown) => { 977 977 + wisp_lexicons::place_wisp::fs::EntryNode::Unknown(unknown) => { 981 978 SubfsEntryNode::Unknown(unknown) 982 979 } 983 980 };

-9

cli/src/mod.rs

··· 1 1 - // @generated by jacquard-lexicon. DO NOT EDIT. 2 2 - // 3 3 - // This file was automatically generated from Lexicon schemas. 4 4 - // Any manual changes will be overwritten on the next regeneration. 5 5 - 6 6 - pub mod builder_types; 7 7 - 8 8 - #[cfg(feature = "place_wisp")] 9 9 - pub mod place_wisp;

-1490

cli/src/place_wisp/fs.rs

··· 1 1 - // @generated by jacquard-lexicon. DO NOT EDIT. 2 2 - // 3 3 - // Lexicon: place.wisp.fs 4 4 - // 5 5 - // This file was automatically generated from Lexicon schemas. 6 6 - // Any manual changes will be overwritten on the next regeneration. 7 7 - 8 8 - #[jacquard_derive::lexicon] 9 9 - #[derive( 10 10 - serde::Serialize, 11 11 - serde::Deserialize, 12 12 - Debug, 13 13 - Clone, 14 14 - PartialEq, 15 15 - Eq, 16 16 - jacquard_derive::IntoStatic 17 17 - )] 18 18 - #[serde(rename_all = "camelCase")] 19 19 - pub struct Directory<'a> { 20 20 - #[serde(borrow)] 21 21 - pub entries: Vec<crate::place_wisp::fs::Entry<'a>>, 22 22 - #[serde(borrow)] 23 23 - pub r#type: jacquard_common::CowStr<'a>, 24 24 - } 25 25 - 26 26 - pub mod directory_state { 27 27 - 28 28 - pub use crate::builder_types::{Set, Unset, IsSet, IsUnset}; 29 29 - #[allow(unused)] 30 30 - use ::core::marker::PhantomData; 31 31 - mod sealed { 32 32 - pub trait Sealed {} 33 33 - } 34 34 - /// State trait tracking which required fields have been set 35 35 - pub trait State: sealed::Sealed { 36 36 - type Type; 37 37 - type Entries; 38 38 - } 39 39 - /// Empty state - all required fields are unset 40 40 - pub struct Empty(()); 41 41 - impl sealed::Sealed for Empty {} 42 42 - impl State for Empty { 43 43 - type Type = Unset; 44 44 - type Entries = Unset; 45 45 - } 46 46 - ///State transition - sets the `type` field to Set 47 47 - pub struct SetType<S: State = Empty>(PhantomData<fn() -> S>); 48 48 - impl<S: State> sealed::Sealed for SetType<S> {} 49 49 - impl<S: State> State for SetType<S> { 50 50 - type Type = Set<members::r#type>; 51 51 - type Entries = S::Entries; 52 52 - } 53 53 - ///State transition - sets the `entries` field to Set 54 54 - pub struct SetEntries<S: State = Empty>(PhantomData<fn() -> S>); 55 55 - impl<S: State> sealed::Sealed for SetEntries<S> {} 56 56 - impl<S: State> State for SetEntries<S> { 57 57 - type Type = S::Type; 58 58 - type Entries = Set<members::entries>; 59 59 - } 60 60 - /// Marker types for field names 61 61 - #[allow(non_camel_case_types)] 62 62 - pub mod members { 63 63 - ///Marker type for the `type` field 64 64 - pub struct r#type(()); 65 65 - ///Marker type for the `entries` field 66 66 - pub struct entries(()); 67 67 - } 68 68 - } 69 69 - 70 70 - /// Builder for constructing an instance of this type 71 71 - pub struct DirectoryBuilder<'a, S: directory_state::State> { 72 72 - _phantom_state: ::core::marker::PhantomData<fn() -> S>, 73 73 - __unsafe_private_named: ( 74 74 - ::core::option::Option<Vec<crate::place_wisp::fs::Entry<'a>>>, 75 75 - ::core::option::Option<jacquard_common::CowStr<'a>>, 76 76 - ), 77 77 - _phantom: ::core::marker::PhantomData<&'a ()>, 78 78 - } 79 79 - 80 80 - impl<'a> Directory<'a> { 81 81 - /// Create a new builder for this type 82 82 - pub fn new() -> DirectoryBuilder<'a, directory_state::Empty> { 83 83 - DirectoryBuilder::new() 84 84 - } 85 85 - } 86 86 - 87 87 - impl<'a> DirectoryBuilder<'a, directory_state::Empty> { 88 88 - /// Create a new builder with all fields unset 89 89 - pub fn new() -> Self { 90 90 - DirectoryBuilder { 91 91 - _phantom_state: ::core::marker::PhantomData, 92 92 - __unsafe_private_named: (None, None), 93 93 - _phantom: ::core::marker::PhantomData, 94 94 - } 95 95 - } 96 96 - } 97 97 - 98 98 - impl<'a, S> DirectoryBuilder<'a, S> 99 99 - where 100 100 - S: directory_state::State, 101 101 - S::Entries: directory_state::IsUnset, 102 102 - { 103 103 - /// Set the `entries` field (required) 104 104 - pub fn entries( 105 105 - mut self, 106 106 - value: impl Into<Vec<crate::place_wisp::fs::Entry<'a>>>, 107 107 - ) -> DirectoryBuilder<'a, directory_state::SetEntries<S>> { 108 108 - self.__unsafe_private_named.0 = ::core::option::Option::Some(value.into()); 109 109 - DirectoryBuilder { 110 110 - _phantom_state: ::core::marker::PhantomData, 111 111 - __unsafe_private_named: self.__unsafe_private_named, 112 112 - _phantom: ::core::marker::PhantomData, 113 113 - } 114 114 - } 115 115 - } 116 116 - 117 117 - impl<'a, S> DirectoryBuilder<'a, S> 118 118 - where 119 119 - S: directory_state::State, 120 120 - S::Type: directory_state::IsUnset, 121 121 - { 122 122 - /// Set the `type` field (required) 123 123 - pub fn r#type( 124 124 - mut self, 125 125 - value: impl Into<jacquard_common::CowStr<'a>>, 126 126 - ) -> DirectoryBuilder<'a, directory_state::SetType<S>> { 127 127 - self.__unsafe_private_named.1 = ::core::option::Option::Some(value.into()); 128 128 - DirectoryBuilder { 129 129 - _phantom_state: ::core::marker::PhantomData, 130 130 - __unsafe_private_named: self.__unsafe_private_named, 131 131 - _phantom: ::core::marker::PhantomData, 132 132 - } 133 133 - } 134 134 - } 135 135 - 136 136 - impl<'a, S> DirectoryBuilder<'a, S> 137 137 - where 138 138 - S: directory_state::State, 139 139 - S::Type: directory_state::IsSet, 140 140 - S::Entries: directory_state::IsSet, 141 141 - { 142 142 - /// Build the final struct 143 143 - pub fn build(self) -> Directory<'a> { 144 144 - Directory { 145 145 - entries: self.__unsafe_private_named.0.unwrap(), 146 146 - r#type: self.__unsafe_private_named.1.unwrap(), 147 147 - extra_data: Default::default(), 148 148 - } 149 149 - } 150 150 - /// Build the final struct with custom extra_data 151 151 - pub fn build_with_data( 152 152 - self, 153 153 - extra_data: std::collections::BTreeMap< 154 154 - jacquard_common::smol_str::SmolStr, 155 155 - jacquard_common::types::value::Data<'a>, 156 156 - >, 157 157 - ) -> Directory<'a> { 158 158 - Directory { 159 159 - entries: self.__unsafe_private_named.0.unwrap(), 160 160 - r#type: self.__unsafe_private_named.1.unwrap(), 161 161 - extra_data: Some(extra_data), 162 162 - } 163 163 - } 164 164 - } 165 165 - 166 166 - fn lexicon_doc_place_wisp_fs() -> ::jacquard_lexicon::lexicon::LexiconDoc<'static> { 167 167 - ::jacquard_lexicon::lexicon::LexiconDoc { 168 168 - lexicon: ::jacquard_lexicon::lexicon::Lexicon::Lexicon1, 169 169 - id: ::jacquard_common::CowStr::new_static("place.wisp.fs"), 170 170 - revision: None, 171 171 - description: None, 172 172 - defs: { 173 173 - let mut map = ::std::collections::BTreeMap::new(); 174 174 - map.insert( 175 175 - ::jacquard_common::smol_str::SmolStr::new_static("directory"), 176 176 - ::jacquard_lexicon::lexicon::LexUserType::Object(::jacquard_lexicon::lexicon::LexObject { 177 177 - description: None, 178 178 - required: Some( 179 179 - vec![ 180 180 - ::jacquard_common::smol_str::SmolStr::new_static("type"), 181 181 - ::jacquard_common::smol_str::SmolStr::new_static("entries") 182 182 - ], 183 183 - ), 184 184 - nullable: None, 185 185 - properties: { 186 186 - #[allow(unused_mut)] 187 187 - let mut map = ::std::collections::BTreeMap::new(); 188 188 - map.insert( 189 189 - ::jacquard_common::smol_str::SmolStr::new_static("entries"), 190 190 - ::jacquard_lexicon::lexicon::LexObjectProperty::Array(::jacquard_lexicon::lexicon::LexArray { 191 191 - description: None, 192 192 - items: ::jacquard_lexicon::lexicon::LexArrayItem::Ref(::jacquard_lexicon::lexicon::LexRef { 193 193 - description: None, 194 194 - r#ref: ::jacquard_common::CowStr::new_static("#entry"), 195 195 - }), 196 196 - min_length: None, 197 197 - max_length: Some(500usize), 198 198 - }), 199 199 - ); 200 200 - map.insert( 201 201 - ::jacquard_common::smol_str::SmolStr::new_static("type"), 202 202 - ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString { 203 203 - description: None, 204 204 - format: None, 205 205 - default: None, 206 206 - min_length: None, 207 207 - max_length: None, 208 208 - min_graphemes: None, 209 209 - max_graphemes: None, 210 210 - r#enum: None, 211 211 - r#const: None, 212 212 - known_values: None, 213 213 - }), 214 214 - ); 215 215 - map 216 216 - }, 217 217 - }), 218 218 - ); 219 219 - map.insert( 220 220 - ::jacquard_common::smol_str::SmolStr::new_static("entry"), 221 221 - ::jacquard_lexicon::lexicon::LexUserType::Object(::jacquard_lexicon::lexicon::LexObject { 222 222 - description: None, 223 223 - required: Some( 224 224 - vec![ 225 225 - ::jacquard_common::smol_str::SmolStr::new_static("name"), 226 226 - ::jacquard_common::smol_str::SmolStr::new_static("node") 227 227 - ], 228 228 - ), 229 229 - nullable: None, 230 230 - properties: { 231 231 - #[allow(unused_mut)] 232 232 - let mut map = ::std::collections::BTreeMap::new(); 233 233 - map.insert( 234 234 - ::jacquard_common::smol_str::SmolStr::new_static("name"), 235 235 - ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString { 236 236 - description: None, 237 237 - format: None, 238 238 - default: None, 239 239 - min_length: None, 240 240 - max_length: Some(255usize), 241 241 - min_graphemes: None, 242 242 - max_graphemes: None, 243 243 - r#enum: None, 244 244 - r#const: None, 245 245 - known_values: None, 246 246 - }), 247 247 - ); 248 248 - map.insert( 249 249 - ::jacquard_common::smol_str::SmolStr::new_static("node"), 250 250 - ::jacquard_lexicon::lexicon::LexObjectProperty::Union(::jacquard_lexicon::lexicon::LexRefUnion { 251 251 - description: None, 252 252 - refs: vec![ 253 253 - ::jacquard_common::CowStr::new_static("#file"), 254 254 - ::jacquard_common::CowStr::new_static("#directory"), 255 255 - ::jacquard_common::CowStr::new_static("#subfs") 256 256 - ], 257 257 - closed: None, 258 258 - }), 259 259 - ); 260 260 - map 261 261 - }, 262 262 - }), 263 263 - ); 264 264 - map.insert( 265 265 - ::jacquard_common::smol_str::SmolStr::new_static("file"), 266 266 - ::jacquard_lexicon::lexicon::LexUserType::Object(::jacquard_lexicon::lexicon::LexObject { 267 267 - description: None, 268 268 - required: Some( 269 269 - vec![ 270 270 - ::jacquard_common::smol_str::SmolStr::new_static("type"), 271 271 - ::jacquard_common::smol_str::SmolStr::new_static("blob") 272 272 - ], 273 273 - ), 274 274 - nullable: None, 275 275 - properties: { 276 276 - #[allow(unused_mut)] 277 277 - let mut map = ::std::collections::BTreeMap::new(); 278 278 - map.insert( 279 279 - ::jacquard_common::smol_str::SmolStr::new_static("base64"), 280 280 - ::jacquard_lexicon::lexicon::LexObjectProperty::Boolean(::jacquard_lexicon::lexicon::LexBoolean { 281 281 - description: None, 282 282 - default: None, 283 283 - r#const: None, 284 284 - }), 285 285 - ); 286 286 - map.insert( 287 287 - ::jacquard_common::smol_str::SmolStr::new_static("blob"), 288 288 - ::jacquard_lexicon::lexicon::LexObjectProperty::Blob(::jacquard_lexicon::lexicon::LexBlob { 289 289 - description: None, 290 290 - accept: None, 291 291 - max_size: None, 292 292 - }), 293 293 - ); 294 294 - map.insert( 295 295 - ::jacquard_common::smol_str::SmolStr::new_static("encoding"), 296 296 - ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString { 297 297 - description: Some( 298 298 - ::jacquard_common::CowStr::new_static( 299 299 - "Content encoding (e.g., gzip for compressed files)", 300 300 - ), 301 301 - ), 302 302 - format: None, 303 303 - default: None, 304 304 - min_length: None, 305 305 - max_length: None, 306 306 - min_graphemes: None, 307 307 - max_graphemes: None, 308 308 - r#enum: None, 309 309 - r#const: None, 310 310 - known_values: None, 311 311 - }), 312 312 - ); 313 313 - map.insert( 314 314 - ::jacquard_common::smol_str::SmolStr::new_static("mimeType"), 315 315 - ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString { 316 316 - description: Some( 317 317 - ::jacquard_common::CowStr::new_static( 318 318 - "Original MIME type before compression", 319 319 - ), 320 320 - ), 321 321 - format: None, 322 322 - default: None, 323 323 - min_length: None, 324 324 - max_length: None, 325 325 - min_graphemes: None, 326 326 - max_graphemes: None, 327 327 - r#enum: None, 328 328 - r#const: None, 329 329 - known_values: None, 330 330 - }), 331 331 - ); 332 332 - map.insert( 333 333 - ::jacquard_common::smol_str::SmolStr::new_static("type"), 334 334 - ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString { 335 335 - description: None, 336 336 - format: None, 337 337 - default: None, 338 338 - min_length: None, 339 339 - max_length: None, 340 340 - min_graphemes: None, 341 341 - max_graphemes: None, 342 342 - r#enum: None, 343 343 - r#const: None, 344 344 - known_values: None, 345 345 - }), 346 346 - ); 347 347 - map 348 348 - }, 349 349 - }), 350 350 - ); 351 351 - map.insert( 352 352 - ::jacquard_common::smol_str::SmolStr::new_static("main"), 353 353 - ::jacquard_lexicon::lexicon::LexUserType::Record(::jacquard_lexicon::lexicon::LexRecord { 354 354 - description: Some( 355 355 - ::jacquard_common::CowStr::new_static( 356 356 - "Virtual filesystem manifest for a Wisp site", 357 357 - ), 358 358 - ), 359 359 - key: None, 360 360 - record: ::jacquard_lexicon::lexicon::LexRecordRecord::Object(::jacquard_lexicon::lexicon::LexObject { 361 361 - description: None, 362 362 - required: Some( 363 363 - vec![ 364 364 - ::jacquard_common::smol_str::SmolStr::new_static("site"), 365 365 - ::jacquard_common::smol_str::SmolStr::new_static("root"), 366 366 - ::jacquard_common::smol_str::SmolStr::new_static("createdAt") 367 367 - ], 368 368 - ), 369 369 - nullable: None, 370 370 - properties: { 371 371 - #[allow(unused_mut)] 372 372 - let mut map = ::std::collections::BTreeMap::new(); 373 373 - map.insert( 374 374 - ::jacquard_common::smol_str::SmolStr::new_static( 375 375 - "createdAt", 376 376 - ), 377 377 - ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString { 378 378 - description: None, 379 379 - format: Some( 380 380 - ::jacquard_lexicon::lexicon::LexStringFormat::Datetime, 381 381 - ), 382 382 - default: None, 383 383 - min_length: None, 384 384 - max_length: None, 385 385 - min_graphemes: None, 386 386 - max_graphemes: None, 387 387 - r#enum: None, 388 388 - r#const: None, 389 389 - known_values: None, 390 390 - }), 391 391 - ); 392 392 - map.insert( 393 393 - ::jacquard_common::smol_str::SmolStr::new_static( 394 394 - "fileCount", 395 395 - ), 396 396 - ::jacquard_lexicon::lexicon::LexObjectProperty::Integer(::jacquard_lexicon::lexicon::LexInteger { 397 397 - description: None, 398 398 - default: None, 399 399 - minimum: Some(0i64), 400 400 - maximum: Some(1000i64), 401 401 - r#enum: None, 402 402 - r#const: None, 403 403 - }), 404 404 - ); 405 405 - map.insert( 406 406 - ::jacquard_common::smol_str::SmolStr::new_static("root"), 407 407 - ::jacquard_lexicon::lexicon::LexObjectProperty::Ref(::jacquard_lexicon::lexicon::LexRef { 408 408 - description: None, 409 409 - r#ref: ::jacquard_common::CowStr::new_static("#directory"), 410 410 - }), 411 411 - ); 412 412 - map.insert( 413 413 - ::jacquard_common::smol_str::SmolStr::new_static("site"), 414 414 - ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString { 415 415 - description: None, 416 416 - format: None, 417 417 - default: None, 418 418 - min_length: None, 419 419 - max_length: None, 420 420 - min_graphemes: None, 421 421 - max_graphemes: None, 422 422 - r#enum: None, 423 423 - r#const: None, 424 424 - known_values: None, 425 425 - }), 426 426 - ); 427 427 - map 428 428 - }, 429 429 - }), 430 430 - }), 431 431 - ); 432 432 - map.insert( 433 433 - ::jacquard_common::smol_str::SmolStr::new_static("subfs"), 434 434 - ::jacquard_lexicon::lexicon::LexUserType::Object(::jacquard_lexicon::lexicon::LexObject { 435 435 - description: None, 436 436 - required: Some( 437 437 - vec![ 438 438 - ::jacquard_common::smol_str::SmolStr::new_static("type"), 439 439 - ::jacquard_common::smol_str::SmolStr::new_static("subject") 440 440 - ], 441 441 - ), 442 442 - nullable: None, 443 443 - properties: { 444 444 - #[allow(unused_mut)] 445 445 - let mut map = ::std::collections::BTreeMap::new(); 446 446 - map.insert( 447 447 - ::jacquard_common::smol_str::SmolStr::new_static("flat"), 448 448 - ::jacquard_lexicon::lexicon::LexObjectProperty::Boolean(::jacquard_lexicon::lexicon::LexBoolean { 449 449 - description: None, 450 450 - default: None, 451 451 - r#const: None, 452 452 - }), 453 453 - ); 454 454 - map.insert( 455 455 - ::jacquard_common::smol_str::SmolStr::new_static("subject"), 456 456 - ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString { 457 457 - description: Some( 458 458 - ::jacquard_common::CowStr::new_static( 459 459 - "AT-URI pointing to a place.wisp.subfs record containing this subtree.", 460 460 - ), 461 461 - ), 462 462 - format: Some( 463 463 - ::jacquard_lexicon::lexicon::LexStringFormat::AtUri, 464 464 - ), 465 465 - default: None, 466 466 - min_length: None, 467 467 - max_length: None, 468 468 - min_graphemes: None, 469 469 - max_graphemes: None, 470 470 - r#enum: None, 471 471 - r#const: None, 472 472 - known_values: None, 473 473 - }), 474 474 - ); 475 475 - map.insert( 476 476 - ::jacquard_common::smol_str::SmolStr::new_static("type"), 477 477 - ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString { 478 478 - description: None, 479 479 - format: None, 480 480 - default: None, 481 481 - min_length: None, 482 482 - max_length: None, 483 483 - min_graphemes: None, 484 484 - max_graphemes: None, 485 485 - r#enum: None, 486 486 - r#const: None, 487 487 - known_values: None, 488 488 - }), 489 489 - ); 490 490 - map 491 491 - }, 492 492 - }), 493 493 - ); 494 494 - map 495 495 - }, 496 496 - } 497 497 - } 498 498 - 499 499 - impl<'a> ::jacquard_lexicon::schema::LexiconSchema for Directory<'a> { 500 500 - fn nsid() -> &'static str { 501 501 - "place.wisp.fs" 502 502 - } 503 503 - fn def_name() -> &'static str { 504 504 - "directory" 505 505 - } 506 506 - fn lexicon_doc() -> ::jacquard_lexicon::lexicon::LexiconDoc<'static> { 507 507 - lexicon_doc_place_wisp_fs() 508 508 - } 509 509 - fn validate( 510 510 - &self, 511 511 - ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 512 512 - { 513 513 - let value = &self.entries; 514 514 - #[allow(unused_comparisons)] 515 515 - if value.len() > 500usize { 516 516 - return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 517 517 - path: ::jacquard_lexicon::validation::ValidationPath::from_field( 518 518 - "entries", 519 519 - ), 520 520 - max: 500usize, 521 521 - actual: value.len(), 522 522 - }); 523 523 - } 524 524 - } 525 525 - Ok(()) 526 526 - } 527 527 - } 528 528 - 529 529 - #[jacquard_derive::lexicon] 530 530 - #[derive( 531 531 - serde::Serialize, 532 532 - serde::Deserialize, 533 533 - Debug, 534 534 - Clone, 535 535 - PartialEq, 536 536 - Eq, 537 537 - jacquard_derive::IntoStatic 538 538 - )] 539 539 - #[serde(rename_all = "camelCase")] 540 540 - pub struct Entry<'a> { 541 541 - #[serde(borrow)] 542 542 - pub name: jacquard_common::CowStr<'a>, 543 543 - #[serde(borrow)] 544 544 - pub node: EntryNode<'a>, 545 545 - } 546 546 - 547 547 - pub mod entry_state { 548 548 - 549 549 - pub use crate::builder_types::{Set, Unset, IsSet, IsUnset}; 550 550 - #[allow(unused)] 551 551 - use ::core::marker::PhantomData; 552 552 - mod sealed { 553 553 - pub trait Sealed {} 554 554 - } 555 555 - /// State trait tracking which required fields have been set 556 556 - pub trait State: sealed::Sealed { 557 557 - type Name; 558 558 - type Node; 559 559 - } 560 560 - /// Empty state - all required fields are unset 561 561 - pub struct Empty(()); 562 562 - impl sealed::Sealed for Empty {} 563 563 - impl State for Empty { 564 564 - type Name = Unset; 565 565 - type Node = Unset; 566 566 - } 567 567 - ///State transition - sets the `name` field to Set 568 568 - pub struct SetName<S: State = Empty>(PhantomData<fn() -> S>); 569 569 - impl<S: State> sealed::Sealed for SetName<S> {} 570 570 - impl<S: State> State for SetName<S> { 571 571 - type Name = Set<members::name>; 572 572 - type Node = S::Node; 573 573 - } 574 574 - ///State transition - sets the `node` field to Set 575 575 - pub struct SetNode<S: State = Empty>(PhantomData<fn() -> S>); 576 576 - impl<S: State> sealed::Sealed for SetNode<S> {} 577 577 - impl<S: State> State for SetNode<S> { 578 578 - type Name = S::Name; 579 579 - type Node = Set<members::node>; 580 580 - } 581 581 - /// Marker types for field names 582 582 - #[allow(non_camel_case_types)] 583 583 - pub mod members { 584 584 - ///Marker type for the `name` field 585 585 - pub struct name(()); 586 586 - ///Marker type for the `node` field 587 587 - pub struct node(()); 588 588 - } 589 589 - } 590 590 - 591 591 - /// Builder for constructing an instance of this type 592 592 - pub struct EntryBuilder<'a, S: entry_state::State> { 593 593 - _phantom_state: ::core::marker::PhantomData<fn() -> S>, 594 594 - __unsafe_private_named: ( 595 595 - ::core::option::Option<jacquard_common::CowStr<'a>>, 596 596 - ::core::option::Option<EntryNode<'a>>, 597 597 - ), 598 598 - _phantom: ::core::marker::PhantomData<&'a ()>, 599 599 - } 600 600 - 601 601 - impl<'a> Entry<'a> { 602 602 - /// Create a new builder for this type 603 603 - pub fn new() -> EntryBuilder<'a, entry_state::Empty> { 604 604 - EntryBuilder::new() 605 605 - } 606 606 - } 607 607 - 608 608 - impl<'a> EntryBuilder<'a, entry_state::Empty> { 609 609 - /// Create a new builder with all fields unset 610 610 - pub fn new() -> Self { 611 611 - EntryBuilder { 612 612 - _phantom_state: ::core::marker::PhantomData, 613 613 - __unsafe_private_named: (None, None), 614 614 - _phantom: ::core::marker::PhantomData, 615 615 - } 616 616 - } 617 617 - } 618 618 - 619 619 - impl<'a, S> EntryBuilder<'a, S> 620 620 - where 621 621 - S: entry_state::State, 622 622 - S::Name: entry_state::IsUnset, 623 623 - { 624 624 - /// Set the `name` field (required) 625 625 - pub fn name( 626 626 - mut self, 627 627 - value: impl Into<jacquard_common::CowStr<'a>>, 628 628 - ) -> EntryBuilder<'a, entry_state::SetName<S>> { 629 629 - self.__unsafe_private_named.0 = ::core::option::Option::Some(value.into()); 630 630 - EntryBuilder { 631 631 - _phantom_state: ::core::marker::PhantomData, 632 632 - __unsafe_private_named: self.__unsafe_private_named, 633 633 - _phantom: ::core::marker::PhantomData, 634 634 - } 635 635 - } 636 636 - } 637 637 - 638 638 - impl<'a, S> EntryBuilder<'a, S> 639 639 - where 640 640 - S: entry_state::State, 641 641 - S::Node: entry_state::IsUnset, 642 642 - { 643 643 - /// Set the `node` field (required) 644 644 - pub fn node( 645 645 - mut self, 646 646 - value: impl Into<EntryNode<'a>>, 647 647 - ) -> EntryBuilder<'a, entry_state::SetNode<S>> { 648 648 - self.__unsafe_private_named.1 = ::core::option::Option::Some(value.into()); 649 649 - EntryBuilder { 650 650 - _phantom_state: ::core::marker::PhantomData, 651 651 - __unsafe_private_named: self.__unsafe_private_named, 652 652 - _phantom: ::core::marker::PhantomData, 653 653 - } 654 654 - } 655 655 - } 656 656 - 657 657 - impl<'a, S> EntryBuilder<'a, S> 658 658 - where 659 659 - S: entry_state::State, 660 660 - S::Name: entry_state::IsSet, 661 661 - S::Node: entry_state::IsSet, 662 662 - { 663 663 - /// Build the final struct 664 664 - pub fn build(self) -> Entry<'a> { 665 665 - Entry { 666 666 - name: self.__unsafe_private_named.0.unwrap(), 667 667 - node: self.__unsafe_private_named.1.unwrap(), 668 668 - extra_data: Default::default(), 669 669 - } 670 670 - } 671 671 - /// Build the final struct with custom extra_data 672 672 - pub fn build_with_data( 673 673 - self, 674 674 - extra_data: std::collections::BTreeMap< 675 675 - jacquard_common::smol_str::SmolStr, 676 676 - jacquard_common::types::value::Data<'a>, 677 677 - >, 678 678 - ) -> Entry<'a> { 679 679 - Entry { 680 680 - name: self.__unsafe_private_named.0.unwrap(), 681 681 - node: self.__unsafe_private_named.1.unwrap(), 682 682 - extra_data: Some(extra_data), 683 683 - } 684 684 - } 685 685 - } 686 686 - 687 687 - #[jacquard_derive::open_union] 688 688 - #[derive( 689 689 - serde::Serialize, 690 690 - serde::Deserialize, 691 691 - Debug, 692 692 - Clone, 693 693 - PartialEq, 694 694 - Eq, 695 695 - jacquard_derive::IntoStatic 696 696 - )] 697 697 - #[serde(tag = "$type")] 698 698 - #[serde(bound(deserialize = "'de: 'a"))] 699 699 - pub enum EntryNode<'a> { 700 700 - #[serde(rename = "place.wisp.fs#file")] 701 701 - File(Box<crate::place_wisp::fs::File<'a>>), 702 702 - #[serde(rename = "place.wisp.fs#directory")] 703 703 - Directory(Box<crate::place_wisp::fs::Directory<'a>>), 704 704 - #[serde(rename = "place.wisp.fs#subfs")] 705 705 - Subfs(Box<crate::place_wisp::fs::Subfs<'a>>), 706 706 - } 707 707 - 708 708 - impl<'a> ::jacquard_lexicon::schema::LexiconSchema for Entry<'a> { 709 709 - fn nsid() -> &'static str { 710 710 - "place.wisp.fs" 711 711 - } 712 712 - fn def_name() -> &'static str { 713 713 - "entry" 714 714 - } 715 715 - fn lexicon_doc() -> ::jacquard_lexicon::lexicon::LexiconDoc<'static> { 716 716 - lexicon_doc_place_wisp_fs() 717 717 - } 718 718 - fn validate( 719 719 - &self, 720 720 - ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 721 721 - { 722 722 - let value = &self.name; 723 723 - #[allow(unused_comparisons)] 724 724 - if <str>::len(value.as_ref()) > 255usize { 725 725 - return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 726 726 - path: ::jacquard_lexicon::validation::ValidationPath::from_field( 727 727 - "name", 728 728 - ), 729 729 - max: 255usize, 730 730 - actual: <str>::len(value.as_ref()), 731 731 - }); 732 732 - } 733 733 - } 734 734 - Ok(()) 735 735 - } 736 736 - } 737 737 - 738 738 - #[jacquard_derive::lexicon] 739 739 - #[derive( 740 740 - serde::Serialize, 741 741 - serde::Deserialize, 742 742 - Debug, 743 743 - Clone, 744 744 - PartialEq, 745 745 - Eq, 746 746 - jacquard_derive::IntoStatic 747 747 - )] 748 748 - #[serde(rename_all = "camelCase")] 749 749 - pub struct File<'a> { 750 750 - /// True if blob content is base64-encoded (used to bypass PDS content sniffing) 751 751 - #[serde(skip_serializing_if = "std::option::Option::is_none")] 752 752 - pub base64: Option<bool>, 753 753 - /// Content blob ref 754 754 - #[serde(borrow)] 755 755 - pub blob: jacquard_common::types::blob::BlobRef<'a>, 756 756 - /// Content encoding (e.g., gzip for compressed files) 757 757 - #[serde(skip_serializing_if = "std::option::Option::is_none")] 758 758 - #[serde(borrow)] 759 759 - pub encoding: Option<jacquard_common::CowStr<'a>>, 760 760 - /// Original MIME type before compression 761 761 - #[serde(skip_serializing_if = "std::option::Option::is_none")] 762 762 - #[serde(borrow)] 763 763 - pub mime_type: Option<jacquard_common::CowStr<'a>>, 764 764 - #[serde(borrow)] 765 765 - pub r#type: jacquard_common::CowStr<'a>, 766 766 - } 767 767 - 768 768 - pub mod file_state { 769 769 - 770 770 - pub use crate::builder_types::{Set, Unset, IsSet, IsUnset}; 771 771 - #[allow(unused)] 772 772 - use ::core::marker::PhantomData; 773 773 - mod sealed { 774 774 - pub trait Sealed {} 775 775 - } 776 776 - /// State trait tracking which required fields have been set 777 777 - pub trait State: sealed::Sealed { 778 778 - type Type; 779 779 - type Blob; 780 780 - } 781 781 - /// Empty state - all required fields are unset 782 782 - pub struct Empty(()); 783 783 - impl sealed::Sealed for Empty {} 784 784 - impl State for Empty { 785 785 - type Type = Unset; 786 786 - type Blob = Unset; 787 787 - } 788 788 - ///State transition - sets the `type` field to Set 789 789 - pub struct SetType<S: State = Empty>(PhantomData<fn() -> S>); 790 790 - impl<S: State> sealed::Sealed for SetType<S> {} 791 791 - impl<S: State> State for SetType<S> { 792 792 - type Type = Set<members::r#type>; 793 793 - type Blob = S::Blob; 794 794 - } 795 795 - ///State transition - sets the `blob` field to Set 796 796 - pub struct SetBlob<S: State = Empty>(PhantomData<fn() -> S>); 797 797 - impl<S: State> sealed::Sealed for SetBlob<S> {} 798 798 - impl<S: State> State for SetBlob<S> { 799 799 - type Type = S::Type; 800 800 - type Blob = Set<members::blob>; 801 801 - } 802 802 - /// Marker types for field names 803 803 - #[allow(non_camel_case_types)] 804 804 - pub mod members { 805 805 - ///Marker type for the `type` field 806 806 - pub struct r#type(()); 807 807 - ///Marker type for the `blob` field 808 808 - pub struct blob(()); 809 809 - } 810 810 - } 811 811 - 812 812 - /// Builder for constructing an instance of this type 813 813 - pub struct FileBuilder<'a, S: file_state::State> { 814 814 - _phantom_state: ::core::marker::PhantomData<fn() -> S>, 815 815 - __unsafe_private_named: ( 816 816 - ::core::option::Option<bool>, 817 817 - ::core::option::Option<jacquard_common::types::blob::BlobRef<'a>>, 818 818 - ::core::option::Option<jacquard_common::CowStr<'a>>, 819 819 - ::core::option::Option<jacquard_common::CowStr<'a>>, 820 820 - ::core::option::Option<jacquard_common::CowStr<'a>>, 821 821 - ), 822 822 - _phantom: ::core::marker::PhantomData<&'a ()>, 823 823 - } 824 824 - 825 825 - impl<'a> File<'a> { 826 826 - /// Create a new builder for this type 827 827 - pub fn new() -> FileBuilder<'a, file_state::Empty> { 828 828 - FileBuilder::new() 829 829 - } 830 830 - } 831 831 - 832 832 - impl<'a> FileBuilder<'a, file_state::Empty> { 833 833 - /// Create a new builder with all fields unset 834 834 - pub fn new() -> Self { 835 835 - FileBuilder { 836 836 - _phantom_state: ::core::marker::PhantomData, 837 837 - __unsafe_private_named: (None, None, None, None, None), 838 838 - _phantom: ::core::marker::PhantomData, 839 839 - } 840 840 - } 841 841 - } 842 842 - 843 843 - impl<'a, S: file_state::State> FileBuilder<'a, S> { 844 844 - /// Set the `base64` field (optional) 845 845 - pub fn base64(mut self, value: impl Into<Option<bool>>) -> Self { 846 846 - self.__unsafe_private_named.0 = value.into(); 847 847 - self 848 848 - } 849 849 - /// Set the `base64` field to an Option value (optional) 850 850 - pub fn maybe_base64(mut self, value: Option<bool>) -> Self { 851 851 - self.__unsafe_private_named.0 = value; 852 852 - self 853 853 - } 854 854 - } 855 855 - 856 856 - impl<'a, S> FileBuilder<'a, S> 857 857 - where 858 858 - S: file_state::State, 859 859 - S::Blob: file_state::IsUnset, 860 860 - { 861 861 - /// Set the `blob` field (required) 862 862 - pub fn blob( 863 863 - mut self, 864 864 - value: impl Into<jacquard_common::types::blob::BlobRef<'a>>, 865 865 - ) -> FileBuilder<'a, file_state::SetBlob<S>> { 866 866 - self.__unsafe_private_named.1 = ::core::option::Option::Some(value.into()); 867 867 - FileBuilder { 868 868 - _phantom_state: ::core::marker::PhantomData, 869 869 - __unsafe_private_named: self.__unsafe_private_named, 870 870 - _phantom: ::core::marker::PhantomData, 871 871 - } 872 872 - } 873 873 - } 874 874 - 875 875 - impl<'a, S: file_state::State> FileBuilder<'a, S> { 876 876 - /// Set the `encoding` field (optional) 877 877 - pub fn encoding( 878 878 - mut self, 879 879 - value: impl Into<Option<jacquard_common::CowStr<'a>>>, 880 880 - ) -> Self { 881 881 - self.__unsafe_private_named.2 = value.into(); 882 882 - self 883 883 - } 884 884 - /// Set the `encoding` field to an Option value (optional) 885 885 - pub fn maybe_encoding(mut self, value: Option<jacquard_common::CowStr<'a>>) -> Self { 886 886 - self.__unsafe_private_named.2 = value; 887 887 - self 888 888 - } 889 889 - } 890 890 - 891 891 - impl<'a, S: file_state::State> FileBuilder<'a, S> { 892 892 - /// Set the `mimeType` field (optional) 893 893 - pub fn mime_type( 894 894 - mut self, 895 895 - value: impl Into<Option<jacquard_common::CowStr<'a>>>, 896 896 - ) -> Self { 897 897 - self.__unsafe_private_named.3 = value.into(); 898 898 - self 899 899 - } 900 900 - /// Set the `mimeType` field to an Option value (optional) 901 901 - pub fn maybe_mime_type( 902 902 - mut self, 903 903 - value: Option<jacquard_common::CowStr<'a>>, 904 904 - ) -> Self { 905 905 - self.__unsafe_private_named.3 = value; 906 906 - self 907 907 - } 908 908 - } 909 909 - 910 910 - impl<'a, S> FileBuilder<'a, S> 911 911 - where 912 912 - S: file_state::State, 913 913 - S::Type: file_state::IsUnset, 914 914 - { 915 915 - /// Set the `type` field (required) 916 916 - pub fn r#type( 917 917 - mut self, 918 918 - value: impl Into<jacquard_common::CowStr<'a>>, 919 919 - ) -> FileBuilder<'a, file_state::SetType<S>> { 920 920 - self.__unsafe_private_named.4 = ::core::option::Option::Some(value.into()); 921 921 - FileBuilder { 922 922 - _phantom_state: ::core::marker::PhantomData, 923 923 - __unsafe_private_named: self.__unsafe_private_named, 924 924 - _phantom: ::core::marker::PhantomData, 925 925 - } 926 926 - } 927 927 - } 928 928 - 929 929 - impl<'a, S> FileBuilder<'a, S> 930 930 - where 931 931 - S: file_state::State, 932 932 - S::Type: file_state::IsSet, 933 933 - S::Blob: file_state::IsSet, 934 934 - { 935 935 - /// Build the final struct 936 936 - pub fn build(self) -> File<'a> { 937 937 - File { 938 938 - base64: self.__unsafe_private_named.0, 939 939 - blob: self.__unsafe_private_named.1.unwrap(), 940 940 - encoding: self.__unsafe_private_named.2, 941 941 - mime_type: self.__unsafe_private_named.3, 942 942 - r#type: self.__unsafe_private_named.4.unwrap(), 943 943 - extra_data: Default::default(), 944 944 - } 945 945 - } 946 946 - /// Build the final struct with custom extra_data 947 947 - pub fn build_with_data( 948 948 - self, 949 949 - extra_data: std::collections::BTreeMap< 950 950 - jacquard_common::smol_str::SmolStr, 951 951 - jacquard_common::types::value::Data<'a>, 952 952 - >, 953 953 - ) -> File<'a> { 954 954 - File { 955 955 - base64: self.__unsafe_private_named.0, 956 956 - blob: self.__unsafe_private_named.1.unwrap(), 957 957 - encoding: self.__unsafe_private_named.2, 958 958 - mime_type: self.__unsafe_private_named.3, 959 959 - r#type: self.__unsafe_private_named.4.unwrap(), 960 960 - extra_data: Some(extra_data), 961 961 - } 962 962 - } 963 963 - } 964 964 - 965 965 - impl<'a> ::jacquard_lexicon::schema::LexiconSchema for File<'a> { 966 966 - fn nsid() -> &'static str { 967 967 - "place.wisp.fs" 968 968 - } 969 969 - fn def_name() -> &'static str { 970 970 - "file" 971 971 - } 972 972 - fn lexicon_doc() -> ::jacquard_lexicon::lexicon::LexiconDoc<'static> { 973 973 - lexicon_doc_place_wisp_fs() 974 974 - } 975 975 - fn validate( 976 976 - &self, 977 977 - ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 978 978 - Ok(()) 979 979 - } 980 980 - } 981 981 - 982 982 - /// Virtual filesystem manifest for a Wisp site 983 983 - #[jacquard_derive::lexicon] 984 984 - #[derive( 985 985 - serde::Serialize, 986 986 - serde::Deserialize, 987 987 - Debug, 988 988 - Clone, 989 989 - PartialEq, 990 990 - Eq, 991 991 - jacquard_derive::IntoStatic 992 992 - )] 993 993 - #[serde(rename_all = "camelCase")] 994 994 - pub struct Fs<'a> { 995 995 - pub created_at: jacquard_common::types::string::Datetime, 996 996 - #[serde(skip_serializing_if = "std::option::Option::is_none")] 997 997 - pub file_count: Option<i64>, 998 998 - #[serde(borrow)] 999 999 - pub root: crate::place_wisp::fs::Directory<'a>, 1000 1000 - #[serde(borrow)] 1001 1001 - pub site: jacquard_common::CowStr<'a>, 1002 1002 - } 1003 1003 - 1004 1004 - pub mod fs_state { 1005 1005 - 1006 1006 - pub use crate::builder_types::{Set, Unset, IsSet, IsUnset}; 1007 1007 - #[allow(unused)] 1008 1008 - use ::core::marker::PhantomData; 1009 1009 - mod sealed { 1010 1010 - pub trait Sealed {} 1011 1011 - } 1012 1012 - /// State trait tracking which required fields have been set 1013 1013 - pub trait State: sealed::Sealed { 1014 1014 - type Site; 1015 1015 - type Root; 1016 1016 - type CreatedAt; 1017 1017 - } 1018 1018 - /// Empty state - all required fields are unset 1019 1019 - pub struct Empty(()); 1020 1020 - impl sealed::Sealed for Empty {} 1021 1021 - impl State for Empty { 1022 1022 - type Site = Unset; 1023 1023 - type Root = Unset; 1024 1024 - type CreatedAt = Unset; 1025 1025 - } 1026 1026 - ///State transition - sets the `site` field to Set 1027 1027 - pub struct SetSite<S: State = Empty>(PhantomData<fn() -> S>); 1028 1028 - impl<S: State> sealed::Sealed for SetSite<S> {} 1029 1029 - impl<S: State> State for SetSite<S> { 1030 1030 - type Site = Set<members::site>; 1031 1031 - type Root = S::Root; 1032 1032 - type CreatedAt = S::CreatedAt; 1033 1033 - } 1034 1034 - ///State transition - sets the `root` field to Set 1035 1035 - pub struct SetRoot<S: State = Empty>(PhantomData<fn() -> S>); 1036 1036 - impl<S: State> sealed::Sealed for SetRoot<S> {} 1037 1037 - impl<S: State> State for SetRoot<S> { 1038 1038 - type Site = S::Site; 1039 1039 - type Root = Set<members::root>; 1040 1040 - type CreatedAt = S::CreatedAt; 1041 1041 - } 1042 1042 - ///State transition - sets the `created_at` field to Set 1043 1043 - pub struct SetCreatedAt<S: State = Empty>(PhantomData<fn() -> S>); 1044 1044 - impl<S: State> sealed::Sealed for SetCreatedAt<S> {} 1045 1045 - impl<S: State> State for SetCreatedAt<S> { 1046 1046 - type Site = S::Site; 1047 1047 - type Root = S::Root; 1048 1048 - type CreatedAt = Set<members::created_at>; 1049 1049 - } 1050 1050 - /// Marker types for field names 1051 1051 - #[allow(non_camel_case_types)] 1052 1052 - pub mod members { 1053 1053 - ///Marker type for the `site` field 1054 1054 - pub struct site(()); 1055 1055 - ///Marker type for the `root` field 1056 1056 - pub struct root(()); 1057 1057 - ///Marker type for the `created_at` field 1058 1058 - pub struct created_at(()); 1059 1059 - } 1060 1060 - } 1061 1061 - 1062 1062 - /// Builder for constructing an instance of this type 1063 1063 - pub struct FsBuilder<'a, S: fs_state::State> { 1064 1064 - _phantom_state: ::core::marker::PhantomData<fn() -> S>, 1065 1065 - __unsafe_private_named: ( 1066 1066 - ::core::option::Option<jacquard_common::types::string::Datetime>, 1067 1067 - ::core::option::Option<i64>, 1068 1068 - ::core::option::Option<crate::place_wisp::fs::Directory<'a>>, 1069 1069 - ::core::option::Option<jacquard_common::CowStr<'a>>, 1070 1070 - ), 1071 1071 - _phantom: ::core::marker::PhantomData<&'a ()>, 1072 1072 - } 1073 1073 - 1074 1074 - impl<'a> Fs<'a> { 1075 1075 - /// Create a new builder for this type 1076 1076 - pub fn new() -> FsBuilder<'a, fs_state::Empty> { 1077 1077 - FsBuilder::new() 1078 1078 - } 1079 1079 - } 1080 1080 - 1081 1081 - impl<'a> FsBuilder<'a, fs_state::Empty> { 1082 1082 - /// Create a new builder with all fields unset 1083 1083 - pub fn new() -> Self { 1084 1084 - FsBuilder { 1085 1085 - _phantom_state: ::core::marker::PhantomData, 1086 1086 - __unsafe_private_named: (None, None, None, None), 1087 1087 - _phantom: ::core::marker::PhantomData, 1088 1088 - } 1089 1089 - } 1090 1090 - } 1091 1091 - 1092 1092 - impl<'a, S> FsBuilder<'a, S> 1093 1093 - where 1094 1094 - S: fs_state::State, 1095 1095 - S::CreatedAt: fs_state::IsUnset, 1096 1096 - { 1097 1097 - /// Set the `createdAt` field (required) 1098 1098 - pub fn created_at( 1099 1099 - mut self, 1100 1100 - value: impl Into<jacquard_common::types::string::Datetime>, 1101 1101 - ) -> FsBuilder<'a, fs_state::SetCreatedAt<S>> { 1102 1102 - self.__unsafe_private_named.0 = ::core::option::Option::Some(value.into()); 1103 1103 - FsBuilder { 1104 1104 - _phantom_state: ::core::marker::PhantomData, 1105 1105 - __unsafe_private_named: self.__unsafe_private_named, 1106 1106 - _phantom: ::core::marker::PhantomData, 1107 1107 - } 1108 1108 - } 1109 1109 - } 1110 1110 - 1111 1111 - impl<'a, S: fs_state::State> FsBuilder<'a, S> { 1112 1112 - /// Set the `fileCount` field (optional) 1113 1113 - pub fn file_count(mut self, value: impl Into<Option<i64>>) -> Self { 1114 1114 - self.__unsafe_private_named.1 = value.into(); 1115 1115 - self 1116 1116 - } 1117 1117 - /// Set the `fileCount` field to an Option value (optional) 1118 1118 - pub fn maybe_file_count(mut self, value: Option<i64>) -> Self { 1119 1119 - self.__unsafe_private_named.1 = value; 1120 1120 - self 1121 1121 - } 1122 1122 - } 1123 1123 - 1124 1124 - impl<'a, S> FsBuilder<'a, S> 1125 1125 - where 1126 1126 - S: fs_state::State, 1127 1127 - S::Root: fs_state::IsUnset, 1128 1128 - { 1129 1129 - /// Set the `root` field (required) 1130 1130 - pub fn root( 1131 1131 - mut self, 1132 1132 - value: impl Into<crate::place_wisp::fs::Directory<'a>>, 1133 1133 - ) -> FsBuilder<'a, fs_state::SetRoot<S>> { 1134 1134 - self.__unsafe_private_named.2 = ::core::option::Option::Some(value.into()); 1135 1135 - FsBuilder { 1136 1136 - _phantom_state: ::core::marker::PhantomData, 1137 1137 - __unsafe_private_named: self.__unsafe_private_named, 1138 1138 - _phantom: ::core::marker::PhantomData, 1139 1139 - } 1140 1140 - } 1141 1141 - } 1142 1142 - 1143 1143 - impl<'a, S> FsBuilder<'a, S> 1144 1144 - where 1145 1145 - S: fs_state::State, 1146 1146 - S::Site: fs_state::IsUnset, 1147 1147 - { 1148 1148 - /// Set the `site` field (required) 1149 1149 - pub fn site( 1150 1150 - mut self, 1151 1151 - value: impl Into<jacquard_common::CowStr<'a>>, 1152 1152 - ) -> FsBuilder<'a, fs_state::SetSite<S>> { 1153 1153 - self.__unsafe_private_named.3 = ::core::option::Option::Some(value.into()); 1154 1154 - FsBuilder { 1155 1155 - _phantom_state: ::core::marker::PhantomData, 1156 1156 - __unsafe_private_named: self.__unsafe_private_named, 1157 1157 - _phantom: ::core::marker::PhantomData, 1158 1158 - } 1159 1159 - } 1160 1160 - } 1161 1161 - 1162 1162 - impl<'a, S> FsBuilder<'a, S> 1163 1163 - where 1164 1164 - S: fs_state::State, 1165 1165 - S::Site: fs_state::IsSet, 1166 1166 - S::Root: fs_state::IsSet, 1167 1167 - S::CreatedAt: fs_state::IsSet, 1168 1168 - { 1169 1169 - /// Build the final struct 1170 1170 - pub fn build(self) -> Fs<'a> { 1171 1171 - Fs { 1172 1172 - created_at: self.__unsafe_private_named.0.unwrap(), 1173 1173 - file_count: self.__unsafe_private_named.1, 1174 1174 - root: self.__unsafe_private_named.2.unwrap(), 1175 1175 - site: self.__unsafe_private_named.3.unwrap(), 1176 1176 - extra_data: Default::default(), 1177 1177 - } 1178 1178 - } 1179 1179 - /// Build the final struct with custom extra_data 1180 1180 - pub fn build_with_data( 1181 1181 - self, 1182 1182 - extra_data: std::collections::BTreeMap< 1183 1183 - jacquard_common::smol_str::SmolStr, 1184 1184 - jacquard_common::types::value::Data<'a>, 1185 1185 - >, 1186 1186 - ) -> Fs<'a> { 1187 1187 - Fs { 1188 1188 - created_at: self.__unsafe_private_named.0.unwrap(), 1189 1189 - file_count: self.__unsafe_private_named.1, 1190 1190 - root: self.__unsafe_private_named.2.unwrap(), 1191 1191 - site: self.__unsafe_private_named.3.unwrap(), 1192 1192 - extra_data: Some(extra_data), 1193 1193 - } 1194 1194 - } 1195 1195 - } 1196 1196 - 1197 1197 - impl<'a> Fs<'a> { 1198 1198 - pub fn uri( 1199 1199 - uri: impl Into<jacquard_common::CowStr<'a>>, 1200 1200 - ) -> Result< 1201 1201 - jacquard_common::types::uri::RecordUri<'a, FsRecord>, 1202 1202 - jacquard_common::types::uri::UriError, 1203 1203 - > { 1204 1204 - jacquard_common::types::uri::RecordUri::try_from_uri( 1205 1205 - jacquard_common::types::string::AtUri::new_cow(uri.into())?, 1206 1206 - ) 1207 1207 - } 1208 1208 - } 1209 1209 - 1210 1210 - /// Typed wrapper for GetRecord response with this collection's record type. 1211 1211 - #[derive( 1212 1212 - serde::Serialize, 1213 1213 - serde::Deserialize, 1214 1214 - Debug, 1215 1215 - Clone, 1216 1216 - PartialEq, 1217 1217 - Eq, 1218 1218 - jacquard_derive::IntoStatic 1219 1219 - )] 1220 1220 - #[serde(rename_all = "camelCase")] 1221 1221 - pub struct FsGetRecordOutput<'a> { 1222 1222 - #[serde(skip_serializing_if = "std::option::Option::is_none")] 1223 1223 - #[serde(borrow)] 1224 1224 - pub cid: std::option::Option<jacquard_common::types::string::Cid<'a>>, 1225 1225 - #[serde(borrow)] 1226 1226 - pub uri: jacquard_common::types::string::AtUri<'a>, 1227 1227 - #[serde(borrow)] 1228 1228 - pub value: Fs<'a>, 1229 1229 - } 1230 1230 - 1231 1231 - impl From<FsGetRecordOutput<'_>> for Fs<'_> { 1232 1232 - fn from(output: FsGetRecordOutput<'_>) -> Self { 1233 1233 - use jacquard_common::IntoStatic; 1234 1234 - output.value.into_static() 1235 1235 - } 1236 1236 - } 1237 1237 - 1238 1238 - impl jacquard_common::types::collection::Collection for Fs<'_> { 1239 1239 - const NSID: &'static str = "place.wisp.fs"; 1240 1240 - type Record = FsRecord; 1241 1241 - } 1242 1242 - 1243 1243 - /// Marker type for deserializing records from this collection. 1244 1244 - #[derive(Debug, serde::Serialize, serde::Deserialize)] 1245 1245 - pub struct FsRecord; 1246 1246 - impl jacquard_common::xrpc::XrpcResp for FsRecord { 1247 1247 - const NSID: &'static str = "place.wisp.fs"; 1248 1248 - const ENCODING: &'static str = "application/json"; 1249 1249 - type Output<'de> = FsGetRecordOutput<'de>; 1250 1250 - type Err<'de> = jacquard_common::types::collection::RecordError<'de>; 1251 1251 - } 1252 1252 - 1253 1253 - impl jacquard_common::types::collection::Collection for FsRecord { 1254 1254 - const NSID: &'static str = "place.wisp.fs"; 1255 1255 - type Record = FsRecord; 1256 1256 - } 1257 1257 - 1258 1258 - impl<'a> ::jacquard_lexicon::schema::LexiconSchema for Fs<'a> { 1259 1259 - fn nsid() -> &'static str { 1260 1260 - "place.wisp.fs" 1261 1261 - } 1262 1262 - fn def_name() -> &'static str { 1263 1263 - "main" 1264 1264 - } 1265 1265 - fn lexicon_doc() -> ::jacquard_lexicon::lexicon::LexiconDoc<'static> { 1266 1266 - lexicon_doc_place_wisp_fs() 1267 1267 - } 1268 1268 - fn validate( 1269 1269 - &self, 1270 1270 - ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 1271 1271 - if let Some(ref value) = self.file_count { 1272 1272 - if *value > 1000i64 { 1273 1273 - return Err(::jacquard_lexicon::validation::ConstraintError::Maximum { 1274 1274 - path: ::jacquard_lexicon::validation::ValidationPath::from_field( 1275 1275 - "file_count", 1276 1276 - ), 1277 1277 - max: 1000i64, 1278 1278 - actual: *value, 1279 1279 - }); 1280 1280 - } 1281 1281 - } 1282 1282 - if let Some(ref value) = self.file_count { 1283 1283 - if *value < 0i64 { 1284 1284 - return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { 1285 1285 - path: ::jacquard_lexicon::validation::ValidationPath::from_field( 1286 1286 - "file_count", 1287 1287 - ), 1288 1288 - min: 0i64, 1289 1289 - actual: *value, 1290 1290 - }); 1291 1291 - } 1292 1292 - } 1293 1293 - Ok(()) 1294 1294 - } 1295 1295 - } 1296 1296 - 1297 1297 - #[jacquard_derive::lexicon] 1298 1298 - #[derive( 1299 1299 - serde::Serialize, 1300 1300 - serde::Deserialize, 1301 1301 - Debug, 1302 1302 - Clone, 1303 1303 - PartialEq, 1304 1304 - Eq, 1305 1305 - jacquard_derive::IntoStatic 1306 1306 - )] 1307 1307 - #[serde(rename_all = "camelCase")] 1308 1308 - pub struct Subfs<'a> { 1309 1309 - /// If true, the subfs record's root entries are merged (flattened) into the parent directory, replacing the subfs entry. If false (default), the subfs entries are placed in a subdirectory with the subfs entry's name. Flat merging is useful for splitting large directories across multiple records while maintaining a flat structure. 1310 1310 - #[serde(skip_serializing_if = "std::option::Option::is_none")] 1311 1311 - pub flat: Option<bool>, 1312 1312 - /// AT-URI pointing to a place.wisp.subfs record containing this subtree. 1313 1313 - #[serde(borrow)] 1314 1314 - pub subject: jacquard_common::types::string::AtUri<'a>, 1315 1315 - #[serde(borrow)] 1316 1316 - pub r#type: jacquard_common::CowStr<'a>, 1317 1317 - } 1318 1318 - 1319 1319 - pub mod subfs_state { 1320 1320 - 1321 1321 - pub use crate::builder_types::{Set, Unset, IsSet, IsUnset}; 1322 1322 - #[allow(unused)] 1323 1323 - use ::core::marker::PhantomData; 1324 1324 - mod sealed { 1325 1325 - pub trait Sealed {} 1326 1326 - } 1327 1327 - /// State trait tracking which required fields have been set 1328 1328 - pub trait State: sealed::Sealed { 1329 1329 - type Type; 1330 1330 - type Subject; 1331 1331 - } 1332 1332 - /// Empty state - all required fields are unset 1333 1333 - pub struct Empty(()); 1334 1334 - impl sealed::Sealed for Empty {} 1335 1335 - impl State for Empty { 1336 1336 - type Type = Unset; 1337 1337 - type Subject = Unset; 1338 1338 - } 1339 1339 - ///State transition - sets the `type` field to Set 1340 1340 - pub struct SetType<S: State = Empty>(PhantomData<fn() -> S>); 1341 1341 - impl<S: State> sealed::Sealed for SetType<S> {} 1342 1342 - impl<S: State> State for SetType<S> { 1343 1343 - type Type = Set<members::r#type>; 1344 1344 - type Subject = S::Subject; 1345 1345 - } 1346 1346 - ///State transition - sets the `subject` field to Set 1347 1347 - pub struct SetSubject<S: State = Empty>(PhantomData<fn() -> S>); 1348 1348 - impl<S: State> sealed::Sealed for SetSubject<S> {} 1349 1349 - impl<S: State> State for SetSubject<S> { 1350 1350 - type Type = S::Type; 1351 1351 - type Subject = Set<members::subject>; 1352 1352 - } 1353 1353 - /// Marker types for field names 1354 1354 - #[allow(non_camel_case_types)] 1355 1355 - pub mod members { 1356 1356 - ///Marker type for the `type` field 1357 1357 - pub struct r#type(()); 1358 1358 - ///Marker type for the `subject` field 1359 1359 - pub struct subject(()); 1360 1360 - } 1361 1361 - } 1362 1362 - 1363 1363 - /// Builder for constructing an instance of this type 1364 1364 - pub struct SubfsBuilder<'a, S: subfs_state::State> { 1365 1365 - _phantom_state: ::core::marker::PhantomData<fn() -> S>, 1366 1366 - __unsafe_private_named: ( 1367 1367 - ::core::option::Option<bool>, 1368 1368 - ::core::option::Option<jacquard_common::types::string::AtUri<'a>>, 1369 1369 - ::core::option::Option<jacquard_common::CowStr<'a>>, 1370 1370 - ), 1371 1371 - _phantom: ::core::marker::PhantomData<&'a ()>, 1372 1372 - } 1373 1373 - 1374 1374 - impl<'a> Subfs<'a> { 1375 1375 - /// Create a new builder for this type 1376 1376 - pub fn new() -> SubfsBuilder<'a, subfs_state::Empty> { 1377 1377 - SubfsBuilder::new() 1378 1378 - } 1379 1379 - } 1380 1380 - 1381 1381 - impl<'a> SubfsBuilder<'a, subfs_state::Empty> { 1382 1382 - /// Create a new builder with all fields unset 1383 1383 - pub fn new() -> Self { 1384 1384 - SubfsBuilder { 1385 1385 - _phantom_state: ::core::marker::PhantomData, 1386 1386 - __unsafe_private_named: (None, None, None), 1387 1387 - _phantom: ::core::marker::PhantomData, 1388 1388 - } 1389 1389 - } 1390 1390 - } 1391 1391 - 1392 1392 - impl<'a, S: subfs_state::State> SubfsBuilder<'a, S> { 1393 1393 - /// Set the `flat` field (optional) 1394 1394 - pub fn flat(mut self, value: impl Into<Option<bool>>) -> Self { 1395 1395 - self.__unsafe_private_named.0 = value.into(); 1396 1396 - self 1397 1397 - } 1398 1398 - /// Set the `flat` field to an Option value (optional) 1399 1399 - pub fn maybe_flat(mut self, value: Option<bool>) -> Self { 1400 1400 - self.__unsafe_private_named.0 = value; 1401 1401 - self 1402 1402 - } 1403 1403 - } 1404 1404 - 1405 1405 - impl<'a, S> SubfsBuilder<'a, S> 1406 1406 - where 1407 1407 - S: subfs_state::State, 1408 1408 - S::Subject: subfs_state::IsUnset, 1409 1409 - { 1410 1410 - /// Set the `subject` field (required) 1411 1411 - pub fn subject( 1412 1412 - mut self, 1413 1413 - value: impl Into<jacquard_common::types::string::AtUri<'a>>, 1414 1414 - ) -> SubfsBuilder<'a, subfs_state::SetSubject<S>> { 1415 1415 - self.__unsafe_private_named.1 = ::core::option::Option::Some(value.into()); 1416 1416 - SubfsBuilder { 1417 1417 - _phantom_state: ::core::marker::PhantomData, 1418 1418 - __unsafe_private_named: self.__unsafe_private_named, 1419 1419 - _phantom: ::core::marker::PhantomData, 1420 1420 - } 1421 1421 - } 1422 1422 - } 1423 1423 - 1424 1424 - impl<'a, S> SubfsBuilder<'a, S> 1425 1425 - where 1426 1426 - S: subfs_state::State, 1427 1427 - S::Type: subfs_state::IsUnset, 1428 1428 - { 1429 1429 - /// Set the `type` field (required) 1430 1430 - pub fn r#type( 1431 1431 - mut self, 1432 1432 - value: impl Into<jacquard_common::CowStr<'a>>, 1433 1433 - ) -> SubfsBuilder<'a, subfs_state::SetType<S>> { 1434 1434 - self.__unsafe_private_named.2 = ::core::option::Option::Some(value.into()); 1435 1435 - SubfsBuilder { 1436 1436 - _phantom_state: ::core::marker::PhantomData, 1437 1437 - __unsafe_private_named: self.__unsafe_private_named, 1438 1438 - _phantom: ::core::marker::PhantomData, 1439 1439 - } 1440 1440 - } 1441 1441 - } 1442 1442 - 1443 1443 - impl<'a, S> SubfsBuilder<'a, S> 1444 1444 - where 1445 1445 - S: subfs_state::State, 1446 1446 - S::Type: subfs_state::IsSet, 1447 1447 - S::Subject: subfs_state::IsSet, 1448 1448 - { 1449 1449 - /// Build the final struct 1450 1450 - pub fn build(self) -> Subfs<'a> { 1451 1451 - Subfs { 1452 1452 - flat: self.__unsafe_private_named.0, 1453 1453 - subject: self.__unsafe_private_named.1.unwrap(), 1454 1454 - r#type: self.__unsafe_private_named.2.unwrap(), 1455 1455 - extra_data: Default::default(), 1456 1456 - } 1457 1457 - } 1458 1458 - /// Build the final struct with custom extra_data 1459 1459 - pub fn build_with_data( 1460 1460 - self, 1461 1461 - extra_data: std::collections::BTreeMap< 1462 1462 - jacquard_common::smol_str::SmolStr, 1463 1463 - jacquard_common::types::value::Data<'a>, 1464 1464 - >, 1465 1465 - ) -> Subfs<'a> { 1466 1466 - Subfs { 1467 1467 - flat: self.__unsafe_private_named.0, 1468 1468 - subject: self.__unsafe_private_named.1.unwrap(), 1469 1469 - r#type: self.__unsafe_private_named.2.unwrap(), 1470 1470 - extra_data: Some(extra_data), 1471 1471 - } 1472 1472 - } 1473 1473 - } 1474 1474 - 1475 1475 - impl<'a> ::jacquard_lexicon::schema::LexiconSchema for Subfs<'a> { 1476 1476 - fn nsid() -> &'static str { 1477 1477 - "place.wisp.fs" 1478 1478 - } 1479 1479 - fn def_name() -> &'static str { 1480 1480 - "subfs" 1481 1481 - } 1482 1482 - fn lexicon_doc() -> ::jacquard_lexicon::lexicon::LexiconDoc<'static> { 1483 1483 - lexicon_doc_place_wisp_fs() 1484 1484 - } 1485 1485 - fn validate( 1486 1486 - &self, 1487 1487 - ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 1488 1488 - Ok(()) 1489 1489 - } 1490 1490 - }

-653

cli/src/place_wisp/settings.rs

··· 1 1 - // @generated by jacquard-lexicon. DO NOT EDIT. 2 2 - // 3 3 - // Lexicon: place.wisp.settings 4 4 - // 5 5 - // This file was automatically generated from Lexicon schemas. 6 6 - // Any manual changes will be overwritten on the next regeneration. 7 7 - 8 8 - /// Custom HTTP header configuration 9 9 - #[jacquard_derive::lexicon] 10 10 - #[derive( 11 11 - serde::Serialize, 12 12 - serde::Deserialize, 13 13 - Debug, 14 14 - Clone, 15 15 - PartialEq, 16 16 - Eq, 17 17 - jacquard_derive::IntoStatic, 18 18 - Default 19 19 - )] 20 20 - #[serde(rename_all = "camelCase")] 21 21 - pub struct CustomHeader<'a> { 22 22 - /// HTTP header name (e.g., 'Cache-Control', 'X-Frame-Options') 23 23 - #[serde(borrow)] 24 24 - pub name: jacquard_common::CowStr<'a>, 25 25 - /// Optional glob pattern to apply this header to specific paths (e.g., '*.html', '/assets/*'). If not specified, applies to all paths. 26 26 - #[serde(skip_serializing_if = "std::option::Option::is_none")] 27 27 - #[serde(borrow)] 28 28 - pub path: std::option::Option<jacquard_common::CowStr<'a>>, 29 29 - /// HTTP header value 30 30 - #[serde(borrow)] 31 31 - pub value: jacquard_common::CowStr<'a>, 32 32 - } 33 33 - 34 34 - fn lexicon_doc_place_wisp_settings() -> ::jacquard_lexicon::lexicon::LexiconDoc< 35 35 - 'static, 36 36 - > { 37 37 - ::jacquard_lexicon::lexicon::LexiconDoc { 38 38 - lexicon: ::jacquard_lexicon::lexicon::Lexicon::Lexicon1, 39 39 - id: ::jacquard_common::CowStr::new_static("place.wisp.settings"), 40 40 - revision: None, 41 41 - description: None, 42 42 - defs: { 43 43 - let mut map = ::std::collections::BTreeMap::new(); 44 44 - map.insert( 45 45 - ::jacquard_common::smol_str::SmolStr::new_static("customHeader"), 46 46 - ::jacquard_lexicon::lexicon::LexUserType::Object(::jacquard_lexicon::lexicon::LexObject { 47 47 - description: Some( 48 48 - ::jacquard_common::CowStr::new_static( 49 49 - "Custom HTTP header configuration", 50 50 - ), 51 51 - ), 52 52 - required: Some( 53 53 - vec![ 54 54 - ::jacquard_common::smol_str::SmolStr::new_static("name"), 55 55 - ::jacquard_common::smol_str::SmolStr::new_static("value") 56 56 - ], 57 57 - ), 58 58 - nullable: None, 59 59 - properties: { 60 60 - #[allow(unused_mut)] 61 61 - let mut map = ::std::collections::BTreeMap::new(); 62 62 - map.insert( 63 63 - ::jacquard_common::smol_str::SmolStr::new_static("name"), 64 64 - ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString { 65 65 - description: Some( 66 66 - ::jacquard_common::CowStr::new_static( 67 67 - "HTTP header name (e.g., 'Cache-Control', 'X-Frame-Options')", 68 68 - ), 69 69 - ), 70 70 - format: None, 71 71 - default: None, 72 72 - min_length: None, 73 73 - max_length: Some(100usize), 74 74 - min_graphemes: None, 75 75 - max_graphemes: None, 76 76 - r#enum: None, 77 77 - r#const: None, 78 78 - known_values: None, 79 79 - }), 80 80 - ); 81 81 - map.insert( 82 82 - ::jacquard_common::smol_str::SmolStr::new_static("path"), 83 83 - ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString { 84 84 - description: Some( 85 85 - ::jacquard_common::CowStr::new_static( 86 86 - "Optional glob pattern to apply this header to specific paths (e.g., '*.html', '/assets/*'). If not specified, applies to all paths.", 87 87 - ), 88 88 - ), 89 89 - format: None, 90 90 - default: None, 91 91 - min_length: None, 92 92 - max_length: Some(500usize), 93 93 - min_graphemes: None, 94 94 - max_graphemes: None, 95 95 - r#enum: None, 96 96 - r#const: None, 97 97 - known_values: None, 98 98 - }), 99 99 - ); 100 100 - map.insert( 101 101 - ::jacquard_common::smol_str::SmolStr::new_static("value"), 102 102 - ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString { 103 103 - description: Some( 104 104 - ::jacquard_common::CowStr::new_static("HTTP header value"), 105 105 - ), 106 106 - format: None, 107 107 - default: None, 108 108 - min_length: None, 109 109 - max_length: Some(1000usize), 110 110 - min_graphemes: None, 111 111 - max_graphemes: None, 112 112 - r#enum: None, 113 113 - r#const: None, 114 114 - known_values: None, 115 115 - }), 116 116 - ); 117 117 - map 118 118 - }, 119 119 - }), 120 120 - ); 121 121 - map.insert( 122 122 - ::jacquard_common::smol_str::SmolStr::new_static("main"), 123 123 - ::jacquard_lexicon::lexicon::LexUserType::Record(::jacquard_lexicon::lexicon::LexRecord { 124 124 - description: Some( 125 125 - ::jacquard_common::CowStr::new_static( 126 126 - "Configuration settings for a static site hosted on wisp.place", 127 127 - ), 128 128 - ), 129 129 - key: Some(::jacquard_common::CowStr::new_static("any")), 130 130 - record: ::jacquard_lexicon::lexicon::LexRecordRecord::Object(::jacquard_lexicon::lexicon::LexObject { 131 131 - description: None, 132 132 - required: None, 133 133 - nullable: None, 134 134 - properties: { 135 135 - #[allow(unused_mut)] 136 136 - let mut map = ::std::collections::BTreeMap::new(); 137 137 - map.insert( 138 138 - ::jacquard_common::smol_str::SmolStr::new_static( 139 139 - "cleanUrls", 140 140 - ), 141 141 - ::jacquard_lexicon::lexicon::LexObjectProperty::Boolean(::jacquard_lexicon::lexicon::LexBoolean { 142 142 - description: None, 143 143 - default: None, 144 144 - r#const: None, 145 145 - }), 146 146 - ); 147 147 - map.insert( 148 148 - ::jacquard_common::smol_str::SmolStr::new_static( 149 149 - "custom404", 150 150 - ), 151 151 - ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString { 152 152 - description: Some( 153 153 - ::jacquard_common::CowStr::new_static( 154 154 - "Custom 404 error page file path. Incompatible with directoryListing and spaMode.", 155 155 - ), 156 156 - ), 157 157 - format: None, 158 158 - default: None, 159 159 - min_length: None, 160 160 - max_length: Some(500usize), 161 161 - min_graphemes: None, 162 162 - max_graphemes: None, 163 163 - r#enum: None, 164 164 - r#const: None, 165 165 - known_values: None, 166 166 - }), 167 167 - ); 168 168 - map.insert( 169 169 - ::jacquard_common::smol_str::SmolStr::new_static( 170 170 - "directoryListing", 171 171 - ), 172 172 - ::jacquard_lexicon::lexicon::LexObjectProperty::Boolean(::jacquard_lexicon::lexicon::LexBoolean { 173 173 - description: None, 174 174 - default: None, 175 175 - r#const: None, 176 176 - }), 177 177 - ); 178 178 - map.insert( 179 179 - ::jacquard_common::smol_str::SmolStr::new_static("headers"), 180 180 - ::jacquard_lexicon::lexicon::LexObjectProperty::Array(::jacquard_lexicon::lexicon::LexArray { 181 181 - description: Some( 182 182 - ::jacquard_common::CowStr::new_static( 183 183 - "Custom HTTP headers to set on responses", 184 184 - ), 185 185 - ), 186 186 - items: ::jacquard_lexicon::lexicon::LexArrayItem::Ref(::jacquard_lexicon::lexicon::LexRef { 187 187 - description: None, 188 188 - r#ref: ::jacquard_common::CowStr::new_static( 189 189 - "#customHeader", 190 190 - ), 191 191 - }), 192 192 - min_length: None, 193 193 - max_length: Some(50usize), 194 194 - }), 195 195 - ); 196 196 - map.insert( 197 197 - ::jacquard_common::smol_str::SmolStr::new_static( 198 198 - "indexFiles", 199 199 - ), 200 200 - ::jacquard_lexicon::lexicon::LexObjectProperty::Array(::jacquard_lexicon::lexicon::LexArray { 201 201 - description: Some( 202 202 - ::jacquard_common::CowStr::new_static( 203 203 - "Ordered list of files to try when serving a directory. Defaults to ['index.html'] if not specified.", 204 204 - ), 205 205 - ), 206 206 - items: ::jacquard_lexicon::lexicon::LexArrayItem::String(::jacquard_lexicon::lexicon::LexString { 207 207 - description: None, 208 208 - format: None, 209 209 - default: None, 210 210 - min_length: None, 211 211 - max_length: Some(255usize), 212 212 - min_graphemes: None, 213 213 - max_graphemes: None, 214 214 - r#enum: None, 215 215 - r#const: None, 216 216 - known_values: None, 217 217 - }), 218 218 - min_length: None, 219 219 - max_length: Some(10usize), 220 220 - }), 221 221 - ); 222 222 - map.insert( 223 223 - ::jacquard_common::smol_str::SmolStr::new_static("spaMode"), 224 224 - ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString { 225 225 - description: Some( 226 226 - ::jacquard_common::CowStr::new_static( 227 227 - "File to serve for all routes (e.g., 'index.html'). When set, enables SPA mode where all non-file requests are routed to this file. Incompatible with directoryListing and custom404.", 228 228 - ), 229 229 - ), 230 230 - format: None, 231 231 - default: None, 232 232 - min_length: None, 233 233 - max_length: Some(500usize), 234 234 - min_graphemes: None, 235 235 - max_graphemes: None, 236 236 - r#enum: None, 237 237 - r#const: None, 238 238 - known_values: None, 239 239 - }), 240 240 - ); 241 241 - map 242 242 - }, 243 243 - }), 244 244 - }), 245 245 - ); 246 246 - map 247 247 - }, 248 248 - } 249 249 - } 250 250 - 251 251 - impl<'a> ::jacquard_lexicon::schema::LexiconSchema for CustomHeader<'a> { 252 252 - fn nsid() -> &'static str { 253 253 - "place.wisp.settings" 254 254 - } 255 255 - fn def_name() -> &'static str { 256 256 - "customHeader" 257 257 - } 258 258 - fn lexicon_doc() -> ::jacquard_lexicon::lexicon::LexiconDoc<'static> { 259 259 - lexicon_doc_place_wisp_settings() 260 260 - } 261 261 - fn validate( 262 262 - &self, 263 263 - ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 264 264 - { 265 265 - let value = &self.name; 266 266 - #[allow(unused_comparisons)] 267 267 - if <str>::len(value.as_ref()) > 100usize { 268 268 - return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 269 269 - path: ::jacquard_lexicon::validation::ValidationPath::from_field( 270 270 - "name", 271 271 - ), 272 272 - max: 100usize, 273 273 - actual: <str>::len(value.as_ref()), 274 274 - }); 275 275 - } 276 276 - } 277 277 - if let Some(ref value) = self.path { 278 278 - #[allow(unused_comparisons)] 279 279 - if <str>::len(value.as_ref()) > 500usize { 280 280 - return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 281 281 - path: ::jacquard_lexicon::validation::ValidationPath::from_field( 282 282 - "path", 283 283 - ), 284 284 - max: 500usize, 285 285 - actual: <str>::len(value.as_ref()), 286 286 - }); 287 287 - } 288 288 - } 289 289 - { 290 290 - let value = &self.value; 291 291 - #[allow(unused_comparisons)] 292 292 - if <str>::len(value.as_ref()) > 1000usize { 293 293 - return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 294 294 - path: ::jacquard_lexicon::validation::ValidationPath::from_field( 295 295 - "value", 296 296 - ), 297 297 - max: 1000usize, 298 298 - actual: <str>::len(value.as_ref()), 299 299 - }); 300 300 - } 301 301 - } 302 302 - Ok(()) 303 303 - } 304 304 - } 305 305 - 306 306 - /// Configuration settings for a static site hosted on wisp.place 307 307 - #[jacquard_derive::lexicon] 308 308 - #[derive( 309 309 - serde::Serialize, 310 310 - serde::Deserialize, 311 311 - Debug, 312 312 - Clone, 313 313 - PartialEq, 314 314 - Eq, 315 315 - jacquard_derive::IntoStatic 316 316 - )] 317 317 - #[serde(rename_all = "camelCase")] 318 318 - pub struct Settings<'a> { 319 319 - /// Enable clean URL routing. When enabled, '/about' will attempt to serve '/about.html' or '/about/index.html' automatically. 320 320 - #[serde(skip_serializing_if = "std::option::Option::is_none")] 321 321 - pub clean_urls: std::option::Option<bool>, 322 322 - /// Custom 404 error page file path. Incompatible with directoryListing and spaMode. 323 323 - #[serde(skip_serializing_if = "std::option::Option::is_none")] 324 324 - #[serde(borrow)] 325 325 - pub custom404: std::option::Option<jacquard_common::CowStr<'a>>, 326 326 - /// Enable directory listing mode for paths that resolve to directories without an index file. Incompatible with spaMode. 327 327 - #[serde(skip_serializing_if = "std::option::Option::is_none")] 328 328 - pub directory_listing: std::option::Option<bool>, 329 329 - /// Custom HTTP headers to set on responses 330 330 - #[serde(skip_serializing_if = "std::option::Option::is_none")] 331 331 - #[serde(borrow)] 332 332 - pub headers: std::option::Option<Vec<crate::place_wisp::settings::CustomHeader<'a>>>, 333 333 - /// Ordered list of files to try when serving a directory. Defaults to ['index.html'] if not specified. 334 334 - #[serde(skip_serializing_if = "std::option::Option::is_none")] 335 335 - #[serde(borrow)] 336 336 - pub index_files: std::option::Option<Vec<jacquard_common::CowStr<'a>>>, 337 337 - /// File to serve for all routes (e.g., 'index.html'). When set, enables SPA mode where all non-file requests are routed to this file. Incompatible with directoryListing and custom404. 338 338 - #[serde(skip_serializing_if = "std::option::Option::is_none")] 339 339 - #[serde(borrow)] 340 340 - pub spa_mode: std::option::Option<jacquard_common::CowStr<'a>>, 341 341 - } 342 342 - 343 343 - pub mod settings_state { 344 344 - 345 345 - pub use crate::builder_types::{Set, Unset, IsSet, IsUnset}; 346 346 - #[allow(unused)] 347 347 - use ::core::marker::PhantomData; 348 348 - mod sealed { 349 349 - pub trait Sealed {} 350 350 - } 351 351 - /// State trait tracking which required fields have been set 352 352 - pub trait State: sealed::Sealed {} 353 353 - /// Empty state - all required fields are unset 354 354 - pub struct Empty(()); 355 355 - impl sealed::Sealed for Empty {} 356 356 - impl State for Empty {} 357 357 - /// Marker types for field names 358 358 - #[allow(non_camel_case_types)] 359 359 - pub mod members {} 360 360 - } 361 361 - 362 362 - /// Builder for constructing an instance of this type 363 363 - pub struct SettingsBuilder<'a, S: settings_state::State> { 364 364 - _phantom_state: ::core::marker::PhantomData<fn() -> S>, 365 365 - __unsafe_private_named: ( 366 366 - ::core::option::Option<bool>, 367 367 - ::core::option::Option<jacquard_common::CowStr<'a>>, 368 368 - ::core::option::Option<bool>, 369 369 - ::core::option::Option<Vec<crate::place_wisp::settings::CustomHeader<'a>>>, 370 370 - ::core::option::Option<Vec<jacquard_common::CowStr<'a>>>, 371 371 - ::core::option::Option<jacquard_common::CowStr<'a>>, 372 372 - ), 373 373 - _phantom: ::core::marker::PhantomData<&'a ()>, 374 374 - } 375 375 - 376 376 - impl<'a> Settings<'a> { 377 377 - /// Create a new builder for this type 378 378 - pub fn new() -> SettingsBuilder<'a, settings_state::Empty> { 379 379 - SettingsBuilder::new() 380 380 - } 381 381 - } 382 382 - 383 383 - impl<'a> SettingsBuilder<'a, settings_state::Empty> { 384 384 - /// Create a new builder with all fields unset 385 385 - pub fn new() -> Self { 386 386 - SettingsBuilder { 387 387 - _phantom_state: ::core::marker::PhantomData, 388 388 - __unsafe_private_named: (None, None, None, None, None, None), 389 389 - _phantom: ::core::marker::PhantomData, 390 390 - } 391 391 - } 392 392 - } 393 393 - 394 394 - impl<'a, S: settings_state::State> SettingsBuilder<'a, S> { 395 395 - /// Set the `cleanUrls` field (optional) 396 396 - pub fn clean_urls(mut self, value: impl Into<Option<bool>>) -> Self { 397 397 - self.__unsafe_private_named.0 = value.into(); 398 398 - self 399 399 - } 400 400 - /// Set the `cleanUrls` field to an Option value (optional) 401 401 - pub fn maybe_clean_urls(mut self, value: Option<bool>) -> Self { 402 402 - self.__unsafe_private_named.0 = value; 403 403 - self 404 404 - } 405 405 - } 406 406 - 407 407 - impl<'a, S: settings_state::State> SettingsBuilder<'a, S> { 408 408 - /// Set the `custom404` field (optional) 409 409 - pub fn custom404( 410 410 - mut self, 411 411 - value: impl Into<Option<jacquard_common::CowStr<'a>>>, 412 412 - ) -> Self { 413 413 - self.__unsafe_private_named.1 = value.into(); 414 414 - self 415 415 - } 416 416 - /// Set the `custom404` field to an Option value (optional) 417 417 - pub fn maybe_custom404( 418 418 - mut self, 419 419 - value: Option<jacquard_common::CowStr<'a>>, 420 420 - ) -> Self { 421 421 - self.__unsafe_private_named.1 = value; 422 422 - self 423 423 - } 424 424 - } 425 425 - 426 426 - impl<'a, S: settings_state::State> SettingsBuilder<'a, S> { 427 427 - /// Set the `directoryListing` field (optional) 428 428 - pub fn directory_listing(mut self, value: impl Into<Option<bool>>) -> Self { 429 429 - self.__unsafe_private_named.2 = value.into(); 430 430 - self 431 431 - } 432 432 - /// Set the `directoryListing` field to an Option value (optional) 433 433 - pub fn maybe_directory_listing(mut self, value: Option<bool>) -> Self { 434 434 - self.__unsafe_private_named.2 = value; 435 435 - self 436 436 - } 437 437 - } 438 438 - 439 439 - impl<'a, S: settings_state::State> SettingsBuilder<'a, S> { 440 440 - /// Set the `headers` field (optional) 441 441 - pub fn headers( 442 442 - mut self, 443 443 - value: impl Into<Option<Vec<crate::place_wisp::settings::CustomHeader<'a>>>>, 444 444 - ) -> Self { 445 445 - self.__unsafe_private_named.3 = value.into(); 446 446 - self 447 447 - } 448 448 - /// Set the `headers` field to an Option value (optional) 449 449 - pub fn maybe_headers( 450 450 - mut self, 451 451 - value: Option<Vec<crate::place_wisp::settings::CustomHeader<'a>>>, 452 452 - ) -> Self { 453 453 - self.__unsafe_private_named.3 = value; 454 454 - self 455 455 - } 456 456 - } 457 457 - 458 458 - impl<'a, S: settings_state::State> SettingsBuilder<'a, S> { 459 459 - /// Set the `indexFiles` field (optional) 460 460 - pub fn index_files( 461 461 - mut self, 462 462 - value: impl Into<Option<Vec<jacquard_common::CowStr<'a>>>>, 463 463 - ) -> Self { 464 464 - self.__unsafe_private_named.4 = value.into(); 465 465 - self 466 466 - } 467 467 - /// Set the `indexFiles` field to an Option value (optional) 468 468 - pub fn maybe_index_files( 469 469 - mut self, 470 470 - value: Option<Vec<jacquard_common::CowStr<'a>>>, 471 471 - ) -> Self { 472 472 - self.__unsafe_private_named.4 = value; 473 473 - self 474 474 - } 475 475 - } 476 476 - 477 477 - impl<'a, S: settings_state::State> SettingsBuilder<'a, S> { 478 478 - /// Set the `spaMode` field (optional) 479 479 - pub fn spa_mode( 480 480 - mut self, 481 481 - value: impl Into<Option<jacquard_common::CowStr<'a>>>, 482 482 - ) -> Self { 483 483 - self.__unsafe_private_named.5 = value.into(); 484 484 - self 485 485 - } 486 486 - /// Set the `spaMode` field to an Option value (optional) 487 487 - pub fn maybe_spa_mode(mut self, value: Option<jacquard_common::CowStr<'a>>) -> Self { 488 488 - self.__unsafe_private_named.5 = value; 489 489 - self 490 490 - } 491 491 - } 492 492 - 493 493 - impl<'a, S> SettingsBuilder<'a, S> 494 494 - where 495 495 - S: settings_state::State, 496 496 - { 497 497 - /// Build the final struct 498 498 - pub fn build(self) -> Settings<'a> { 499 499 - Settings { 500 500 - clean_urls: self.__unsafe_private_named.0, 501 501 - custom404: self.__unsafe_private_named.1, 502 502 - directory_listing: self.__unsafe_private_named.2, 503 503 - headers: self.__unsafe_private_named.3, 504 504 - index_files: self.__unsafe_private_named.4, 505 505 - spa_mode: self.__unsafe_private_named.5, 506 506 - extra_data: Default::default(), 507 507 - } 508 508 - } 509 509 - /// Build the final struct with custom extra_data 510 510 - pub fn build_with_data( 511 511 - self, 512 512 - extra_data: std::collections::BTreeMap< 513 513 - jacquard_common::smol_str::SmolStr, 514 514 - jacquard_common::types::value::Data<'a>, 515 515 - >, 516 516 - ) -> Settings<'a> { 517 517 - Settings { 518 518 - clean_urls: self.__unsafe_private_named.0, 519 519 - custom404: self.__unsafe_private_named.1, 520 520 - directory_listing: self.__unsafe_private_named.2, 521 521 - headers: self.__unsafe_private_named.3, 522 522 - index_files: self.__unsafe_private_named.4, 523 523 - spa_mode: self.__unsafe_private_named.5, 524 524 - extra_data: Some(extra_data), 525 525 - } 526 526 - } 527 527 - } 528 528 - 529 529 - impl<'a> Settings<'a> { 530 530 - pub fn uri( 531 531 - uri: impl Into<jacquard_common::CowStr<'a>>, 532 532 - ) -> Result< 533 533 - jacquard_common::types::uri::RecordUri<'a, SettingsRecord>, 534 534 - jacquard_common::types::uri::UriError, 535 535 - > { 536 536 - jacquard_common::types::uri::RecordUri::try_from_uri( 537 537 - jacquard_common::types::string::AtUri::new_cow(uri.into())?, 538 538 - ) 539 539 - } 540 540 - } 541 541 - 542 542 - /// Typed wrapper for GetRecord response with this collection's record type. 543 543 - #[derive( 544 544 - serde::Serialize, 545 545 - serde::Deserialize, 546 546 - Debug, 547 547 - Clone, 548 548 - PartialEq, 549 549 - Eq, 550 550 - jacquard_derive::IntoStatic 551 551 - )] 552 552 - #[serde(rename_all = "camelCase")] 553 553 - pub struct SettingsGetRecordOutput<'a> { 554 554 - #[serde(skip_serializing_if = "std::option::Option::is_none")] 555 555 - #[serde(borrow)] 556 556 - pub cid: std::option::Option<jacquard_common::types::string::Cid<'a>>, 557 557 - #[serde(borrow)] 558 558 - pub uri: jacquard_common::types::string::AtUri<'a>, 559 559 - #[serde(borrow)] 560 560 - pub value: Settings<'a>, 561 561 - } 562 562 - 563 563 - impl From<SettingsGetRecordOutput<'_>> for Settings<'_> { 564 564 - fn from(output: SettingsGetRecordOutput<'_>) -> Self { 565 565 - use jacquard_common::IntoStatic; 566 566 - output.value.into_static() 567 567 - } 568 568 - } 569 569 - 570 570 - impl jacquard_common::types::collection::Collection for Settings<'_> { 571 571 - const NSID: &'static str = "place.wisp.settings"; 572 572 - type Record = SettingsRecord; 573 573 - } 574 574 - 575 575 - /// Marker type for deserializing records from this collection. 576 576 - #[derive(Debug, serde::Serialize, serde::Deserialize)] 577 577 - pub struct SettingsRecord; 578 578 - impl jacquard_common::xrpc::XrpcResp for SettingsRecord { 579 579 - const NSID: &'static str = "place.wisp.settings"; 580 580 - const ENCODING: &'static str = "application/json"; 581 581 - type Output<'de> = SettingsGetRecordOutput<'de>; 582 582 - type Err<'de> = jacquard_common::types::collection::RecordError<'de>; 583 583 - } 584 584 - 585 585 - impl jacquard_common::types::collection::Collection for SettingsRecord { 586 586 - const NSID: &'static str = "place.wisp.settings"; 587 587 - type Record = SettingsRecord; 588 588 - } 589 589 - 590 590 - impl<'a> ::jacquard_lexicon::schema::LexiconSchema for Settings<'a> { 591 591 - fn nsid() -> &'static str { 592 592 - "place.wisp.settings" 593 593 - } 594 594 - fn def_name() -> &'static str { 595 595 - "main" 596 596 - } 597 597 - fn lexicon_doc() -> ::jacquard_lexicon::lexicon::LexiconDoc<'static> { 598 598 - lexicon_doc_place_wisp_settings() 599 599 - } 600 600 - fn validate( 601 601 - &self, 602 602 - ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 603 603 - if let Some(ref value) = self.custom404 { 604 604 - #[allow(unused_comparisons)] 605 605 - if <str>::len(value.as_ref()) > 500usize { 606 606 - return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 607 607 - path: ::jacquard_lexicon::validation::ValidationPath::from_field( 608 608 - "custom404", 609 609 - ), 610 610 - max: 500usize, 611 611 - actual: <str>::len(value.as_ref()), 612 612 - }); 613 613 - } 614 614 - } 615 615 - if let Some(ref value) = self.headers { 616 616 - #[allow(unused_comparisons)] 617 617 - if value.len() > 50usize { 618 618 - return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 619 619 - path: ::jacquard_lexicon::validation::ValidationPath::from_field( 620 620 - "headers", 621 621 - ), 622 622 - max: 50usize, 623 623 - actual: value.len(), 624 624 - }); 625 625 - } 626 626 - } 627 627 - if let Some(ref value) = self.index_files { 628 628 - #[allow(unused_comparisons)] 629 629 - if value.len() > 10usize { 630 630 - return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 631 631 - path: ::jacquard_lexicon::validation::ValidationPath::from_field( 632 632 - "index_files", 633 633 - ), 634 634 - max: 10usize, 635 635 - actual: value.len(), 636 636 - }); 637 637 - } 638 638 - } 639 639 - if let Some(ref value) = self.spa_mode { 640 640 - #[allow(unused_comparisons)] 641 641 - if <str>::len(value.as_ref()) > 500usize { 642 642 - return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 643 643 - path: ::jacquard_lexicon::validation::ValidationPath::from_field( 644 644 - "spa_mode", 645 645 - ), 646 646 - max: 500usize, 647 647 - actual: <str>::len(value.as_ref()), 648 648 - }); 649 649 - } 650 650 - } 651 651 - Ok(()) 652 652 - } 653 653 - }

-1408

cli/src/place_wisp/subfs.rs

··· 1 1 - // @generated by jacquard-lexicon. DO NOT EDIT. 2 2 - // 3 3 - // Lexicon: place.wisp.subfs 4 4 - // 5 5 - // This file was automatically generated from Lexicon schemas. 6 6 - // Any manual changes will be overwritten on the next regeneration. 7 7 - 8 8 - #[jacquard_derive::lexicon] 9 9 - #[derive( 10 10 - serde::Serialize, 11 11 - serde::Deserialize, 12 12 - Debug, 13 13 - Clone, 14 14 - PartialEq, 15 15 - Eq, 16 16 - jacquard_derive::IntoStatic 17 17 - )] 18 18 - #[serde(rename_all = "camelCase")] 19 19 - pub struct Directory<'a> { 20 20 - #[serde(borrow)] 21 21 - pub entries: Vec<crate::place_wisp::subfs::Entry<'a>>, 22 22 - #[serde(borrow)] 23 23 - pub r#type: jacquard_common::CowStr<'a>, 24 24 - } 25 25 - 26 26 - pub mod directory_state { 27 27 - 28 28 - pub use crate::builder_types::{Set, Unset, IsSet, IsUnset}; 29 29 - #[allow(unused)] 30 30 - use ::core::marker::PhantomData; 31 31 - mod sealed { 32 32 - pub trait Sealed {} 33 33 - } 34 34 - /// State trait tracking which required fields have been set 35 35 - pub trait State: sealed::Sealed { 36 36 - type Type; 37 37 - type Entries; 38 38 - } 39 39 - /// Empty state - all required fields are unset 40 40 - pub struct Empty(()); 41 41 - impl sealed::Sealed for Empty {} 42 42 - impl State for Empty { 43 43 - type Type = Unset; 44 44 - type Entries = Unset; 45 45 - } 46 46 - ///State transition - sets the `type` field to Set 47 47 - pub struct SetType<S: State = Empty>(PhantomData<fn() -> S>); 48 48 - impl<S: State> sealed::Sealed for SetType<S> {} 49 49 - impl<S: State> State for SetType<S> { 50 50 - type Type = Set<members::r#type>; 51 51 - type Entries = S::Entries; 52 52 - } 53 53 - ///State transition - sets the `entries` field to Set 54 54 - pub struct SetEntries<S: State = Empty>(PhantomData<fn() -> S>); 55 55 - impl<S: State> sealed::Sealed for SetEntries<S> {} 56 56 - impl<S: State> State for SetEntries<S> { 57 57 - type Type = S::Type; 58 58 - type Entries = Set<members::entries>; 59 59 - } 60 60 - /// Marker types for field names 61 61 - #[allow(non_camel_case_types)] 62 62 - pub mod members { 63 63 - ///Marker type for the `type` field 64 64 - pub struct r#type(()); 65 65 - ///Marker type for the `entries` field 66 66 - pub struct entries(()); 67 67 - } 68 68 - } 69 69 - 70 70 - /// Builder for constructing an instance of this type 71 71 - pub struct DirectoryBuilder<'a, S: directory_state::State> { 72 72 - _phantom_state: ::core::marker::PhantomData<fn() -> S>, 73 73 - __unsafe_private_named: ( 74 74 - ::core::option::Option<Vec<crate::place_wisp::subfs::Entry<'a>>>, 75 75 - ::core::option::Option<jacquard_common::CowStr<'a>>, 76 76 - ), 77 77 - _phantom: ::core::marker::PhantomData<&'a ()>, 78 78 - } 79 79 - 80 80 - impl<'a> Directory<'a> { 81 81 - /// Create a new builder for this type 82 82 - pub fn new() -> DirectoryBuilder<'a, directory_state::Empty> { 83 83 - DirectoryBuilder::new() 84 84 - } 85 85 - } 86 86 - 87 87 - impl<'a> DirectoryBuilder<'a, directory_state::Empty> { 88 88 - /// Create a new builder with all fields unset 89 89 - pub fn new() -> Self { 90 90 - DirectoryBuilder { 91 91 - _phantom_state: ::core::marker::PhantomData, 92 92 - __unsafe_private_named: (None, None), 93 93 - _phantom: ::core::marker::PhantomData, 94 94 - } 95 95 - } 96 96 - } 97 97 - 98 98 - impl<'a, S> DirectoryBuilder<'a, S> 99 99 - where 100 100 - S: directory_state::State, 101 101 - S::Entries: directory_state::IsUnset, 102 102 - { 103 103 - /// Set the `entries` field (required) 104 104 - pub fn entries( 105 105 - mut self, 106 106 - value: impl Into<Vec<crate::place_wisp::subfs::Entry<'a>>>, 107 107 - ) -> DirectoryBuilder<'a, directory_state::SetEntries<S>> { 108 108 - self.__unsafe_private_named.0 = ::core::option::Option::Some(value.into()); 109 109 - DirectoryBuilder { 110 110 - _phantom_state: ::core::marker::PhantomData, 111 111 - __unsafe_private_named: self.__unsafe_private_named, 112 112 - _phantom: ::core::marker::PhantomData, 113 113 - } 114 114 - } 115 115 - } 116 116 - 117 117 - impl<'a, S> DirectoryBuilder<'a, S> 118 118 - where 119 119 - S: directory_state::State, 120 120 - S::Type: directory_state::IsUnset, 121 121 - { 122 122 - /// Set the `type` field (required) 123 123 - pub fn r#type( 124 124 - mut self, 125 125 - value: impl Into<jacquard_common::CowStr<'a>>, 126 126 - ) -> DirectoryBuilder<'a, directory_state::SetType<S>> { 127 127 - self.__unsafe_private_named.1 = ::core::option::Option::Some(value.into()); 128 128 - DirectoryBuilder { 129 129 - _phantom_state: ::core::marker::PhantomData, 130 130 - __unsafe_private_named: self.__unsafe_private_named, 131 131 - _phantom: ::core::marker::PhantomData, 132 132 - } 133 133 - } 134 134 - } 135 135 - 136 136 - impl<'a, S> DirectoryBuilder<'a, S> 137 137 - where 138 138 - S: directory_state::State, 139 139 - S::Type: directory_state::IsSet, 140 140 - S::Entries: directory_state::IsSet, 141 141 - { 142 142 - /// Build the final struct 143 143 - pub fn build(self) -> Directory<'a> { 144 144 - Directory { 145 145 - entries: self.__unsafe_private_named.0.unwrap(), 146 146 - r#type: self.__unsafe_private_named.1.unwrap(), 147 147 - extra_data: Default::default(), 148 148 - } 149 149 - } 150 150 - /// Build the final struct with custom extra_data 151 151 - pub fn build_with_data( 152 152 - self, 153 153 - extra_data: std::collections::BTreeMap< 154 154 - jacquard_common::smol_str::SmolStr, 155 155 - jacquard_common::types::value::Data<'a>, 156 156 - >, 157 157 - ) -> Directory<'a> { 158 158 - Directory { 159 159 - entries: self.__unsafe_private_named.0.unwrap(), 160 160 - r#type: self.__unsafe_private_named.1.unwrap(), 161 161 - extra_data: Some(extra_data), 162 162 - } 163 163 - } 164 164 - } 165 165 - 166 166 - fn lexicon_doc_place_wisp_subfs() -> ::jacquard_lexicon::lexicon::LexiconDoc<'static> { 167 167 - ::jacquard_lexicon::lexicon::LexiconDoc { 168 168 - lexicon: ::jacquard_lexicon::lexicon::Lexicon::Lexicon1, 169 169 - id: ::jacquard_common::CowStr::new_static("place.wisp.subfs"), 170 170 - revision: None, 171 171 - description: None, 172 172 - defs: { 173 173 - let mut map = ::std::collections::BTreeMap::new(); 174 174 - map.insert( 175 175 - ::jacquard_common::smol_str::SmolStr::new_static("directory"), 176 176 - ::jacquard_lexicon::lexicon::LexUserType::Object(::jacquard_lexicon::lexicon::LexObject { 177 177 - description: None, 178 178 - required: Some( 179 179 - vec![ 180 180 - ::jacquard_common::smol_str::SmolStr::new_static("type"), 181 181 - ::jacquard_common::smol_str::SmolStr::new_static("entries") 182 182 - ], 183 183 - ), 184 184 - nullable: None, 185 185 - properties: { 186 186 - #[allow(unused_mut)] 187 187 - let mut map = ::std::collections::BTreeMap::new(); 188 188 - map.insert( 189 189 - ::jacquard_common::smol_str::SmolStr::new_static("entries"), 190 190 - ::jacquard_lexicon::lexicon::LexObjectProperty::Array(::jacquard_lexicon::lexicon::LexArray { 191 191 - description: None, 192 192 - items: ::jacquard_lexicon::lexicon::LexArrayItem::Ref(::jacquard_lexicon::lexicon::LexRef { 193 193 - description: None, 194 194 - r#ref: ::jacquard_common::CowStr::new_static("#entry"), 195 195 - }), 196 196 - min_length: None, 197 197 - max_length: Some(500usize), 198 198 - }), 199 199 - ); 200 200 - map.insert( 201 201 - ::jacquard_common::smol_str::SmolStr::new_static("type"), 202 202 - ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString { 203 203 - description: None, 204 204 - format: None, 205 205 - default: None, 206 206 - min_length: None, 207 207 - max_length: None, 208 208 - min_graphemes: None, 209 209 - max_graphemes: None, 210 210 - r#enum: None, 211 211 - r#const: None, 212 212 - known_values: None, 213 213 - }), 214 214 - ); 215 215 - map 216 216 - }, 217 217 - }), 218 218 - ); 219 219 - map.insert( 220 220 - ::jacquard_common::smol_str::SmolStr::new_static("entry"), 221 221 - ::jacquard_lexicon::lexicon::LexUserType::Object(::jacquard_lexicon::lexicon::LexObject { 222 222 - description: None, 223 223 - required: Some( 224 224 - vec![ 225 225 - ::jacquard_common::smol_str::SmolStr::new_static("name"), 226 226 - ::jacquard_common::smol_str::SmolStr::new_static("node") 227 227 - ], 228 228 - ), 229 229 - nullable: None, 230 230 - properties: { 231 231 - #[allow(unused_mut)] 232 232 - let mut map = ::std::collections::BTreeMap::new(); 233 233 - map.insert( 234 234 - ::jacquard_common::smol_str::SmolStr::new_static("name"), 235 235 - ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString { 236 236 - description: None, 237 237 - format: None, 238 238 - default: None, 239 239 - min_length: None, 240 240 - max_length: Some(255usize), 241 241 - min_graphemes: None, 242 242 - max_graphemes: None, 243 243 - r#enum: None, 244 244 - r#const: None, 245 245 - known_values: None, 246 246 - }), 247 247 - ); 248 248 - map.insert( 249 249 - ::jacquard_common::smol_str::SmolStr::new_static("node"), 250 250 - ::jacquard_lexicon::lexicon::LexObjectProperty::Union(::jacquard_lexicon::lexicon::LexRefUnion { 251 251 - description: None, 252 252 - refs: vec![ 253 253 - ::jacquard_common::CowStr::new_static("#file"), 254 254 - ::jacquard_common::CowStr::new_static("#directory"), 255 255 - ::jacquard_common::CowStr::new_static("#subfs") 256 256 - ], 257 257 - closed: None, 258 258 - }), 259 259 - ); 260 260 - map 261 261 - }, 262 262 - }), 263 263 - ); 264 264 - map.insert( 265 265 - ::jacquard_common::smol_str::SmolStr::new_static("file"), 266 266 - ::jacquard_lexicon::lexicon::LexUserType::Object(::jacquard_lexicon::lexicon::LexObject { 267 267 - description: None, 268 268 - required: Some( 269 269 - vec![ 270 270 - ::jacquard_common::smol_str::SmolStr::new_static("type"), 271 271 - ::jacquard_common::smol_str::SmolStr::new_static("blob") 272 272 - ], 273 273 - ), 274 274 - nullable: None, 275 275 - properties: { 276 276 - #[allow(unused_mut)] 277 277 - let mut map = ::std::collections::BTreeMap::new(); 278 278 - map.insert( 279 279 - ::jacquard_common::smol_str::SmolStr::new_static("base64"), 280 280 - ::jacquard_lexicon::lexicon::LexObjectProperty::Boolean(::jacquard_lexicon::lexicon::LexBoolean { 281 281 - description: None, 282 282 - default: None, 283 283 - r#const: None, 284 284 - }), 285 285 - ); 286 286 - map.insert( 287 287 - ::jacquard_common::smol_str::SmolStr::new_static("blob"), 288 288 - ::jacquard_lexicon::lexicon::LexObjectProperty::Blob(::jacquard_lexicon::lexicon::LexBlob { 289 289 - description: None, 290 290 - accept: None, 291 291 - max_size: None, 292 292 - }), 293 293 - ); 294 294 - map.insert( 295 295 - ::jacquard_common::smol_str::SmolStr::new_static("encoding"), 296 296 - ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString { 297 297 - description: Some( 298 298 - ::jacquard_common::CowStr::new_static( 299 299 - "Content encoding (e.g., gzip for compressed files)", 300 300 - ), 301 301 - ), 302 302 - format: None, 303 303 - default: None, 304 304 - min_length: None, 305 305 - max_length: None, 306 306 - min_graphemes: None, 307 307 - max_graphemes: None, 308 308 - r#enum: None, 309 309 - r#const: None, 310 310 - known_values: None, 311 311 - }), 312 312 - ); 313 313 - map.insert( 314 314 - ::jacquard_common::smol_str::SmolStr::new_static("mimeType"), 315 315 - ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString { 316 316 - description: Some( 317 317 - ::jacquard_common::CowStr::new_static( 318 318 - "Original MIME type before compression", 319 319 - ), 320 320 - ), 321 321 - format: None, 322 322 - default: None, 323 323 - min_length: None, 324 324 - max_length: None, 325 325 - min_graphemes: None, 326 326 - max_graphemes: None, 327 327 - r#enum: None, 328 328 - r#const: None, 329 329 - known_values: None, 330 330 - }), 331 331 - ); 332 332 - map.insert( 333 333 - ::jacquard_common::smol_str::SmolStr::new_static("type"), 334 334 - ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString { 335 335 - description: None, 336 336 - format: None, 337 337 - default: None, 338 338 - min_length: None, 339 339 - max_length: None, 340 340 - min_graphemes: None, 341 341 - max_graphemes: None, 342 342 - r#enum: None, 343 343 - r#const: None, 344 344 - known_values: None, 345 345 - }), 346 346 - ); 347 347 - map 348 348 - }, 349 349 - }), 350 350 - ); 351 351 - map.insert( 352 352 - ::jacquard_common::smol_str::SmolStr::new_static("main"), 353 353 - ::jacquard_lexicon::lexicon::LexUserType::Record(::jacquard_lexicon::lexicon::LexRecord { 354 354 - description: Some( 355 355 - ::jacquard_common::CowStr::new_static( 356 356 - "Virtual filesystem subtree referenced by place.wisp.fs records. When a subfs entry is expanded, its root entries are merged (flattened) into the parent directory, allowing large directories to be split across multiple records while maintaining a flat structure.", 357 357 - ), 358 358 - ), 359 359 - key: None, 360 360 - record: ::jacquard_lexicon::lexicon::LexRecordRecord::Object(::jacquard_lexicon::lexicon::LexObject { 361 361 - description: None, 362 362 - required: Some( 363 363 - vec![ 364 364 - ::jacquard_common::smol_str::SmolStr::new_static("root"), 365 365 - ::jacquard_common::smol_str::SmolStr::new_static("createdAt") 366 366 - ], 367 367 - ), 368 368 - nullable: None, 369 369 - properties: { 370 370 - #[allow(unused_mut)] 371 371 - let mut map = ::std::collections::BTreeMap::new(); 372 372 - map.insert( 373 373 - ::jacquard_common::smol_str::SmolStr::new_static( 374 374 - "createdAt", 375 375 - ), 376 376 - ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString { 377 377 - description: None, 378 378 - format: Some( 379 379 - ::jacquard_lexicon::lexicon::LexStringFormat::Datetime, 380 380 - ), 381 381 - default: None, 382 382 - min_length: None, 383 383 - max_length: None, 384 384 - min_graphemes: None, 385 385 - max_graphemes: None, 386 386 - r#enum: None, 387 387 - r#const: None, 388 388 - known_values: None, 389 389 - }), 390 390 - ); 391 391 - map.insert( 392 392 - ::jacquard_common::smol_str::SmolStr::new_static( 393 393 - "fileCount", 394 394 - ), 395 395 - ::jacquard_lexicon::lexicon::LexObjectProperty::Integer(::jacquard_lexicon::lexicon::LexInteger { 396 396 - description: None, 397 397 - default: None, 398 398 - minimum: Some(0i64), 399 399 - maximum: Some(1000i64), 400 400 - r#enum: None, 401 401 - r#const: None, 402 402 - }), 403 403 - ); 404 404 - map.insert( 405 405 - ::jacquard_common::smol_str::SmolStr::new_static("root"), 406 406 - ::jacquard_lexicon::lexicon::LexObjectProperty::Ref(::jacquard_lexicon::lexicon::LexRef { 407 407 - description: None, 408 408 - r#ref: ::jacquard_common::CowStr::new_static("#directory"), 409 409 - }), 410 410 - ); 411 411 - map 412 412 - }, 413 413 - }), 414 414 - }), 415 415 - ); 416 416 - map.insert( 417 417 - ::jacquard_common::smol_str::SmolStr::new_static("subfs"), 418 418 - ::jacquard_lexicon::lexicon::LexUserType::Object(::jacquard_lexicon::lexicon::LexObject { 419 419 - description: None, 420 420 - required: Some( 421 421 - vec![ 422 422 - ::jacquard_common::smol_str::SmolStr::new_static("type"), 423 423 - ::jacquard_common::smol_str::SmolStr::new_static("subject") 424 424 - ], 425 425 - ), 426 426 - nullable: None, 427 427 - properties: { 428 428 - #[allow(unused_mut)] 429 429 - let mut map = ::std::collections::BTreeMap::new(); 430 430 - map.insert( 431 431 - ::jacquard_common::smol_str::SmolStr::new_static("subject"), 432 432 - ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString { 433 433 - description: Some( 434 434 - ::jacquard_common::CowStr::new_static( 435 435 - "AT-URI pointing to another place.wisp.subfs record for nested subtrees. When expanded, the referenced record's root entries are merged (flattened) into the parent directory, allowing recursive splitting of large directory structures.", 436 436 - ), 437 437 - ), 438 438 - format: Some( 439 439 - ::jacquard_lexicon::lexicon::LexStringFormat::AtUri, 440 440 - ), 441 441 - default: None, 442 442 - min_length: None, 443 443 - max_length: None, 444 444 - min_graphemes: None, 445 445 - max_graphemes: None, 446 446 - r#enum: None, 447 447 - r#const: None, 448 448 - known_values: None, 449 449 - }), 450 450 - ); 451 451 - map.insert( 452 452 - ::jacquard_common::smol_str::SmolStr::new_static("type"), 453 453 - ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString { 454 454 - description: None, 455 455 - format: None, 456 456 - default: None, 457 457 - min_length: None, 458 458 - max_length: None, 459 459 - min_graphemes: None, 460 460 - max_graphemes: None, 461 461 - r#enum: None, 462 462 - r#const: None, 463 463 - known_values: None, 464 464 - }), 465 465 - ); 466 466 - map 467 467 - }, 468 468 - }), 469 469 - ); 470 470 - map 471 471 - }, 472 472 - } 473 473 - } 474 474 - 475 475 - impl<'a> ::jacquard_lexicon::schema::LexiconSchema for Directory<'a> { 476 476 - fn nsid() -> &'static str { 477 477 - "place.wisp.subfs" 478 478 - } 479 479 - fn def_name() -> &'static str { 480 480 - "directory" 481 481 - } 482 482 - fn lexicon_doc() -> ::jacquard_lexicon::lexicon::LexiconDoc<'static> { 483 483 - lexicon_doc_place_wisp_subfs() 484 484 - } 485 485 - fn validate( 486 486 - &self, 487 487 - ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 488 488 - { 489 489 - let value = &self.entries; 490 490 - #[allow(unused_comparisons)] 491 491 - if value.len() > 500usize { 492 492 - return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 493 493 - path: ::jacquard_lexicon::validation::ValidationPath::from_field( 494 494 - "entries", 495 495 - ), 496 496 - max: 500usize, 497 497 - actual: value.len(), 498 498 - }); 499 499 - } 500 500 - } 501 501 - Ok(()) 502 502 - } 503 503 - } 504 504 - 505 505 - #[jacquard_derive::lexicon] 506 506 - #[derive( 507 507 - serde::Serialize, 508 508 - serde::Deserialize, 509 509 - Debug, 510 510 - Clone, 511 511 - PartialEq, 512 512 - Eq, 513 513 - jacquard_derive::IntoStatic 514 514 - )] 515 515 - #[serde(rename_all = "camelCase")] 516 516 - pub struct Entry<'a> { 517 517 - #[serde(borrow)] 518 518 - pub name: jacquard_common::CowStr<'a>, 519 519 - #[serde(borrow)] 520 520 - pub node: EntryNode<'a>, 521 521 - } 522 522 - 523 523 - pub mod entry_state { 524 524 - 525 525 - pub use crate::builder_types::{Set, Unset, IsSet, IsUnset}; 526 526 - #[allow(unused)] 527 527 - use ::core::marker::PhantomData; 528 528 - mod sealed { 529 529 - pub trait Sealed {} 530 530 - } 531 531 - /// State trait tracking which required fields have been set 532 532 - pub trait State: sealed::Sealed { 533 533 - type Name; 534 534 - type Node; 535 535 - } 536 536 - /// Empty state - all required fields are unset 537 537 - pub struct Empty(()); 538 538 - impl sealed::Sealed for Empty {} 539 539 - impl State for Empty { 540 540 - type Name = Unset; 541 541 - type Node = Unset; 542 542 - } 543 543 - ///State transition - sets the `name` field to Set 544 544 - pub struct SetName<S: State = Empty>(PhantomData<fn() -> S>); 545 545 - impl<S: State> sealed::Sealed for SetName<S> {} 546 546 - impl<S: State> State for SetName<S> { 547 547 - type Name = Set<members::name>; 548 548 - type Node = S::Node; 549 549 - } 550 550 - ///State transition - sets the `node` field to Set 551 551 - pub struct SetNode<S: State = Empty>(PhantomData<fn() -> S>); 552 552 - impl<S: State> sealed::Sealed for SetNode<S> {} 553 553 - impl<S: State> State for SetNode<S> { 554 554 - type Name = S::Name; 555 555 - type Node = Set<members::node>; 556 556 - } 557 557 - /// Marker types for field names 558 558 - #[allow(non_camel_case_types)] 559 559 - pub mod members { 560 560 - ///Marker type for the `name` field 561 561 - pub struct name(()); 562 562 - ///Marker type for the `node` field 563 563 - pub struct node(()); 564 564 - } 565 565 - } 566 566 - 567 567 - /// Builder for constructing an instance of this type 568 568 - pub struct EntryBuilder<'a, S: entry_state::State> { 569 569 - _phantom_state: ::core::marker::PhantomData<fn() -> S>, 570 570 - __unsafe_private_named: ( 571 571 - ::core::option::Option<jacquard_common::CowStr<'a>>, 572 572 - ::core::option::Option<EntryNode<'a>>, 573 573 - ), 574 574 - _phantom: ::core::marker::PhantomData<&'a ()>, 575 575 - } 576 576 - 577 577 - impl<'a> Entry<'a> { 578 578 - /// Create a new builder for this type 579 579 - pub fn new() -> EntryBuilder<'a, entry_state::Empty> { 580 580 - EntryBuilder::new() 581 581 - } 582 582 - } 583 583 - 584 584 - impl<'a> EntryBuilder<'a, entry_state::Empty> { 585 585 - /// Create a new builder with all fields unset 586 586 - pub fn new() -> Self { 587 587 - EntryBuilder { 588 588 - _phantom_state: ::core::marker::PhantomData, 589 589 - __unsafe_private_named: (None, None), 590 590 - _phantom: ::core::marker::PhantomData, 591 591 - } 592 592 - } 593 593 - } 594 594 - 595 595 - impl<'a, S> EntryBuilder<'a, S> 596 596 - where 597 597 - S: entry_state::State, 598 598 - S::Name: entry_state::IsUnset, 599 599 - { 600 600 - /// Set the `name` field (required) 601 601 - pub fn name( 602 602 - mut self, 603 603 - value: impl Into<jacquard_common::CowStr<'a>>, 604 604 - ) -> EntryBuilder<'a, entry_state::SetName<S>> { 605 605 - self.__unsafe_private_named.0 = ::core::option::Option::Some(value.into()); 606 606 - EntryBuilder { 607 607 - _phantom_state: ::core::marker::PhantomData, 608 608 - __unsafe_private_named: self.__unsafe_private_named, 609 609 - _phantom: ::core::marker::PhantomData, 610 610 - } 611 611 - } 612 612 - } 613 613 - 614 614 - impl<'a, S> EntryBuilder<'a, S> 615 615 - where 616 616 - S: entry_state::State, 617 617 - S::Node: entry_state::IsUnset, 618 618 - { 619 619 - /// Set the `node` field (required) 620 620 - pub fn node( 621 621 - mut self, 622 622 - value: impl Into<EntryNode<'a>>, 623 623 - ) -> EntryBuilder<'a, entry_state::SetNode<S>> { 624 624 - self.__unsafe_private_named.1 = ::core::option::Option::Some(value.into()); 625 625 - EntryBuilder { 626 626 - _phantom_state: ::core::marker::PhantomData, 627 627 - __unsafe_private_named: self.__unsafe_private_named, 628 628 - _phantom: ::core::marker::PhantomData, 629 629 - } 630 630 - } 631 631 - } 632 632 - 633 633 - impl<'a, S> EntryBuilder<'a, S> 634 634 - where 635 635 - S: entry_state::State, 636 636 - S::Name: entry_state::IsSet, 637 637 - S::Node: entry_state::IsSet, 638 638 - { 639 639 - /// Build the final struct 640 640 - pub fn build(self) -> Entry<'a> { 641 641 - Entry { 642 642 - name: self.__unsafe_private_named.0.unwrap(), 643 643 - node: self.__unsafe_private_named.1.unwrap(), 644 644 - extra_data: Default::default(), 645 645 - } 646 646 - } 647 647 - /// Build the final struct with custom extra_data 648 648 - pub fn build_with_data( 649 649 - self, 650 650 - extra_data: std::collections::BTreeMap< 651 651 - jacquard_common::smol_str::SmolStr, 652 652 - jacquard_common::types::value::Data<'a>, 653 653 - >, 654 654 - ) -> Entry<'a> { 655 655 - Entry { 656 656 - name: self.__unsafe_private_named.0.unwrap(), 657 657 - node: self.__unsafe_private_named.1.unwrap(), 658 658 - extra_data: Some(extra_data), 659 659 - } 660 660 - } 661 661 - } 662 662 - 663 663 - #[jacquard_derive::open_union] 664 664 - #[derive( 665 665 - serde::Serialize, 666 666 - serde::Deserialize, 667 667 - Debug, 668 668 - Clone, 669 669 - PartialEq, 670 670 - Eq, 671 671 - jacquard_derive::IntoStatic 672 672 - )] 673 673 - #[serde(tag = "$type")] 674 674 - #[serde(bound(deserialize = "'de: 'a"))] 675 675 - pub enum EntryNode<'a> { 676 676 - #[serde(rename = "place.wisp.subfs#file")] 677 677 - File(Box<crate::place_wisp::subfs::File<'a>>), 678 678 - #[serde(rename = "place.wisp.subfs#directory")] 679 679 - Directory(Box<crate::place_wisp::subfs::Directory<'a>>), 680 680 - #[serde(rename = "place.wisp.subfs#subfs")] 681 681 - Subfs(Box<crate::place_wisp::subfs::Subfs<'a>>), 682 682 - } 683 683 - 684 684 - impl<'a> ::jacquard_lexicon::schema::LexiconSchema for Entry<'a> { 685 685 - fn nsid() -> &'static str { 686 686 - "place.wisp.subfs" 687 687 - } 688 688 - fn def_name() -> &'static str { 689 689 - "entry" 690 690 - } 691 691 - fn lexicon_doc() -> ::jacquard_lexicon::lexicon::LexiconDoc<'static> { 692 692 - lexicon_doc_place_wisp_subfs() 693 693 - } 694 694 - fn validate( 695 695 - &self, 696 696 - ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 697 697 - { 698 698 - let value = &self.name; 699 699 - #[allow(unused_comparisons)] 700 700 - if <str>::len(value.as_ref()) > 255usize { 701 701 - return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength { 702 702 - path: ::jacquard_lexicon::validation::ValidationPath::from_field( 703 703 - "name", 704 704 - ), 705 705 - max: 255usize, 706 706 - actual: <str>::len(value.as_ref()), 707 707 - }); 708 708 - } 709 709 - } 710 710 - Ok(()) 711 711 - } 712 712 - } 713 713 - 714 714 - #[jacquard_derive::lexicon] 715 715 - #[derive( 716 716 - serde::Serialize, 717 717 - serde::Deserialize, 718 718 - Debug, 719 719 - Clone, 720 720 - PartialEq, 721 721 - Eq, 722 722 - jacquard_derive::IntoStatic 723 723 - )] 724 724 - #[serde(rename_all = "camelCase")] 725 725 - pub struct File<'a> { 726 726 - /// True if blob content is base64-encoded (used to bypass PDS content sniffing) 727 727 - #[serde(skip_serializing_if = "std::option::Option::is_none")] 728 728 - pub base64: Option<bool>, 729 729 - /// Content blob ref 730 730 - #[serde(borrow)] 731 731 - pub blob: jacquard_common::types::blob::BlobRef<'a>, 732 732 - /// Content encoding (e.g., gzip for compressed files) 733 733 - #[serde(skip_serializing_if = "std::option::Option::is_none")] 734 734 - #[serde(borrow)] 735 735 - pub encoding: Option<jacquard_common::CowStr<'a>>, 736 736 - /// Original MIME type before compression 737 737 - #[serde(skip_serializing_if = "std::option::Option::is_none")] 738 738 - #[serde(borrow)] 739 739 - pub mime_type: Option<jacquard_common::CowStr<'a>>, 740 740 - #[serde(borrow)] 741 741 - pub r#type: jacquard_common::CowStr<'a>, 742 742 - } 743 743 - 744 744 - pub mod file_state { 745 745 - 746 746 - pub use crate::builder_types::{Set, Unset, IsSet, IsUnset}; 747 747 - #[allow(unused)] 748 748 - use ::core::marker::PhantomData; 749 749 - mod sealed { 750 750 - pub trait Sealed {} 751 751 - } 752 752 - /// State trait tracking which required fields have been set 753 753 - pub trait State: sealed::Sealed { 754 754 - type Type; 755 755 - type Blob; 756 756 - } 757 757 - /// Empty state - all required fields are unset 758 758 - pub struct Empty(()); 759 759 - impl sealed::Sealed for Empty {} 760 760 - impl State for Empty { 761 761 - type Type = Unset; 762 762 - type Blob = Unset; 763 763 - } 764 764 - ///State transition - sets the `type` field to Set 765 765 - pub struct SetType<S: State = Empty>(PhantomData<fn() -> S>); 766 766 - impl<S: State> sealed::Sealed for SetType<S> {} 767 767 - impl<S: State> State for SetType<S> { 768 768 - type Type = Set<members::r#type>; 769 769 - type Blob = S::Blob; 770 770 - } 771 771 - ///State transition - sets the `blob` field to Set 772 772 - pub struct SetBlob<S: State = Empty>(PhantomData<fn() -> S>); 773 773 - impl<S: State> sealed::Sealed for SetBlob<S> {} 774 774 - impl<S: State> State for SetBlob<S> { 775 775 - type Type = S::Type; 776 776 - type Blob = Set<members::blob>; 777 777 - } 778 778 - /// Marker types for field names 779 779 - #[allow(non_camel_case_types)] 780 780 - pub mod members { 781 781 - ///Marker type for the `type` field 782 782 - pub struct r#type(()); 783 783 - ///Marker type for the `blob` field 784 784 - pub struct blob(()); 785 785 - } 786 786 - } 787 787 - 788 788 - /// Builder for constructing an instance of this type 789 789 - pub struct FileBuilder<'a, S: file_state::State> { 790 790 - _phantom_state: ::core::marker::PhantomData<fn() -> S>, 791 791 - __unsafe_private_named: ( 792 792 - ::core::option::Option<bool>, 793 793 - ::core::option::Option<jacquard_common::types::blob::BlobRef<'a>>, 794 794 - ::core::option::Option<jacquard_common::CowStr<'a>>, 795 795 - ::core::option::Option<jacquard_common::CowStr<'a>>, 796 796 - ::core::option::Option<jacquard_common::CowStr<'a>>, 797 797 - ), 798 798 - _phantom: ::core::marker::PhantomData<&'a ()>, 799 799 - } 800 800 - 801 801 - impl<'a> File<'a> { 802 802 - /// Create a new builder for this type 803 803 - pub fn new() -> FileBuilder<'a, file_state::Empty> { 804 804 - FileBuilder::new() 805 805 - } 806 806 - } 807 807 - 808 808 - impl<'a> FileBuilder<'a, file_state::Empty> { 809 809 - /// Create a new builder with all fields unset 810 810 - pub fn new() -> Self { 811 811 - FileBuilder { 812 812 - _phantom_state: ::core::marker::PhantomData, 813 813 - __unsafe_private_named: (None, None, None, None, None), 814 814 - _phantom: ::core::marker::PhantomData, 815 815 - } 816 816 - } 817 817 - } 818 818 - 819 819 - impl<'a, S: file_state::State> FileBuilder<'a, S> { 820 820 - /// Set the `base64` field (optional) 821 821 - pub fn base64(mut self, value: impl Into<Option<bool>>) -> Self { 822 822 - self.__unsafe_private_named.0 = value.into(); 823 823 - self 824 824 - } 825 825 - /// Set the `base64` field to an Option value (optional) 826 826 - pub fn maybe_base64(mut self, value: Option<bool>) -> Self { 827 827 - self.__unsafe_private_named.0 = value; 828 828 - self 829 829 - } 830 830 - } 831 831 - 832 832 - impl<'a, S> FileBuilder<'a, S> 833 833 - where 834 834 - S: file_state::State, 835 835 - S::Blob: file_state::IsUnset, 836 836 - { 837 837 - /// Set the `blob` field (required) 838 838 - pub fn blob( 839 839 - mut self, 840 840 - value: impl Into<jacquard_common::types::blob::BlobRef<'a>>, 841 841 - ) -> FileBuilder<'a, file_state::SetBlob<S>> { 842 842 - self.__unsafe_private_named.1 = ::core::option::Option::Some(value.into()); 843 843 - FileBuilder { 844 844 - _phantom_state: ::core::marker::PhantomData, 845 845 - __unsafe_private_named: self.__unsafe_private_named, 846 846 - _phantom: ::core::marker::PhantomData, 847 847 - } 848 848 - } 849 849 - } 850 850 - 851 851 - impl<'a, S: file_state::State> FileBuilder<'a, S> { 852 852 - /// Set the `encoding` field (optional) 853 853 - pub fn encoding( 854 854 - mut self, 855 855 - value: impl Into<Option<jacquard_common::CowStr<'a>>>, 856 856 - ) -> Self { 857 857 - self.__unsafe_private_named.2 = value.into(); 858 858 - self 859 859 - } 860 860 - /// Set the `encoding` field to an Option value (optional) 861 861 - pub fn maybe_encoding(mut self, value: Option<jacquard_common::CowStr<'a>>) -> Self { 862 862 - self.__unsafe_private_named.2 = value; 863 863 - self 864 864 - } 865 865 - } 866 866 - 867 867 - impl<'a, S: file_state::State> FileBuilder<'a, S> { 868 868 - /// Set the `mimeType` field (optional) 869 869 - pub fn mime_type( 870 870 - mut self, 871 871 - value: impl Into<Option<jacquard_common::CowStr<'a>>>, 872 872 - ) -> Self { 873 873 - self.__unsafe_private_named.3 = value.into(); 874 874 - self 875 875 - } 876 876 - /// Set the `mimeType` field to an Option value (optional) 877 877 - pub fn maybe_mime_type( 878 878 - mut self, 879 879 - value: Option<jacquard_common::CowStr<'a>>, 880 880 - ) -> Self { 881 881 - self.__unsafe_private_named.3 = value; 882 882 - self 883 883 - } 884 884 - } 885 885 - 886 886 - impl<'a, S> FileBuilder<'a, S> 887 887 - where 888 888 - S: file_state::State, 889 889 - S::Type: file_state::IsUnset, 890 890 - { 891 891 - /// Set the `type` field (required) 892 892 - pub fn r#type( 893 893 - mut self, 894 894 - value: impl Into<jacquard_common::CowStr<'a>>, 895 895 - ) -> FileBuilder<'a, file_state::SetType<S>> { 896 896 - self.__unsafe_private_named.4 = ::core::option::Option::Some(value.into()); 897 897 - FileBuilder { 898 898 - _phantom_state: ::core::marker::PhantomData, 899 899 - __unsafe_private_named: self.__unsafe_private_named, 900 900 - _phantom: ::core::marker::PhantomData, 901 901 - } 902 902 - } 903 903 - } 904 904 - 905 905 - impl<'a, S> FileBuilder<'a, S> 906 906 - where 907 907 - S: file_state::State, 908 908 - S::Type: file_state::IsSet, 909 909 - S::Blob: file_state::IsSet, 910 910 - { 911 911 - /// Build the final struct 912 912 - pub fn build(self) -> File<'a> { 913 913 - File { 914 914 - base64: self.__unsafe_private_named.0, 915 915 - blob: self.__unsafe_private_named.1.unwrap(), 916 916 - encoding: self.__unsafe_private_named.2, 917 917 - mime_type: self.__unsafe_private_named.3, 918 918 - r#type: self.__unsafe_private_named.4.unwrap(), 919 919 - extra_data: Default::default(), 920 920 - } 921 921 - } 922 922 - /// Build the final struct with custom extra_data 923 923 - pub fn build_with_data( 924 924 - self, 925 925 - extra_data: std::collections::BTreeMap< 926 926 - jacquard_common::smol_str::SmolStr, 927 927 - jacquard_common::types::value::Data<'a>, 928 928 - >, 929 929 - ) -> File<'a> { 930 930 - File { 931 931 - base64: self.__unsafe_private_named.0, 932 932 - blob: self.__unsafe_private_named.1.unwrap(), 933 933 - encoding: self.__unsafe_private_named.2, 934 934 - mime_type: self.__unsafe_private_named.3, 935 935 - r#type: self.__unsafe_private_named.4.unwrap(), 936 936 - extra_data: Some(extra_data), 937 937 - } 938 938 - } 939 939 - } 940 940 - 941 941 - impl<'a> ::jacquard_lexicon::schema::LexiconSchema for File<'a> { 942 942 - fn nsid() -> &'static str { 943 943 - "place.wisp.subfs" 944 944 - } 945 945 - fn def_name() -> &'static str { 946 946 - "file" 947 947 - } 948 948 - fn lexicon_doc() -> ::jacquard_lexicon::lexicon::LexiconDoc<'static> { 949 949 - lexicon_doc_place_wisp_subfs() 950 950 - } 951 951 - fn validate( 952 952 - &self, 953 953 - ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 954 954 - Ok(()) 955 955 - } 956 956 - } 957 957 - 958 958 - /// Virtual filesystem subtree referenced by place.wisp.fs records. When a subfs entry is expanded, its root entries are merged (flattened) into the parent directory, allowing large directories to be split across multiple records while maintaining a flat structure. 959 959 - #[jacquard_derive::lexicon] 960 960 - #[derive( 961 961 - serde::Serialize, 962 962 - serde::Deserialize, 963 963 - Debug, 964 964 - Clone, 965 965 - PartialEq, 966 966 - Eq, 967 967 - jacquard_derive::IntoStatic 968 968 - )] 969 969 - #[serde(rename_all = "camelCase")] 970 970 - pub struct SubfsRecord<'a> { 971 971 - pub created_at: jacquard_common::types::string::Datetime, 972 972 - #[serde(skip_serializing_if = "std::option::Option::is_none")] 973 973 - pub file_count: Option<i64>, 974 974 - #[serde(borrow)] 975 975 - pub root: crate::place_wisp::subfs::Directory<'a>, 976 976 - } 977 977 - 978 978 - pub mod subfs_record_state { 979 979 - 980 980 - pub use crate::builder_types::{Set, Unset, IsSet, IsUnset}; 981 981 - #[allow(unused)] 982 982 - use ::core::marker::PhantomData; 983 983 - mod sealed { 984 984 - pub trait Sealed {} 985 985 - } 986 986 - /// State trait tracking which required fields have been set 987 987 - pub trait State: sealed::Sealed { 988 988 - type Root; 989 989 - type CreatedAt; 990 990 - } 991 991 - /// Empty state - all required fields are unset 992 992 - pub struct Empty(()); 993 993 - impl sealed::Sealed for Empty {} 994 994 - impl State for Empty { 995 995 - type Root = Unset; 996 996 - type CreatedAt = Unset; 997 997 - } 998 998 - ///State transition - sets the `root` field to Set 999 999 - pub struct SetRoot<S: State = Empty>(PhantomData<fn() -> S>); 1000 1000 - impl<S: State> sealed::Sealed for SetRoot<S> {} 1001 1001 - impl<S: State> State for SetRoot<S> { 1002 1002 - type Root = Set<members::root>; 1003 1003 - type CreatedAt = S::CreatedAt; 1004 1004 - } 1005 1005 - ///State transition - sets the `created_at` field to Set 1006 1006 - pub struct SetCreatedAt<S: State = Empty>(PhantomData<fn() -> S>); 1007 1007 - impl<S: State> sealed::Sealed for SetCreatedAt<S> {} 1008 1008 - impl<S: State> State for SetCreatedAt<S> { 1009 1009 - type Root = S::Root; 1010 1010 - type CreatedAt = Set<members::created_at>; 1011 1011 - } 1012 1012 - /// Marker types for field names 1013 1013 - #[allow(non_camel_case_types)] 1014 1014 - pub mod members { 1015 1015 - ///Marker type for the `root` field 1016 1016 - pub struct root(()); 1017 1017 - ///Marker type for the `created_at` field 1018 1018 - pub struct created_at(()); 1019 1019 - } 1020 1020 - } 1021 1021 - 1022 1022 - /// Builder for constructing an instance of this type 1023 1023 - pub struct SubfsRecordBuilder<'a, S: subfs_record_state::State> { 1024 1024 - _phantom_state: ::core::marker::PhantomData<fn() -> S>, 1025 1025 - __unsafe_private_named: ( 1026 1026 - ::core::option::Option<jacquard_common::types::string::Datetime>, 1027 1027 - ::core::option::Option<i64>, 1028 1028 - ::core::option::Option<crate::place_wisp::subfs::Directory<'a>>, 1029 1029 - ), 1030 1030 - _phantom: ::core::marker::PhantomData<&'a ()>, 1031 1031 - } 1032 1032 - 1033 1033 - impl<'a> SubfsRecord<'a> { 1034 1034 - /// Create a new builder for this type 1035 1035 - pub fn new() -> SubfsRecordBuilder<'a, subfs_record_state::Empty> { 1036 1036 - SubfsRecordBuilder::new() 1037 1037 - } 1038 1038 - } 1039 1039 - 1040 1040 - impl<'a> SubfsRecordBuilder<'a, subfs_record_state::Empty> { 1041 1041 - /// Create a new builder with all fields unset 1042 1042 - pub fn new() -> Self { 1043 1043 - SubfsRecordBuilder { 1044 1044 - _phantom_state: ::core::marker::PhantomData, 1045 1045 - __unsafe_private_named: (None, None, None), 1046 1046 - _phantom: ::core::marker::PhantomData, 1047 1047 - } 1048 1048 - } 1049 1049 - } 1050 1050 - 1051 1051 - impl<'a, S> SubfsRecordBuilder<'a, S> 1052 1052 - where 1053 1053 - S: subfs_record_state::State, 1054 1054 - S::CreatedAt: subfs_record_state::IsUnset, 1055 1055 - { 1056 1056 - /// Set the `createdAt` field (required) 1057 1057 - pub fn created_at( 1058 1058 - mut self, 1059 1059 - value: impl Into<jacquard_common::types::string::Datetime>, 1060 1060 - ) -> SubfsRecordBuilder<'a, subfs_record_state::SetCreatedAt<S>> { 1061 1061 - self.__unsafe_private_named.0 = ::core::option::Option::Some(value.into()); 1062 1062 - SubfsRecordBuilder { 1063 1063 - _phantom_state: ::core::marker::PhantomData, 1064 1064 - __unsafe_private_named: self.__unsafe_private_named, 1065 1065 - _phantom: ::core::marker::PhantomData, 1066 1066 - } 1067 1067 - } 1068 1068 - } 1069 1069 - 1070 1070 - impl<'a, S: subfs_record_state::State> SubfsRecordBuilder<'a, S> { 1071 1071 - /// Set the `fileCount` field (optional) 1072 1072 - pub fn file_count(mut self, value: impl Into<Option<i64>>) -> Self { 1073 1073 - self.__unsafe_private_named.1 = value.into(); 1074 1074 - self 1075 1075 - } 1076 1076 - /// Set the `fileCount` field to an Option value (optional) 1077 1077 - pub fn maybe_file_count(mut self, value: Option<i64>) -> Self { 1078 1078 - self.__unsafe_private_named.1 = value; 1079 1079 - self 1080 1080 - } 1081 1081 - } 1082 1082 - 1083 1083 - impl<'a, S> SubfsRecordBuilder<'a, S> 1084 1084 - where 1085 1085 - S: subfs_record_state::State, 1086 1086 - S::Root: subfs_record_state::IsUnset, 1087 1087 - { 1088 1088 - /// Set the `root` field (required) 1089 1089 - pub fn root( 1090 1090 - mut self, 1091 1091 - value: impl Into<crate::place_wisp::subfs::Directory<'a>>, 1092 1092 - ) -> SubfsRecordBuilder<'a, subfs_record_state::SetRoot<S>> { 1093 1093 - self.__unsafe_private_named.2 = ::core::option::Option::Some(value.into()); 1094 1094 - SubfsRecordBuilder { 1095 1095 - _phantom_state: ::core::marker::PhantomData, 1096 1096 - __unsafe_private_named: self.__unsafe_private_named, 1097 1097 - _phantom: ::core::marker::PhantomData, 1098 1098 - } 1099 1099 - } 1100 1100 - } 1101 1101 - 1102 1102 - impl<'a, S> SubfsRecordBuilder<'a, S> 1103 1103 - where 1104 1104 - S: subfs_record_state::State, 1105 1105 - S::Root: subfs_record_state::IsSet, 1106 1106 - S::CreatedAt: subfs_record_state::IsSet, 1107 1107 - { 1108 1108 - /// Build the final struct 1109 1109 - pub fn build(self) -> SubfsRecord<'a> { 1110 1110 - SubfsRecord { 1111 1111 - created_at: self.__unsafe_private_named.0.unwrap(), 1112 1112 - file_count: self.__unsafe_private_named.1, 1113 1113 - root: self.__unsafe_private_named.2.unwrap(), 1114 1114 - extra_data: Default::default(), 1115 1115 - } 1116 1116 - } 1117 1117 - /// Build the final struct with custom extra_data 1118 1118 - pub fn build_with_data( 1119 1119 - self, 1120 1120 - extra_data: std::collections::BTreeMap< 1121 1121 - jacquard_common::smol_str::SmolStr, 1122 1122 - jacquard_common::types::value::Data<'a>, 1123 1123 - >, 1124 1124 - ) -> SubfsRecord<'a> { 1125 1125 - SubfsRecord { 1126 1126 - created_at: self.__unsafe_private_named.0.unwrap(), 1127 1127 - file_count: self.__unsafe_private_named.1, 1128 1128 - root: self.__unsafe_private_named.2.unwrap(), 1129 1129 - extra_data: Some(extra_data), 1130 1130 - } 1131 1131 - } 1132 1132 - } 1133 1133 - 1134 1134 - impl<'a> SubfsRecord<'a> { 1135 1135 - pub fn uri( 1136 1136 - uri: impl Into<jacquard_common::CowStr<'a>>, 1137 1137 - ) -> Result< 1138 1138 - jacquard_common::types::uri::RecordUri<'a, SubfsRecordRecord>, 1139 1139 - jacquard_common::types::uri::UriError, 1140 1140 - > { 1141 1141 - jacquard_common::types::uri::RecordUri::try_from_uri( 1142 1142 - jacquard_common::types::string::AtUri::new_cow(uri.into())?, 1143 1143 - ) 1144 1144 - } 1145 1145 - } 1146 1146 - 1147 1147 - /// Typed wrapper for GetRecord response with this collection's record type. 1148 1148 - #[derive( 1149 1149 - serde::Serialize, 1150 1150 - serde::Deserialize, 1151 1151 - Debug, 1152 1152 - Clone, 1153 1153 - PartialEq, 1154 1154 - Eq, 1155 1155 - jacquard_derive::IntoStatic 1156 1156 - )] 1157 1157 - #[serde(rename_all = "camelCase")] 1158 1158 - pub struct SubfsRecordGetRecordOutput<'a> { 1159 1159 - #[serde(skip_serializing_if = "std::option::Option::is_none")] 1160 1160 - #[serde(borrow)] 1161 1161 - pub cid: std::option::Option<jacquard_common::types::string::Cid<'a>>, 1162 1162 - #[serde(borrow)] 1163 1163 - pub uri: jacquard_common::types::string::AtUri<'a>, 1164 1164 - #[serde(borrow)] 1165 1165 - pub value: SubfsRecord<'a>, 1166 1166 - } 1167 1167 - 1168 1168 - impl From<SubfsRecordGetRecordOutput<'_>> for SubfsRecord<'_> { 1169 1169 - fn from(output: SubfsRecordGetRecordOutput<'_>) -> Self { 1170 1170 - use jacquard_common::IntoStatic; 1171 1171 - output.value.into_static() 1172 1172 - } 1173 1173 - } 1174 1174 - 1175 1175 - impl jacquard_common::types::collection::Collection for SubfsRecord<'_> { 1176 1176 - const NSID: &'static str = "place.wisp.subfs"; 1177 1177 - type Record = SubfsRecordRecord; 1178 1178 - } 1179 1179 - 1180 1180 - /// Marker type for deserializing records from this collection. 1181 1181 - #[derive(Debug, serde::Serialize, serde::Deserialize)] 1182 1182 - pub struct SubfsRecordRecord; 1183 1183 - impl jacquard_common::xrpc::XrpcResp for SubfsRecordRecord { 1184 1184 - const NSID: &'static str = "place.wisp.subfs"; 1185 1185 - const ENCODING: &'static str = "application/json"; 1186 1186 - type Output<'de> = SubfsRecordGetRecordOutput<'de>; 1187 1187 - type Err<'de> = jacquard_common::types::collection::RecordError<'de>; 1188 1188 - } 1189 1189 - 1190 1190 - impl jacquard_common::types::collection::Collection for SubfsRecordRecord { 1191 1191 - const NSID: &'static str = "place.wisp.subfs"; 1192 1192 - type Record = SubfsRecordRecord; 1193 1193 - } 1194 1194 - 1195 1195 - impl<'a> ::jacquard_lexicon::schema::LexiconSchema for SubfsRecord<'a> { 1196 1196 - fn nsid() -> &'static str { 1197 1197 - "place.wisp.subfs" 1198 1198 - } 1199 1199 - fn def_name() -> &'static str { 1200 1200 - "main" 1201 1201 - } 1202 1202 - fn lexicon_doc() -> ::jacquard_lexicon::lexicon::LexiconDoc<'static> { 1203 1203 - lexicon_doc_place_wisp_subfs() 1204 1204 - } 1205 1205 - fn validate( 1206 1206 - &self, 1207 1207 - ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 1208 1208 - if let Some(ref value) = self.file_count { 1209 1209 - if *value > 1000i64 { 1210 1210 - return Err(::jacquard_lexicon::validation::ConstraintError::Maximum { 1211 1211 - path: ::jacquard_lexicon::validation::ValidationPath::from_field( 1212 1212 - "file_count", 1213 1213 - ), 1214 1214 - max: 1000i64, 1215 1215 - actual: *value, 1216 1216 - }); 1217 1217 - } 1218 1218 - } 1219 1219 - if let Some(ref value) = self.file_count { 1220 1220 - if *value < 0i64 { 1221 1221 - return Err(::jacquard_lexicon::validation::ConstraintError::Minimum { 1222 1222 - path: ::jacquard_lexicon::validation::ValidationPath::from_field( 1223 1223 - "file_count", 1224 1224 - ), 1225 1225 - min: 0i64, 1226 1226 - actual: *value, 1227 1227 - }); 1228 1228 - } 1229 1229 - } 1230 1230 - Ok(()) 1231 1231 - } 1232 1232 - } 1233 1233 - 1234 1234 - #[jacquard_derive::lexicon] 1235 1235 - #[derive( 1236 1236 - serde::Serialize, 1237 1237 - serde::Deserialize, 1238 1238 - Debug, 1239 1239 - Clone, 1240 1240 - PartialEq, 1241 1241 - Eq, 1242 1242 - jacquard_derive::IntoStatic 1243 1243 - )] 1244 1244 - #[serde(rename_all = "camelCase")] 1245 1245 - pub struct Subfs<'a> { 1246 1246 - /// AT-URI pointing to another place.wisp.subfs record for nested subtrees. When expanded, the referenced record's root entries are merged (flattened) into the parent directory, allowing recursive splitting of large directory structures. 1247 1247 - #[serde(borrow)] 1248 1248 - pub subject: jacquard_common::types::string::AtUri<'a>, 1249 1249 - #[serde(borrow)] 1250 1250 - pub r#type: jacquard_common::CowStr<'a>, 1251 1251 - } 1252 1252 - 1253 1253 - pub mod subfs_state { 1254 1254 - 1255 1255 - pub use crate::builder_types::{Set, Unset, IsSet, IsUnset}; 1256 1256 - #[allow(unused)] 1257 1257 - use ::core::marker::PhantomData; 1258 1258 - mod sealed { 1259 1259 - pub trait Sealed {} 1260 1260 - } 1261 1261 - /// State trait tracking which required fields have been set 1262 1262 - pub trait State: sealed::Sealed { 1263 1263 - type Type; 1264 1264 - type Subject; 1265 1265 - } 1266 1266 - /// Empty state - all required fields are unset 1267 1267 - pub struct Empty(()); 1268 1268 - impl sealed::Sealed for Empty {} 1269 1269 - impl State for Empty { 1270 1270 - type Type = Unset; 1271 1271 - type Subject = Unset; 1272 1272 - } 1273 1273 - ///State transition - sets the `type` field to Set 1274 1274 - pub struct SetType<S: State = Empty>(PhantomData<fn() -> S>); 1275 1275 - impl<S: State> sealed::Sealed for SetType<S> {} 1276 1276 - impl<S: State> State for SetType<S> { 1277 1277 - type Type = Set<members::r#type>; 1278 1278 - type Subject = S::Subject; 1279 1279 - } 1280 1280 - ///State transition - sets the `subject` field to Set 1281 1281 - pub struct SetSubject<S: State = Empty>(PhantomData<fn() -> S>); 1282 1282 - impl<S: State> sealed::Sealed for SetSubject<S> {} 1283 1283 - impl<S: State> State for SetSubject<S> { 1284 1284 - type Type = S::Type; 1285 1285 - type Subject = Set<members::subject>; 1286 1286 - } 1287 1287 - /// Marker types for field names 1288 1288 - #[allow(non_camel_case_types)] 1289 1289 - pub mod members { 1290 1290 - ///Marker type for the `type` field 1291 1291 - pub struct r#type(()); 1292 1292 - ///Marker type for the `subject` field 1293 1293 - pub struct subject(()); 1294 1294 - } 1295 1295 - } 1296 1296 - 1297 1297 - /// Builder for constructing an instance of this type 1298 1298 - pub struct SubfsBuilder<'a, S: subfs_state::State> { 1299 1299 - _phantom_state: ::core::marker::PhantomData<fn() -> S>, 1300 1300 - __unsafe_private_named: ( 1301 1301 - ::core::option::Option<jacquard_common::types::string::AtUri<'a>>, 1302 1302 - ::core::option::Option<jacquard_common::CowStr<'a>>, 1303 1303 - ), 1304 1304 - _phantom: ::core::marker::PhantomData<&'a ()>, 1305 1305 - } 1306 1306 - 1307 1307 - impl<'a> Subfs<'a> { 1308 1308 - /// Create a new builder for this type 1309 1309 - pub fn new() -> SubfsBuilder<'a, subfs_state::Empty> { 1310 1310 - SubfsBuilder::new() 1311 1311 - } 1312 1312 - } 1313 1313 - 1314 1314 - impl<'a> SubfsBuilder<'a, subfs_state::Empty> { 1315 1315 - /// Create a new builder with all fields unset 1316 1316 - pub fn new() -> Self { 1317 1317 - SubfsBuilder { 1318 1318 - _phantom_state: ::core::marker::PhantomData, 1319 1319 - __unsafe_private_named: (None, None), 1320 1320 - _phantom: ::core::marker::PhantomData, 1321 1321 - } 1322 1322 - } 1323 1323 - } 1324 1324 - 1325 1325 - impl<'a, S> SubfsBuilder<'a, S> 1326 1326 - where 1327 1327 - S: subfs_state::State, 1328 1328 - S::Subject: subfs_state::IsUnset, 1329 1329 - { 1330 1330 - /// Set the `subject` field (required) 1331 1331 - pub fn subject( 1332 1332 - mut self, 1333 1333 - value: impl Into<jacquard_common::types::string::AtUri<'a>>, 1334 1334 - ) -> SubfsBuilder<'a, subfs_state::SetSubject<S>> { 1335 1335 - self.__unsafe_private_named.0 = ::core::option::Option::Some(value.into()); 1336 1336 - SubfsBuilder { 1337 1337 - _phantom_state: ::core::marker::PhantomData, 1338 1338 - __unsafe_private_named: self.__unsafe_private_named, 1339 1339 - _phantom: ::core::marker::PhantomData, 1340 1340 - } 1341 1341 - } 1342 1342 - } 1343 1343 - 1344 1344 - impl<'a, S> SubfsBuilder<'a, S> 1345 1345 - where 1346 1346 - S: subfs_state::State, 1347 1347 - S::Type: subfs_state::IsUnset, 1348 1348 - { 1349 1349 - /// Set the `type` field (required) 1350 1350 - pub fn r#type( 1351 1351 - mut self, 1352 1352 - value: impl Into<jacquard_common::CowStr<'a>>, 1353 1353 - ) -> SubfsBuilder<'a, subfs_state::SetType<S>> { 1354 1354 - self.__unsafe_private_named.1 = ::core::option::Option::Some(value.into()); 1355 1355 - SubfsBuilder { 1356 1356 - _phantom_state: ::core::marker::PhantomData, 1357 1357 - __unsafe_private_named: self.__unsafe_private_named, 1358 1358 - _phantom: ::core::marker::PhantomData, 1359 1359 - } 1360 1360 - } 1361 1361 - } 1362 1362 - 1363 1363 - impl<'a, S> SubfsBuilder<'a, S> 1364 1364 - where 1365 1365 - S: subfs_state::State, 1366 1366 - S::Type: subfs_state::IsSet, 1367 1367 - S::Subject: subfs_state::IsSet, 1368 1368 - { 1369 1369 - /// Build the final struct 1370 1370 - pub fn build(self) -> Subfs<'a> { 1371 1371 - Subfs { 1372 1372 - subject: self.__unsafe_private_named.0.unwrap(), 1373 1373 - r#type: self.__unsafe_private_named.1.unwrap(), 1374 1374 - extra_data: Default::default(), 1375 1375 - } 1376 1376 - } 1377 1377 - /// Build the final struct with custom extra_data 1378 1378 - pub fn build_with_data( 1379 1379 - self, 1380 1380 - extra_data: std::collections::BTreeMap< 1381 1381 - jacquard_common::smol_str::SmolStr, 1382 1382 - jacquard_common::types::value::Data<'a>, 1383 1383 - >, 1384 1384 - ) -> Subfs<'a> { 1385 1385 - Subfs { 1386 1386 - subject: self.__unsafe_private_named.0.unwrap(), 1387 1387 - r#type: self.__unsafe_private_named.1.unwrap(), 1388 1388 - extra_data: Some(extra_data), 1389 1389 - } 1390 1390 - } 1391 1391 - } 1392 1392 - 1393 1393 - impl<'a> ::jacquard_lexicon::schema::LexiconSchema for Subfs<'a> { 1394 1394 - fn nsid() -> &'static str { 1395 1395 - "place.wisp.subfs" 1396 1396 - } 1397 1397 - fn def_name() -> &'static str { 1398 1398 - "subfs" 1399 1399 - } 1400 1400 - fn lexicon_doc() -> ::jacquard_lexicon::lexicon::LexiconDoc<'static> { 1401 1401 - lexicon_doc_place_wisp_subfs() 1402 1402 - } 1403 1403 - fn validate( 1404 1404 - &self, 1405 1405 - ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> { 1406 1406 - Ok(()) 1407 1407 - } 1408 1408 - }

-8

cli/src/place_wisp.rs

··· 1 1 - // @generated by jacquard-lexicon. DO NOT EDIT. 2 2 - // 3 3 - // This file was automatically generated from Lexicon schemas. 4 4 - // Any manual changes will be overwritten on the next regeneration. 5 5 - 6 6 - pub mod fs; 7 7 - pub mod settings; 8 8 - pub mod subfs;

+12 -12

cli/src/pull.rs

··· 1 1 use crate::blob_map; 2 2 use crate::download; 3 3 use crate::metadata::SiteMetadata; 4 4 - use crate::place_wisp::fs::*; 4 4 + use wisp_lexicons::place_wisp::fs::*; 5 5 use crate::subfs_utils; 6 6 use jacquard::CowStr; 7 7 use jacquard::prelude::IdentityResolver; ··· 410 410 ) -> miette::Result<Directory<'static>> { 411 411 use jacquard_common::IntoStatic; 412 412 use jacquard_common::types::value::from_data; 413 413 - use crate::place_wisp::subfs::SubfsRecord; 413 413 + use wisp_lexicons::place_wisp::subfs::SubfsRecord; 414 414 415 415 - let mut all_subfs_map: HashMap<String, crate::place_wisp::subfs::Directory> = HashMap::new(); 415 415 + let mut all_subfs_map: HashMap<String, wisp_lexicons::place_wisp::subfs::Directory> = HashMap::new(); 416 416 let mut to_fetch = subfs_utils::extract_subfs_uris(directory, String::new()); 417 417 418 418 if to_fetch.is_empty() { ··· 516 516 517 517 /// Extract subfs URIs from a subfs::Directory (helper for pull) 518 518 fn extract_subfs_uris_from_subfs_dir( 519 519 - directory: &crate::place_wisp::subfs::Directory, 519 519 + directory: &wisp_lexicons::place_wisp::subfs::Directory, 520 520 current_path: String, 521 521 ) -> Vec<(String, String)> { 522 522 let mut uris = Vec::new(); ··· 529 529 }; 530 530 531 531 match &entry.node { 532 532 - crate::place_wisp::subfs::EntryNode::Subfs(subfs_node) => { 532 532 + wisp_lexicons::place_wisp::subfs::EntryNode::Subfs(subfs_node) => { 533 533 uris.push((subfs_node.subject.to_string(), full_path.clone())); 534 534 } 535 535 - crate::place_wisp::subfs::EntryNode::Directory(subdir) => { 535 535 + wisp_lexicons::place_wisp::subfs::EntryNode::Directory(subdir) => { 536 536 let nested = extract_subfs_uris_from_subfs_dir(subdir, full_path); 537 537 uris.extend(nested); 538 538 } ··· 546 546 /// Recursively replace subfs nodes with their actual content 547 547 fn replace_subfs_with_content( 548 548 directory: Directory, 549 549 - subfs_map: &HashMap<String, crate::place_wisp::subfs::Directory>, 549 549 + subfs_map: &HashMap<String, wisp_lexicons::place_wisp::subfs::Directory>, 550 550 current_path: String, 551 551 ) -> Directory<'static> { 552 552 use jacquard_common::IntoStatic; ··· 628 628 } 629 629 630 630 /// Convert a subfs entry to a fs entry (they have the same structure but different types) 631 631 - fn convert_subfs_entry_to_fs(subfs_entry: crate::place_wisp::subfs::Entry<'static>) -> Entry<'static> { 631 631 + fn convert_subfs_entry_to_fs(subfs_entry: wisp_lexicons::place_wisp::subfs::Entry<'static>) -> Entry<'static> { 632 632 use jacquard_common::IntoStatic; 633 633 634 634 let node = match subfs_entry.node { 635 635 - crate::place_wisp::subfs::EntryNode::File(file) => { 635 635 + wisp_lexicons::place_wisp::subfs::EntryNode::File(file) => { 636 636 EntryNode::File(Box::new( 637 637 File::new() 638 638 .r#type(file.r#type.into_static()) ··· 643 643 .build() 644 644 )) 645 645 } 646 646 - crate::place_wisp::subfs::EntryNode::Directory(dir) => { 646 646 + wisp_lexicons::place_wisp::subfs::EntryNode::Directory(dir) => { 647 647 let converted_entries: Vec<Entry<'static>> = dir 648 648 .entries 649 649 .into_iter() ··· 657 657 .build() 658 658 )) 659 659 } 660 660 - crate::place_wisp::subfs::EntryNode::Subfs(_nested_subfs) => { 660 660 + wisp_lexicons::place_wisp::subfs::EntryNode::Subfs(_nested_subfs) => { 661 661 // Nested subfs should have been expanded already - if we get here, it means expansion failed 662 662 // Treat it like a directory reference that should have been expanded 663 663 eprintln!(" ⚠️ Warning: unexpanded nested subfs at path, treating as empty directory"); ··· 668 668 .build() 669 669 )) 670 670 } 671 671 - crate::place_wisp::subfs::EntryNode::Unknown(unknown) => { 671 671 + wisp_lexicons::place_wisp::subfs::EntryNode::Unknown(unknown) => { 672 672 EntryNode::Unknown(unknown) 673 673 } 674 674 };

+1 -1

cli/src/serve.rs

··· 1 1 use crate::pull::pull_site; 2 2 use crate::redirects::{load_redirect_rules, match_redirect_rule, RedirectRule}; 3 3 - use crate::place_wisp::settings::Settings; 3 3 + use wisp_lexicons::place_wisp::settings::Settings; 4 4 use axum::{ 5 5 Router, 6 6 extract::Request,

+14 -14

cli/src/subfs_utils.rs

··· 6 6 use miette::IntoDiagnostic; 7 7 use std::collections::HashMap; 8 8 9 9 - use crate::place_wisp::fs::{Directory as FsDirectory, EntryNode as FsEntryNode}; 10 10 - use crate::place_wisp::subfs::SubfsRecord; 9 9 + use wisp_lexicons::place_wisp::fs::{Directory as FsDirectory, EntryNode as FsEntryNode}; 10 10 + use wisp_lexicons::place_wisp::subfs::SubfsRecord; 11 11 12 12 /// Extract all subfs URIs from a directory tree with their mount paths 13 13 pub fn extract_subfs_uris(directory: &FsDirectory, current_path: String) -> Vec<(String, String)> { ··· 145 145 146 146 /// Extract subfs URIs from a subfs::Directory 147 147 fn extract_subfs_uris_from_subfs_dir( 148 148 - directory: &crate::place_wisp::subfs::Directory, 148 148 + directory: &wisp_lexicons::place_wisp::subfs::Directory, 149 149 current_path: String, 150 150 ) -> Vec<(String, String)> { 151 151 let mut uris = Vec::new(); 152 152 153 153 for entry in &directory.entries { 154 154 match &entry.node { 155 155 - crate::place_wisp::subfs::EntryNode::Subfs(subfs_node) => { 155 155 + wisp_lexicons::place_wisp::subfs::EntryNode::Subfs(subfs_node) => { 156 156 // Check if this is a chunk entry (chunk0, chunk1, etc.) 157 157 // Chunks should be flat-merged, so use the parent's path 158 158 let mount_path = if entry.name.starts_with("chunk") && ··· 171 171 172 172 uris.push((subfs_node.subject.to_string(), mount_path)); 173 173 } 174 174 - crate::place_wisp::subfs::EntryNode::Directory(subdir) => { 174 174 + wisp_lexicons::place_wisp::subfs::EntryNode::Directory(subdir) => { 175 175 let full_path = if current_path.is_empty() { 176 176 entry.name.to_string() 177 177 } else { ··· 204 204 for (mount_path, subfs_record) in all_subfs { 205 205 // Check if this record only contains chunk subfs references (no files) 206 206 let only_has_chunks = subfs_record.root.entries.iter().all(|e| { 207 207 - matches!(&e.node, crate::place_wisp::subfs::EntryNode::Subfs(_)) && 207 207 + matches!(&e.node, wisp_lexicons::place_wisp::subfs::EntryNode::Subfs(_)) && 208 208 e.name.starts_with("chunk") && 209 209 e.name.chars().skip(5).all(|c| c.is_ascii_digit()) 210 210 }); ··· 232 232 /// Extract blobs from a subfs directory (works with subfs::Directory) 233 233 /// Returns a map of file paths to their blob refs and CIDs 234 234 fn extract_subfs_blobs( 235 235 - directory: &crate::place_wisp::subfs::Directory, 235 235 + directory: &wisp_lexicons::place_wisp::subfs::Directory, 236 236 current_path: String, 237 237 ) -> HashMap<String, (BlobRef<'static>, String)> { 238 238 let mut blob_map = HashMap::new(); ··· 245 245 }; 246 246 247 247 match &entry.node { 248 248 - crate::place_wisp::subfs::EntryNode::File(file_node) => { 248 248 + wisp_lexicons::place_wisp::subfs::EntryNode::File(file_node) => { 249 249 let blob_ref = &file_node.blob; 250 250 let cid_string = blob_ref.blob().r#ref.to_string(); 251 251 blob_map.insert( ··· 253 253 (blob_ref.clone().into_static(), cid_string) 254 254 ); 255 255 } 256 256 - crate::place_wisp::subfs::EntryNode::Directory(subdir) => { 256 256 + wisp_lexicons::place_wisp::subfs::EntryNode::Directory(subdir) => { 257 257 let sub_map = extract_subfs_blobs(subdir, full_path); 258 258 blob_map.extend(sub_map); 259 259 } 260 260 - crate::place_wisp::subfs::EntryNode::Subfs(_nested_subfs) => { 260 260 + wisp_lexicons::place_wisp::subfs::EntryNode::Subfs(_nested_subfs) => { 261 261 // Nested subfs - these should be resolved recursively in the main flow 262 262 // For now, we skip them (they'll be fetched separately) 263 263 eprintln!(" ⚠️ Found nested subfs at {}, skipping (should be fetched separately)", full_path); 264 264 } 265 265 - crate::place_wisp::subfs::EntryNode::Unknown(_) => { 265 265 + wisp_lexicons::place_wisp::subfs::EntryNode::Unknown(_) => { 266 266 // Skip unknown nodes 267 267 } 268 268 } ··· 352 352 flat: bool, 353 353 ) -> miette::Result<FsDirectory<'static>> { 354 354 use jacquard_common::CowStr; 355 355 - use crate::place_wisp::fs::{Entry, Subfs}; 355 355 + use wisp_lexicons::place_wisp::fs::{Entry, Subfs}; 356 356 357 357 let path_parts: Vec<&str> = target_path.split('/').collect(); 358 358 ··· 430 430 431 431 // Construct AT-URI and convert to RecordUri 432 432 let at_uri = AtUri::new(uri).into_diagnostic()?; 433 433 - let record_uri: RecordUri<'_, crate::place_wisp::subfs::SubfsRecordRecord> = RecordUri::try_from_uri(at_uri).into_diagnostic()?; 433 433 + let record_uri: RecordUri<'_, wisp_lexicons::place_wisp::subfs::SubfsRecordRecord> = RecordUri::try_from_uri(at_uri).into_diagnostic()?; 434 434 435 435 let rkey = record_uri.rkey() 436 436 .ok_or_else(|| miette::miette!("Invalid subfs URI: missing rkey"))? ··· 489 489 } 490 490 491 491 /// Estimate the JSON size of a single entry 492 492 - fn estimate_entry_size(entry: &crate::place_wisp::fs::Entry) -> usize { 492 492 + fn estimate_entry_size(entry: &wisp_lexicons::place_wisp::fs::Entry) -> usize { 493 493 match serde_json::to_string(entry) { 494 494 Ok(json) => json.len(), 495 495 Err(_) => 500, // Conservative estimate if serialization fails

+21

docker-compose.yml

··· 1 1 + services: 2 2 + postgres: 3 3 + image: postgres:16-alpine 4 4 + container_name: wisp-postgres 5 5 + restart: unless-stopped 6 6 + environment: 7 7 + POSTGRES_USER: postgres 8 8 + POSTGRES_PASSWORD: postgres 9 9 + POSTGRES_DB: wisp 10 10 + ports: 11 11 + - "5432:5432" 12 12 + volumes: 13 13 + - postgres_data:/var/lib/postgresql/data 14 14 + healthcheck: 15 15 + test: ["CMD-SHELL", "pg_isready -U postgres"] 16 16 + interval: 5s 17 17 + timeout: 5s 18 18 + retries: 5 19 19 + 20 20 + volumes: 21 21 + postgres_data:

+3 -1

docs/astro.config.mjs

··· 7 7 integrations: [ 8 8 starlight({ 9 9 title: 'Wisp.place Docs', 10 10 - social: [{ icon: 'github', label: 'GitHub', href: 'https://github.com/tangled-org/wisp.place' }], 10 10 + components: { 11 11 + SocialIcons: './src/components/SocialIcons.astro', 12 12 + }, 11 13 sidebar: [ 12 14 { 13 15 label: 'Getting Started',

+9

docs/src/assets/tangled-icon.svg

··· 1 1 + <svg xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape" xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd" xmlns="http://www.w3.org/2000/svg" xmlns:svg="http://www.w3.org/2000/svg" version="1.1" id="svg1" width="25" height="25" viewBox="0 0 25 25" sodipodi:docname="tangled_dolly_silhouette.png"> 2 2 + <defs id="defs1"/> 3 3 + <sodipodi:namedview id="namedview1" pagecolor="#ffffff" bordercolor="#000000" borderopacity="0.25" inkscape:showpageshadow="2" inkscape:pageopacity="0.0" inkscape:pagecheckerboard="true" inkscape:deskcolor="#d1d1d1"> 4 4 + <inkscape:page x="0" y="0" width="25" height="25" id="page2" margin="0" bleed="0"/> 5 5 + </sodipodi:namedview> 6 6 + <g inkscape:groupmode="layer" inkscape:label="Image" id="g1"> 7 7 + <path style="fill:#000000;stroke-width:1.12248" d="m 16.208435,23.914069 c -0.06147,-0.02273 -0.147027,-0.03034 -0.190158,-0.01691 -0.197279,0.06145 -1.31068,-0.230493 -1.388819,-0.364153 -0.01956,-0.03344 -0.163274,-0.134049 -0.319377,-0.223561 -0.550395,-0.315603 -1.010951,-0.696643 -1.428383,-1.181771 -0.264598,-0.307509 -0.597257,-0.785384 -0.597257,-0.857979 0,-0.0216 -0.02841,-0.06243 -0.06313,-0.0907 -0.04977,-0.04053 -0.160873,0.0436 -0.52488,0.397463 -0.479803,0.466432 -0.78924,0.689475 -1.355603,0.977118 -0.183693,0.0933 -0.323426,0.179989 -0.310516,0.192658 0.02801,0.02748 -0.7656391,0.270031 -1.209129,0.369517 -0.5378332,0.120647 -1.6341809,0.08626 -1.9721503,-0.06186 C 6.7977157,23.031391 6.56735,22.957551 6.3371134,22.889782 4.9717169,22.487902 3.7511914,21.481518 3.1172396,20.234838 2.6890391,19.392772 2.5582276,18.827446 2.5610489,17.831154 2.5639589,16.802192 2.7366641,16.125844 3.2142117,15.273187 3.3040457,15.112788 3.3713143,14.976533 3.3636956,14.9704 3.3560756,14.9643 3.2459634,14.90305 3.1189994,14.834381 1.7582586,14.098312 0.77760984,12.777439 0.44909837,11.23818 0.33531456,10.705039 0.33670119,9.7067968 0.45195381,9.1778795 0.72259241,7.9359287 1.3827188,6.8888436 2.4297498,6.0407205 2.6856126,5.8334648 3.2975489,5.4910878 3.6885849,5.3364049 L 4.0584319,5.190106 4.2333984,4.860432 C 4.8393906,3.7186139 5.8908314,2.7968028 7.1056396,2.3423025 7.7690673,2.0940921 8.2290216,2.0150935 9.01853,2.0137575 c 0.9625627,-0.00163 1.629181,0.1532762 2.485864,0.5776514 l 0.271744,0.1346134 0.42911,-0.3607688 c 1.082666,-0.9102346 2.185531,-1.3136811 3.578383,-1.3090327 0.916696,0.00306 1.573918,0.1517893 2.356121,0.5331927 1.465948,0.7148 2.54506,2.0625628 2.865177,3.57848 l 0.07653,0.362429 0.515095,0.2556611 c 1.022872,0.5076874 1.756122,1.1690944 2.288361,2.0641468 0.401896,0.6758594 0.537303,1.0442682 0.675505,1.8378683 0.288575,1.6570823 -0.266229,3.3548023 -1.490464,4.5608743 -0.371074,0.36557 -0.840205,0.718265 -1.203442,0.904754 -0.144112,0.07398 -0.271303,0.15826 -0.282647,0.187269 -0.01134,0.02901 0.02121,0.142764 0.07234,0.25279 0.184248,0.396467 0.451371,1.331823 0.619371,2.168779 0.463493,2.30908 -0.754646,4.693707 -2.92278,5.721632 -0.479538,0.227352 -0.717629,0.309322 -1.144194,0.39393 -0.321869,0.06383 -1.850573,0.09139 -2.000174,0.03604 z M 12.25443,18.636956 c 0.739923,-0.24652 1.382521,-0.718922 1.874623,-1.37812 0.0752,-0.100718 0.213883,-0.275851 0.308198,-0.389167 0.09432,-0.113318 0.210136,-0.271056 0.257381,-0.350531 0.416347,-0.700389 0.680936,-1.176102 0.766454,-1.378041 0.05594,-0.132087 0.114653,-0.239607 0.130477,-0.238929 0.01583,6.79e-4 0.08126,0.08531 0.145412,0.188069 0.178029,0.285173 0.614305,0.658998 0.868158,0.743878 0.259802,0.08686 0.656158,0.09598 0.911369,0.02095 0.213812,-0.06285 0.507296,-0.298016 0.645179,-0.516947 0.155165,-0.246374 0.327989,-0.989595 0.327989,-1.410501 0,-1.26718 -0.610975,-3.143405 -1.237774,-3.801045 -0.198483,-0.2082486 -0.208557,-0.2319396 -0.208557,-0.4904655 0,-0.2517771 -0.08774,-0.5704927 -0.258476,-0.938956 C 16.694963,8.50313 16.375697,8.1377479 16.135846,7.9543702 L 15.932296,7.7987471 15.683004,7.9356529 C 15.131767,8.2383821 14.435638,8.1945733 13.943459,7.8261812 L 13.782862,7.7059758 13.686773,7.8908012 C 13.338849,8.5600578 12.487087,8.8811064 11.743178,8.6233891 11.487199,8.5347109 11.358897,8.4505994 11.063189,8.1776138 L 10.69871,7.8411436 10.453484,8.0579255 C 10.318608,8.1771557 10.113778,8.3156283 9.9983037,8.3656417 9.7041488,8.4930449 9.1808299,8.5227884 8.8979004,8.4281886 8.7754792,8.3872574 8.6687415,8.3537661 8.6607053,8.3537661 c -0.03426,0 -0.3092864,0.3066098 -0.3791974,0.42275 -0.041935,0.069664 -0.1040482,0.1266636 -0.1380294,0.1266636 -0.1316419,0 -0.4197402,0.1843928 -0.6257041,0.4004735 -0.1923125,0.2017571 -0.6853701,0.9036038 -0.8926582,1.2706578 -0.042662,0.07554 -0.1803555,0.353687 -0.3059848,0.618091 -0.1256293,0.264406 -0.3270073,0.686768 -0.4475067,0.938581 -0.1204992,0.251816 -0.2469926,0.519654 -0.2810961,0.595199 -0.2592829,0.574347 -0.285919,1.391094 -0.057822,1.77304 0.1690683,0.283105 0.4224039,0.480895 0.7285507,0.568809 0.487122,0.139885 0.9109638,-0.004 1.6013422,-0.543768 l 0.4560939,-0.356568 0.0036,0.172041 c 0.01635,0.781837 0.1831084,1.813183 0.4016641,2.484154 0.1160449,0.356262 0.3781448,0.83968 0.5614081,1.035462 0.2171883,0.232025 0.7140951,0.577268 1.0100284,0.701749 0.121485,0.0511 0.351032,0.110795 0.510105,0.132647 0.396966,0.05452 1.2105,0.02265 1.448934,-0.05679 z" id="path1"/> 8 8 + </g> 9 9 + </svg>

+26

docs/src/components/SocialIcons.astro

··· 1 1 + --- 2 2 + // Custom social icons component to use the Tangled icon 3 3 + --- 4 4 + 5 5 + <div class="sl-flex"> 6 6 + <a 7 7 + href="https://tangled.org/nekomimi.pet/wisp.place-monorepo" 8 8 + rel="me" 9 9 + class="sl-flex" 10 10 + aria-label="Tangled" 11 11 + > 12 12 + <svg 13 13 + xmlns="http://www.w3.org/2000/svg" 14 14 + viewBox="0 0 25 25" 15 15 + width="16" 16 16 + height="16" 17 17 + aria-hidden="true" 18 18 + focusable="false" 19 19 + > 20 20 + <path 21 21 + style="fill:currentColor;stroke-width:1.12248" 22 22 + d="m 16.208435,23.914069 c -0.06147,-0.02273 -0.147027,-0.03034 -0.190158,-0.01691 -0.197279,0.06145 -1.31068,-0.230493 -1.388819,-0.364153 -0.01956,-0.03344 -0.163274,-0.134049 -0.319377,-0.223561 -0.550395,-0.315603 -1.010951,-0.696643 -1.428383,-1.181771 -0.264598,-0.307509 -0.597257,-0.785384 -0.597257,-0.857979 0,-0.0216 -0.02841,-0.06243 -0.06313,-0.0907 -0.04977,-0.04053 -0.160873,0.0436 -0.52488,0.397463 -0.479803,0.466432 -0.78924,0.689475 -1.355603,0.977118 -0.183693,0.0933 -0.323426,0.179989 -0.310516,0.192658 0.02801,0.02748 -0.7656391,0.270031 -1.209129,0.369517 -0.5378332,0.120647 -1.6341809,0.08626 -1.9721503,-0.06186 C 6.7977157,23.031391 6.56735,22.957551 6.3371134,22.889782 4.9717169,22.487902 3.7511914,21.481518 3.1172396,20.234838 2.6890391,19.392772 2.5582276,18.827446 2.5610489,17.831154 2.5639589,16.802192 2.7366641,16.125844 3.2142117,15.273187 3.3040457,15.112788 3.3713143,14.976533 3.3636956,14.9704 3.3560756,14.9643 3.2459634,14.90305 3.1189994,14.834381 1.7582586,14.098312 0.77760984,12.777439 0.44909837,11.23818 0.33531456,10.705039 0.33670119,9.7067968 0.45195381,9.1778795 0.72259241,7.9359287 1.3827188,6.8888436 2.4297498,6.0407205 2.6856126,5.8334648 3.2975489,5.4910878 3.6885849,5.3364049 L 4.0584319,5.190106 4.2333984,4.860432 C 4.8393906,3.7186139 5.8908314,2.7968028 7.1056396,2.3423025 7.7690673,2.0940921 8.2290216,2.0150935 9.01853,2.0137575 c 0.9625627,-0.00163 1.629181,0.1532762 2.485864,0.5776514 l 0.271744,0.1346134 0.42911,-0.3607688 c 1.082666,-0.9102346 2.185531,-1.3136811 3.578383,-1.3090327 0.916696,0.00306 1.573918,0.1517893 2.356121,0.5331927 1.465948,0.7148 2.54506,2.0625628 2.865177,3.57848 l 0.07653,0.362429 0.515095,0.2556611 c 1.022872,0.5076874 1.756122,1.1690944 2.288361,2.0641468 0.401896,0.6758594 0.537303,1.0442682 0.675505,1.8378683 0.288575,1.6570823 -0.266229,3.3548023 -1.490464,4.5608743 -0.371074,0.36557 -0.840205,0.718265 -1.203442,0.904754 -0.144112,0.07398 -0.271303,0.15826 -0.282647,0.187269 -0.01134,0.02901 0.02121,0.142764 0.07234,0.25279 0.184248,0.396467 0.451371,1.331823 0.619371,2.168779 0.463493,2.30908 -0.754646,4.693707 -2.92278,5.721632 -0.479538,0.227352 -0.717629,0.309322 -1.144194,0.39393 -0.321869,0.06383 -1.850573,0.09139 -2.000174,0.03604 z M 12.25443,18.636956 c 0.739923,-0.24652 1.382521,-0.718922 1.874623,-1.37812 0.0752,-0.100718 0.213883,-0.275851 0.308198,-0.389167 0.09432,-0.113318 0.210136,-0.271056 0.257381,-0.350531 0.416347,-0.700389 0.680936,-1.176102 0.766454,-1.378041 0.05594,-0.132087 0.114653,-0.239607 0.130477,-0.238929 0.01583,6.79e-4 0.08126,0.08531 0.145412,0.188069 0.178029,0.285173 0.614305,0.658998 0.868158,0.743878 0.259802,0.08686 0.656158,0.09598 0.911369,0.02095 0.213812,-0.06285 0.507296,-0.298016 0.645179,-0.516947 0.155165,-0.246374 0.327989,-0.989595 0.327989,-1.410501 0,-1.26718 -0.610975,-3.143405 -1.237774,-3.801045 -0.198483,-0.2082486 -0.208557,-0.2319396 -0.208557,-0.4904655 0,-0.2517771 -0.08774,-0.5704927 -0.258476,-0.938956 C 16.694963,8.50313 16.375697,8.1377479 16.135846,7.9543702 L 15.932296,7.7987471 15.683004,7.9356529 C 15.131767,8.2383821 14.435638,8.1945733 13.943459,7.8261812 L 13.782862,7.7059758 13.686773,7.8908012 C 13.338849,8.5600578 12.487087,8.8811064 11.743178,8.6233891 11.487199,8.5347109 11.358897,8.4505994 11.063189,8.1776138 L 10.69871,7.8411436 10.453484,8.0579255 C 10.318608,8.1771557 10.113778,8.3156283 9.9983037,8.3656417 9.7041488,8.4930449 9.1808299,8.5227884 8.8979004,8.4281886 8.7754792,8.3872574 8.6687415,8.3537661 8.6607053,8.3537661 c -0.03426,0 -0.3092864,0.3066098 -0.3791974,0.42275 -0.041935,0.069664 -0.1040482,0.1266636 -0.1380294,0.1266636 -0.1316419,0 -0.4197402,0.1843928 -0.6257041,0.4004735 -0.1923125,0.2017571 -0.6853701,0.9036038 -0.8926582,1.2706578 -0.042662,0.07554 -0.1803555,0.353687 -0.3059848,0.618091 -0.1256293,0.264406 -0.3270073,0.686768 -0.4475067,0.938581 -0.1204992,0.251816 -0.2469926,0.519654 -0.2810961,0.595199 -0.2592829,0.574347 -0.285919,1.391094 -0.057822,1.77304 0.1690683,0.283105 0.4224039,0.480895 0.7285507,0.568809 0.487122,0.139885 0.9109638,-0.004 1.6013422,-0.543768 l 0.4560939,-0.356568 0.0036,0.172041 c 0.01635,0.781837 0.1831084,1.813183 0.4016641,2.484154 0.1160449,0.356262 0.3781448,0.83968 0.5614081,1.035462 0.2171883,0.232025 0.7140951,0.577268 1.0100284,0.701749 0.121485,0.0511 0.351032,0.110795 0.510105,0.132647 0.396966,0.05452 1.2105,0.02265 1.448934,-0.05679 z" 23 23 + ></path> 24 24 + </svg> 25 25 + </a> 26 26 + </div>

+6 -11

docs/src/content/docs/cli.md

··· 71 71 72 72 engine: 'nixery' 73 73 74 74 - clone: 75 75 - skip: false 76 76 - depth: 1 77 77 - submodules: false 78 78 - 79 74 dependencies: 80 75 nixpkgs: 81 76 - nodejs ··· 141 136 # Pull a site to a specific directory 142 137 wisp-cli pull your-handle.bsky.social \ 143 138 --site my-site \ 144 144 - --output ./my-site 139 139 + --path ./my-site 145 140 146 141 # Pull to current directory 147 142 wisp-cli pull your-handle.bsky.social \ ··· 238 233 ### Pull Command 239 234 240 235 ```bash 241 241 - wisp-cli pull [OPTIONS] <INPUT> 236 236 + wisp-cli pull [OPTIONS] --site <SITE> <INPUT> 242 237 243 238 Arguments: 244 239 <INPUT> Handle or DID 245 240 246 241 Options: 247 242 -s, --site <SITE> Site name to download 248 248 - -o, --output <OUTPUT> Output directory [default: .] 243 243 + -p, --path <PATH> Output directory [default: .] 249 244 -h, --help Print help 250 245 ``` 251 246 252 247 ### Serve Command 253 248 254 249 ```bash 255 255 - wisp-cli serve [OPTIONS] <INPUT> 250 250 + wisp-cli serve [OPTIONS] --site <SITE> <INPUT> 256 251 257 252 Arguments: 258 253 <INPUT> Handle or DID 259 254 260 255 Options: 261 256 -s, --site <SITE> Site name to serve 262 262 - -o, --output <OUTPUT> Site files directory [default: .] 263 263 - -p, --port <PORT> Port to serve on [default: 8080] 257 257 + -p, --path <PATH> Site files directory [default: .] 258 258 + -P, --port <PORT> Port to serve on [default: 8080] 264 259 --spa Enable SPA mode (serve index.html for all routes) 265 260 --directory Enable directory listing mode for paths without index files 266 261 -h, --help Print help

+15 -15

docs/src/styles/custom.css

··· 5 5 /* Increase base font size by 10% */ 6 6 font-size: 110%; 7 7 8 8 - /* Light theme - Warm beige background from app */ 9 9 - --sl-color-bg: oklch(0.90 0.012 35); 10 10 - --sl-color-bg-sidebar: oklch(0.93 0.01 35); 11 11 - --sl-color-bg-nav: oklch(0.93 0.01 35); 12 12 - --sl-color-text: oklch(0.18 0.01 30); 13 13 - --sl-color-text-accent: oklch(0.78 0.15 345); 14 14 - --sl-color-accent: oklch(0.78 0.15 345); 15 15 - --sl-color-accent-low: oklch(0.95 0.03 345); 16 16 - --sl-color-border: oklch(0.75 0.015 30); 17 17 - --sl-color-gray-1: oklch(0.52 0.015 30); 18 18 - --sl-color-gray-2: oklch(0.42 0.015 30); 19 19 - --sl-color-gray-3: oklch(0.33 0.015 30); 20 20 - --sl-color-gray-4: oklch(0.25 0.015 30); 21 21 - --sl-color-gray-5: oklch(0.75 0.015 30); 8 8 + /* Light theme - Warm beige with improved contrast */ 9 9 + --sl-color-bg: oklch(0.92 0.012 35); 10 10 + --sl-color-bg-sidebar: oklch(0.95 0.008 35); 11 11 + --sl-color-bg-nav: oklch(0.95 0.008 35); 12 12 + --sl-color-text: oklch(0.15 0.015 30); 13 13 + --sl-color-text-accent: oklch(0.65 0.18 345); 14 14 + --sl-color-accent: oklch(0.65 0.18 345); 15 15 + --sl-color-accent-low: oklch(0.92 0.05 345); 16 16 + --sl-color-border: oklch(0.65 0.02 30); 17 17 + --sl-color-gray-1: oklch(0.45 0.02 30); 18 18 + --sl-color-gray-2: oklch(0.35 0.02 30); 19 19 + --sl-color-gray-3: oklch(0.28 0.02 30); 20 20 + --sl-color-gray-4: oklch(0.20 0.015 30); 21 21 + --sl-color-gray-5: oklch(0.65 0.02 30); 22 22 --sl-color-bg-accent: oklch(0.88 0.01 35); 23 23 } 24 24 ··· 70 70 /* Sidebar active/hover state text contrast fix */ 71 71 .sidebar a[aria-current="page"], 72 72 .sidebar a[aria-current="page"] span { 73 73 - color: oklch(0.23 0.015 285) !important; 73 73 + color: oklch(0.15 0.015 30) !important; 74 74 } 75 75 76 76 [data-theme="dark"] .sidebar a[aria-current="page"],

-318

flake.lock

··· 1 1 - { 2 2 - "nodes": { 3 3 - "crane": { 4 4 - "flake": false, 5 5 - "locked": { 6 6 - "lastModified": 1758758545, 7 7 - "narHash": "sha256-NU5WaEdfwF6i8faJ2Yh+jcK9vVFrofLcwlD/mP65JrI=", 8 8 - "owner": "ipetkov", 9 9 - "repo": "crane", 10 10 - "rev": "95d528a5f54eaba0d12102249ce42f4d01f4e364", 11 11 - "type": "github" 12 12 - }, 13 13 - "original": { 14 14 - "owner": "ipetkov", 15 15 - "ref": "v0.21.1", 16 16 - "repo": "crane", 17 17 - "type": "github" 18 18 - } 19 19 - }, 20 20 - "dream2nix": { 21 21 - "inputs": { 22 22 - "nixpkgs": [ 23 23 - "nci", 24 24 - "nixpkgs" 25 25 - ], 26 26 - "purescript-overlay": "purescript-overlay", 27 27 - "pyproject-nix": "pyproject-nix" 28 28 - }, 29 29 - "locked": { 30 30 - "lastModified": 1754978539, 31 31 - "narHash": "sha256-nrDovydywSKRbWim9Ynmgj8SBm8LK3DI2WuhIqzOHYI=", 32 32 - "owner": "nix-community", 33 33 - "repo": "dream2nix", 34 34 - "rev": "fbec3263cb4895ac86ee9506cdc4e6919a1a2214", 35 35 - "type": "github" 36 36 - }, 37 37 - "original": { 38 38 - "owner": "nix-community", 39 39 - "repo": "dream2nix", 40 40 - "type": "github" 41 41 - } 42 42 - }, 43 43 - "fenix": { 44 44 - "inputs": { 45 45 - "nixpkgs": [ 46 46 - "nixpkgs" 47 47 - ], 48 48 - "rust-analyzer-src": "rust-analyzer-src" 49 49 - }, 50 50 - "locked": { 51 51 - "lastModified": 1762584108, 52 52 - "narHash": "sha256-wZUW7dlXMXaRdvNbaADqhF8gg9bAfFiMV+iyFQiDv+Y=", 53 53 - "owner": "nix-community", 54 54 - "repo": "fenix", 55 55 - "rev": "32f3ad3b6c690061173e1ac16708874975ec6056", 56 56 - "type": "github" 57 57 - }, 58 58 - "original": { 59 59 - "owner": "nix-community", 60 60 - "repo": "fenix", 61 61 - "type": "github" 62 62 - } 63 63 - }, 64 64 - "flake-compat": { 65 65 - "flake": false, 66 66 - "locked": { 67 67 - "lastModified": 1696426674, 68 68 - "narHash": "sha256-kvjfFW7WAETZlt09AgDn1MrtKzP7t90Vf7vypd3OL1U=", 69 69 - "owner": "edolstra", 70 70 - "repo": "flake-compat", 71 71 - "rev": "0f9255e01c2351cc7d116c072cb317785dd33b33", 72 72 - "type": "github" 73 73 - }, 74 74 - "original": { 75 75 - "owner": "edolstra", 76 76 - "repo": "flake-compat", 77 77 - "type": "github" 78 78 - } 79 79 - }, 80 80 - "mk-naked-shell": { 81 81 - "flake": false, 82 82 - "locked": { 83 83 - "lastModified": 1681286841, 84 84 - "narHash": "sha256-3XlJrwlR0nBiREnuogoa5i1b4+w/XPe0z8bbrJASw0g=", 85 85 - "owner": "90-008", 86 86 - "repo": "mk-naked-shell", 87 87 - "rev": "7612f828dd6f22b7fb332cc69440e839d7ffe6bd", 88 88 - "type": "github" 89 89 - }, 90 90 - "original": { 91 91 - "owner": "90-008", 92 92 - "repo": "mk-naked-shell", 93 93 - "type": "github" 94 94 - } 95 95 - }, 96 96 - "nci": { 97 97 - "inputs": { 98 98 - "crane": "crane", 99 99 - "dream2nix": "dream2nix", 100 100 - "mk-naked-shell": "mk-naked-shell", 101 101 - "nixpkgs": [ 102 102 - "nixpkgs" 103 103 - ], 104 104 - "parts": "parts", 105 105 - "rust-overlay": "rust-overlay", 106 106 - "treefmt": "treefmt" 107 107 - }, 108 108 - "locked": { 109 109 - "lastModified": 1762582646, 110 110 - "narHash": "sha256-MMzE4xccG+8qbLhdaZoeFDUKWUOn3B4lhp5dZmgukmM=", 111 111 - "owner": "90-008", 112 112 - "repo": "nix-cargo-integration", 113 113 - "rev": "0993c449377049fa8868a664e8290ac6658e0b9a", 114 114 - "type": "github" 115 115 - }, 116 116 - "original": { 117 117 - "owner": "90-008", 118 118 - "repo": "nix-cargo-integration", 119 119 - "type": "github" 120 120 - } 121 121 - }, 122 122 - "nixpkgs": { 123 123 - "locked": { 124 124 - "lastModified": 1762361079, 125 125 - "narHash": "sha256-lz718rr1BDpZBYk7+G8cE6wee3PiBUpn8aomG/vLLiY=", 126 126 - "owner": "nixos", 127 127 - "repo": "nixpkgs", 128 128 - "rev": "ffcdcf99d65c61956d882df249a9be53e5902ea5", 129 129 - "type": "github" 130 130 - }, 131 131 - "original": { 132 132 - "owner": "nixos", 133 133 - "ref": "nixpkgs-unstable", 134 134 - "repo": "nixpkgs", 135 135 - "type": "github" 136 136 - } 137 137 - }, 138 138 - "parts": { 139 139 - "inputs": { 140 140 - "nixpkgs-lib": [ 141 141 - "nci", 142 142 - "nixpkgs" 143 143 - ] 144 144 - }, 145 145 - "locked": { 146 146 - "lastModified": 1762440070, 147 147 - "narHash": "sha256-xxdepIcb39UJ94+YydGP221rjnpkDZUlykKuF54PsqI=", 148 148 - "owner": "hercules-ci", 149 149 - "repo": "flake-parts", 150 150 - "rev": "26d05891e14c88eb4a5d5bee659c0db5afb609d8", 151 151 - "type": "github" 152 152 - }, 153 153 - "original": { 154 154 - "owner": "hercules-ci", 155 155 - "repo": "flake-parts", 156 156 - "type": "github" 157 157 - } 158 158 - }, 159 159 - "parts_2": { 160 160 - "inputs": { 161 161 - "nixpkgs-lib": [ 162 162 - "nixpkgs" 163 163 - ] 164 164 - }, 165 165 - "locked": { 166 166 - "lastModified": 1762440070, 167 167 - "narHash": "sha256-xxdepIcb39UJ94+YydGP221rjnpkDZUlykKuF54PsqI=", 168 168 - "owner": "hercules-ci", 169 169 - "repo": "flake-parts", 170 170 - "rev": "26d05891e14c88eb4a5d5bee659c0db5afb609d8", 171 171 - "type": "github" 172 172 - }, 173 173 - "original": { 174 174 - "owner": "hercules-ci", 175 175 - "repo": "flake-parts", 176 176 - "type": "github" 177 177 - } 178 178 - }, 179 179 - "purescript-overlay": { 180 180 - "inputs": { 181 181 - "flake-compat": "flake-compat", 182 182 - "nixpkgs": [ 183 183 - "nci", 184 184 - "dream2nix", 185 185 - "nixpkgs" 186 186 - ], 187 187 - "slimlock": "slimlock" 188 188 - }, 189 189 - "locked": { 190 190 - "lastModified": 1728546539, 191 191 - "narHash": "sha256-Sws7w0tlnjD+Bjck1nv29NjC5DbL6nH5auL9Ex9Iz2A=", 192 192 - "owner": "thomashoneyman", 193 193 - "repo": "purescript-overlay", 194 194 - "rev": "4ad4c15d07bd899d7346b331f377606631eb0ee4", 195 195 - "type": "github" 196 196 - }, 197 197 - "original": { 198 198 - "owner": "thomashoneyman", 199 199 - "repo": "purescript-overlay", 200 200 - "type": "github" 201 201 - } 202 202 - }, 203 203 - "pyproject-nix": { 204 204 - "inputs": { 205 205 - "nixpkgs": [ 206 206 - "nci", 207 207 - "dream2nix", 208 208 - "nixpkgs" 209 209 - ] 210 210 - }, 211 211 - "locked": { 212 212 - "lastModified": 1752481895, 213 213 - "narHash": "sha256-luVj97hIMpCbwhx3hWiRwjP2YvljWy8FM+4W9njDhLA=", 214 214 - "owner": "pyproject-nix", 215 215 - "repo": "pyproject.nix", 216 216 - "rev": "16ee295c25107a94e59a7fc7f2e5322851781162", 217 217 - "type": "github" 218 218 - }, 219 219 - "original": { 220 220 - "owner": "pyproject-nix", 221 221 - "repo": "pyproject.nix", 222 222 - "type": "github" 223 223 - } 224 224 - }, 225 225 - "root": { 226 226 - "inputs": { 227 227 - "fenix": "fenix", 228 228 - "nci": "nci", 229 229 - "nixpkgs": "nixpkgs", 230 230 - "parts": "parts_2" 231 231 - } 232 232 - }, 233 233 - "rust-analyzer-src": { 234 234 - "flake": false, 235 235 - "locked": { 236 236 - "lastModified": 1762438844, 237 237 - "narHash": "sha256-ApIKJf6CcMsV2nYBXhGF95BmZMO/QXPhgfSnkA/rVUo=", 238 238 - "owner": "rust-lang", 239 239 - "repo": "rust-analyzer", 240 240 - "rev": "4bf516ee5a960c1e2eee9fedd9b1c9e976a19c86", 241 241 - "type": "github" 242 242 - }, 243 243 - "original": { 244 244 - "owner": "rust-lang", 245 245 - "ref": "nightly", 246 246 - "repo": "rust-analyzer", 247 247 - "type": "github" 248 248 - } 249 249 - }, 250 250 - "rust-overlay": { 251 251 - "inputs": { 252 252 - "nixpkgs": [ 253 253 - "nci", 254 254 - "nixpkgs" 255 255 - ] 256 256 - }, 257 257 - "locked": { 258 258 - "lastModified": 1762569282, 259 259 - "narHash": "sha256-vINZAJpXQTZd5cfh06Rcw7hesH7sGSvi+Tn+HUieJn8=", 260 260 - "owner": "oxalica", 261 261 - "repo": "rust-overlay", 262 262 - "rev": "a35a6144b976f70827c2fe2f5c89d16d8f9179d8", 263 263 - "type": "github" 264 264 - }, 265 265 - "original": { 266 266 - "owner": "oxalica", 267 267 - "repo": "rust-overlay", 268 268 - "type": "github" 269 269 - } 270 270 - }, 271 271 - "slimlock": { 272 272 - "inputs": { 273 273 - "nixpkgs": [ 274 274 - "nci", 275 275 - "dream2nix", 276 276 - "purescript-overlay", 277 277 - "nixpkgs" 278 278 - ] 279 279 - }, 280 280 - "locked": { 281 281 - "lastModified": 1688756706, 282 282 - "narHash": "sha256-xzkkMv3neJJJ89zo3o2ojp7nFeaZc2G0fYwNXNJRFlo=", 283 283 - "owner": "thomashoneyman", 284 284 - "repo": "slimlock", 285 285 - "rev": "cf72723f59e2340d24881fd7bf61cb113b4c407c", 286 286 - "type": "github" 287 287 - }, 288 288 - "original": { 289 289 - "owner": "thomashoneyman", 290 290 - "repo": "slimlock", 291 291 - "type": "github" 292 292 - } 293 293 - }, 294 294 - "treefmt": { 295 295 - "inputs": { 296 296 - "nixpkgs": [ 297 297 - "nci", 298 298 - "nixpkgs" 299 299 - ] 300 300 - }, 301 301 - "locked": { 302 302 - "lastModified": 1762410071, 303 303 - "narHash": "sha256-aF5fvoZeoXNPxT0bejFUBXeUjXfHLSL7g+mjR/p5TEg=", 304 304 - "owner": "numtide", 305 305 - "repo": "treefmt-nix", 306 306 - "rev": "97a30861b13c3731a84e09405414398fbf3e109f", 307 307 - "type": "github" 308 308 - }, 309 309 - "original": { 310 310 - "owner": "numtide", 311 311 - "repo": "treefmt-nix", 312 312 - "type": "github" 313 313 - } 314 314 - } 315 315 - }, 316 316 - "root": "root", 317 317 - "version": 7 318 318 - }

-59

flake.nix

··· 1 1 - { 2 2 - inputs.nixpkgs.url = "github:nixos/nixpkgs/nixpkgs-unstable"; 3 3 - inputs.nci.url = "github:90-008/nix-cargo-integration"; 4 4 - inputs.nci.inputs.nixpkgs.follows = "nixpkgs"; 5 5 - inputs.parts.url = "github:hercules-ci/flake-parts"; 6 6 - inputs.parts.inputs.nixpkgs-lib.follows = "nixpkgs"; 7 7 - inputs.fenix = { 8 8 - url = "github:nix-community/fenix"; 9 9 - inputs.nixpkgs.follows = "nixpkgs"; 10 10 - }; 11 11 - 12 12 - outputs = inputs @ { 13 13 - parts, 14 14 - nci, 15 15 - ... 16 16 - }: 17 17 - parts.lib.mkFlake {inherit inputs;} { 18 18 - systems = ["x86_64-linux" "aarch64-darwin"]; 19 19 - imports = [ 20 20 - nci.flakeModule 21 21 - ./crates.nix 22 22 - ]; 23 23 - perSystem = { 24 24 - pkgs, 25 25 - config, 26 26 - ... 27 27 - }: let 28 28 - crateOutputs = config.nci.outputs."wisp-cli"; 29 29 - mkRenamedPackage = name: pkg: isWindows: pkgs.runCommand name {} '' 30 30 - mkdir -p $out/bin 31 31 - if [ -f ${pkg}/bin/wisp-cli.exe ]; then 32 32 - cp ${pkg}/bin/wisp-cli.exe $out/bin/${name} 33 33 - elif [ -f ${pkg}/bin/wisp-cli ]; then 34 34 - cp ${pkg}/bin/wisp-cli $out/bin/${name} 35 35 - else 36 36 - echo "Error: Could not find wisp-cli binary in ${pkg}/bin/" 37 37 - ls -la ${pkg}/bin/ || true 38 38 - exit 1 39 39 - fi 40 40 - ''; 41 41 - in { 42 42 - devShells.default = crateOutputs.devShell; 43 43 - packages.default = crateOutputs.packages.release; 44 44 - packages.wisp-cli-x86_64-linux = mkRenamedPackage "wisp-cli-x86_64-linux" crateOutputs.packages.release false; 45 45 - packages.wisp-cli-aarch64-linux = mkRenamedPackage "wisp-cli-aarch64-linux" crateOutputs.allTargets."aarch64-unknown-linux-gnu".packages.release false; 46 46 - packages.wisp-cli-x86_64-windows = mkRenamedPackage "wisp-cli-x86_64-windows.exe" crateOutputs.allTargets."x86_64-pc-windows-gnu".packages.release true; 47 47 - packages.wisp-cli-aarch64-darwin = mkRenamedPackage "wisp-cli-aarch64-darwin" crateOutputs.allTargets."aarch64-apple-darwin".packages.release false; 48 48 - packages.all = pkgs.symlinkJoin { 49 49 - name = "wisp-cli-all"; 50 50 - paths = [ 51 51 - config.packages.wisp-cli-x86_64-linux 52 52 - config.packages.wisp-cli-aarch64-linux 53 53 - config.packages.wisp-cli-x86_64-windows 54 54 - config.packages.wisp-cli-aarch64-darwin 55 55 - ]; 56 56 - }; 57 57 - }; 58 58 - }; 59 59 - }

+59

lexicons/fs.json

··· 1 1 + { 2 2 + "lexicon": 1, 3 3 + "id": "place.wisp.fs", 4 4 + "defs": { 5 5 + "main": { 6 6 + "type": "record", 7 7 + "description": "Virtual filesystem manifest for a Wisp site", 8 8 + "record": { 9 9 + "type": "object", 10 10 + "required": ["site", "root", "createdAt"], 11 11 + "properties": { 12 12 + "site": { "type": "string" }, 13 13 + "root": { "type": "ref", "ref": "#directory" }, 14 14 + "fileCount": { "type": "integer", "minimum": 0, "maximum": 1000 }, 15 15 + "createdAt": { "type": "string", "format": "datetime" } 16 16 + } 17 17 + } 18 18 + }, 19 19 + "file": { 20 20 + "type": "object", 21 21 + "required": ["type", "blob"], 22 22 + "properties": { 23 23 + "type": { "type": "string", "const": "file" }, 24 24 + "blob": { "type": "blob", "accept": ["*/*"], "maxSize": 1000000000, "description": "Content blob ref" }, 25 25 + "encoding": { "type": "string", "enum": ["gzip"], "description": "Content encoding (e.g., gzip for compressed files)" }, 26 26 + "mimeType": { "type": "string", "description": "Original MIME type before compression" }, 27 27 + "base64": { "type": "boolean", "description": "True if blob content is base64-encoded (used to bypass PDS content sniffing)" } } 28 28 + }, 29 29 + "directory": { 30 30 + "type": "object", 31 31 + "required": ["type", "entries"], 32 32 + "properties": { 33 33 + "type": { "type": "string", "const": "directory" }, 34 34 + "entries": { 35 35 + "type": "array", 36 36 + "maxLength": 500, 37 37 + "items": { "type": "ref", "ref": "#entry" } 38 38 + } 39 39 + } 40 40 + }, 41 41 + "entry": { 42 42 + "type": "object", 43 43 + "required": ["name", "node"], 44 44 + "properties": { 45 45 + "name": { "type": "string", "maxLength": 255 }, 46 46 + "node": { "type": "union", "refs": ["#file", "#directory", "#subfs"] } 47 47 + } 48 48 + }, 49 49 + "subfs": { 50 50 + "type": "object", 51 51 + "required": ["type", "subject"], 52 52 + "properties": { 53 53 + "type": { "type": "string", "const": "subfs" }, 54 54 + "subject": { "type": "string", "format": "at-uri", "description": "AT-URI pointing to a place.wisp.subfs record containing this subtree." }, 55 55 + "flat": { "type": "boolean", "description": "If true (default), the subfs record's root entries are merged (flattened) into the parent directory, replacing the subfs entry. If false, the subfs entries are placed in a subdirectory with the subfs entry's name. Flat merging is useful for splitting large directories across multiple records while maintaining a flat structure." } 56 56 + } 57 57 + } 58 58 + } 59 59 + }

+76

lexicons/settings.json

··· 1 1 + { 2 2 + "lexicon": 1, 3 3 + "id": "place.wisp.settings", 4 4 + "defs": { 5 5 + "main": { 6 6 + "type": "record", 7 7 + "description": "Configuration settings for a static site hosted on wisp.place", 8 8 + "key": "any", 9 9 + "record": { 10 10 + "type": "object", 11 11 + "properties": { 12 12 + "directoryListing": { 13 13 + "type": "boolean", 14 14 + "description": "Enable directory listing mode for paths that resolve to directories without an index file. Incompatible with spaMode.", 15 15 + "default": false 16 16 + }, 17 17 + "spaMode": { 18 18 + "type": "string", 19 19 + "description": "File to serve for all routes (e.g., 'index.html'). When set, enables SPA mode where all non-file requests are routed to this file. Incompatible with directoryListing and custom404.", 20 20 + "maxLength": 500 21 21 + }, 22 22 + "custom404": { 23 23 + "type": "string", 24 24 + "description": "Custom 404 error page file path. Incompatible with directoryListing and spaMode.", 25 25 + "maxLength": 500 26 26 + }, 27 27 + "indexFiles": { 28 28 + "type": "array", 29 29 + "description": "Ordered list of files to try when serving a directory. Defaults to ['index.html'] if not specified.", 30 30 + "items": { 31 31 + "type": "string", 32 32 + "maxLength": 255 33 33 + }, 34 34 + "maxLength": 10 35 35 + }, 36 36 + "cleanUrls": { 37 37 + "type": "boolean", 38 38 + "description": "Enable clean URL routing. When enabled, '/about' will attempt to serve '/about.html' or '/about/index.html' automatically.", 39 39 + "default": false 40 40 + }, 41 41 + "headers": { 42 42 + "type": "array", 43 43 + "description": "Custom HTTP headers to set on responses", 44 44 + "items": { 45 45 + "type": "ref", 46 46 + "ref": "#customHeader" 47 47 + }, 48 48 + "maxLength": 50 49 49 + } 50 50 + } 51 51 + } 52 52 + }, 53 53 + "customHeader": { 54 54 + "type": "object", 55 55 + "description": "Custom HTTP header configuration", 56 56 + "required": ["name", "value"], 57 57 + "properties": { 58 58 + "name": { 59 59 + "type": "string", 60 60 + "description": "HTTP header name (e.g., 'Cache-Control', 'X-Frame-Options')", 61 61 + "maxLength": 100 62 62 + }, 63 63 + "value": { 64 64 + "type": "string", 65 65 + "description": "HTTP header value", 66 66 + "maxLength": 1000 67 67 + }, 68 68 + "path": { 69 69 + "type": "string", 70 70 + "description": "Optional glob pattern to apply this header to specific paths (e.g., '*.html', '/assets/*'). If not specified, applies to all paths.", 71 71 + "maxLength": 500 72 72 + } 73 73 + } 74 74 + } 75 75 + } 76 76 + }

+59

lexicons/subfs.json

··· 1 1 + { 2 2 + "lexicon": 1, 3 3 + "id": "place.wisp.subfs", 4 4 + "defs": { 5 5 + "main": { 6 6 + "type": "record", 7 7 + "description": "Virtual filesystem subtree referenced by place.wisp.fs records. When a subfs entry is expanded, its root entries are merged (flattened) into the parent directory, allowing large directories to be split across multiple records while maintaining a flat structure.", 8 8 + "record": { 9 9 + "type": "object", 10 10 + "required": ["root", "createdAt"], 11 11 + "properties": { 12 12 + "root": { "type": "ref", "ref": "#directory" }, 13 13 + "fileCount": { "type": "integer", "minimum": 0, "maximum": 1000 }, 14 14 + "createdAt": { "type": "string", "format": "datetime" } 15 15 + } 16 16 + } 17 17 + }, 18 18 + "file": { 19 19 + "type": "object", 20 20 + "required": ["type", "blob"], 21 21 + "properties": { 22 22 + "type": { "type": "string", "const": "file" }, 23 23 + "blob": { "type": "blob", "accept": ["*/*"], "maxSize": 1000000000, "description": "Content blob ref" }, 24 24 + "encoding": { "type": "string", "enum": ["gzip"], "description": "Content encoding (e.g., gzip for compressed files)" }, 25 25 + "mimeType": { "type": "string", "description": "Original MIME type before compression" }, 26 26 + "base64": { "type": "boolean", "description": "True if blob content is base64-encoded (used to bypass PDS content sniffing)" } 27 27 + } 28 28 + }, 29 29 + "directory": { 30 30 + "type": "object", 31 31 + "required": ["type", "entries"], 32 32 + "properties": { 33 33 + "type": { "type": "string", "const": "directory" }, 34 34 + "entries": { 35 35 + "type": "array", 36 36 + "maxLength": 500, 37 37 + "items": { "type": "ref", "ref": "#entry" } 38 38 + } 39 39 + } 40 40 + }, 41 41 + "entry": { 42 42 + "type": "object", 43 43 + "required": ["name", "node"], 44 44 + "properties": { 45 45 + "name": { "type": "string", "maxLength": 255 }, 46 46 + "node": { "type": "union", "refs": ["#file", "#directory", "#subfs"] } 47 47 + } 48 48 + }, 49 49 + "subfs": { 50 50 + "type": "object", 51 51 + "required": ["type", "subject"], 52 52 + "properties": { 53 53 + "type": { "type": "string", "const": "subfs" }, 54 54 + "subject": { "type": "string", "format": "at-uri", "description": "AT-URI pointing to another place.wisp.subfs record for nested subtrees. When expanded, the referenced record's root entries are merged (flattened) into the parent directory, allowing recursive splitting of large directory structures." } 55 55 + } 56 56 + } 57 57 + } 58 58 + } 59 59 +

+6 -2

package.json

··· 24 24 "check": "cd apps/main-app && npm run check && cd ../hosting-service && npm run check", 25 25 "screenshot": "bun run apps/main-app/scripts/screenshot-sites.ts", 26 26 "hosting:dev": "cd apps/hosting-service && npm run dev", 27 27 - "hosting:start": "cd apps/hosting-service && npm run start" 27 27 + "hosting:start": "cd apps/hosting-service && npm run start", 28 28 + "codegen": "./scripts/codegen.sh" 28 29 }, 29 30 "trustedDependencies": [ 30 31 "@parcel/watcher", 31 32 "bun", 32 33 "esbuild" 33 33 - ] 34 34 + ], 35 35 + "devDependencies": { 36 36 + "@types/bun": "^1.3.5" 37 37 + } 34 38 }

+244

packages/@wisp/fs-utils/src/tree.test.ts

··· 1 1 + import { describe, test, expect } from 'bun:test' 2 2 + import { processUploadedFiles, type UploadedFile } from './tree' 3 3 + 4 4 + describe('processUploadedFiles', () => { 5 5 + test('should preserve nested directory structure', () => { 6 6 + const files: UploadedFile[] = [ 7 7 + { 8 8 + name: 'mysite/index.html', 9 9 + content: Buffer.from('<html>'), 10 10 + mimeType: 'text/html', 11 11 + size: 6 12 12 + }, 13 13 + { 14 14 + name: 'mysite/_astro/main.js', 15 15 + content: Buffer.from('console.log()'), 16 16 + mimeType: 'application/javascript', 17 17 + size: 13 18 18 + }, 19 19 + { 20 20 + name: 'mysite/_astro/styles.css', 21 21 + content: Buffer.from('body {}'), 22 22 + mimeType: 'text/css', 23 23 + size: 7 24 24 + }, 25 25 + { 26 26 + name: 'mysite/images/logo.png', 27 27 + content: Buffer.from([0x89, 0x50, 0x4e, 0x47]), 28 28 + mimeType: 'image/png', 29 29 + size: 4 30 30 + } 31 31 + ] 32 32 + 33 33 + const result = processUploadedFiles(files) 34 34 + 35 35 + expect(result.fileCount).toBe(4) 36 36 + expect(result.directory.entries).toHaveLength(3) // index.html, _astro/, images/ 37 37 + 38 38 + // Check _astro directory exists 39 39 + const astroEntry = result.directory.entries.find(e => e.name === '_astro') 40 40 + expect(astroEntry).toBeTruthy() 41 41 + expect('type' in astroEntry!.node && astroEntry!.node.type).toBe('directory') 42 42 + 43 43 + if ('entries' in astroEntry!.node) { 44 44 + const astroDir = astroEntry!.node 45 45 + expect(astroDir.entries).toHaveLength(2) // main.js, styles.css 46 46 + expect(astroDir.entries.find(e => e.name === 'main.js')).toBeTruthy() 47 47 + expect(astroDir.entries.find(e => e.name === 'styles.css')).toBeTruthy() 48 48 + } 49 49 + 50 50 + // Check images directory exists 51 51 + const imagesEntry = result.directory.entries.find(e => e.name === 'images') 52 52 + expect(imagesEntry).toBeTruthy() 53 53 + expect('type' in imagesEntry!.node && imagesEntry!.node.type).toBe('directory') 54 54 + 55 55 + if ('entries' in imagesEntry!.node) { 56 56 + const imagesDir = imagesEntry!.node 57 57 + expect(imagesDir.entries).toHaveLength(1) // logo.png 58 58 + expect(imagesDir.entries.find(e => e.name === 'logo.png')).toBeTruthy() 59 59 + } 60 60 + }) 61 61 + 62 62 + test('should handle deeply nested directories', () => { 63 63 + const files: UploadedFile[] = [ 64 64 + { 65 65 + name: 'site/a/b/c/d/deep.txt', 66 66 + content: Buffer.from('deep'), 67 67 + mimeType: 'text/plain', 68 68 + size: 4 69 69 + } 70 70 + ] 71 71 + 72 72 + const result = processUploadedFiles(files) 73 73 + 74 74 + expect(result.fileCount).toBe(1) 75 75 + 76 76 + // Navigate through nested structure 77 77 + const aEntry = result.directory.entries.find(e => e.name === 'a') 78 78 + expect(aEntry).toBeTruthy() 79 79 + expect('type' in aEntry!.node && aEntry!.node.type).toBe('directory') 80 80 + 81 81 + if ('entries' in aEntry!.node) { 82 82 + const bEntry = aEntry!.node.entries.find(e => e.name === 'b') 83 83 + expect(bEntry).toBeTruthy() 84 84 + expect('type' in bEntry!.node && bEntry!.node.type).toBe('directory') 85 85 + 86 86 + if ('entries' in bEntry!.node) { 87 87 + const cEntry = bEntry!.node.entries.find(e => e.name === 'c') 88 88 + expect(cEntry).toBeTruthy() 89 89 + expect('type' in cEntry!.node && cEntry!.node.type).toBe('directory') 90 90 + 91 91 + if ('entries' in cEntry!.node) { 92 92 + const dEntry = cEntry!.node.entries.find(e => e.name === 'd') 93 93 + expect(dEntry).toBeTruthy() 94 94 + expect('type' in dEntry!.node && dEntry!.node.type).toBe('directory') 95 95 + 96 96 + if ('entries' in dEntry!.node) { 97 97 + const fileEntry = dEntry!.node.entries.find(e => e.name === 'deep.txt') 98 98 + expect(fileEntry).toBeTruthy() 99 99 + expect('type' in fileEntry!.node && fileEntry!.node.type).toBe('file') 100 100 + } 101 101 + } 102 102 + } 103 103 + } 104 104 + }) 105 105 + 106 106 + test('should handle files at root level', () => { 107 107 + const files: UploadedFile[] = [ 108 108 + { 109 109 + name: 'mysite/index.html', 110 110 + content: Buffer.from('<html>'), 111 111 + mimeType: 'text/html', 112 112 + size: 6 113 113 + }, 114 114 + { 115 115 + name: 'mysite/robots.txt', 116 116 + content: Buffer.from('User-agent: *'), 117 117 + mimeType: 'text/plain', 118 118 + size: 13 119 119 + } 120 120 + ] 121 121 + 122 122 + const result = processUploadedFiles(files) 123 123 + 124 124 + expect(result.fileCount).toBe(2) 125 125 + expect(result.directory.entries).toHaveLength(2) 126 126 + expect(result.directory.entries.find(e => e.name === 'index.html')).toBeTruthy() 127 127 + expect(result.directory.entries.find(e => e.name === 'robots.txt')).toBeTruthy() 128 128 + }) 129 129 + 130 130 + test('should skip .git directories', () => { 131 131 + const files: UploadedFile[] = [ 132 132 + { 133 133 + name: 'mysite/index.html', 134 134 + content: Buffer.from('<html>'), 135 135 + mimeType: 'text/html', 136 136 + size: 6 137 137 + }, 138 138 + { 139 139 + name: 'mysite/.git/config', 140 140 + content: Buffer.from('[core]'), 141 141 + mimeType: 'text/plain', 142 142 + size: 6 143 143 + }, 144 144 + { 145 145 + name: 'mysite/.gitignore', 146 146 + content: Buffer.from('node_modules'), 147 147 + mimeType: 'text/plain', 148 148 + size: 12 149 149 + } 150 150 + ] 151 151 + 152 152 + const result = processUploadedFiles(files) 153 153 + 154 154 + expect(result.fileCount).toBe(2) // Only index.html and .gitignore 155 155 + expect(result.directory.entries).toHaveLength(2) 156 156 + expect(result.directory.entries.find(e => e.name === 'index.html')).toBeTruthy() 157 157 + expect(result.directory.entries.find(e => e.name === '.gitignore')).toBeTruthy() 158 158 + expect(result.directory.entries.find(e => e.name === '.git')).toBeFalsy() 159 159 + }) 160 160 + 161 161 + test('should handle mixed root and nested files', () => { 162 162 + const files: UploadedFile[] = [ 163 163 + { 164 164 + name: 'mysite/index.html', 165 165 + content: Buffer.from('<html>'), 166 166 + mimeType: 'text/html', 167 167 + size: 6 168 168 + }, 169 169 + { 170 170 + name: 'mysite/about/index.html', 171 171 + content: Buffer.from('<html>'), 172 172 + mimeType: 'text/html', 173 173 + size: 6 174 174 + }, 175 175 + { 176 176 + name: 'mysite/about/team.html', 177 177 + content: Buffer.from('<html>'), 178 178 + mimeType: 'text/html', 179 179 + size: 6 180 180 + }, 181 181 + { 182 182 + name: 'mysite/robots.txt', 183 183 + content: Buffer.from('User-agent: *'), 184 184 + mimeType: 'text/plain', 185 185 + size: 13 186 186 + } 187 187 + ] 188 188 + 189 189 + const result = processUploadedFiles(files) 190 190 + 191 191 + expect(result.fileCount).toBe(4) 192 192 + expect(result.directory.entries).toHaveLength(3) // index.html, about/, robots.txt 193 193 + 194 194 + const aboutEntry = result.directory.entries.find(e => e.name === 'about') 195 195 + expect(aboutEntry).toBeTruthy() 196 196 + expect('type' in aboutEntry!.node && aboutEntry!.node.type).toBe('directory') 197 197 + 198 198 + if ('entries' in aboutEntry!.node) { 199 199 + const aboutDir = aboutEntry!.node 200 200 + expect(aboutDir.entries).toHaveLength(2) // index.html, team.html 201 201 + expect(aboutDir.entries.find(e => e.name === 'index.html')).toBeTruthy() 202 202 + expect(aboutDir.entries.find(e => e.name === 'team.html')).toBeTruthy() 203 203 + } 204 204 + }) 205 205 + 206 206 + test('should handle empty file array', () => { 207 207 + const files: UploadedFile[] = [] 208 208 + 209 209 + const result = processUploadedFiles(files) 210 210 + 211 211 + expect(result.fileCount).toBe(0) 212 212 + expect(result.directory.entries).toHaveLength(0) 213 213 + }) 214 214 + 215 215 + test('should strip base folder name from paths', () => { 216 216 + // This tests the behavior where file.name includes the base folder 217 217 + // e.g., "mysite/index.html" should become "index.html" at root 218 218 + const files: UploadedFile[] = [ 219 219 + { 220 220 + name: 'build-output/index.html', 221 221 + content: Buffer.from('<html>'), 222 222 + mimeType: 'text/html', 223 223 + size: 6 224 224 + }, 225 225 + { 226 226 + name: 'build-output/assets/main.js', 227 227 + content: Buffer.from('console.log()'), 228 228 + mimeType: 'application/javascript', 229 229 + size: 13 230 230 + } 231 231 + ] 232 232 + 233 233 + const result = processUploadedFiles(files) 234 234 + 235 235 + expect(result.fileCount).toBe(2) 236 236 + 237 237 + // Should have index.html at root and assets/ directory 238 238 + expect(result.directory.entries.find(e => e.name === 'index.html')).toBeTruthy() 239 239 + expect(result.directory.entries.find(e => e.name === 'assets')).toBeTruthy() 240 240 + 241 241 + // Should NOT have 'build-output' directory 242 242 + expect(result.directory.entries.find(e => e.name === 'build-output')).toBeFalsy() 243 243 + }) 244 244 + })

-59

packages/@wisp/lexicons/lexicons/fs.json

··· 1 1 - { 2 2 - "lexicon": 1, 3 3 - "id": "place.wisp.fs", 4 4 - "defs": { 5 5 - "main": { 6 6 - "type": "record", 7 7 - "description": "Virtual filesystem manifest for a Wisp site", 8 8 - "record": { 9 9 - "type": "object", 10 10 - "required": ["site", "root", "createdAt"], 11 11 - "properties": { 12 12 - "site": { "type": "string" }, 13 13 - "root": { "type": "ref", "ref": "#directory" }, 14 14 - "fileCount": { "type": "integer", "minimum": 0, "maximum": 1000 }, 15 15 - "createdAt": { "type": "string", "format": "datetime" } 16 16 - } 17 17 - } 18 18 - }, 19 19 - "file": { 20 20 - "type": "object", 21 21 - "required": ["type", "blob"], 22 22 - "properties": { 23 23 - "type": { "type": "string", "const": "file" }, 24 24 - "blob": { "type": "blob", "accept": ["*/*"], "maxSize": 1000000000, "description": "Content blob ref" }, 25 25 - "encoding": { "type": "string", "enum": ["gzip"], "description": "Content encoding (e.g., gzip for compressed files)" }, 26 26 - "mimeType": { "type": "string", "description": "Original MIME type before compression" }, 27 27 - "base64": { "type": "boolean", "description": "True if blob content is base64-encoded (used to bypass PDS content sniffing)" } } 28 28 - }, 29 29 - "directory": { 30 30 - "type": "object", 31 31 - "required": ["type", "entries"], 32 32 - "properties": { 33 33 - "type": { "type": "string", "const": "directory" }, 34 34 - "entries": { 35 35 - "type": "array", 36 36 - "maxLength": 500, 37 37 - "items": { "type": "ref", "ref": "#entry" } 38 38 - } 39 39 - } 40 40 - }, 41 41 - "entry": { 42 42 - "type": "object", 43 43 - "required": ["name", "node"], 44 44 - "properties": { 45 45 - "name": { "type": "string", "maxLength": 255 }, 46 46 - "node": { "type": "union", "refs": ["#file", "#directory", "#subfs"] } 47 47 - } 48 48 - }, 49 49 - "subfs": { 50 50 - "type": "object", 51 51 - "required": ["type", "subject"], 52 52 - "properties": { 53 53 - "type": { "type": "string", "const": "subfs" }, 54 54 - "subject": { "type": "string", "format": "at-uri", "description": "AT-URI pointing to a place.wisp.subfs record containing this subtree." }, 55 55 - "flat": { "type": "boolean", "description": "If true (default), the subfs record's root entries are merged (flattened) into the parent directory, replacing the subfs entry. If false, the subfs entries are placed in a subdirectory with the subfs entry's name. Flat merging is useful for splitting large directories across multiple records while maintaining a flat structure." } 56 56 - } 57 57 - } 58 58 - } 59 59 - }

-76

packages/@wisp/lexicons/lexicons/settings.json

··· 1 1 - { 2 2 - "lexicon": 1, 3 3 - "id": "place.wisp.settings", 4 4 - "defs": { 5 5 - "main": { 6 6 - "type": "record", 7 7 - "description": "Configuration settings for a static site hosted on wisp.place", 8 8 - "key": "any", 9 9 - "record": { 10 10 - "type": "object", 11 11 - "properties": { 12 12 - "directoryListing": { 13 13 - "type": "boolean", 14 14 - "description": "Enable directory listing mode for paths that resolve to directories without an index file. Incompatible with spaMode.", 15 15 - "default": false 16 16 - }, 17 17 - "spaMode": { 18 18 - "type": "string", 19 19 - "description": "File to serve for all routes (e.g., 'index.html'). When set, enables SPA mode where all non-file requests are routed to this file. Incompatible with directoryListing and custom404.", 20 20 - "maxLength": 500 21 21 - }, 22 22 - "custom404": { 23 23 - "type": "string", 24 24 - "description": "Custom 404 error page file path. Incompatible with directoryListing and spaMode.", 25 25 - "maxLength": 500 26 26 - }, 27 27 - "indexFiles": { 28 28 - "type": "array", 29 29 - "description": "Ordered list of files to try when serving a directory. Defaults to ['index.html'] if not specified.", 30 30 - "items": { 31 31 - "type": "string", 32 32 - "maxLength": 255 33 33 - }, 34 34 - "maxLength": 10 35 35 - }, 36 36 - "cleanUrls": { 37 37 - "type": "boolean", 38 38 - "description": "Enable clean URL routing. When enabled, '/about' will attempt to serve '/about.html' or '/about/index.html' automatically.", 39 39 - "default": false 40 40 - }, 41 41 - "headers": { 42 42 - "type": "array", 43 43 - "description": "Custom HTTP headers to set on responses", 44 44 - "items": { 45 45 - "type": "ref", 46 46 - "ref": "#customHeader" 47 47 - }, 48 48 - "maxLength": 50 49 49 - } 50 50 - } 51 51 - } 52 52 - }, 53 53 - "customHeader": { 54 54 - "type": "object", 55 55 - "description": "Custom HTTP header configuration", 56 56 - "required": ["name", "value"], 57 57 - "properties": { 58 58 - "name": { 59 59 - "type": "string", 60 60 - "description": "HTTP header name (e.g., 'Cache-Control', 'X-Frame-Options')", 61 61 - "maxLength": 100 62 62 - }, 63 63 - "value": { 64 64 - "type": "string", 65 65 - "description": "HTTP header value", 66 66 - "maxLength": 1000 67 67 - }, 68 68 - "path": { 69 69 - "type": "string", 70 70 - "description": "Optional glob pattern to apply this header to specific paths (e.g., '*.html', '/assets/*'). If not specified, applies to all paths.", 71 71 - "maxLength": 500 72 72 - } 73 73 - } 74 74 - } 75 75 - } 76 76 - }

-59

packages/@wisp/lexicons/lexicons/subfs.json

··· 1 1 - { 2 2 - "lexicon": 1, 3 3 - "id": "place.wisp.subfs", 4 4 - "defs": { 5 5 - "main": { 6 6 - "type": "record", 7 7 - "description": "Virtual filesystem subtree referenced by place.wisp.fs records. When a subfs entry is expanded, its root entries are merged (flattened) into the parent directory, allowing large directories to be split across multiple records while maintaining a flat structure.", 8 8 - "record": { 9 9 - "type": "object", 10 10 - "required": ["root", "createdAt"], 11 11 - "properties": { 12 12 - "root": { "type": "ref", "ref": "#directory" }, 13 13 - "fileCount": { "type": "integer", "minimum": 0, "maximum": 1000 }, 14 14 - "createdAt": { "type": "string", "format": "datetime" } 15 15 - } 16 16 - } 17 17 - }, 18 18 - "file": { 19 19 - "type": "object", 20 20 - "required": ["type", "blob"], 21 21 - "properties": { 22 22 - "type": { "type": "string", "const": "file" }, 23 23 - "blob": { "type": "blob", "accept": ["*/*"], "maxSize": 1000000000, "description": "Content blob ref" }, 24 24 - "encoding": { "type": "string", "enum": ["gzip"], "description": "Content encoding (e.g., gzip for compressed files)" }, 25 25 - "mimeType": { "type": "string", "description": "Original MIME type before compression" }, 26 26 - "base64": { "type": "boolean", "description": "True if blob content is base64-encoded (used to bypass PDS content sniffing)" } 27 27 - } 28 28 - }, 29 29 - "directory": { 30 30 - "type": "object", 31 31 - "required": ["type", "entries"], 32 32 - "properties": { 33 33 - "type": { "type": "string", "const": "directory" }, 34 34 - "entries": { 35 35 - "type": "array", 36 36 - "maxLength": 500, 37 37 - "items": { "type": "ref", "ref": "#entry" } 38 38 - } 39 39 - } 40 40 - }, 41 41 - "entry": { 42 42 - "type": "object", 43 43 - "required": ["name", "node"], 44 44 - "properties": { 45 45 - "name": { "type": "string", "maxLength": 255 }, 46 46 - "node": { "type": "union", "refs": ["#file", "#directory", "#subfs"] } 47 47 - } 48 48 - }, 49 49 - "subfs": { 50 50 - "type": "object", 51 51 - "required": ["type", "subject"], 52 52 - "properties": { 53 53 - "type": { "type": "string", "const": "subfs" }, 54 54 - "subject": { "type": "string", "format": "at-uri", "description": "AT-URI pointing to another place.wisp.subfs record for nested subtrees. When expanded, the referenced record's root entries are merged (flattened) into the parent directory, allowing recursive splitting of large directory structures." } 55 55 - } 56 56 - } 57 57 - } 58 58 - } 59 59 -

+1 -1

packages/@wisp/lexicons/package.json

··· 32 32 } 33 33 }, 34 34 "scripts": { 35 35 - "codegen": "lex gen-server ./src ./lexicons" 35 35 + "codegen": "lex gen-server ./src ../../../lexicons/*.json" 36 36 }, 37 37 "dependencies": { 38 38 "@atproto/lexicon": "^0.5.1",

+1 -1

packages/@wisp/lexicons/src/index.ts

··· 9 9 type MethodConfigOrHandler, 10 10 createServer as createXrpcServer, 11 11 } from '@atproto/xrpc-server' 12 12 - import { schemas } from './lexicons' 12 12 + import { schemas } from './lexicons.js' 13 13 14 14 export function createServer(options?: XrpcOptions): Server { 15 15 return new Server(options)

+1 -1

packages/@wisp/lexicons/src/lexicons.ts

··· 7 7 ValidationError, 8 8 type ValidationResult, 9 9 } from '@atproto/lexicon' 10 10 - import { type $Typed, is$typed, maybe$typed } from './util' 10 10 + import { type $Typed, is$typed, maybe$typed } from './util.js' 11 11 12 12 export const schemaDict = { 13 13 PlaceWispFs: {

+1 -1

packages/@wisp/observability/README.md

··· 214 214 215 215 ## License 216 216 217 217 - Private 217 217 + MIT

+2 -2

packages/@wisp/observability/src/exporters.ts

··· 3 3 * Integrates with Grafana Loki for logs and Prometheus/OTLP for metrics 4 4 */ 5 5 6 6 - import { LogEntry, ErrorEntry, MetricEntry } from './core' 7 7 - import { metrics, MeterProvider } from '@opentelemetry/api' 6 6 + import type { LogEntry, ErrorEntry, MetricEntry } from './core' 7 7 + import { metrics, type MeterProvider } from '@opentelemetry/api' 8 8 import { MeterProvider as SdkMeterProvider, PeriodicExportingMetricReader } from '@opentelemetry/sdk-metrics' 9 9 import { OTLPMetricExporter } from '@opentelemetry/exporter-metrics-otlp-http' 10 10 import { Resource } from '@opentelemetry/resources'

+28

scripts/codegen.sh

··· 1 1 + #!/bin/bash 2 2 + set -e 3 3 + 4 4 + SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)" 5 5 + ROOT_DIR="$(dirname "$SCRIPT_DIR")" 6 6 + 7 7 + # Parse arguments 8 8 + AUTO_ACCEPT="" 9 9 + if [[ "$1" == "-y" || "$1" == "--yes" ]]; then 10 10 + AUTO_ACCEPT="yes |" 11 11 + fi 12 12 + 13 13 + echo "=== Generating TypeScript lexicons ===" 14 14 + cd "$ROOT_DIR/packages/@wisp/lexicons" 15 15 + eval "$AUTO_ACCEPT npm run codegen" 16 16 + 17 17 + echo "=== Generating Rust lexicons ===" 18 18 + echo "Installing jacquard-lexgen..." 19 19 + cargo install jacquard-lexgen --version 0.9.5 2>/dev/null || true 20 20 + echo "Running jacquard-codegen..." 21 21 + echo " Input: $ROOT_DIR/lexicons" 22 22 + echo " Output: $ROOT_DIR/cli/crates/lexicons/src" 23 23 + jacquard-codegen -i "$ROOT_DIR/lexicons" -o "$ROOT_DIR/cli/crates/lexicons/src" 24 24 + 25 25 + # Add extern crate alloc for the macro to work 26 26 + sed -i '' '1s/^/extern crate alloc;\n\n/' "$ROOT_DIR/cli/crates/lexicons/src/lib.rs" 27 27 + 28 28 + echo "=== Done ==="

+1 -1

tsconfig.json

··· 33 33 // "rootDirs": [], /* Allow multiple folders to be treated as one when resolving modules. */ 34 34 // "typeRoots": [], /* Specify multiple folders that act like './node_modules/@types'. */ 35 35 "types": [ 36 36 - "bun-types" 36 36 + "bun" 37 37 ] /* Specify type package names to be included without being referenced in a source file. */, 38 38 // "allowUmdGlobalAccess": true, /* Allow accessing UMD globals from modules. */ 39 39 // "moduleSuffixes": [], /* List of file name suffixes to search when resolving a module. */