comparing 7eddd78e06f93dfab778718ada17bad84130372e and main on nekomimi.pet/wisp.place-monorepo

.gitignore

···

       0
        
       
     

       1
        
       # See https://help.github.com/articles/ignoring-files/ for more about ignoring files.

     

       2
        
       .env

     

       3
        
       # dependencies

···

       1
       +
       .research/

     

       2
        
       # See https://help.github.com/articles/ignoring-files/ for more about ignoring files.

     

       3
        
       .env

     

       4
        
       # dependencies

+8 -2

apps/hosting-service/src/index.ts

···

       4
        
       import { createLogger, initializeGrafanaExporters } from '@wisp/observability';

     

       5
        
       import { mkdirSync, existsSync } from 'fs';

     

       6
        
       import { backfillCache } from './lib/backfill';

     

       7
       -
       import { startDomainCacheCleanup, stopDomainCacheCleanup, setCacheOnlyMode } from './lib/db';

     

       8
        
       

     

       9
        
       // Initialize Grafana exporters if configured

     

       10
        
       initializeGrafanaExporters({

     
···

       16
        
       

     

       17
        
       const PORT = process.env.PORT ? parseInt(process.env.PORT) : 3001;

     

       18
        
       const CACHE_DIR = process.env.CACHE_DIR || './cache/sites';

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       19
        
       

     

       20
        
       // Parse CLI arguments

     

       21
        
       const args = process.argv.slice(2);

     
···

       52
        
         console.log('🔄 Backfill requested, starting cache backfill...');

     

       53
        
         backfillCache({

     

       54
        
           skipExisting: true,

     

       55
       -
           concurrency: 3,

     

       56
        
         }).then((stats) => {

     

       57
        
           console.log('✅ Cache backfill completed');

     

       58
        
         }).catch((err) => {

     
···

       83
        
       Cache:        ${CACHE_DIR}

     

       84
        
       Firehose:     Connected to Firehose

     

       85
        
       Cache-Only:   ${CACHE_ONLY_MODE ? 'ENABLED (no DB writes)' : 'DISABLED'}

     

       0
        
       
     

       86
        
       `);

     

       87
        
       

     

       88
        
       // Graceful shutdown

     
···

       90
        
         console.log('\n🛑 Shutting down...');

     

       91
        
         firehose.stop();

     

       92
        
         stopDomainCacheCleanup();

     

       0
        
       
     

       93
        
         server.close();

     

       94
        
         process.exit(0);

     

       95
        
       });

     
···

       98
        
         console.log('\n🛑 Shutting down...');

     

       99
        
         firehose.stop();

     

       100
        
         stopDomainCacheCleanup();

     

       0
        
       
     

       101
        
         server.close();

     

       102
        
         process.exit(0);

     

       103
        
       });

···

       4
        
       import { createLogger, initializeGrafanaExporters } from '@wisp/observability';

     

       5
        
       import { mkdirSync, existsSync } from 'fs';

     

       6
        
       import { backfillCache } from './lib/backfill';

     

       7
       +
       import { startDomainCacheCleanup, stopDomainCacheCleanup, setCacheOnlyMode, closeDatabase } from './lib/db';

     

       8
        
       

     

       9
        
       // Initialize Grafana exporters if configured

     

       10
        
       initializeGrafanaExporters({

     
···

       16
        
       

     

       17
        
       const PORT = process.env.PORT ? parseInt(process.env.PORT) : 3001;

     

       18
        
       const CACHE_DIR = process.env.CACHE_DIR || './cache/sites';

     

       19
       +
       const BACKFILL_CONCURRENCY = process.env.BACKFILL_CONCURRENCY

     

       20
       +
         ? parseInt(process.env.BACKFILL_CONCURRENCY)

     

       21
       +
         : undefined; // Let backfill.ts default (10) apply

     

       22
        
       

     

       23
        
       // Parse CLI arguments

     

       24
        
       const args = process.argv.slice(2);

     
···

       55
        
         console.log('🔄 Backfill requested, starting cache backfill...');

     

       56
        
         backfillCache({

     

       57
        
           skipExisting: true,

     

       58
       +
           concurrency: BACKFILL_CONCURRENCY,

     

       59
        
         }).then((stats) => {

     

       60
        
           console.log('✅ Cache backfill completed');

     

       61
        
         }).catch((err) => {

     
···

       86
        
       Cache:        ${CACHE_DIR}

     

       87
        
       Firehose:     Connected to Firehose

     

       88
        
       Cache-Only:   ${CACHE_ONLY_MODE ? 'ENABLED (no DB writes)' : 'DISABLED'}

     

       89
       +
       Backfill:     ${backfillOnStartup ? `ENABLED (concurrency: ${BACKFILL_CONCURRENCY || 10})` : 'DISABLED'}

     

       90
        
       `);

     

       91
        
       

     

       92
        
       // Graceful shutdown

     
···

       94
        
         console.log('\n🛑 Shutting down...');

     

       95
        
         firehose.stop();

     

       96
        
         stopDomainCacheCleanup();

     

       97
       +
         await closeDatabase();

     

       98
        
         server.close();

     

       99
        
         process.exit(0);

     

       100
        
       });

     
···

       103
        
         console.log('\n🛑 Shutting down...');

     

       104
        
         firehose.stop();

     

       105
        
         stopDomainCacheCleanup();

     

       106
       +
         await closeDatabase();

     

       107
        
         server.close();

     

       108
        
         process.exit(0);

     

       109
        
       });

+65 -57

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

···

       60
        
             console.log(`⚙️  Limited to ${maxSites} sites for backfill`);

     

       61
        
           }

     

       62
        
       

     

       63
       -
           // Process sites in batches

     

       64
       -
           const batches: typeof sites[] = [];

     

       65
       -
           for (let i = 0; i < sites.length; i += concurrency) {

     

       66
       -
             batches.push(sites.slice(i, i + concurrency));

     

       67
       -
           }

     

       68
       -
       

     

       69
        
           let processed = 0;

     

       70
       -
           for (const batch of batches) {

     

       71
       -
             await Promise.all(

     

       72
       -
               batch.map(async (site) => {

     

       73
       -
                 try {

     

       74
       -
                   // Check if already cached

     

       75
       -
                   if (skipExisting && isCached(site.did, site.rkey)) {

     

       76
       -
                     stats.skipped++;

     

       77
       -
                     processed++;

     

       78
       -
                     logger.debug(`Skipping already cached site`, { did: site.did, rkey: site.rkey });

     

       79
       -
                     console.log(`⏭️  [${processed}/${sites.length}] Skipped (cached): ${site.display_name || site.rkey}`);

     

       80
       -
                     return;

     

       81
       -
                   }

     

       82
        
       

     

       83
       -
                   // Fetch site record

     

       84
       -
                   const siteData = await fetchSiteRecord(site.did, site.rkey);

     

       85
       -
                   if (!siteData) {

     

       86
       -
                     stats.failed++;

     

       87
       -
                     processed++;

     

       88
       -
                     logger.error('Site record not found during backfill', null, { did: site.did, rkey: site.rkey });

     

       89
       -
                     console.log(`❌ [${processed}/${sites.length}] Failed (not found): ${site.display_name || site.rkey}`);

     

       90
       -
                     return;

     

       91
       -
                   }

     

       92
       -
       

     

       93
       -
                   // Get PDS endpoint

     

       94
       -
                   const pdsEndpoint = await getPdsForDid(site.did);

     

       95
       -
                   if (!pdsEndpoint) {

     

       96
       -
                     stats.failed++;

     

       97
       -
                     processed++;

     

       98
       -
                     logger.error('PDS not found during backfill', null, { did: site.did });

     

       99
       -
                     console.log(`❌ [${processed}/${sites.length}] Failed (no PDS): ${site.display_name || site.rkey}`);

     

       100
       -
                     return;

     

       101
       -
                   }

     

       102
        
       

     

       103
       -
                   // Mark site as being cached to prevent serving stale content during update

     

       104
       -
                   markSiteAsBeingCached(site.did, site.rkey);

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       105
        
       

     

       106
       -
                   try {

     

       107
       -
                     // Download and cache site

     

       108
       -
                     await downloadAndCacheSite(site.did, site.rkey, siteData.record, pdsEndpoint, siteData.cid);

     

       109
       -
                     // Clear redirect rules cache since the site was updated

     

       110
       -
                     clearRedirectRulesCache(site.did, site.rkey);

     

       111
       -
                     stats.cached++;

     

       112
       -
                     processed++;

     

       113
       -
                     logger.info('Successfully cached site during backfill', { did: site.did, rkey: site.rkey });

     

       114
       -
                     console.log(`✅ [${processed}/${sites.length}] Cached: ${site.display_name || site.rkey}`);

     

       115
       -
                   } finally {

     

       116
       -
                     // Always unmark, even if caching fails

     

       117
       -
                     unmarkSiteAsBeingCached(site.did, site.rkey);

     

       118
       -
                   }

     

       119
       -
                 } catch (err) {

     

       120
        
                   stats.failed++;

     

       121
        
                   processed++;

     

       122
       -
                   logger.error('Failed to cache site during backfill', err, { did: site.did, rkey: site.rkey });

     

       123
       -
                   console.log(`❌ [${processed}/${sites.length}] Failed: ${site.display_name || site.rkey}`);

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       124
        
                 }

     

       125
       -
               })

     

       126
       -
             );

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       127
        
           }

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       128
        
       

     

       129
        
           stats.duration = Date.now() - startTime;

     

       130

···

       60
        
             console.log(`⚙️  Limited to ${maxSites} sites for backfill`);

     

       61
        
           }

     

       62
        
       

     

       63
       +
           // Process sites with sliding window concurrency pool

     

       64
       +
           const executing = new Set<Promise<void>>();

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       65
        
           let processed = 0;

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       66
        
       

     

       67
       +
           for (const site of sites) {

     

       68
       +
             // Create task for this site

     

       69
       +
             const processSite = async () => {

     

       70
       +
               try {

     

       71
       +
                 // Check if already cached

     

       72
       +
                 if (skipExisting && isCached(site.did, site.rkey)) {

     

       73
       +
                   stats.skipped++;

     

       74
       +
                   processed++;

     

       75
       +
                   logger.debug(`Skipping already cached site`, { did: site.did, rkey: site.rkey });

     

       76
       +
                   console.log(`⏭️  [${processed}/${sites.length}] Skipped (cached): ${site.display_name || site.rkey}`);

     

       77
       +
                   return;

     

       78
       +
                 }

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       79
        
       

     

       80
       +
                 // Fetch site record

     

       81
       +
                 const siteData = await fetchSiteRecord(site.did, site.rkey);

     

       82
       +
                 if (!siteData) {

     

       83
       +
                   stats.failed++;

     

       84
       +
                   processed++;

     

       85
       +
                   logger.error('Site record not found during backfill', null, { did: site.did, rkey: site.rkey });

     

       86
       +
                   console.log(`❌ [${processed}/${sites.length}] Failed (not found): ${site.display_name || site.rkey}`);

     

       87
       +
                   return;

     

       88
       +
                 }

     

       89
        
       

     

       90
       +
                 // Get PDS endpoint

     

       91
       +
                 const pdsEndpoint = await getPdsForDid(site.did);

     

       92
       +
                 if (!pdsEndpoint) {

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       93
        
                   stats.failed++;

     

       94
        
                   processed++;

     

       95
       +
                   logger.error('PDS not found during backfill', null, { did: site.did });

     

       96
       +
                   console.log(`❌ [${processed}/${sites.length}] Failed (no PDS): ${site.display_name || site.rkey}`);

     

       97
       +
                   return;

     

       98
       +
                 }

     

       99
       +
       

     

       100
       +
                 // Mark site as being cached to prevent serving stale content during update

     

       101
       +
                 markSiteAsBeingCached(site.did, site.rkey);

     

       102
       +
       

     

       103
       +
                 try {

     

       104
       +
                   // Download and cache site

     

       105
       +
                   await downloadAndCacheSite(site.did, site.rkey, siteData.record, pdsEndpoint, siteData.cid);

     

       106
       +
                   // Clear redirect rules cache since the site was updated

     

       107
       +
                   clearRedirectRulesCache(site.did, site.rkey);

     

       108
       +
                   stats.cached++;

     

       109
       +
                   processed++;

     

       110
       +
                   logger.info('Successfully cached site during backfill', { did: site.did, rkey: site.rkey });

     

       111
       +
                   console.log(`✅ [${processed}/${sites.length}] Cached: ${site.display_name || site.rkey}`);

     

       112
       +
                 } finally {

     

       113
       +
                   // Always unmark, even if caching fails

     

       114
       +
                   unmarkSiteAsBeingCached(site.did, site.rkey);

     

       115
        
                 }

     

       116
       +
               } catch (err) {

     

       117
       +
                 stats.failed++;

     

       118
       +
                 processed++;

     

       119
       +
                 logger.error('Failed to cache site during backfill', err, { did: site.did, rkey: site.rkey });

     

       120
       +
                 console.log(`❌ [${processed}/${sites.length}] Failed: ${site.display_name || site.rkey}`);

     

       121
       +
               }

     

       122
       +
             };

     

       123
       +
       

     

       124
       +
             // Add to executing pool and remove when done

     

       125
       +
             const promise = processSite().finally(() => executing.delete(promise));

     

       126
       +
             executing.add(promise);

     

       127
       +
       

     

       128
       +
             // When pool is full, wait for at least one to complete

     

       129
       +
             if (executing.size >= concurrency) {

     

       130
       +
               await Promise.race(executing);

     

       131
       +
             }

     

       132
        
           }

     

       133
       +
       

     

       134
       +
           // Wait for all remaining tasks to complete

     

       135
       +
           await Promise.all(executing);

     

       136
        
       

     

       137
        
           stats.duration = Date.now() - startTime;

     

       138

+32 -1

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

···

       183
        
         return hashNum & 0x7FFFFFFFFFFFFFFFn;

     

       184
        
       }

     

       185
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       186
        
       /**

     

       187
        
        * Acquire a distributed lock using PostgreSQL advisory locks

     

       188
        
        * Returns true if lock was acquired, false if already held by another instance

     
···

       193
        
       

     

       194
        
         try {

     

       195
        
           const result = await sql`SELECT pg_try_advisory_lock(${Number(lockId)}) as acquired`;

     

       196
       -
           return result[0]?.acquired === true;

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       197
        
         } catch (err) {

     

       198
        
           console.error('Failed to acquire lock', { key, error: err });

     

       199
        
           return false;

     
···

       208
        
       

     

       209
        
         try {

     

       210
        
           await sql`SELECT pg_advisory_unlock(${Number(lockId)})`;

     

       0
        
       
     

       211
        
         } catch (err) {

     

       212
        
           console.error('Failed to release lock', { key, error: err });

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       213
        
         }

     

       214
        
       }

     

       215

···

       183
        
         return hashNum & 0x7FFFFFFFFFFFFFFFn;

     

       184
        
       }

     

       185
        
       

     

       186
       +
       // Track active locks for cleanup on shutdown

     

       187
       +
       const activeLocks = new Set<string>();

     

       188
       +
       

     

       189
        
       /**

     

       190
        
        * Acquire a distributed lock using PostgreSQL advisory locks

     

       191
        
        * Returns true if lock was acquired, false if already held by another instance

     
···

       196
        
       

     

       197
        
         try {

     

       198
        
           const result = await sql`SELECT pg_try_advisory_lock(${Number(lockId)}) as acquired`;

     

       199
       +
           const acquired = result[0]?.acquired === true;

     

       200
       +
           if (acquired) {

     

       201
       +
             activeLocks.add(key);

     

       202
       +
           }

     

       203
       +
           return acquired;

     

       204
        
         } catch (err) {

     

       205
        
           console.error('Failed to acquire lock', { key, error: err });

     

       206
        
           return false;

     
···

       215
        
       

     

       216
        
         try {

     

       217
        
           await sql`SELECT pg_advisory_unlock(${Number(lockId)})`;

     

       218
       +
           activeLocks.delete(key);

     

       219
        
         } catch (err) {

     

       220
        
           console.error('Failed to release lock', { key, error: err });

     

       221
       +
           // Still remove from tracking even if unlock fails

     

       222
       +
           activeLocks.delete(key);

     

       223
       +
         }

     

       224
       +
       }

     

       225
       +
       

     

       226
       +
       /**

     

       227
       +
        * Close all database connections

     

       228
       +
        * Call this during graceful shutdown

     

       229
       +
        */

     

       230
       +
       export async function closeDatabase(): Promise<void> {

     

       231
       +
         try {

     

       232
       +
           // Release all active advisory locks before closing connections

     

       233
       +
           if (activeLocks.size > 0) {

     

       234
       +
             console.log(`[DB] Releasing ${activeLocks.size} active advisory locks before shutdown`);

     

       235
       +
             for (const key of activeLocks) {

     

       236
       +
               await releaseLock(key);

     

       237
       +
             }

     

       238
       +
           }

     

       239
       +
       

     

       240
       +
           await sql.end({ timeout: 5 });

     

       241
       +
           console.log('[DB] Database connections closed');

     

       242
       +
         } catch (err) {

     

       243
       +
           console.error('[DB] Error closing database connections:', err);

     

       244
        
         }

     

       245
        
       }

     

       246

+26 -2

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

···

       90
        
       export async function fetchSiteRecord(did: string, rkey: string): Promise<{ record: WispFsRecord; cid: string } | null> {

     

       91
        
         try {

     

       92
        
           const pdsEndpoint = await getPdsForDid(did);

     

       93
       -
           if (!pdsEndpoint) return null;

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       94
        
       

     

       95
        
           const url = `${pdsEndpoint}/xrpc/com.atproto.repo.getRecord?repo=${encodeURIComponent(did)}&collection=place.wisp.fs&rkey=${encodeURIComponent(rkey)}`;

     

       96
        
           const data = await safeFetchJson(url);

     
···

       100
        
             cid: data.cid || ''

     

       101
        
           };

     

       102
        
         } catch (err) {

     

       103
       -
           console.error('Failed to fetch site record', did, rkey, err);

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       104
        
           return null;

     

       105
        
         }

     

       106
        
       }

···

       90
        
       export async function fetchSiteRecord(did: string, rkey: string): Promise<{ record: WispFsRecord; cid: string } | null> {

     

       91
        
         try {

     

       92
        
           const pdsEndpoint = await getPdsForDid(did);

     

       93
       +
           if (!pdsEndpoint) {

     

       94
       +
             console.error('[hosting-service] Failed to get PDS endpoint for DID', { did, rkey });

     

       95
       +
             return null;

     

       96
       +
           }

     

       97
        
       

     

       98
        
           const url = `${pdsEndpoint}/xrpc/com.atproto.repo.getRecord?repo=${encodeURIComponent(did)}&collection=place.wisp.fs&rkey=${encodeURIComponent(rkey)}`;

     

       99
        
           const data = await safeFetchJson(url);

     
···

       103
        
             cid: data.cid || ''

     

       104
        
           };

     

       105
        
         } catch (err) {

     

       106
       +
           const errorCode = (err as any)?.code;

     

       107
       +
           const errorMsg = err instanceof Error ? err.message : String(err);

     

       108
       +
       

     

       109
       +
           // Better error logging to distinguish between network errors and 404s

     

       110
       +
           if (errorMsg.includes('HTTP 404') || errorMsg.includes('Not Found')) {

     

       111
       +
             console.log('[hosting-service] Site record not found', { did, rkey });

     

       112
       +
           } else if (errorCode && ['ECONNRESET', 'ERR_SSL_TLSV1_ALERT_INTERNAL_ERROR', 'ETIMEDOUT'].includes(errorCode)) {

     

       113
       +
             console.error('[hosting-service] Network/SSL error fetching site record (after retries)', {

     

       114
       +
               did,

     

       115
       +
               rkey,

     

       116
       +
               error: errorMsg,

     

       117
       +
               code: errorCode

     

       118
       +
             });

     

       119
       +
           } else {

     

       120
       +
             console.error('[hosting-service] Failed to fetch site record', {

     

       121
       +
               did,

     

       122
       +
               rkey,

     

       123
       +
               error: errorMsg,

     

       124
       +
               code: errorCode

     

       125
       +
             });

     

       126
       +
           }

     

       127
       +
       

     

       128
        
           return null;

     

       129
        
         }

     

       130
        
       }

+1 -1

apps/main-app/package.json

···

       41
        
           "bun-plugin-tailwind": "^0.1.2",

     

       42
        
           "class-variance-authority": "^0.7.1",

     

       43
        
           "clsx": "^2.1.1",

     

       44
       -
           "elysia": "latest",

     

       45
        
           "ignore": "^7.0.5",

     

       46
        
           "iron-session": "^8.0.4",

     

       47
        
           "lucide-react": "^0.546.0",

···

       41
        
           "bun-plugin-tailwind": "^0.1.2",

     

       42
        
           "class-variance-authority": "^0.7.1",

     

       43
        
           "clsx": "^2.1.1",

     

       44
       +
           "elysia": "^1.4.18",

     

       45
        
           "ignore": "^7.0.5",

     

       46
        
           "iron-session": "^8.0.4",

     

       47
        
           "lucide-react": "^0.546.0",

+4 -4

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

···

       6
        
       

     

       7
        
       function AcceptableUsePage() {

     

       8
        
       	return (

     

       9
       -
       		<div className="min-h-screen bg-background">

     

       10
        
       			{/* Header */}

     

       11
       -
       			<header className="border-b border-border/40 bg-background/80 backdrop-blur-sm sticky top-0 z-50">

     

       12
       -
       				<div className="container mx-auto px-4 py-4 flex items-center justify-between">

     

       13
        
       					<div className="flex items-center gap-2">

     

       14
        
       						<img src="/transparent-full-size-ico.png" alt="wisp.place" className="w-8 h-8" />

     

       15
        
       						<span className="text-xl font-semibold text-foreground">

     
···

       326
        
       			</div>

     

       327
        
       

     

       328
        
       			{/* Footer */}

     

       329
       -
       			<footer className="border-t border-border/40 bg-muted/20 mt-12">

     

       330
        
       				<div className="container mx-auto px-4 py-8">

     

       331
        
       					<div className="text-center text-sm text-muted-foreground">

     

       332
        
       						<p>

···

       6
        
       

     

       7
        
       function AcceptableUsePage() {

     

       8
        
       	return (

     

       9
       +
       		<div className="w-full min-h-screen bg-background flex flex-col">

     

       10
        
       			{/* Header */}

     

       11
       +
       			<header className="w-full border-b border-border/40 bg-background/80 backdrop-blur-sm sticky top-0 z-50">

     

       12
       +
       				<div className="max-w-6xl w-full mx-auto px-4 h-16 flex items-center justify-between">

     

       13
        
       					<div className="flex items-center gap-2">

     

       14
        
       						<img src="/transparent-full-size-ico.png" alt="wisp.place" className="w-8 h-8" />

     

       15
        
       						<span className="text-xl font-semibold text-foreground">

     
···

       326
        
       			</div>

     

       327
        
       

     

       328
        
       			{/* Footer */}

     

       329
       +
       			<footer className="border-t border-border/40 bg-muted/20 mt-auto">

     

       330
        
       				<div className="container mx-auto px-4 py-8">

     

       331
        
       					<div className="text-center text-sm text-muted-foreground">

     

       332
        
       						<p>

+1 -1

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

···

       12
        
           <CheckboxPrimitive.Root

     

       13
        
             data-slot="checkbox"

     

       14
        
             className={cn(

     

       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",

     

       16
        
               className

     

       17
        
             )}

     

       18
        
             {...props}

···

       12
        
           <CheckboxPrimitive.Root

     

       13
        
             data-slot="checkbox"

     

       14
        
             className={cn(

     

       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
        
               className

     

       17
        
             )}

     

       18
        
             {...props}

+6 -6

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

···

       302
        
       		return (

     

       303
        
       			<div className="w-full min-h-screen bg-background">

     

       304
        
       				{/* Header Skeleton */}

     

       305
       -
       				<header className="border-b border-border/40 bg-background/80 backdrop-blur-sm sticky top-0 z-50">

     

       306
       -
       					<div className="container mx-auto px-4 py-4 flex items-center justify-between">

     

       307
        
       						<div className="flex items-center gap-2">

     

       308
        
       							<img src="/transparent-full-size-ico.png" alt="wisp.place" className="w-8 h-8" />

     

       309
        
       							<span className="text-xl font-semibold text-foreground">

     
···

       366
        
       	}

     

       367
        
       

     

       368
        
       	return (

     

       369
       -
       		<div className="w-full min-h-screen bg-background">

     

       370
        
       			{/* Header */}

     

       371
       -
       			<header className="border-b border-border/40 bg-background/80 backdrop-blur-sm sticky top-0 z-50">

     

       372
       -
       				<div className="container mx-auto px-4 py-4 flex items-center justify-between">

     

       373
        
       					<div className="flex items-center gap-2">

     

       374
        
       						<img src="/transparent-full-size-ico.png" alt="wisp.place" className="w-8 h-8" />

     

       375
        
       						<span className="text-xl font-semibold text-foreground">

     
···

       454
        
       			</div>

     

       455
        
       

     

       456
        
       			{/* Footer */}

     

       457
       -
       			<footer className="border-t border-border/40 bg-muted/20 mt-12">

     

       458
        
       				<div className="container mx-auto px-4 py-8">

     

       459
        
       					<div className="text-center text-sm text-muted-foreground">

     

       460
        
       						<p>

···

       302
        
       		return (

     

       303
        
       			<div className="w-full min-h-screen bg-background">

     

       304
        
       				{/* Header Skeleton */}

     

       305
       +
       				<header className="w-full border-b border-border/40 bg-background/80 backdrop-blur-sm sticky top-0 z-50">

     

       306
       +
       					<div className="max-w-6xl w-full mx-auto px-4 h-16 flex items-center justify-between">

     

       307
        
       						<div className="flex items-center gap-2">

     

       308
        
       							<img src="/transparent-full-size-ico.png" alt="wisp.place" className="w-8 h-8" />

     

       309
        
       							<span className="text-xl font-semibold text-foreground">

     
···

       366
        
       	}

     

       367
        
       

     

       368
        
       	return (

     

       369
       +
       		<div className="w-full min-h-screen bg-background flex flex-col">

     

       370
        
       			{/* Header */}

     

       371
       +
       			<header className="w-full border-b border-border/40 bg-background/80 backdrop-blur-sm sticky top-0 z-50">

     

       372
       +
       				<div className="max-w-6xl w-full mx-auto px-4 h-16 flex items-center justify-between">

     

       373
        
       					<div className="flex items-center gap-2">

     

       374
        
       						<img src="/transparent-full-size-ico.png" alt="wisp.place" className="w-8 h-8" />

     

       375
        
       						<span className="text-xl font-semibold text-foreground">

     
···

       454
        
       			</div>

     

       455
        
       

     

       456
        
       			{/* Footer */}

     

       457
       +
       			<footer className="border-t border-border/40 bg-muted/20 mt-auto">

     

       458
        
       				<div className="container mx-auto px-4 py-8">

     

       459
        
       					<div className="text-center text-sm text-muted-foreground">

     

       460
        
       						<p>

+74 -66

apps/main-app/public/index.tsx

···

       88
        
       

     

       89
        
       	const handleKeyDown = (e: React.KeyboardEvent<HTMLInputElement>) => {

     

       90
        
       		const navigationKeys = ['ArrowDown', 'ArrowUp', 'PageDown', 'PageUp', 'Enter', 'Escape']

     

       91
       -
       		

     

       92
        
       		// Mark that we should preserve the index for navigation keys

     

       93
        
       		if (navigationKeys.includes(e.key)) {

     

       94
        
       			preserveIndexRef.current = true

     
···

       142
        
       		setIndex(-1)

     

       143
        
       		setIsOpen(false)

     

       144
        
       		onSelect?.(handle)

     

       145
       -
       		

     

       146
        
       		// Auto-submit the form if enabled

     

       147
        
       		if (autoSubmit && inputRef.current) {

     

       148
        
       			const form = inputRef.current.closest('form')

     
···

       236
        
       									height: 'calc(1.5rem + 12px)',

     

       237
        
       									borderRadius: '4px',

     

       238
        
       									cursor: 'pointer',

     

       239
       -
       									backgroundColor: i === index ? 'hsl(var(--accent) / 0.5)' : 'transparent',

     

       240
        
       									transition: 'background-color 0.1s'

     

       241
        
       								}}

     

       242
        
       								onMouseEnter={() => setIndex(i)}

     
···

       246
        
       										width: '1.5rem',

     

       247
        
       										height: '1.5rem',

     

       248
        
       										borderRadius: '50%',

     

       249
       -
       										backgroundColor: 'hsl(var(--muted))',

     

       250
        
       										overflow: 'hidden',

     

       251
        
       										flexShrink: 0

     

       252
        
       									}}

     
···

       255
        
       										<img

     

       256
        
       											src={actor.avatar}

     

       257
        
       											alt=""

     

       0
        
       
     

       258
        
       											style={{

     

       259
        
       												display: 'block',

     

       260
        
       												width: '100%',

     
···

       359
        
       

     

       360
        
       	return (

     

       361
        
       		<>

     

       362
       -
       			<div className="min-h-screen">

     

       363
        
       				{/* Header */}

     

       364
       -
       				<header className="border-b border-border/40 bg-background/80 backdrop-blur-sm sticky top-0 z-50">

     

       365
       -
       					<div className="container mx-auto px-4 py-4 flex items-center justify-between">

     

       366
        
       						<div className="flex items-center gap-2">

     

       367
        
       							<img src="/transparent-full-size-ico.png" alt="wisp.place" className="w-8 h-8" />

     

       368
       -
       							<span className="text-xl font-semibold text-foreground">

     

       369
        
       								wisp.place

     

       370
        
       							</span>

     

       371
        
       						</div>

     

       372
       -
       						<div className="flex items-center gap-3">

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       373
        
       							<Button

     

       374
       -
       								variant="ghost"

     

       375
        
       								size="sm"

     

       0
        
       
     

       376
        
       								onClick={() => setShowForm(true)}

     

       377
        
       							>

     

       378
        
       								Sign In

     

       379
        
       							</Button>

     

       380
       -
       							<Button

     

       381
       -
       								size="sm"

     

       382
       -
       								className="bg-accent text-accent-foreground hover:bg-accent/90"

     

       383
       -
       								asChild

     

       384
       -
       							>

     

       385
       -
       								<a href="https://docs.wisp.place" target="_blank" rel="noopener noreferrer">

     

       386
       -
       									Read the Docs

     

       387
       -
       								</a>

     

       388
       -
       							</Button>

     

       389
        
       						</div>

     

       390
        
       					</div>

     

       391
        
       				</header>

     

       392
        
       

     

       393
        
       				{/* Hero Section */}

     

       394
       -
       				<section className="container mx-auto px-4 py-20 md:py-32">

     

       395
        
       					<div className="max-w-4xl mx-auto text-center">

     

       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
       -
       							<span className="w-2 h-2 bg-accent rounded-full animate-pulse"></span>

     

       398
       -
       							<span className="text-sm text-foreground">

     

       399
       -
       								Built on AT Protocol

     

       400
       -
       							</span>

     

       401
       -
       						</div>

     

       402
       -
       

     

       403
       -
       						<h1 className="text-5xl md:text-7xl font-bold text-balance mb-6 leading-tight">

     

       404
       -
       							Your Website.Your Control. Lightning Fast.

     

       405
        
       						</h1>

     

       406
        
       

     

       407
       -
       						<p className="text-xl md:text-2xl text-muted-foreground text-balance mb-10 leading-relaxed max-w-3xl mx-auto">

     

       408
       -
       							Host static sites in your AT Protocol account. You

     

       409
       -
       							keep ownership and control. We just serve them fast

     

       410
       -
       							through our CDN.

     

       0
        
       
     

       411
        
       						</p>

     

       412
        
       

     

       413
       -
       						<div className="max-w-md mx-auto relative">

     

       0
        
       
     

       414
        
       							<div

     

       415
       -
       								className={`transition-all duration-500 ease-in-out ${

     

       416
       -
       									showForm

     

       417
       -
       										? 'opacity-0 -translate-y-5 pointer-events-none'

     

       418
       -
       										: 'opacity-100 translate-y-0'

     

       419
       -
       								}`}

     

       420
        
       							>

     

       421
       -
       								<Button

     

       422
       -
       									size="lg"

     

       423
       -
       									className="bg-primary text-primary-foreground hover:bg-primary/90 text-lg px-8 py-6 w-full"

     

       424
       -
       									onClick={() => setShowForm(true)}

     

       425
       -
       								>

     

       426
       -
       									Log in with AT Proto

     

       427
       -
       									<ArrowRight className="ml-2 w-5 h-5" />

     

       428
       -
       								</Button>

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       429
        
       							</div>

     

       430
        
       

     

       431
        
       							<div

     

       432
       -
       								className={`transition-all duration-500 ease-in-out absolute inset-0 ${

     

       433
       -
       									showForm

     

       434
       -
       										? 'opacity-100 translate-y-0'

     

       435
       -
       										: 'opacity-0 translate-y-5 pointer-events-none'

     

       436
       -
       								}`}

     

       437
        
       							>

     

       438
        
       								<form

     

       439
        
       									onSubmit={async (e) => {

     
···

       494
        
       									</ActorTypeahead>

     

       495
        
       									<button

     

       496
        
       										type="submit"

     

       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"

     

       498
        
       									>

     

       499
        
       										Continue

     

       500
        
       										<ArrowRight className="ml-2 w-5 h-5" />

     
···

       518
        
       								</div>

     

       519
        
       								<div>

     

       520
        
       									<h3 className="text-xl font-semibold mb-2">

     

       521
       -
       										Upload your static site

     

       522
        
       									</h3>

     

       523
        
       									<p className="text-muted-foreground">

     

       524
       -
       										Your HTML, CSS, and JavaScript files are

     

       525
       -
       										stored in your AT Protocol account as

     

       526
       -
       										gzipped blobs and a manifest record.

     

       527
        
       									</p>

     

       528
        
       								</div>

     

       529
        
       							</div>

     
···

       533
        
       								</div>

     

       534
        
       								<div>

     

       535
        
       									<h3 className="text-xl font-semibold mb-2">

     

       536
       -
       										We serve it globally

     

       537
        
       									</h3>

     

       538
        
       									<p className="text-muted-foreground">

     

       539
       -
       										Wisp.place reads your site from your

     

       540
       -
       										account and delivers it through our CDN

     

       541
       -
       										for fast loading anywhere.

     

       542
        
       									</p>

     

       543
        
       								</div>

     

       544
        
       							</div>

     
···

       548
        
       								</div>

     

       549
        
       								<div>

     

       550
        
       									<h3 className="text-xl font-semibold mb-2">

     

       551
       -
       										You stay in control

     

       552
        
       									</h3>

     

       553
        
       									<p className="text-muted-foreground">

     

       554
       -
       										Update or remove your site anytime

     

       555
       -
       										through your AT Protocol account. No

     

       556
       -
       										lock-in, no middleman ownership.

     

       557
        
       									</p>

     

       558
        
       								</div>

     

       559
        
       							</div>

     
···

       686
        
       				</section>

     

       687
        
       

     

       688
        
       				{/* Footer */}

     

       689
       -
       				<footer className="border-t border-border/40 bg-muted/20">

     

       690
        
       					<div className="container mx-auto px-4 py-8">

     

       691
        
       						<div className="text-center text-sm text-muted-foreground">

     

       692
        
       							<p>

···

       88
        
       

     

       89
        
       	const handleKeyDown = (e: React.KeyboardEvent<HTMLInputElement>) => {

     

       90
        
       		const navigationKeys = ['ArrowDown', 'ArrowUp', 'PageDown', 'PageUp', 'Enter', 'Escape']

     

       91
       +
       

     

       92
        
       		// Mark that we should preserve the index for navigation keys

     

       93
        
       		if (navigationKeys.includes(e.key)) {

     

       94
        
       			preserveIndexRef.current = true

     
···

       142
        
       		setIndex(-1)

     

       143
        
       		setIsOpen(false)

     

       144
        
       		onSelect?.(handle)

     

       145
       +
       

     

       146
        
       		// Auto-submit the form if enabled

     

       147
        
       		if (autoSubmit && inputRef.current) {

     

       148
        
       			const form = inputRef.current.closest('form')

     
···

       236
        
       									height: 'calc(1.5rem + 12px)',

     

       237
        
       									borderRadius: '4px',

     

       238
        
       									cursor: 'pointer',

     

       239
       +
       									backgroundColor: i === index ? 'color-mix(in oklch, var(--accent) 50%, transparent)' : 'transparent',

     

       240
        
       									transition: 'background-color 0.1s'

     

       241
        
       								}}

     

       242
        
       								onMouseEnter={() => setIndex(i)}

     
···

       246
        
       										width: '1.5rem',

     

       247
        
       										height: '1.5rem',

     

       248
        
       										borderRadius: '50%',

     

       249
       +
       										backgroundColor: 'var(--muted)',

     

       250
        
       										overflow: 'hidden',

     

       251
        
       										flexShrink: 0

     

       252
        
       									}}

     
···

       255
        
       										<img

     

       256
        
       											src={actor.avatar}

     

       257
        
       											alt=""

     

       258
       +
       											loading="lazy"

     

       259
        
       											style={{

     

       260
        
       												display: 'block',

     

       261
        
       												width: '100%',

     
···

       360
        
       

     

       361
        
       	return (

     

       362
        
       		<>

     

       363
       +
       			<div className="w-full min-h-screen flex flex-col">

     

       364
        
       				{/* Header */}

     

       365
       +
       				<header className="w-full border-b border-border/40 bg-background/80 backdrop-blur-sm sticky top-0 z-50">

     

       366
       +
       					<div className="max-w-6xl w-full mx-auto px-4 h-16 flex items-center justify-between">

     

       367
        
       						<div className="flex items-center gap-2">

     

       368
        
       							<img src="/transparent-full-size-ico.png" alt="wisp.place" className="w-8 h-8" />

     

       369
       +
       							<span className="text-lg font-semibold text-foreground">

     

       370
        
       								wisp.place

     

       371
        
       							</span>

     

       372
        
       						</div>

     

       373
       +
       						<div className="flex items-center gap-4">

     

       374
       +
       							<a

     

       375
       +
       								href="https://docs.wisp.place"

     

       376
       +
       								target="_blank"

     

       377
       +
       								rel="noopener noreferrer"

     

       378
       +
       								className="text-sm text-muted-foreground hover:text-foreground transition-colors"

     

       379
       +
       							>

     

       380
       +
       								Read the Docs

     

       381
       +
       							</a>

     

       382
        
       							<Button

     

       383
       +
       								variant="outline"

     

       384
        
       								size="sm"

     

       385
       +
       								className="btn-hover-lift"

     

       386
        
       								onClick={() => setShowForm(true)}

     

       387
        
       							>

     

       388
        
       								Sign In

     

       389
        
       							</Button>

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       390
        
       						</div>

     

       391
        
       					</div>

     

       392
        
       				</header>

     

       393
        
       

     

       394
        
       				{/* Hero Section */}

     

       395
       +
       				<section className="container mx-auto px-4 py-24 md:py-36">

     

       396
        
       					<div className="max-w-4xl mx-auto text-center">

     

       397
       +
       						{/* Main Headline */}

     

       398
       +
       						<h1 className="animate-fade-in-up animate-delay-100 text-5xl md:text-7xl font-bold mb-2 leading-tight tracking-tight">

     

       399
       +
       							Deploy Anywhere.

     

       400
       +
       						</h1>

     

       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
       +
       							For Free. Forever.

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       403
        
       						</h1>

     

       404
        
       

     

       405
       +
       						{/* Subheadline */}

     

       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
       +
       							The easiest way to deploy and orchestrate static sites.

     

       408
       +
       							Push updates instantly. Host on our infrastructure or yours.

     

       409
       +
       							All powered by AT Protocol.

     

       410
        
       						</p>

     

       411
        
       

     

       412
       +
       						{/* CTA Buttons */}

     

       413
       +
       						<div className="animate-fade-in-up animate-delay-400 max-w-lg mx-auto relative">

     

       414
        
       							<div

     

       415
       +
       								className={`transition-all duration-500 ease-in-out ${showForm

     

       416
       +
       									? 'opacity-0 -translate-y-5 pointer-events-none absolute inset-0'

     

       417
       +
       									: 'opacity-100 translate-y-0'

     

       418
       +
       									}`}

     

       0
        
       
     

       419
        
       							>

     

       420
       +
       								<div className="flex flex-col sm:flex-row gap-3 justify-center">

     

       421
       +
       									<Button

     

       422
       +
       										size="lg"

     

       423
       +
       										className="bg-foreground text-background hover:bg-foreground/90 text-base px-6 py-5 btn-hover-lift"

     

       424
       +
       										onClick={() => setShowForm(true)}

     

       425
       +
       									>

     

       426
       +
       										<span className="mr-2 font-bold">@</span>

     

       427
       +
       										Deploy with AT

     

       428
       +
       									</Button>

     

       429
       +
       									<Button

     

       430
       +
       										variant="outline"

     

       431
       +
       										size="lg"

     

       432
       +
       										className="text-base px-6 py-5 btn-hover-lift"

     

       433
       +
       										asChild

     

       434
       +
       									>

     

       435
       +
       										<a href="https://docs.wisp.place/cli/" target="_blank" rel="noopener noreferrer">

     

       436
       +
       											<span className="font-mono mr-2 text-muted-foreground">&gt;_</span>

     

       437
       +
       											Install wisp-cli

     

       438
       +
       										</a>

     

       439
       +
       									</Button>

     

       440
       +
       								</div>

     

       441
        
       							</div>

     

       442
        
       

     

       443
        
       							<div

     

       444
       +
       								className={`transition-all duration-500 ease-in-out ${showForm

     

       445
       +
       									? 'opacity-100 translate-y-0'

     

       446
       +
       									: 'opacity-0 translate-y-5 pointer-events-none absolute inset-0'

     

       447
       +
       									}`}

     

       0
        
       
     

       448
        
       							>

     

       449
        
       								<form

     

       450
        
       									onSubmit={async (e) => {

     
···

       505
        
       									</ActorTypeahead>

     

       506
        
       									<button

     

       507
        
       										type="submit"

     

       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"

     

       509
        
       									>

     

       510
        
       										Continue

     

       511
        
       										<ArrowRight className="ml-2 w-5 h-5" />

     
···

       529
        
       								</div>

     

       530
        
       								<div>

     

       531
        
       									<h3 className="text-xl font-semibold mb-2">

     

       532
       +
       										Drop in your files

     

       533
        
       									</h3>

     

       534
        
       									<p className="text-muted-foreground">

     

       535
       +
       										Upload your site through our dashboard or push with the CLI.

     

       536
       +
       										Everything gets stored directly in your AT Protocol account.

     

       0
        
       
     

       537
        
       									</p>

     

       538
        
       								</div>

     

       539
        
       							</div>

     
···

       543
        
       								</div>

     

       544
        
       								<div>

     

       545
        
       									<h3 className="text-xl font-semibold mb-2">

     

       546
       +
       										We handle the rest

     

       547
        
       									</h3>

     

       548
        
       									<p className="text-muted-foreground">

     

       549
       +
       										Your site goes live instantly on our global CDN.

     

       550
       +
       										Custom domains, HTTPS, caching—all automatic.

     

       0
        
       
     

       551
        
       									</p>

     

       552
        
       								</div>

     

       553
        
       							</div>

     
···

       557
        
       								</div>

     

       558
        
       								<div>

     

       559
        
       									<h3 className="text-xl font-semibold mb-2">

     

       560
       +
       										Push updates instantly

     

       561
        
       									</h3>

     

       562
        
       									<p className="text-muted-foreground">

     

       563
       +
       										Ship changes in seconds. Update through the dashboard,

     

       564
       +
       										run wisp-cli deploy, or wire up your CI/CD pipeline.

     

       0
        
       
     

       565
        
       									</p>

     

       566
        
       								</div>

     

       567
        
       							</div>

     
···

       694
        
       				</section>

     

       695
        
       

     

       696
        
       				{/* Footer */}

     

       697
       +
       				<footer className="border-t border-border/40 bg-muted/20 mt-auto">

     

       698
        
       					<div className="container mx-auto px-4 py-8">

     

       699
        
       						<div className="text-center text-sm text-muted-foreground">

     

       700
        
       							<p>

+16 -19

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

···

       161
        
       	return (

     

       162
        
       		<div className="w-full min-h-screen bg-background">

     

       163
        
       			{/* Header */}

     

       164
       -
       			<header className="border-b border-border/40 bg-background/80 backdrop-blur-sm sticky top-0 z-50">

     

       165
       -
       				<div className="container mx-auto px-4 py-4 flex items-center justify-between">

     

       166
        
       					<div className="flex items-center gap-2">

     

       167
        
       						<div className="w-8 h-8 bg-primary rounded-lg flex items-center justify-center">

     

       168
        
       							<Globe className="w-5 h-5 text-primary-foreground" />

     
···

       179
        
       				<div className="mb-8">

     

       180
        
       					<div className="flex items-center justify-center gap-2 mb-4">

     

       181
        
       						<div

     

       182
       -
       							className={`w-8 h-8 rounded-full flex items-center justify-center ${

     

       183
       -
       								step === 'domain'

     

       184
       -
       									? 'bg-primary text-primary-foreground'

     

       185
       -
       									: 'bg-green-500 text-white'

     

       186
       -
       							}`}

     

       187
        
       						>

     

       188
        
       							{step === 'domain' ? (

     

       189
        
       								'1'

     
···

       193
        
       						</div>

     

       194
        
       						<div className="w-16 h-0.5 bg-border"></div>

     

       195
        
       						<div

     

       196
       -
       							className={`w-8 h-8 rounded-full flex items-center justify-center ${

     

       197
       -
       								step === 'upload'

     

       198
       -
       									? 'bg-primary text-primary-foreground'

     

       199
       -
       									: step === 'domain'

     

       200
       -
       										? 'bg-muted text-muted-foreground'

     

       201
       -
       										: 'bg-green-500 text-white'

     

       202
       -
       							}`}

     

       203
        
       						>

     

       204
        
       							{step === 'complete' ? (

     

       205
        
       								<CheckCircle2 className="w-5 h-5" />

     
···

       258
        
       										{!isCheckingAvailability &&

     

       259
        
       											isAvailable !== null && (

     

       260
        
       												<div

     

       261
       -
       													className={`absolute right-3 top-1/2 -translate-y-1/2 ${

     

       262
       -
       														isAvailable

     

       263
       -
       															? 'text-green-500'

     

       264
       -
       															: 'text-red-500'

     

       265
       -
       													}`}

     

       266
        
       												>

     

       267
        
       													{isAvailable ? '✓' : '✗'}

     

       268
        
       												</div>

···

       161
        
       	return (

     

       162
        
       		<div className="w-full min-h-screen bg-background">

     

       163
        
       			{/* Header */}

     

       164
       +
       			<header className="w-full border-b border-border/40 bg-background/80 backdrop-blur-sm sticky top-0 z-50">

     

       165
       +
       				<div className="max-w-6xl w-full mx-auto px-4 h-16 flex items-center justify-between">

     

       166
        
       					<div className="flex items-center gap-2">

     

       167
        
       						<div className="w-8 h-8 bg-primary rounded-lg flex items-center justify-center">

     

       168
        
       							<Globe className="w-5 h-5 text-primary-foreground" />

     
···

       179
        
       				<div className="mb-8">

     

       180
        
       					<div className="flex items-center justify-center gap-2 mb-4">

     

       181
        
       						<div

     

       182
       +
       							className={`w-8 h-8 rounded-full flex items-center justify-center ${step === 'domain'

     

       183
       +
       								? 'bg-primary text-primary-foreground'

     

       184
       +
       								: 'bg-green-500 text-white'

     

       185
       +
       								}`}

     

       0
        
       
     

       186
        
       						>

     

       187
        
       							{step === 'domain' ? (

     

       188
        
       								'1'

     
···

       192
        
       						</div>

     

       193
        
       						<div className="w-16 h-0.5 bg-border"></div>

     

       194
        
       						<div

     

       195
       +
       							className={`w-8 h-8 rounded-full flex items-center justify-center ${step === 'upload'

     

       196
       +
       								? 'bg-primary text-primary-foreground'

     

       197
       +
       								: step === 'domain'

     

       198
       +
       									? 'bg-muted text-muted-foreground'

     

       199
       +
       									: 'bg-green-500 text-white'

     

       200
       +
       								}`}

     

       0
        
       
     

       201
        
       						>

     

       202
        
       							{step === 'complete' ? (

     

       203
        
       								<CheckCircle2 className="w-5 h-5" />

     
···

       256
        
       										{!isCheckingAvailability &&

     

       257
        
       											isAvailable !== null && (

     

       258
        
       												<div

     

       259
       +
       													className={`absolute right-3 top-1/2 -translate-y-1/2 ${isAvailable

     

       260
       +
       														? 'text-green-500'

     

       261
       +
       														: 'text-red-500'

     

       262
       +
       														}`}

     

       0
        
       
     

       263
        
       												>

     

       264
        
       													{isAvailable ? '✓' : '✗'}

     

       265
        
       												</div>

+212 -39

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

···

       6
        
       :root {

     

       7
        
         color-scheme: light;

     

       8
        
       

     

       9
       -
         /* Warm beige background inspired by Sunset design #E9DDD8 */

     

       10
       -
         --background: oklch(0.90 0.012 35);

     

       11
       -
         /* Very dark brown text for strong contrast #2A2420 */

     

       12
       -
         --foreground: oklch(0.18 0.01 30);

     

       13
        
       

     

       14
       -
         /* Slightly lighter card background */

     

       15
       -
         --card: oklch(0.93 0.01 35);

     

       16
       -
         --card-foreground: oklch(0.18 0.01 30);

     

       17
        
       

     

       18
       -
         --popover: oklch(0.93 0.01 35);

     

       19
       -
         --popover-foreground: oklch(0.18 0.01 30);

     

       20
        
       

     

       21
       -
         /* Dark brown primary inspired by #645343 */

     

       22
       -
         --primary: oklch(0.35 0.02 35);

     

       23
       -
         --primary-foreground: oklch(0.95 0.01 35);

     

       24
        
       

     

       25
       -
         /* Bright pink accent for links #FFAAD2 */

     

       26
       -
         --accent: oklch(0.78 0.15 345);

     

       27
       -
         --accent-foreground: oklch(0.18 0.01 30);

     

       28
        
       

     

       29
       -
         /* Medium taupe secondary inspired by #867D76 */

     

       30
       -
         --secondary: oklch(0.52 0.015 30);

     

       31
       -
         --secondary-foreground: oklch(0.95 0.01 35);

     

       32
        
       

     

       33
       -
         /* Light warm muted background */

     

       34
        
         --muted: oklch(0.88 0.01 35);

     

       35
       -
         --muted-foreground: oklch(0.42 0.015 30);

     

       36
        
       

     

       37
       -
         --border: oklch(0.75 0.015 30);

     

       38
       -
         --input: oklch(0.92 0.01 35);

     

       39
       -
         --ring: oklch(0.72 0.08 15);

     

       0
        
       
     

       0
        
       
     

       40
        
       

     

       41
       -
         --destructive: oklch(0.577 0.245 27.325);

     

       42
       -
         --destructive-foreground: oklch(0.985 0 0);

     

       43
        
       

     

       44
       -
         --chart-1: oklch(0.78 0.15 345);

     

       45
        
         --chart-2: oklch(0.32 0.04 285);

     

       46
       -
         --chart-3: oklch(0.56 0.08 220);

     

       47
       -
         --chart-4: oklch(0.85 0.02 130);

     

       48
       -
         --chart-5: oklch(0.93 0.03 85);

     

       49
        
       

     

       50
        
         --radius: 0.75rem;

     

       51
       -
         --sidebar: oklch(0.985 0 0);

     

       52
       -
         --sidebar-foreground: oklch(0.145 0 0);

     

       53
       -
         --sidebar-primary: oklch(0.205 0 0);

     

       54
       -
         --sidebar-primary-foreground: oklch(0.985 0 0);

     

       55
       -
         --sidebar-accent: oklch(0.97 0 0);

     

       56
       -
         --sidebar-accent-foreground: oklch(0.205 0 0);

     

       57
       -
         --sidebar-border: oklch(0.922 0 0);

     

       58
       -
         --sidebar-ring: oklch(0.708 0 0);

     

       59
        
       }

     

       60
        
       

     

       61
        
       .dark {

     
···

       160
        
         * {

     

       161
        
           @apply border-border outline-ring/50;

     

       162
        
         }

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       163
        
         body {

     

       164
        
           @apply bg-background text-foreground;

     

       165
        
         }

     

       166
        
       }

     

       167
        
       

     

       168
        
       @keyframes arrow-bounce {

     

       169
       -
         0%, 100% {

     

       0
        
       
     

       0
        
       
     

       170
        
           transform: translateX(0);

     

       171
        
         }

     

       0
        
       
     

       172
        
         50% {

     

       173
        
           transform: translateX(4px);

     

       174
        
         }

     
···

       189
        
         border-radius: 0.5rem;

     

       190
        
         padding: 1rem;

     

       191
        
         overflow-x: auto;

     

       192
       -
         border: 1px solid hsl(var(--border));

     

       193
        
       }

     

       194
        
       

     

       195
        
       .shiki-wrapper pre {

     

       196
        
         margin: 0 !important;

     

       197
        
         padding: 0 !important;

     

       198
        
       }

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0

···

       6
        
       :root {

     

       7
        
         color-scheme: light;

     

       8
        
       

     

       9
       +
         /* Warm beige background inspired by Sunset design */

     

       10
       +
         --background: oklch(0.92 0.012 35);

     

       11
       +
         /* Very dark brown text for strong contrast */

     

       12
       +
         --foreground: oklch(0.15 0.015 30);

     

       13
        
       

     

       14
       +
         /* Slightly lighter card background for elevation */

     

       15
       +
         --card: oklch(0.95 0.008 35);

     

       16
       +
         --card-foreground: oklch(0.15 0.015 30);

     

       17
        
       

     

       18
       +
         --popover: oklch(0.96 0.006 35);

     

       19
       +
         --popover-foreground: oklch(0.15 0.015 30);

     

       20
        
       

     

       21
       +
         /* Dark brown primary - darker for better contrast */

     

       22
       +
         --primary: oklch(0.30 0.025 35);

     

       23
       +
         --primary-foreground: oklch(0.96 0.008 35);

     

       24
        
       

     

       25
       +
         /* Deeper pink accent for better visibility */

     

       26
       +
         --accent: oklch(0.65 0.18 345);

     

       27
       +
         --accent-foreground: oklch(0.15 0.015 30);

     

       28
        
       

     

       29
       +
         /* Darker taupe secondary for better contrast */

     

       30
       +
         --secondary: oklch(0.85 0.012 30);

     

       31
       +
         --secondary-foreground: oklch(0.25 0.02 30);

     

       32
        
       

     

       33
       +
         /* Muted areas with better distinction */

     

       34
        
         --muted: oklch(0.88 0.01 35);

     

       35
       +
         --muted-foreground: oklch(0.35 0.02 30);

     

       36
        
       

     

       37
       +
         /* Significantly darker border for visibility */

     

       38
       +
         --border: oklch(0.65 0.02 30);

     

       39
       +
         /* Input backgrounds lighter than cards */

     

       40
       +
         --input: oklch(0.97 0.005 35);

     

       41
       +
         --ring: oklch(0.55 0.12 345);

     

       42
        
       

     

       43
       +
         --destructive: oklch(0.50 0.20 25);

     

       44
       +
         --destructive-foreground: oklch(0.98 0 0);

     

       45
        
       

     

       46
       +
         --chart-1: oklch(0.65 0.18 345);

     

       47
        
         --chart-2: oklch(0.32 0.04 285);

     

       48
       +
         --chart-3: oklch(0.50 0.10 220);

     

       49
       +
         --chart-4: oklch(0.70 0.08 130);

     

       50
       +
         --chart-5: oklch(0.75 0.06 85);

     

       51
        
       

     

       52
        
         --radius: 0.75rem;

     

       53
       +
         --sidebar: oklch(0.94 0.008 35);

     

       54
       +
         --sidebar-foreground: oklch(0.15 0.015 30);

     

       55
       +
         --sidebar-primary: oklch(0.30 0.025 35);

     

       56
       +
         --sidebar-primary-foreground: oklch(0.96 0.008 35);

     

       57
       +
         --sidebar-accent: oklch(0.90 0.01 35);

     

       58
       +
         --sidebar-accent-foreground: oklch(0.20 0.02 30);

     

       59
       +
         --sidebar-border: oklch(0.65 0.02 30);

     

       60
       +
         --sidebar-ring: oklch(0.55 0.12 345);

     

       61
        
       }

     

       62
        
       

     

       63
        
       .dark {

     
···

       162
        
         * {

     

       163
        
           @apply border-border outline-ring/50;

     

       164
        
         }

     

       165
       +
       

     

       166
       +
         html {

     

       167
       +
           scrollbar-gutter: stable;

     

       168
       +
         }

     

       169
       +
       

     

       170
        
         body {

     

       171
        
           @apply bg-background text-foreground;

     

       172
        
         }

     

       173
        
       }

     

       174
        
       

     

       175
        
       @keyframes arrow-bounce {

     

       176
       +
       

     

       177
       +
         0%,

     

       178
       +
         100% {

     

       179
        
           transform: translateX(0);

     

       180
        
         }

     

       181
       +
       

     

       182
        
         50% {

     

       183
        
           transform: translateX(4px);

     

       184
        
         }

     
···

       199
        
         border-radius: 0.5rem;

     

       200
        
         padding: 1rem;

     

       201
        
         overflow-x: auto;

     

       202
       +
         border: 1px solid var(--border);

     

       203
        
       }

     

       204
        
       

     

       205
        
       .shiki-wrapper pre {

     

       206
        
         margin: 0 !important;

     

       207
        
         padding: 0 !important;

     

       208
        
       }

     

       209
       +
       

     

       210
       +
       /* ========== Landing Page Animations ========== */

     

       211
       +
       

     

       212
       +
       /* Animated gradient for headline text */

     

       213
       +
       @keyframes gradient-shift {

     

       214
       +
       

     

       215
       +
         0%,

     

       216
       +
         100% {

     

       217
       +
           background-position: 0% 50%;

     

       218
       +
         }

     

       219
       +
       

     

       220
       +
         50% {

     

       221
       +
           background-position: 100% 50%;

     

       222
       +
         }

     

       223
       +
       }

     

       224
       +
       

     

       225
       +
       .text-gradient-animate {

     

       226
       +
         background: linear-gradient(90deg,

     

       227
       +
             oklch(0.55 0.22 350),

     

       228
       +
             oklch(0.60 0.24 10),

     

       229
       +
             oklch(0.55 0.22 350));

     

       230
       +
         background-size: 200% auto;

     

       231
       +
         -webkit-background-clip: text;

     

       232
       +
         background-clip: text;

     

       233
       +
         -webkit-text-fill-color: transparent;

     

       234
       +
         animation: gradient-shift 4s ease-in-out infinite;

     

       235
       +
       }

     

       236
       +
       

     

       237
       +
       .dark .text-gradient-animate {

     

       238
       +
         background: linear-gradient(90deg,

     

       239
       +
             oklch(0.75 0.12 295),

     

       240
       +
             oklch(0.85 0.10 5),

     

       241
       +
             oklch(0.75 0.12 295));

     

       242
       +
         background-size: 200% auto;

     

       243
       +
         -webkit-background-clip: text;

     

       244
       +
         background-clip: text;

     

       245
       +
         -webkit-text-fill-color: transparent;

     

       246
       +
       }

     

       247
       +
       

     

       248
       +
       /* Floating/breathing animation for hero elements */

     

       249
       +
       @keyframes float {

     

       250
       +
       

     

       251
       +
         0%,

     

       252
       +
         100% {

     

       253
       +
           transform: translateY(0);

     

       254
       +
         }

     

       255
       +
       

     

       256
       +
         50% {

     

       257
       +
           transform: translateY(-8px);

     

       258
       +
         }

     

       259
       +
       }

     

       260
       +
       

     

       261
       +
       .animate-float {

     

       262
       +
         animation: float 3s ease-in-out infinite;

     

       263
       +
       }

     

       264
       +
       

     

       265
       +
       .animate-float-delayed {

     

       266
       +
         animation: float 3s ease-in-out infinite;

     

       267
       +
         animation-delay: 0.5s;

     

       268
       +
       }

     

       269
       +
       

     

       270
       +
       /* Staggered fade-in animation */

     

       271
       +
       @keyframes fade-in-up {

     

       272
       +
         from {

     

       273
       +
           opacity: 0;

     

       274
       +
           transform: translateY(20px);

     

       275
       +
         }

     

       276
       +
       

     

       277
       +
         to {

     

       278
       +
           opacity: 1;

     

       279
       +
           transform: translateY(0);

     

       280
       +
         }

     

       281
       +
       }

     

       282
       +
       

     

       283
       +
       .animate-fade-in-up {

     

       284
       +
         animation: fade-in-up 0.6s ease-out forwards;

     

       285
       +
         opacity: 0;

     

       286
       +
       }

     

       287
       +
       

     

       288
       +
       .animate-delay-100 {

     

       289
       +
         animation-delay: 0.1s;

     

       290
       +
       }

     

       291
       +
       

     

       292
       +
       .animate-delay-200 {

     

       293
       +
         animation-delay: 0.2s;

     

       294
       +
       }

     

       295
       +
       

     

       296
       +
       .animate-delay-300 {

     

       297
       +
         animation-delay: 0.3s;

     

       298
       +
       }

     

       299
       +
       

     

       300
       +
       .animate-delay-400 {

     

       301
       +
         animation-delay: 0.4s;

     

       302
       +
       }

     

       303
       +
       

     

       304
       +
       .animate-delay-500 {

     

       305
       +
         animation-delay: 0.5s;

     

       306
       +
       }

     

       307
       +
       

     

       308
       +
       .animate-delay-600 {

     

       309
       +
         animation-delay: 0.6s;

     

       310
       +
       }

     

       311
       +
       

     

       312
       +
       /* Terminal cursor blink */

     

       313
       +
       @keyframes cursor-blink {

     

       314
       +
       

     

       315
       +
         0%,

     

       316
       +
         50% {

     

       317
       +
           opacity: 1;

     

       318
       +
         }

     

       319
       +
       

     

       320
       +
         51%,

     

       321
       +
         100% {

     

       322
       +
           opacity: 0;

     

       323
       +
         }

     

       324
       +
       }

     

       325
       +
       

     

       326
       +
       .animate-cursor-blink {

     

       327
       +
         animation: cursor-blink 1s step-end infinite;

     

       328
       +
       }

     

       329
       +
       

     

       330
       +
       /* Button hover scale effect */

     

       331
       +
       .btn-hover-lift {

     

       332
       +
         transition: all 0.2s ease-out;

     

       333
       +
       }

     

       334
       +
       

     

       335
       +
       .btn-hover-lift:hover {

     

       336
       +
         transform: translateY(-2px);

     

       337
       +
         box-shadow: 0 4px 12px rgba(0, 0, 0, 0.15);

     

       338
       +
       }

     

       339
       +
       

     

       340
       +
       .btn-hover-lift:active {

     

       341
       +
         transform: translateY(0);

     

       342
       +
       }

     

       343
       +
       

     

       344
       +
       /* Subtle pulse for feature dots */

     

       345
       +
       @keyframes dot-pulse {

     

       346
       +
       

     

       347
       +
         0%,

     

       348
       +
         100% {

     

       349
       +
           transform: scale(1);

     

       350
       +
           opacity: 1;

     

       351
       +
         }

     

       352
       +
       

     

       353
       +
         50% {

     

       354
       +
           transform: scale(1.2);

     

       355
       +
           opacity: 0.8;

     

       356
       +
         }

     

       357
       +
       }

     

       358
       +
       

     

       359
       +
       .animate-dot-pulse {

     

       360
       +
         animation: dot-pulse 2s ease-in-out infinite;

     

       361
       +
       }

     

       362
       +
       

     

       363
       +
       .animate-dot-pulse-delayed-1 {

     

       364
       +
         animation: dot-pulse 2s ease-in-out infinite;

     

       365
       +
         animation-delay: 0.3s;

     

       366
       +
       }

     

       367
       +
       

     

       368
       +
       .animate-dot-pulse-delayed-2 {

     

       369
       +
         animation: dot-pulse 2s ease-in-out infinite;

     

       370
       +
         animation-delay: 0.6s;

     

       371
       +
       }

+23 -3

apps/main-app/src/index.ts

···

       12
        
       	cleanupExpiredSessions,

     

       13
        
       	rotateKeysIfNeeded

     

       14
        
       } from './lib/oauth-client'

     

       15
       -
       import { getCookieSecret } from './lib/db'

     

       16
        
       import { authRoutes } from './routes/auth'

     

       17
        
       import { wispRoutes } from './routes/wisp'

     

       18
        
       import { domainRoutes } from './routes/domain'

     
···

       61
        
       setInterval(runMaintenance, 60 * 60 * 1000)

     

       62
        
       

     

       63
        
       // Start DNS verification worker (runs every 10 minutes)

     

       0
        
       
     

       64
        
       const dnsVerifier = new DNSVerificationWorker(

     

       65
        
       	10 * 60 * 1000, // 10 minutes

     

       66
        
       	(msg, data) => {

     
···

       68
        
       	}

     

       69
        
       )

     

       70
        
       

     

       71
       -
       dnsVerifier.start()

     

       72
       -
       logger.info('DNS Verifier Started - checking custom domains every 10 minutes')

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       73
        
       

     

       74
        
       export const app = new Elysia({

     

       75
        
       		serve: {

     
···

       200
        
       console.log(

     

       201
        
       	`🦊 Elysia is running at ${app.server?.hostname}:${app.server?.port}`

     

       202
        
       )

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0

···

       12
        
       	cleanupExpiredSessions,

     

       13
        
       	rotateKeysIfNeeded

     

       14
        
       } from './lib/oauth-client'

     

       15
       +
       import { getCookieSecret, closeDatabase } from './lib/db'

     

       16
        
       import { authRoutes } from './routes/auth'

     

       17
        
       import { wispRoutes } from './routes/wisp'

     

       18
        
       import { domainRoutes } from './routes/domain'

     
···

       61
        
       setInterval(runMaintenance, 60 * 60 * 1000)

     

       62
        
       

     

       63
        
       // Start DNS verification worker (runs every 10 minutes)

     

       64
       +
       // Can be disabled via DISABLE_DNS_WORKER=true environment variable

     

       65
        
       const dnsVerifier = new DNSVerificationWorker(

     

       66
        
       	10 * 60 * 1000, // 10 minutes

     

       67
        
       	(msg, data) => {

     
···

       69
        
       	}

     

       70
        
       )

     

       71
        
       

     

       72
       +
       if (Bun.env.DISABLE_DNS_WORKER !== 'true') {

     

       73
       +
       	dnsVerifier.start()

     

       74
       +
       	logger.info('DNS Verifier Started - checking custom domains every 10 minutes')

     

       75
       +
       } else {

     

       76
       +
       	logger.info('DNS Verifier disabled via DISABLE_DNS_WORKER environment variable')

     

       77
       +
       }

     

       78
        
       

     

       79
        
       export const app = new Elysia({

     

       80
        
       		serve: {

     
···

       205
        
       console.log(

     

       206
        
       	`🦊 Elysia is running at ${app.server?.hostname}:${app.server?.port}`

     

       207
        
       )

     

       208
       +
       

     

       209
       +
       // Graceful shutdown

     

       210
       +
       process.on('SIGINT', async () => {

     

       211
       +
       	console.log('\n🛑 Shutting down...')

     

       212
       +
       	dnsVerifier.stop()

     

       213
       +
       	await closeDatabase()

     

       214
       +
       	process.exit(0)

     

       215
       +
       })

     

       216
       +
       

     

       217
       +
       process.on('SIGTERM', async () => {

     

       218
       +
       	console.log('\n🛑 Shutting down...')

     

       219
       +
       	dnsVerifier.stop()

     

       220
       +
       	await closeDatabase()

     

       221
       +
       	process.exit(0)

     

       222
       +
       })

+13

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

···

       526
        
           console.log('[CookieSecret] Generated new cookie signing secret');

     

       527
        
           return secret;

     

       528
        
       };

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0

···

       526
        
           console.log('[CookieSecret] Generated new cookie signing secret');

     

       527
        
           return secret;

     

       528
        
       };

     

       529
       +
       

     

       530
       +
       /**

     

       531
       +
        * Close database connection

     

       532
       +
        * Call this during graceful shutdown

     

       533
       +
        */

     

       534
       +
       export const closeDatabase = async (): Promise<void> => {

     

       535
       +
           try {

     

       536
       +
               await db.end();

     

       537
       +
               console.log('[DB] Database connection closed');

     

       538
       +
           } catch (err) {

     

       539
       +
               console.error('[DB] Error closing database connection:', err);

     

       540
       +
           }

     

       541
       +
       };

+10 -16

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

···

       39
        
       

     

       40
        
       const logger = createLogger('main-app')

     

       41
        
       

     

       42
       -
       function isValidSiteName(siteName: string): boolean {

     

       43
        
           if (!siteName || typeof siteName !== 'string') return false;

     

       44
        
       

     

       45
        
           // Length check (AT Protocol rkey limit)

     
···

       183
        
                       continue;

     

       184
        
                   }

     

       185
        
       

     

       186
       -
                   console.log(`Processing file ${i + 1}/${fileArray.length}:`, file.name, file.size, 'bytes');

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       187
        
                   updateJobProgress(jobId, {

     

       188
        
                       filesProcessed: i + 1,

     

       189
       -
                       currentFile: file.name

     

       190
        
                   });

     

       191
        
       

     

       192
        
                   // Skip files that match ignore patterns

     

       193
       -
                   const normalizedPath = file.name.replace(/^[^\/]*\//, '');

     

       194
        
       

     

       195
        
                   if (shouldIgnore(ignoreMatcher, normalizedPath)) {

     

       196
       -
                       console.log(`Skipping ignored file: ${file.name}`);

     

       197
        
                       skippedFiles.push({

     

       198
       -
                           name: file.name,

     

       199
        
                           reason: 'matched ignore pattern'

     

       200
        
                       });

     

       201
        
                       continue;

     
···

       205
        
                   const maxSize = MAX_FILE_SIZE;

     

       206
        
                   if (file.size > maxSize) {

     

       207
        
                       skippedFiles.push({

     

       208
       -
                           name: file.name,

     

       209
        
                           reason: `file too large (${(file.size / 1024 / 1024).toFixed(2)}MB, max 100MB)`

     

       210
        
                       });

     

       211
        
                       continue;

     
···

       238
        
                           // Text files: compress AND base64 encode

     

       239
        
                           finalContent = Buffer.from(compressedContent.toString('base64'), 'binary');

     

       240
        
                           base64Encoded = true;

     

       241
       -
                           const compressionRatio = (compressedContent.length / originalContent.length * 100).toFixed(1);

     

       242
       -
                           console.log(`Compressing+base64 ${file.name}: ${originalContent.length} -> ${compressedContent.length} bytes (${compressionRatio}%), base64: ${finalContent.length} bytes`);

     

       243
       -
                           logger.info(`Compressing+base64 ${file.name}: ${originalContent.length} -> ${compressedContent.length} bytes (${compressionRatio}%), base64: ${finalContent.length} bytes`);

     

       244
        
                       } else {

     

       245
        
                           // Audio files: just compress, no base64

     

       246
        
                           finalContent = compressedContent;

     

       247
       -
                           const compressionRatio = (compressedContent.length / originalContent.length * 100).toFixed(1);

     

       248
       -
                           console.log(`Compressing ${file.name}: ${originalContent.length} -> ${compressedContent.length} bytes (${compressionRatio}%)`);

     

       249
       -
                           logger.info(`Compressing ${file.name}: ${originalContent.length} -> ${compressedContent.length} bytes (${compressionRatio}%)`);

     

       250
        
                       }

     

       251
        
                   } else {

     

       252
        
                       // Binary files: upload directly

     

       253
        
                       finalContent = originalContent;

     

       254
       -
                       console.log(`Uploading ${file.name} directly: ${originalContent.length} bytes (no compression)`);

     

       255
       -
                       logger.info(`Uploading ${file.name} directly: ${originalContent.length} bytes (binary)`);

     

       256
        
                   }

     

       257
        
       

     

       258
        
                   uploadedFiles.push({

     

       259
       -
                       name: file.name,

     

       260
        
                       content: finalContent,

     

       261
        
                       mimeType: originalMimeType,

     

       262
        
                       size: finalContent.length,

···

       39
        
       

     

       40
        
       const logger = createLogger('main-app')

     

       41
        
       

     

       42
       +
       export function isValidSiteName(siteName: string): boolean {

     

       43
        
           if (!siteName || typeof siteName !== 'string') return false;

     

       44
        
       

     

       45
        
           // Length check (AT Protocol rkey limit)

     
···

       183
        
                       continue;

     

       184
        
                   }

     

       185
        
       

     

       186
       +
                   // Use webkitRelativePath when available (directory uploads), fallback to name for regular file uploads

     

       187
       +
                   const webkitPath = 'webkitRelativePath' in file ? String(file.webkitRelativePath) : '';

     

       188
       +
                   const filePath = webkitPath || file.name;

     

       189
       +
       

     

       190
        
                   updateJobProgress(jobId, {

     

       191
        
                       filesProcessed: i + 1,

     

       192
       +
                       currentFile: filePath

     

       193
        
                   });

     

       194
        
       

     

       195
        
                   // Skip files that match ignore patterns

     

       196
       +
                   const normalizedPath = filePath.replace(/^[^\/]*\//, '');

     

       197
        
       

     

       198
        
                   if (shouldIgnore(ignoreMatcher, normalizedPath)) {

     

       0
        
       
     

       199
        
                       skippedFiles.push({

     

       200
       +
                           name: filePath,

     

       201
        
                           reason: 'matched ignore pattern'

     

       202
        
                       });

     

       203
        
                       continue;

     
···

       207
        
                   const maxSize = MAX_FILE_SIZE;

     

       208
        
                   if (file.size > maxSize) {

     

       209
        
                       skippedFiles.push({

     

       210
       +
                           name: filePath,

     

       211
        
                           reason: `file too large (${(file.size / 1024 / 1024).toFixed(2)}MB, max 100MB)`

     

       212
        
                       });

     

       213
        
                       continue;

     
···

       240
        
                           // Text files: compress AND base64 encode

     

       241
        
                           finalContent = Buffer.from(compressedContent.toString('base64'), 'binary');

     

       242
        
                           base64Encoded = true;

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       243
        
                       } else {

     

       244
        
                           // Audio files: just compress, no base64

     

       245
        
                           finalContent = compressedContent;

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       246
        
                       }

     

       247
        
                   } else {

     

       248
        
                       // Binary files: upload directly

     

       249
        
                       finalContent = originalContent;

     

       0
        
       
     

       0
        
       
     

       250
        
                   }

     

       251
        
       

     

       252
        
                   uploadedFiles.push({

     

       253
       +
                       name: filePath,

     

       254
        
                       content: finalContent,

     

       255
        
                       mimeType: originalMimeType,

     

       256
        
                       size: finalContent.length,

+14 -4

bun.lock

···

       8
        
               "@tailwindcss/cli": "^4.1.17",

     

       9
        
               "atproto-ui": "^0.12.0",

     

       10
        
               "bun-plugin-tailwind": "^0.1.2",

     

       0
        
       
     

       11
        
               "tailwindcss": "^4.1.17",

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       12
        
             },

     

       13
        
           },

     

       14
        
           "apps/hosting-service": {

     
···

       75
        
               "bun-plugin-tailwind": "^0.1.2",

     

       76
        
               "class-variance-authority": "^0.7.1",

     

       77
        
               "clsx": "^2.1.1",

     

       78
       -
               "elysia": "latest",

     

       79
        
               "ignore": "^7.0.5",

     

       80
        
               "iron-session": "^8.0.4",

     

       81
        
               "lucide-react": "^0.546.0",

     
···

       158
        
               "typescript": "^5.9.3",

     

       159
        
             },

     

       160
        
             "peerDependencies": {

     

       161
       -
               "hono": "",

     

       162
        
             },

     

       163
        
             "optionalPeers": [

     

       164
        
               "hono",

     
···

       582
        
       

     

       583
        
           "@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=="],

     

       584
        
       

     

       585
       -
           "@types/bun": ["@types/bun@1.3.3", "", { "dependencies": { "bun-types": "1.3.3" } }, "sha512-ogrKbJ2X5N0kWLLFKeytG0eHDleBYtngtlbu9cyBKFtNL3cnpDZkNdQj8flVf6WTZUX5ulI9AY1oa7ljhSrp+g=="],

     

       586
        
       

     

       587
        
           "@types/mime-types": ["@types/mime-types@2.1.4", "", {}, "sha512-lfU4b34HOri+kAY5UheuFMWPDOI+OPceBSHZKp69gEyTL/mmJ4cnU6Y/rlme3UL3GyOn6Y42hyIEw0/q8sWx5w=="],

     

       588
        
       

     
···

       650
        
       

     

       651
        
           "bun-plugin-tailwind": ["bun-plugin-tailwind@0.1.2", "", { "peerDependencies": { "bun": ">=1.0.0" } }, "sha512-41jNC1tZRSK3s1o7pTNrLuQG8kL/0vR/JgiTmZAJ1eHwe0w5j6HFPKeqEk0WAD13jfrUC7+ULuewFBBCoADPpg=="],

     

       652
        
       

     

       653
       -
           "bun-types": ["bun-types@1.3.3", "", { "dependencies": { "@types/node": "*" } }, "sha512-z3Xwlg7j2l9JY27x5Qn3Wlyos8YAp0kKRlrePAOjgjMGS5IG6E7Jnlx736vH9UVI4wUICwwhC9anYL++XeOgTQ=="],

     

       654
        
       

     

       655
        
           "bytes": ["bytes@3.1.2", "", {}, "sha512-/Nf7TyzTx6S3yRJObOAV7956r8cr2+Oj8AC5dt8wSP3BQAoeX58NoHyCU8P8zGkNXStjTSi6fzO6F0pBdcYbEg=="],

     

       656
        
       

     
···

       1266
        
       

     

       1267
        
           "@tokenizer/inflate/debug": ["debug@4.4.3", "", { "dependencies": { "ms": "^2.1.3" } }, "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA=="],

     

       1268
        
       

     

       0
        
       
     

       0
        
       
     

       1269
        
           "@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=="],

     

       1270
        
       

     

       1271
        
           "express/cookie": ["cookie@0.7.2", "", {}, "sha512-yki5XnKuf750l50uGTllt6kKILY4nQ1eNIQatoXEByZ5dWgnKqbnqmTrBE5B4N7lrMJKQ2ytWMiTO2o0v6Ew/w=="],

     
···

       1295
        
           "uint8arrays/multiformats": ["multiformats@9.9.0", "", {}, "sha512-HoMUjhH9T8DDBNT+6xzkrd9ga/XiBI4xLr58LJACwK6G3HTOPeMz4nB4KJs33L2BelrIJa7P0VuNaVF3hMYfjg=="],

     

       1296
        
       

     

       1297
        
           "wisp-hosting-service/@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=="],

     

       0
        
       
     

       0
        
       
     

       1298
        
       

     

       1299
        
           "@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=="],

     

       1300
        
       

     
···

       1397
        
           "tsx/esbuild/@esbuild/win32-x64": ["@esbuild/win32-x64@0.27.1", "", { "os": "win32", "cpu": "x64" }, "sha512-d5X6RMYv6taIymSk8JBP+nxv8DQAMY6A51GPgusqLdK9wBz5wWIXy1KjTck6HnjE9hqJzJRdk+1p/t5soSbCtw=="],

     

       1398
        
       

     

       1399
        
           "wisp-hosting-service/@atproto/api/multiformats": ["multiformats@9.9.0", "", {}, "sha512-HoMUjhH9T8DDBNT+6xzkrd9ga/XiBI4xLr58LJACwK6G3HTOPeMz4nB4KJs33L2BelrIJa7P0VuNaVF3hMYfjg=="],

     

       0
        
       
     

       0
        
       
     

       1400
        
         }

     

       1401
        
       }

···

       8
        
               "@tailwindcss/cli": "^4.1.17",

     

       9
        
               "atproto-ui": "^0.12.0",

     

       10
        
               "bun-plugin-tailwind": "^0.1.2",

     

       11
       +
               "elysia": "^1.4.18",

     

       12
        
               "tailwindcss": "^4.1.17",

     

       13
       +
             },

     

       14
       +
             "devDependencies": {

     

       15
       +
               "@types/bun": "^1.3.5",

     

       16
        
             },

     

       17
        
           },

     

       18
        
           "apps/hosting-service": {

     
···

       79
        
               "bun-plugin-tailwind": "^0.1.2",

     

       80
        
               "class-variance-authority": "^0.7.1",

     

       81
        
               "clsx": "^2.1.1",

     

       82
       +
               "elysia": "^1.4.18",

     

       83
        
               "ignore": "^7.0.5",

     

       84
        
               "iron-session": "^8.0.4",

     

       85
        
               "lucide-react": "^0.546.0",

     
···

       162
        
               "typescript": "^5.9.3",

     

       163
        
             },

     

       164
        
             "peerDependencies": {

     

       165
       +
               "hono": "^4.10.7",

     

       166
        
             },

     

       167
        
             "optionalPeers": [

     

       168
        
               "hono",

     
···

       586
        
       

     

       587
        
           "@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=="],

     

       588
        
       

     

       589
       +
           "@types/bun": ["@types/bun@1.3.5", "", { "dependencies": { "bun-types": "1.3.5" } }, "sha512-RnygCqNrd3srIPEWBd5LFeUYG7plCoH2Yw9WaZGyNmdTEei+gWaHqydbaIRkIkcbXwhBT94q78QljxN0Sk838w=="],

     

       590
        
       

     

       591
        
           "@types/mime-types": ["@types/mime-types@2.1.4", "", {}, "sha512-lfU4b34HOri+kAY5UheuFMWPDOI+OPceBSHZKp69gEyTL/mmJ4cnU6Y/rlme3UL3GyOn6Y42hyIEw0/q8sWx5w=="],

     

       592
        
       

     
···

       654
        
       

     

       655
        
           "bun-plugin-tailwind": ["bun-plugin-tailwind@0.1.2", "", { "peerDependencies": { "bun": ">=1.0.0" } }, "sha512-41jNC1tZRSK3s1o7pTNrLuQG8kL/0vR/JgiTmZAJ1eHwe0w5j6HFPKeqEk0WAD13jfrUC7+ULuewFBBCoADPpg=="],

     

       656
        
       

     

       657
       +
           "bun-types": ["bun-types@1.3.4", "", { "dependencies": { "@types/node": "*" } }, "sha512-5ua817+BZPZOlNaRgGBpZJOSAQ9RQ17pkwPD0yR7CfJg+r8DgIILByFifDTa+IPDDxzf5VNhtNlcKqFzDgJvlQ=="],

     

       658
        
       

     

       659
        
           "bytes": ["bytes@3.1.2", "", {}, "sha512-/Nf7TyzTx6S3yRJObOAV7956r8cr2+Oj8AC5dt8wSP3BQAoeX58NoHyCU8P8zGkNXStjTSi6fzO6F0pBdcYbEg=="],

     

       660
        
       

     
···

       1270
        
       

     

       1271
        
           "@tokenizer/inflate/debug": ["debug@4.4.3", "", { "dependencies": { "ms": "^2.1.3" } }, "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA=="],

     

       1272
        
       

     

       1273
       +
           "@types/bun/bun-types": ["bun-types@1.3.5", "", { "dependencies": { "@types/node": "*" } }, "sha512-inmAYe2PFLs0SUbFOWSVD24sg1jFlMPxOjOSSCYqUgn4Hsc3rDc7dFvfVYjFPNHtov6kgUeulV4SxbuIV/stPw=="],

     

       1274
       +
       

     

       1275
        
           "@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=="],

     

       1276
        
       

     

       1277
        
           "express/cookie": ["cookie@0.7.2", "", {}, "sha512-yki5XnKuf750l50uGTllt6kKILY4nQ1eNIQatoXEByZ5dWgnKqbnqmTrBE5B4N7lrMJKQ2ytWMiTO2o0v6Ew/w=="],

     
···

       1301
        
           "uint8arrays/multiformats": ["multiformats@9.9.0", "", {}, "sha512-HoMUjhH9T8DDBNT+6xzkrd9ga/XiBI4xLr58LJACwK6G3HTOPeMz4nB4KJs33L2BelrIJa7P0VuNaVF3hMYfjg=="],

     

       1302
        
       

     

       1303
        
           "wisp-hosting-service/@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=="],

     

       1304
       +
       

     

       1305
       +
           "wisp-hosting-service/@types/bun": ["@types/bun@1.3.3", "", { "dependencies": { "bun-types": "1.3.3" } }, "sha512-ogrKbJ2X5N0kWLLFKeytG0eHDleBYtngtlbu9cyBKFtNL3cnpDZkNdQj8flVf6WTZUX5ulI9AY1oa7ljhSrp+g=="],

     

       1306
        
       

     

       1307
        
           "@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=="],

     

       1308
        
       

     
···

       1405
        
           "tsx/esbuild/@esbuild/win32-x64": ["@esbuild/win32-x64@0.27.1", "", { "os": "win32", "cpu": "x64" }, "sha512-d5X6RMYv6taIymSk8JBP+nxv8DQAMY6A51GPgusqLdK9wBz5wWIXy1KjTck6HnjE9hqJzJRdk+1p/t5soSbCtw=="],

     

       1406
        
       

     

       1407
        
           "wisp-hosting-service/@atproto/api/multiformats": ["multiformats@9.9.0", "", {}, "sha512-HoMUjhH9T8DDBNT+6xzkrd9ga/XiBI4xLr58LJACwK6G3HTOPeMz4nB4KJs33L2BelrIJa7P0VuNaVF3hMYfjg=="],

     

       1408
       +
       

     

       1409
       +
           "wisp-hosting-service/@types/bun/bun-types": ["bun-types@1.3.3", "", { "dependencies": { "@types/node": "*" } }, "sha512-z3Xwlg7j2l9JY27x5Qn3Wlyos8YAp0kKRlrePAOjgjMGS5IG6E7Jnlx736vH9UVI4wUICwwhC9anYL++XeOgTQ=="],

     

       1410
        
         }

     

       1411
        
       }

+181 -242

cli/Cargo.lock

···

       3
        
       version = 4

     

       4
        
       

     

       5
        
       [[package]]

     

       6
       -
       name = "abnf"

     

       7
       -
       version = "0.13.0"

     

       8
       -
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       9
       -
       checksum = "087113bd50d9adce24850eed5d0476c7d199d532fce8fab5173650331e09033a"

     

       10
       -
       dependencies = [

     

       11
       -
        "abnf-core",

     

       12
       -
        "nom",

     

       13
       -
       ]

     

       14
       -
       

     

       15
       -
       [[package]]

     

       16
       -
       name = "abnf-core"

     

       17
       -
       version = "0.5.0"

     

       18
       -
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       19
       -
       checksum = "c44e09c43ae1c368fb91a03a566472d0087c26cf7e1b9e8e289c14ede681dd7d"

     

       20
       -
       dependencies = [

     

       21
       -
        "nom",

     

       22
       -
       ]

     

       23
       -
       

     

       24
       -
       [[package]]

     

       25
        
       name = "addr2line"

     

       26
        
       version = "0.25.1"

     

       27
        
       source = "registry+https://github.com/rust-lang/crates.io-index"

     
···

       71
        
       dependencies = [

     

       72
        
        "alloc-no-stdlib",

     

       73
        
       ]

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       74
        
       

     

       75
        
       [[package]]

     

       76
        
       name = "android_system_properties"

     
···

       159
        
        "proc-macro2",

     

       160
        
        "quote",

     

       161
        
        "syn 2.0.111",

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       162
        
       ]

     

       163
        
       

     

       164
        
       [[package]]

     
···

       370
        
       ]

     

       371
        
       

     

       372
        
       [[package]]

     

       373
       -
       name = "btree-range-map"

     

       374
       -
       version = "0.7.2"

     

       375
       -
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       376
       -
       checksum = "1be5c9672446d3800bcbcaabaeba121fe22f1fb25700c4562b22faf76d377c33"

     

       377
       -
       dependencies = [

     

       378
       -
        "btree-slab",

     

       379
       -
        "cc-traits",

     

       380
       -
        "range-traits",

     

       381
       -
        "serde",

     

       382
       -
        "slab",

     

       383
       -
       ]

     

       384
       -
       

     

       385
       -
       [[package]]

     

       386
       -
       name = "btree-slab"

     

       387
       -
       version = "0.6.1"

     

       388
       -
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       389
       -
       checksum = "7a2b56d3029f075c4fa892428a098425b86cef5c89ae54073137ece416aef13c"

     

       390
       -
       dependencies = [

     

       391
       -
        "cc-traits",

     

       392
       -
        "slab",

     

       393
       -
        "smallvec",

     

       394
       -
       ]

     

       395
       -
       

     

       396
       -
       [[package]]

     

       397
        
       name = "buf_redux"

     

       398
        
       version = "0.8.4"

     

       399
        
       source = "registry+https://github.com/rust-lang/crates.io-index"

     
···

       441
        
       dependencies = [

     

       442
        
        "find-msvc-tools",

     

       443
        
        "shlex",

     

       444
       -
       ]

     

       445
       -
       

     

       446
       -
       [[package]]

     

       447
       -
       name = "cc-traits"

     

       448
       -
       version = "2.0.0"

     

       449
       -
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       450
       -
       checksum = "060303ef31ef4a522737e1b1ab68c67916f2a787bb2f4f54f383279adba962b5"

     

       451
       -
       dependencies = [

     

       452
       -
        "slab",

     

       453
        
       ]

     

       454
        
       

     

       455
        
       [[package]]

     
···

       572
        
       checksum = "a1d728cc89cf3aee9ff92b05e62b19ee65a02b5702cff7d5a377e32c6ae29d8d"

     

       573
        
       

     

       574
        
       [[package]]

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       575
        
       name = "colorchoice"

     

       576
        
       version = "1.0.4"

     

       577
        
       source = "registry+https://github.com/rust-lang/crates.io-index"

     
···

       693
        
       ]

     

       694
        
       

     

       695
        
       [[package]]

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       696
        
       name = "crossbeam-channel"

     

       697
        
       version = "0.5.15"

     

       698
        
       source = "registry+https://github.com/rust-lang/crates.io-index"

     
···

       857
        
       checksum = "ececcb659e7ba858fb4f10388c250a7252eb0a27373f1a72b8748afdd248e587"

     

       858
        
       dependencies = [

     

       859
        
        "powerfmt",

     

       860
       -
        "serde_core",

     

       861
        
       ]

     

       862
        
       

     

       863
        
       [[package]]

     
···

       932
        
       ]

     

       933
        
       

     

       934
        
       [[package]]

     

       935
       -
       name = "dyn-clone"

     

       936
       -
       version = "1.0.20"

     

       937
       -
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       938
       -
       checksum = "d0881ea181b1df73ff77ffaaf9c7544ecc11e82fba9b5f27b262a3c73a332555"

     

       939
       -
       

     

       940
       -
       [[package]]

     

       941
        
       name = "ecdsa"

     

       942
        
       version = "0.16.9"

     

       943
        
       source = "registry+https://github.com/rust-lang/crates.io-index"

     
···

       972
        
       ]

     

       973
        
       

     

       974
        
       [[package]]

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       975
        
       name = "encode_unicode"

     

       976
        
       version = "1.0.0"

     

       977
        
       source = "registry+https://github.com/rust-lang/crates.io-index"

     
···

       1065
        
       checksum = "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1"

     

       1066
        
       

     

       1067
        
       [[package]]

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       1068
        
       name = "form_urlencoded"

     

       1069
        
       version = "1.2.2"

     

       1070
        
       source = "registry+https://github.com/rust-lang/crates.io-index"

     
···

       1329
        
        "futures-core",

     

       1330
        
        "futures-sink",

     

       1331
        
        "http",

     

       1332
       -
        "indexmap 2.12.1",

     

       1333
        
        "slab",

     

       1334
        
        "tokio",

     

       1335
        
        "tokio-util",

     
···

       1348
        
       ]

     

       1349
        
       

     

       1350
        
       [[package]]

     

       1351
       -
       name = "hashbrown"

     

       1352
       -
       version = "0.12.3"

     

       1353
        
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       1354
       -
       checksum = "8a9ee70c43aaf417c914396645a0fa852624801b24ebb7ae78fe8272889ac888"

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       1355
        
       

     

       1356
        
       [[package]]

     

       1357
        
       name = "hashbrown"

     
···

       1361
        
       

     

       1362
        
       [[package]]

     

       1363
        
       name = "hashbrown"

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       1364
        
       version = "0.16.1"

     

       1365
        
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       1366
        
       checksum = "841d1cc9bed7f9236f321df977030373f4a4163ae1a7dbfe1a51a2c1a51d9100"

     

       1367
        
       

     

       1368
        
       [[package]]

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       1369
        
       name = "heck"

     

       1370
        
       version = "0.4.1"

     

       1371
        
       source = "registry+https://github.com/rust-lang/crates.io-index"

     
···

       1388
        
       version = "0.4.3"

     

       1389
        
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       1390
        
       checksum = "7f24254aa9a54b5c858eaee2f5bccdb46aaf0e486a595ed5fd8f86ba55232a70"

     

       1391
       -
       

     

       1392
       -
       [[package]]

     

       1393
       -
       name = "hex_fmt"

     

       1394
       -
       version = "0.3.0"

     

       1395
       -
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       1396
       -
       checksum = "b07f60793ff0a4d9cef0f18e63b5357e06209987153a64648c972c1e5aff336f"

     

       1397
        
       

     

       1398
        
       [[package]]

     

       1399
        
       name = "hickory-proto"

     
···

       1730
        
       

     

       1731
        
       [[package]]

     

       1732
        
       name = "indexmap"

     

       1733
       -
       version = "1.9.3"

     

       1734
       -
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       1735
       -
       checksum = "bd070e393353796e801d209ad339e89596eb4c8d430d18ede6a1cced8fafbd99"

     

       1736
       -
       dependencies = [

     

       1737
       -
        "autocfg",

     

       1738
       -
        "hashbrown 0.12.3",

     

       1739
       -
        "serde",

     

       1740
       -
       ]

     

       1741
       -
       

     

       1742
       -
       [[package]]

     

       1743
       -
       name = "indexmap"

     

       1744
        
       version = "2.12.1"

     

       1745
        
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       1746
        
       checksum = "0ad4bb2b565bca0645f4d68c5c9af97fba094e9791da685bf83cb5f3ce74acf2"

     

       1747
        
       dependencies = [

     

       1748
        
        "equivalent",

     

       1749
        
        "hashbrown 0.16.1",

     

       1750
       -
        "serde",

     

       1751
       -
        "serde_core",

     

       1752
        
       ]

     

       1753
        
       

     

       1754
        
       [[package]]

     
···

       1762
        
        "portable-atomic",

     

       1763
        
        "unicode-width 0.2.2",

     

       1764
        
        "web-time",

     

       1765
       -
       ]

     

       1766
       -
       

     

       1767
       -
       [[package]]

     

       1768
       -
       name = "indoc"

     

       1769
       -
       version = "2.0.7"

     

       1770
       -
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       1771
       -
       checksum = "79cf5c93f93228cf8efb3ba362535fb11199ac548a09ce117c9b1adc3030d706"

     

       1772
       -
       dependencies = [

     

       1773
       -
        "rustversion",

     

       1774
        
       ]

     

       1775
        
       

     

       1776
        
       [[package]]

     
···

       1841
        
       

     

       1842
        
       [[package]]

     

       1843
        
       name = "jacquard"

     

       1844
       -
       version = "0.9.3"

     

       0
        
       
     

       1845
        
       dependencies = [

     

       1846
        
        "bytes",

     

       1847
        
        "getrandom 0.2.16",

     
···

       1870
        
       

     

       1871
        
       [[package]]

     

       1872
        
       name = "jacquard-api"

     

       1873
       -
       version = "0.9.2"

     

       0
        
       
     

       1874
        
       dependencies = [

     

       1875
        
        "bon",

     

       1876
        
        "bytes",

     
···

       1880
        
        "miette",

     

       1881
        
        "rustversion",

     

       1882
        
        "serde",

     

       0
        
       
     

       1883
        
        "serde_ipld_dagcbor",

     

       1884
        
        "thiserror 2.0.17",

     

       1885
        
        "unicode-segmentation",

     
···

       1887
        
       

     

       1888
        
       [[package]]

     

       1889
        
       name = "jacquard-common"

     

       1890
       -
       version = "0.9.2"

     

       0
        
       
     

       1891
        
       dependencies = [

     

       1892
        
        "base64 0.22.1",

     

       1893
        
        "bon",

     

       1894
        
        "bytes",

     

       1895
        
        "chrono",

     

       1896
        
        "ciborium",

     

       0
        
       
     

       1897
        
        "cid",

     

       1898
        
        "futures",

     

       1899
        
        "getrandom 0.2.16",

     

       1900
        
        "getrandom 0.3.4",

     

       0
        
       
     

       1901
        
        "http",

     

       1902
        
        "ipld-core",

     

       1903
        
        "k256",

     

       1904
       -
        "langtag",

     

       1905
        
        "miette",

     

       1906
        
        "multibase",

     

       1907
        
        "multihash",

     

       1908
        
        "n0-future 0.1.3",

     

       1909
        
        "ouroboros",

     

       0
        
       
     

       1910
        
        "p256",

     

       0
        
       
     

       1911
        
        "rand 0.9.2",

     

       1912
        
        "regex",

     

       0
        
       
     

       1913
        
        "regex-lite",

     

       1914
        
        "reqwest",

     

       1915
        
        "serde",

     

       0
        
       
     

       1916
        
        "serde_html_form",

     

       1917
        
        "serde_ipld_dagcbor",

     

       1918
        
        "serde_json",

     

       1919
        
        "signature",

     

       1920
        
        "smol_str",

     

       0
        
       
     

       1921
        
        "thiserror 2.0.17",

     

       1922
        
        "tokio",

     

       1923
        
        "tokio-tungstenite-wasm",

     
···

       1928
        
       

     

       1929
        
       [[package]]

     

       1930
        
       name = "jacquard-derive"

     

       1931
       -
       version = "0.9.3"

     

       0
        
       
     

       1932
        
       dependencies = [

     

       1933
        
        "heck 0.5.0",

     

       1934
        
        "jacquard-lexicon",

     
···

       1939
        
       

     

       1940
        
       [[package]]

     

       1941
        
       name = "jacquard-identity"

     

       1942
       -
       version = "0.9.2"

     

       0
        
       
     

       1943
        
       dependencies = [

     

       1944
        
        "bon",

     

       1945
        
        "bytes",

     
···

       1949
        
        "jacquard-common",

     

       1950
        
        "jacquard-lexicon",

     

       1951
        
        "miette",

     

       1952
       -
        "mini-moka",

     

       0
        
       
     

       1953
        
        "percent-encoding",

     

       1954
        
        "reqwest",

     

       1955
        
        "serde",

     
···

       1964
        
       

     

       1965
        
       [[package]]

     

       1966
        
       name = "jacquard-lexicon"

     

       1967
       -
       version = "0.9.2"

     

       0
        
       
     

       1968
        
       dependencies = [

     

       1969
        
        "cid",

     

       1970
        
        "dashmap",

     
···

       1989
        
       

     

       1990
        
       [[package]]

     

       1991
        
       name = "jacquard-oauth"

     

       1992
       -
       version = "0.9.2"

     

       0
        
       
     

       1993
        
       dependencies = [

     

       1994
        
        "base64 0.22.1",

     

       1995
        
        "bytes",

     
···

       2098
        
       ]

     

       2099
        
       

     

       2100
        
       [[package]]

     

       2101
       -
       name = "langtag"

     

       2102
       -
       version = "0.4.0"

     

       2103
       -
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       2104
       -
       checksum = "9ecb4c689a30e48ebeaa14237f34037e300dd072e6ad21a9ec72e810ff3c6600"

     

       2105
       -
       dependencies = [

     

       2106
       -
        "serde",

     

       2107
       -
        "static-regular-grammar",

     

       2108
       -
        "thiserror 1.0.69",

     

       2109
       -
       ]

     

       2110
       -
       

     

       2111
       -
       [[package]]

     

       2112
        
       name = "lazy_static"

     

       2113
        
       version = "1.5.0"

     

       2114
        
       source = "registry+https://github.com/rust-lang/crates.io-index"

     
···

       2208
        
       checksum = "c41e0c4fef86961ac6d6f8a82609f55f31b05e4fce149ac5710e439df7619ba4"

     

       2209
        
       

     

       2210
        
       [[package]]

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       2211
        
       name = "markup5ever"

     

       2212
        
       version = "0.12.1"

     

       2213
        
       source = "registry+https://github.com/rust-lang/crates.io-index"

     
···

       2312
        
       ]

     

       2313
        
       

     

       2314
        
       [[package]]

     

       2315
       -
       name = "mini-moka"

     

       2316
        
       version = "0.10.99"

     

       0
        
       
     

       2317
        
       dependencies = [

     

       2318
        
        "crossbeam-channel",

     

       2319
        
        "crossbeam-utils",

     
···

       2323
        
        "triomphe",

     

       2324
        
        "web-time",

     

       2325
        
       ]

     

       2326
       -
       

     

       2327
       -
       [[package]]

     

       2328
       -
       name = "minimal-lexical"

     

       2329
       -
       version = "0.2.1"

     

       2330
       -
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       2331
       -
       checksum = "68354c5c6bd36d73ff3feceb05efa59b6acb7626617f4962be322a825e61f79a"

     

       2332
        
       

     

       2333
        
       [[package]]

     

       2334
        
       name = "miniz_oxide"

     
···

       2393
        
       ]

     

       2394
        
       

     

       2395
        
       [[package]]

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       2396
        
       name = "n0-future"

     

       2397
        
       version = "0.1.3"

     

       2398
        
       source = "registry+https://github.com/rust-lang/crates.io-index"

     
···

       2447
        
       checksum = "650eef8c711430f1a879fdd01d4745a7deea475becfb90269c06775983bbf086"

     

       2448
        
       

     

       2449
        
       [[package]]

     

       2450
       -
       name = "nom"

     

       2451
       -
       version = "7.1.3"

     

       2452
       -
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       2453
       -
       checksum = "d273983c5a657a70a3e8f2a01329822f3b8c8172b73826411a55751e404a0a4a"

     

       2454
       -
       dependencies = [

     

       2455
       -
        "memchr",

     

       2456
       -
        "minimal-lexical",

     

       2457
       -
       ]

     

       2458
       -
       

     

       2459
       -
       [[package]]

     

       2460
        
       name = "nu-ansi-term"

     

       2461
        
       version = "0.50.3"

     

       2462
        
       source = "registry+https://github.com/rust-lang/crates.io-index"

     
···

       2631
        
       checksum = "9c6901729fa79e91a0913333229e9ca5dc725089d1c363b2f4b4760709dc4a52"

     

       2632
        
       

     

       2633
        
       [[package]]

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       2634
        
       name = "p256"

     

       2635
        
       version = "0.13.2"

     

       2636
        
       source = "registry+https://github.com/rust-lang/crates.io-index"

     
···

       2794
        
       checksum = "f84267b20a16ea918e43c6a88433c2d54fa145c92a811b5b047ccbe153674483"

     

       2795
        
       

     

       2796
        
       [[package]]

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       2797
        
       name = "potential_utf"

     

       2798
        
       version = "0.1.4"

     

       2799
        
       source = "registry+https://github.com/rust-lang/crates.io-index"

     
···

       2840
        
       checksum = "353e1ca18966c16d9deb1c69278edbc5f194139612772bd9537af60ac231e1e6"

     

       2841
        
       dependencies = [

     

       2842
        
        "elliptic-curve",

     

       2843
       -
       ]

     

       2844
       -
       

     

       2845
       -
       [[package]]

     

       2846
       -
       name = "proc-macro-error"

     

       2847
       -
       version = "1.0.4"

     

       2848
       -
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       2849
       -
       checksum = "da25490ff9892aab3fcf7c36f08cfb902dd3e71ca0f9f9517bea02a73a5ce38c"

     

       2850
       -
       dependencies = [

     

       2851
       -
        "proc-macro-error-attr",

     

       2852
       -
        "proc-macro2",

     

       2853
       -
        "quote",

     

       2854
       -
        "syn 1.0.109",

     

       2855
       -
        "version_check",

     

       2856
       -
       ]

     

       2857
       -
       

     

       2858
       -
       [[package]]

     

       2859
       -
       name = "proc-macro-error-attr"

     

       2860
       -
       version = "1.0.4"

     

       2861
       -
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       2862
       -
       checksum = "a1be40180e52ecc98ad80b184934baf3d0d29f979574e439af5a55274b35f869"

     

       2863
       -
       dependencies = [

     

       2864
       -
        "proc-macro2",

     

       2865
       -
        "quote",

     

       2866
       -
        "version_check",

     

       2867
        
       ]

     

       2868
        
       

     

       2869
        
       [[package]]

     
···

       3024
        
       ]

     

       3025
        
       

     

       3026
        
       [[package]]

     

       3027
       -
       name = "range-traits"

     

       3028
       -
       version = "0.3.2"

     

       3029
       -
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       3030
       -
       checksum = "d20581732dd76fa913c7dff1a2412b714afe3573e94d41c34719de73337cc8ab"

     

       3031
       -
       

     

       3032
       -
       [[package]]

     

       3033
        
       name = "redox_syscall"

     

       3034
        
       version = "0.5.18"

     

       3035
        
       source = "registry+https://github.com/rust-lang/crates.io-index"

     
···

       3050
        
       ]

     

       3051
        
       

     

       3052
        
       [[package]]

     

       3053
       -
       name = "ref-cast"

     

       3054
       -
       version = "1.0.25"

     

       3055
       -
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       3056
       -
       checksum = "f354300ae66f76f1c85c5f84693f0ce81d747e2c3f21a45fef496d89c960bf7d"

     

       3057
       -
       dependencies = [

     

       3058
       -
        "ref-cast-impl",

     

       3059
       -
       ]

     

       3060
       -
       

     

       3061
       -
       [[package]]

     

       3062
       -
       name = "ref-cast-impl"

     

       3063
       -
       version = "1.0.25"

     

       3064
       -
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       3065
       -
       checksum = "b7186006dcb21920990093f30e3dea63b7d6e977bf1256be20c3563a5db070da"

     

       3066
       -
       dependencies = [

     

       3067
       -
        "proc-macro2",

     

       3068
       -
        "quote",

     

       3069
       -
        "syn 2.0.111",

     

       3070
       -
       ]

     

       3071
       -
       

     

       3072
       -
       [[package]]

     

       3073
        
       name = "regex"

     

       3074
        
       version = "1.12.2"

     

       3075
        
       source = "registry+https://github.com/rust-lang/crates.io-index"

     
···

       3236
        
       checksum = "357703d41365b4b27c590e3ed91eabb1b663f07c4c084095e60cbed4362dff0d"

     

       3237
        
       

     

       3238
        
       [[package]]

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       3239
        
       name = "rustix"

     

       3240
        
       version = "1.1.2"

     

       3241
        
       source = "registry+https://github.com/rust-lang/crates.io-index"

     
···

       3332
        
       ]

     

       3333
        
       

     

       3334
        
       [[package]]

     

       3335
       -
       name = "schemars"

     

       3336
       -
       version = "0.9.0"

     

       3337
       -
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       3338
       -
       checksum = "4cd191f9397d57d581cddd31014772520aa448f65ef991055d7f61582c65165f"

     

       3339
       -
       dependencies = [

     

       3340
       -
        "dyn-clone",

     

       3341
       -
        "ref-cast",

     

       3342
       -
        "serde",

     

       3343
       -
        "serde_json",

     

       3344
       -
       ]

     

       3345
       -
       

     

       3346
       -
       [[package]]

     

       3347
       -
       name = "schemars"

     

       3348
       -
       version = "1.1.0"

     

       3349
       -
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       3350
       -
       checksum = "9558e172d4e8533736ba97870c4b2cd63f84b382a3d6eb063da41b91cce17289"

     

       3351
       -
       dependencies = [

     

       3352
       -
        "dyn-clone",

     

       3353
       -
        "ref-cast",

     

       3354
       -
        "serde",

     

       3355
       -
        "serde_json",

     

       3356
       -
       ]

     

       3357
       -
       

     

       3358
       -
       [[package]]

     

       3359
        
       name = "scoped-tls"

     

       3360
        
       version = "1.0.1"

     

       3361
        
       source = "registry+https://github.com/rust-lang/crates.io-index"

     
···

       3403
        
        "core-foundation-sys",

     

       3404
        
        "libc",

     

       3405
        
       ]

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       3406
        
       

     

       3407
        
       [[package]]

     

       3408
        
       name = "send_wrapper"

     
···

       3452
        
       

     

       3453
        
       [[package]]

     

       3454
        
       name = "serde_html_form"

     

       3455
       -
       version = "0.2.8"

     

       3456
        
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       3457
       -
       checksum = "b2f2d7ff8a2140333718bb329f5c40fc5f0865b84c426183ce14c97d2ab8154f"

     

       3458
        
       dependencies = [

     

       3459
        
        "form_urlencoded",

     

       3460
       -
        "indexmap 2.12.1",

     

       3461
        
        "itoa",

     

       3462
       -
        "ryu",

     

       3463
        
        "serde_core",

     

       3464
        
       ]

     

       3465
        
       

     
···

       3531
        
        "base64 0.22.1",

     

       3532
        
        "chrono",

     

       3533
        
        "hex",

     

       3534
       -
        "indexmap 1.9.3",

     

       3535
       -
        "indexmap 2.12.1",

     

       3536
       -
        "schemars 0.9.0",

     

       3537
       -
        "schemars 1.1.0",

     

       3538
        
        "serde_core",

     

       3539
        
        "serde_json",

     

       3540
        
        "serde_with_macros",

     
···

       3683
        
       version = "0.9.8"

     

       3684
        
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       3685
        
       checksum = "6980e8d7511241f8acf4aebddbb1ff938df5eebe98691418c4468d0b72a96a67"

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       3686
        
       

     

       3687
        
       [[package]]

     

       3688
        
       name = "spin"

     
···

       3707
        
       checksum = "6ce2be8dc25455e1f91df71bfa12ad37d7af1092ae736f3a6cd0e37bc7810596"

     

       3708
        
       

     

       3709
        
       [[package]]

     

       3710
       -
       name = "static-regular-grammar"

     

       3711
       -
       version = "2.0.2"

     

       3712
       -
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       3713
       -
       checksum = "4f4a6c40247579acfbb138c3cd7de3dab113ab4ac6227f1b7de7d626ee667957"

     

       3714
       -
       dependencies = [

     

       3715
       -
        "abnf",

     

       3716
       -
        "btree-range-map",

     

       3717
       -
        "ciborium",

     

       3718
       -
        "hex_fmt",

     

       3719
       -
        "indoc",

     

       3720
       -
        "proc-macro-error",

     

       3721
       -
        "proc-macro2",

     

       3722
       -
        "quote",

     

       3723
       -
        "serde",

     

       3724
       -
        "sha2",

     

       3725
       -
        "syn 2.0.111",

     

       3726
       -
        "thiserror 1.0.69",

     

       3727
       -
       ]

     

       3728
       -
       

     

       3729
       -
       [[package]]

     

       3730
        
       name = "static_assertions"

     

       3731
        
       version = "1.1.0"

     

       3732
        
       source = "registry+https://github.com/rust-lang/crates.io-index"

     
···

       3968
        
       checksum = "91e7d9e3bb61134e77bde20dd4825b97c010155709965fedf0f49bb138e52a9d"

     

       3969
        
       dependencies = [

     

       3970
        
        "deranged",

     

       3971
       -
        "itoa",

     

       3972
        
        "libc",

     

       3973
        
        "num-conv",

     

       3974
        
        "num_threads",

     

       3975
        
        "powerfmt",

     

       3976
        
        "serde",

     

       3977
        
        "time-core",

     

       3978
       -
        "time-macros",

     

       3979
        
       ]

     

       3980
        
       

     

       3981
        
       [[package]]

     
···

       3983
        
       version = "0.1.6"

     

       3984
        
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       3985
        
       checksum = "40868e7c1d2f0b8d73e4a8c7f0ff63af4f6d19be117e90bd73eb1d62cf831c6b"

     

       3986
       -
       

     

       3987
       -
       [[package]]

     

       3988
       -
       name = "time-macros"

     

       3989
       -
       version = "0.2.24"

     

       3990
       -
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       3991
       -
       checksum = "30cfb0125f12d9c277f35663a0a33f8c30190f4e4574868a330595412d34ebf3"

     

       3992
       -
       dependencies = [

     

       3993
       -
        "num-conv",

     

       3994
       -
        "time-core",

     

       3995
       -
       ]

     

       3996
        
       

     

       3997
        
       [[package]]

     

       3998
        
       name = "tiny_http"

     
···

       5078
        
        "tower-http",

     

       5079
        
        "url",

     

       5080
        
        "walkdir",

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       5081
        
       ]

     

       5082
        
       

     

       5083
        
       [[package]]

···

       3
        
       version = 4

     

       4
        
       

     

       5
        
       [[package]]

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       6
        
       name = "addr2line"

     

       7
        
       version = "0.25.1"

     

       8
        
       source = "registry+https://github.com/rust-lang/crates.io-index"

     
···

       52
        
       dependencies = [

     

       53
        
        "alloc-no-stdlib",

     

       54
        
       ]

     

       55
       +
       

     

       56
       +
       [[package]]

     

       57
       +
       name = "allocator-api2"

     

       58
       +
       version = "0.2.21"

     

       59
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       60
       +
       checksum = "683d7910e743518b0e34f1186f92494becacb047c7b6bf616c96772180fef923"

     

       61
        
       

     

       62
        
       [[package]]

     

       63
        
       name = "android_system_properties"

     
···

       146
        
        "proc-macro2",

     

       147
        
        "quote",

     

       148
        
        "syn 2.0.111",

     

       149
       +
       ]

     

       150
       +
       

     

       151
       +
       [[package]]

     

       152
       +
       name = "atomic-polyfill"

     

       153
       +
       version = "1.0.3"

     

       154
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       155
       +
       checksum = "8cf2bce30dfe09ef0bfaef228b9d414faaf7e563035494d7fe092dba54b300f4"

     

       156
       +
       dependencies = [

     

       157
       +
        "critical-section",

     

       158
        
       ]

     

       159
        
       

     

       160
        
       [[package]]

     
···

       366
        
       ]

     

       367
        
       

     

       368
        
       [[package]]

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       369
        
       name = "buf_redux"

     

       370
        
       version = "0.8.4"

     

       371
        
       source = "registry+https://github.com/rust-lang/crates.io-index"

     
···

       413
        
       dependencies = [

     

       414
        
        "find-msvc-tools",

     

       415
        
        "shlex",

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       416
        
       ]

     

       417
        
       

     

       418
        
       [[package]]

     
···

       535
        
       checksum = "a1d728cc89cf3aee9ff92b05e62b19ee65a02b5702cff7d5a377e32c6ae29d8d"

     

       536
        
       

     

       537
        
       [[package]]

     

       538
       +
       name = "cobs"

     

       539
       +
       version = "0.3.0"

     

       540
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       541
       +
       checksum = "0fa961b519f0b462e3a3b4a34b64d119eeaca1d59af726fe450bbba07a9fc0a1"

     

       542
       +
       dependencies = [

     

       543
       +
        "thiserror 2.0.17",

     

       544
       +
       ]

     

       545
       +
       

     

       546
       +
       [[package]]

     

       547
        
       name = "colorchoice"

     

       548
        
       version = "1.0.4"

     

       549
        
       source = "registry+https://github.com/rust-lang/crates.io-index"

     
···

       665
        
       ]

     

       666
        
       

     

       667
        
       [[package]]

     

       668
       +
       name = "critical-section"

     

       669
       +
       version = "1.2.0"

     

       670
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       671
       +
       checksum = "790eea4361631c5e7d22598ecd5723ff611904e3344ce8720784c93e3d83d40b"

     

       672
       +
       

     

       673
       +
       [[package]]

     

       674
        
       name = "crossbeam-channel"

     

       675
        
       version = "0.5.15"

     

       676
        
       source = "registry+https://github.com/rust-lang/crates.io-index"

     
···

       835
        
       checksum = "ececcb659e7ba858fb4f10388c250a7252eb0a27373f1a72b8748afdd248e587"

     

       836
        
       dependencies = [

     

       837
        
        "powerfmt",

     

       0
        
       
     

       838
        
       ]

     

       839
        
       

     

       840
        
       [[package]]

     
···

       909
        
       ]

     

       910
        
       

     

       911
        
       [[package]]

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       912
        
       name = "ecdsa"

     

       913
        
       version = "0.16.9"

     

       914
        
       source = "registry+https://github.com/rust-lang/crates.io-index"

     
···

       943
        
       ]

     

       944
        
       

     

       945
        
       [[package]]

     

       946
       +
       name = "embedded-io"

     

       947
       +
       version = "0.4.0"

     

       948
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       949
       +
       checksum = "ef1a6892d9eef45c8fa6b9e0086428a2cca8491aca8f787c534a3d6d0bcb3ced"

     

       950
       +
       

     

       951
       +
       [[package]]

     

       952
       +
       name = "embedded-io"

     

       953
       +
       version = "0.6.1"

     

       954
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       955
       +
       checksum = "edd0f118536f44f5ccd48bcb8b111bdc3de888b58c74639dfb034a357d0f206d"

     

       956
       +
       

     

       957
       +
       [[package]]

     

       958
        
       name = "encode_unicode"

     

       959
        
       version = "1.0.0"

     

       960
        
       source = "registry+https://github.com/rust-lang/crates.io-index"

     
···

       1048
        
       checksum = "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1"

     

       1049
        
       

     

       1050
        
       [[package]]

     

       1051
       +
       name = "foldhash"

     

       1052
       +
       version = "0.1.5"

     

       1053
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       1054
       +
       checksum = "d9c4f5dac5e15c24eb999c26181a6ca40b39fe946cbe4c263c7209467bc83af2"

     

       1055
       +
       

     

       1056
       +
       [[package]]

     

       1057
        
       name = "form_urlencoded"

     

       1058
        
       version = "1.2.2"

     

       1059
        
       source = "registry+https://github.com/rust-lang/crates.io-index"

     
···

       1318
        
        "futures-core",

     

       1319
        
        "futures-sink",

     

       1320
        
        "http",

     

       1321
       +
        "indexmap",

     

       1322
        
        "slab",

     

       1323
        
        "tokio",

     

       1324
        
        "tokio-util",

     
···

       1337
        
       ]

     

       1338
        
       

     

       1339
        
       [[package]]

     

       1340
       +
       name = "hash32"

     

       1341
       +
       version = "0.2.1"

     

       1342
        
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       1343
       +
       checksum = "b0c35f58762feb77d74ebe43bdbc3210f09be9fe6742234d573bacc26ed92b67"

     

       1344
       +
       dependencies = [

     

       1345
       +
        "byteorder",

     

       1346
       +
       ]

     

       1347
        
       

     

       1348
        
       [[package]]

     

       1349
        
       name = "hashbrown"

     
···

       1353
        
       

     

       1354
        
       [[package]]

     

       1355
        
       name = "hashbrown"

     

       1356
       +
       version = "0.15.5"

     

       1357
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       1358
       +
       checksum = "9229cfe53dfd69f0609a49f65461bd93001ea1ef889cd5529dd176593f5338a1"

     

       1359
       +
       dependencies = [

     

       1360
       +
        "allocator-api2",

     

       1361
       +
        "equivalent",

     

       1362
       +
        "foldhash",

     

       1363
       +
       ]

     

       1364
       +
       

     

       1365
       +
       [[package]]

     

       1366
       +
       name = "hashbrown"

     

       1367
        
       version = "0.16.1"

     

       1368
        
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       1369
        
       checksum = "841d1cc9bed7f9236f321df977030373f4a4163ae1a7dbfe1a51a2c1a51d9100"

     

       1370
        
       

     

       1371
        
       [[package]]

     

       1372
       +
       name = "heapless"

     

       1373
       +
       version = "0.7.17"

     

       1374
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       1375
       +
       checksum = "cdc6457c0eb62c71aac4bc17216026d8410337c4126773b9c5daba343f17964f"

     

       1376
       +
       dependencies = [

     

       1377
       +
        "atomic-polyfill",

     

       1378
       +
        "hash32",

     

       1379
       +
        "rustc_version",

     

       1380
       +
        "serde",

     

       1381
       +
        "spin 0.9.8",

     

       1382
       +
        "stable_deref_trait",

     

       1383
       +
       ]

     

       1384
       +
       

     

       1385
       +
       [[package]]

     

       1386
        
       name = "heck"

     

       1387
        
       version = "0.4.1"

     

       1388
        
       source = "registry+https://github.com/rust-lang/crates.io-index"

     
···

       1405
        
       version = "0.4.3"

     

       1406
        
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       1407
        
       checksum = "7f24254aa9a54b5c858eaee2f5bccdb46aaf0e486a595ed5fd8f86ba55232a70"

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       1408
        
       

     

       1409
        
       [[package]]

     

       1410
        
       name = "hickory-proto"

     
···

       1741
        
       

     

       1742
        
       [[package]]

     

       1743
        
       name = "indexmap"

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       1744
        
       version = "2.12.1"

     

       1745
        
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       1746
        
       checksum = "0ad4bb2b565bca0645f4d68c5c9af97fba094e9791da685bf83cb5f3ce74acf2"

     

       1747
        
       dependencies = [

     

       1748
        
        "equivalent",

     

       1749
        
        "hashbrown 0.16.1",

     

       0
        
       
     

       0
        
       
     

       1750
        
       ]

     

       1751
        
       

     

       1752
        
       [[package]]

     
···

       1760
        
        "portable-atomic",

     

       1761
        
        "unicode-width 0.2.2",

     

       1762
        
        "web-time",

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       1763
        
       ]

     

       1764
        
       

     

       1765
        
       [[package]]

     
···

       1830
        
       

     

       1831
        
       [[package]]

     

       1832
        
       name = "jacquard"

     

       1833
       +
       version = "0.9.5"

     

       1834
       +
       source = "git+https://tangled.org/nonbinary.computer/jacquard#5bcf7f8e87324b8e67fc273c678d0490c9c6d15b"

     

       1835
        
       dependencies = [

     

       1836
        
        "bytes",

     

       1837
        
        "getrandom 0.2.16",

     
···

       1860
        
       

     

       1861
        
       [[package]]

     

       1862
        
       name = "jacquard-api"

     

       1863
       +
       version = "0.9.5"

     

       1864
       +
       source = "git+https://tangled.org/nonbinary.computer/jacquard#5bcf7f8e87324b8e67fc273c678d0490c9c6d15b"

     

       1865
        
       dependencies = [

     

       1866
        
        "bon",

     

       1867
        
        "bytes",

     
···

       1871
        
        "miette",

     

       1872
        
        "rustversion",

     

       1873
        
        "serde",

     

       1874
       +
        "serde_bytes",

     

       1875
        
        "serde_ipld_dagcbor",

     

       1876
        
        "thiserror 2.0.17",

     

       1877
        
        "unicode-segmentation",

     
···

       1879
        
       

     

       1880
        
       [[package]]

     

       1881
        
       name = "jacquard-common"

     

       1882
       +
       version = "0.9.5"

     

       1883
       +
       source = "git+https://tangled.org/nonbinary.computer/jacquard#5bcf7f8e87324b8e67fc273c678d0490c9c6d15b"

     

       1884
        
       dependencies = [

     

       1885
        
        "base64 0.22.1",

     

       1886
        
        "bon",

     

       1887
        
        "bytes",

     

       1888
        
        "chrono",

     

       1889
        
        "ciborium",

     

       1890
       +
        "ciborium-io",

     

       1891
        
        "cid",

     

       1892
        
        "futures",

     

       1893
        
        "getrandom 0.2.16",

     

       1894
        
        "getrandom 0.3.4",

     

       1895
       +
        "hashbrown 0.15.5",

     

       1896
        
        "http",

     

       1897
        
        "ipld-core",

     

       1898
        
        "k256",

     

       1899
       +
        "maitake-sync",

     

       1900
        
        "miette",

     

       1901
        
        "multibase",

     

       1902
        
        "multihash",

     

       1903
        
        "n0-future 0.1.3",

     

       1904
        
        "ouroboros",

     

       1905
       +
        "oxilangtag",

     

       1906
        
        "p256",

     

       1907
       +
        "postcard",

     

       1908
        
        "rand 0.9.2",

     

       1909
        
        "regex",

     

       1910
       +
        "regex-automata",

     

       1911
        
        "regex-lite",

     

       1912
        
        "reqwest",

     

       1913
        
        "serde",

     

       1914
       +
        "serde_bytes",

     

       1915
        
        "serde_html_form",

     

       1916
        
        "serde_ipld_dagcbor",

     

       1917
        
        "serde_json",

     

       1918
        
        "signature",

     

       1919
        
        "smol_str",

     

       1920
       +
        "spin 0.10.0",

     

       1921
        
        "thiserror 2.0.17",

     

       1922
        
        "tokio",

     

       1923
        
        "tokio-tungstenite-wasm",

     
···

       1928
        
       

     

       1929
        
       [[package]]

     

       1930
        
       name = "jacquard-derive"

     

       1931
       +
       version = "0.9.5"

     

       1932
       +
       source = "git+https://tangled.org/nonbinary.computer/jacquard#5bcf7f8e87324b8e67fc273c678d0490c9c6d15b"

     

       1933
        
       dependencies = [

     

       1934
        
        "heck 0.5.0",

     

       1935
        
        "jacquard-lexicon",

     
···

       1940
        
       

     

       1941
        
       [[package]]

     

       1942
        
       name = "jacquard-identity"

     

       1943
       +
       version = "0.9.5"

     

       1944
       +
       source = "git+https://tangled.org/nonbinary.computer/jacquard#5bcf7f8e87324b8e67fc273c678d0490c9c6d15b"

     

       1945
        
       dependencies = [

     

       1946
        
        "bon",

     

       1947
        
        "bytes",

     
···

       1951
        
        "jacquard-common",

     

       1952
        
        "jacquard-lexicon",

     

       1953
        
        "miette",

     

       1954
       +
        "mini-moka-wasm",

     

       1955
       +
        "n0-future 0.1.3",

     

       1956
        
        "percent-encoding",

     

       1957
        
        "reqwest",

     

       1958
        
        "serde",

     
···

       1967
        
       

     

       1968
        
       [[package]]

     

       1969
        
       name = "jacquard-lexicon"

     

       1970
       +
       version = "0.9.5"

     

       1971
       +
       source = "git+https://tangled.org/nonbinary.computer/jacquard#5bcf7f8e87324b8e67fc273c678d0490c9c6d15b"

     

       1972
        
       dependencies = [

     

       1973
        
        "cid",

     

       1974
        
        "dashmap",

     
···

       1993
        
       

     

       1994
        
       [[package]]

     

       1995
        
       name = "jacquard-oauth"

     

       1996
       +
       version = "0.9.6"

     

       1997
       +
       source = "git+https://tangled.org/nonbinary.computer/jacquard#5bcf7f8e87324b8e67fc273c678d0490c9c6d15b"

     

       1998
        
       dependencies = [

     

       1999
        
        "base64 0.22.1",

     

       2000
        
        "bytes",

     
···

       2103
        
       ]

     

       2104
        
       

     

       2105
        
       [[package]]

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       2106
        
       name = "lazy_static"

     

       2107
        
       version = "1.5.0"

     

       2108
        
       source = "registry+https://github.com/rust-lang/crates.io-index"

     
···

       2202
        
       checksum = "c41e0c4fef86961ac6d6f8a82609f55f31b05e4fce149ac5710e439df7619ba4"

     

       2203
        
       

     

       2204
        
       [[package]]

     

       2205
       +
       name = "maitake-sync"

     

       2206
       +
       version = "0.1.2"

     

       2207
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       2208
       +
       checksum = "6816ab14147f80234c675b80ed6dc4f440d8a1cefc158e766067aedb84c0bcd5"

     

       2209
       +
       dependencies = [

     

       2210
       +
        "cordyceps",

     

       2211
       +
        "loom",

     

       2212
       +
        "mycelium-bitfield",

     

       2213
       +
        "pin-project",

     

       2214
       +
        "portable-atomic",

     

       2215
       +
       ]

     

       2216
       +
       

     

       2217
       +
       [[package]]

     

       2218
        
       name = "markup5ever"

     

       2219
        
       version = "0.12.1"

     

       2220
        
       source = "registry+https://github.com/rust-lang/crates.io-index"

     
···

       2319
        
       ]

     

       2320
        
       

     

       2321
        
       [[package]]

     

       2322
       +
       name = "mini-moka-wasm"

     

       2323
        
       version = "0.10.99"

     

       2324
       +
       source = "git+https://tangled.org/nonbinary.computer/jacquard#5bcf7f8e87324b8e67fc273c678d0490c9c6d15b"

     

       2325
        
       dependencies = [

     

       2326
        
        "crossbeam-channel",

     

       2327
        
        "crossbeam-utils",

     
···

       2331
        
        "triomphe",

     

       2332
        
        "web-time",

     

       2333
        
       ]

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       2334
        
       

     

       2335
        
       [[package]]

     

       2336
        
       name = "miniz_oxide"

     
···

       2395
        
       ]

     

       2396
        
       

     

       2397
        
       [[package]]

     

       2398
       +
       name = "mycelium-bitfield"

     

       2399
       +
       version = "0.1.5"

     

       2400
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       2401
       +
       checksum = "24e0cc5e2c585acbd15c5ce911dff71e1f4d5313f43345873311c4f5efd741cc"

     

       2402
       +
       

     

       2403
       +
       [[package]]

     

       2404
        
       name = "n0-future"

     

       2405
        
       version = "0.1.3"

     

       2406
        
       source = "registry+https://github.com/rust-lang/crates.io-index"

     
···

       2455
        
       checksum = "650eef8c711430f1a879fdd01d4745a7deea475becfb90269c06775983bbf086"

     

       2456
        
       

     

       2457
        
       [[package]]

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       2458
        
       name = "nu-ansi-term"

     

       2459
        
       version = "0.50.3"

     

       2460
        
       source = "registry+https://github.com/rust-lang/crates.io-index"

     
···

       2629
        
       checksum = "9c6901729fa79e91a0913333229e9ca5dc725089d1c363b2f4b4760709dc4a52"

     

       2630
        
       

     

       2631
        
       [[package]]

     

       2632
       +
       name = "oxilangtag"

     

       2633
       +
       version = "0.1.5"

     

       2634
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       2635
       +
       checksum = "23f3f87617a86af77fa3691e6350483e7154c2ead9f1261b75130e21ca0f8acb"

     

       2636
       +
       dependencies = [

     

       2637
       +
        "serde",

     

       2638
       +
       ]

     

       2639
       +
       

     

       2640
       +
       [[package]]

     

       2641
        
       name = "p256"

     

       2642
        
       version = "0.13.2"

     

       2643
        
       source = "registry+https://github.com/rust-lang/crates.io-index"

     
···

       2801
        
       checksum = "f84267b20a16ea918e43c6a88433c2d54fa145c92a811b5b047ccbe153674483"

     

       2802
        
       

     

       2803
        
       [[package]]

     

       2804
       +
       name = "postcard"

     

       2805
       +
       version = "1.1.3"

     

       2806
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       2807
       +
       checksum = "6764c3b5dd454e283a30e6dfe78e9b31096d9e32036b5d1eaac7a6119ccb9a24"

     

       2808
       +
       dependencies = [

     

       2809
       +
        "cobs",

     

       2810
       +
        "embedded-io 0.4.0",

     

       2811
       +
        "embedded-io 0.6.1",

     

       2812
       +
        "heapless",

     

       2813
       +
        "serde",

     

       2814
       +
       ]

     

       2815
       +
       

     

       2816
       +
       [[package]]

     

       2817
        
       name = "potential_utf"

     

       2818
        
       version = "0.1.4"

     

       2819
        
       source = "registry+https://github.com/rust-lang/crates.io-index"

     
···

       2860
        
       checksum = "353e1ca18966c16d9deb1c69278edbc5f194139612772bd9537af60ac231e1e6"

     

       2861
        
       dependencies = [

     

       2862
        
        "elliptic-curve",

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       2863
        
       ]

     

       2864
        
       

     

       2865
        
       [[package]]

     
···

       3020
        
       ]

     

       3021
        
       

     

       3022
        
       [[package]]

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       3023
        
       name = "redox_syscall"

     

       3024
        
       version = "0.5.18"

     

       3025
        
       source = "registry+https://github.com/rust-lang/crates.io-index"

     
···

       3040
        
       ]

     

       3041
        
       

     

       3042
        
       [[package]]

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       3043
        
       name = "regex"

     

       3044
        
       version = "1.12.2"

     

       3045
        
       source = "registry+https://github.com/rust-lang/crates.io-index"

     
···

       3206
        
       checksum = "357703d41365b4b27c590e3ed91eabb1b663f07c4c084095e60cbed4362dff0d"

     

       3207
        
       

     

       3208
        
       [[package]]

     

       3209
       +
       name = "rustc_version"

     

       3210
       +
       version = "0.4.1"

     

       3211
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       3212
       +
       checksum = "cfcb3a22ef46e85b45de6ee7e79d063319ebb6594faafcf1c225ea92ab6e9b92"

     

       3213
       +
       dependencies = [

     

       3214
       +
        "semver",

     

       3215
       +
       ]

     

       3216
       +
       

     

       3217
       +
       [[package]]

     

       3218
        
       name = "rustix"

     

       3219
        
       version = "1.1.2"

     

       3220
        
       source = "registry+https://github.com/rust-lang/crates.io-index"

     
···

       3311
        
       ]

     

       3312
        
       

     

       3313
        
       [[package]]

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       3314
        
       name = "scoped-tls"

     

       3315
        
       version = "1.0.1"

     

       3316
        
       source = "registry+https://github.com/rust-lang/crates.io-index"

     
···

       3358
        
        "core-foundation-sys",

     

       3359
        
        "libc",

     

       3360
        
       ]

     

       3361
       +
       

     

       3362
       +
       [[package]]

     

       3363
       +
       name = "semver"

     

       3364
       +
       version = "1.0.27"

     

       3365
       +
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       3366
       +
       checksum = "d767eb0aabc880b29956c35734170f26ed551a859dbd361d140cdbeca61ab1e2"

     

       3367
        
       

     

       3368
        
       [[package]]

     

       3369
        
       name = "send_wrapper"

     
···

       3413
        
       

     

       3414
        
       [[package]]

     

       3415
        
       name = "serde_html_form"

     

       3416
       +
       version = "0.3.2"

     

       3417
        
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       3418
       +
       checksum = "2acf96b1d9364968fce46ebb548f1c0e1d7eceae27bdff73865d42e6c7369d94"

     

       3419
        
       dependencies = [

     

       3420
        
        "form_urlencoded",

     

       3421
       +
        "indexmap",

     

       3422
        
        "itoa",

     

       0
        
       
     

       3423
        
        "serde_core",

     

       3424
        
       ]

     

       3425
        
       

     
···

       3491
        
        "base64 0.22.1",

     

       3492
        
        "chrono",

     

       3493
        
        "hex",

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       3494
        
        "serde_core",

     

       3495
        
        "serde_json",

     

       3496
        
        "serde_with_macros",

     
···

       3639
        
       version = "0.9.8"

     

       3640
        
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       3641
        
       checksum = "6980e8d7511241f8acf4aebddbb1ff938df5eebe98691418c4468d0b72a96a67"

     

       3642
       +
       dependencies = [

     

       3643
       +
        "lock_api",

     

       3644
       +
       ]

     

       3645
        
       

     

       3646
        
       [[package]]

     

       3647
        
       name = "spin"

     
···

       3666
        
       checksum = "6ce2be8dc25455e1f91df71bfa12ad37d7af1092ae736f3a6cd0e37bc7810596"

     

       3667
        
       

     

       3668
        
       [[package]]

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       3669
        
       name = "static_assertions"

     

       3670
        
       version = "1.1.0"

     

       3671
        
       source = "registry+https://github.com/rust-lang/crates.io-index"

     
···

       3907
        
       checksum = "91e7d9e3bb61134e77bde20dd4825b97c010155709965fedf0f49bb138e52a9d"

     

       3908
        
       dependencies = [

     

       3909
        
        "deranged",

     

       0
        
       
     

       3910
        
        "libc",

     

       3911
        
        "num-conv",

     

       3912
        
        "num_threads",

     

       3913
        
        "powerfmt",

     

       3914
        
        "serde",

     

       3915
        
        "time-core",

     

       0
        
       
     

       3916
        
       ]

     

       3917
        
       

     

       3918
        
       [[package]]

     
···

       3920
        
       version = "0.1.6"

     

       3921
        
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       3922
        
       checksum = "40868e7c1d2f0b8d73e4a8c7f0ff63af4f6d19be117e90bd73eb1d62cf831c6b"

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       3923
        
       

     

       3924
        
       [[package]]

     

       3925
        
       name = "tiny_http"

     
···

       5005
        
        "tower-http",

     

       5006
        
        "url",

     

       5007
        
        "walkdir",

     

       5008
       +
        "wisp-lexicons",

     

       5009
       +
       ]

     

       5010
       +
       

     

       5011
       +
       [[package]]

     

       5012
       +
       name = "wisp-lexicons"

     

       5013
       +
       version = "0.1.0"

     

       5014
       +
       dependencies = [

     

       5015
       +
        "jacquard-common",

     

       5016
       +
        "jacquard-derive",

     

       5017
       +
        "jacquard-lexicon",

     

       5018
       +
        "rustversion",

     

       5019
       +
        "serde",

     

       5020
        
       ]

     

       5021
        
       

     

       5022
        
       [[package]]

+8 -7

cli/Cargo.toml

···

       8
        
       place_wisp = []

     

       9
        
       

     

       10
        
       [dependencies]

     

       11
       -
       jacquard = { git = "https://tangled.org/nekomimi.pet/jacquard", features = ["loopback"] }

     

       12
       -
       jacquard-oauth = { git = "https://tangled.org/nekomimi.pet/jacquard" }

     

       13
       -
       jacquard-api = { git = "https://tangled.org/nekomimi.pet/jacquard", features = ["streaming"] }

     

       14
       -
       jacquard-common = { git = "https://tangled.org/nekomimi.pet/jacquard", features = ["websocket"] }

     

       15
       -
       jacquard-identity = { git = "https://tangled.org/nekomimi.pet/jacquard", features = ["dns"] }

     

       16
       -
       jacquard-derive = { git = "https://tangled.org/nekomimi.pet/jacquard" }

     

       17
       -
       jacquard-lexicon = { git = "https://tangled.org/nekomimi.pet/jacquard" }

     

       0
        
       
     

       18
        
       #jacquard = { path = "../../jacquard/crates/jacquard", features = ["loopback"] }

     

       19
        
       #jacquard-oauth = { path = "../../jacquard/crates/jacquard-oauth" }

     

       20
        
       #jacquard-api = { path = "../../jacquard/crates/jacquard-api", features = ["streaming"] }

···

       8
        
       place_wisp = []

     

       9
        
       

     

       10
        
       [dependencies]

     

       11
       +
       jacquard = { git = "https://tangled.org/nonbinary.computer/jacquard", features = ["loopback"] }

     

       12
       +
       jacquard-oauth = { git = "https://tangled.org/nonbinary.computer/jacquard" }

     

       13
       +
       jacquard-api = { git = "https://tangled.org/nonbinary.computer/jacquard", features = ["streaming"] }

     

       14
       +
       jacquard-common = { git = "https://tangled.org/nonbinary.computer/jacquard", features = ["websocket"] }

     

       15
       +
       jacquard-identity = { git = "https://tangled.org/nonbinary.computer/jacquard", features = ["dns"] }

     

       16
       +
       jacquard-derive = { git = "https://tangled.org/nonbinary.computer/jacquard" }

     

       17
       +
       jacquard-lexicon = { git = "https://tangled.org/nonbinary.computer/jacquard" }

     

       18
       +
       wisp-lexicons = { path = "crates/lexicons" }

     

       19
        
       #jacquard = { path = "../../jacquard/crates/jacquard", features = ["loopback"] }

     

       20
        
       #jacquard-oauth = { path = "../../jacquard/crates/jacquard-oauth" }

     

       21
        
       #jacquard-api = { path = "../../jacquard/crates/jacquard-api", features = ["streaming"] }

+72 -2

cli/README.md

···

       32
        
       

     

       33
        
       ## Usage

     

       34
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       35
        
       ### Basic Deployment

     

       36
        
       

     

       37
        
       Deploy the current directory:

     

       38
        
       

     

       39
        
       ```bash

     

       40
       -
       wisp-cli nekomimi.ppet --path . --site my-site

     

       41
        
       ```

     

       42
        
       

     

       43
        
       Deploy a specific directory:

     
···

       46
        
       wisp-cli alice.bsky.social --path ./dist/ --site my-site

     

       47
        
       ```

     

       48
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       49
        
       ### Authentication Methods

     

       50
        
       

     

       51
        
       #### OAuth (Recommended)

     
···

       79
        
       

     

       80
        
       ## Command-Line Options

     

       81
        
       

     

       0
        
       
     

       0
        
       
     

       82
        
       ```

     

       83
       -
       wisp-cli [OPTIONS] <INPUT>

     

       84
        
       

     

       85
        
       Arguments:

     

       86
        
         <INPUT>  Handle (e.g., alice.bsky.social), DID, or PDS URL

     
···

       90
        
         -s, --site <SITE>           Site name (defaults to directory name)

     

       91
        
             --store <STORE>         Path to auth store file (only used with OAuth) [default: /tmp/wisp-oauth-session.json]

     

       92
        
             --password <PASSWORD>   App Password for authentication (alternative to OAuth)

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       93
        
         -h, --help                  Print help

     

       94
        
         -V, --version               Print version

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       95
        
       ```

     

       96
        
       

     

       97
        
       ## How It Works

···

       32
        
       

     

       33
        
       ## Usage

     

       34
        
       

     

       35
       +
       ### Commands

     

       36
       +
       

     

       37
       +
       The CLI supports three main commands:

     

       38
       +
       - **deploy**: Upload a site to your PDS (default command)

     

       39
       +
       - **pull**: Download a site from a PDS to a local directory

     

       40
       +
       - **serve**: Serve a site locally with real-time firehose updates

     

       41
       +
       

     

       42
        
       ### Basic Deployment

     

       43
        
       

     

       44
        
       Deploy the current directory:

     

       45
        
       

     

       46
        
       ```bash

     

       47
       +
       wisp-cli nekomimi.pet --path . --site my-site

     

       48
        
       ```

     

       49
        
       

     

       50
        
       Deploy a specific directory:

     
···

       53
        
       wisp-cli alice.bsky.social --path ./dist/ --site my-site

     

       54
        
       ```

     

       55
        
       

     

       56
       +
       Or use the explicit `deploy` subcommand:

     

       57
       +
       

     

       58
       +
       ```bash

     

       59
       +
       wisp-cli deploy alice.bsky.social --path ./dist/ --site my-site

     

       60
       +
       ```

     

       61
       +
       

     

       62
       +
       ### Pull a Site

     

       63
       +
       

     

       64
       +
       Download a site from a PDS to a local directory:

     

       65
       +
       

     

       66
       +
       ```bash

     

       67
       +
       wisp-cli pull alice.bsky.social --site my-site --path ./downloaded-site

     

       68
       +
       ```

     

       69
       +
       

     

       70
       +
       This will download all files from the site to the specified directory.

     

       71
       +
       

     

       72
       +
       ### Serve a Site Locally

     

       73
       +
       

     

       74
       +
       Serve a site locally with real-time updates from the firehose:

     

       75
       +
       

     

       76
       +
       ```bash

     

       77
       +
       wisp-cli serve alice.bsky.social --site my-site --path ./site --port 8080

     

       78
       +
       ```

     

       79
       +
       

     

       80
       +
       This will:

     

       81
       +
       1. Download the site to the specified path

     

       82
       +
       2. Start a local server on the specified port (default: 8080)

     

       83
       +
       3. Watch the firehose for updates and automatically reload files when changed

     

       84
       +
       

     

       85
        
       ### Authentication Methods

     

       86
        
       

     

       87
        
       #### OAuth (Recommended)

     
···

       115
        
       

     

       116
        
       ## Command-Line Options

     

       117
        
       

     

       118
       +
       ### Deploy Command

     

       119
       +
       

     

       120
        
       ```

     

       121
       +
       wisp-cli [deploy] [OPTIONS] <INPUT>

     

       122
        
       

     

       123
        
       Arguments:

     

       124
        
         <INPUT>  Handle (e.g., alice.bsky.social), DID, or PDS URL

     
···

       128
        
         -s, --site <SITE>           Site name (defaults to directory name)

     

       129
        
             --store <STORE>         Path to auth store file (only used with OAuth) [default: /tmp/wisp-oauth-session.json]

     

       130
        
             --password <PASSWORD>   App Password for authentication (alternative to OAuth)

     

       131
       +
             --directory             Enable directory listing mode for paths without index files

     

       132
       +
             --spa                   Enable SPA mode (serve index.html for all routes)

     

       133
       +
         -y, --yes                   Skip confirmation prompts (automatically accept warnings)

     

       134
        
         -h, --help                  Print help

     

       135
        
         -V, --version               Print version

     

       136
       +
       ```

     

       137
       +
       

     

       138
       +
       ### Pull Command

     

       139
       +
       

     

       140
       +
       ```

     

       141
       +
       wisp-cli pull [OPTIONS] --site <SITE> <INPUT>

     

       142
       +
       

     

       143
       +
       Arguments:

     

       144
       +
         <INPUT>  Handle (e.g., alice.bsky.social) or DID

     

       145
       +
       

     

       146
       +
       Options:

     

       147
       +
         -s, --site <SITE>  Site name (record key)

     

       148
       +
         -p, --path <PATH>  Output directory for the downloaded site [default: .]

     

       149
       +
         -h, --help         Print help

     

       150
       +
       ```

     

       151
       +
       

     

       152
       +
       ### Serve Command

     

       153
       +
       

     

       154
       +
       ```

     

       155
       +
       wisp-cli serve [OPTIONS] --site <SITE> <INPUT>

     

       156
       +
       

     

       157
       +
       Arguments:

     

       158
       +
         <INPUT>  Handle (e.g., alice.bsky.social) or DID

     

       159
       +
       

     

       160
       +
       Options:

     

       161
       +
         -s, --site <SITE>  Site name (record key)

     

       162
       +
         -p, --path <PATH>  Output directory for the site files [default: .]

     

       163
       +
         -P, --port <PORT>  Port to serve on [default: 8080]

     

       164
       +
         -h, --help         Print help

     

       165
        
       ```

     

       166
        
       

     

       167
        
       ## How It Works

+15

cli/crates/lexicons/Cargo.toml

···

       1
       +
       [package]

     

       2
       +
       name = "wisp-lexicons"

     

       3
       +
       version = "0.1.0"

     

       4
       +
       edition = "2024"

     

       5
       +
       

     

       6
       +
       [features]

     

       7
       +
       default = ["place_wisp"]

     

       8
       +
       place_wisp = []

     

       9
       +
       

     

       10
       +
       [dependencies]

     

       11
       +
       jacquard-common = { git = "https://tangled.org/nonbinary.computer/jacquard" }

     

       12
       +
       jacquard-derive = { git = "https://tangled.org/nonbinary.computer/jacquard" }

     

       13
       +
       jacquard-lexicon = { git = "https://tangled.org/nonbinary.computer/jacquard" }

     

       14
       +
       serde = { version = "1.0", features = ["derive"] }

     

       15
       +
       rustversion = "1.0"

+43

cli/crates/lexicons/src/builder_types.rs

···

       1
       +
       // @generated by jacquard-lexicon. DO NOT EDIT.

     

       2
       +
       //

     

       3
       +
       // This file was automatically generated from Lexicon schemas.

     

       4
       +
       // Any manual changes will be overwritten on the next regeneration.

     

       5
       +
       

     

       6
       +
       /// Marker type indicating a builder field has been set

     

       7
       +
       pub struct Set<T>(pub T);

     

       8
       +
       impl<T> Set<T> {

     

       9
       +
           /// Extract the inner value

     

       10
       +
           #[inline]

     

       11
       +
           pub fn into_inner(self) -> T {

     

       12
       +
               self.0

     

       13
       +
           }

     

       14
       +
       }

     

       15
       +
       

     

       16
       +
       /// Marker type indicating a builder field has not been set

     

       17
       +
       pub struct Unset;

     

       18
       +
       /// Trait indicating a builder field is set (has a value)

     

       19
       +
       #[rustversion::attr(

     

       20
       +
           since(1.78.0),

     

       21
       +
           diagnostic::on_unimplemented(

     

       22
       +
               message = "the field `{Self}` was not set, but this method requires it to be set",

     

       23
       +
               label = "the field `{Self}` was not set"

     

       24
       +
           )

     

       25
       +
       )]

     

       26
       +
       pub trait IsSet: private::Sealed {}

     

       27
       +
       /// Trait indicating a builder field is unset (no value yet)

     

       28
       +
       #[rustversion::attr(

     

       29
       +
           since(1.78.0),

     

       30
       +
           diagnostic::on_unimplemented(

     

       31
       +
               message = "the field `{Self}` was already set, but this method requires it to be unset",

     

       32
       +
               label = "the field `{Self}` was already set"

     

       33
       +
           )

     

       34
       +
       )]

     

       35
       +
       pub trait IsUnset: private::Sealed {}

     

       36
       +
       impl<T> IsSet for Set<T> {}

     

       37
       +
       impl IsUnset for Unset {}

     

       38
       +
       mod private {

     

       39
       +
           /// Sealed trait to prevent external implementations

     

       40
       +
           pub trait Sealed {}

     

       41
       +
           impl<T> Sealed for super::Set<T> {}

     

       42
       +
           impl Sealed for super::Unset {}

     

       43
       +
       }

+11

cli/crates/lexicons/src/lib.rs

···

       1
       +
       extern crate alloc;

     

       2
       +
       

     

       3
       +
       // @generated by jacquard-lexicon. DO NOT EDIT.

     

       4
       +
       //

     

       5
       +
       // This file was automatically generated from Lexicon schemas.

     

       6
       +
       // Any manual changes will be overwritten on the next regeneration.

     

       7
       +
       

     

       8
       +
       pub mod builder_types;

     

       9
       +
       

     

       10
       +
       #[cfg(feature = "place_wisp")]

     

       11
       +
       pub mod place_wisp;

+1490

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

···

       1
       +
       // @generated by jacquard-lexicon. DO NOT EDIT.

     

       2
       +
       //

     

       3
       +
       // Lexicon: place.wisp.fs

     

       4
       +
       //

     

       5
       +
       // This file was automatically generated from Lexicon schemas.

     

       6
       +
       // Any manual changes will be overwritten on the next regeneration.

     

       7
       +
       

     

       8
       +
       #[jacquard_derive::lexicon]

     

       9
       +
       #[derive(

     

       10
       +
           serde::Serialize,

     

       11
       +
           serde::Deserialize,

     

       12
       +
           Debug,

     

       13
       +
           Clone,

     

       14
       +
           PartialEq,

     

       15
       +
           Eq,

     

       16
       +
           jacquard_derive::IntoStatic

     

       17
       +
       )]

     

       18
       +
       #[serde(rename_all = "camelCase")]

     

       19
       +
       pub struct Directory<'a> {

     

       20
       +
           #[serde(borrow)]

     

       21
       +
           pub entries: Vec<crate::place_wisp::fs::Entry<'a>>,

     

       22
       +
           #[serde(borrow)]

     

       23
       +
           pub r#type: jacquard_common::CowStr<'a>,

     

       24
       +
       }

     

       25
       +
       

     

       26
       +
       pub mod directory_state {

     

       27
       +
       

     

       28
       +
           pub use crate::builder_types::{Set, Unset, IsSet, IsUnset};

     

       29
       +
           #[allow(unused)]

     

       30
       +
           use ::core::marker::PhantomData;

     

       31
       +
           mod sealed {

     

       32
       +
               pub trait Sealed {}

     

       33
       +
           }

     

       34
       +
           /// State trait tracking which required fields have been set

     

       35
       +
           pub trait State: sealed::Sealed {

     

       36
       +
               type Type;

     

       37
       +
               type Entries;

     

       38
       +
           }

     

       39
       +
           /// Empty state - all required fields are unset

     

       40
       +
           pub struct Empty(());

     

       41
       +
           impl sealed::Sealed for Empty {}

     

       42
       +
           impl State for Empty {

     

       43
       +
               type Type = Unset;

     

       44
       +
               type Entries = Unset;

     

       45
       +
           }

     

       46
       +
           ///State transition - sets the `type` field to Set

     

       47
       +
           pub struct SetType<S: State = Empty>(PhantomData<fn() -> S>);

     

       48
       +
           impl<S: State> sealed::Sealed for SetType<S> {}

     

       49
       +
           impl<S: State> State for SetType<S> {

     

       50
       +
               type Type = Set<members::r#type>;

     

       51
       +
               type Entries = S::Entries;

     

       52
       +
           }

     

       53
       +
           ///State transition - sets the `entries` field to Set

     

       54
       +
           pub struct SetEntries<S: State = Empty>(PhantomData<fn() -> S>);

     

       55
       +
           impl<S: State> sealed::Sealed for SetEntries<S> {}

     

       56
       +
           impl<S: State> State for SetEntries<S> {

     

       57
       +
               type Type = S::Type;

     

       58
       +
               type Entries = Set<members::entries>;

     

       59
       +
           }

     

       60
       +
           /// Marker types for field names

     

       61
       +
           #[allow(non_camel_case_types)]

     

       62
       +
           pub mod members {

     

       63
       +
               ///Marker type for the `type` field

     

       64
       +
               pub struct r#type(());

     

       65
       +
               ///Marker type for the `entries` field

     

       66
       +
               pub struct entries(());

     

       67
       +
           }

     

       68
       +
       }

     

       69
       +
       

     

       70
       +
       /// Builder for constructing an instance of this type

     

       71
       +
       pub struct DirectoryBuilder<'a, S: directory_state::State> {

     

       72
       +
           _phantom_state: ::core::marker::PhantomData<fn() -> S>,

     

       73
       +
           __unsafe_private_named: (

     

       74
       +
               ::core::option::Option<Vec<crate::place_wisp::fs::Entry<'a>>>,

     

       75
       +
               ::core::option::Option<jacquard_common::CowStr<'a>>,

     

       76
       +
           ),

     

       77
       +
           _phantom: ::core::marker::PhantomData<&'a ()>,

     

       78
       +
       }

     

       79
       +
       

     

       80
       +
       impl<'a> Directory<'a> {

     

       81
       +
           /// Create a new builder for this type

     

       82
       +
           pub fn new() -> DirectoryBuilder<'a, directory_state::Empty> {

     

       83
       +
               DirectoryBuilder::new()

     

       84
       +
           }

     

       85
       +
       }

     

       86
       +
       

     

       87
       +
       impl<'a> DirectoryBuilder<'a, directory_state::Empty> {

     

       88
       +
           /// Create a new builder with all fields unset

     

       89
       +
           pub fn new() -> Self {

     

       90
       +
               DirectoryBuilder {

     

       91
       +
                   _phantom_state: ::core::marker::PhantomData,

     

       92
       +
                   __unsafe_private_named: (None, None),

     

       93
       +
                   _phantom: ::core::marker::PhantomData,

     

       94
       +
               }

     

       95
       +
           }

     

       96
       +
       }

     

       97
       +
       

     

       98
       +
       impl<'a, S> DirectoryBuilder<'a, S>

     

       99
       +
       where

     

       100
       +
           S: directory_state::State,

     

       101
       +
           S::Entries: directory_state::IsUnset,

     

       102
       +
       {

     

       103
       +
           /// Set the `entries` field (required)

     

       104
       +
           pub fn entries(

     

       105
       +
               mut self,

     

       106
       +
               value: impl Into<Vec<crate::place_wisp::fs::Entry<'a>>>,

     

       107
       +
           ) -> DirectoryBuilder<'a, directory_state::SetEntries<S>> {

     

       108
       +
               self.__unsafe_private_named.0 = ::core::option::Option::Some(value.into());

     

       109
       +
               DirectoryBuilder {

     

       110
       +
                   _phantom_state: ::core::marker::PhantomData,

     

       111
       +
                   __unsafe_private_named: self.__unsafe_private_named,

     

       112
       +
                   _phantom: ::core::marker::PhantomData,

     

       113
       +
               }

     

       114
       +
           }

     

       115
       +
       }

     

       116
       +
       

     

       117
       +
       impl<'a, S> DirectoryBuilder<'a, S>

     

       118
       +
       where

     

       119
       +
           S: directory_state::State,

     

       120
       +
           S::Type: directory_state::IsUnset,

     

       121
       +
       {

     

       122
       +
           /// Set the `type` field (required)

     

       123
       +
           pub fn r#type(

     

       124
       +
               mut self,

     

       125
       +
               value: impl Into<jacquard_common::CowStr<'a>>,

     

       126
       +
           ) -> DirectoryBuilder<'a, directory_state::SetType<S>> {

     

       127
       +
               self.__unsafe_private_named.1 = ::core::option::Option::Some(value.into());

     

       128
       +
               DirectoryBuilder {

     

       129
       +
                   _phantom_state: ::core::marker::PhantomData,

     

       130
       +
                   __unsafe_private_named: self.__unsafe_private_named,

     

       131
       +
                   _phantom: ::core::marker::PhantomData,

     

       132
       +
               }

     

       133
       +
           }

     

       134
       +
       }

     

       135
       +
       

     

       136
       +
       impl<'a, S> DirectoryBuilder<'a, S>

     

       137
       +
       where

     

       138
       +
           S: directory_state::State,

     

       139
       +
           S::Type: directory_state::IsSet,

     

       140
       +
           S::Entries: directory_state::IsSet,

     

       141
       +
       {

     

       142
       +
           /// Build the final struct

     

       143
       +
           pub fn build(self) -> Directory<'a> {

     

       144
       +
               Directory {

     

       145
       +
                   entries: self.__unsafe_private_named.0.unwrap(),

     

       146
       +
                   r#type: self.__unsafe_private_named.1.unwrap(),

     

       147
       +
                   extra_data: Default::default(),

     

       148
       +
               }

     

       149
       +
           }

     

       150
       +
           /// Build the final struct with custom extra_data

     

       151
       +
           pub fn build_with_data(

     

       152
       +
               self,

     

       153
       +
               extra_data: std::collections::BTreeMap<

     

       154
       +
                   jacquard_common::smol_str::SmolStr,

     

       155
       +
                   jacquard_common::types::value::Data<'a>,

     

       156
       +
               >,

     

       157
       +
           ) -> Directory<'a> {

     

       158
       +
               Directory {

     

       159
       +
                   entries: self.__unsafe_private_named.0.unwrap(),

     

       160
       +
                   r#type: self.__unsafe_private_named.1.unwrap(),

     

       161
       +
                   extra_data: Some(extra_data),

     

       162
       +
               }

     

       163
       +
           }

     

       164
       +
       }

     

       165
       +
       

     

       166
       +
       fn lexicon_doc_place_wisp_fs() -> ::jacquard_lexicon::lexicon::LexiconDoc<'static> {

     

       167
       +
           ::jacquard_lexicon::lexicon::LexiconDoc {

     

       168
       +
               lexicon: ::jacquard_lexicon::lexicon::Lexicon::Lexicon1,

     

       169
       +
               id: ::jacquard_common::CowStr::new_static("place.wisp.fs"),

     

       170
       +
               revision: None,

     

       171
       +
               description: None,

     

       172
       +
               defs: {

     

       173
       +
                   let mut map = ::std::collections::BTreeMap::new();

     

       174
       +
                   map.insert(

     

       175
       +
                       ::jacquard_common::smol_str::SmolStr::new_static("directory"),

     

       176
       +
                       ::jacquard_lexicon::lexicon::LexUserType::Object(::jacquard_lexicon::lexicon::LexObject {

     

       177
       +
                           description: None,

     

       178
       +
                           required: Some(

     

       179
       +
                               vec![

     

       180
       +
                                   ::jacquard_common::smol_str::SmolStr::new_static("type"),

     

       181
       +
                                   ::jacquard_common::smol_str::SmolStr::new_static("entries")

     

       182
       +
                               ],

     

       183
       +
                           ),

     

       184
       +
                           nullable: None,

     

       185
       +
                           properties: {

     

       186
       +
                               #[allow(unused_mut)]

     

       187
       +
                               let mut map = ::std::collections::BTreeMap::new();

     

       188
       +
                               map.insert(

     

       189
       +
                                   ::jacquard_common::smol_str::SmolStr::new_static("entries"),

     

       190
       +
                                   ::jacquard_lexicon::lexicon::LexObjectProperty::Array(::jacquard_lexicon::lexicon::LexArray {

     

       191
       +
                                       description: None,

     

       192
       +
                                       items: ::jacquard_lexicon::lexicon::LexArrayItem::Ref(::jacquard_lexicon::lexicon::LexRef {

     

       193
       +
                                           description: None,

     

       194
       +
                                           r#ref: ::jacquard_common::CowStr::new_static("#entry"),

     

       195
       +
                                       }),

     

       196
       +
                                       min_length: None,

     

       197
       +
                                       max_length: Some(500usize),

     

       198
       +
                                   }),

     

       199
       +
                               );

     

       200
       +
                               map.insert(

     

       201
       +
                                   ::jacquard_common::smol_str::SmolStr::new_static("type"),

     

       202
       +
                                   ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {

     

       203
       +
                                       description: None,

     

       204
       +
                                       format: None,

     

       205
       +
                                       default: None,

     

       206
       +
                                       min_length: None,

     

       207
       +
                                       max_length: None,

     

       208
       +
                                       min_graphemes: None,

     

       209
       +
                                       max_graphemes: None,

     

       210
       +
                                       r#enum: None,

     

       211
       +
                                       r#const: None,

     

       212
       +
                                       known_values: None,

     

       213
       +
                                   }),

     

       214
       +
                               );

     

       215
       +
                               map

     

       216
       +
                           },

     

       217
       +
                       }),

     

       218
       +
                   );

     

       219
       +
                   map.insert(

     

       220
       +
                       ::jacquard_common::smol_str::SmolStr::new_static("entry"),

     

       221
       +
                       ::jacquard_lexicon::lexicon::LexUserType::Object(::jacquard_lexicon::lexicon::LexObject {

     

       222
       +
                           description: None,

     

       223
       +
                           required: Some(

     

       224
       +
                               vec![

     

       225
       +
                                   ::jacquard_common::smol_str::SmolStr::new_static("name"),

     

       226
       +
                                   ::jacquard_common::smol_str::SmolStr::new_static("node")

     

       227
       +
                               ],

     

       228
       +
                           ),

     

       229
       +
                           nullable: None,

     

       230
       +
                           properties: {

     

       231
       +
                               #[allow(unused_mut)]

     

       232
       +
                               let mut map = ::std::collections::BTreeMap::new();

     

       233
       +
                               map.insert(

     

       234
       +
                                   ::jacquard_common::smol_str::SmolStr::new_static("name"),

     

       235
       +
                                   ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {

     

       236
       +
                                       description: None,

     

       237
       +
                                       format: None,

     

       238
       +
                                       default: None,

     

       239
       +
                                       min_length: None,

     

       240
       +
                                       max_length: Some(255usize),

     

       241
       +
                                       min_graphemes: None,

     

       242
       +
                                       max_graphemes: None,

     

       243
       +
                                       r#enum: None,

     

       244
       +
                                       r#const: None,

     

       245
       +
                                       known_values: None,

     

       246
       +
                                   }),

     

       247
       +
                               );

     

       248
       +
                               map.insert(

     

       249
       +
                                   ::jacquard_common::smol_str::SmolStr::new_static("node"),

     

       250
       +
                                   ::jacquard_lexicon::lexicon::LexObjectProperty::Union(::jacquard_lexicon::lexicon::LexRefUnion {

     

       251
       +
                                       description: None,

     

       252
       +
                                       refs: vec![

     

       253
       +
                                           ::jacquard_common::CowStr::new_static("#file"),

     

       254
       +
                                           ::jacquard_common::CowStr::new_static("#directory"),

     

       255
       +
                                           ::jacquard_common::CowStr::new_static("#subfs")

     

       256
       +
                                       ],

     

       257
       +
                                       closed: None,

     

       258
       +
                                   }),

     

       259
       +
                               );

     

       260
       +
                               map

     

       261
       +
                           },

     

       262
       +
                       }),

     

       263
       +
                   );

     

       264
       +
                   map.insert(

     

       265
       +
                       ::jacquard_common::smol_str::SmolStr::new_static("file"),

     

       266
       +
                       ::jacquard_lexicon::lexicon::LexUserType::Object(::jacquard_lexicon::lexicon::LexObject {

     

       267
       +
                           description: None,

     

       268
       +
                           required: Some(

     

       269
       +
                               vec![

     

       270
       +
                                   ::jacquard_common::smol_str::SmolStr::new_static("type"),

     

       271
       +
                                   ::jacquard_common::smol_str::SmolStr::new_static("blob")

     

       272
       +
                               ],

     

       273
       +
                           ),

     

       274
       +
                           nullable: None,

     

       275
       +
                           properties: {

     

       276
       +
                               #[allow(unused_mut)]

     

       277
       +
                               let mut map = ::std::collections::BTreeMap::new();

     

       278
       +
                               map.insert(

     

       279
       +
                                   ::jacquard_common::smol_str::SmolStr::new_static("base64"),

     

       280
       +
                                   ::jacquard_lexicon::lexicon::LexObjectProperty::Boolean(::jacquard_lexicon::lexicon::LexBoolean {

     

       281
       +
                                       description: None,

     

       282
       +
                                       default: None,

     

       283
       +
                                       r#const: None,

     

       284
       +
                                   }),

     

       285
       +
                               );

     

       286
       +
                               map.insert(

     

       287
       +
                                   ::jacquard_common::smol_str::SmolStr::new_static("blob"),

     

       288
       +
                                   ::jacquard_lexicon::lexicon::LexObjectProperty::Blob(::jacquard_lexicon::lexicon::LexBlob {

     

       289
       +
                                       description: None,

     

       290
       +
                                       accept: None,

     

       291
       +
                                       max_size: None,

     

       292
       +
                                   }),

     

       293
       +
                               );

     

       294
       +
                               map.insert(

     

       295
       +
                                   ::jacquard_common::smol_str::SmolStr::new_static("encoding"),

     

       296
       +
                                   ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {

     

       297
       +
                                       description: Some(

     

       298
       +
                                           ::jacquard_common::CowStr::new_static(

     

       299
       +
                                               "Content encoding (e.g., gzip for compressed files)",

     

       300
       +
                                           ),

     

       301
       +
                                       ),

     

       302
       +
                                       format: None,

     

       303
       +
                                       default: None,

     

       304
       +
                                       min_length: None,

     

       305
       +
                                       max_length: None,

     

       306
       +
                                       min_graphemes: None,

     

       307
       +
                                       max_graphemes: None,

     

       308
       +
                                       r#enum: None,

     

       309
       +
                                       r#const: None,

     

       310
       +
                                       known_values: None,

     

       311
       +
                                   }),

     

       312
       +
                               );

     

       313
       +
                               map.insert(

     

       314
       +
                                   ::jacquard_common::smol_str::SmolStr::new_static("mimeType"),

     

       315
       +
                                   ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {

     

       316
       +
                                       description: Some(

     

       317
       +
                                           ::jacquard_common::CowStr::new_static(

     

       318
       +
                                               "Original MIME type before compression",

     

       319
       +
                                           ),

     

       320
       +
                                       ),

     

       321
       +
                                       format: None,

     

       322
       +
                                       default: None,

     

       323
       +
                                       min_length: None,

     

       324
       +
                                       max_length: None,

     

       325
       +
                                       min_graphemes: None,

     

       326
       +
                                       max_graphemes: None,

     

       327
       +
                                       r#enum: None,

     

       328
       +
                                       r#const: None,

     

       329
       +
                                       known_values: None,

     

       330
       +
                                   }),

     

       331
       +
                               );

     

       332
       +
                               map.insert(

     

       333
       +
                                   ::jacquard_common::smol_str::SmolStr::new_static("type"),

     

       334
       +
                                   ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {

     

       335
       +
                                       description: None,

     

       336
       +
                                       format: None,

     

       337
       +
                                       default: None,

     

       338
       +
                                       min_length: None,

     

       339
       +
                                       max_length: None,

     

       340
       +
                                       min_graphemes: None,

     

       341
       +
                                       max_graphemes: None,

     

       342
       +
                                       r#enum: None,

     

       343
       +
                                       r#const: None,

     

       344
       +
                                       known_values: None,

     

       345
       +
                                   }),

     

       346
       +
                               );

     

       347
       +
                               map

     

       348
       +
                           },

     

       349
       +
                       }),

     

       350
       +
                   );

     

       351
       +
                   map.insert(

     

       352
       +
                       ::jacquard_common::smol_str::SmolStr::new_static("main"),

     

       353
       +
                       ::jacquard_lexicon::lexicon::LexUserType::Record(::jacquard_lexicon::lexicon::LexRecord {

     

       354
       +
                           description: Some(

     

       355
       +
                               ::jacquard_common::CowStr::new_static(

     

       356
       +
                                   "Virtual filesystem manifest for a Wisp site",

     

       357
       +
                               ),

     

       358
       +
                           ),

     

       359
       +
                           key: None,

     

       360
       +
                           record: ::jacquard_lexicon::lexicon::LexRecordRecord::Object(::jacquard_lexicon::lexicon::LexObject {

     

       361
       +
                               description: None,

     

       362
       +
                               required: Some(

     

       363
       +
                                   vec![

     

       364
       +
                                       ::jacquard_common::smol_str::SmolStr::new_static("site"),

     

       365
       +
                                       ::jacquard_common::smol_str::SmolStr::new_static("root"),

     

       366
       +
                                       ::jacquard_common::smol_str::SmolStr::new_static("createdAt")

     

       367
       +
                                   ],

     

       368
       +
                               ),

     

       369
       +
                               nullable: None,

     

       370
       +
                               properties: {

     

       371
       +
                                   #[allow(unused_mut)]

     

       372
       +
                                   let mut map = ::std::collections::BTreeMap::new();

     

       373
       +
                                   map.insert(

     

       374
       +
                                       ::jacquard_common::smol_str::SmolStr::new_static(

     

       375
       +
                                           "createdAt",

     

       376
       +
                                       ),

     

       377
       +
                                       ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {

     

       378
       +
                                           description: None,

     

       379
       +
                                           format: Some(

     

       380
       +
                                               ::jacquard_lexicon::lexicon::LexStringFormat::Datetime,

     

       381
       +
                                           ),

     

       382
       +
                                           default: None,

     

       383
       +
                                           min_length: None,

     

       384
       +
                                           max_length: None,

     

       385
       +
                                           min_graphemes: None,

     

       386
       +
                                           max_graphemes: None,

     

       387
       +
                                           r#enum: None,

     

       388
       +
                                           r#const: None,

     

       389
       +
                                           known_values: None,

     

       390
       +
                                       }),

     

       391
       +
                                   );

     

       392
       +
                                   map.insert(

     

       393
       +
                                       ::jacquard_common::smol_str::SmolStr::new_static(

     

       394
       +
                                           "fileCount",

     

       395
       +
                                       ),

     

       396
       +
                                       ::jacquard_lexicon::lexicon::LexObjectProperty::Integer(::jacquard_lexicon::lexicon::LexInteger {

     

       397
       +
                                           description: None,

     

       398
       +
                                           default: None,

     

       399
       +
                                           minimum: Some(0i64),

     

       400
       +
                                           maximum: Some(1000i64),

     

       401
       +
                                           r#enum: None,

     

       402
       +
                                           r#const: None,

     

       403
       +
                                       }),

     

       404
       +
                                   );

     

       405
       +
                                   map.insert(

     

       406
       +
                                       ::jacquard_common::smol_str::SmolStr::new_static("root"),

     

       407
       +
                                       ::jacquard_lexicon::lexicon::LexObjectProperty::Ref(::jacquard_lexicon::lexicon::LexRef {

     

       408
       +
                                           description: None,

     

       409
       +
                                           r#ref: ::jacquard_common::CowStr::new_static("#directory"),

     

       410
       +
                                       }),

     

       411
       +
                                   );

     

       412
       +
                                   map.insert(

     

       413
       +
                                       ::jacquard_common::smol_str::SmolStr::new_static("site"),

     

       414
       +
                                       ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {

     

       415
       +
                                           description: None,

     

       416
       +
                                           format: None,

     

       417
       +
                                           default: None,

     

       418
       +
                                           min_length: None,

     

       419
       +
                                           max_length: None,

     

       420
       +
                                           min_graphemes: None,

     

       421
       +
                                           max_graphemes: None,

     

       422
       +
                                           r#enum: None,

     

       423
       +
                                           r#const: None,

     

       424
       +
                                           known_values: None,

     

       425
       +
                                       }),

     

       426
       +
                                   );

     

       427
       +
                                   map

     

       428
       +
                               },

     

       429
       +
                           }),

     

       430
       +
                       }),

     

       431
       +
                   );

     

       432
       +
                   map.insert(

     

       433
       +
                       ::jacquard_common::smol_str::SmolStr::new_static("subfs"),

     

       434
       +
                       ::jacquard_lexicon::lexicon::LexUserType::Object(::jacquard_lexicon::lexicon::LexObject {

     

       435
       +
                           description: None,

     

       436
       +
                           required: Some(

     

       437
       +
                               vec![

     

       438
       +
                                   ::jacquard_common::smol_str::SmolStr::new_static("type"),

     

       439
       +
                                   ::jacquard_common::smol_str::SmolStr::new_static("subject")

     

       440
       +
                               ],

     

       441
       +
                           ),

     

       442
       +
                           nullable: None,

     

       443
       +
                           properties: {

     

       444
       +
                               #[allow(unused_mut)]

     

       445
       +
                               let mut map = ::std::collections::BTreeMap::new();

     

       446
       +
                               map.insert(

     

       447
       +
                                   ::jacquard_common::smol_str::SmolStr::new_static("flat"),

     

       448
       +
                                   ::jacquard_lexicon::lexicon::LexObjectProperty::Boolean(::jacquard_lexicon::lexicon::LexBoolean {

     

       449
       +
                                       description: None,

     

       450
       +
                                       default: None,

     

       451
       +
                                       r#const: None,

     

       452
       +
                                   }),

     

       453
       +
                               );

     

       454
       +
                               map.insert(

     

       455
       +
                                   ::jacquard_common::smol_str::SmolStr::new_static("subject"),

     

       456
       +
                                   ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {

     

       457
       +
                                       description: Some(

     

       458
       +
                                           ::jacquard_common::CowStr::new_static(

     

       459
       +
                                               "AT-URI pointing to a place.wisp.subfs record containing this subtree.",

     

       460
       +
                                           ),

     

       461
       +
                                       ),

     

       462
       +
                                       format: Some(

     

       463
       +
                                           ::jacquard_lexicon::lexicon::LexStringFormat::AtUri,

     

       464
       +
                                       ),

     

       465
       +
                                       default: None,

     

       466
       +
                                       min_length: None,

     

       467
       +
                                       max_length: None,

     

       468
       +
                                       min_graphemes: None,

     

       469
       +
                                       max_graphemes: None,

     

       470
       +
                                       r#enum: None,

     

       471
       +
                                       r#const: None,

     

       472
       +
                                       known_values: None,

     

       473
       +
                                   }),

     

       474
       +
                               );

     

       475
       +
                               map.insert(

     

       476
       +
                                   ::jacquard_common::smol_str::SmolStr::new_static("type"),

     

       477
       +
                                   ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {

     

       478
       +
                                       description: None,

     

       479
       +
                                       format: None,

     

       480
       +
                                       default: None,

     

       481
       +
                                       min_length: None,

     

       482
       +
                                       max_length: None,

     

       483
       +
                                       min_graphemes: None,

     

       484
       +
                                       max_graphemes: None,

     

       485
       +
                                       r#enum: None,

     

       486
       +
                                       r#const: None,

     

       487
       +
                                       known_values: None,

     

       488
       +
                                   }),

     

       489
       +
                               );

     

       490
       +
                               map

     

       491
       +
                           },

     

       492
       +
                       }),

     

       493
       +
                   );

     

       494
       +
                   map

     

       495
       +
               },

     

       496
       +
           }

     

       497
       +
       }

     

       498
       +
       

     

       499
       +
       impl<'a> ::jacquard_lexicon::schema::LexiconSchema for Directory<'a> {

     

       500
       +
           fn nsid() -> &'static str {

     

       501
       +
               "place.wisp.fs"

     

       502
       +
           }

     

       503
       +
           fn def_name() -> &'static str {

     

       504
       +
               "directory"

     

       505
       +
           }

     

       506
       +
           fn lexicon_doc() -> ::jacquard_lexicon::lexicon::LexiconDoc<'static> {

     

       507
       +
               lexicon_doc_place_wisp_fs()

     

       508
       +
           }

     

       509
       +
           fn validate(

     

       510
       +
               &self,

     

       511
       +
           ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> {

     

       512
       +
               {

     

       513
       +
                   let value = &self.entries;

     

       514
       +
                   #[allow(unused_comparisons)]

     

       515
       +
                   if value.len() > 500usize {

     

       516
       +
                       return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength {

     

       517
       +
                           path: ::jacquard_lexicon::validation::ValidationPath::from_field(

     

       518
       +
                               "entries",

     

       519
       +
                           ),

     

       520
       +
                           max: 500usize,

     

       521
       +
                           actual: value.len(),

     

       522
       +
                       });

     

       523
       +
                   }

     

       524
       +
               }

     

       525
       +
               Ok(())

     

       526
       +
           }

     

       527
       +
       }

     

       528
       +
       

     

       529
       +
       #[jacquard_derive::lexicon]

     

       530
       +
       #[derive(

     

       531
       +
           serde::Serialize,

     

       532
       +
           serde::Deserialize,

     

       533
       +
           Debug,

     

       534
       +
           Clone,

     

       535
       +
           PartialEq,

     

       536
       +
           Eq,

     

       537
       +
           jacquard_derive::IntoStatic

     

       538
       +
       )]

     

       539
       +
       #[serde(rename_all = "camelCase")]

     

       540
       +
       pub struct Entry<'a> {

     

       541
       +
           #[serde(borrow)]

     

       542
       +
           pub name: jacquard_common::CowStr<'a>,

     

       543
       +
           #[serde(borrow)]

     

       544
       +
           pub node: EntryNode<'a>,

     

       545
       +
       }

     

       546
       +
       

     

       547
       +
       pub mod entry_state {

     

       548
       +
       

     

       549
       +
           pub use crate::builder_types::{Set, Unset, IsSet, IsUnset};

     

       550
       +
           #[allow(unused)]

     

       551
       +
           use ::core::marker::PhantomData;

     

       552
       +
           mod sealed {

     

       553
       +
               pub trait Sealed {}

     

       554
       +
           }

     

       555
       +
           /// State trait tracking which required fields have been set

     

       556
       +
           pub trait State: sealed::Sealed {

     

       557
       +
               type Node;

     

       558
       +
               type Name;

     

       559
       +
           }

     

       560
       +
           /// Empty state - all required fields are unset

     

       561
       +
           pub struct Empty(());

     

       562
       +
           impl sealed::Sealed for Empty {}

     

       563
       +
           impl State for Empty {

     

       564
       +
               type Node = Unset;

     

       565
       +
               type Name = Unset;

     

       566
       +
           }

     

       567
       +
           ///State transition - sets the `node` field to Set

     

       568
       +
           pub struct SetNode<S: State = Empty>(PhantomData<fn() -> S>);

     

       569
       +
           impl<S: State> sealed::Sealed for SetNode<S> {}

     

       570
       +
           impl<S: State> State for SetNode<S> {

     

       571
       +
               type Node = Set<members::node>;

     

       572
       +
               type Name = S::Name;

     

       573
       +
           }

     

       574
       +
           ///State transition - sets the `name` field to Set

     

       575
       +
           pub struct SetName<S: State = Empty>(PhantomData<fn() -> S>);

     

       576
       +
           impl<S: State> sealed::Sealed for SetName<S> {}

     

       577
       +
           impl<S: State> State for SetName<S> {

     

       578
       +
               type Node = S::Node;

     

       579
       +
               type Name = Set<members::name>;

     

       580
       +
           }

     

       581
       +
           /// Marker types for field names

     

       582
       +
           #[allow(non_camel_case_types)]

     

       583
       +
           pub mod members {

     

       584
       +
               ///Marker type for the `node` field

     

       585
       +
               pub struct node(());

     

       586
       +
               ///Marker type for the `name` field

     

       587
       +
               pub struct name(());

     

       588
       +
           }

     

       589
       +
       }

     

       590
       +
       

     

       591
       +
       /// Builder for constructing an instance of this type

     

       592
       +
       pub struct EntryBuilder<'a, S: entry_state::State> {

     

       593
       +
           _phantom_state: ::core::marker::PhantomData<fn() -> S>,

     

       594
       +
           __unsafe_private_named: (

     

       595
       +
               ::core::option::Option<jacquard_common::CowStr<'a>>,

     

       596
       +
               ::core::option::Option<EntryNode<'a>>,

     

       597
       +
           ),

     

       598
       +
           _phantom: ::core::marker::PhantomData<&'a ()>,

     

       599
       +
       }

     

       600
       +
       

     

       601
       +
       impl<'a> Entry<'a> {

     

       602
       +
           /// Create a new builder for this type

     

       603
       +
           pub fn new() -> EntryBuilder<'a, entry_state::Empty> {

     

       604
       +
               EntryBuilder::new()

     

       605
       +
           }

     

       606
       +
       }

     

       607
       +
       

     

       608
       +
       impl<'a> EntryBuilder<'a, entry_state::Empty> {

     

       609
       +
           /// Create a new builder with all fields unset

     

       610
       +
           pub fn new() -> Self {

     

       611
       +
               EntryBuilder {

     

       612
       +
                   _phantom_state: ::core::marker::PhantomData,

     

       613
       +
                   __unsafe_private_named: (None, None),

     

       614
       +
                   _phantom: ::core::marker::PhantomData,

     

       615
       +
               }

     

       616
       +
           }

     

       617
       +
       }

     

       618
       +
       

     

       619
       +
       impl<'a, S> EntryBuilder<'a, S>

     

       620
       +
       where

     

       621
       +
           S: entry_state::State,

     

       622
       +
           S::Name: entry_state::IsUnset,

     

       623
       +
       {

     

       624
       +
           /// Set the `name` field (required)

     

       625
       +
           pub fn name(

     

       626
       +
               mut self,

     

       627
       +
               value: impl Into<jacquard_common::CowStr<'a>>,

     

       628
       +
           ) -> EntryBuilder<'a, entry_state::SetName<S>> {

     

       629
       +
               self.__unsafe_private_named.0 = ::core::option::Option::Some(value.into());

     

       630
       +
               EntryBuilder {

     

       631
       +
                   _phantom_state: ::core::marker::PhantomData,

     

       632
       +
                   __unsafe_private_named: self.__unsafe_private_named,

     

       633
       +
                   _phantom: ::core::marker::PhantomData,

     

       634
       +
               }

     

       635
       +
           }

     

       636
       +
       }

     

       637
       +
       

     

       638
       +
       impl<'a, S> EntryBuilder<'a, S>

     

       639
       +
       where

     

       640
       +
           S: entry_state::State,

     

       641
       +
           S::Node: entry_state::IsUnset,

     

       642
       +
       {

     

       643
       +
           /// Set the `node` field (required)

     

       644
       +
           pub fn node(

     

       645
       +
               mut self,

     

       646
       +
               value: impl Into<EntryNode<'a>>,

     

       647
       +
           ) -> EntryBuilder<'a, entry_state::SetNode<S>> {

     

       648
       +
               self.__unsafe_private_named.1 = ::core::option::Option::Some(value.into());

     

       649
       +
               EntryBuilder {

     

       650
       +
                   _phantom_state: ::core::marker::PhantomData,

     

       651
       +
                   __unsafe_private_named: self.__unsafe_private_named,

     

       652
       +
                   _phantom: ::core::marker::PhantomData,

     

       653
       +
               }

     

       654
       +
           }

     

       655
       +
       }

     

       656
       +
       

     

       657
       +
       impl<'a, S> EntryBuilder<'a, S>

     

       658
       +
       where

     

       659
       +
           S: entry_state::State,

     

       660
       +
           S::Node: entry_state::IsSet,

     

       661
       +
           S::Name: entry_state::IsSet,

     

       662
       +
       {

     

       663
       +
           /// Build the final struct

     

       664
       +
           pub fn build(self) -> Entry<'a> {

     

       665
       +
               Entry {

     

       666
       +
                   name: self.__unsafe_private_named.0.unwrap(),

     

       667
       +
                   node: self.__unsafe_private_named.1.unwrap(),

     

       668
       +
                   extra_data: Default::default(),

     

       669
       +
               }

     

       670
       +
           }

     

       671
       +
           /// Build the final struct with custom extra_data

     

       672
       +
           pub fn build_with_data(

     

       673
       +
               self,

     

       674
       +
               extra_data: std::collections::BTreeMap<

     

       675
       +
                   jacquard_common::smol_str::SmolStr,

     

       676
       +
                   jacquard_common::types::value::Data<'a>,

     

       677
       +
               >,

     

       678
       +
           ) -> Entry<'a> {

     

       679
       +
               Entry {

     

       680
       +
                   name: self.__unsafe_private_named.0.unwrap(),

     

       681
       +
                   node: self.__unsafe_private_named.1.unwrap(),

     

       682
       +
                   extra_data: Some(extra_data),

     

       683
       +
               }

     

       684
       +
           }

     

       685
       +
       }

     

       686
       +
       

     

       687
       +
       #[jacquard_derive::open_union]

     

       688
       +
       #[derive(

     

       689
       +
           serde::Serialize,

     

       690
       +
           serde::Deserialize,

     

       691
       +
           Debug,

     

       692
       +
           Clone,

     

       693
       +
           PartialEq,

     

       694
       +
           Eq,

     

       695
       +
           jacquard_derive::IntoStatic

     

       696
       +
       )]

     

       697
       +
       #[serde(tag = "$type")]

     

       698
       +
       #[serde(bound(deserialize = "'de: 'a"))]

     

       699
       +
       pub enum EntryNode<'a> {

     

       700
       +
           #[serde(rename = "place.wisp.fs#file")]

     

       701
       +
           File(Box<crate::place_wisp::fs::File<'a>>),

     

       702
       +
           #[serde(rename = "place.wisp.fs#directory")]

     

       703
       +
           Directory(Box<crate::place_wisp::fs::Directory<'a>>),

     

       704
       +
           #[serde(rename = "place.wisp.fs#subfs")]

     

       705
       +
           Subfs(Box<crate::place_wisp::fs::Subfs<'a>>),

     

       706
       +
       }

     

       707
       +
       

     

       708
       +
       impl<'a> ::jacquard_lexicon::schema::LexiconSchema for Entry<'a> {

     

       709
       +
           fn nsid() -> &'static str {

     

       710
       +
               "place.wisp.fs"

     

       711
       +
           }

     

       712
       +
           fn def_name() -> &'static str {

     

       713
       +
               "entry"

     

       714
       +
           }

     

       715
       +
           fn lexicon_doc() -> ::jacquard_lexicon::lexicon::LexiconDoc<'static> {

     

       716
       +
               lexicon_doc_place_wisp_fs()

     

       717
       +
           }

     

       718
       +
           fn validate(

     

       719
       +
               &self,

     

       720
       +
           ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> {

     

       721
       +
               {

     

       722
       +
                   let value = &self.name;

     

       723
       +
                   #[allow(unused_comparisons)]

     

       724
       +
                   if <str>::len(value.as_ref()) > 255usize {

     

       725
       +
                       return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength {

     

       726
       +
                           path: ::jacquard_lexicon::validation::ValidationPath::from_field(

     

       727
       +
                               "name",

     

       728
       +
                           ),

     

       729
       +
                           max: 255usize,

     

       730
       +
                           actual: <str>::len(value.as_ref()),

     

       731
       +
                       });

     

       732
       +
                   }

     

       733
       +
               }

     

       734
       +
               Ok(())

     

       735
       +
           }

     

       736
       +
       }

     

       737
       +
       

     

       738
       +
       #[jacquard_derive::lexicon]

     

       739
       +
       #[derive(

     

       740
       +
           serde::Serialize,

     

       741
       +
           serde::Deserialize,

     

       742
       +
           Debug,

     

       743
       +
           Clone,

     

       744
       +
           PartialEq,

     

       745
       +
           Eq,

     

       746
       +
           jacquard_derive::IntoStatic

     

       747
       +
       )]

     

       748
       +
       #[serde(rename_all = "camelCase")]

     

       749
       +
       pub struct File<'a> {

     

       750
       +
           /// True if blob content is base64-encoded (used to bypass PDS content sniffing)

     

       751
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       752
       +
           pub base64: std::option::Option<bool>,

     

       753
       +
           /// Content blob ref

     

       754
       +
           #[serde(borrow)]

     

       755
       +
           pub blob: jacquard_common::types::blob::BlobRef<'a>,

     

       756
       +
           /// Content encoding (e.g., gzip for compressed files)

     

       757
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       758
       +
           #[serde(borrow)]

     

       759
       +
           pub encoding: std::option::Option<jacquard_common::CowStr<'a>>,

     

       760
       +
           /// Original MIME type before compression

     

       761
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       762
       +
           #[serde(borrow)]

     

       763
       +
           pub mime_type: std::option::Option<jacquard_common::CowStr<'a>>,

     

       764
       +
           #[serde(borrow)]

     

       765
       +
           pub r#type: jacquard_common::CowStr<'a>,

     

       766
       +
       }

     

       767
       +
       

     

       768
       +
       pub mod file_state {

     

       769
       +
       

     

       770
       +
           pub use crate::builder_types::{Set, Unset, IsSet, IsUnset};

     

       771
       +
           #[allow(unused)]

     

       772
       +
           use ::core::marker::PhantomData;

     

       773
       +
           mod sealed {

     

       774
       +
               pub trait Sealed {}

     

       775
       +
           }

     

       776
       +
           /// State trait tracking which required fields have been set

     

       777
       +
           pub trait State: sealed::Sealed {

     

       778
       +
               type Type;

     

       779
       +
               type Blob;

     

       780
       +
           }

     

       781
       +
           /// Empty state - all required fields are unset

     

       782
       +
           pub struct Empty(());

     

       783
       +
           impl sealed::Sealed for Empty {}

     

       784
       +
           impl State for Empty {

     

       785
       +
               type Type = Unset;

     

       786
       +
               type Blob = Unset;

     

       787
       +
           }

     

       788
       +
           ///State transition - sets the `type` field to Set

     

       789
       +
           pub struct SetType<S: State = Empty>(PhantomData<fn() -> S>);

     

       790
       +
           impl<S: State> sealed::Sealed for SetType<S> {}

     

       791
       +
           impl<S: State> State for SetType<S> {

     

       792
       +
               type Type = Set<members::r#type>;

     

       793
       +
               type Blob = S::Blob;

     

       794
       +
           }

     

       795
       +
           ///State transition - sets the `blob` field to Set

     

       796
       +
           pub struct SetBlob<S: State = Empty>(PhantomData<fn() -> S>);

     

       797
       +
           impl<S: State> sealed::Sealed for SetBlob<S> {}

     

       798
       +
           impl<S: State> State for SetBlob<S> {

     

       799
       +
               type Type = S::Type;

     

       800
       +
               type Blob = Set<members::blob>;

     

       801
       +
           }

     

       802
       +
           /// Marker types for field names

     

       803
       +
           #[allow(non_camel_case_types)]

     

       804
       +
           pub mod members {

     

       805
       +
               ///Marker type for the `type` field

     

       806
       +
               pub struct r#type(());

     

       807
       +
               ///Marker type for the `blob` field

     

       808
       +
               pub struct blob(());

     

       809
       +
           }

     

       810
       +
       }

     

       811
       +
       

     

       812
       +
       /// Builder for constructing an instance of this type

     

       813
       +
       pub struct FileBuilder<'a, S: file_state::State> {

     

       814
       +
           _phantom_state: ::core::marker::PhantomData<fn() -> S>,

     

       815
       +
           __unsafe_private_named: (

     

       816
       +
               ::core::option::Option<bool>,

     

       817
       +
               ::core::option::Option<jacquard_common::types::blob::BlobRef<'a>>,

     

       818
       +
               ::core::option::Option<jacquard_common::CowStr<'a>>,

     

       819
       +
               ::core::option::Option<jacquard_common::CowStr<'a>>,

     

       820
       +
               ::core::option::Option<jacquard_common::CowStr<'a>>,

     

       821
       +
           ),

     

       822
       +
           _phantom: ::core::marker::PhantomData<&'a ()>,

     

       823
       +
       }

     

       824
       +
       

     

       825
       +
       impl<'a> File<'a> {

     

       826
       +
           /// Create a new builder for this type

     

       827
       +
           pub fn new() -> FileBuilder<'a, file_state::Empty> {

     

       828
       +
               FileBuilder::new()

     

       829
       +
           }

     

       830
       +
       }

     

       831
       +
       

     

       832
       +
       impl<'a> FileBuilder<'a, file_state::Empty> {

     

       833
       +
           /// Create a new builder with all fields unset

     

       834
       +
           pub fn new() -> Self {

     

       835
       +
               FileBuilder {

     

       836
       +
                   _phantom_state: ::core::marker::PhantomData,

     

       837
       +
                   __unsafe_private_named: (None, None, None, None, None),

     

       838
       +
                   _phantom: ::core::marker::PhantomData,

     

       839
       +
               }

     

       840
       +
           }

     

       841
       +
       }

     

       842
       +
       

     

       843
       +
       impl<'a, S: file_state::State> FileBuilder<'a, S> {

     

       844
       +
           /// Set the `base64` field (optional)

     

       845
       +
           pub fn base64(mut self, value: impl Into<Option<bool>>) -> Self {

     

       846
       +
               self.__unsafe_private_named.0 = value.into();

     

       847
       +
               self

     

       848
       +
           }

     

       849
       +
           /// Set the `base64` field to an Option value (optional)

     

       850
       +
           pub fn maybe_base64(mut self, value: Option<bool>) -> Self {

     

       851
       +
               self.__unsafe_private_named.0 = value;

     

       852
       +
               self

     

       853
       +
           }

     

       854
       +
       }

     

       855
       +
       

     

       856
       +
       impl<'a, S> FileBuilder<'a, S>

     

       857
       +
       where

     

       858
       +
           S: file_state::State,

     

       859
       +
           S::Blob: file_state::IsUnset,

     

       860
       +
       {

     

       861
       +
           /// Set the `blob` field (required)

     

       862
       +
           pub fn blob(

     

       863
       +
               mut self,

     

       864
       +
               value: impl Into<jacquard_common::types::blob::BlobRef<'a>>,

     

       865
       +
           ) -> FileBuilder<'a, file_state::SetBlob<S>> {

     

       866
       +
               self.__unsafe_private_named.1 = ::core::option::Option::Some(value.into());

     

       867
       +
               FileBuilder {

     

       868
       +
                   _phantom_state: ::core::marker::PhantomData,

     

       869
       +
                   __unsafe_private_named: self.__unsafe_private_named,

     

       870
       +
                   _phantom: ::core::marker::PhantomData,

     

       871
       +
               }

     

       872
       +
           }

     

       873
       +
       }

     

       874
       +
       

     

       875
       +
       impl<'a, S: file_state::State> FileBuilder<'a, S> {

     

       876
       +
           /// Set the `encoding` field (optional)

     

       877
       +
           pub fn encoding(

     

       878
       +
               mut self,

     

       879
       +
               value: impl Into<Option<jacquard_common::CowStr<'a>>>,

     

       880
       +
           ) -> Self {

     

       881
       +
               self.__unsafe_private_named.2 = value.into();

     

       882
       +
               self

     

       883
       +
           }

     

       884
       +
           /// Set the `encoding` field to an Option value (optional)

     

       885
       +
           pub fn maybe_encoding(mut self, value: Option<jacquard_common::CowStr<'a>>) -> Self {

     

       886
       +
               self.__unsafe_private_named.2 = value;

     

       887
       +
               self

     

       888
       +
           }

     

       889
       +
       }

     

       890
       +
       

     

       891
       +
       impl<'a, S: file_state::State> FileBuilder<'a, S> {

     

       892
       +
           /// Set the `mimeType` field (optional)

     

       893
       +
           pub fn mime_type(

     

       894
       +
               mut self,

     

       895
       +
               value: impl Into<Option<jacquard_common::CowStr<'a>>>,

     

       896
       +
           ) -> Self {

     

       897
       +
               self.__unsafe_private_named.3 = value.into();

     

       898
       +
               self

     

       899
       +
           }

     

       900
       +
           /// Set the `mimeType` field to an Option value (optional)

     

       901
       +
           pub fn maybe_mime_type(

     

       902
       +
               mut self,

     

       903
       +
               value: Option<jacquard_common::CowStr<'a>>,

     

       904
       +
           ) -> Self {

     

       905
       +
               self.__unsafe_private_named.3 = value;

     

       906
       +
               self

     

       907
       +
           }

     

       908
       +
       }

     

       909
       +
       

     

       910
       +
       impl<'a, S> FileBuilder<'a, S>

     

       911
       +
       where

     

       912
       +
           S: file_state::State,

     

       913
       +
           S::Type: file_state::IsUnset,

     

       914
       +
       {

     

       915
       +
           /// Set the `type` field (required)

     

       916
       +
           pub fn r#type(

     

       917
       +
               mut self,

     

       918
       +
               value: impl Into<jacquard_common::CowStr<'a>>,

     

       919
       +
           ) -> FileBuilder<'a, file_state::SetType<S>> {

     

       920
       +
               self.__unsafe_private_named.4 = ::core::option::Option::Some(value.into());

     

       921
       +
               FileBuilder {

     

       922
       +
                   _phantom_state: ::core::marker::PhantomData,

     

       923
       +
                   __unsafe_private_named: self.__unsafe_private_named,

     

       924
       +
                   _phantom: ::core::marker::PhantomData,

     

       925
       +
               }

     

       926
       +
           }

     

       927
       +
       }

     

       928
       +
       

     

       929
       +
       impl<'a, S> FileBuilder<'a, S>

     

       930
       +
       where

     

       931
       +
           S: file_state::State,

     

       932
       +
           S::Type: file_state::IsSet,

     

       933
       +
           S::Blob: file_state::IsSet,

     

       934
       +
       {

     

       935
       +
           /// Build the final struct

     

       936
       +
           pub fn build(self) -> File<'a> {

     

       937
       +
               File {

     

       938
       +
                   base64: self.__unsafe_private_named.0,

     

       939
       +
                   blob: self.__unsafe_private_named.1.unwrap(),

     

       940
       +
                   encoding: self.__unsafe_private_named.2,

     

       941
       +
                   mime_type: self.__unsafe_private_named.3,

     

       942
       +
                   r#type: self.__unsafe_private_named.4.unwrap(),

     

       943
       +
                   extra_data: Default::default(),

     

       944
       +
               }

     

       945
       +
           }

     

       946
       +
           /// Build the final struct with custom extra_data

     

       947
       +
           pub fn build_with_data(

     

       948
       +
               self,

     

       949
       +
               extra_data: std::collections::BTreeMap<

     

       950
       +
                   jacquard_common::smol_str::SmolStr,

     

       951
       +
                   jacquard_common::types::value::Data<'a>,

     

       952
       +
               >,

     

       953
       +
           ) -> File<'a> {

     

       954
       +
               File {

     

       955
       +
                   base64: self.__unsafe_private_named.0,

     

       956
       +
                   blob: self.__unsafe_private_named.1.unwrap(),

     

       957
       +
                   encoding: self.__unsafe_private_named.2,

     

       958
       +
                   mime_type: self.__unsafe_private_named.3,

     

       959
       +
                   r#type: self.__unsafe_private_named.4.unwrap(),

     

       960
       +
                   extra_data: Some(extra_data),

     

       961
       +
               }

     

       962
       +
           }

     

       963
       +
       }

     

       964
       +
       

     

       965
       +
       impl<'a> ::jacquard_lexicon::schema::LexiconSchema for File<'a> {

     

       966
       +
           fn nsid() -> &'static str {

     

       967
       +
               "place.wisp.fs"

     

       968
       +
           }

     

       969
       +
           fn def_name() -> &'static str {

     

       970
       +
               "file"

     

       971
       +
           }

     

       972
       +
           fn lexicon_doc() -> ::jacquard_lexicon::lexicon::LexiconDoc<'static> {

     

       973
       +
               lexicon_doc_place_wisp_fs()

     

       974
       +
           }

     

       975
       +
           fn validate(

     

       976
       +
               &self,

     

       977
       +
           ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> {

     

       978
       +
               Ok(())

     

       979
       +
           }

     

       980
       +
       }

     

       981
       +
       

     

       982
       +
       /// Virtual filesystem manifest for a Wisp site

     

       983
       +
       #[jacquard_derive::lexicon]

     

       984
       +
       #[derive(

     

       985
       +
           serde::Serialize,

     

       986
       +
           serde::Deserialize,

     

       987
       +
           Debug,

     

       988
       +
           Clone,

     

       989
       +
           PartialEq,

     

       990
       +
           Eq,

     

       991
       +
           jacquard_derive::IntoStatic

     

       992
       +
       )]

     

       993
       +
       #[serde(rename_all = "camelCase")]

     

       994
       +
       pub struct Fs<'a> {

     

       995
       +
           pub created_at: jacquard_common::types::string::Datetime,

     

       996
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       997
       +
           pub file_count: std::option::Option<i64>,

     

       998
       +
           #[serde(borrow)]

     

       999
       +
           pub root: crate::place_wisp::fs::Directory<'a>,

     

       1000
       +
           #[serde(borrow)]

     

       1001
       +
           pub site: jacquard_common::CowStr<'a>,

     

       1002
       +
       }

     

       1003
       +
       

     

       1004
       +
       pub mod fs_state {

     

       1005
       +
       

     

       1006
       +
           pub use crate::builder_types::{Set, Unset, IsSet, IsUnset};

     

       1007
       +
           #[allow(unused)]

     

       1008
       +
           use ::core::marker::PhantomData;

     

       1009
       +
           mod sealed {

     

       1010
       +
               pub trait Sealed {}

     

       1011
       +
           }

     

       1012
       +
           /// State trait tracking which required fields have been set

     

       1013
       +
           pub trait State: sealed::Sealed {

     

       1014
       +
               type CreatedAt;

     

       1015
       +
               type Site;

     

       1016
       +
               type Root;

     

       1017
       +
           }

     

       1018
       +
           /// Empty state - all required fields are unset

     

       1019
       +
           pub struct Empty(());

     

       1020
       +
           impl sealed::Sealed for Empty {}

     

       1021
       +
           impl State for Empty {

     

       1022
       +
               type CreatedAt = Unset;

     

       1023
       +
               type Site = Unset;

     

       1024
       +
               type Root = Unset;

     

       1025
       +
           }

     

       1026
       +
           ///State transition - sets the `created_at` field to Set

     

       1027
       +
           pub struct SetCreatedAt<S: State = Empty>(PhantomData<fn() -> S>);

     

       1028
       +
           impl<S: State> sealed::Sealed for SetCreatedAt<S> {}

     

       1029
       +
           impl<S: State> State for SetCreatedAt<S> {

     

       1030
       +
               type CreatedAt = Set<members::created_at>;

     

       1031
       +
               type Site = S::Site;

     

       1032
       +
               type Root = S::Root;

     

       1033
       +
           }

     

       1034
       +
           ///State transition - sets the `site` field to Set

     

       1035
       +
           pub struct SetSite<S: State = Empty>(PhantomData<fn() -> S>);

     

       1036
       +
           impl<S: State> sealed::Sealed for SetSite<S> {}

     

       1037
       +
           impl<S: State> State for SetSite<S> {

     

       1038
       +
               type CreatedAt = S::CreatedAt;

     

       1039
       +
               type Site = Set<members::site>;

     

       1040
       +
               type Root = S::Root;

     

       1041
       +
           }

     

       1042
       +
           ///State transition - sets the `root` field to Set

     

       1043
       +
           pub struct SetRoot<S: State = Empty>(PhantomData<fn() -> S>);

     

       1044
       +
           impl<S: State> sealed::Sealed for SetRoot<S> {}

     

       1045
       +
           impl<S: State> State for SetRoot<S> {

     

       1046
       +
               type CreatedAt = S::CreatedAt;

     

       1047
       +
               type Site = S::Site;

     

       1048
       +
               type Root = Set<members::root>;

     

       1049
       +
           }

     

       1050
       +
           /// Marker types for field names

     

       1051
       +
           #[allow(non_camel_case_types)]

     

       1052
       +
           pub mod members {

     

       1053
       +
               ///Marker type for the `created_at` field

     

       1054
       +
               pub struct created_at(());

     

       1055
       +
               ///Marker type for the `site` field

     

       1056
       +
               pub struct site(());

     

       1057
       +
               ///Marker type for the `root` field

     

       1058
       +
               pub struct root(());

     

       1059
       +
           }

     

       1060
       +
       }

     

       1061
       +
       

     

       1062
       +
       /// Builder for constructing an instance of this type

     

       1063
       +
       pub struct FsBuilder<'a, S: fs_state::State> {

     

       1064
       +
           _phantom_state: ::core::marker::PhantomData<fn() -> S>,

     

       1065
       +
           __unsafe_private_named: (

     

       1066
       +
               ::core::option::Option<jacquard_common::types::string::Datetime>,

     

       1067
       +
               ::core::option::Option<i64>,

     

       1068
       +
               ::core::option::Option<crate::place_wisp::fs::Directory<'a>>,

     

       1069
       +
               ::core::option::Option<jacquard_common::CowStr<'a>>,

     

       1070
       +
           ),

     

       1071
       +
           _phantom: ::core::marker::PhantomData<&'a ()>,

     

       1072
       +
       }

     

       1073
       +
       

     

       1074
       +
       impl<'a> Fs<'a> {

     

       1075
       +
           /// Create a new builder for this type

     

       1076
       +
           pub fn new() -> FsBuilder<'a, fs_state::Empty> {

     

       1077
       +
               FsBuilder::new()

     

       1078
       +
           }

     

       1079
       +
       }

     

       1080
       +
       

     

       1081
       +
       impl<'a> FsBuilder<'a, fs_state::Empty> {

     

       1082
       +
           /// Create a new builder with all fields unset

     

       1083
       +
           pub fn new() -> Self {

     

       1084
       +
               FsBuilder {

     

       1085
       +
                   _phantom_state: ::core::marker::PhantomData,

     

       1086
       +
                   __unsafe_private_named: (None, None, None, None),

     

       1087
       +
                   _phantom: ::core::marker::PhantomData,

     

       1088
       +
               }

     

       1089
       +
           }

     

       1090
       +
       }

     

       1091
       +
       

     

       1092
       +
       impl<'a, S> FsBuilder<'a, S>

     

       1093
       +
       where

     

       1094
       +
           S: fs_state::State,

     

       1095
       +
           S::CreatedAt: fs_state::IsUnset,

     

       1096
       +
       {

     

       1097
       +
           /// Set the `createdAt` field (required)

     

       1098
       +
           pub fn created_at(

     

       1099
       +
               mut self,

     

       1100
       +
               value: impl Into<jacquard_common::types::string::Datetime>,

     

       1101
       +
           ) -> FsBuilder<'a, fs_state::SetCreatedAt<S>> {

     

       1102
       +
               self.__unsafe_private_named.0 = ::core::option::Option::Some(value.into());

     

       1103
       +
               FsBuilder {

     

       1104
       +
                   _phantom_state: ::core::marker::PhantomData,

     

       1105
       +
                   __unsafe_private_named: self.__unsafe_private_named,

     

       1106
       +
                   _phantom: ::core::marker::PhantomData,

     

       1107
       +
               }

     

       1108
       +
           }

     

       1109
       +
       }

     

       1110
       +
       

     

       1111
       +
       impl<'a, S: fs_state::State> FsBuilder<'a, S> {

     

       1112
       +
           /// Set the `fileCount` field (optional)

     

       1113
       +
           pub fn file_count(mut self, value: impl Into<Option<i64>>) -> Self {

     

       1114
       +
               self.__unsafe_private_named.1 = value.into();

     

       1115
       +
               self

     

       1116
       +
           }

     

       1117
       +
           /// Set the `fileCount` field to an Option value (optional)

     

       1118
       +
           pub fn maybe_file_count(mut self, value: Option<i64>) -> Self {

     

       1119
       +
               self.__unsafe_private_named.1 = value;

     

       1120
       +
               self

     

       1121
       +
           }

     

       1122
       +
       }

     

       1123
       +
       

     

       1124
       +
       impl<'a, S> FsBuilder<'a, S>

     

       1125
       +
       where

     

       1126
       +
           S: fs_state::State,

     

       1127
       +
           S::Root: fs_state::IsUnset,

     

       1128
       +
       {

     

       1129
       +
           /// Set the `root` field (required)

     

       1130
       +
           pub fn root(

     

       1131
       +
               mut self,

     

       1132
       +
               value: impl Into<crate::place_wisp::fs::Directory<'a>>,

     

       1133
       +
           ) -> FsBuilder<'a, fs_state::SetRoot<S>> {

     

       1134
       +
               self.__unsafe_private_named.2 = ::core::option::Option::Some(value.into());

     

       1135
       +
               FsBuilder {

     

       1136
       +
                   _phantom_state: ::core::marker::PhantomData,

     

       1137
       +
                   __unsafe_private_named: self.__unsafe_private_named,

     

       1138
       +
                   _phantom: ::core::marker::PhantomData,

     

       1139
       +
               }

     

       1140
       +
           }

     

       1141
       +
       }

     

       1142
       +
       

     

       1143
       +
       impl<'a, S> FsBuilder<'a, S>

     

       1144
       +
       where

     

       1145
       +
           S: fs_state::State,

     

       1146
       +
           S::Site: fs_state::IsUnset,

     

       1147
       +
       {

     

       1148
       +
           /// Set the `site` field (required)

     

       1149
       +
           pub fn site(

     

       1150
       +
               mut self,

     

       1151
       +
               value: impl Into<jacquard_common::CowStr<'a>>,

     

       1152
       +
           ) -> FsBuilder<'a, fs_state::SetSite<S>> {

     

       1153
       +
               self.__unsafe_private_named.3 = ::core::option::Option::Some(value.into());

     

       1154
       +
               FsBuilder {

     

       1155
       +
                   _phantom_state: ::core::marker::PhantomData,

     

       1156
       +
                   __unsafe_private_named: self.__unsafe_private_named,

     

       1157
       +
                   _phantom: ::core::marker::PhantomData,

     

       1158
       +
               }

     

       1159
       +
           }

     

       1160
       +
       }

     

       1161
       +
       

     

       1162
       +
       impl<'a, S> FsBuilder<'a, S>

     

       1163
       +
       where

     

       1164
       +
           S: fs_state::State,

     

       1165
       +
           S::CreatedAt: fs_state::IsSet,

     

       1166
       +
           S::Site: fs_state::IsSet,

     

       1167
       +
           S::Root: fs_state::IsSet,

     

       1168
       +
       {

     

       1169
       +
           /// Build the final struct

     

       1170
       +
           pub fn build(self) -> Fs<'a> {

     

       1171
       +
               Fs {

     

       1172
       +
                   created_at: self.__unsafe_private_named.0.unwrap(),

     

       1173
       +
                   file_count: self.__unsafe_private_named.1,

     

       1174
       +
                   root: self.__unsafe_private_named.2.unwrap(),

     

       1175
       +
                   site: self.__unsafe_private_named.3.unwrap(),

     

       1176
       +
                   extra_data: Default::default(),

     

       1177
       +
               }

     

       1178
       +
           }

     

       1179
       +
           /// Build the final struct with custom extra_data

     

       1180
       +
           pub fn build_with_data(

     

       1181
       +
               self,

     

       1182
       +
               extra_data: std::collections::BTreeMap<

     

       1183
       +
                   jacquard_common::smol_str::SmolStr,

     

       1184
       +
                   jacquard_common::types::value::Data<'a>,

     

       1185
       +
               >,

     

       1186
       +
           ) -> Fs<'a> {

     

       1187
       +
               Fs {

     

       1188
       +
                   created_at: self.__unsafe_private_named.0.unwrap(),

     

       1189
       +
                   file_count: self.__unsafe_private_named.1,

     

       1190
       +
                   root: self.__unsafe_private_named.2.unwrap(),

     

       1191
       +
                   site: self.__unsafe_private_named.3.unwrap(),

     

       1192
       +
                   extra_data: Some(extra_data),

     

       1193
       +
               }

     

       1194
       +
           }

     

       1195
       +
       }

     

       1196
       +
       

     

       1197
       +
       impl<'a> Fs<'a> {

     

       1198
       +
           pub fn uri(

     

       1199
       +
               uri: impl Into<jacquard_common::CowStr<'a>>,

     

       1200
       +
           ) -> Result<

     

       1201
       +
               jacquard_common::types::uri::RecordUri<'a, FsRecord>,

     

       1202
       +
               jacquard_common::types::uri::UriError,

     

       1203
       +
           > {

     

       1204
       +
               jacquard_common::types::uri::RecordUri::try_from_uri(

     

       1205
       +
                   jacquard_common::types::string::AtUri::new_cow(uri.into())?,

     

       1206
       +
               )

     

       1207
       +
           }

     

       1208
       +
       }

     

       1209
       +
       

     

       1210
       +
       /// Typed wrapper for GetRecord response with this collection's record type.

     

       1211
       +
       #[derive(

     

       1212
       +
           serde::Serialize,

     

       1213
       +
           serde::Deserialize,

     

       1214
       +
           Debug,

     

       1215
       +
           Clone,

     

       1216
       +
           PartialEq,

     

       1217
       +
           Eq,

     

       1218
       +
           jacquard_derive::IntoStatic

     

       1219
       +
       )]

     

       1220
       +
       #[serde(rename_all = "camelCase")]

     

       1221
       +
       pub struct FsGetRecordOutput<'a> {

     

       1222
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       1223
       +
           #[serde(borrow)]

     

       1224
       +
           pub cid: std::option::Option<jacquard_common::types::string::Cid<'a>>,

     

       1225
       +
           #[serde(borrow)]

     

       1226
       +
           pub uri: jacquard_common::types::string::AtUri<'a>,

     

       1227
       +
           #[serde(borrow)]

     

       1228
       +
           pub value: Fs<'a>,

     

       1229
       +
       }

     

       1230
       +
       

     

       1231
       +
       impl From<FsGetRecordOutput<'_>> for Fs<'_> {

     

       1232
       +
           fn from(output: FsGetRecordOutput<'_>) -> Self {

     

       1233
       +
               use jacquard_common::IntoStatic;

     

       1234
       +
               output.value.into_static()

     

       1235
       +
           }

     

       1236
       +
       }

     

       1237
       +
       

     

       1238
       +
       impl jacquard_common::types::collection::Collection for Fs<'_> {

     

       1239
       +
           const NSID: &'static str = "place.wisp.fs";

     

       1240
       +
           type Record = FsRecord;

     

       1241
       +
       }

     

       1242
       +
       

     

       1243
       +
       /// Marker type for deserializing records from this collection.

     

       1244
       +
       #[derive(Debug, serde::Serialize, serde::Deserialize)]

     

       1245
       +
       pub struct FsRecord;

     

       1246
       +
       impl jacquard_common::xrpc::XrpcResp for FsRecord {

     

       1247
       +
           const NSID: &'static str = "place.wisp.fs";

     

       1248
       +
           const ENCODING: &'static str = "application/json";

     

       1249
       +
           type Output<'de> = FsGetRecordOutput<'de>;

     

       1250
       +
           type Err<'de> = jacquard_common::types::collection::RecordError<'de>;

     

       1251
       +
       }

     

       1252
       +
       

     

       1253
       +
       impl jacquard_common::types::collection::Collection for FsRecord {

     

       1254
       +
           const NSID: &'static str = "place.wisp.fs";

     

       1255
       +
           type Record = FsRecord;

     

       1256
       +
       }

     

       1257
       +
       

     

       1258
       +
       impl<'a> ::jacquard_lexicon::schema::LexiconSchema for Fs<'a> {

     

       1259
       +
           fn nsid() -> &'static str {

     

       1260
       +
               "place.wisp.fs"

     

       1261
       +
           }

     

       1262
       +
           fn def_name() -> &'static str {

     

       1263
       +
               "main"

     

       1264
       +
           }

     

       1265
       +
           fn lexicon_doc() -> ::jacquard_lexicon::lexicon::LexiconDoc<'static> {

     

       1266
       +
               lexicon_doc_place_wisp_fs()

     

       1267
       +
           }

     

       1268
       +
           fn validate(

     

       1269
       +
               &self,

     

       1270
       +
           ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> {

     

       1271
       +
               if let Some(ref value) = self.file_count {

     

       1272
       +
                   if *value > 1000i64 {

     

       1273
       +
                       return Err(::jacquard_lexicon::validation::ConstraintError::Maximum {

     

       1274
       +
                           path: ::jacquard_lexicon::validation::ValidationPath::from_field(

     

       1275
       +
                               "file_count",

     

       1276
       +
                           ),

     

       1277
       +
                           max: 1000i64,

     

       1278
       +
                           actual: *value,

     

       1279
       +
                       });

     

       1280
       +
                   }

     

       1281
       +
               }

     

       1282
       +
               if let Some(ref value) = self.file_count {

     

       1283
       +
                   if *value < 0i64 {

     

       1284
       +
                       return Err(::jacquard_lexicon::validation::ConstraintError::Minimum {

     

       1285
       +
                           path: ::jacquard_lexicon::validation::ValidationPath::from_field(

     

       1286
       +
                               "file_count",

     

       1287
       +
                           ),

     

       1288
       +
                           min: 0i64,

     

       1289
       +
                           actual: *value,

     

       1290
       +
                       });

     

       1291
       +
                   }

     

       1292
       +
               }

     

       1293
       +
               Ok(())

     

       1294
       +
           }

     

       1295
       +
       }

     

       1296
       +
       

     

       1297
       +
       #[jacquard_derive::lexicon]

     

       1298
       +
       #[derive(

     

       1299
       +
           serde::Serialize,

     

       1300
       +
           serde::Deserialize,

     

       1301
       +
           Debug,

     

       1302
       +
           Clone,

     

       1303
       +
           PartialEq,

     

       1304
       +
           Eq,

     

       1305
       +
           jacquard_derive::IntoStatic

     

       1306
       +
       )]

     

       1307
       +
       #[serde(rename_all = "camelCase")]

     

       1308
       +
       pub struct Subfs<'a> {

     

       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
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       1311
       +
           pub flat: std::option::Option<bool>,

     

       1312
       +
           /// AT-URI pointing to a place.wisp.subfs record containing this subtree.

     

       1313
       +
           #[serde(borrow)]

     

       1314
       +
           pub subject: jacquard_common::types::string::AtUri<'a>,

     

       1315
       +
           #[serde(borrow)]

     

       1316
       +
           pub r#type: jacquard_common::CowStr<'a>,

     

       1317
       +
       }

     

       1318
       +
       

     

       1319
       +
       pub mod subfs_state {

     

       1320
       +
       

     

       1321
       +
           pub use crate::builder_types::{Set, Unset, IsSet, IsUnset};

     

       1322
       +
           #[allow(unused)]

     

       1323
       +
           use ::core::marker::PhantomData;

     

       1324
       +
           mod sealed {

     

       1325
       +
               pub trait Sealed {}

     

       1326
       +
           }

     

       1327
       +
           /// State trait tracking which required fields have been set

     

       1328
       +
           pub trait State: sealed::Sealed {

     

       1329
       +
               type Type;

     

       1330
       +
               type Subject;

     

       1331
       +
           }

     

       1332
       +
           /// Empty state - all required fields are unset

     

       1333
       +
           pub struct Empty(());

     

       1334
       +
           impl sealed::Sealed for Empty {}

     

       1335
       +
           impl State for Empty {

     

       1336
       +
               type Type = Unset;

     

       1337
       +
               type Subject = Unset;

     

       1338
       +
           }

     

       1339
       +
           ///State transition - sets the `type` field to Set

     

       1340
       +
           pub struct SetType<S: State = Empty>(PhantomData<fn() -> S>);

     

       1341
       +
           impl<S: State> sealed::Sealed for SetType<S> {}

     

       1342
       +
           impl<S: State> State for SetType<S> {

     

       1343
       +
               type Type = Set<members::r#type>;

     

       1344
       +
               type Subject = S::Subject;

     

       1345
       +
           }

     

       1346
       +
           ///State transition - sets the `subject` field to Set

     

       1347
       +
           pub struct SetSubject<S: State = Empty>(PhantomData<fn() -> S>);

     

       1348
       +
           impl<S: State> sealed::Sealed for SetSubject<S> {}

     

       1349
       +
           impl<S: State> State for SetSubject<S> {

     

       1350
       +
               type Type = S::Type;

     

       1351
       +
               type Subject = Set<members::subject>;

     

       1352
       +
           }

     

       1353
       +
           /// Marker types for field names

     

       1354
       +
           #[allow(non_camel_case_types)]

     

       1355
       +
           pub mod members {

     

       1356
       +
               ///Marker type for the `type` field

     

       1357
       +
               pub struct r#type(());

     

       1358
       +
               ///Marker type for the `subject` field

     

       1359
       +
               pub struct subject(());

     

       1360
       +
           }

     

       1361
       +
       }

     

       1362
       +
       

     

       1363
       +
       /// Builder for constructing an instance of this type

     

       1364
       +
       pub struct SubfsBuilder<'a, S: subfs_state::State> {

     

       1365
       +
           _phantom_state: ::core::marker::PhantomData<fn() -> S>,

     

       1366
       +
           __unsafe_private_named: (

     

       1367
       +
               ::core::option::Option<bool>,

     

       1368
       +
               ::core::option::Option<jacquard_common::types::string::AtUri<'a>>,

     

       1369
       +
               ::core::option::Option<jacquard_common::CowStr<'a>>,

     

       1370
       +
           ),

     

       1371
       +
           _phantom: ::core::marker::PhantomData<&'a ()>,

     

       1372
       +
       }

     

       1373
       +
       

     

       1374
       +
       impl<'a> Subfs<'a> {

     

       1375
       +
           /// Create a new builder for this type

     

       1376
       +
           pub fn new() -> SubfsBuilder<'a, subfs_state::Empty> {

     

       1377
       +
               SubfsBuilder::new()

     

       1378
       +
           }

     

       1379
       +
       }

     

       1380
       +
       

     

       1381
       +
       impl<'a> SubfsBuilder<'a, subfs_state::Empty> {

     

       1382
       +
           /// Create a new builder with all fields unset

     

       1383
       +
           pub fn new() -> Self {

     

       1384
       +
               SubfsBuilder {

     

       1385
       +
                   _phantom_state: ::core::marker::PhantomData,

     

       1386
       +
                   __unsafe_private_named: (None, None, None),

     

       1387
       +
                   _phantom: ::core::marker::PhantomData,

     

       1388
       +
               }

     

       1389
       +
           }

     

       1390
       +
       }

     

       1391
       +
       

     

       1392
       +
       impl<'a, S: subfs_state::State> SubfsBuilder<'a, S> {

     

       1393
       +
           /// Set the `flat` field (optional)

     

       1394
       +
           pub fn flat(mut self, value: impl Into<Option<bool>>) -> Self {

     

       1395
       +
               self.__unsafe_private_named.0 = value.into();

     

       1396
       +
               self

     

       1397
       +
           }

     

       1398
       +
           /// Set the `flat` field to an Option value (optional)

     

       1399
       +
           pub fn maybe_flat(mut self, value: Option<bool>) -> Self {

     

       1400
       +
               self.__unsafe_private_named.0 = value;

     

       1401
       +
               self

     

       1402
       +
           }

     

       1403
       +
       }

     

       1404
       +
       

     

       1405
       +
       impl<'a, S> SubfsBuilder<'a, S>

     

       1406
       +
       where

     

       1407
       +
           S: subfs_state::State,

     

       1408
       +
           S::Subject: subfs_state::IsUnset,

     

       1409
       +
       {

     

       1410
       +
           /// Set the `subject` field (required)

     

       1411
       +
           pub fn subject(

     

       1412
       +
               mut self,

     

       1413
       +
               value: impl Into<jacquard_common::types::string::AtUri<'a>>,

     

       1414
       +
           ) -> SubfsBuilder<'a, subfs_state::SetSubject<S>> {

     

       1415
       +
               self.__unsafe_private_named.1 = ::core::option::Option::Some(value.into());

     

       1416
       +
               SubfsBuilder {

     

       1417
       +
                   _phantom_state: ::core::marker::PhantomData,

     

       1418
       +
                   __unsafe_private_named: self.__unsafe_private_named,

     

       1419
       +
                   _phantom: ::core::marker::PhantomData,

     

       1420
       +
               }

     

       1421
       +
           }

     

       1422
       +
       }

     

       1423
       +
       

     

       1424
       +
       impl<'a, S> SubfsBuilder<'a, S>

     

       1425
       +
       where

     

       1426
       +
           S: subfs_state::State,

     

       1427
       +
           S::Type: subfs_state::IsUnset,

     

       1428
       +
       {

     

       1429
       +
           /// Set the `type` field (required)

     

       1430
       +
           pub fn r#type(

     

       1431
       +
               mut self,

     

       1432
       +
               value: impl Into<jacquard_common::CowStr<'a>>,

     

       1433
       +
           ) -> SubfsBuilder<'a, subfs_state::SetType<S>> {

     

       1434
       +
               self.__unsafe_private_named.2 = ::core::option::Option::Some(value.into());

     

       1435
       +
               SubfsBuilder {

     

       1436
       +
                   _phantom_state: ::core::marker::PhantomData,

     

       1437
       +
                   __unsafe_private_named: self.__unsafe_private_named,

     

       1438
       +
                   _phantom: ::core::marker::PhantomData,

     

       1439
       +
               }

     

       1440
       +
           }

     

       1441
       +
       }

     

       1442
       +
       

     

       1443
       +
       impl<'a, S> SubfsBuilder<'a, S>

     

       1444
       +
       where

     

       1445
       +
           S: subfs_state::State,

     

       1446
       +
           S::Type: subfs_state::IsSet,

     

       1447
       +
           S::Subject: subfs_state::IsSet,

     

       1448
       +
       {

     

       1449
       +
           /// Build the final struct

     

       1450
       +
           pub fn build(self) -> Subfs<'a> {

     

       1451
       +
               Subfs {

     

       1452
       +
                   flat: self.__unsafe_private_named.0,

     

       1453
       +
                   subject: self.__unsafe_private_named.1.unwrap(),

     

       1454
       +
                   r#type: self.__unsafe_private_named.2.unwrap(),

     

       1455
       +
                   extra_data: Default::default(),

     

       1456
       +
               }

     

       1457
       +
           }

     

       1458
       +
           /// Build the final struct with custom extra_data

     

       1459
       +
           pub fn build_with_data(

     

       1460
       +
               self,

     

       1461
       +
               extra_data: std::collections::BTreeMap<

     

       1462
       +
                   jacquard_common::smol_str::SmolStr,

     

       1463
       +
                   jacquard_common::types::value::Data<'a>,

     

       1464
       +
               >,

     

       1465
       +
           ) -> Subfs<'a> {

     

       1466
       +
               Subfs {

     

       1467
       +
                   flat: self.__unsafe_private_named.0,

     

       1468
       +
                   subject: self.__unsafe_private_named.1.unwrap(),

     

       1469
       +
                   r#type: self.__unsafe_private_named.2.unwrap(),

     

       1470
       +
                   extra_data: Some(extra_data),

     

       1471
       +
               }

     

       1472
       +
           }

     

       1473
       +
       }

     

       1474
       +
       

     

       1475
       +
       impl<'a> ::jacquard_lexicon::schema::LexiconSchema for Subfs<'a> {

     

       1476
       +
           fn nsid() -> &'static str {

     

       1477
       +
               "place.wisp.fs"

     

       1478
       +
           }

     

       1479
       +
           fn def_name() -> &'static str {

     

       1480
       +
               "subfs"

     

       1481
       +
           }

     

       1482
       +
           fn lexicon_doc() -> ::jacquard_lexicon::lexicon::LexiconDoc<'static> {

     

       1483
       +
               lexicon_doc_place_wisp_fs()

     

       1484
       +
           }

     

       1485
       +
           fn validate(

     

       1486
       +
               &self,

     

       1487
       +
           ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> {

     

       1488
       +
               Ok(())

     

       1489
       +
           }

     

       1490
       +
       }

+653

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

···

       1
       +
       // @generated by jacquard-lexicon. DO NOT EDIT.

     

       2
       +
       //

     

       3
       +
       // Lexicon: place.wisp.settings

     

       4
       +
       //

     

       5
       +
       // This file was automatically generated from Lexicon schemas.

     

       6
       +
       // Any manual changes will be overwritten on the next regeneration.

     

       7
       +
       

     

       8
       +
       /// Custom HTTP header configuration

     

       9
       +
       #[jacquard_derive::lexicon]

     

       10
       +
       #[derive(

     

       11
       +
           serde::Serialize,

     

       12
       +
           serde::Deserialize,

     

       13
       +
           Debug,

     

       14
       +
           Clone,

     

       15
       +
           PartialEq,

     

       16
       +
           Eq,

     

       17
       +
           jacquard_derive::IntoStatic,

     

       18
       +
           Default

     

       19
       +
       )]

     

       20
       +
       #[serde(rename_all = "camelCase")]

     

       21
       +
       pub struct CustomHeader<'a> {

     

       22
       +
           /// HTTP header name (e.g., 'Cache-Control', 'X-Frame-Options')

     

       23
       +
           #[serde(borrow)]

     

       24
       +
           pub name: jacquard_common::CowStr<'a>,

     

       25
       +
           /// Optional glob pattern to apply this header to specific paths (e.g., '*.html', '/assets/*'). If not specified, applies to all paths.

     

       26
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       27
       +
           #[serde(borrow)]

     

       28
       +
           pub path: std::option::Option<jacquard_common::CowStr<'a>>,

     

       29
       +
           /// HTTP header value

     

       30
       +
           #[serde(borrow)]

     

       31
       +
           pub value: jacquard_common::CowStr<'a>,

     

       32
       +
       }

     

       33
       +
       

     

       34
       +
       fn lexicon_doc_place_wisp_settings() -> ::jacquard_lexicon::lexicon::LexiconDoc<

     

       35
       +
           'static,

     

       36
       +
       > {

     

       37
       +
           ::jacquard_lexicon::lexicon::LexiconDoc {

     

       38
       +
               lexicon: ::jacquard_lexicon::lexicon::Lexicon::Lexicon1,

     

       39
       +
               id: ::jacquard_common::CowStr::new_static("place.wisp.settings"),

     

       40
       +
               revision: None,

     

       41
       +
               description: None,

     

       42
       +
               defs: {

     

       43
       +
                   let mut map = ::std::collections::BTreeMap::new();

     

       44
       +
                   map.insert(

     

       45
       +
                       ::jacquard_common::smol_str::SmolStr::new_static("customHeader"),

     

       46
       +
                       ::jacquard_lexicon::lexicon::LexUserType::Object(::jacquard_lexicon::lexicon::LexObject {

     

       47
       +
                           description: Some(

     

       48
       +
                               ::jacquard_common::CowStr::new_static(

     

       49
       +
                                   "Custom HTTP header configuration",

     

       50
       +
                               ),

     

       51
       +
                           ),

     

       52
       +
                           required: Some(

     

       53
       +
                               vec![

     

       54
       +
                                   ::jacquard_common::smol_str::SmolStr::new_static("name"),

     

       55
       +
                                   ::jacquard_common::smol_str::SmolStr::new_static("value")

     

       56
       +
                               ],

     

       57
       +
                           ),

     

       58
       +
                           nullable: None,

     

       59
       +
                           properties: {

     

       60
       +
                               #[allow(unused_mut)]

     

       61
       +
                               let mut map = ::std::collections::BTreeMap::new();

     

       62
       +
                               map.insert(

     

       63
       +
                                   ::jacquard_common::smol_str::SmolStr::new_static("name"),

     

       64
       +
                                   ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {

     

       65
       +
                                       description: Some(

     

       66
       +
                                           ::jacquard_common::CowStr::new_static(

     

       67
       +
                                               "HTTP header name (e.g., 'Cache-Control', 'X-Frame-Options')",

     

       68
       +
                                           ),

     

       69
       +
                                       ),

     

       70
       +
                                       format: None,

     

       71
       +
                                       default: None,

     

       72
       +
                                       min_length: None,

     

       73
       +
                                       max_length: Some(100usize),

     

       74
       +
                                       min_graphemes: None,

     

       75
       +
                                       max_graphemes: None,

     

       76
       +
                                       r#enum: None,

     

       77
       +
                                       r#const: None,

     

       78
       +
                                       known_values: None,

     

       79
       +
                                   }),

     

       80
       +
                               );

     

       81
       +
                               map.insert(

     

       82
       +
                                   ::jacquard_common::smol_str::SmolStr::new_static("path"),

     

       83
       +
                                   ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {

     

       84
       +
                                       description: Some(

     

       85
       +
                                           ::jacquard_common::CowStr::new_static(

     

       86
       +
                                               "Optional glob pattern to apply this header to specific paths (e.g., '*.html', '/assets/*'). If not specified, applies to all paths.",

     

       87
       +
                                           ),

     

       88
       +
                                       ),

     

       89
       +
                                       format: None,

     

       90
       +
                                       default: None,

     

       91
       +
                                       min_length: None,

     

       92
       +
                                       max_length: Some(500usize),

     

       93
       +
                                       min_graphemes: None,

     

       94
       +
                                       max_graphemes: None,

     

       95
       +
                                       r#enum: None,

     

       96
       +
                                       r#const: None,

     

       97
       +
                                       known_values: None,

     

       98
       +
                                   }),

     

       99
       +
                               );

     

       100
       +
                               map.insert(

     

       101
       +
                                   ::jacquard_common::smol_str::SmolStr::new_static("value"),

     

       102
       +
                                   ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {

     

       103
       +
                                       description: Some(

     

       104
       +
                                           ::jacquard_common::CowStr::new_static("HTTP header value"),

     

       105
       +
                                       ),

     

       106
       +
                                       format: None,

     

       107
       +
                                       default: None,

     

       108
       +
                                       min_length: None,

     

       109
       +
                                       max_length: Some(1000usize),

     

       110
       +
                                       min_graphemes: None,

     

       111
       +
                                       max_graphemes: None,

     

       112
       +
                                       r#enum: None,

     

       113
       +
                                       r#const: None,

     

       114
       +
                                       known_values: None,

     

       115
       +
                                   }),

     

       116
       +
                               );

     

       117
       +
                               map

     

       118
       +
                           },

     

       119
       +
                       }),

     

       120
       +
                   );

     

       121
       +
                   map.insert(

     

       122
       +
                       ::jacquard_common::smol_str::SmolStr::new_static("main"),

     

       123
       +
                       ::jacquard_lexicon::lexicon::LexUserType::Record(::jacquard_lexicon::lexicon::LexRecord {

     

       124
       +
                           description: Some(

     

       125
       +
                               ::jacquard_common::CowStr::new_static(

     

       126
       +
                                   "Configuration settings for a static site hosted on wisp.place",

     

       127
       +
                               ),

     

       128
       +
                           ),

     

       129
       +
                           key: Some(::jacquard_common::CowStr::new_static("any")),

     

       130
       +
                           record: ::jacquard_lexicon::lexicon::LexRecordRecord::Object(::jacquard_lexicon::lexicon::LexObject {

     

       131
       +
                               description: None,

     

       132
       +
                               required: None,

     

       133
       +
                               nullable: None,

     

       134
       +
                               properties: {

     

       135
       +
                                   #[allow(unused_mut)]

     

       136
       +
                                   let mut map = ::std::collections::BTreeMap::new();

     

       137
       +
                                   map.insert(

     

       138
       +
                                       ::jacquard_common::smol_str::SmolStr::new_static(

     

       139
       +
                                           "cleanUrls",

     

       140
       +
                                       ),

     

       141
       +
                                       ::jacquard_lexicon::lexicon::LexObjectProperty::Boolean(::jacquard_lexicon::lexicon::LexBoolean {

     

       142
       +
                                           description: None,

     

       143
       +
                                           default: None,

     

       144
       +
                                           r#const: None,

     

       145
       +
                                       }),

     

       146
       +
                                   );

     

       147
       +
                                   map.insert(

     

       148
       +
                                       ::jacquard_common::smol_str::SmolStr::new_static(

     

       149
       +
                                           "custom404",

     

       150
       +
                                       ),

     

       151
       +
                                       ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {

     

       152
       +
                                           description: Some(

     

       153
       +
                                               ::jacquard_common::CowStr::new_static(

     

       154
       +
                                                   "Custom 404 error page file path. Incompatible with directoryListing and spaMode.",

     

       155
       +
                                               ),

     

       156
       +
                                           ),

     

       157
       +
                                           format: None,

     

       158
       +
                                           default: None,

     

       159
       +
                                           min_length: None,

     

       160
       +
                                           max_length: Some(500usize),

     

       161
       +
                                           min_graphemes: None,

     

       162
       +
                                           max_graphemes: None,

     

       163
       +
                                           r#enum: None,

     

       164
       +
                                           r#const: None,

     

       165
       +
                                           known_values: None,

     

       166
       +
                                       }),

     

       167
       +
                                   );

     

       168
       +
                                   map.insert(

     

       169
       +
                                       ::jacquard_common::smol_str::SmolStr::new_static(

     

       170
       +
                                           "directoryListing",

     

       171
       +
                                       ),

     

       172
       +
                                       ::jacquard_lexicon::lexicon::LexObjectProperty::Boolean(::jacquard_lexicon::lexicon::LexBoolean {

     

       173
       +
                                           description: None,

     

       174
       +
                                           default: None,

     

       175
       +
                                           r#const: None,

     

       176
       +
                                       }),

     

       177
       +
                                   );

     

       178
       +
                                   map.insert(

     

       179
       +
                                       ::jacquard_common::smol_str::SmolStr::new_static("headers"),

     

       180
       +
                                       ::jacquard_lexicon::lexicon::LexObjectProperty::Array(::jacquard_lexicon::lexicon::LexArray {

     

       181
       +
                                           description: Some(

     

       182
       +
                                               ::jacquard_common::CowStr::new_static(

     

       183
       +
                                                   "Custom HTTP headers to set on responses",

     

       184
       +
                                               ),

     

       185
       +
                                           ),

     

       186
       +
                                           items: ::jacquard_lexicon::lexicon::LexArrayItem::Ref(::jacquard_lexicon::lexicon::LexRef {

     

       187
       +
                                               description: None,

     

       188
       +
                                               r#ref: ::jacquard_common::CowStr::new_static(

     

       189
       +
                                                   "#customHeader",

     

       190
       +
                                               ),

     

       191
       +
                                           }),

     

       192
       +
                                           min_length: None,

     

       193
       +
                                           max_length: Some(50usize),

     

       194
       +
                                       }),

     

       195
       +
                                   );

     

       196
       +
                                   map.insert(

     

       197
       +
                                       ::jacquard_common::smol_str::SmolStr::new_static(

     

       198
       +
                                           "indexFiles",

     

       199
       +
                                       ),

     

       200
       +
                                       ::jacquard_lexicon::lexicon::LexObjectProperty::Array(::jacquard_lexicon::lexicon::LexArray {

     

       201
       +
                                           description: Some(

     

       202
       +
                                               ::jacquard_common::CowStr::new_static(

     

       203
       +
                                                   "Ordered list of files to try when serving a directory. Defaults to ['index.html'] if not specified.",

     

       204
       +
                                               ),

     

       205
       +
                                           ),

     

       206
       +
                                           items: ::jacquard_lexicon::lexicon::LexArrayItem::String(::jacquard_lexicon::lexicon::LexString {

     

       207
       +
                                               description: None,

     

       208
       +
                                               format: None,

     

       209
       +
                                               default: None,

     

       210
       +
                                               min_length: None,

     

       211
       +
                                               max_length: Some(255usize),

     

       212
       +
                                               min_graphemes: None,

     

       213
       +
                                               max_graphemes: None,

     

       214
       +
                                               r#enum: None,

     

       215
       +
                                               r#const: None,

     

       216
       +
                                               known_values: None,

     

       217
       +
                                           }),

     

       218
       +
                                           min_length: None,

     

       219
       +
                                           max_length: Some(10usize),

     

       220
       +
                                       }),

     

       221
       +
                                   );

     

       222
       +
                                   map.insert(

     

       223
       +
                                       ::jacquard_common::smol_str::SmolStr::new_static("spaMode"),

     

       224
       +
                                       ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {

     

       225
       +
                                           description: Some(

     

       226
       +
                                               ::jacquard_common::CowStr::new_static(

     

       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
       +
                                               ),

     

       229
       +
                                           ),

     

       230
       +
                                           format: None,

     

       231
       +
                                           default: None,

     

       232
       +
                                           min_length: None,

     

       233
       +
                                           max_length: Some(500usize),

     

       234
       +
                                           min_graphemes: None,

     

       235
       +
                                           max_graphemes: None,

     

       236
       +
                                           r#enum: None,

     

       237
       +
                                           r#const: None,

     

       238
       +
                                           known_values: None,

     

       239
       +
                                       }),

     

       240
       +
                                   );

     

       241
       +
                                   map

     

       242
       +
                               },

     

       243
       +
                           }),

     

       244
       +
                       }),

     

       245
       +
                   );

     

       246
       +
                   map

     

       247
       +
               },

     

       248
       +
           }

     

       249
       +
       }

     

       250
       +
       

     

       251
       +
       impl<'a> ::jacquard_lexicon::schema::LexiconSchema for CustomHeader<'a> {

     

       252
       +
           fn nsid() -> &'static str {

     

       253
       +
               "place.wisp.settings"

     

       254
       +
           }

     

       255
       +
           fn def_name() -> &'static str {

     

       256
       +
               "customHeader"

     

       257
       +
           }

     

       258
       +
           fn lexicon_doc() -> ::jacquard_lexicon::lexicon::LexiconDoc<'static> {

     

       259
       +
               lexicon_doc_place_wisp_settings()

     

       260
       +
           }

     

       261
       +
           fn validate(

     

       262
       +
               &self,

     

       263
       +
           ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> {

     

       264
       +
               {

     

       265
       +
                   let value = &self.name;

     

       266
       +
                   #[allow(unused_comparisons)]

     

       267
       +
                   if <str>::len(value.as_ref()) > 100usize {

     

       268
       +
                       return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength {

     

       269
       +
                           path: ::jacquard_lexicon::validation::ValidationPath::from_field(

     

       270
       +
                               "name",

     

       271
       +
                           ),

     

       272
       +
                           max: 100usize,

     

       273
       +
                           actual: <str>::len(value.as_ref()),

     

       274
       +
                       });

     

       275
       +
                   }

     

       276
       +
               }

     

       277
       +
               if let Some(ref value) = self.path {

     

       278
       +
                   #[allow(unused_comparisons)]

     

       279
       +
                   if <str>::len(value.as_ref()) > 500usize {

     

       280
       +
                       return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength {

     

       281
       +
                           path: ::jacquard_lexicon::validation::ValidationPath::from_field(

     

       282
       +
                               "path",

     

       283
       +
                           ),

     

       284
       +
                           max: 500usize,

     

       285
       +
                           actual: <str>::len(value.as_ref()),

     

       286
       +
                       });

     

       287
       +
                   }

     

       288
       +
               }

     

       289
       +
               {

     

       290
       +
                   let value = &self.value;

     

       291
       +
                   #[allow(unused_comparisons)]

     

       292
       +
                   if <str>::len(value.as_ref()) > 1000usize {

     

       293
       +
                       return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength {

     

       294
       +
                           path: ::jacquard_lexicon::validation::ValidationPath::from_field(

     

       295
       +
                               "value",

     

       296
       +
                           ),

     

       297
       +
                           max: 1000usize,

     

       298
       +
                           actual: <str>::len(value.as_ref()),

     

       299
       +
                       });

     

       300
       +
                   }

     

       301
       +
               }

     

       302
       +
               Ok(())

     

       303
       +
           }

     

       304
       +
       }

     

       305
       +
       

     

       306
       +
       /// Configuration settings for a static site hosted on wisp.place

     

       307
       +
       #[jacquard_derive::lexicon]

     

       308
       +
       #[derive(

     

       309
       +
           serde::Serialize,

     

       310
       +
           serde::Deserialize,

     

       311
       +
           Debug,

     

       312
       +
           Clone,

     

       313
       +
           PartialEq,

     

       314
       +
           Eq,

     

       315
       +
           jacquard_derive::IntoStatic

     

       316
       +
       )]

     

       317
       +
       #[serde(rename_all = "camelCase")]

     

       318
       +
       pub struct Settings<'a> {

     

       319
       +
           /// Enable clean URL routing. When enabled, '/about' will attempt to serve '/about.html' or '/about/index.html' automatically.

     

       320
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       321
       +
           pub clean_urls: std::option::Option<bool>,

     

       322
       +
           /// Custom 404 error page file path. Incompatible with directoryListing and spaMode.

     

       323
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       324
       +
           #[serde(borrow)]

     

       325
       +
           pub custom404: std::option::Option<jacquard_common::CowStr<'a>>,

     

       326
       +
           /// Enable directory listing mode for paths that resolve to directories without an index file. Incompatible with spaMode.

     

       327
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       328
       +
           pub directory_listing: std::option::Option<bool>,

     

       329
       +
           /// Custom HTTP headers to set on responses

     

       330
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       331
       +
           #[serde(borrow)]

     

       332
       +
           pub headers: std::option::Option<Vec<crate::place_wisp::settings::CustomHeader<'a>>>,

     

       333
       +
           /// Ordered list of files to try when serving a directory. Defaults to ['index.html'] if not specified.

     

       334
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       335
       +
           #[serde(borrow)]

     

       336
       +
           pub index_files: std::option::Option<Vec<jacquard_common::CowStr<'a>>>,

     

       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
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       339
       +
           #[serde(borrow)]

     

       340
       +
           pub spa_mode: std::option::Option<jacquard_common::CowStr<'a>>,

     

       341
       +
       }

     

       342
       +
       

     

       343
       +
       pub mod settings_state {

     

       344
       +
       

     

       345
       +
           pub use crate::builder_types::{Set, Unset, IsSet, IsUnset};

     

       346
       +
           #[allow(unused)]

     

       347
       +
           use ::core::marker::PhantomData;

     

       348
       +
           mod sealed {

     

       349
       +
               pub trait Sealed {}

     

       350
       +
           }

     

       351
       +
           /// State trait tracking which required fields have been set

     

       352
       +
           pub trait State: sealed::Sealed {}

     

       353
       +
           /// Empty state - all required fields are unset

     

       354
       +
           pub struct Empty(());

     

       355
       +
           impl sealed::Sealed for Empty {}

     

       356
       +
           impl State for Empty {}

     

       357
       +
           /// Marker types for field names

     

       358
       +
           #[allow(non_camel_case_types)]

     

       359
       +
           pub mod members {}

     

       360
       +
       }

     

       361
       +
       

     

       362
       +
       /// Builder for constructing an instance of this type

     

       363
       +
       pub struct SettingsBuilder<'a, S: settings_state::State> {

     

       364
       +
           _phantom_state: ::core::marker::PhantomData<fn() -> S>,

     

       365
       +
           __unsafe_private_named: (

     

       366
       +
               ::core::option::Option<bool>,

     

       367
       +
               ::core::option::Option<jacquard_common::CowStr<'a>>,

     

       368
       +
               ::core::option::Option<bool>,

     

       369
       +
               ::core::option::Option<Vec<crate::place_wisp::settings::CustomHeader<'a>>>,

     

       370
       +
               ::core::option::Option<Vec<jacquard_common::CowStr<'a>>>,

     

       371
       +
               ::core::option::Option<jacquard_common::CowStr<'a>>,

     

       372
       +
           ),

     

       373
       +
           _phantom: ::core::marker::PhantomData<&'a ()>,

     

       374
       +
       }

     

       375
       +
       

     

       376
       +
       impl<'a> Settings<'a> {

     

       377
       +
           /// Create a new builder for this type

     

       378
       +
           pub fn new() -> SettingsBuilder<'a, settings_state::Empty> {

     

       379
       +
               SettingsBuilder::new()

     

       380
       +
           }

     

       381
       +
       }

     

       382
       +
       

     

       383
       +
       impl<'a> SettingsBuilder<'a, settings_state::Empty> {

     

       384
       +
           /// Create a new builder with all fields unset

     

       385
       +
           pub fn new() -> Self {

     

       386
       +
               SettingsBuilder {

     

       387
       +
                   _phantom_state: ::core::marker::PhantomData,

     

       388
       +
                   __unsafe_private_named: (None, None, None, None, None, None),

     

       389
       +
                   _phantom: ::core::marker::PhantomData,

     

       390
       +
               }

     

       391
       +
           }

     

       392
       +
       }

     

       393
       +
       

     

       394
       +
       impl<'a, S: settings_state::State> SettingsBuilder<'a, S> {

     

       395
       +
           /// Set the `cleanUrls` field (optional)

     

       396
       +
           pub fn clean_urls(mut self, value: impl Into<Option<bool>>) -> Self {

     

       397
       +
               self.__unsafe_private_named.0 = value.into();

     

       398
       +
               self

     

       399
       +
           }

     

       400
       +
           /// Set the `cleanUrls` field to an Option value (optional)

     

       401
       +
           pub fn maybe_clean_urls(mut self, value: Option<bool>) -> Self {

     

       402
       +
               self.__unsafe_private_named.0 = value;

     

       403
       +
               self

     

       404
       +
           }

     

       405
       +
       }

     

       406
       +
       

     

       407
       +
       impl<'a, S: settings_state::State> SettingsBuilder<'a, S> {

     

       408
       +
           /// Set the `custom404` field (optional)

     

       409
       +
           pub fn custom404(

     

       410
       +
               mut self,

     

       411
       +
               value: impl Into<Option<jacquard_common::CowStr<'a>>>,

     

       412
       +
           ) -> Self {

     

       413
       +
               self.__unsafe_private_named.1 = value.into();

     

       414
       +
               self

     

       415
       +
           }

     

       416
       +
           /// Set the `custom404` field to an Option value (optional)

     

       417
       +
           pub fn maybe_custom404(

     

       418
       +
               mut self,

     

       419
       +
               value: Option<jacquard_common::CowStr<'a>>,

     

       420
       +
           ) -> Self {

     

       421
       +
               self.__unsafe_private_named.1 = value;

     

       422
       +
               self

     

       423
       +
           }

     

       424
       +
       }

     

       425
       +
       

     

       426
       +
       impl<'a, S: settings_state::State> SettingsBuilder<'a, S> {

     

       427
       +
           /// Set the `directoryListing` field (optional)

     

       428
       +
           pub fn directory_listing(mut self, value: impl Into<Option<bool>>) -> Self {

     

       429
       +
               self.__unsafe_private_named.2 = value.into();

     

       430
       +
               self

     

       431
       +
           }

     

       432
       +
           /// Set the `directoryListing` field to an Option value (optional)

     

       433
       +
           pub fn maybe_directory_listing(mut self, value: Option<bool>) -> Self {

     

       434
       +
               self.__unsafe_private_named.2 = value;

     

       435
       +
               self

     

       436
       +
           }

     

       437
       +
       }

     

       438
       +
       

     

       439
       +
       impl<'a, S: settings_state::State> SettingsBuilder<'a, S> {

     

       440
       +
           /// Set the `headers` field (optional)

     

       441
       +
           pub fn headers(

     

       442
       +
               mut self,

     

       443
       +
               value: impl Into<Option<Vec<crate::place_wisp::settings::CustomHeader<'a>>>>,

     

       444
       +
           ) -> Self {

     

       445
       +
               self.__unsafe_private_named.3 = value.into();

     

       446
       +
               self

     

       447
       +
           }

     

       448
       +
           /// Set the `headers` field to an Option value (optional)

     

       449
       +
           pub fn maybe_headers(

     

       450
       +
               mut self,

     

       451
       +
               value: Option<Vec<crate::place_wisp::settings::CustomHeader<'a>>>,

     

       452
       +
           ) -> Self {

     

       453
       +
               self.__unsafe_private_named.3 = value;

     

       454
       +
               self

     

       455
       +
           }

     

       456
       +
       }

     

       457
       +
       

     

       458
       +
       impl<'a, S: settings_state::State> SettingsBuilder<'a, S> {

     

       459
       +
           /// Set the `indexFiles` field (optional)

     

       460
       +
           pub fn index_files(

     

       461
       +
               mut self,

     

       462
       +
               value: impl Into<Option<Vec<jacquard_common::CowStr<'a>>>>,

     

       463
       +
           ) -> Self {

     

       464
       +
               self.__unsafe_private_named.4 = value.into();

     

       465
       +
               self

     

       466
       +
           }

     

       467
       +
           /// Set the `indexFiles` field to an Option value (optional)

     

       468
       +
           pub fn maybe_index_files(

     

       469
       +
               mut self,

     

       470
       +
               value: Option<Vec<jacquard_common::CowStr<'a>>>,

     

       471
       +
           ) -> Self {

     

       472
       +
               self.__unsafe_private_named.4 = value;

     

       473
       +
               self

     

       474
       +
           }

     

       475
       +
       }

     

       476
       +
       

     

       477
       +
       impl<'a, S: settings_state::State> SettingsBuilder<'a, S> {

     

       478
       +
           /// Set the `spaMode` field (optional)

     

       479
       +
           pub fn spa_mode(

     

       480
       +
               mut self,

     

       481
       +
               value: impl Into<Option<jacquard_common::CowStr<'a>>>,

     

       482
       +
           ) -> Self {

     

       483
       +
               self.__unsafe_private_named.5 = value.into();

     

       484
       +
               self

     

       485
       +
           }

     

       486
       +
           /// Set the `spaMode` field to an Option value (optional)

     

       487
       +
           pub fn maybe_spa_mode(mut self, value: Option<jacquard_common::CowStr<'a>>) -> Self {

     

       488
       +
               self.__unsafe_private_named.5 = value;

     

       489
       +
               self

     

       490
       +
           }

     

       491
       +
       }

     

       492
       +
       

     

       493
       +
       impl<'a, S> SettingsBuilder<'a, S>

     

       494
       +
       where

     

       495
       +
           S: settings_state::State,

     

       496
       +
       {

     

       497
       +
           /// Build the final struct

     

       498
       +
           pub fn build(self) -> Settings<'a> {

     

       499
       +
               Settings {

     

       500
       +
                   clean_urls: self.__unsafe_private_named.0,

     

       501
       +
                   custom404: self.__unsafe_private_named.1,

     

       502
       +
                   directory_listing: self.__unsafe_private_named.2,

     

       503
       +
                   headers: self.__unsafe_private_named.3,

     

       504
       +
                   index_files: self.__unsafe_private_named.4,

     

       505
       +
                   spa_mode: self.__unsafe_private_named.5,

     

       506
       +
                   extra_data: Default::default(),

     

       507
       +
               }

     

       508
       +
           }

     

       509
       +
           /// Build the final struct with custom extra_data

     

       510
       +
           pub fn build_with_data(

     

       511
       +
               self,

     

       512
       +
               extra_data: std::collections::BTreeMap<

     

       513
       +
                   jacquard_common::smol_str::SmolStr,

     

       514
       +
                   jacquard_common::types::value::Data<'a>,

     

       515
       +
               >,

     

       516
       +
           ) -> Settings<'a> {

     

       517
       +
               Settings {

     

       518
       +
                   clean_urls: self.__unsafe_private_named.0,

     

       519
       +
                   custom404: self.__unsafe_private_named.1,

     

       520
       +
                   directory_listing: self.__unsafe_private_named.2,

     

       521
       +
                   headers: self.__unsafe_private_named.3,

     

       522
       +
                   index_files: self.__unsafe_private_named.4,

     

       523
       +
                   spa_mode: self.__unsafe_private_named.5,

     

       524
       +
                   extra_data: Some(extra_data),

     

       525
       +
               }

     

       526
       +
           }

     

       527
       +
       }

     

       528
       +
       

     

       529
       +
       impl<'a> Settings<'a> {

     

       530
       +
           pub fn uri(

     

       531
       +
               uri: impl Into<jacquard_common::CowStr<'a>>,

     

       532
       +
           ) -> Result<

     

       533
       +
               jacquard_common::types::uri::RecordUri<'a, SettingsRecord>,

     

       534
       +
               jacquard_common::types::uri::UriError,

     

       535
       +
           > {

     

       536
       +
               jacquard_common::types::uri::RecordUri::try_from_uri(

     

       537
       +
                   jacquard_common::types::string::AtUri::new_cow(uri.into())?,

     

       538
       +
               )

     

       539
       +
           }

     

       540
       +
       }

     

       541
       +
       

     

       542
       +
       /// Typed wrapper for GetRecord response with this collection's record type.

     

       543
       +
       #[derive(

     

       544
       +
           serde::Serialize,

     

       545
       +
           serde::Deserialize,

     

       546
       +
           Debug,

     

       547
       +
           Clone,

     

       548
       +
           PartialEq,

     

       549
       +
           Eq,

     

       550
       +
           jacquard_derive::IntoStatic

     

       551
       +
       )]

     

       552
       +
       #[serde(rename_all = "camelCase")]

     

       553
       +
       pub struct SettingsGetRecordOutput<'a> {

     

       554
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       555
       +
           #[serde(borrow)]

     

       556
       +
           pub cid: std::option::Option<jacquard_common::types::string::Cid<'a>>,

     

       557
       +
           #[serde(borrow)]

     

       558
       +
           pub uri: jacquard_common::types::string::AtUri<'a>,

     

       559
       +
           #[serde(borrow)]

     

       560
       +
           pub value: Settings<'a>,

     

       561
       +
       }

     

       562
       +
       

     

       563
       +
       impl From<SettingsGetRecordOutput<'_>> for Settings<'_> {

     

       564
       +
           fn from(output: SettingsGetRecordOutput<'_>) -> Self {

     

       565
       +
               use jacquard_common::IntoStatic;

     

       566
       +
               output.value.into_static()

     

       567
       +
           }

     

       568
       +
       }

     

       569
       +
       

     

       570
       +
       impl jacquard_common::types::collection::Collection for Settings<'_> {

     

       571
       +
           const NSID: &'static str = "place.wisp.settings";

     

       572
       +
           type Record = SettingsRecord;

     

       573
       +
       }

     

       574
       +
       

     

       575
       +
       /// Marker type for deserializing records from this collection.

     

       576
       +
       #[derive(Debug, serde::Serialize, serde::Deserialize)]

     

       577
       +
       pub struct SettingsRecord;

     

       578
       +
       impl jacquard_common::xrpc::XrpcResp for SettingsRecord {

     

       579
       +
           const NSID: &'static str = "place.wisp.settings";

     

       580
       +
           const ENCODING: &'static str = "application/json";

     

       581
       +
           type Output<'de> = SettingsGetRecordOutput<'de>;

     

       582
       +
           type Err<'de> = jacquard_common::types::collection::RecordError<'de>;

     

       583
       +
       }

     

       584
       +
       

     

       585
       +
       impl jacquard_common::types::collection::Collection for SettingsRecord {

     

       586
       +
           const NSID: &'static str = "place.wisp.settings";

     

       587
       +
           type Record = SettingsRecord;

     

       588
       +
       }

     

       589
       +
       

     

       590
       +
       impl<'a> ::jacquard_lexicon::schema::LexiconSchema for Settings<'a> {

     

       591
       +
           fn nsid() -> &'static str {

     

       592
       +
               "place.wisp.settings"

     

       593
       +
           }

     

       594
       +
           fn def_name() -> &'static str {

     

       595
       +
               "main"

     

       596
       +
           }

     

       597
       +
           fn lexicon_doc() -> ::jacquard_lexicon::lexicon::LexiconDoc<'static> {

     

       598
       +
               lexicon_doc_place_wisp_settings()

     

       599
       +
           }

     

       600
       +
           fn validate(

     

       601
       +
               &self,

     

       602
       +
           ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> {

     

       603
       +
               if let Some(ref value) = self.custom404 {

     

       604
       +
                   #[allow(unused_comparisons)]

     

       605
       +
                   if <str>::len(value.as_ref()) > 500usize {

     

       606
       +
                       return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength {

     

       607
       +
                           path: ::jacquard_lexicon::validation::ValidationPath::from_field(

     

       608
       +
                               "custom404",

     

       609
       +
                           ),

     

       610
       +
                           max: 500usize,

     

       611
       +
                           actual: <str>::len(value.as_ref()),

     

       612
       +
                       });

     

       613
       +
                   }

     

       614
       +
               }

     

       615
       +
               if let Some(ref value) = self.headers {

     

       616
       +
                   #[allow(unused_comparisons)]

     

       617
       +
                   if value.len() > 50usize {

     

       618
       +
                       return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength {

     

       619
       +
                           path: ::jacquard_lexicon::validation::ValidationPath::from_field(

     

       620
       +
                               "headers",

     

       621
       +
                           ),

     

       622
       +
                           max: 50usize,

     

       623
       +
                           actual: value.len(),

     

       624
       +
                       });

     

       625
       +
                   }

     

       626
       +
               }

     

       627
       +
               if let Some(ref value) = self.index_files {

     

       628
       +
                   #[allow(unused_comparisons)]

     

       629
       +
                   if value.len() > 10usize {

     

       630
       +
                       return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength {

     

       631
       +
                           path: ::jacquard_lexicon::validation::ValidationPath::from_field(

     

       632
       +
                               "index_files",

     

       633
       +
                           ),

     

       634
       +
                           max: 10usize,

     

       635
       +
                           actual: value.len(),

     

       636
       +
                       });

     

       637
       +
                   }

     

       638
       +
               }

     

       639
       +
               if let Some(ref value) = self.spa_mode {

     

       640
       +
                   #[allow(unused_comparisons)]

     

       641
       +
                   if <str>::len(value.as_ref()) > 500usize {

     

       642
       +
                       return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength {

     

       643
       +
                           path: ::jacquard_lexicon::validation::ValidationPath::from_field(

     

       644
       +
                               "spa_mode",

     

       645
       +
                           ),

     

       646
       +
                           max: 500usize,

     

       647
       +
                           actual: <str>::len(value.as_ref()),

     

       648
       +
                       });

     

       649
       +
                   }

     

       650
       +
               }

     

       651
       +
               Ok(())

     

       652
       +
           }

     

       653
       +
       }

+1408

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

···

       1
       +
       // @generated by jacquard-lexicon. DO NOT EDIT.

     

       2
       +
       //

     

       3
       +
       // Lexicon: place.wisp.subfs

     

       4
       +
       //

     

       5
       +
       // This file was automatically generated from Lexicon schemas.

     

       6
       +
       // Any manual changes will be overwritten on the next regeneration.

     

       7
       +
       

     

       8
       +
       #[jacquard_derive::lexicon]

     

       9
       +
       #[derive(

     

       10
       +
           serde::Serialize,

     

       11
       +
           serde::Deserialize,

     

       12
       +
           Debug,

     

       13
       +
           Clone,

     

       14
       +
           PartialEq,

     

       15
       +
           Eq,

     

       16
       +
           jacquard_derive::IntoStatic

     

       17
       +
       )]

     

       18
       +
       #[serde(rename_all = "camelCase")]

     

       19
       +
       pub struct Directory<'a> {

     

       20
       +
           #[serde(borrow)]

     

       21
       +
           pub entries: Vec<crate::place_wisp::subfs::Entry<'a>>,

     

       22
       +
           #[serde(borrow)]

     

       23
       +
           pub r#type: jacquard_common::CowStr<'a>,

     

       24
       +
       }

     

       25
       +
       

     

       26
       +
       pub mod directory_state {

     

       27
       +
       

     

       28
       +
           pub use crate::builder_types::{Set, Unset, IsSet, IsUnset};

     

       29
       +
           #[allow(unused)]

     

       30
       +
           use ::core::marker::PhantomData;

     

       31
       +
           mod sealed {

     

       32
       +
               pub trait Sealed {}

     

       33
       +
           }

     

       34
       +
           /// State trait tracking which required fields have been set

     

       35
       +
           pub trait State: sealed::Sealed {

     

       36
       +
               type Type;

     

       37
       +
               type Entries;

     

       38
       +
           }

     

       39
       +
           /// Empty state - all required fields are unset

     

       40
       +
           pub struct Empty(());

     

       41
       +
           impl sealed::Sealed for Empty {}

     

       42
       +
           impl State for Empty {

     

       43
       +
               type Type = Unset;

     

       44
       +
               type Entries = Unset;

     

       45
       +
           }

     

       46
       +
           ///State transition - sets the `type` field to Set

     

       47
       +
           pub struct SetType<S: State = Empty>(PhantomData<fn() -> S>);

     

       48
       +
           impl<S: State> sealed::Sealed for SetType<S> {}

     

       49
       +
           impl<S: State> State for SetType<S> {

     

       50
       +
               type Type = Set<members::r#type>;

     

       51
       +
               type Entries = S::Entries;

     

       52
       +
           }

     

       53
       +
           ///State transition - sets the `entries` field to Set

     

       54
       +
           pub struct SetEntries<S: State = Empty>(PhantomData<fn() -> S>);

     

       55
       +
           impl<S: State> sealed::Sealed for SetEntries<S> {}

     

       56
       +
           impl<S: State> State for SetEntries<S> {

     

       57
       +
               type Type = S::Type;

     

       58
       +
               type Entries = Set<members::entries>;

     

       59
       +
           }

     

       60
       +
           /// Marker types for field names

     

       61
       +
           #[allow(non_camel_case_types)]

     

       62
       +
           pub mod members {

     

       63
       +
               ///Marker type for the `type` field

     

       64
       +
               pub struct r#type(());

     

       65
       +
               ///Marker type for the `entries` field

     

       66
       +
               pub struct entries(());

     

       67
       +
           }

     

       68
       +
       }

     

       69
       +
       

     

       70
       +
       /// Builder for constructing an instance of this type

     

       71
       +
       pub struct DirectoryBuilder<'a, S: directory_state::State> {

     

       72
       +
           _phantom_state: ::core::marker::PhantomData<fn() -> S>,

     

       73
       +
           __unsafe_private_named: (

     

       74
       +
               ::core::option::Option<Vec<crate::place_wisp::subfs::Entry<'a>>>,

     

       75
       +
               ::core::option::Option<jacquard_common::CowStr<'a>>,

     

       76
       +
           ),

     

       77
       +
           _phantom: ::core::marker::PhantomData<&'a ()>,

     

       78
       +
       }

     

       79
       +
       

     

       80
       +
       impl<'a> Directory<'a> {

     

       81
       +
           /// Create a new builder for this type

     

       82
       +
           pub fn new() -> DirectoryBuilder<'a, directory_state::Empty> {

     

       83
       +
               DirectoryBuilder::new()

     

       84
       +
           }

     

       85
       +
       }

     

       86
       +
       

     

       87
       +
       impl<'a> DirectoryBuilder<'a, directory_state::Empty> {

     

       88
       +
           /// Create a new builder with all fields unset

     

       89
       +
           pub fn new() -> Self {

     

       90
       +
               DirectoryBuilder {

     

       91
       +
                   _phantom_state: ::core::marker::PhantomData,

     

       92
       +
                   __unsafe_private_named: (None, None),

     

       93
       +
                   _phantom: ::core::marker::PhantomData,

     

       94
       +
               }

     

       95
       +
           }

     

       96
       +
       }

     

       97
       +
       

     

       98
       +
       impl<'a, S> DirectoryBuilder<'a, S>

     

       99
       +
       where

     

       100
       +
           S: directory_state::State,

     

       101
       +
           S::Entries: directory_state::IsUnset,

     

       102
       +
       {

     

       103
       +
           /// Set the `entries` field (required)

     

       104
       +
           pub fn entries(

     

       105
       +
               mut self,

     

       106
       +
               value: impl Into<Vec<crate::place_wisp::subfs::Entry<'a>>>,

     

       107
       +
           ) -> DirectoryBuilder<'a, directory_state::SetEntries<S>> {

     

       108
       +
               self.__unsafe_private_named.0 = ::core::option::Option::Some(value.into());

     

       109
       +
               DirectoryBuilder {

     

       110
       +
                   _phantom_state: ::core::marker::PhantomData,

     

       111
       +
                   __unsafe_private_named: self.__unsafe_private_named,

     

       112
       +
                   _phantom: ::core::marker::PhantomData,

     

       113
       +
               }

     

       114
       +
           }

     

       115
       +
       }

     

       116
       +
       

     

       117
       +
       impl<'a, S> DirectoryBuilder<'a, S>

     

       118
       +
       where

     

       119
       +
           S: directory_state::State,

     

       120
       +
           S::Type: directory_state::IsUnset,

     

       121
       +
       {

     

       122
       +
           /// Set the `type` field (required)

     

       123
       +
           pub fn r#type(

     

       124
       +
               mut self,

     

       125
       +
               value: impl Into<jacquard_common::CowStr<'a>>,

     

       126
       +
           ) -> DirectoryBuilder<'a, directory_state::SetType<S>> {

     

       127
       +
               self.__unsafe_private_named.1 = ::core::option::Option::Some(value.into());

     

       128
       +
               DirectoryBuilder {

     

       129
       +
                   _phantom_state: ::core::marker::PhantomData,

     

       130
       +
                   __unsafe_private_named: self.__unsafe_private_named,

     

       131
       +
                   _phantom: ::core::marker::PhantomData,

     

       132
       +
               }

     

       133
       +
           }

     

       134
       +
       }

     

       135
       +
       

     

       136
       +
       impl<'a, S> DirectoryBuilder<'a, S>

     

       137
       +
       where

     

       138
       +
           S: directory_state::State,

     

       139
       +
           S::Type: directory_state::IsSet,

     

       140
       +
           S::Entries: directory_state::IsSet,

     

       141
       +
       {

     

       142
       +
           /// Build the final struct

     

       143
       +
           pub fn build(self) -> Directory<'a> {

     

       144
       +
               Directory {

     

       145
       +
                   entries: self.__unsafe_private_named.0.unwrap(),

     

       146
       +
                   r#type: self.__unsafe_private_named.1.unwrap(),

     

       147
       +
                   extra_data: Default::default(),

     

       148
       +
               }

     

       149
       +
           }

     

       150
       +
           /// Build the final struct with custom extra_data

     

       151
       +
           pub fn build_with_data(

     

       152
       +
               self,

     

       153
       +
               extra_data: std::collections::BTreeMap<

     

       154
       +
                   jacquard_common::smol_str::SmolStr,

     

       155
       +
                   jacquard_common::types::value::Data<'a>,

     

       156
       +
               >,

     

       157
       +
           ) -> Directory<'a> {

     

       158
       +
               Directory {

     

       159
       +
                   entries: self.__unsafe_private_named.0.unwrap(),

     

       160
       +
                   r#type: self.__unsafe_private_named.1.unwrap(),

     

       161
       +
                   extra_data: Some(extra_data),

     

       162
       +
               }

     

       163
       +
           }

     

       164
       +
       }

     

       165
       +
       

     

       166
       +
       fn lexicon_doc_place_wisp_subfs() -> ::jacquard_lexicon::lexicon::LexiconDoc<'static> {

     

       167
       +
           ::jacquard_lexicon::lexicon::LexiconDoc {

     

       168
       +
               lexicon: ::jacquard_lexicon::lexicon::Lexicon::Lexicon1,

     

       169
       +
               id: ::jacquard_common::CowStr::new_static("place.wisp.subfs"),

     

       170
       +
               revision: None,

     

       171
       +
               description: None,

     

       172
       +
               defs: {

     

       173
       +
                   let mut map = ::std::collections::BTreeMap::new();

     

       174
       +
                   map.insert(

     

       175
       +
                       ::jacquard_common::smol_str::SmolStr::new_static("directory"),

     

       176
       +
                       ::jacquard_lexicon::lexicon::LexUserType::Object(::jacquard_lexicon::lexicon::LexObject {

     

       177
       +
                           description: None,

     

       178
       +
                           required: Some(

     

       179
       +
                               vec![

     

       180
       +
                                   ::jacquard_common::smol_str::SmolStr::new_static("type"),

     

       181
       +
                                   ::jacquard_common::smol_str::SmolStr::new_static("entries")

     

       182
       +
                               ],

     

       183
       +
                           ),

     

       184
       +
                           nullable: None,

     

       185
       +
                           properties: {

     

       186
       +
                               #[allow(unused_mut)]

     

       187
       +
                               let mut map = ::std::collections::BTreeMap::new();

     

       188
       +
                               map.insert(

     

       189
       +
                                   ::jacquard_common::smol_str::SmolStr::new_static("entries"),

     

       190
       +
                                   ::jacquard_lexicon::lexicon::LexObjectProperty::Array(::jacquard_lexicon::lexicon::LexArray {

     

       191
       +
                                       description: None,

     

       192
       +
                                       items: ::jacquard_lexicon::lexicon::LexArrayItem::Ref(::jacquard_lexicon::lexicon::LexRef {

     

       193
       +
                                           description: None,

     

       194
       +
                                           r#ref: ::jacquard_common::CowStr::new_static("#entry"),

     

       195
       +
                                       }),

     

       196
       +
                                       min_length: None,

     

       197
       +
                                       max_length: Some(500usize),

     

       198
       +
                                   }),

     

       199
       +
                               );

     

       200
       +
                               map.insert(

     

       201
       +
                                   ::jacquard_common::smol_str::SmolStr::new_static("type"),

     

       202
       +
                                   ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {

     

       203
       +
                                       description: None,

     

       204
       +
                                       format: None,

     

       205
       +
                                       default: None,

     

       206
       +
                                       min_length: None,

     

       207
       +
                                       max_length: None,

     

       208
       +
                                       min_graphemes: None,

     

       209
       +
                                       max_graphemes: None,

     

       210
       +
                                       r#enum: None,

     

       211
       +
                                       r#const: None,

     

       212
       +
                                       known_values: None,

     

       213
       +
                                   }),

     

       214
       +
                               );

     

       215
       +
                               map

     

       216
       +
                           },

     

       217
       +
                       }),

     

       218
       +
                   );

     

       219
       +
                   map.insert(

     

       220
       +
                       ::jacquard_common::smol_str::SmolStr::new_static("entry"),

     

       221
       +
                       ::jacquard_lexicon::lexicon::LexUserType::Object(::jacquard_lexicon::lexicon::LexObject {

     

       222
       +
                           description: None,

     

       223
       +
                           required: Some(

     

       224
       +
                               vec![

     

       225
       +
                                   ::jacquard_common::smol_str::SmolStr::new_static("name"),

     

       226
       +
                                   ::jacquard_common::smol_str::SmolStr::new_static("node")

     

       227
       +
                               ],

     

       228
       +
                           ),

     

       229
       +
                           nullable: None,

     

       230
       +
                           properties: {

     

       231
       +
                               #[allow(unused_mut)]

     

       232
       +
                               let mut map = ::std::collections::BTreeMap::new();

     

       233
       +
                               map.insert(

     

       234
       +
                                   ::jacquard_common::smol_str::SmolStr::new_static("name"),

     

       235
       +
                                   ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {

     

       236
       +
                                       description: None,

     

       237
       +
                                       format: None,

     

       238
       +
                                       default: None,

     

       239
       +
                                       min_length: None,

     

       240
       +
                                       max_length: Some(255usize),

     

       241
       +
                                       min_graphemes: None,

     

       242
       +
                                       max_graphemes: None,

     

       243
       +
                                       r#enum: None,

     

       244
       +
                                       r#const: None,

     

       245
       +
                                       known_values: None,

     

       246
       +
                                   }),

     

       247
       +
                               );

     

       248
       +
                               map.insert(

     

       249
       +
                                   ::jacquard_common::smol_str::SmolStr::new_static("node"),

     

       250
       +
                                   ::jacquard_lexicon::lexicon::LexObjectProperty::Union(::jacquard_lexicon::lexicon::LexRefUnion {

     

       251
       +
                                       description: None,

     

       252
       +
                                       refs: vec![

     

       253
       +
                                           ::jacquard_common::CowStr::new_static("#file"),

     

       254
       +
                                           ::jacquard_common::CowStr::new_static("#directory"),

     

       255
       +
                                           ::jacquard_common::CowStr::new_static("#subfs")

     

       256
       +
                                       ],

     

       257
       +
                                       closed: None,

     

       258
       +
                                   }),

     

       259
       +
                               );

     

       260
       +
                               map

     

       261
       +
                           },

     

       262
       +
                       }),

     

       263
       +
                   );

     

       264
       +
                   map.insert(

     

       265
       +
                       ::jacquard_common::smol_str::SmolStr::new_static("file"),

     

       266
       +
                       ::jacquard_lexicon::lexicon::LexUserType::Object(::jacquard_lexicon::lexicon::LexObject {

     

       267
       +
                           description: None,

     

       268
       +
                           required: Some(

     

       269
       +
                               vec![

     

       270
       +
                                   ::jacquard_common::smol_str::SmolStr::new_static("type"),

     

       271
       +
                                   ::jacquard_common::smol_str::SmolStr::new_static("blob")

     

       272
       +
                               ],

     

       273
       +
                           ),

     

       274
       +
                           nullable: None,

     

       275
       +
                           properties: {

     

       276
       +
                               #[allow(unused_mut)]

     

       277
       +
                               let mut map = ::std::collections::BTreeMap::new();

     

       278
       +
                               map.insert(

     

       279
       +
                                   ::jacquard_common::smol_str::SmolStr::new_static("base64"),

     

       280
       +
                                   ::jacquard_lexicon::lexicon::LexObjectProperty::Boolean(::jacquard_lexicon::lexicon::LexBoolean {

     

       281
       +
                                       description: None,

     

       282
       +
                                       default: None,

     

       283
       +
                                       r#const: None,

     

       284
       +
                                   }),

     

       285
       +
                               );

     

       286
       +
                               map.insert(

     

       287
       +
                                   ::jacquard_common::smol_str::SmolStr::new_static("blob"),

     

       288
       +
                                   ::jacquard_lexicon::lexicon::LexObjectProperty::Blob(::jacquard_lexicon::lexicon::LexBlob {

     

       289
       +
                                       description: None,

     

       290
       +
                                       accept: None,

     

       291
       +
                                       max_size: None,

     

       292
       +
                                   }),

     

       293
       +
                               );

     

       294
       +
                               map.insert(

     

       295
       +
                                   ::jacquard_common::smol_str::SmolStr::new_static("encoding"),

     

       296
       +
                                   ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {

     

       297
       +
                                       description: Some(

     

       298
       +
                                           ::jacquard_common::CowStr::new_static(

     

       299
       +
                                               "Content encoding (e.g., gzip for compressed files)",

     

       300
       +
                                           ),

     

       301
       +
                                       ),

     

       302
       +
                                       format: None,

     

       303
       +
                                       default: None,

     

       304
       +
                                       min_length: None,

     

       305
       +
                                       max_length: None,

     

       306
       +
                                       min_graphemes: None,

     

       307
       +
                                       max_graphemes: None,

     

       308
       +
                                       r#enum: None,

     

       309
       +
                                       r#const: None,

     

       310
       +
                                       known_values: None,

     

       311
       +
                                   }),

     

       312
       +
                               );

     

       313
       +
                               map.insert(

     

       314
       +
                                   ::jacquard_common::smol_str::SmolStr::new_static("mimeType"),

     

       315
       +
                                   ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {

     

       316
       +
                                       description: Some(

     

       317
       +
                                           ::jacquard_common::CowStr::new_static(

     

       318
       +
                                               "Original MIME type before compression",

     

       319
       +
                                           ),

     

       320
       +
                                       ),

     

       321
       +
                                       format: None,

     

       322
       +
                                       default: None,

     

       323
       +
                                       min_length: None,

     

       324
       +
                                       max_length: None,

     

       325
       +
                                       min_graphemes: None,

     

       326
       +
                                       max_graphemes: None,

     

       327
       +
                                       r#enum: None,

     

       328
       +
                                       r#const: None,

     

       329
       +
                                       known_values: None,

     

       330
       +
                                   }),

     

       331
       +
                               );

     

       332
       +
                               map.insert(

     

       333
       +
                                   ::jacquard_common::smol_str::SmolStr::new_static("type"),

     

       334
       +
                                   ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {

     

       335
       +
                                       description: None,

     

       336
       +
                                       format: None,

     

       337
       +
                                       default: None,

     

       338
       +
                                       min_length: None,

     

       339
       +
                                       max_length: None,

     

       340
       +
                                       min_graphemes: None,

     

       341
       +
                                       max_graphemes: None,

     

       342
       +
                                       r#enum: None,

     

       343
       +
                                       r#const: None,

     

       344
       +
                                       known_values: None,

     

       345
       +
                                   }),

     

       346
       +
                               );

     

       347
       +
                               map

     

       348
       +
                           },

     

       349
       +
                       }),

     

       350
       +
                   );

     

       351
       +
                   map.insert(

     

       352
       +
                       ::jacquard_common::smol_str::SmolStr::new_static("main"),

     

       353
       +
                       ::jacquard_lexicon::lexicon::LexUserType::Record(::jacquard_lexicon::lexicon::LexRecord {

     

       354
       +
                           description: Some(

     

       355
       +
                               ::jacquard_common::CowStr::new_static(

     

       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
       +
                               ),

     

       358
       +
                           ),

     

       359
       +
                           key: None,

     

       360
       +
                           record: ::jacquard_lexicon::lexicon::LexRecordRecord::Object(::jacquard_lexicon::lexicon::LexObject {

     

       361
       +
                               description: None,

     

       362
       +
                               required: Some(

     

       363
       +
                                   vec![

     

       364
       +
                                       ::jacquard_common::smol_str::SmolStr::new_static("root"),

     

       365
       +
                                       ::jacquard_common::smol_str::SmolStr::new_static("createdAt")

     

       366
       +
                                   ],

     

       367
       +
                               ),

     

       368
       +
                               nullable: None,

     

       369
       +
                               properties: {

     

       370
       +
                                   #[allow(unused_mut)]

     

       371
       +
                                   let mut map = ::std::collections::BTreeMap::new();

     

       372
       +
                                   map.insert(

     

       373
       +
                                       ::jacquard_common::smol_str::SmolStr::new_static(

     

       374
       +
                                           "createdAt",

     

       375
       +
                                       ),

     

       376
       +
                                       ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {

     

       377
       +
                                           description: None,

     

       378
       +
                                           format: Some(

     

       379
       +
                                               ::jacquard_lexicon::lexicon::LexStringFormat::Datetime,

     

       380
       +
                                           ),

     

       381
       +
                                           default: None,

     

       382
       +
                                           min_length: None,

     

       383
       +
                                           max_length: None,

     

       384
       +
                                           min_graphemes: None,

     

       385
       +
                                           max_graphemes: None,

     

       386
       +
                                           r#enum: None,

     

       387
       +
                                           r#const: None,

     

       388
       +
                                           known_values: None,

     

       389
       +
                                       }),

     

       390
       +
                                   );

     

       391
       +
                                   map.insert(

     

       392
       +
                                       ::jacquard_common::smol_str::SmolStr::new_static(

     

       393
       +
                                           "fileCount",

     

       394
       +
                                       ),

     

       395
       +
                                       ::jacquard_lexicon::lexicon::LexObjectProperty::Integer(::jacquard_lexicon::lexicon::LexInteger {

     

       396
       +
                                           description: None,

     

       397
       +
                                           default: None,

     

       398
       +
                                           minimum: Some(0i64),

     

       399
       +
                                           maximum: Some(1000i64),

     

       400
       +
                                           r#enum: None,

     

       401
       +
                                           r#const: None,

     

       402
       +
                                       }),

     

       403
       +
                                   );

     

       404
       +
                                   map.insert(

     

       405
       +
                                       ::jacquard_common::smol_str::SmolStr::new_static("root"),

     

       406
       +
                                       ::jacquard_lexicon::lexicon::LexObjectProperty::Ref(::jacquard_lexicon::lexicon::LexRef {

     

       407
       +
                                           description: None,

     

       408
       +
                                           r#ref: ::jacquard_common::CowStr::new_static("#directory"),

     

       409
       +
                                       }),

     

       410
       +
                                   );

     

       411
       +
                                   map

     

       412
       +
                               },

     

       413
       +
                           }),

     

       414
       +
                       }),

     

       415
       +
                   );

     

       416
       +
                   map.insert(

     

       417
       +
                       ::jacquard_common::smol_str::SmolStr::new_static("subfs"),

     

       418
       +
                       ::jacquard_lexicon::lexicon::LexUserType::Object(::jacquard_lexicon::lexicon::LexObject {

     

       419
       +
                           description: None,

     

       420
       +
                           required: Some(

     

       421
       +
                               vec![

     

       422
       +
                                   ::jacquard_common::smol_str::SmolStr::new_static("type"),

     

       423
       +
                                   ::jacquard_common::smol_str::SmolStr::new_static("subject")

     

       424
       +
                               ],

     

       425
       +
                           ),

     

       426
       +
                           nullable: None,

     

       427
       +
                           properties: {

     

       428
       +
                               #[allow(unused_mut)]

     

       429
       +
                               let mut map = ::std::collections::BTreeMap::new();

     

       430
       +
                               map.insert(

     

       431
       +
                                   ::jacquard_common::smol_str::SmolStr::new_static("subject"),

     

       432
       +
                                   ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {

     

       433
       +
                                       description: Some(

     

       434
       +
                                           ::jacquard_common::CowStr::new_static(

     

       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
       +
                                           ),

     

       437
       +
                                       ),

     

       438
       +
                                       format: Some(

     

       439
       +
                                           ::jacquard_lexicon::lexicon::LexStringFormat::AtUri,

     

       440
       +
                                       ),

     

       441
       +
                                       default: None,

     

       442
       +
                                       min_length: None,

     

       443
       +
                                       max_length: None,

     

       444
       +
                                       min_graphemes: None,

     

       445
       +
                                       max_graphemes: None,

     

       446
       +
                                       r#enum: None,

     

       447
       +
                                       r#const: None,

     

       448
       +
                                       known_values: None,

     

       449
       +
                                   }),

     

       450
       +
                               );

     

       451
       +
                               map.insert(

     

       452
       +
                                   ::jacquard_common::smol_str::SmolStr::new_static("type"),

     

       453
       +
                                   ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {

     

       454
       +
                                       description: None,

     

       455
       +
                                       format: None,

     

       456
       +
                                       default: None,

     

       457
       +
                                       min_length: None,

     

       458
       +
                                       max_length: None,

     

       459
       +
                                       min_graphemes: None,

     

       460
       +
                                       max_graphemes: None,

     

       461
       +
                                       r#enum: None,

     

       462
       +
                                       r#const: None,

     

       463
       +
                                       known_values: None,

     

       464
       +
                                   }),

     

       465
       +
                               );

     

       466
       +
                               map

     

       467
       +
                           },

     

       468
       +
                       }),

     

       469
       +
                   );

     

       470
       +
                   map

     

       471
       +
               },

     

       472
       +
           }

     

       473
       +
       }

     

       474
       +
       

     

       475
       +
       impl<'a> ::jacquard_lexicon::schema::LexiconSchema for Directory<'a> {

     

       476
       +
           fn nsid() -> &'static str {

     

       477
       +
               "place.wisp.subfs"

     

       478
       +
           }

     

       479
       +
           fn def_name() -> &'static str {

     

       480
       +
               "directory"

     

       481
       +
           }

     

       482
       +
           fn lexicon_doc() -> ::jacquard_lexicon::lexicon::LexiconDoc<'static> {

     

       483
       +
               lexicon_doc_place_wisp_subfs()

     

       484
       +
           }

     

       485
       +
           fn validate(

     

       486
       +
               &self,

     

       487
       +
           ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> {

     

       488
       +
               {

     

       489
       +
                   let value = &self.entries;

     

       490
       +
                   #[allow(unused_comparisons)]

     

       491
       +
                   if value.len() > 500usize {

     

       492
       +
                       return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength {

     

       493
       +
                           path: ::jacquard_lexicon::validation::ValidationPath::from_field(

     

       494
       +
                               "entries",

     

       495
       +
                           ),

     

       496
       +
                           max: 500usize,

     

       497
       +
                           actual: value.len(),

     

       498
       +
                       });

     

       499
       +
                   }

     

       500
       +
               }

     

       501
       +
               Ok(())

     

       502
       +
           }

     

       503
       +
       }

     

       504
       +
       

     

       505
       +
       #[jacquard_derive::lexicon]

     

       506
       +
       #[derive(

     

       507
       +
           serde::Serialize,

     

       508
       +
           serde::Deserialize,

     

       509
       +
           Debug,

     

       510
       +
           Clone,

     

       511
       +
           PartialEq,

     

       512
       +
           Eq,

     

       513
       +
           jacquard_derive::IntoStatic

     

       514
       +
       )]

     

       515
       +
       #[serde(rename_all = "camelCase")]

     

       516
       +
       pub struct Entry<'a> {

     

       517
       +
           #[serde(borrow)]

     

       518
       +
           pub name: jacquard_common::CowStr<'a>,

     

       519
       +
           #[serde(borrow)]

     

       520
       +
           pub node: EntryNode<'a>,

     

       521
       +
       }

     

       522
       +
       

     

       523
       +
       pub mod entry_state {

     

       524
       +
       

     

       525
       +
           pub use crate::builder_types::{Set, Unset, IsSet, IsUnset};

     

       526
       +
           #[allow(unused)]

     

       527
       +
           use ::core::marker::PhantomData;

     

       528
       +
           mod sealed {

     

       529
       +
               pub trait Sealed {}

     

       530
       +
           }

     

       531
       +
           /// State trait tracking which required fields have been set

     

       532
       +
           pub trait State: sealed::Sealed {

     

       533
       +
               type Name;

     

       534
       +
               type Node;

     

       535
       +
           }

     

       536
       +
           /// Empty state - all required fields are unset

     

       537
       +
           pub struct Empty(());

     

       538
       +
           impl sealed::Sealed for Empty {}

     

       539
       +
           impl State for Empty {

     

       540
       +
               type Name = Unset;

     

       541
       +
               type Node = Unset;

     

       542
       +
           }

     

       543
       +
           ///State transition - sets the `name` field to Set

     

       544
       +
           pub struct SetName<S: State = Empty>(PhantomData<fn() -> S>);

     

       545
       +
           impl<S: State> sealed::Sealed for SetName<S> {}

     

       546
       +
           impl<S: State> State for SetName<S> {

     

       547
       +
               type Name = Set<members::name>;

     

       548
       +
               type Node = S::Node;

     

       549
       +
           }

     

       550
       +
           ///State transition - sets the `node` field to Set

     

       551
       +
           pub struct SetNode<S: State = Empty>(PhantomData<fn() -> S>);

     

       552
       +
           impl<S: State> sealed::Sealed for SetNode<S> {}

     

       553
       +
           impl<S: State> State for SetNode<S> {

     

       554
       +
               type Name = S::Name;

     

       555
       +
               type Node = Set<members::node>;

     

       556
       +
           }

     

       557
       +
           /// Marker types for field names

     

       558
       +
           #[allow(non_camel_case_types)]

     

       559
       +
           pub mod members {

     

       560
       +
               ///Marker type for the `name` field

     

       561
       +
               pub struct name(());

     

       562
       +
               ///Marker type for the `node` field

     

       563
       +
               pub struct node(());

     

       564
       +
           }

     

       565
       +
       }

     

       566
       +
       

     

       567
       +
       /// Builder for constructing an instance of this type

     

       568
       +
       pub struct EntryBuilder<'a, S: entry_state::State> {

     

       569
       +
           _phantom_state: ::core::marker::PhantomData<fn() -> S>,

     

       570
       +
           __unsafe_private_named: (

     

       571
       +
               ::core::option::Option<jacquard_common::CowStr<'a>>,

     

       572
       +
               ::core::option::Option<EntryNode<'a>>,

     

       573
       +
           ),

     

       574
       +
           _phantom: ::core::marker::PhantomData<&'a ()>,

     

       575
       +
       }

     

       576
       +
       

     

       577
       +
       impl<'a> Entry<'a> {

     

       578
       +
           /// Create a new builder for this type

     

       579
       +
           pub fn new() -> EntryBuilder<'a, entry_state::Empty> {

     

       580
       +
               EntryBuilder::new()

     

       581
       +
           }

     

       582
       +
       }

     

       583
       +
       

     

       584
       +
       impl<'a> EntryBuilder<'a, entry_state::Empty> {

     

       585
       +
           /// Create a new builder with all fields unset

     

       586
       +
           pub fn new() -> Self {

     

       587
       +
               EntryBuilder {

     

       588
       +
                   _phantom_state: ::core::marker::PhantomData,

     

       589
       +
                   __unsafe_private_named: (None, None),

     

       590
       +
                   _phantom: ::core::marker::PhantomData,

     

       591
       +
               }

     

       592
       +
           }

     

       593
       +
       }

     

       594
       +
       

     

       595
       +
       impl<'a, S> EntryBuilder<'a, S>

     

       596
       +
       where

     

       597
       +
           S: entry_state::State,

     

       598
       +
           S::Name: entry_state::IsUnset,

     

       599
       +
       {

     

       600
       +
           /// Set the `name` field (required)

     

       601
       +
           pub fn name(

     

       602
       +
               mut self,

     

       603
       +
               value: impl Into<jacquard_common::CowStr<'a>>,

     

       604
       +
           ) -> EntryBuilder<'a, entry_state::SetName<S>> {

     

       605
       +
               self.__unsafe_private_named.0 = ::core::option::Option::Some(value.into());

     

       606
       +
               EntryBuilder {

     

       607
       +
                   _phantom_state: ::core::marker::PhantomData,

     

       608
       +
                   __unsafe_private_named: self.__unsafe_private_named,

     

       609
       +
                   _phantom: ::core::marker::PhantomData,

     

       610
       +
               }

     

       611
       +
           }

     

       612
       +
       }

     

       613
       +
       

     

       614
       +
       impl<'a, S> EntryBuilder<'a, S>

     

       615
       +
       where

     

       616
       +
           S: entry_state::State,

     

       617
       +
           S::Node: entry_state::IsUnset,

     

       618
       +
       {

     

       619
       +
           /// Set the `node` field (required)

     

       620
       +
           pub fn node(

     

       621
       +
               mut self,

     

       622
       +
               value: impl Into<EntryNode<'a>>,

     

       623
       +
           ) -> EntryBuilder<'a, entry_state::SetNode<S>> {

     

       624
       +
               self.__unsafe_private_named.1 = ::core::option::Option::Some(value.into());

     

       625
       +
               EntryBuilder {

     

       626
       +
                   _phantom_state: ::core::marker::PhantomData,

     

       627
       +
                   __unsafe_private_named: self.__unsafe_private_named,

     

       628
       +
                   _phantom: ::core::marker::PhantomData,

     

       629
       +
               }

     

       630
       +
           }

     

       631
       +
       }

     

       632
       +
       

     

       633
       +
       impl<'a, S> EntryBuilder<'a, S>

     

       634
       +
       where

     

       635
       +
           S: entry_state::State,

     

       636
       +
           S::Name: entry_state::IsSet,

     

       637
       +
           S::Node: entry_state::IsSet,

     

       638
       +
       {

     

       639
       +
           /// Build the final struct

     

       640
       +
           pub fn build(self) -> Entry<'a> {

     

       641
       +
               Entry {

     

       642
       +
                   name: self.__unsafe_private_named.0.unwrap(),

     

       643
       +
                   node: self.__unsafe_private_named.1.unwrap(),

     

       644
       +
                   extra_data: Default::default(),

     

       645
       +
               }

     

       646
       +
           }

     

       647
       +
           /// Build the final struct with custom extra_data

     

       648
       +
           pub fn build_with_data(

     

       649
       +
               self,

     

       650
       +
               extra_data: std::collections::BTreeMap<

     

       651
       +
                   jacquard_common::smol_str::SmolStr,

     

       652
       +
                   jacquard_common::types::value::Data<'a>,

     

       653
       +
               >,

     

       654
       +
           ) -> Entry<'a> {

     

       655
       +
               Entry {

     

       656
       +
                   name: self.__unsafe_private_named.0.unwrap(),

     

       657
       +
                   node: self.__unsafe_private_named.1.unwrap(),

     

       658
       +
                   extra_data: Some(extra_data),

     

       659
       +
               }

     

       660
       +
           }

     

       661
       +
       }

     

       662
       +
       

     

       663
       +
       #[jacquard_derive::open_union]

     

       664
       +
       #[derive(

     

       665
       +
           serde::Serialize,

     

       666
       +
           serde::Deserialize,

     

       667
       +
           Debug,

     

       668
       +
           Clone,

     

       669
       +
           PartialEq,

     

       670
       +
           Eq,

     

       671
       +
           jacquard_derive::IntoStatic

     

       672
       +
       )]

     

       673
       +
       #[serde(tag = "$type")]

     

       674
       +
       #[serde(bound(deserialize = "'de: 'a"))]

     

       675
       +
       pub enum EntryNode<'a> {

     

       676
       +
           #[serde(rename = "place.wisp.subfs#file")]

     

       677
       +
           File(Box<crate::place_wisp::subfs::File<'a>>),

     

       678
       +
           #[serde(rename = "place.wisp.subfs#directory")]

     

       679
       +
           Directory(Box<crate::place_wisp::subfs::Directory<'a>>),

     

       680
       +
           #[serde(rename = "place.wisp.subfs#subfs")]

     

       681
       +
           Subfs(Box<crate::place_wisp::subfs::Subfs<'a>>),

     

       682
       +
       }

     

       683
       +
       

     

       684
       +
       impl<'a> ::jacquard_lexicon::schema::LexiconSchema for Entry<'a> {

     

       685
       +
           fn nsid() -> &'static str {

     

       686
       +
               "place.wisp.subfs"

     

       687
       +
           }

     

       688
       +
           fn def_name() -> &'static str {

     

       689
       +
               "entry"

     

       690
       +
           }

     

       691
       +
           fn lexicon_doc() -> ::jacquard_lexicon::lexicon::LexiconDoc<'static> {

     

       692
       +
               lexicon_doc_place_wisp_subfs()

     

       693
       +
           }

     

       694
       +
           fn validate(

     

       695
       +
               &self,

     

       696
       +
           ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> {

     

       697
       +
               {

     

       698
       +
                   let value = &self.name;

     

       699
       +
                   #[allow(unused_comparisons)]

     

       700
       +
                   if <str>::len(value.as_ref()) > 255usize {

     

       701
       +
                       return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength {

     

       702
       +
                           path: ::jacquard_lexicon::validation::ValidationPath::from_field(

     

       703
       +
                               "name",

     

       704
       +
                           ),

     

       705
       +
                           max: 255usize,

     

       706
       +
                           actual: <str>::len(value.as_ref()),

     

       707
       +
                       });

     

       708
       +
                   }

     

       709
       +
               }

     

       710
       +
               Ok(())

     

       711
       +
           }

     

       712
       +
       }

     

       713
       +
       

     

       714
       +
       #[jacquard_derive::lexicon]

     

       715
       +
       #[derive(

     

       716
       +
           serde::Serialize,

     

       717
       +
           serde::Deserialize,

     

       718
       +
           Debug,

     

       719
       +
           Clone,

     

       720
       +
           PartialEq,

     

       721
       +
           Eq,

     

       722
       +
           jacquard_derive::IntoStatic

     

       723
       +
       )]

     

       724
       +
       #[serde(rename_all = "camelCase")]

     

       725
       +
       pub struct File<'a> {

     

       726
       +
           /// True if blob content is base64-encoded (used to bypass PDS content sniffing)

     

       727
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       728
       +
           pub base64: std::option::Option<bool>,

     

       729
       +
           /// Content blob ref

     

       730
       +
           #[serde(borrow)]

     

       731
       +
           pub blob: jacquard_common::types::blob::BlobRef<'a>,

     

       732
       +
           /// Content encoding (e.g., gzip for compressed files)

     

       733
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       734
       +
           #[serde(borrow)]

     

       735
       +
           pub encoding: std::option::Option<jacquard_common::CowStr<'a>>,

     

       736
       +
           /// Original MIME type before compression

     

       737
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       738
       +
           #[serde(borrow)]

     

       739
       +
           pub mime_type: std::option::Option<jacquard_common::CowStr<'a>>,

     

       740
       +
           #[serde(borrow)]

     

       741
       +
           pub r#type: jacquard_common::CowStr<'a>,

     

       742
       +
       }

     

       743
       +
       

     

       744
       +
       pub mod file_state {

     

       745
       +
       

     

       746
       +
           pub use crate::builder_types::{Set, Unset, IsSet, IsUnset};

     

       747
       +
           #[allow(unused)]

     

       748
       +
           use ::core::marker::PhantomData;

     

       749
       +
           mod sealed {

     

       750
       +
               pub trait Sealed {}

     

       751
       +
           }

     

       752
       +
           /// State trait tracking which required fields have been set

     

       753
       +
           pub trait State: sealed::Sealed {

     

       754
       +
               type Blob;

     

       755
       +
               type Type;

     

       756
       +
           }

     

       757
       +
           /// Empty state - all required fields are unset

     

       758
       +
           pub struct Empty(());

     

       759
       +
           impl sealed::Sealed for Empty {}

     

       760
       +
           impl State for Empty {

     

       761
       +
               type Blob = Unset;

     

       762
       +
               type Type = Unset;

     

       763
       +
           }

     

       764
       +
           ///State transition - sets the `blob` field to Set

     

       765
       +
           pub struct SetBlob<S: State = Empty>(PhantomData<fn() -> S>);

     

       766
       +
           impl<S: State> sealed::Sealed for SetBlob<S> {}

     

       767
       +
           impl<S: State> State for SetBlob<S> {

     

       768
       +
               type Blob = Set<members::blob>;

     

       769
       +
               type Type = S::Type;

     

       770
       +
           }

     

       771
       +
           ///State transition - sets the `type` field to Set

     

       772
       +
           pub struct SetType<S: State = Empty>(PhantomData<fn() -> S>);

     

       773
       +
           impl<S: State> sealed::Sealed for SetType<S> {}

     

       774
       +
           impl<S: State> State for SetType<S> {

     

       775
       +
               type Blob = S::Blob;

     

       776
       +
               type Type = Set<members::r#type>;

     

       777
       +
           }

     

       778
       +
           /// Marker types for field names

     

       779
       +
           #[allow(non_camel_case_types)]

     

       780
       +
           pub mod members {

     

       781
       +
               ///Marker type for the `blob` field

     

       782
       +
               pub struct blob(());

     

       783
       +
               ///Marker type for the `type` field

     

       784
       +
               pub struct r#type(());

     

       785
       +
           }

     

       786
       +
       }

     

       787
       +
       

     

       788
       +
       /// Builder for constructing an instance of this type

     

       789
       +
       pub struct FileBuilder<'a, S: file_state::State> {

     

       790
       +
           _phantom_state: ::core::marker::PhantomData<fn() -> S>,

     

       791
       +
           __unsafe_private_named: (

     

       792
       +
               ::core::option::Option<bool>,

     

       793
       +
               ::core::option::Option<jacquard_common::types::blob::BlobRef<'a>>,

     

       794
       +
               ::core::option::Option<jacquard_common::CowStr<'a>>,

     

       795
       +
               ::core::option::Option<jacquard_common::CowStr<'a>>,

     

       796
       +
               ::core::option::Option<jacquard_common::CowStr<'a>>,

     

       797
       +
           ),

     

       798
       +
           _phantom: ::core::marker::PhantomData<&'a ()>,

     

       799
       +
       }

     

       800
       +
       

     

       801
       +
       impl<'a> File<'a> {

     

       802
       +
           /// Create a new builder for this type

     

       803
       +
           pub fn new() -> FileBuilder<'a, file_state::Empty> {

     

       804
       +
               FileBuilder::new()

     

       805
       +
           }

     

       806
       +
       }

     

       807
       +
       

     

       808
       +
       impl<'a> FileBuilder<'a, file_state::Empty> {

     

       809
       +
           /// Create a new builder with all fields unset

     

       810
       +
           pub fn new() -> Self {

     

       811
       +
               FileBuilder {

     

       812
       +
                   _phantom_state: ::core::marker::PhantomData,

     

       813
       +
                   __unsafe_private_named: (None, None, None, None, None),

     

       814
       +
                   _phantom: ::core::marker::PhantomData,

     

       815
       +
               }

     

       816
       +
           }

     

       817
       +
       }

     

       818
       +
       

     

       819
       +
       impl<'a, S: file_state::State> FileBuilder<'a, S> {

     

       820
       +
           /// Set the `base64` field (optional)

     

       821
       +
           pub fn base64(mut self, value: impl Into<Option<bool>>) -> Self {

     

       822
       +
               self.__unsafe_private_named.0 = value.into();

     

       823
       +
               self

     

       824
       +
           }

     

       825
       +
           /// Set the `base64` field to an Option value (optional)

     

       826
       +
           pub fn maybe_base64(mut self, value: Option<bool>) -> Self {

     

       827
       +
               self.__unsafe_private_named.0 = value;

     

       828
       +
               self

     

       829
       +
           }

     

       830
       +
       }

     

       831
       +
       

     

       832
       +
       impl<'a, S> FileBuilder<'a, S>

     

       833
       +
       where

     

       834
       +
           S: file_state::State,

     

       835
       +
           S::Blob: file_state::IsUnset,

     

       836
       +
       {

     

       837
       +
           /// Set the `blob` field (required)

     

       838
       +
           pub fn blob(

     

       839
       +
               mut self,

     

       840
       +
               value: impl Into<jacquard_common::types::blob::BlobRef<'a>>,

     

       841
       +
           ) -> FileBuilder<'a, file_state::SetBlob<S>> {

     

       842
       +
               self.__unsafe_private_named.1 = ::core::option::Option::Some(value.into());

     

       843
       +
               FileBuilder {

     

       844
       +
                   _phantom_state: ::core::marker::PhantomData,

     

       845
       +
                   __unsafe_private_named: self.__unsafe_private_named,

     

       846
       +
                   _phantom: ::core::marker::PhantomData,

     

       847
       +
               }

     

       848
       +
           }

     

       849
       +
       }

     

       850
       +
       

     

       851
       +
       impl<'a, S: file_state::State> FileBuilder<'a, S> {

     

       852
       +
           /// Set the `encoding` field (optional)

     

       853
       +
           pub fn encoding(

     

       854
       +
               mut self,

     

       855
       +
               value: impl Into<Option<jacquard_common::CowStr<'a>>>,

     

       856
       +
           ) -> Self {

     

       857
       +
               self.__unsafe_private_named.2 = value.into();

     

       858
       +
               self

     

       859
       +
           }

     

       860
       +
           /// Set the `encoding` field to an Option value (optional)

     

       861
       +
           pub fn maybe_encoding(mut self, value: Option<jacquard_common::CowStr<'a>>) -> Self {

     

       862
       +
               self.__unsafe_private_named.2 = value;

     

       863
       +
               self

     

       864
       +
           }

     

       865
       +
       }

     

       866
       +
       

     

       867
       +
       impl<'a, S: file_state::State> FileBuilder<'a, S> {

     

       868
       +
           /// Set the `mimeType` field (optional)

     

       869
       +
           pub fn mime_type(

     

       870
       +
               mut self,

     

       871
       +
               value: impl Into<Option<jacquard_common::CowStr<'a>>>,

     

       872
       +
           ) -> Self {

     

       873
       +
               self.__unsafe_private_named.3 = value.into();

     

       874
       +
               self

     

       875
       +
           }

     

       876
       +
           /// Set the `mimeType` field to an Option value (optional)

     

       877
       +
           pub fn maybe_mime_type(

     

       878
       +
               mut self,

     

       879
       +
               value: Option<jacquard_common::CowStr<'a>>,

     

       880
       +
           ) -> Self {

     

       881
       +
               self.__unsafe_private_named.3 = value;

     

       882
       +
               self

     

       883
       +
           }

     

       884
       +
       }

     

       885
       +
       

     

       886
       +
       impl<'a, S> FileBuilder<'a, S>

     

       887
       +
       where

     

       888
       +
           S: file_state::State,

     

       889
       +
           S::Type: file_state::IsUnset,

     

       890
       +
       {

     

       891
       +
           /// Set the `type` field (required)

     

       892
       +
           pub fn r#type(

     

       893
       +
               mut self,

     

       894
       +
               value: impl Into<jacquard_common::CowStr<'a>>,

     

       895
       +
           ) -> FileBuilder<'a, file_state::SetType<S>> {

     

       896
       +
               self.__unsafe_private_named.4 = ::core::option::Option::Some(value.into());

     

       897
       +
               FileBuilder {

     

       898
       +
                   _phantom_state: ::core::marker::PhantomData,

     

       899
       +
                   __unsafe_private_named: self.__unsafe_private_named,

     

       900
       +
                   _phantom: ::core::marker::PhantomData,

     

       901
       +
               }

     

       902
       +
           }

     

       903
       +
       }

     

       904
       +
       

     

       905
       +
       impl<'a, S> FileBuilder<'a, S>

     

       906
       +
       where

     

       907
       +
           S: file_state::State,

     

       908
       +
           S::Blob: file_state::IsSet,

     

       909
       +
           S::Type: file_state::IsSet,

     

       910
       +
       {

     

       911
       +
           /// Build the final struct

     

       912
       +
           pub fn build(self) -> File<'a> {

     

       913
       +
               File {

     

       914
       +
                   base64: self.__unsafe_private_named.0,

     

       915
       +
                   blob: self.__unsafe_private_named.1.unwrap(),

     

       916
       +
                   encoding: self.__unsafe_private_named.2,

     

       917
       +
                   mime_type: self.__unsafe_private_named.3,

     

       918
       +
                   r#type: self.__unsafe_private_named.4.unwrap(),

     

       919
       +
                   extra_data: Default::default(),

     

       920
       +
               }

     

       921
       +
           }

     

       922
       +
           /// Build the final struct with custom extra_data

     

       923
       +
           pub fn build_with_data(

     

       924
       +
               self,

     

       925
       +
               extra_data: std::collections::BTreeMap<

     

       926
       +
                   jacquard_common::smol_str::SmolStr,

     

       927
       +
                   jacquard_common::types::value::Data<'a>,

     

       928
       +
               >,

     

       929
       +
           ) -> File<'a> {

     

       930
       +
               File {

     

       931
       +
                   base64: self.__unsafe_private_named.0,

     

       932
       +
                   blob: self.__unsafe_private_named.1.unwrap(),

     

       933
       +
                   encoding: self.__unsafe_private_named.2,

     

       934
       +
                   mime_type: self.__unsafe_private_named.3,

     

       935
       +
                   r#type: self.__unsafe_private_named.4.unwrap(),

     

       936
       +
                   extra_data: Some(extra_data),

     

       937
       +
               }

     

       938
       +
           }

     

       939
       +
       }

     

       940
       +
       

     

       941
       +
       impl<'a> ::jacquard_lexicon::schema::LexiconSchema for File<'a> {

     

       942
       +
           fn nsid() -> &'static str {

     

       943
       +
               "place.wisp.subfs"

     

       944
       +
           }

     

       945
       +
           fn def_name() -> &'static str {

     

       946
       +
               "file"

     

       947
       +
           }

     

       948
       +
           fn lexicon_doc() -> ::jacquard_lexicon::lexicon::LexiconDoc<'static> {

     

       949
       +
               lexicon_doc_place_wisp_subfs()

     

       950
       +
           }

     

       951
       +
           fn validate(

     

       952
       +
               &self,

     

       953
       +
           ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> {

     

       954
       +
               Ok(())

     

       955
       +
           }

     

       956
       +
       }

     

       957
       +
       

     

       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
       +
       #[jacquard_derive::lexicon]

     

       960
       +
       #[derive(

     

       961
       +
           serde::Serialize,

     

       962
       +
           serde::Deserialize,

     

       963
       +
           Debug,

     

       964
       +
           Clone,

     

       965
       +
           PartialEq,

     

       966
       +
           Eq,

     

       967
       +
           jacquard_derive::IntoStatic

     

       968
       +
       )]

     

       969
       +
       #[serde(rename_all = "camelCase")]

     

       970
       +
       pub struct SubfsRecord<'a> {

     

       971
       +
           pub created_at: jacquard_common::types::string::Datetime,

     

       972
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       973
       +
           pub file_count: std::option::Option<i64>,

     

       974
       +
           #[serde(borrow)]

     

       975
       +
           pub root: crate::place_wisp::subfs::Directory<'a>,

     

       976
       +
       }

     

       977
       +
       

     

       978
       +
       pub mod subfs_record_state {

     

       979
       +
       

     

       980
       +
           pub use crate::builder_types::{Set, Unset, IsSet, IsUnset};

     

       981
       +
           #[allow(unused)]

     

       982
       +
           use ::core::marker::PhantomData;

     

       983
       +
           mod sealed {

     

       984
       +
               pub trait Sealed {}

     

       985
       +
           }

     

       986
       +
           /// State trait tracking which required fields have been set

     

       987
       +
           pub trait State: sealed::Sealed {

     

       988
       +
               type Root;

     

       989
       +
               type CreatedAt;

     

       990
       +
           }

     

       991
       +
           /// Empty state - all required fields are unset

     

       992
       +
           pub struct Empty(());

     

       993
       +
           impl sealed::Sealed for Empty {}

     

       994
       +
           impl State for Empty {

     

       995
       +
               type Root = Unset;

     

       996
       +
               type CreatedAt = Unset;

     

       997
       +
           }

     

       998
       +
           ///State transition - sets the `root` field to Set

     

       999
       +
           pub struct SetRoot<S: State = Empty>(PhantomData<fn() -> S>);

     

       1000
       +
           impl<S: State> sealed::Sealed for SetRoot<S> {}

     

       1001
       +
           impl<S: State> State for SetRoot<S> {

     

       1002
       +
               type Root = Set<members::root>;

     

       1003
       +
               type CreatedAt = S::CreatedAt;

     

       1004
       +
           }

     

       1005
       +
           ///State transition - sets the `created_at` field to Set

     

       1006
       +
           pub struct SetCreatedAt<S: State = Empty>(PhantomData<fn() -> S>);

     

       1007
       +
           impl<S: State> sealed::Sealed for SetCreatedAt<S> {}

     

       1008
       +
           impl<S: State> State for SetCreatedAt<S> {

     

       1009
       +
               type Root = S::Root;

     

       1010
       +
               type CreatedAt = Set<members::created_at>;

     

       1011
       +
           }

     

       1012
       +
           /// Marker types for field names

     

       1013
       +
           #[allow(non_camel_case_types)]

     

       1014
       +
           pub mod members {

     

       1015
       +
               ///Marker type for the `root` field

     

       1016
       +
               pub struct root(());

     

       1017
       +
               ///Marker type for the `created_at` field

     

       1018
       +
               pub struct created_at(());

     

       1019
       +
           }

     

       1020
       +
       }

     

       1021
       +
       

     

       1022
       +
       /// Builder for constructing an instance of this type

     

       1023
       +
       pub struct SubfsRecordBuilder<'a, S: subfs_record_state::State> {

     

       1024
       +
           _phantom_state: ::core::marker::PhantomData<fn() -> S>,

     

       1025
       +
           __unsafe_private_named: (

     

       1026
       +
               ::core::option::Option<jacquard_common::types::string::Datetime>,

     

       1027
       +
               ::core::option::Option<i64>,

     

       1028
       +
               ::core::option::Option<crate::place_wisp::subfs::Directory<'a>>,

     

       1029
       +
           ),

     

       1030
       +
           _phantom: ::core::marker::PhantomData<&'a ()>,

     

       1031
       +
       }

     

       1032
       +
       

     

       1033
       +
       impl<'a> SubfsRecord<'a> {

     

       1034
       +
           /// Create a new builder for this type

     

       1035
       +
           pub fn new() -> SubfsRecordBuilder<'a, subfs_record_state::Empty> {

     

       1036
       +
               SubfsRecordBuilder::new()

     

       1037
       +
           }

     

       1038
       +
       }

     

       1039
       +
       

     

       1040
       +
       impl<'a> SubfsRecordBuilder<'a, subfs_record_state::Empty> {

     

       1041
       +
           /// Create a new builder with all fields unset

     

       1042
       +
           pub fn new() -> Self {

     

       1043
       +
               SubfsRecordBuilder {

     

       1044
       +
                   _phantom_state: ::core::marker::PhantomData,

     

       1045
       +
                   __unsafe_private_named: (None, None, None),

     

       1046
       +
                   _phantom: ::core::marker::PhantomData,

     

       1047
       +
               }

     

       1048
       +
           }

     

       1049
       +
       }

     

       1050
       +
       

     

       1051
       +
       impl<'a, S> SubfsRecordBuilder<'a, S>

     

       1052
       +
       where

     

       1053
       +
           S: subfs_record_state::State,

     

       1054
       +
           S::CreatedAt: subfs_record_state::IsUnset,

     

       1055
       +
       {

     

       1056
       +
           /// Set the `createdAt` field (required)

     

       1057
       +
           pub fn created_at(

     

       1058
       +
               mut self,

     

       1059
       +
               value: impl Into<jacquard_common::types::string::Datetime>,

     

       1060
       +
           ) -> SubfsRecordBuilder<'a, subfs_record_state::SetCreatedAt<S>> {

     

       1061
       +
               self.__unsafe_private_named.0 = ::core::option::Option::Some(value.into());

     

       1062
       +
               SubfsRecordBuilder {

     

       1063
       +
                   _phantom_state: ::core::marker::PhantomData,

     

       1064
       +
                   __unsafe_private_named: self.__unsafe_private_named,

     

       1065
       +
                   _phantom: ::core::marker::PhantomData,

     

       1066
       +
               }

     

       1067
       +
           }

     

       1068
       +
       }

     

       1069
       +
       

     

       1070
       +
       impl<'a, S: subfs_record_state::State> SubfsRecordBuilder<'a, S> {

     

       1071
       +
           /// Set the `fileCount` field (optional)

     

       1072
       +
           pub fn file_count(mut self, value: impl Into<Option<i64>>) -> Self {

     

       1073
       +
               self.__unsafe_private_named.1 = value.into();

     

       1074
       +
               self

     

       1075
       +
           }

     

       1076
       +
           /// Set the `fileCount` field to an Option value (optional)

     

       1077
       +
           pub fn maybe_file_count(mut self, value: Option<i64>) -> Self {

     

       1078
       +
               self.__unsafe_private_named.1 = value;

     

       1079
       +
               self

     

       1080
       +
           }

     

       1081
       +
       }

     

       1082
       +
       

     

       1083
       +
       impl<'a, S> SubfsRecordBuilder<'a, S>

     

       1084
       +
       where

     

       1085
       +
           S: subfs_record_state::State,

     

       1086
       +
           S::Root: subfs_record_state::IsUnset,

     

       1087
       +
       {

     

       1088
       +
           /// Set the `root` field (required)

     

       1089
       +
           pub fn root(

     

       1090
       +
               mut self,

     

       1091
       +
               value: impl Into<crate::place_wisp::subfs::Directory<'a>>,

     

       1092
       +
           ) -> SubfsRecordBuilder<'a, subfs_record_state::SetRoot<S>> {

     

       1093
       +
               self.__unsafe_private_named.2 = ::core::option::Option::Some(value.into());

     

       1094
       +
               SubfsRecordBuilder {

     

       1095
       +
                   _phantom_state: ::core::marker::PhantomData,

     

       1096
       +
                   __unsafe_private_named: self.__unsafe_private_named,

     

       1097
       +
                   _phantom: ::core::marker::PhantomData,

     

       1098
       +
               }

     

       1099
       +
           }

     

       1100
       +
       }

     

       1101
       +
       

     

       1102
       +
       impl<'a, S> SubfsRecordBuilder<'a, S>

     

       1103
       +
       where

     

       1104
       +
           S: subfs_record_state::State,

     

       1105
       +
           S::Root: subfs_record_state::IsSet,

     

       1106
       +
           S::CreatedAt: subfs_record_state::IsSet,

     

       1107
       +
       {

     

       1108
       +
           /// Build the final struct

     

       1109
       +
           pub fn build(self) -> SubfsRecord<'a> {

     

       1110
       +
               SubfsRecord {

     

       1111
       +
                   created_at: self.__unsafe_private_named.0.unwrap(),

     

       1112
       +
                   file_count: self.__unsafe_private_named.1,

     

       1113
       +
                   root: self.__unsafe_private_named.2.unwrap(),

     

       1114
       +
                   extra_data: Default::default(),

     

       1115
       +
               }

     

       1116
       +
           }

     

       1117
       +
           /// Build the final struct with custom extra_data

     

       1118
       +
           pub fn build_with_data(

     

       1119
       +
               self,

     

       1120
       +
               extra_data: std::collections::BTreeMap<

     

       1121
       +
                   jacquard_common::smol_str::SmolStr,

     

       1122
       +
                   jacquard_common::types::value::Data<'a>,

     

       1123
       +
               >,

     

       1124
       +
           ) -> SubfsRecord<'a> {

     

       1125
       +
               SubfsRecord {

     

       1126
       +
                   created_at: self.__unsafe_private_named.0.unwrap(),

     

       1127
       +
                   file_count: self.__unsafe_private_named.1,

     

       1128
       +
                   root: self.__unsafe_private_named.2.unwrap(),

     

       1129
       +
                   extra_data: Some(extra_data),

     

       1130
       +
               }

     

       1131
       +
           }

     

       1132
       +
       }

     

       1133
       +
       

     

       1134
       +
       impl<'a> SubfsRecord<'a> {

     

       1135
       +
           pub fn uri(

     

       1136
       +
               uri: impl Into<jacquard_common::CowStr<'a>>,

     

       1137
       +
           ) -> Result<

     

       1138
       +
               jacquard_common::types::uri::RecordUri<'a, SubfsRecordRecord>,

     

       1139
       +
               jacquard_common::types::uri::UriError,

     

       1140
       +
           > {

     

       1141
       +
               jacquard_common::types::uri::RecordUri::try_from_uri(

     

       1142
       +
                   jacquard_common::types::string::AtUri::new_cow(uri.into())?,

     

       1143
       +
               )

     

       1144
       +
           }

     

       1145
       +
       }

     

       1146
       +
       

     

       1147
       +
       /// Typed wrapper for GetRecord response with this collection's record type.

     

       1148
       +
       #[derive(

     

       1149
       +
           serde::Serialize,

     

       1150
       +
           serde::Deserialize,

     

       1151
       +
           Debug,

     

       1152
       +
           Clone,

     

       1153
       +
           PartialEq,

     

       1154
       +
           Eq,

     

       1155
       +
           jacquard_derive::IntoStatic

     

       1156
       +
       )]

     

       1157
       +
       #[serde(rename_all = "camelCase")]

     

       1158
       +
       pub struct SubfsRecordGetRecordOutput<'a> {

     

       1159
       +
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       1160
       +
           #[serde(borrow)]

     

       1161
       +
           pub cid: std::option::Option<jacquard_common::types::string::Cid<'a>>,

     

       1162
       +
           #[serde(borrow)]

     

       1163
       +
           pub uri: jacquard_common::types::string::AtUri<'a>,

     

       1164
       +
           #[serde(borrow)]

     

       1165
       +
           pub value: SubfsRecord<'a>,

     

       1166
       +
       }

     

       1167
       +
       

     

       1168
       +
       impl From<SubfsRecordGetRecordOutput<'_>> for SubfsRecord<'_> {

     

       1169
       +
           fn from(output: SubfsRecordGetRecordOutput<'_>) -> Self {

     

       1170
       +
               use jacquard_common::IntoStatic;

     

       1171
       +
               output.value.into_static()

     

       1172
       +
           }

     

       1173
       +
       }

     

       1174
       +
       

     

       1175
       +
       impl jacquard_common::types::collection::Collection for SubfsRecord<'_> {

     

       1176
       +
           const NSID: &'static str = "place.wisp.subfs";

     

       1177
       +
           type Record = SubfsRecordRecord;

     

       1178
       +
       }

     

       1179
       +
       

     

       1180
       +
       /// Marker type for deserializing records from this collection.

     

       1181
       +
       #[derive(Debug, serde::Serialize, serde::Deserialize)]

     

       1182
       +
       pub struct SubfsRecordRecord;

     

       1183
       +
       impl jacquard_common::xrpc::XrpcResp for SubfsRecordRecord {

     

       1184
       +
           const NSID: &'static str = "place.wisp.subfs";

     

       1185
       +
           const ENCODING: &'static str = "application/json";

     

       1186
       +
           type Output<'de> = SubfsRecordGetRecordOutput<'de>;

     

       1187
       +
           type Err<'de> = jacquard_common::types::collection::RecordError<'de>;

     

       1188
       +
       }

     

       1189
       +
       

     

       1190
       +
       impl jacquard_common::types::collection::Collection for SubfsRecordRecord {

     

       1191
       +
           const NSID: &'static str = "place.wisp.subfs";

     

       1192
       +
           type Record = SubfsRecordRecord;

     

       1193
       +
       }

     

       1194
       +
       

     

       1195
       +
       impl<'a> ::jacquard_lexicon::schema::LexiconSchema for SubfsRecord<'a> {

     

       1196
       +
           fn nsid() -> &'static str {

     

       1197
       +
               "place.wisp.subfs"

     

       1198
       +
           }

     

       1199
       +
           fn def_name() -> &'static str {

     

       1200
       +
               "main"

     

       1201
       +
           }

     

       1202
       +
           fn lexicon_doc() -> ::jacquard_lexicon::lexicon::LexiconDoc<'static> {

     

       1203
       +
               lexicon_doc_place_wisp_subfs()

     

       1204
       +
           }

     

       1205
       +
           fn validate(

     

       1206
       +
               &self,

     

       1207
       +
           ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> {

     

       1208
       +
               if let Some(ref value) = self.file_count {

     

       1209
       +
                   if *value > 1000i64 {

     

       1210
       +
                       return Err(::jacquard_lexicon::validation::ConstraintError::Maximum {

     

       1211
       +
                           path: ::jacquard_lexicon::validation::ValidationPath::from_field(

     

       1212
       +
                               "file_count",

     

       1213
       +
                           ),

     

       1214
       +
                           max: 1000i64,

     

       1215
       +
                           actual: *value,

     

       1216
       +
                       });

     

       1217
       +
                   }

     

       1218
       +
               }

     

       1219
       +
               if let Some(ref value) = self.file_count {

     

       1220
       +
                   if *value < 0i64 {

     

       1221
       +
                       return Err(::jacquard_lexicon::validation::ConstraintError::Minimum {

     

       1222
       +
                           path: ::jacquard_lexicon::validation::ValidationPath::from_field(

     

       1223
       +
                               "file_count",

     

       1224
       +
                           ),

     

       1225
       +
                           min: 0i64,

     

       1226
       +
                           actual: *value,

     

       1227
       +
                       });

     

       1228
       +
                   }

     

       1229
       +
               }

     

       1230
       +
               Ok(())

     

       1231
       +
           }

     

       1232
       +
       }

     

       1233
       +
       

     

       1234
       +
       #[jacquard_derive::lexicon]

     

       1235
       +
       #[derive(

     

       1236
       +
           serde::Serialize,

     

       1237
       +
           serde::Deserialize,

     

       1238
       +
           Debug,

     

       1239
       +
           Clone,

     

       1240
       +
           PartialEq,

     

       1241
       +
           Eq,

     

       1242
       +
           jacquard_derive::IntoStatic

     

       1243
       +
       )]

     

       1244
       +
       #[serde(rename_all = "camelCase")]

     

       1245
       +
       pub struct Subfs<'a> {

     

       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
       +
           #[serde(borrow)]

     

       1248
       +
           pub subject: jacquard_common::types::string::AtUri<'a>,

     

       1249
       +
           #[serde(borrow)]

     

       1250
       +
           pub r#type: jacquard_common::CowStr<'a>,

     

       1251
       +
       }

     

       1252
       +
       

     

       1253
       +
       pub mod subfs_state {

     

       1254
       +
       

     

       1255
       +
           pub use crate::builder_types::{Set, Unset, IsSet, IsUnset};

     

       1256
       +
           #[allow(unused)]

     

       1257
       +
           use ::core::marker::PhantomData;

     

       1258
       +
           mod sealed {

     

       1259
       +
               pub trait Sealed {}

     

       1260
       +
           }

     

       1261
       +
           /// State trait tracking which required fields have been set

     

       1262
       +
           pub trait State: sealed::Sealed {

     

       1263
       +
               type Subject;

     

       1264
       +
               type Type;

     

       1265
       +
           }

     

       1266
       +
           /// Empty state - all required fields are unset

     

       1267
       +
           pub struct Empty(());

     

       1268
       +
           impl sealed::Sealed for Empty {}

     

       1269
       +
           impl State for Empty {

     

       1270
       +
               type Subject = Unset;

     

       1271
       +
               type Type = Unset;

     

       1272
       +
           }

     

       1273
       +
           ///State transition - sets the `subject` field to Set

     

       1274
       +
           pub struct SetSubject<S: State = Empty>(PhantomData<fn() -> S>);

     

       1275
       +
           impl<S: State> sealed::Sealed for SetSubject<S> {}

     

       1276
       +
           impl<S: State> State for SetSubject<S> {

     

       1277
       +
               type Subject = Set<members::subject>;

     

       1278
       +
               type Type = S::Type;

     

       1279
       +
           }

     

       1280
       +
           ///State transition - sets the `type` field to Set

     

       1281
       +
           pub struct SetType<S: State = Empty>(PhantomData<fn() -> S>);

     

       1282
       +
           impl<S: State> sealed::Sealed for SetType<S> {}

     

       1283
       +
           impl<S: State> State for SetType<S> {

     

       1284
       +
               type Subject = S::Subject;

     

       1285
       +
               type Type = Set<members::r#type>;

     

       1286
       +
           }

     

       1287
       +
           /// Marker types for field names

     

       1288
       +
           #[allow(non_camel_case_types)]

     

       1289
       +
           pub mod members {

     

       1290
       +
               ///Marker type for the `subject` field

     

       1291
       +
               pub struct subject(());

     

       1292
       +
               ///Marker type for the `type` field

     

       1293
       +
               pub struct r#type(());

     

       1294
       +
           }

     

       1295
       +
       }

     

       1296
       +
       

     

       1297
       +
       /// Builder for constructing an instance of this type

     

       1298
       +
       pub struct SubfsBuilder<'a, S: subfs_state::State> {

     

       1299
       +
           _phantom_state: ::core::marker::PhantomData<fn() -> S>,

     

       1300
       +
           __unsafe_private_named: (

     

       1301
       +
               ::core::option::Option<jacquard_common::types::string::AtUri<'a>>,

     

       1302
       +
               ::core::option::Option<jacquard_common::CowStr<'a>>,

     

       1303
       +
           ),

     

       1304
       +
           _phantom: ::core::marker::PhantomData<&'a ()>,

     

       1305
       +
       }

     

       1306
       +
       

     

       1307
       +
       impl<'a> Subfs<'a> {

     

       1308
       +
           /// Create a new builder for this type

     

       1309
       +
           pub fn new() -> SubfsBuilder<'a, subfs_state::Empty> {

     

       1310
       +
               SubfsBuilder::new()

     

       1311
       +
           }

     

       1312
       +
       }

     

       1313
       +
       

     

       1314
       +
       impl<'a> SubfsBuilder<'a, subfs_state::Empty> {

     

       1315
       +
           /// Create a new builder with all fields unset

     

       1316
       +
           pub fn new() -> Self {

     

       1317
       +
               SubfsBuilder {

     

       1318
       +
                   _phantom_state: ::core::marker::PhantomData,

     

       1319
       +
                   __unsafe_private_named: (None, None),

     

       1320
       +
                   _phantom: ::core::marker::PhantomData,

     

       1321
       +
               }

     

       1322
       +
           }

     

       1323
       +
       }

     

       1324
       +
       

     

       1325
       +
       impl<'a, S> SubfsBuilder<'a, S>

     

       1326
       +
       where

     

       1327
       +
           S: subfs_state::State,

     

       1328
       +
           S::Subject: subfs_state::IsUnset,

     

       1329
       +
       {

     

       1330
       +
           /// Set the `subject` field (required)

     

       1331
       +
           pub fn subject(

     

       1332
       +
               mut self,

     

       1333
       +
               value: impl Into<jacquard_common::types::string::AtUri<'a>>,

     

       1334
       +
           ) -> SubfsBuilder<'a, subfs_state::SetSubject<S>> {

     

       1335
       +
               self.__unsafe_private_named.0 = ::core::option::Option::Some(value.into());

     

       1336
       +
               SubfsBuilder {

     

       1337
       +
                   _phantom_state: ::core::marker::PhantomData,

     

       1338
       +
                   __unsafe_private_named: self.__unsafe_private_named,

     

       1339
       +
                   _phantom: ::core::marker::PhantomData,

     

       1340
       +
               }

     

       1341
       +
           }

     

       1342
       +
       }

     

       1343
       +
       

     

       1344
       +
       impl<'a, S> SubfsBuilder<'a, S>

     

       1345
       +
       where

     

       1346
       +
           S: subfs_state::State,

     

       1347
       +
           S::Type: subfs_state::IsUnset,

     

       1348
       +
       {

     

       1349
       +
           /// Set the `type` field (required)

     

       1350
       +
           pub fn r#type(

     

       1351
       +
               mut self,

     

       1352
       +
               value: impl Into<jacquard_common::CowStr<'a>>,

     

       1353
       +
           ) -> SubfsBuilder<'a, subfs_state::SetType<S>> {

     

       1354
       +
               self.__unsafe_private_named.1 = ::core::option::Option::Some(value.into());

     

       1355
       +
               SubfsBuilder {

     

       1356
       +
                   _phantom_state: ::core::marker::PhantomData,

     

       1357
       +
                   __unsafe_private_named: self.__unsafe_private_named,

     

       1358
       +
                   _phantom: ::core::marker::PhantomData,

     

       1359
       +
               }

     

       1360
       +
           }

     

       1361
       +
       }

     

       1362
       +
       

     

       1363
       +
       impl<'a, S> SubfsBuilder<'a, S>

     

       1364
       +
       where

     

       1365
       +
           S: subfs_state::State,

     

       1366
       +
           S::Subject: subfs_state::IsSet,

     

       1367
       +
           S::Type: subfs_state::IsSet,

     

       1368
       +
       {

     

       1369
       +
           /// Build the final struct

     

       1370
       +
           pub fn build(self) -> Subfs<'a> {

     

       1371
       +
               Subfs {

     

       1372
       +
                   subject: self.__unsafe_private_named.0.unwrap(),

     

       1373
       +
                   r#type: self.__unsafe_private_named.1.unwrap(),

     

       1374
       +
                   extra_data: Default::default(),

     

       1375
       +
               }

     

       1376
       +
           }

     

       1377
       +
           /// Build the final struct with custom extra_data

     

       1378
       +
           pub fn build_with_data(

     

       1379
       +
               self,

     

       1380
       +
               extra_data: std::collections::BTreeMap<

     

       1381
       +
                   jacquard_common::smol_str::SmolStr,

     

       1382
       +
                   jacquard_common::types::value::Data<'a>,

     

       1383
       +
               >,

     

       1384
       +
           ) -> Subfs<'a> {

     

       1385
       +
               Subfs {

     

       1386
       +
                   subject: self.__unsafe_private_named.0.unwrap(),

     

       1387
       +
                   r#type: self.__unsafe_private_named.1.unwrap(),

     

       1388
       +
                   extra_data: Some(extra_data),

     

       1389
       +
               }

     

       1390
       +
           }

     

       1391
       +
       }

     

       1392
       +
       

     

       1393
       +
       impl<'a> ::jacquard_lexicon::schema::LexiconSchema for Subfs<'a> {

     

       1394
       +
           fn nsid() -> &'static str {

     

       1395
       +
               "place.wisp.subfs"

     

       1396
       +
           }

     

       1397
       +
           fn def_name() -> &'static str {

     

       1398
       +
               "subfs"

     

       1399
       +
           }

     

       1400
       +
           fn lexicon_doc() -> ::jacquard_lexicon::lexicon::LexiconDoc<'static> {

     

       1401
       +
               lexicon_doc_place_wisp_subfs()

     

       1402
       +
           }

     

       1403
       +
           fn validate(

     

       1404
       +
               &self,

     

       1405
       +
           ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> {

     

       1406
       +
               Ok(())

     

       1407
       +
           }

     

       1408
       +
       }

cli/crates/lexicons/src/place_wisp.rs

···

       1
       +
       // @generated by jacquard-lexicon. DO NOT EDIT.

     

       2
       +
       //

     

       3
       +
       // This file was automatically generated from Lexicon schemas.

     

       4
       +
       // Any manual changes will be overwritten on the next regeneration.

     

       5
       +
       

     

       6
       +
       pub mod fs;

     

       7
       +
       pub mod settings;

     

       8
       +
       pub mod subfs;

+1 -1

cli/src/blob_map.rs

···

       2
        
       use jacquard_common::IntoStatic;

     

       3
        
       use std::collections::HashMap;

     

       4
        
       

     

       5
       -
       use crate::place_wisp::fs::{Directory, EntryNode};

     

       6
        
       

     

       7
        
       /// Extract blob information from a directory tree

     

       8
        
       /// Returns a map of file paths to their blob refs and CIDs

···

       2
        
       use jacquard_common::IntoStatic;

     

       3
        
       use std::collections::HashMap;

     

       4
        
       

     

       5
       +
       use wisp_lexicons::place_wisp::fs::{Directory, EntryNode};

     

       6
        
       

     

       7
        
       /// Extract blob information from a directory tree

     

       8
        
       /// Returns a map of file paths to their blob refs and CIDs

-43

cli/src/builder_types.rs

···

       1
       -
       // @generated by jacquard-lexicon. DO NOT EDIT.

     

       2
       -
       //

     

       3
       -
       // This file was automatically generated from Lexicon schemas.

     

       4
       -
       // Any manual changes will be overwritten on the next regeneration.

     

       5
       -
       

     

       6
       -
       /// Marker type indicating a builder field has been set

     

       7
       -
       pub struct Set<T>(pub T);

     

       8
       -
       impl<T> Set<T> {

     

       9
       -
           /// Extract the inner value

     

       10
       -
           #[inline]

     

       11
       -
           pub fn into_inner(self) -> T {

     

       12
       -
               self.0

     

       13
       -
           }

     

       14
       -
       }

     

       15
       -
       

     

       16
       -
       /// Marker type indicating a builder field has not been set

     

       17
       -
       pub struct Unset;

     

       18
       -
       /// Trait indicating a builder field is set (has a value)

     

       19
       -
       #[rustversion::attr(

     

       20
       -
           since(1.78.0),

     

       21
       -
           diagnostic::on_unimplemented(

     

       22
       -
               message = "the field `{Self}` was not set, but this method requires it to be set",

     

       23
       -
               label = "the field `{Self}` was not set"

     

       24
       -
           )

     

       25
       -
       )]

     

       26
       -
       pub trait IsSet: private::Sealed {}

     

       27
       -
       /// Trait indicating a builder field is unset (no value yet)

     

       28
       -
       #[rustversion::attr(

     

       29
       -
           since(1.78.0),

     

       30
       -
           diagnostic::on_unimplemented(

     

       31
       -
               message = "the field `{Self}` was already set, but this method requires it to be unset",

     

       32
       -
               label = "the field `{Self}` was already set"

     

       33
       -
           )

     

       34
       -
       )]

     

       35
       -
       pub trait IsUnset: private::Sealed {}

     

       36
       -
       impl<T> IsSet for Set<T> {}

     

       37
       -
       impl IsUnset for Unset {}

     

       38
       -
       mod private {

     

       39
       -
           /// Sealed trait to prevent external implementations

     

       40
       -
           pub trait Sealed {}

     

       41
       -
           impl<T> Sealed for super::Set<T> {}

     

       42
       -
           impl Sealed for super::Unset {}

     

       43
       -
       }

-9

cli/src/lib.rs

···

       1
       -
       // @generated by jacquard-lexicon. DO NOT EDIT.

     

       2
       -
       //

     

       3
       -
       // This file was automatically generated from Lexicon schemas.

     

       4
       -
       // Any manual changes will be overwritten on the next regeneration.

     

       5
       -
       

     

       6
       -
       pub mod builder_types;

     

       7
       -
       

     

       8
       -
       #[cfg(feature = "place_wisp")]

     

       9
       -
       pub mod place_wisp;

+28 -31

cli/src/main.rs

···

       1
       -
       mod builder_types;

     

       2
       -
       mod place_wisp;

     

       3
        
       mod cid;

     

       4
        
       mod blob_map;

     

       5
        
       mod metadata;

     
···

       28
        
       use futures::stream::{self, StreamExt};

     

       29
        
       use indicatif::{ProgressBar, ProgressStyle, MultiProgress};

     

       30
        
       

     

       31
       -
       use place_wisp::fs::*;

     

       32
       -
       use place_wisp::settings::*;

     

       33
        
       

     

       34
        
       /// Maximum number of concurrent file uploads to the PDS

     

       35
        
       const MAX_CONCURRENT_UPLOADS: usize = 2;

     
···

       43
        
       struct Args {

     

       44
        
           #[command(subcommand)]

     

       45
        
           command: Option<Commands>,

     

       46
       -
           

     

       47
        
           // Deploy arguments (when no subcommand is specified)

     

       48
        
           /// Handle (e.g., alice.bsky.social), DID, or PDS URL

     

       49
       -
           #[arg(global = true, conflicts_with = "command")]

     

       50
        
           input: Option<CowStr<'static>>,

     

       51
        
       

     

       52
        
           /// Path to the directory containing your static site

     

       53
       -
           #[arg(short, long, global = true, conflicts_with = "command")]

     

       54
        
           path: Option<PathBuf>,

     

       55
        
       

     

       56
        
           /// Site name (defaults to directory name)

     

       57
       -
           #[arg(short, long, global = true, conflicts_with = "command")]

     

       58
        
           site: Option<String>,

     

       59
        
       

     

       60
        
           /// Path to auth store file

     

       61
       -
           #[arg(long, global = true, conflicts_with = "command")]

     

       62
        
           store: Option<String>,

     

       63
        
       

     

       64
        
           /// App Password for authentication

     

       65
       -
           #[arg(long, global = true, conflicts_with = "command")]

     

       66
        
           password: Option<CowStr<'static>>,

     

       67
        
       

     

       68
        
           /// Enable directory listing mode for paths without index files

     

       69
       -
           #[arg(long, global = true, conflicts_with = "command")]

     

       70
        
           directory: bool,

     

       71
        
       

     

       72
        
           /// Enable SPA mode (serve index.html for all routes)

     

       73
       -
           #[arg(long, global = true, conflicts_with = "command")]

     

       74
        
           spa: bool,

     

       75
        
       

     

       76
        
           /// Skip confirmation prompts (automatically accept warnings)

     

       77
       -
           #[arg(short = 'y', long, global = true, conflicts_with = "command")]

     

       78
        
           yes: bool,

     

       79
        
       }

     

       80
        
       

     
···

       124
        
       

     

       125
        
               /// Output directory for the downloaded site

     

       126
        
               #[arg(short, long, default_value = ".")]

     

       127
       -
               output: PathBuf,

     

       128
        
           },

     

       129
        
           /// Serve a site locally with real-time firehose updates

     

       130
        
           Serve {

     
···

       137
        
       

     

       138
        
               /// Output directory for the site files

     

       139
        
               #[arg(short, long, default_value = ".")]

     

       140
       -
               output: PathBuf,

     

       141
        
       

     

       142
        
               /// Port to serve on

     

       143
       -
               #[arg(short, long, default_value = "8080")]

     

       144
        
               port: u16,

     

       145
        
           },

     

       146
        
       }

     
···

       158
        
                       run_with_oauth(input, store, path, site, directory, spa, yes).await

     

       159
        
                   }

     

       160
        
               }

     

       161
       -
               Some(Commands::Pull { input, site, output }) => {

     

       162
       -
                   pull::pull_site(input, CowStr::from(site), output).await

     

       163
        
               }

     

       164
       -
               Some(Commands::Serve { input, site, output, port }) => {

     

       165
       -
                   serve::serve_site(input, CowStr::from(site), output, port).await

     

       166
        
               }

     

       167
        
               None => {

     

       168
        
                   // Legacy mode: if input is provided, assume deploy command

     
···

       512
        
                               let chunk_file_count = subfs_utils::count_files_in_directory(chunk);

     

       513
        
                               let chunk_size = subfs_utils::estimate_directory_size(chunk);

     

       514
        
       

     

       515
       -
                               let chunk_manifest = crate::place_wisp::subfs::SubfsRecord::new()

     

       516
        
                                   .root(convert_fs_dir_to_subfs_dir(chunk.clone()))

     

       517
        
                                   .file_count(Some(chunk_file_count as i64))

     

       518
        
                                   .created_at(Datetime::now())

     
···

       535
        
                           // Each chunk reference MUST have flat: true to merge chunk contents

     

       536
        
                           println!("  → Creating parent subfs with {} chunk references...", chunk_uris.len());

     

       537
        
                           use jacquard_common::CowStr;

     

       538
       -
                           use crate::place_wisp::fs::{Subfs};

     

       539
        
       

     

       540
        
                           // Convert to fs::Subfs (which has the 'flat' field) instead of subfs::Subfs

     

       541
        
                           let parent_entries_fs: Vec<Entry> = chunk_uris.iter().enumerate().map(|(i, (uri, _))| {

     
···

       565
        
                           let parent_tid = Tid::now_0();

     

       566
        
                           let parent_rkey = parent_tid.to_string();

     

       567
        
       

     

       568
       -
                           let parent_manifest = crate::place_wisp::subfs::SubfsRecord::new()

     

       569
        
                               .root(parent_root_subfs)

     

       570
        
                               .file_count(Some(largest_dir.file_count as i64))

     

       571
        
                               .created_at(Datetime::now())

     
···

       584
        
                           let subfs_tid = Tid::now_0();

     

       585
        
                           let subfs_rkey = subfs_tid.to_string();

     

       586
        
       

     

       587
       -
                           let subfs_manifest = crate::place_wisp::subfs::SubfsRecord::new()

     

       588
        
                               .root(convert_fs_dir_to_subfs_dir(largest_dir.directory.clone()))

     

       589
        
                               .file_count(Some(largest_dir.file_count as i64))

     

       590
        
                               .created_at(Datetime::now())

     
···

       952
        
       

     

       953
        
       /// Convert fs::Directory to subfs::Directory

     

       954
        
       /// They have the same structure, but different types

     

       955
       -
       fn convert_fs_dir_to_subfs_dir(fs_dir: place_wisp::fs::Directory<'static>) -> place_wisp::subfs::Directory<'static> {

     

       956
       -
           use place_wisp::subfs::{Directory as SubfsDirectory, Entry as SubfsEntry, EntryNode as SubfsEntryNode, File as SubfsFile};

     

       957
        
       

     

       958
        
           let subfs_entries: Vec<SubfsEntry> = fs_dir.entries.into_iter().map(|entry| {

     

       959
        
               let node = match entry.node {

     

       960
       -
                   place_wisp::fs::EntryNode::File(file) => {

     

       961
        
                       SubfsEntryNode::File(Box::new(SubfsFile::new()

     

       962
        
                           .r#type(file.r#type)

     

       963
        
                           .blob(file.blob)

     
···

       966
        
                           .base64(file.base64)

     

       967
        
                           .build()))

     

       968
        
                   }

     

       969
       -
                   place_wisp::fs::EntryNode::Directory(dir) => {

     

       970
        
                       SubfsEntryNode::Directory(Box::new(convert_fs_dir_to_subfs_dir(*dir)))

     

       971
        
                   }

     

       972
       -
                   place_wisp::fs::EntryNode::Subfs(subfs) => {

     

       973
        
                       // Nested subfs in the directory we're converting

     

       974
        
                       // Note: subfs::Subfs doesn't have the 'flat' field - that's only in fs::Subfs

     

       975
       -
                       SubfsEntryNode::Subfs(Box::new(place_wisp::subfs::Subfs::new()

     

       976
        
                           .r#type(subfs.r#type)

     

       977
        
                           .subject(subfs.subject)

     

       978
        
                           .build()))

     

       979
        
                   }

     

       980
       -
                   place_wisp::fs::EntryNode::Unknown(unknown) => {

     

       981
        
                       SubfsEntryNode::Unknown(unknown)

     

       982
        
                   }

     

       983
        
               };

···

       0
        
       
     

       0
        
       
     

       1
        
       mod cid;

     

       2
        
       mod blob_map;

     

       3
        
       mod metadata;

     
···

       26
        
       use futures::stream::{self, StreamExt};

     

       27
        
       use indicatif::{ProgressBar, ProgressStyle, MultiProgress};

     

       28
        
       

     

       29
       +
       use wisp_lexicons::place_wisp::fs::*;

     

       30
       +
       use wisp_lexicons::place_wisp::settings::*;

     

       31
        
       

     

       32
        
       /// Maximum number of concurrent file uploads to the PDS

     

       33
        
       const MAX_CONCURRENT_UPLOADS: usize = 2;

     
···

       41
        
       struct Args {

     

       42
        
           #[command(subcommand)]

     

       43
        
           command: Option<Commands>,

     

       44
       +
       

     

       45
        
           // Deploy arguments (when no subcommand is specified)

     

       46
        
           /// Handle (e.g., alice.bsky.social), DID, or PDS URL

     

       0
        
       
     

       47
        
           input: Option<CowStr<'static>>,

     

       48
        
       

     

       49
        
           /// Path to the directory containing your static site

     

       50
       +
           #[arg(short, long)]

     

       51
        
           path: Option<PathBuf>,

     

       52
        
       

     

       53
        
           /// Site name (defaults to directory name)

     

       54
       +
           #[arg(short, long)]

     

       55
        
           site: Option<String>,

     

       56
        
       

     

       57
        
           /// Path to auth store file

     

       58
       +
           #[arg(long)]

     

       59
        
           store: Option<String>,

     

       60
        
       

     

       61
        
           /// App Password for authentication

     

       62
       +
           #[arg(long)]

     

       63
        
           password: Option<CowStr<'static>>,

     

       64
        
       

     

       65
        
           /// Enable directory listing mode for paths without index files

     

       66
       +
           #[arg(long)]

     

       67
        
           directory: bool,

     

       68
        
       

     

       69
        
           /// Enable SPA mode (serve index.html for all routes)

     

       70
       +
           #[arg(long)]

     

       71
        
           spa: bool,

     

       72
        
       

     

       73
        
           /// Skip confirmation prompts (automatically accept warnings)

     

       74
       +
           #[arg(short = 'y', long)]

     

       75
        
           yes: bool,

     

       76
        
       }

     

       77
        
       

     
···

       121
        
       

     

       122
        
               /// Output directory for the downloaded site

     

       123
        
               #[arg(short, long, default_value = ".")]

     

       124
       +
               path: PathBuf,

     

       125
        
           },

     

       126
        
           /// Serve a site locally with real-time firehose updates

     

       127
        
           Serve {

     
···

       134
        
       

     

       135
        
               /// Output directory for the site files

     

       136
        
               #[arg(short, long, default_value = ".")]

     

       137
       +
               path: PathBuf,

     

       138
        
       

     

       139
        
               /// Port to serve on

     

       140
       +
               #[arg(short = 'P', long, default_value = "8080")]

     

       141
        
               port: u16,

     

       142
        
           },

     

       143
        
       }

     
···

       155
        
                       run_with_oauth(input, store, path, site, directory, spa, yes).await

     

       156
        
                   }

     

       157
        
               }

     

       158
       +
               Some(Commands::Pull { input, site, path }) => {

     

       159
       +
                   pull::pull_site(input, CowStr::from(site), path).await

     

       160
        
               }

     

       161
       +
               Some(Commands::Serve { input, site, path, port }) => {

     

       162
       +
                   serve::serve_site(input, CowStr::from(site), path, port).await

     

       163
        
               }

     

       164
        
               None => {

     

       165
        
                   // Legacy mode: if input is provided, assume deploy command

     
···

       509
        
                               let chunk_file_count = subfs_utils::count_files_in_directory(chunk);

     

       510
        
                               let chunk_size = subfs_utils::estimate_directory_size(chunk);

     

       511
        
       

     

       512
       +
                               let chunk_manifest = wisp_lexicons::place_wisp::subfs::SubfsRecord::new()

     

       513
        
                                   .root(convert_fs_dir_to_subfs_dir(chunk.clone()))

     

       514
        
                                   .file_count(Some(chunk_file_count as i64))

     

       515
        
                                   .created_at(Datetime::now())

     
···

       532
        
                           // Each chunk reference MUST have flat: true to merge chunk contents

     

       533
        
                           println!("  → Creating parent subfs with {} chunk references...", chunk_uris.len());

     

       534
        
                           use jacquard_common::CowStr;

     

       535
       +
                           use wisp_lexicons::place_wisp::fs::{Subfs};

     

       536
        
       

     

       537
        
                           // Convert to fs::Subfs (which has the 'flat' field) instead of subfs::Subfs

     

       538
        
                           let parent_entries_fs: Vec<Entry> = chunk_uris.iter().enumerate().map(|(i, (uri, _))| {

     
···

       562
        
                           let parent_tid = Tid::now_0();

     

       563
        
                           let parent_rkey = parent_tid.to_string();

     

       564
        
       

     

       565
       +
                           let parent_manifest = wisp_lexicons::place_wisp::subfs::SubfsRecord::new()

     

       566
        
                               .root(parent_root_subfs)

     

       567
        
                               .file_count(Some(largest_dir.file_count as i64))

     

       568
        
                               .created_at(Datetime::now())

     
···

       581
        
                           let subfs_tid = Tid::now_0();

     

       582
        
                           let subfs_rkey = subfs_tid.to_string();

     

       583
        
       

     

       584
       +
                           let subfs_manifest = wisp_lexicons::place_wisp::subfs::SubfsRecord::new()

     

       585
        
                               .root(convert_fs_dir_to_subfs_dir(largest_dir.directory.clone()))

     

       586
        
                               .file_count(Some(largest_dir.file_count as i64))

     

       587
        
                               .created_at(Datetime::now())

     
···

       949
        
       

     

       950
        
       /// Convert fs::Directory to subfs::Directory

     

       951
        
       /// They have the same structure, but different types

     

       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
       +
           use wisp_lexicons::place_wisp::subfs::{Directory as SubfsDirectory, Entry as SubfsEntry, EntryNode as SubfsEntryNode, File as SubfsFile};

     

       954
        
       

     

       955
        
           let subfs_entries: Vec<SubfsEntry> = fs_dir.entries.into_iter().map(|entry| {

     

       956
        
               let node = match entry.node {

     

       957
       +
                   wisp_lexicons::place_wisp::fs::EntryNode::File(file) => {

     

       958
        
                       SubfsEntryNode::File(Box::new(SubfsFile::new()

     

       959
        
                           .r#type(file.r#type)

     

       960
        
                           .blob(file.blob)

     
···

       963
        
                           .base64(file.base64)

     

       964
        
                           .build()))

     

       965
        
                   }

     

       966
       +
                   wisp_lexicons::place_wisp::fs::EntryNode::Directory(dir) => {

     

       967
        
                       SubfsEntryNode::Directory(Box::new(convert_fs_dir_to_subfs_dir(*dir)))

     

       968
        
                   }

     

       969
       +
                   wisp_lexicons::place_wisp::fs::EntryNode::Subfs(subfs) => {

     

       970
        
                       // Nested subfs in the directory we're converting

     

       971
        
                       // Note: subfs::Subfs doesn't have the 'flat' field - that's only in fs::Subfs

     

       972
       +
                       SubfsEntryNode::Subfs(Box::new(wisp_lexicons::place_wisp::subfs::Subfs::new()

     

       973
        
                           .r#type(subfs.r#type)

     

       974
        
                           .subject(subfs.subject)

     

       975
        
                           .build()))

     

       976
        
                   }

     

       977
       +
                   wisp_lexicons::place_wisp::fs::EntryNode::Unknown(unknown) => {

     

       978
        
                       SubfsEntryNode::Unknown(unknown)

     

       979
        
                   }

     

       980
        
               };

-9

cli/src/mod.rs

···

       1
       -
       // @generated by jacquard-lexicon. DO NOT EDIT.

     

       2
       -
       //

     

       3
       -
       // This file was automatically generated from Lexicon schemas.

     

       4
       -
       // Any manual changes will be overwritten on the next regeneration.

     

       5
       -
       

     

       6
       -
       pub mod builder_types;

     

       7
       -
       

     

       8
       -
       #[cfg(feature = "place_wisp")]

     

       9
       -
       pub mod place_wisp;

-1490

cli/src/place_wisp/fs.rs

···

       1
       -
       // @generated by jacquard-lexicon. DO NOT EDIT.

     

       2
       -
       //

     

       3
       -
       // Lexicon: place.wisp.fs

     

       4
       -
       //

     

       5
       -
       // This file was automatically generated from Lexicon schemas.

     

       6
       -
       // Any manual changes will be overwritten on the next regeneration.

     

       7
       -
       

     

       8
       -
       #[jacquard_derive::lexicon]

     

       9
       -
       #[derive(

     

       10
       -
           serde::Serialize,

     

       11
       -
           serde::Deserialize,

     

       12
       -
           Debug,

     

       13
       -
           Clone,

     

       14
       -
           PartialEq,

     

       15
       -
           Eq,

     

       16
       -
           jacquard_derive::IntoStatic

     

       17
       -
       )]

     

       18
       -
       #[serde(rename_all = "camelCase")]

     

       19
       -
       pub struct Directory<'a> {

     

       20
       -
           #[serde(borrow)]

     

       21
       -
           pub entries: Vec<crate::place_wisp::fs::Entry<'a>>,

     

       22
       -
           #[serde(borrow)]

     

       23
       -
           pub r#type: jacquard_common::CowStr<'a>,

     

       24
       -
       }

     

       25
       -
       

     

       26
       -
       pub mod directory_state {

     

       27
       -
       

     

       28
       -
           pub use crate::builder_types::{Set, Unset, IsSet, IsUnset};

     

       29
       -
           #[allow(unused)]

     

       30
       -
           use ::core::marker::PhantomData;

     

       31
       -
           mod sealed {

     

       32
       -
               pub trait Sealed {}

     

       33
       -
           }

     

       34
       -
           /// State trait tracking which required fields have been set

     

       35
       -
           pub trait State: sealed::Sealed {

     

       36
       -
               type Type;

     

       37
       -
               type Entries;

     

       38
       -
           }

     

       39
       -
           /// Empty state - all required fields are unset

     

       40
       -
           pub struct Empty(());

     

       41
       -
           impl sealed::Sealed for Empty {}

     

       42
       -
           impl State for Empty {

     

       43
       -
               type Type = Unset;

     

       44
       -
               type Entries = Unset;

     

       45
       -
           }

     

       46
       -
           ///State transition - sets the `type` field to Set

     

       47
       -
           pub struct SetType<S: State = Empty>(PhantomData<fn() -> S>);

     

       48
       -
           impl<S: State> sealed::Sealed for SetType<S> {}

     

       49
       -
           impl<S: State> State for SetType<S> {

     

       50
       -
               type Type = Set<members::r#type>;

     

       51
       -
               type Entries = S::Entries;

     

       52
       -
           }

     

       53
       -
           ///State transition - sets the `entries` field to Set

     

       54
       -
           pub struct SetEntries<S: State = Empty>(PhantomData<fn() -> S>);

     

       55
       -
           impl<S: State> sealed::Sealed for SetEntries<S> {}

     

       56
       -
           impl<S: State> State for SetEntries<S> {

     

       57
       -
               type Type = S::Type;

     

       58
       -
               type Entries = Set<members::entries>;

     

       59
       -
           }

     

       60
       -
           /// Marker types for field names

     

       61
       -
           #[allow(non_camel_case_types)]

     

       62
       -
           pub mod members {

     

       63
       -
               ///Marker type for the `type` field

     

       64
       -
               pub struct r#type(());

     

       65
       -
               ///Marker type for the `entries` field

     

       66
       -
               pub struct entries(());

     

       67
       -
           }

     

       68
       -
       }

     

       69
       -
       

     

       70
       -
       /// Builder for constructing an instance of this type

     

       71
       -
       pub struct DirectoryBuilder<'a, S: directory_state::State> {

     

       72
       -
           _phantom_state: ::core::marker::PhantomData<fn() -> S>,

     

       73
       -
           __unsafe_private_named: (

     

       74
       -
               ::core::option::Option<Vec<crate::place_wisp::fs::Entry<'a>>>,

     

       75
       -
               ::core::option::Option<jacquard_common::CowStr<'a>>,

     

       76
       -
           ),

     

       77
       -
           _phantom: ::core::marker::PhantomData<&'a ()>,

     

       78
       -
       }

     

       79
       -
       

     

       80
       -
       impl<'a> Directory<'a> {

     

       81
       -
           /// Create a new builder for this type

     

       82
       -
           pub fn new() -> DirectoryBuilder<'a, directory_state::Empty> {

     

       83
       -
               DirectoryBuilder::new()

     

       84
       -
           }

     

       85
       -
       }

     

       86
       -
       

     

       87
       -
       impl<'a> DirectoryBuilder<'a, directory_state::Empty> {

     

       88
       -
           /// Create a new builder with all fields unset

     

       89
       -
           pub fn new() -> Self {

     

       90
       -
               DirectoryBuilder {

     

       91
       -
                   _phantom_state: ::core::marker::PhantomData,

     

       92
       -
                   __unsafe_private_named: (None, None),

     

       93
       -
                   _phantom: ::core::marker::PhantomData,

     

       94
       -
               }

     

       95
       -
           }

     

       96
       -
       }

     

       97
       -
       

     

       98
       -
       impl<'a, S> DirectoryBuilder<'a, S>

     

       99
       -
       where

     

       100
       -
           S: directory_state::State,

     

       101
       -
           S::Entries: directory_state::IsUnset,

     

       102
       -
       {

     

       103
       -
           /// Set the `entries` field (required)

     

       104
       -
           pub fn entries(

     

       105
       -
               mut self,

     

       106
       -
               value: impl Into<Vec<crate::place_wisp::fs::Entry<'a>>>,

     

       107
       -
           ) -> DirectoryBuilder<'a, directory_state::SetEntries<S>> {

     

       108
       -
               self.__unsafe_private_named.0 = ::core::option::Option::Some(value.into());

     

       109
       -
               DirectoryBuilder {

     

       110
       -
                   _phantom_state: ::core::marker::PhantomData,

     

       111
       -
                   __unsafe_private_named: self.__unsafe_private_named,

     

       112
       -
                   _phantom: ::core::marker::PhantomData,

     

       113
       -
               }

     

       114
       -
           }

     

       115
       -
       }

     

       116
       -
       

     

       117
       -
       impl<'a, S> DirectoryBuilder<'a, S>

     

       118
       -
       where

     

       119
       -
           S: directory_state::State,

     

       120
       -
           S::Type: directory_state::IsUnset,

     

       121
       -
       {

     

       122
       -
           /// Set the `type` field (required)

     

       123
       -
           pub fn r#type(

     

       124
       -
               mut self,

     

       125
       -
               value: impl Into<jacquard_common::CowStr<'a>>,

     

       126
       -
           ) -> DirectoryBuilder<'a, directory_state::SetType<S>> {

     

       127
       -
               self.__unsafe_private_named.1 = ::core::option::Option::Some(value.into());

     

       128
       -
               DirectoryBuilder {

     

       129
       -
                   _phantom_state: ::core::marker::PhantomData,

     

       130
       -
                   __unsafe_private_named: self.__unsafe_private_named,

     

       131
       -
                   _phantom: ::core::marker::PhantomData,

     

       132
       -
               }

     

       133
       -
           }

     

       134
       -
       }

     

       135
       -
       

     

       136
       -
       impl<'a, S> DirectoryBuilder<'a, S>

     

       137
       -
       where

     

       138
       -
           S: directory_state::State,

     

       139
       -
           S::Type: directory_state::IsSet,

     

       140
       -
           S::Entries: directory_state::IsSet,

     

       141
       -
       {

     

       142
       -
           /// Build the final struct

     

       143
       -
           pub fn build(self) -> Directory<'a> {

     

       144
       -
               Directory {

     

       145
       -
                   entries: self.__unsafe_private_named.0.unwrap(),

     

       146
       -
                   r#type: self.__unsafe_private_named.1.unwrap(),

     

       147
       -
                   extra_data: Default::default(),

     

       148
       -
               }

     

       149
       -
           }

     

       150
       -
           /// Build the final struct with custom extra_data

     

       151
       -
           pub fn build_with_data(

     

       152
       -
               self,

     

       153
       -
               extra_data: std::collections::BTreeMap<

     

       154
       -
                   jacquard_common::smol_str::SmolStr,

     

       155
       -
                   jacquard_common::types::value::Data<'a>,

     

       156
       -
               >,

     

       157
       -
           ) -> Directory<'a> {

     

       158
       -
               Directory {

     

       159
       -
                   entries: self.__unsafe_private_named.0.unwrap(),

     

       160
       -
                   r#type: self.__unsafe_private_named.1.unwrap(),

     

       161
       -
                   extra_data: Some(extra_data),

     

       162
       -
               }

     

       163
       -
           }

     

       164
       -
       }

     

       165
       -
       

     

       166
       -
       fn lexicon_doc_place_wisp_fs() -> ::jacquard_lexicon::lexicon::LexiconDoc<'static> {

     

       167
       -
           ::jacquard_lexicon::lexicon::LexiconDoc {

     

       168
       -
               lexicon: ::jacquard_lexicon::lexicon::Lexicon::Lexicon1,

     

       169
       -
               id: ::jacquard_common::CowStr::new_static("place.wisp.fs"),

     

       170
       -
               revision: None,

     

       171
       -
               description: None,

     

       172
       -
               defs: {

     

       173
       -
                   let mut map = ::std::collections::BTreeMap::new();

     

       174
       -
                   map.insert(

     

       175
       -
                       ::jacquard_common::smol_str::SmolStr::new_static("directory"),

     

       176
       -
                       ::jacquard_lexicon::lexicon::LexUserType::Object(::jacquard_lexicon::lexicon::LexObject {

     

       177
       -
                           description: None,

     

       178
       -
                           required: Some(

     

       179
       -
                               vec![

     

       180
       -
                                   ::jacquard_common::smol_str::SmolStr::new_static("type"),

     

       181
       -
                                   ::jacquard_common::smol_str::SmolStr::new_static("entries")

     

       182
       -
                               ],

     

       183
       -
                           ),

     

       184
       -
                           nullable: None,

     

       185
       -
                           properties: {

     

       186
       -
                               #[allow(unused_mut)]

     

       187
       -
                               let mut map = ::std::collections::BTreeMap::new();

     

       188
       -
                               map.insert(

     

       189
       -
                                   ::jacquard_common::smol_str::SmolStr::new_static("entries"),

     

       190
       -
                                   ::jacquard_lexicon::lexicon::LexObjectProperty::Array(::jacquard_lexicon::lexicon::LexArray {

     

       191
       -
                                       description: None,

     

       192
       -
                                       items: ::jacquard_lexicon::lexicon::LexArrayItem::Ref(::jacquard_lexicon::lexicon::LexRef {

     

       193
       -
                                           description: None,

     

       194
       -
                                           r#ref: ::jacquard_common::CowStr::new_static("#entry"),

     

       195
       -
                                       }),

     

       196
       -
                                       min_length: None,

     

       197
       -
                                       max_length: Some(500usize),

     

       198
       -
                                   }),

     

       199
       -
                               );

     

       200
       -
                               map.insert(

     

       201
       -
                                   ::jacquard_common::smol_str::SmolStr::new_static("type"),

     

       202
       -
                                   ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {

     

       203
       -
                                       description: None,

     

       204
       -
                                       format: None,

     

       205
       -
                                       default: None,

     

       206
       -
                                       min_length: None,

     

       207
       -
                                       max_length: None,

     

       208
       -
                                       min_graphemes: None,

     

       209
       -
                                       max_graphemes: None,

     

       210
       -
                                       r#enum: None,

     

       211
       -
                                       r#const: None,

     

       212
       -
                                       known_values: None,

     

       213
       -
                                   }),

     

       214
       -
                               );

     

       215
       -
                               map

     

       216
       -
                           },

     

       217
       -
                       }),

     

       218
       -
                   );

     

       219
       -
                   map.insert(

     

       220
       -
                       ::jacquard_common::smol_str::SmolStr::new_static("entry"),

     

       221
       -
                       ::jacquard_lexicon::lexicon::LexUserType::Object(::jacquard_lexicon::lexicon::LexObject {

     

       222
       -
                           description: None,

     

       223
       -
                           required: Some(

     

       224
       -
                               vec![

     

       225
       -
                                   ::jacquard_common::smol_str::SmolStr::new_static("name"),

     

       226
       -
                                   ::jacquard_common::smol_str::SmolStr::new_static("node")

     

       227
       -
                               ],

     

       228
       -
                           ),

     

       229
       -
                           nullable: None,

     

       230
       -
                           properties: {

     

       231
       -
                               #[allow(unused_mut)]

     

       232
       -
                               let mut map = ::std::collections::BTreeMap::new();

     

       233
       -
                               map.insert(

     

       234
       -
                                   ::jacquard_common::smol_str::SmolStr::new_static("name"),

     

       235
       -
                                   ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {

     

       236
       -
                                       description: None,

     

       237
       -
                                       format: None,

     

       238
       -
                                       default: None,

     

       239
       -
                                       min_length: None,

     

       240
       -
                                       max_length: Some(255usize),

     

       241
       -
                                       min_graphemes: None,

     

       242
       -
                                       max_graphemes: None,

     

       243
       -
                                       r#enum: None,

     

       244
       -
                                       r#const: None,

     

       245
       -
                                       known_values: None,

     

       246
       -
                                   }),

     

       247
       -
                               );

     

       248
       -
                               map.insert(

     

       249
       -
                                   ::jacquard_common::smol_str::SmolStr::new_static("node"),

     

       250
       -
                                   ::jacquard_lexicon::lexicon::LexObjectProperty::Union(::jacquard_lexicon::lexicon::LexRefUnion {

     

       251
       -
                                       description: None,

     

       252
       -
                                       refs: vec![

     

       253
       -
                                           ::jacquard_common::CowStr::new_static("#file"),

     

       254
       -
                                           ::jacquard_common::CowStr::new_static("#directory"),

     

       255
       -
                                           ::jacquard_common::CowStr::new_static("#subfs")

     

       256
       -
                                       ],

     

       257
       -
                                       closed: None,

     

       258
       -
                                   }),

     

       259
       -
                               );

     

       260
       -
                               map

     

       261
       -
                           },

     

       262
       -
                       }),

     

       263
       -
                   );

     

       264
       -
                   map.insert(

     

       265
       -
                       ::jacquard_common::smol_str::SmolStr::new_static("file"),

     

       266
       -
                       ::jacquard_lexicon::lexicon::LexUserType::Object(::jacquard_lexicon::lexicon::LexObject {

     

       267
       -
                           description: None,

     

       268
       -
                           required: Some(

     

       269
       -
                               vec![

     

       270
       -
                                   ::jacquard_common::smol_str::SmolStr::new_static("type"),

     

       271
       -
                                   ::jacquard_common::smol_str::SmolStr::new_static("blob")

     

       272
       -
                               ],

     

       273
       -
                           ),

     

       274
       -
                           nullable: None,

     

       275
       -
                           properties: {

     

       276
       -
                               #[allow(unused_mut)]

     

       277
       -
                               let mut map = ::std::collections::BTreeMap::new();

     

       278
       -
                               map.insert(

     

       279
       -
                                   ::jacquard_common::smol_str::SmolStr::new_static("base64"),

     

       280
       -
                                   ::jacquard_lexicon::lexicon::LexObjectProperty::Boolean(::jacquard_lexicon::lexicon::LexBoolean {

     

       281
       -
                                       description: None,

     

       282
       -
                                       default: None,

     

       283
       -
                                       r#const: None,

     

       284
       -
                                   }),

     

       285
       -
                               );

     

       286
       -
                               map.insert(

     

       287
       -
                                   ::jacquard_common::smol_str::SmolStr::new_static("blob"),

     

       288
       -
                                   ::jacquard_lexicon::lexicon::LexObjectProperty::Blob(::jacquard_lexicon::lexicon::LexBlob {

     

       289
       -
                                       description: None,

     

       290
       -
                                       accept: None,

     

       291
       -
                                       max_size: None,

     

       292
       -
                                   }),

     

       293
       -
                               );

     

       294
       -
                               map.insert(

     

       295
       -
                                   ::jacquard_common::smol_str::SmolStr::new_static("encoding"),

     

       296
       -
                                   ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {

     

       297
       -
                                       description: Some(

     

       298
       -
                                           ::jacquard_common::CowStr::new_static(

     

       299
       -
                                               "Content encoding (e.g., gzip for compressed files)",

     

       300
       -
                                           ),

     

       301
       -
                                       ),

     

       302
       -
                                       format: None,

     

       303
       -
                                       default: None,

     

       304
       -
                                       min_length: None,

     

       305
       -
                                       max_length: None,

     

       306
       -
                                       min_graphemes: None,

     

       307
       -
                                       max_graphemes: None,

     

       308
       -
                                       r#enum: None,

     

       309
       -
                                       r#const: None,

     

       310
       -
                                       known_values: None,

     

       311
       -
                                   }),

     

       312
       -
                               );

     

       313
       -
                               map.insert(

     

       314
       -
                                   ::jacquard_common::smol_str::SmolStr::new_static("mimeType"),

     

       315
       -
                                   ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {

     

       316
       -
                                       description: Some(

     

       317
       -
                                           ::jacquard_common::CowStr::new_static(

     

       318
       -
                                               "Original MIME type before compression",

     

       319
       -
                                           ),

     

       320
       -
                                       ),

     

       321
       -
                                       format: None,

     

       322
       -
                                       default: None,

     

       323
       -
                                       min_length: None,

     

       324
       -
                                       max_length: None,

     

       325
       -
                                       min_graphemes: None,

     

       326
       -
                                       max_graphemes: None,

     

       327
       -
                                       r#enum: None,

     

       328
       -
                                       r#const: None,

     

       329
       -
                                       known_values: None,

     

       330
       -
                                   }),

     

       331
       -
                               );

     

       332
       -
                               map.insert(

     

       333
       -
                                   ::jacquard_common::smol_str::SmolStr::new_static("type"),

     

       334
       -
                                   ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {

     

       335
       -
                                       description: None,

     

       336
       -
                                       format: None,

     

       337
       -
                                       default: None,

     

       338
       -
                                       min_length: None,

     

       339
       -
                                       max_length: None,

     

       340
       -
                                       min_graphemes: None,

     

       341
       -
                                       max_graphemes: None,

     

       342
       -
                                       r#enum: None,

     

       343
       -
                                       r#const: None,

     

       344
       -
                                       known_values: None,

     

       345
       -
                                   }),

     

       346
       -
                               );

     

       347
       -
                               map

     

       348
       -
                           },

     

       349
       -
                       }),

     

       350
       -
                   );

     

       351
       -
                   map.insert(

     

       352
       -
                       ::jacquard_common::smol_str::SmolStr::new_static("main"),

     

       353
       -
                       ::jacquard_lexicon::lexicon::LexUserType::Record(::jacquard_lexicon::lexicon::LexRecord {

     

       354
       -
                           description: Some(

     

       355
       -
                               ::jacquard_common::CowStr::new_static(

     

       356
       -
                                   "Virtual filesystem manifest for a Wisp site",

     

       357
       -
                               ),

     

       358
       -
                           ),

     

       359
       -
                           key: None,

     

       360
       -
                           record: ::jacquard_lexicon::lexicon::LexRecordRecord::Object(::jacquard_lexicon::lexicon::LexObject {

     

       361
       -
                               description: None,

     

       362
       -
                               required: Some(

     

       363
       -
                                   vec![

     

       364
       -
                                       ::jacquard_common::smol_str::SmolStr::new_static("site"),

     

       365
       -
                                       ::jacquard_common::smol_str::SmolStr::new_static("root"),

     

       366
       -
                                       ::jacquard_common::smol_str::SmolStr::new_static("createdAt")

     

       367
       -
                                   ],

     

       368
       -
                               ),

     

       369
       -
                               nullable: None,

     

       370
       -
                               properties: {

     

       371
       -
                                   #[allow(unused_mut)]

     

       372
       -
                                   let mut map = ::std::collections::BTreeMap::new();

     

       373
       -
                                   map.insert(

     

       374
       -
                                       ::jacquard_common::smol_str::SmolStr::new_static(

     

       375
       -
                                           "createdAt",

     

       376
       -
                                       ),

     

       377
       -
                                       ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {

     

       378
       -
                                           description: None,

     

       379
       -
                                           format: Some(

     

       380
       -
                                               ::jacquard_lexicon::lexicon::LexStringFormat::Datetime,

     

       381
       -
                                           ),

     

       382
       -
                                           default: None,

     

       383
       -
                                           min_length: None,

     

       384
       -
                                           max_length: None,

     

       385
       -
                                           min_graphemes: None,

     

       386
       -
                                           max_graphemes: None,

     

       387
       -
                                           r#enum: None,

     

       388
       -
                                           r#const: None,

     

       389
       -
                                           known_values: None,

     

       390
       -
                                       }),

     

       391
       -
                                   );

     

       392
       -
                                   map.insert(

     

       393
       -
                                       ::jacquard_common::smol_str::SmolStr::new_static(

     

       394
       -
                                           "fileCount",

     

       395
       -
                                       ),

     

       396
       -
                                       ::jacquard_lexicon::lexicon::LexObjectProperty::Integer(::jacquard_lexicon::lexicon::LexInteger {

     

       397
       -
                                           description: None,

     

       398
       -
                                           default: None,

     

       399
       -
                                           minimum: Some(0i64),

     

       400
       -
                                           maximum: Some(1000i64),

     

       401
       -
                                           r#enum: None,

     

       402
       -
                                           r#const: None,

     

       403
       -
                                       }),

     

       404
       -
                                   );

     

       405
       -
                                   map.insert(

     

       406
       -
                                       ::jacquard_common::smol_str::SmolStr::new_static("root"),

     

       407
       -
                                       ::jacquard_lexicon::lexicon::LexObjectProperty::Ref(::jacquard_lexicon::lexicon::LexRef {

     

       408
       -
                                           description: None,

     

       409
       -
                                           r#ref: ::jacquard_common::CowStr::new_static("#directory"),

     

       410
       -
                                       }),

     

       411
       -
                                   );

     

       412
       -
                                   map.insert(

     

       413
       -
                                       ::jacquard_common::smol_str::SmolStr::new_static("site"),

     

       414
       -
                                       ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {

     

       415
       -
                                           description: None,

     

       416
       -
                                           format: None,

     

       417
       -
                                           default: None,

     

       418
       -
                                           min_length: None,

     

       419
       -
                                           max_length: None,

     

       420
       -
                                           min_graphemes: None,

     

       421
       -
                                           max_graphemes: None,

     

       422
       -
                                           r#enum: None,

     

       423
       -
                                           r#const: None,

     

       424
       -
                                           known_values: None,

     

       425
       -
                                       }),

     

       426
       -
                                   );

     

       427
       -
                                   map

     

       428
       -
                               },

     

       429
       -
                           }),

     

       430
       -
                       }),

     

       431
       -
                   );

     

       432
       -
                   map.insert(

     

       433
       -
                       ::jacquard_common::smol_str::SmolStr::new_static("subfs"),

     

       434
       -
                       ::jacquard_lexicon::lexicon::LexUserType::Object(::jacquard_lexicon::lexicon::LexObject {

     

       435
       -
                           description: None,

     

       436
       -
                           required: Some(

     

       437
       -
                               vec![

     

       438
       -
                                   ::jacquard_common::smol_str::SmolStr::new_static("type"),

     

       439
       -
                                   ::jacquard_common::smol_str::SmolStr::new_static("subject")

     

       440
       -
                               ],

     

       441
       -
                           ),

     

       442
       -
                           nullable: None,

     

       443
       -
                           properties: {

     

       444
       -
                               #[allow(unused_mut)]

     

       445
       -
                               let mut map = ::std::collections::BTreeMap::new();

     

       446
       -
                               map.insert(

     

       447
       -
                                   ::jacquard_common::smol_str::SmolStr::new_static("flat"),

     

       448
       -
                                   ::jacquard_lexicon::lexicon::LexObjectProperty::Boolean(::jacquard_lexicon::lexicon::LexBoolean {

     

       449
       -
                                       description: None,

     

       450
       -
                                       default: None,

     

       451
       -
                                       r#const: None,

     

       452
       -
                                   }),

     

       453
       -
                               );

     

       454
       -
                               map.insert(

     

       455
       -
                                   ::jacquard_common::smol_str::SmolStr::new_static("subject"),

     

       456
       -
                                   ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {

     

       457
       -
                                       description: Some(

     

       458
       -
                                           ::jacquard_common::CowStr::new_static(

     

       459
       -
                                               "AT-URI pointing to a place.wisp.subfs record containing this subtree.",

     

       460
       -
                                           ),

     

       461
       -
                                       ),

     

       462
       -
                                       format: Some(

     

       463
       -
                                           ::jacquard_lexicon::lexicon::LexStringFormat::AtUri,

     

       464
       -
                                       ),

     

       465
       -
                                       default: None,

     

       466
       -
                                       min_length: None,

     

       467
       -
                                       max_length: None,

     

       468
       -
                                       min_graphemes: None,

     

       469
       -
                                       max_graphemes: None,

     

       470
       -
                                       r#enum: None,

     

       471
       -
                                       r#const: None,

     

       472
       -
                                       known_values: None,

     

       473
       -
                                   }),

     

       474
       -
                               );

     

       475
       -
                               map.insert(

     

       476
       -
                                   ::jacquard_common::smol_str::SmolStr::new_static("type"),

     

       477
       -
                                   ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {

     

       478
       -
                                       description: None,

     

       479
       -
                                       format: None,

     

       480
       -
                                       default: None,

     

       481
       -
                                       min_length: None,

     

       482
       -
                                       max_length: None,

     

       483
       -
                                       min_graphemes: None,

     

       484
       -
                                       max_graphemes: None,

     

       485
       -
                                       r#enum: None,

     

       486
       -
                                       r#const: None,

     

       487
       -
                                       known_values: None,

     

       488
       -
                                   }),

     

       489
       -
                               );

     

       490
       -
                               map

     

       491
       -
                           },

     

       492
       -
                       }),

     

       493
       -
                   );

     

       494
       -
                   map

     

       495
       -
               },

     

       496
       -
           }

     

       497
       -
       }

     

       498
       -
       

     

       499
       -
       impl<'a> ::jacquard_lexicon::schema::LexiconSchema for Directory<'a> {

     

       500
       -
           fn nsid() -> &'static str {

     

       501
       -
               "place.wisp.fs"

     

       502
       -
           }

     

       503
       -
           fn def_name() -> &'static str {

     

       504
       -
               "directory"

     

       505
       -
           }

     

       506
       -
           fn lexicon_doc() -> ::jacquard_lexicon::lexicon::LexiconDoc<'static> {

     

       507
       -
               lexicon_doc_place_wisp_fs()

     

       508
       -
           }

     

       509
       -
           fn validate(

     

       510
       -
               &self,

     

       511
       -
           ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> {

     

       512
       -
               {

     

       513
       -
                   let value = &self.entries;

     

       514
       -
                   #[allow(unused_comparisons)]

     

       515
       -
                   if value.len() > 500usize {

     

       516
       -
                       return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength {

     

       517
       -
                           path: ::jacquard_lexicon::validation::ValidationPath::from_field(

     

       518
       -
                               "entries",

     

       519
       -
                           ),

     

       520
       -
                           max: 500usize,

     

       521
       -
                           actual: value.len(),

     

       522
       -
                       });

     

       523
       -
                   }

     

       524
       -
               }

     

       525
       -
               Ok(())

     

       526
       -
           }

     

       527
       -
       }

     

       528
       -
       

     

       529
       -
       #[jacquard_derive::lexicon]

     

       530
       -
       #[derive(

     

       531
       -
           serde::Serialize,

     

       532
       -
           serde::Deserialize,

     

       533
       -
           Debug,

     

       534
       -
           Clone,

     

       535
       -
           PartialEq,

     

       536
       -
           Eq,

     

       537
       -
           jacquard_derive::IntoStatic

     

       538
       -
       )]

     

       539
       -
       #[serde(rename_all = "camelCase")]

     

       540
       -
       pub struct Entry<'a> {

     

       541
       -
           #[serde(borrow)]

     

       542
       -
           pub name: jacquard_common::CowStr<'a>,

     

       543
       -
           #[serde(borrow)]

     

       544
       -
           pub node: EntryNode<'a>,

     

       545
       -
       }

     

       546
       -
       

     

       547
       -
       pub mod entry_state {

     

       548
       -
       

     

       549
       -
           pub use crate::builder_types::{Set, Unset, IsSet, IsUnset};

     

       550
       -
           #[allow(unused)]

     

       551
       -
           use ::core::marker::PhantomData;

     

       552
       -
           mod sealed {

     

       553
       -
               pub trait Sealed {}

     

       554
       -
           }

     

       555
       -
           /// State trait tracking which required fields have been set

     

       556
       -
           pub trait State: sealed::Sealed {

     

       557
       -
               type Name;

     

       558
       -
               type Node;

     

       559
       -
           }

     

       560
       -
           /// Empty state - all required fields are unset

     

       561
       -
           pub struct Empty(());

     

       562
       -
           impl sealed::Sealed for Empty {}

     

       563
       -
           impl State for Empty {

     

       564
       -
               type Name = Unset;

     

       565
       -
               type Node = Unset;

     

       566
       -
           }

     

       567
       -
           ///State transition - sets the `name` field to Set

     

       568
       -
           pub struct SetName<S: State = Empty>(PhantomData<fn() -> S>);

     

       569
       -
           impl<S: State> sealed::Sealed for SetName<S> {}

     

       570
       -
           impl<S: State> State for SetName<S> {

     

       571
       -
               type Name = Set<members::name>;

     

       572
       -
               type Node = S::Node;

     

       573
       -
           }

     

       574
       -
           ///State transition - sets the `node` field to Set

     

       575
       -
           pub struct SetNode<S: State = Empty>(PhantomData<fn() -> S>);

     

       576
       -
           impl<S: State> sealed::Sealed for SetNode<S> {}

     

       577
       -
           impl<S: State> State for SetNode<S> {

     

       578
       -
               type Name = S::Name;

     

       579
       -
               type Node = Set<members::node>;

     

       580
       -
           }

     

       581
       -
           /// Marker types for field names

     

       582
       -
           #[allow(non_camel_case_types)]

     

       583
       -
           pub mod members {

     

       584
       -
               ///Marker type for the `name` field

     

       585
       -
               pub struct name(());

     

       586
       -
               ///Marker type for the `node` field

     

       587
       -
               pub struct node(());

     

       588
       -
           }

     

       589
       -
       }

     

       590
       -
       

     

       591
       -
       /// Builder for constructing an instance of this type

     

       592
       -
       pub struct EntryBuilder<'a, S: entry_state::State> {

     

       593
       -
           _phantom_state: ::core::marker::PhantomData<fn() -> S>,

     

       594
       -
           __unsafe_private_named: (

     

       595
       -
               ::core::option::Option<jacquard_common::CowStr<'a>>,

     

       596
       -
               ::core::option::Option<EntryNode<'a>>,

     

       597
       -
           ),

     

       598
       -
           _phantom: ::core::marker::PhantomData<&'a ()>,

     

       599
       -
       }

     

       600
       -
       

     

       601
       -
       impl<'a> Entry<'a> {

     

       602
       -
           /// Create a new builder for this type

     

       603
       -
           pub fn new() -> EntryBuilder<'a, entry_state::Empty> {

     

       604
       -
               EntryBuilder::new()

     

       605
       -
           }

     

       606
       -
       }

     

       607
       -
       

     

       608
       -
       impl<'a> EntryBuilder<'a, entry_state::Empty> {

     

       609
       -
           /// Create a new builder with all fields unset

     

       610
       -
           pub fn new() -> Self {

     

       611
       -
               EntryBuilder {

     

       612
       -
                   _phantom_state: ::core::marker::PhantomData,

     

       613
       -
                   __unsafe_private_named: (None, None),

     

       614
       -
                   _phantom: ::core::marker::PhantomData,

     

       615
       -
               }

     

       616
       -
           }

     

       617
       -
       }

     

       618
       -
       

     

       619
       -
       impl<'a, S> EntryBuilder<'a, S>

     

       620
       -
       where

     

       621
       -
           S: entry_state::State,

     

       622
       -
           S::Name: entry_state::IsUnset,

     

       623
       -
       {

     

       624
       -
           /// Set the `name` field (required)

     

       625
       -
           pub fn name(

     

       626
       -
               mut self,

     

       627
       -
               value: impl Into<jacquard_common::CowStr<'a>>,

     

       628
       -
           ) -> EntryBuilder<'a, entry_state::SetName<S>> {

     

       629
       -
               self.__unsafe_private_named.0 = ::core::option::Option::Some(value.into());

     

       630
       -
               EntryBuilder {

     

       631
       -
                   _phantom_state: ::core::marker::PhantomData,

     

       632
       -
                   __unsafe_private_named: self.__unsafe_private_named,

     

       633
       -
                   _phantom: ::core::marker::PhantomData,

     

       634
       -
               }

     

       635
       -
           }

     

       636
       -
       }

     

       637
       -
       

     

       638
       -
       impl<'a, S> EntryBuilder<'a, S>

     

       639
       -
       where

     

       640
       -
           S: entry_state::State,

     

       641
       -
           S::Node: entry_state::IsUnset,

     

       642
       -
       {

     

       643
       -
           /// Set the `node` field (required)

     

       644
       -
           pub fn node(

     

       645
       -
               mut self,

     

       646
       -
               value: impl Into<EntryNode<'a>>,

     

       647
       -
           ) -> EntryBuilder<'a, entry_state::SetNode<S>> {

     

       648
       -
               self.__unsafe_private_named.1 = ::core::option::Option::Some(value.into());

     

       649
       -
               EntryBuilder {

     

       650
       -
                   _phantom_state: ::core::marker::PhantomData,

     

       651
       -
                   __unsafe_private_named: self.__unsafe_private_named,

     

       652
       -
                   _phantom: ::core::marker::PhantomData,

     

       653
       -
               }

     

       654
       -
           }

     

       655
       -
       }

     

       656
       -
       

     

       657
       -
       impl<'a, S> EntryBuilder<'a, S>

     

       658
       -
       where

     

       659
       -
           S: entry_state::State,

     

       660
       -
           S::Name: entry_state::IsSet,

     

       661
       -
           S::Node: entry_state::IsSet,

     

       662
       -
       {

     

       663
       -
           /// Build the final struct

     

       664
       -
           pub fn build(self) -> Entry<'a> {

     

       665
       -
               Entry {

     

       666
       -
                   name: self.__unsafe_private_named.0.unwrap(),

     

       667
       -
                   node: self.__unsafe_private_named.1.unwrap(),

     

       668
       -
                   extra_data: Default::default(),

     

       669
       -
               }

     

       670
       -
           }

     

       671
       -
           /// Build the final struct with custom extra_data

     

       672
       -
           pub fn build_with_data(

     

       673
       -
               self,

     

       674
       -
               extra_data: std::collections::BTreeMap<

     

       675
       -
                   jacquard_common::smol_str::SmolStr,

     

       676
       -
                   jacquard_common::types::value::Data<'a>,

     

       677
       -
               >,

     

       678
       -
           ) -> Entry<'a> {

     

       679
       -
               Entry {

     

       680
       -
                   name: self.__unsafe_private_named.0.unwrap(),

     

       681
       -
                   node: self.__unsafe_private_named.1.unwrap(),

     

       682
       -
                   extra_data: Some(extra_data),

     

       683
       -
               }

     

       684
       -
           }

     

       685
       -
       }

     

       686
       -
       

     

       687
       -
       #[jacquard_derive::open_union]

     

       688
       -
       #[derive(

     

       689
       -
           serde::Serialize,

     

       690
       -
           serde::Deserialize,

     

       691
       -
           Debug,

     

       692
       -
           Clone,

     

       693
       -
           PartialEq,

     

       694
       -
           Eq,

     

       695
       -
           jacquard_derive::IntoStatic

     

       696
       -
       )]

     

       697
       -
       #[serde(tag = "$type")]

     

       698
       -
       #[serde(bound(deserialize = "'de: 'a"))]

     

       699
       -
       pub enum EntryNode<'a> {

     

       700
       -
           #[serde(rename = "place.wisp.fs#file")]

     

       701
       -
           File(Box<crate::place_wisp::fs::File<'a>>),

     

       702
       -
           #[serde(rename = "place.wisp.fs#directory")]

     

       703
       -
           Directory(Box<crate::place_wisp::fs::Directory<'a>>),

     

       704
       -
           #[serde(rename = "place.wisp.fs#subfs")]

     

       705
       -
           Subfs(Box<crate::place_wisp::fs::Subfs<'a>>),

     

       706
       -
       }

     

       707
       -
       

     

       708
       -
       impl<'a> ::jacquard_lexicon::schema::LexiconSchema for Entry<'a> {

     

       709
       -
           fn nsid() -> &'static str {

     

       710
       -
               "place.wisp.fs"

     

       711
       -
           }

     

       712
       -
           fn def_name() -> &'static str {

     

       713
       -
               "entry"

     

       714
       -
           }

     

       715
       -
           fn lexicon_doc() -> ::jacquard_lexicon::lexicon::LexiconDoc<'static> {

     

       716
       -
               lexicon_doc_place_wisp_fs()

     

       717
       -
           }

     

       718
       -
           fn validate(

     

       719
       -
               &self,

     

       720
       -
           ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> {

     

       721
       -
               {

     

       722
       -
                   let value = &self.name;

     

       723
       -
                   #[allow(unused_comparisons)]

     

       724
       -
                   if <str>::len(value.as_ref()) > 255usize {

     

       725
       -
                       return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength {

     

       726
       -
                           path: ::jacquard_lexicon::validation::ValidationPath::from_field(

     

       727
       -
                               "name",

     

       728
       -
                           ),

     

       729
       -
                           max: 255usize,

     

       730
       -
                           actual: <str>::len(value.as_ref()),

     

       731
       -
                       });

     

       732
       -
                   }

     

       733
       -
               }

     

       734
       -
               Ok(())

     

       735
       -
           }

     

       736
       -
       }

     

       737
       -
       

     

       738
       -
       #[jacquard_derive::lexicon]

     

       739
       -
       #[derive(

     

       740
       -
           serde::Serialize,

     

       741
       -
           serde::Deserialize,

     

       742
       -
           Debug,

     

       743
       -
           Clone,

     

       744
       -
           PartialEq,

     

       745
       -
           Eq,

     

       746
       -
           jacquard_derive::IntoStatic

     

       747
       -
       )]

     

       748
       -
       #[serde(rename_all = "camelCase")]

     

       749
       -
       pub struct File<'a> {

     

       750
       -
           /// True if blob content is base64-encoded (used to bypass PDS content sniffing)

     

       751
       -
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       752
       -
           pub base64: Option<bool>,

     

       753
       -
           /// Content blob ref

     

       754
       -
           #[serde(borrow)]

     

       755
       -
           pub blob: jacquard_common::types::blob::BlobRef<'a>,

     

       756
       -
           /// Content encoding (e.g., gzip for compressed files)

     

       757
       -
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       758
       -
           #[serde(borrow)]

     

       759
       -
           pub encoding: Option<jacquard_common::CowStr<'a>>,

     

       760
       -
           /// Original MIME type before compression

     

       761
       -
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       762
       -
           #[serde(borrow)]

     

       763
       -
           pub mime_type: Option<jacquard_common::CowStr<'a>>,

     

       764
       -
           #[serde(borrow)]

     

       765
       -
           pub r#type: jacquard_common::CowStr<'a>,

     

       766
       -
       }

     

       767
       -
       

     

       768
       -
       pub mod file_state {

     

       769
       -
       

     

       770
       -
           pub use crate::builder_types::{Set, Unset, IsSet, IsUnset};

     

       771
       -
           #[allow(unused)]

     

       772
       -
           use ::core::marker::PhantomData;

     

       773
       -
           mod sealed {

     

       774
       -
               pub trait Sealed {}

     

       775
       -
           }

     

       776
       -
           /// State trait tracking which required fields have been set

     

       777
       -
           pub trait State: sealed::Sealed {

     

       778
       -
               type Type;

     

       779
       -
               type Blob;

     

       780
       -
           }

     

       781
       -
           /// Empty state - all required fields are unset

     

       782
       -
           pub struct Empty(());

     

       783
       -
           impl sealed::Sealed for Empty {}

     

       784
       -
           impl State for Empty {

     

       785
       -
               type Type = Unset;

     

       786
       -
               type Blob = Unset;

     

       787
       -
           }

     

       788
       -
           ///State transition - sets the `type` field to Set

     

       789
       -
           pub struct SetType<S: State = Empty>(PhantomData<fn() -> S>);

     

       790
       -
           impl<S: State> sealed::Sealed for SetType<S> {}

     

       791
       -
           impl<S: State> State for SetType<S> {

     

       792
       -
               type Type = Set<members::r#type>;

     

       793
       -
               type Blob = S::Blob;

     

       794
       -
           }

     

       795
       -
           ///State transition - sets the `blob` field to Set

     

       796
       -
           pub struct SetBlob<S: State = Empty>(PhantomData<fn() -> S>);

     

       797
       -
           impl<S: State> sealed::Sealed for SetBlob<S> {}

     

       798
       -
           impl<S: State> State for SetBlob<S> {

     

       799
       -
               type Type = S::Type;

     

       800
       -
               type Blob = Set<members::blob>;

     

       801
       -
           }

     

       802
       -
           /// Marker types for field names

     

       803
       -
           #[allow(non_camel_case_types)]

     

       804
       -
           pub mod members {

     

       805
       -
               ///Marker type for the `type` field

     

       806
       -
               pub struct r#type(());

     

       807
       -
               ///Marker type for the `blob` field

     

       808
       -
               pub struct blob(());

     

       809
       -
           }

     

       810
       -
       }

     

       811
       -
       

     

       812
       -
       /// Builder for constructing an instance of this type

     

       813
       -
       pub struct FileBuilder<'a, S: file_state::State> {

     

       814
       -
           _phantom_state: ::core::marker::PhantomData<fn() -> S>,

     

       815
       -
           __unsafe_private_named: (

     

       816
       -
               ::core::option::Option<bool>,

     

       817
       -
               ::core::option::Option<jacquard_common::types::blob::BlobRef<'a>>,

     

       818
       -
               ::core::option::Option<jacquard_common::CowStr<'a>>,

     

       819
       -
               ::core::option::Option<jacquard_common::CowStr<'a>>,

     

       820
       -
               ::core::option::Option<jacquard_common::CowStr<'a>>,

     

       821
       -
           ),

     

       822
       -
           _phantom: ::core::marker::PhantomData<&'a ()>,

     

       823
       -
       }

     

       824
       -
       

     

       825
       -
       impl<'a> File<'a> {

     

       826
       -
           /// Create a new builder for this type

     

       827
       -
           pub fn new() -> FileBuilder<'a, file_state::Empty> {

     

       828
       -
               FileBuilder::new()

     

       829
       -
           }

     

       830
       -
       }

     

       831
       -
       

     

       832
       -
       impl<'a> FileBuilder<'a, file_state::Empty> {

     

       833
       -
           /// Create a new builder with all fields unset

     

       834
       -
           pub fn new() -> Self {

     

       835
       -
               FileBuilder {

     

       836
       -
                   _phantom_state: ::core::marker::PhantomData,

     

       837
       -
                   __unsafe_private_named: (None, None, None, None, None),

     

       838
       -
                   _phantom: ::core::marker::PhantomData,

     

       839
       -
               }

     

       840
       -
           }

     

       841
       -
       }

     

       842
       -
       

     

       843
       -
       impl<'a, S: file_state::State> FileBuilder<'a, S> {

     

       844
       -
           /// Set the `base64` field (optional)

     

       845
       -
           pub fn base64(mut self, value: impl Into<Option<bool>>) -> Self {

     

       846
       -
               self.__unsafe_private_named.0 = value.into();

     

       847
       -
               self

     

       848
       -
           }

     

       849
       -
           /// Set the `base64` field to an Option value (optional)

     

       850
       -
           pub fn maybe_base64(mut self, value: Option<bool>) -> Self {

     

       851
       -
               self.__unsafe_private_named.0 = value;

     

       852
       -
               self

     

       853
       -
           }

     

       854
       -
       }

     

       855
       -
       

     

       856
       -
       impl<'a, S> FileBuilder<'a, S>

     

       857
       -
       where

     

       858
       -
           S: file_state::State,

     

       859
       -
           S::Blob: file_state::IsUnset,

     

       860
       -
       {

     

       861
       -
           /// Set the `blob` field (required)

     

       862
       -
           pub fn blob(

     

       863
       -
               mut self,

     

       864
       -
               value: impl Into<jacquard_common::types::blob::BlobRef<'a>>,

     

       865
       -
           ) -> FileBuilder<'a, file_state::SetBlob<S>> {

     

       866
       -
               self.__unsafe_private_named.1 = ::core::option::Option::Some(value.into());

     

       867
       -
               FileBuilder {

     

       868
       -
                   _phantom_state: ::core::marker::PhantomData,

     

       869
       -
                   __unsafe_private_named: self.__unsafe_private_named,

     

       870
       -
                   _phantom: ::core::marker::PhantomData,

     

       871
       -
               }

     

       872
       -
           }

     

       873
       -
       }

     

       874
       -
       

     

       875
       -
       impl<'a, S: file_state::State> FileBuilder<'a, S> {

     

       876
       -
           /// Set the `encoding` field (optional)

     

       877
       -
           pub fn encoding(

     

       878
       -
               mut self,

     

       879
       -
               value: impl Into<Option<jacquard_common::CowStr<'a>>>,

     

       880
       -
           ) -> Self {

     

       881
       -
               self.__unsafe_private_named.2 = value.into();

     

       882
       -
               self

     

       883
       -
           }

     

       884
       -
           /// Set the `encoding` field to an Option value (optional)

     

       885
       -
           pub fn maybe_encoding(mut self, value: Option<jacquard_common::CowStr<'a>>) -> Self {

     

       886
       -
               self.__unsafe_private_named.2 = value;

     

       887
       -
               self

     

       888
       -
           }

     

       889
       -
       }

     

       890
       -
       

     

       891
       -
       impl<'a, S: file_state::State> FileBuilder<'a, S> {

     

       892
       -
           /// Set the `mimeType` field (optional)

     

       893
       -
           pub fn mime_type(

     

       894
       -
               mut self,

     

       895
       -
               value: impl Into<Option<jacquard_common::CowStr<'a>>>,

     

       896
       -
           ) -> Self {

     

       897
       -
               self.__unsafe_private_named.3 = value.into();

     

       898
       -
               self

     

       899
       -
           }

     

       900
       -
           /// Set the `mimeType` field to an Option value (optional)

     

       901
       -
           pub fn maybe_mime_type(

     

       902
       -
               mut self,

     

       903
       -
               value: Option<jacquard_common::CowStr<'a>>,

     

       904
       -
           ) -> Self {

     

       905
       -
               self.__unsafe_private_named.3 = value;

     

       906
       -
               self

     

       907
       -
           }

     

       908
       -
       }

     

       909
       -
       

     

       910
       -
       impl<'a, S> FileBuilder<'a, S>

     

       911
       -
       where

     

       912
       -
           S: file_state::State,

     

       913
       -
           S::Type: file_state::IsUnset,

     

       914
       -
       {

     

       915
       -
           /// Set the `type` field (required)

     

       916
       -
           pub fn r#type(

     

       917
       -
               mut self,

     

       918
       -
               value: impl Into<jacquard_common::CowStr<'a>>,

     

       919
       -
           ) -> FileBuilder<'a, file_state::SetType<S>> {

     

       920
       -
               self.__unsafe_private_named.4 = ::core::option::Option::Some(value.into());

     

       921
       -
               FileBuilder {

     

       922
       -
                   _phantom_state: ::core::marker::PhantomData,

     

       923
       -
                   __unsafe_private_named: self.__unsafe_private_named,

     

       924
       -
                   _phantom: ::core::marker::PhantomData,

     

       925
       -
               }

     

       926
       -
           }

     

       927
       -
       }

     

       928
       -
       

     

       929
       -
       impl<'a, S> FileBuilder<'a, S>

     

       930
       -
       where

     

       931
       -
           S: file_state::State,

     

       932
       -
           S::Type: file_state::IsSet,

     

       933
       -
           S::Blob: file_state::IsSet,

     

       934
       -
       {

     

       935
       -
           /// Build the final struct

     

       936
       -
           pub fn build(self) -> File<'a> {

     

       937
       -
               File {

     

       938
       -
                   base64: self.__unsafe_private_named.0,

     

       939
       -
                   blob: self.__unsafe_private_named.1.unwrap(),

     

       940
       -
                   encoding: self.__unsafe_private_named.2,

     

       941
       -
                   mime_type: self.__unsafe_private_named.3,

     

       942
       -
                   r#type: self.__unsafe_private_named.4.unwrap(),

     

       943
       -
                   extra_data: Default::default(),

     

       944
       -
               }

     

       945
       -
           }

     

       946
       -
           /// Build the final struct with custom extra_data

     

       947
       -
           pub fn build_with_data(

     

       948
       -
               self,

     

       949
       -
               extra_data: std::collections::BTreeMap<

     

       950
       -
                   jacquard_common::smol_str::SmolStr,

     

       951
       -
                   jacquard_common::types::value::Data<'a>,

     

       952
       -
               >,

     

       953
       -
           ) -> File<'a> {

     

       954
       -
               File {

     

       955
       -
                   base64: self.__unsafe_private_named.0,

     

       956
       -
                   blob: self.__unsafe_private_named.1.unwrap(),

     

       957
       -
                   encoding: self.__unsafe_private_named.2,

     

       958
       -
                   mime_type: self.__unsafe_private_named.3,

     

       959
       -
                   r#type: self.__unsafe_private_named.4.unwrap(),

     

       960
       -
                   extra_data: Some(extra_data),

     

       961
       -
               }

     

       962
       -
           }

     

       963
       -
       }

     

       964
       -
       

     

       965
       -
       impl<'a> ::jacquard_lexicon::schema::LexiconSchema for File<'a> {

     

       966
       -
           fn nsid() -> &'static str {

     

       967
       -
               "place.wisp.fs"

     

       968
       -
           }

     

       969
       -
           fn def_name() -> &'static str {

     

       970
       -
               "file"

     

       971
       -
           }

     

       972
       -
           fn lexicon_doc() -> ::jacquard_lexicon::lexicon::LexiconDoc<'static> {

     

       973
       -
               lexicon_doc_place_wisp_fs()

     

       974
       -
           }

     

       975
       -
           fn validate(

     

       976
       -
               &self,

     

       977
       -
           ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> {

     

       978
       -
               Ok(())

     

       979
       -
           }

     

       980
       -
       }

     

       981
       -
       

     

       982
       -
       /// Virtual filesystem manifest for a Wisp site

     

       983
       -
       #[jacquard_derive::lexicon]

     

       984
       -
       #[derive(

     

       985
       -
           serde::Serialize,

     

       986
       -
           serde::Deserialize,

     

       987
       -
           Debug,

     

       988
       -
           Clone,

     

       989
       -
           PartialEq,

     

       990
       -
           Eq,

     

       991
       -
           jacquard_derive::IntoStatic

     

       992
       -
       )]

     

       993
       -
       #[serde(rename_all = "camelCase")]

     

       994
       -
       pub struct Fs<'a> {

     

       995
       -
           pub created_at: jacquard_common::types::string::Datetime,

     

       996
       -
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       997
       -
           pub file_count: Option<i64>,

     

       998
       -
           #[serde(borrow)]

     

       999
       -
           pub root: crate::place_wisp::fs::Directory<'a>,

     

       1000
       -
           #[serde(borrow)]

     

       1001
       -
           pub site: jacquard_common::CowStr<'a>,

     

       1002
       -
       }

     

       1003
       -
       

     

       1004
       -
       pub mod fs_state {

     

       1005
       -
       

     

       1006
       -
           pub use crate::builder_types::{Set, Unset, IsSet, IsUnset};

     

       1007
       -
           #[allow(unused)]

     

       1008
       -
           use ::core::marker::PhantomData;

     

       1009
       -
           mod sealed {

     

       1010
       -
               pub trait Sealed {}

     

       1011
       -
           }

     

       1012
       -
           /// State trait tracking which required fields have been set

     

       1013
       -
           pub trait State: sealed::Sealed {

     

       1014
       -
               type Site;

     

       1015
       -
               type Root;

     

       1016
       -
               type CreatedAt;

     

       1017
       -
           }

     

       1018
       -
           /// Empty state - all required fields are unset

     

       1019
       -
           pub struct Empty(());

     

       1020
       -
           impl sealed::Sealed for Empty {}

     

       1021
       -
           impl State for Empty {

     

       1022
       -
               type Site = Unset;

     

       1023
       -
               type Root = Unset;

     

       1024
       -
               type CreatedAt = Unset;

     

       1025
       -
           }

     

       1026
       -
           ///State transition - sets the `site` field to Set

     

       1027
       -
           pub struct SetSite<S: State = Empty>(PhantomData<fn() -> S>);

     

       1028
       -
           impl<S: State> sealed::Sealed for SetSite<S> {}

     

       1029
       -
           impl<S: State> State for SetSite<S> {

     

       1030
       -
               type Site = Set<members::site>;

     

       1031
       -
               type Root = S::Root;

     

       1032
       -
               type CreatedAt = S::CreatedAt;

     

       1033
       -
           }

     

       1034
       -
           ///State transition - sets the `root` field to Set

     

       1035
       -
           pub struct SetRoot<S: State = Empty>(PhantomData<fn() -> S>);

     

       1036
       -
           impl<S: State> sealed::Sealed for SetRoot<S> {}

     

       1037
       -
           impl<S: State> State for SetRoot<S> {

     

       1038
       -
               type Site = S::Site;

     

       1039
       -
               type Root = Set<members::root>;

     

       1040
       -
               type CreatedAt = S::CreatedAt;

     

       1041
       -
           }

     

       1042
       -
           ///State transition - sets the `created_at` field to Set

     

       1043
       -
           pub struct SetCreatedAt<S: State = Empty>(PhantomData<fn() -> S>);

     

       1044
       -
           impl<S: State> sealed::Sealed for SetCreatedAt<S> {}

     

       1045
       -
           impl<S: State> State for SetCreatedAt<S> {

     

       1046
       -
               type Site = S::Site;

     

       1047
       -
               type Root = S::Root;

     

       1048
       -
               type CreatedAt = Set<members::created_at>;

     

       1049
       -
           }

     

       1050
       -
           /// Marker types for field names

     

       1051
       -
           #[allow(non_camel_case_types)]

     

       1052
       -
           pub mod members {

     

       1053
       -
               ///Marker type for the `site` field

     

       1054
       -
               pub struct site(());

     

       1055
       -
               ///Marker type for the `root` field

     

       1056
       -
               pub struct root(());

     

       1057
       -
               ///Marker type for the `created_at` field

     

       1058
       -
               pub struct created_at(());

     

       1059
       -
           }

     

       1060
       -
       }

     

       1061
       -
       

     

       1062
       -
       /// Builder for constructing an instance of this type

     

       1063
       -
       pub struct FsBuilder<'a, S: fs_state::State> {

     

       1064
       -
           _phantom_state: ::core::marker::PhantomData<fn() -> S>,

     

       1065
       -
           __unsafe_private_named: (

     

       1066
       -
               ::core::option::Option<jacquard_common::types::string::Datetime>,

     

       1067
       -
               ::core::option::Option<i64>,

     

       1068
       -
               ::core::option::Option<crate::place_wisp::fs::Directory<'a>>,

     

       1069
       -
               ::core::option::Option<jacquard_common::CowStr<'a>>,

     

       1070
       -
           ),

     

       1071
       -
           _phantom: ::core::marker::PhantomData<&'a ()>,

     

       1072
       -
       }

     

       1073
       -
       

     

       1074
       -
       impl<'a> Fs<'a> {

     

       1075
       -
           /// Create a new builder for this type

     

       1076
       -
           pub fn new() -> FsBuilder<'a, fs_state::Empty> {

     

       1077
       -
               FsBuilder::new()

     

       1078
       -
           }

     

       1079
       -
       }

     

       1080
       -
       

     

       1081
       -
       impl<'a> FsBuilder<'a, fs_state::Empty> {

     

       1082
       -
           /// Create a new builder with all fields unset

     

       1083
       -
           pub fn new() -> Self {

     

       1084
       -
               FsBuilder {

     

       1085
       -
                   _phantom_state: ::core::marker::PhantomData,

     

       1086
       -
                   __unsafe_private_named: (None, None, None, None),

     

       1087
       -
                   _phantom: ::core::marker::PhantomData,

     

       1088
       -
               }

     

       1089
       -
           }

     

       1090
       -
       }

     

       1091
       -
       

     

       1092
       -
       impl<'a, S> FsBuilder<'a, S>

     

       1093
       -
       where

     

       1094
       -
           S: fs_state::State,

     

       1095
       -
           S::CreatedAt: fs_state::IsUnset,

     

       1096
       -
       {

     

       1097
       -
           /// Set the `createdAt` field (required)

     

       1098
       -
           pub fn created_at(

     

       1099
       -
               mut self,

     

       1100
       -
               value: impl Into<jacquard_common::types::string::Datetime>,

     

       1101
       -
           ) -> FsBuilder<'a, fs_state::SetCreatedAt<S>> {

     

       1102
       -
               self.__unsafe_private_named.0 = ::core::option::Option::Some(value.into());

     

       1103
       -
               FsBuilder {

     

       1104
       -
                   _phantom_state: ::core::marker::PhantomData,

     

       1105
       -
                   __unsafe_private_named: self.__unsafe_private_named,

     

       1106
       -
                   _phantom: ::core::marker::PhantomData,

     

       1107
       -
               }

     

       1108
       -
           }

     

       1109
       -
       }

     

       1110
       -
       

     

       1111
       -
       impl<'a, S: fs_state::State> FsBuilder<'a, S> {

     

       1112
       -
           /// Set the `fileCount` field (optional)

     

       1113
       -
           pub fn file_count(mut self, value: impl Into<Option<i64>>) -> Self {

     

       1114
       -
               self.__unsafe_private_named.1 = value.into();

     

       1115
       -
               self

     

       1116
       -
           }

     

       1117
       -
           /// Set the `fileCount` field to an Option value (optional)

     

       1118
       -
           pub fn maybe_file_count(mut self, value: Option<i64>) -> Self {

     

       1119
       -
               self.__unsafe_private_named.1 = value;

     

       1120
       -
               self

     

       1121
       -
           }

     

       1122
       -
       }

     

       1123
       -
       

     

       1124
       -
       impl<'a, S> FsBuilder<'a, S>

     

       1125
       -
       where

     

       1126
       -
           S: fs_state::State,

     

       1127
       -
           S::Root: fs_state::IsUnset,

     

       1128
       -
       {

     

       1129
       -
           /// Set the `root` field (required)

     

       1130
       -
           pub fn root(

     

       1131
       -
               mut self,

     

       1132
       -
               value: impl Into<crate::place_wisp::fs::Directory<'a>>,

     

       1133
       -
           ) -> FsBuilder<'a, fs_state::SetRoot<S>> {

     

       1134
       -
               self.__unsafe_private_named.2 = ::core::option::Option::Some(value.into());

     

       1135
       -
               FsBuilder {

     

       1136
       -
                   _phantom_state: ::core::marker::PhantomData,

     

       1137
       -
                   __unsafe_private_named: self.__unsafe_private_named,

     

       1138
       -
                   _phantom: ::core::marker::PhantomData,

     

       1139
       -
               }

     

       1140
       -
           }

     

       1141
       -
       }

     

       1142
       -
       

     

       1143
       -
       impl<'a, S> FsBuilder<'a, S>

     

       1144
       -
       where

     

       1145
       -
           S: fs_state::State,

     

       1146
       -
           S::Site: fs_state::IsUnset,

     

       1147
       -
       {

     

       1148
       -
           /// Set the `site` field (required)

     

       1149
       -
           pub fn site(

     

       1150
       -
               mut self,

     

       1151
       -
               value: impl Into<jacquard_common::CowStr<'a>>,

     

       1152
       -
           ) -> FsBuilder<'a, fs_state::SetSite<S>> {

     

       1153
       -
               self.__unsafe_private_named.3 = ::core::option::Option::Some(value.into());

     

       1154
       -
               FsBuilder {

     

       1155
       -
                   _phantom_state: ::core::marker::PhantomData,

     

       1156
       -
                   __unsafe_private_named: self.__unsafe_private_named,

     

       1157
       -
                   _phantom: ::core::marker::PhantomData,

     

       1158
       -
               }

     

       1159
       -
           }

     

       1160
       -
       }

     

       1161
       -
       

     

       1162
       -
       impl<'a, S> FsBuilder<'a, S>

     

       1163
       -
       where

     

       1164
       -
           S: fs_state::State,

     

       1165
       -
           S::Site: fs_state::IsSet,

     

       1166
       -
           S::Root: fs_state::IsSet,

     

       1167
       -
           S::CreatedAt: fs_state::IsSet,

     

       1168
       -
       {

     

       1169
       -
           /// Build the final struct

     

       1170
       -
           pub fn build(self) -> Fs<'a> {

     

       1171
       -
               Fs {

     

       1172
       -
                   created_at: self.__unsafe_private_named.0.unwrap(),

     

       1173
       -
                   file_count: self.__unsafe_private_named.1,

     

       1174
       -
                   root: self.__unsafe_private_named.2.unwrap(),

     

       1175
       -
                   site: self.__unsafe_private_named.3.unwrap(),

     

       1176
       -
                   extra_data: Default::default(),

     

       1177
       -
               }

     

       1178
       -
           }

     

       1179
       -
           /// Build the final struct with custom extra_data

     

       1180
       -
           pub fn build_with_data(

     

       1181
       -
               self,

     

       1182
       -
               extra_data: std::collections::BTreeMap<

     

       1183
       -
                   jacquard_common::smol_str::SmolStr,

     

       1184
       -
                   jacquard_common::types::value::Data<'a>,

     

       1185
       -
               >,

     

       1186
       -
           ) -> Fs<'a> {

     

       1187
       -
               Fs {

     

       1188
       -
                   created_at: self.__unsafe_private_named.0.unwrap(),

     

       1189
       -
                   file_count: self.__unsafe_private_named.1,

     

       1190
       -
                   root: self.__unsafe_private_named.2.unwrap(),

     

       1191
       -
                   site: self.__unsafe_private_named.3.unwrap(),

     

       1192
       -
                   extra_data: Some(extra_data),

     

       1193
       -
               }

     

       1194
       -
           }

     

       1195
       -
       }

     

       1196
       -
       

     

       1197
       -
       impl<'a> Fs<'a> {

     

       1198
       -
           pub fn uri(

     

       1199
       -
               uri: impl Into<jacquard_common::CowStr<'a>>,

     

       1200
       -
           ) -> Result<

     

       1201
       -
               jacquard_common::types::uri::RecordUri<'a, FsRecord>,

     

       1202
       -
               jacquard_common::types::uri::UriError,

     

       1203
       -
           > {

     

       1204
       -
               jacquard_common::types::uri::RecordUri::try_from_uri(

     

       1205
       -
                   jacquard_common::types::string::AtUri::new_cow(uri.into())?,

     

       1206
       -
               )

     

       1207
       -
           }

     

       1208
       -
       }

     

       1209
       -
       

     

       1210
       -
       /// Typed wrapper for GetRecord response with this collection's record type.

     

       1211
       -
       #[derive(

     

       1212
       -
           serde::Serialize,

     

       1213
       -
           serde::Deserialize,

     

       1214
       -
           Debug,

     

       1215
       -
           Clone,

     

       1216
       -
           PartialEq,

     

       1217
       -
           Eq,

     

       1218
       -
           jacquard_derive::IntoStatic

     

       1219
       -
       )]

     

       1220
       -
       #[serde(rename_all = "camelCase")]

     

       1221
       -
       pub struct FsGetRecordOutput<'a> {

     

       1222
       -
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       1223
       -
           #[serde(borrow)]

     

       1224
       -
           pub cid: std::option::Option<jacquard_common::types::string::Cid<'a>>,

     

       1225
       -
           #[serde(borrow)]

     

       1226
       -
           pub uri: jacquard_common::types::string::AtUri<'a>,

     

       1227
       -
           #[serde(borrow)]

     

       1228
       -
           pub value: Fs<'a>,

     

       1229
       -
       }

     

       1230
       -
       

     

       1231
       -
       impl From<FsGetRecordOutput<'_>> for Fs<'_> {

     

       1232
       -
           fn from(output: FsGetRecordOutput<'_>) -> Self {

     

       1233
       -
               use jacquard_common::IntoStatic;

     

       1234
       -
               output.value.into_static()

     

       1235
       -
           }

     

       1236
       -
       }

     

       1237
       -
       

     

       1238
       -
       impl jacquard_common::types::collection::Collection for Fs<'_> {

     

       1239
       -
           const NSID: &'static str = "place.wisp.fs";

     

       1240
       -
           type Record = FsRecord;

     

       1241
       -
       }

     

       1242
       -
       

     

       1243
       -
       /// Marker type for deserializing records from this collection.

     

       1244
       -
       #[derive(Debug, serde::Serialize, serde::Deserialize)]

     

       1245
       -
       pub struct FsRecord;

     

       1246
       -
       impl jacquard_common::xrpc::XrpcResp for FsRecord {

     

       1247
       -
           const NSID: &'static str = "place.wisp.fs";

     

       1248
       -
           const ENCODING: &'static str = "application/json";

     

       1249
       -
           type Output<'de> = FsGetRecordOutput<'de>;

     

       1250
       -
           type Err<'de> = jacquard_common::types::collection::RecordError<'de>;

     

       1251
       -
       }

     

       1252
       -
       

     

       1253
       -
       impl jacquard_common::types::collection::Collection for FsRecord {

     

       1254
       -
           const NSID: &'static str = "place.wisp.fs";

     

       1255
       -
           type Record = FsRecord;

     

       1256
       -
       }

     

       1257
       -
       

     

       1258
       -
       impl<'a> ::jacquard_lexicon::schema::LexiconSchema for Fs<'a> {

     

       1259
       -
           fn nsid() -> &'static str {

     

       1260
       -
               "place.wisp.fs"

     

       1261
       -
           }

     

       1262
       -
           fn def_name() -> &'static str {

     

       1263
       -
               "main"

     

       1264
       -
           }

     

       1265
       -
           fn lexicon_doc() -> ::jacquard_lexicon::lexicon::LexiconDoc<'static> {

     

       1266
       -
               lexicon_doc_place_wisp_fs()

     

       1267
       -
           }

     

       1268
       -
           fn validate(

     

       1269
       -
               &self,

     

       1270
       -
           ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> {

     

       1271
       -
               if let Some(ref value) = self.file_count {

     

       1272
       -
                   if *value > 1000i64 {

     

       1273
       -
                       return Err(::jacquard_lexicon::validation::ConstraintError::Maximum {

     

       1274
       -
                           path: ::jacquard_lexicon::validation::ValidationPath::from_field(

     

       1275
       -
                               "file_count",

     

       1276
       -
                           ),

     

       1277
       -
                           max: 1000i64,

     

       1278
       -
                           actual: *value,

     

       1279
       -
                       });

     

       1280
       -
                   }

     

       1281
       -
               }

     

       1282
       -
               if let Some(ref value) = self.file_count {

     

       1283
       -
                   if *value < 0i64 {

     

       1284
       -
                       return Err(::jacquard_lexicon::validation::ConstraintError::Minimum {

     

       1285
       -
                           path: ::jacquard_lexicon::validation::ValidationPath::from_field(

     

       1286
       -
                               "file_count",

     

       1287
       -
                           ),

     

       1288
       -
                           min: 0i64,

     

       1289
       -
                           actual: *value,

     

       1290
       -
                       });

     

       1291
       -
                   }

     

       1292
       -
               }

     

       1293
       -
               Ok(())

     

       1294
       -
           }

     

       1295
       -
       }

     

       1296
       -
       

     

       1297
       -
       #[jacquard_derive::lexicon]

     

       1298
       -
       #[derive(

     

       1299
       -
           serde::Serialize,

     

       1300
       -
           serde::Deserialize,

     

       1301
       -
           Debug,

     

       1302
       -
           Clone,

     

       1303
       -
           PartialEq,

     

       1304
       -
           Eq,

     

       1305
       -
           jacquard_derive::IntoStatic

     

       1306
       -
       )]

     

       1307
       -
       #[serde(rename_all = "camelCase")]

     

       1308
       -
       pub struct Subfs<'a> {

     

       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
       -
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       1311
       -
           pub flat: Option<bool>,

     

       1312
       -
           /// AT-URI pointing to a place.wisp.subfs record containing this subtree.

     

       1313
       -
           #[serde(borrow)]

     

       1314
       -
           pub subject: jacquard_common::types::string::AtUri<'a>,

     

       1315
       -
           #[serde(borrow)]

     

       1316
       -
           pub r#type: jacquard_common::CowStr<'a>,

     

       1317
       -
       }

     

       1318
       -
       

     

       1319
       -
       pub mod subfs_state {

     

       1320
       -
       

     

       1321
       -
           pub use crate::builder_types::{Set, Unset, IsSet, IsUnset};

     

       1322
       -
           #[allow(unused)]

     

       1323
       -
           use ::core::marker::PhantomData;

     

       1324
       -
           mod sealed {

     

       1325
       -
               pub trait Sealed {}

     

       1326
       -
           }

     

       1327
       -
           /// State trait tracking which required fields have been set

     

       1328
       -
           pub trait State: sealed::Sealed {

     

       1329
       -
               type Type;

     

       1330
       -
               type Subject;

     

       1331
       -
           }

     

       1332
       -
           /// Empty state - all required fields are unset

     

       1333
       -
           pub struct Empty(());

     

       1334
       -
           impl sealed::Sealed for Empty {}

     

       1335
       -
           impl State for Empty {

     

       1336
       -
               type Type = Unset;

     

       1337
       -
               type Subject = Unset;

     

       1338
       -
           }

     

       1339
       -
           ///State transition - sets the `type` field to Set

     

       1340
       -
           pub struct SetType<S: State = Empty>(PhantomData<fn() -> S>);

     

       1341
       -
           impl<S: State> sealed::Sealed for SetType<S> {}

     

       1342
       -
           impl<S: State> State for SetType<S> {

     

       1343
       -
               type Type = Set<members::r#type>;

     

       1344
       -
               type Subject = S::Subject;

     

       1345
       -
           }

     

       1346
       -
           ///State transition - sets the `subject` field to Set

     

       1347
       -
           pub struct SetSubject<S: State = Empty>(PhantomData<fn() -> S>);

     

       1348
       -
           impl<S: State> sealed::Sealed for SetSubject<S> {}

     

       1349
       -
           impl<S: State> State for SetSubject<S> {

     

       1350
       -
               type Type = S::Type;

     

       1351
       -
               type Subject = Set<members::subject>;

     

       1352
       -
           }

     

       1353
       -
           /// Marker types for field names

     

       1354
       -
           #[allow(non_camel_case_types)]

     

       1355
       -
           pub mod members {

     

       1356
       -
               ///Marker type for the `type` field

     

       1357
       -
               pub struct r#type(());

     

       1358
       -
               ///Marker type for the `subject` field

     

       1359
       -
               pub struct subject(());

     

       1360
       -
           }

     

       1361
       -
       }

     

       1362
       -
       

     

       1363
       -
       /// Builder for constructing an instance of this type

     

       1364
       -
       pub struct SubfsBuilder<'a, S: subfs_state::State> {

     

       1365
       -
           _phantom_state: ::core::marker::PhantomData<fn() -> S>,

     

       1366
       -
           __unsafe_private_named: (

     

       1367
       -
               ::core::option::Option<bool>,

     

       1368
       -
               ::core::option::Option<jacquard_common::types::string::AtUri<'a>>,

     

       1369
       -
               ::core::option::Option<jacquard_common::CowStr<'a>>,

     

       1370
       -
           ),

     

       1371
       -
           _phantom: ::core::marker::PhantomData<&'a ()>,

     

       1372
       -
       }

     

       1373
       -
       

     

       1374
       -
       impl<'a> Subfs<'a> {

     

       1375
       -
           /// Create a new builder for this type

     

       1376
       -
           pub fn new() -> SubfsBuilder<'a, subfs_state::Empty> {

     

       1377
       -
               SubfsBuilder::new()

     

       1378
       -
           }

     

       1379
       -
       }

     

       1380
       -
       

     

       1381
       -
       impl<'a> SubfsBuilder<'a, subfs_state::Empty> {

     

       1382
       -
           /// Create a new builder with all fields unset

     

       1383
       -
           pub fn new() -> Self {

     

       1384
       -
               SubfsBuilder {

     

       1385
       -
                   _phantom_state: ::core::marker::PhantomData,

     

       1386
       -
                   __unsafe_private_named: (None, None, None),

     

       1387
       -
                   _phantom: ::core::marker::PhantomData,

     

       1388
       -
               }

     

       1389
       -
           }

     

       1390
       -
       }

     

       1391
       -
       

     

       1392
       -
       impl<'a, S: subfs_state::State> SubfsBuilder<'a, S> {

     

       1393
       -
           /// Set the `flat` field (optional)

     

       1394
       -
           pub fn flat(mut self, value: impl Into<Option<bool>>) -> Self {

     

       1395
       -
               self.__unsafe_private_named.0 = value.into();

     

       1396
       -
               self

     

       1397
       -
           }

     

       1398
       -
           /// Set the `flat` field to an Option value (optional)

     

       1399
       -
           pub fn maybe_flat(mut self, value: Option<bool>) -> Self {

     

       1400
       -
               self.__unsafe_private_named.0 = value;

     

       1401
       -
               self

     

       1402
       -
           }

     

       1403
       -
       }

     

       1404
       -
       

     

       1405
       -
       impl<'a, S> SubfsBuilder<'a, S>

     

       1406
       -
       where

     

       1407
       -
           S: subfs_state::State,

     

       1408
       -
           S::Subject: subfs_state::IsUnset,

     

       1409
       -
       {

     

       1410
       -
           /// Set the `subject` field (required)

     

       1411
       -
           pub fn subject(

     

       1412
       -
               mut self,

     

       1413
       -
               value: impl Into<jacquard_common::types::string::AtUri<'a>>,

     

       1414
       -
           ) -> SubfsBuilder<'a, subfs_state::SetSubject<S>> {

     

       1415
       -
               self.__unsafe_private_named.1 = ::core::option::Option::Some(value.into());

     

       1416
       -
               SubfsBuilder {

     

       1417
       -
                   _phantom_state: ::core::marker::PhantomData,

     

       1418
       -
                   __unsafe_private_named: self.__unsafe_private_named,

     

       1419
       -
                   _phantom: ::core::marker::PhantomData,

     

       1420
       -
               }

     

       1421
       -
           }

     

       1422
       -
       }

     

       1423
       -
       

     

       1424
       -
       impl<'a, S> SubfsBuilder<'a, S>

     

       1425
       -
       where

     

       1426
       -
           S: subfs_state::State,

     

       1427
       -
           S::Type: subfs_state::IsUnset,

     

       1428
       -
       {

     

       1429
       -
           /// Set the `type` field (required)

     

       1430
       -
           pub fn r#type(

     

       1431
       -
               mut self,

     

       1432
       -
               value: impl Into<jacquard_common::CowStr<'a>>,

     

       1433
       -
           ) -> SubfsBuilder<'a, subfs_state::SetType<S>> {

     

       1434
       -
               self.__unsafe_private_named.2 = ::core::option::Option::Some(value.into());

     

       1435
       -
               SubfsBuilder {

     

       1436
       -
                   _phantom_state: ::core::marker::PhantomData,

     

       1437
       -
                   __unsafe_private_named: self.__unsafe_private_named,

     

       1438
       -
                   _phantom: ::core::marker::PhantomData,

     

       1439
       -
               }

     

       1440
       -
           }

     

       1441
       -
       }

     

       1442
       -
       

     

       1443
       -
       impl<'a, S> SubfsBuilder<'a, S>

     

       1444
       -
       where

     

       1445
       -
           S: subfs_state::State,

     

       1446
       -
           S::Type: subfs_state::IsSet,

     

       1447
       -
           S::Subject: subfs_state::IsSet,

     

       1448
       -
       {

     

       1449
       -
           /// Build the final struct

     

       1450
       -
           pub fn build(self) -> Subfs<'a> {

     

       1451
       -
               Subfs {

     

       1452
       -
                   flat: self.__unsafe_private_named.0,

     

       1453
       -
                   subject: self.__unsafe_private_named.1.unwrap(),

     

       1454
       -
                   r#type: self.__unsafe_private_named.2.unwrap(),

     

       1455
       -
                   extra_data: Default::default(),

     

       1456
       -
               }

     

       1457
       -
           }

     

       1458
       -
           /// Build the final struct with custom extra_data

     

       1459
       -
           pub fn build_with_data(

     

       1460
       -
               self,

     

       1461
       -
               extra_data: std::collections::BTreeMap<

     

       1462
       -
                   jacquard_common::smol_str::SmolStr,

     

       1463
       -
                   jacquard_common::types::value::Data<'a>,

     

       1464
       -
               >,

     

       1465
       -
           ) -> Subfs<'a> {

     

       1466
       -
               Subfs {

     

       1467
       -
                   flat: self.__unsafe_private_named.0,

     

       1468
       -
                   subject: self.__unsafe_private_named.1.unwrap(),

     

       1469
       -
                   r#type: self.__unsafe_private_named.2.unwrap(),

     

       1470
       -
                   extra_data: Some(extra_data),

     

       1471
       -
               }

     

       1472
       -
           }

     

       1473
       -
       }

     

       1474
       -
       

     

       1475
       -
       impl<'a> ::jacquard_lexicon::schema::LexiconSchema for Subfs<'a> {

     

       1476
       -
           fn nsid() -> &'static str {

     

       1477
       -
               "place.wisp.fs"

     

       1478
       -
           }

     

       1479
       -
           fn def_name() -> &'static str {

     

       1480
       -
               "subfs"

     

       1481
       -
           }

     

       1482
       -
           fn lexicon_doc() -> ::jacquard_lexicon::lexicon::LexiconDoc<'static> {

     

       1483
       -
               lexicon_doc_place_wisp_fs()

     

       1484
       -
           }

     

       1485
       -
           fn validate(

     

       1486
       -
               &self,

     

       1487
       -
           ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> {

     

       1488
       -
               Ok(())

     

       1489
       -
           }

     

       1490
       -
       }

-653

cli/src/place_wisp/settings.rs

···

       1
       -
       // @generated by jacquard-lexicon. DO NOT EDIT.

     

       2
       -
       //

     

       3
       -
       // Lexicon: place.wisp.settings

     

       4
       -
       //

     

       5
       -
       // This file was automatically generated from Lexicon schemas.

     

       6
       -
       // Any manual changes will be overwritten on the next regeneration.

     

       7
       -
       

     

       8
       -
       /// Custom HTTP header configuration

     

       9
       -
       #[jacquard_derive::lexicon]

     

       10
       -
       #[derive(

     

       11
       -
           serde::Serialize,

     

       12
       -
           serde::Deserialize,

     

       13
       -
           Debug,

     

       14
       -
           Clone,

     

       15
       -
           PartialEq,

     

       16
       -
           Eq,

     

       17
       -
           jacquard_derive::IntoStatic,

     

       18
       -
           Default

     

       19
       -
       )]

     

       20
       -
       #[serde(rename_all = "camelCase")]

     

       21
       -
       pub struct CustomHeader<'a> {

     

       22
       -
           /// HTTP header name (e.g., 'Cache-Control', 'X-Frame-Options')

     

       23
       -
           #[serde(borrow)]

     

       24
       -
           pub name: jacquard_common::CowStr<'a>,

     

       25
       -
           /// Optional glob pattern to apply this header to specific paths (e.g., '*.html', '/assets/*'). If not specified, applies to all paths.

     

       26
       -
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       27
       -
           #[serde(borrow)]

     

       28
       -
           pub path: std::option::Option<jacquard_common::CowStr<'a>>,

     

       29
       -
           /// HTTP header value

     

       30
       -
           #[serde(borrow)]

     

       31
       -
           pub value: jacquard_common::CowStr<'a>,

     

       32
       -
       }

     

       33
       -
       

     

       34
       -
       fn lexicon_doc_place_wisp_settings() -> ::jacquard_lexicon::lexicon::LexiconDoc<

     

       35
       -
           'static,

     

       36
       -
       > {

     

       37
       -
           ::jacquard_lexicon::lexicon::LexiconDoc {

     

       38
       -
               lexicon: ::jacquard_lexicon::lexicon::Lexicon::Lexicon1,

     

       39
       -
               id: ::jacquard_common::CowStr::new_static("place.wisp.settings"),

     

       40
       -
               revision: None,

     

       41
       -
               description: None,

     

       42
       -
               defs: {

     

       43
       -
                   let mut map = ::std::collections::BTreeMap::new();

     

       44
       -
                   map.insert(

     

       45
       -
                       ::jacquard_common::smol_str::SmolStr::new_static("customHeader"),

     

       46
       -
                       ::jacquard_lexicon::lexicon::LexUserType::Object(::jacquard_lexicon::lexicon::LexObject {

     

       47
       -
                           description: Some(

     

       48
       -
                               ::jacquard_common::CowStr::new_static(

     

       49
       -
                                   "Custom HTTP header configuration",

     

       50
       -
                               ),

     

       51
       -
                           ),

     

       52
       -
                           required: Some(

     

       53
       -
                               vec![

     

       54
       -
                                   ::jacquard_common::smol_str::SmolStr::new_static("name"),

     

       55
       -
                                   ::jacquard_common::smol_str::SmolStr::new_static("value")

     

       56
       -
                               ],

     

       57
       -
                           ),

     

       58
       -
                           nullable: None,

     

       59
       -
                           properties: {

     

       60
       -
                               #[allow(unused_mut)]

     

       61
       -
                               let mut map = ::std::collections::BTreeMap::new();

     

       62
       -
                               map.insert(

     

       63
       -
                                   ::jacquard_common::smol_str::SmolStr::new_static("name"),

     

       64
       -
                                   ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {

     

       65
       -
                                       description: Some(

     

       66
       -
                                           ::jacquard_common::CowStr::new_static(

     

       67
       -
                                               "HTTP header name (e.g., 'Cache-Control', 'X-Frame-Options')",

     

       68
       -
                                           ),

     

       69
       -
                                       ),

     

       70
       -
                                       format: None,

     

       71
       -
                                       default: None,

     

       72
       -
                                       min_length: None,

     

       73
       -
                                       max_length: Some(100usize),

     

       74
       -
                                       min_graphemes: None,

     

       75
       -
                                       max_graphemes: None,

     

       76
       -
                                       r#enum: None,

     

       77
       -
                                       r#const: None,

     

       78
       -
                                       known_values: None,

     

       79
       -
                                   }),

     

       80
       -
                               );

     

       81
       -
                               map.insert(

     

       82
       -
                                   ::jacquard_common::smol_str::SmolStr::new_static("path"),

     

       83
       -
                                   ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {

     

       84
       -
                                       description: Some(

     

       85
       -
                                           ::jacquard_common::CowStr::new_static(

     

       86
       -
                                               "Optional glob pattern to apply this header to specific paths (e.g., '*.html', '/assets/*'). If not specified, applies to all paths.",

     

       87
       -
                                           ),

     

       88
       -
                                       ),

     

       89
       -
                                       format: None,

     

       90
       -
                                       default: None,

     

       91
       -
                                       min_length: None,

     

       92
       -
                                       max_length: Some(500usize),

     

       93
       -
                                       min_graphemes: None,

     

       94
       -
                                       max_graphemes: None,

     

       95
       -
                                       r#enum: None,

     

       96
       -
                                       r#const: None,

     

       97
       -
                                       known_values: None,

     

       98
       -
                                   }),

     

       99
       -
                               );

     

       100
       -
                               map.insert(

     

       101
       -
                                   ::jacquard_common::smol_str::SmolStr::new_static("value"),

     

       102
       -
                                   ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {

     

       103
       -
                                       description: Some(

     

       104
       -
                                           ::jacquard_common::CowStr::new_static("HTTP header value"),

     

       105
       -
                                       ),

     

       106
       -
                                       format: None,

     

       107
       -
                                       default: None,

     

       108
       -
                                       min_length: None,

     

       109
       -
                                       max_length: Some(1000usize),

     

       110
       -
                                       min_graphemes: None,

     

       111
       -
                                       max_graphemes: None,

     

       112
       -
                                       r#enum: None,

     

       113
       -
                                       r#const: None,

     

       114
       -
                                       known_values: None,

     

       115
       -
                                   }),

     

       116
       -
                               );

     

       117
       -
                               map

     

       118
       -
                           },

     

       119
       -
                       }),

     

       120
       -
                   );

     

       121
       -
                   map.insert(

     

       122
       -
                       ::jacquard_common::smol_str::SmolStr::new_static("main"),

     

       123
       -
                       ::jacquard_lexicon::lexicon::LexUserType::Record(::jacquard_lexicon::lexicon::LexRecord {

     

       124
       -
                           description: Some(

     

       125
       -
                               ::jacquard_common::CowStr::new_static(

     

       126
       -
                                   "Configuration settings for a static site hosted on wisp.place",

     

       127
       -
                               ),

     

       128
       -
                           ),

     

       129
       -
                           key: Some(::jacquard_common::CowStr::new_static("any")),

     

       130
       -
                           record: ::jacquard_lexicon::lexicon::LexRecordRecord::Object(::jacquard_lexicon::lexicon::LexObject {

     

       131
       -
                               description: None,

     

       132
       -
                               required: None,

     

       133
       -
                               nullable: None,

     

       134
       -
                               properties: {

     

       135
       -
                                   #[allow(unused_mut)]

     

       136
       -
                                   let mut map = ::std::collections::BTreeMap::new();

     

       137
       -
                                   map.insert(

     

       138
       -
                                       ::jacquard_common::smol_str::SmolStr::new_static(

     

       139
       -
                                           "cleanUrls",

     

       140
       -
                                       ),

     

       141
       -
                                       ::jacquard_lexicon::lexicon::LexObjectProperty::Boolean(::jacquard_lexicon::lexicon::LexBoolean {

     

       142
       -
                                           description: None,

     

       143
       -
                                           default: None,

     

       144
       -
                                           r#const: None,

     

       145
       -
                                       }),

     

       146
       -
                                   );

     

       147
       -
                                   map.insert(

     

       148
       -
                                       ::jacquard_common::smol_str::SmolStr::new_static(

     

       149
       -
                                           "custom404",

     

       150
       -
                                       ),

     

       151
       -
                                       ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {

     

       152
       -
                                           description: Some(

     

       153
       -
                                               ::jacquard_common::CowStr::new_static(

     

       154
       -
                                                   "Custom 404 error page file path. Incompatible with directoryListing and spaMode.",

     

       155
       -
                                               ),

     

       156
       -
                                           ),

     

       157
       -
                                           format: None,

     

       158
       -
                                           default: None,

     

       159
       -
                                           min_length: None,

     

       160
       -
                                           max_length: Some(500usize),

     

       161
       -
                                           min_graphemes: None,

     

       162
       -
                                           max_graphemes: None,

     

       163
       -
                                           r#enum: None,

     

       164
       -
                                           r#const: None,

     

       165
       -
                                           known_values: None,

     

       166
       -
                                       }),

     

       167
       -
                                   );

     

       168
       -
                                   map.insert(

     

       169
       -
                                       ::jacquard_common::smol_str::SmolStr::new_static(

     

       170
       -
                                           "directoryListing",

     

       171
       -
                                       ),

     

       172
       -
                                       ::jacquard_lexicon::lexicon::LexObjectProperty::Boolean(::jacquard_lexicon::lexicon::LexBoolean {

     

       173
       -
                                           description: None,

     

       174
       -
                                           default: None,

     

       175
       -
                                           r#const: None,

     

       176
       -
                                       }),

     

       177
       -
                                   );

     

       178
       -
                                   map.insert(

     

       179
       -
                                       ::jacquard_common::smol_str::SmolStr::new_static("headers"),

     

       180
       -
                                       ::jacquard_lexicon::lexicon::LexObjectProperty::Array(::jacquard_lexicon::lexicon::LexArray {

     

       181
       -
                                           description: Some(

     

       182
       -
                                               ::jacquard_common::CowStr::new_static(

     

       183
       -
                                                   "Custom HTTP headers to set on responses",

     

       184
       -
                                               ),

     

       185
       -
                                           ),

     

       186
       -
                                           items: ::jacquard_lexicon::lexicon::LexArrayItem::Ref(::jacquard_lexicon::lexicon::LexRef {

     

       187
       -
                                               description: None,

     

       188
       -
                                               r#ref: ::jacquard_common::CowStr::new_static(

     

       189
       -
                                                   "#customHeader",

     

       190
       -
                                               ),

     

       191
       -
                                           }),

     

       192
       -
                                           min_length: None,

     

       193
       -
                                           max_length: Some(50usize),

     

       194
       -
                                       }),

     

       195
       -
                                   );

     

       196
       -
                                   map.insert(

     

       197
       -
                                       ::jacquard_common::smol_str::SmolStr::new_static(

     

       198
       -
                                           "indexFiles",

     

       199
       -
                                       ),

     

       200
       -
                                       ::jacquard_lexicon::lexicon::LexObjectProperty::Array(::jacquard_lexicon::lexicon::LexArray {

     

       201
       -
                                           description: Some(

     

       202
       -
                                               ::jacquard_common::CowStr::new_static(

     

       203
       -
                                                   "Ordered list of files to try when serving a directory. Defaults to ['index.html'] if not specified.",

     

       204
       -
                                               ),

     

       205
       -
                                           ),

     

       206
       -
                                           items: ::jacquard_lexicon::lexicon::LexArrayItem::String(::jacquard_lexicon::lexicon::LexString {

     

       207
       -
                                               description: None,

     

       208
       -
                                               format: None,

     

       209
       -
                                               default: None,

     

       210
       -
                                               min_length: None,

     

       211
       -
                                               max_length: Some(255usize),

     

       212
       -
                                               min_graphemes: None,

     

       213
       -
                                               max_graphemes: None,

     

       214
       -
                                               r#enum: None,

     

       215
       -
                                               r#const: None,

     

       216
       -
                                               known_values: None,

     

       217
       -
                                           }),

     

       218
       -
                                           min_length: None,

     

       219
       -
                                           max_length: Some(10usize),

     

       220
       -
                                       }),

     

       221
       -
                                   );

     

       222
       -
                                   map.insert(

     

       223
       -
                                       ::jacquard_common::smol_str::SmolStr::new_static("spaMode"),

     

       224
       -
                                       ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {

     

       225
       -
                                           description: Some(

     

       226
       -
                                               ::jacquard_common::CowStr::new_static(

     

       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
       -
                                               ),

     

       229
       -
                                           ),

     

       230
       -
                                           format: None,

     

       231
       -
                                           default: None,

     

       232
       -
                                           min_length: None,

     

       233
       -
                                           max_length: Some(500usize),

     

       234
       -
                                           min_graphemes: None,

     

       235
       -
                                           max_graphemes: None,

     

       236
       -
                                           r#enum: None,

     

       237
       -
                                           r#const: None,

     

       238
       -
                                           known_values: None,

     

       239
       -
                                       }),

     

       240
       -
                                   );

     

       241
       -
                                   map

     

       242
       -
                               },

     

       243
       -
                           }),

     

       244
       -
                       }),

     

       245
       -
                   );

     

       246
       -
                   map

     

       247
       -
               },

     

       248
       -
           }

     

       249
       -
       }

     

       250
       -
       

     

       251
       -
       impl<'a> ::jacquard_lexicon::schema::LexiconSchema for CustomHeader<'a> {

     

       252
       -
           fn nsid() -> &'static str {

     

       253
       -
               "place.wisp.settings"

     

       254
       -
           }

     

       255
       -
           fn def_name() -> &'static str {

     

       256
       -
               "customHeader"

     

       257
       -
           }

     

       258
       -
           fn lexicon_doc() -> ::jacquard_lexicon::lexicon::LexiconDoc<'static> {

     

       259
       -
               lexicon_doc_place_wisp_settings()

     

       260
       -
           }

     

       261
       -
           fn validate(

     

       262
       -
               &self,

     

       263
       -
           ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> {

     

       264
       -
               {

     

       265
       -
                   let value = &self.name;

     

       266
       -
                   #[allow(unused_comparisons)]

     

       267
       -
                   if <str>::len(value.as_ref()) > 100usize {

     

       268
       -
                       return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength {

     

       269
       -
                           path: ::jacquard_lexicon::validation::ValidationPath::from_field(

     

       270
       -
                               "name",

     

       271
       -
                           ),

     

       272
       -
                           max: 100usize,

     

       273
       -
                           actual: <str>::len(value.as_ref()),

     

       274
       -
                       });

     

       275
       -
                   }

     

       276
       -
               }

     

       277
       -
               if let Some(ref value) = self.path {

     

       278
       -
                   #[allow(unused_comparisons)]

     

       279
       -
                   if <str>::len(value.as_ref()) > 500usize {

     

       280
       -
                       return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength {

     

       281
       -
                           path: ::jacquard_lexicon::validation::ValidationPath::from_field(

     

       282
       -
                               "path",

     

       283
       -
                           ),

     

       284
       -
                           max: 500usize,

     

       285
       -
                           actual: <str>::len(value.as_ref()),

     

       286
       -
                       });

     

       287
       -
                   }

     

       288
       -
               }

     

       289
       -
               {

     

       290
       -
                   let value = &self.value;

     

       291
       -
                   #[allow(unused_comparisons)]

     

       292
       -
                   if <str>::len(value.as_ref()) > 1000usize {

     

       293
       -
                       return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength {

     

       294
       -
                           path: ::jacquard_lexicon::validation::ValidationPath::from_field(

     

       295
       -
                               "value",

     

       296
       -
                           ),

     

       297
       -
                           max: 1000usize,

     

       298
       -
                           actual: <str>::len(value.as_ref()),

     

       299
       -
                       });

     

       300
       -
                   }

     

       301
       -
               }

     

       302
       -
               Ok(())

     

       303
       -
           }

     

       304
       -
       }

     

       305
       -
       

     

       306
       -
       /// Configuration settings for a static site hosted on wisp.place

     

       307
       -
       #[jacquard_derive::lexicon]

     

       308
       -
       #[derive(

     

       309
       -
           serde::Serialize,

     

       310
       -
           serde::Deserialize,

     

       311
       -
           Debug,

     

       312
       -
           Clone,

     

       313
       -
           PartialEq,

     

       314
       -
           Eq,

     

       315
       -
           jacquard_derive::IntoStatic

     

       316
       -
       )]

     

       317
       -
       #[serde(rename_all = "camelCase")]

     

       318
       -
       pub struct Settings<'a> {

     

       319
       -
           /// Enable clean URL routing. When enabled, '/about' will attempt to serve '/about.html' or '/about/index.html' automatically.

     

       320
       -
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       321
       -
           pub clean_urls: std::option::Option<bool>,

     

       322
       -
           /// Custom 404 error page file path. Incompatible with directoryListing and spaMode.

     

       323
       -
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       324
       -
           #[serde(borrow)]

     

       325
       -
           pub custom404: std::option::Option<jacquard_common::CowStr<'a>>,

     

       326
       -
           /// Enable directory listing mode for paths that resolve to directories without an index file. Incompatible with spaMode.

     

       327
       -
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       328
       -
           pub directory_listing: std::option::Option<bool>,

     

       329
       -
           /// Custom HTTP headers to set on responses

     

       330
       -
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       331
       -
           #[serde(borrow)]

     

       332
       -
           pub headers: std::option::Option<Vec<crate::place_wisp::settings::CustomHeader<'a>>>,

     

       333
       -
           /// Ordered list of files to try when serving a directory. Defaults to ['index.html'] if not specified.

     

       334
       -
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       335
       -
           #[serde(borrow)]

     

       336
       -
           pub index_files: std::option::Option<Vec<jacquard_common::CowStr<'a>>>,

     

       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
       -
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       339
       -
           #[serde(borrow)]

     

       340
       -
           pub spa_mode: std::option::Option<jacquard_common::CowStr<'a>>,

     

       341
       -
       }

     

       342
       -
       

     

       343
       -
       pub mod settings_state {

     

       344
       -
       

     

       345
       -
           pub use crate::builder_types::{Set, Unset, IsSet, IsUnset};

     

       346
       -
           #[allow(unused)]

     

       347
       -
           use ::core::marker::PhantomData;

     

       348
       -
           mod sealed {

     

       349
       -
               pub trait Sealed {}

     

       350
       -
           }

     

       351
       -
           /// State trait tracking which required fields have been set

     

       352
       -
           pub trait State: sealed::Sealed {}

     

       353
       -
           /// Empty state - all required fields are unset

     

       354
       -
           pub struct Empty(());

     

       355
       -
           impl sealed::Sealed for Empty {}

     

       356
       -
           impl State for Empty {}

     

       357
       -
           /// Marker types for field names

     

       358
       -
           #[allow(non_camel_case_types)]

     

       359
       -
           pub mod members {}

     

       360
       -
       }

     

       361
       -
       

     

       362
       -
       /// Builder for constructing an instance of this type

     

       363
       -
       pub struct SettingsBuilder<'a, S: settings_state::State> {

     

       364
       -
           _phantom_state: ::core::marker::PhantomData<fn() -> S>,

     

       365
       -
           __unsafe_private_named: (

     

       366
       -
               ::core::option::Option<bool>,

     

       367
       -
               ::core::option::Option<jacquard_common::CowStr<'a>>,

     

       368
       -
               ::core::option::Option<bool>,

     

       369
       -
               ::core::option::Option<Vec<crate::place_wisp::settings::CustomHeader<'a>>>,

     

       370
       -
               ::core::option::Option<Vec<jacquard_common::CowStr<'a>>>,

     

       371
       -
               ::core::option::Option<jacquard_common::CowStr<'a>>,

     

       372
       -
           ),

     

       373
       -
           _phantom: ::core::marker::PhantomData<&'a ()>,

     

       374
       -
       }

     

       375
       -
       

     

       376
       -
       impl<'a> Settings<'a> {

     

       377
       -
           /// Create a new builder for this type

     

       378
       -
           pub fn new() -> SettingsBuilder<'a, settings_state::Empty> {

     

       379
       -
               SettingsBuilder::new()

     

       380
       -
           }

     

       381
       -
       }

     

       382
       -
       

     

       383
       -
       impl<'a> SettingsBuilder<'a, settings_state::Empty> {

     

       384
       -
           /// Create a new builder with all fields unset

     

       385
       -
           pub fn new() -> Self {

     

       386
       -
               SettingsBuilder {

     

       387
       -
                   _phantom_state: ::core::marker::PhantomData,

     

       388
       -
                   __unsafe_private_named: (None, None, None, None, None, None),

     

       389
       -
                   _phantom: ::core::marker::PhantomData,

     

       390
       -
               }

     

       391
       -
           }

     

       392
       -
       }

     

       393
       -
       

     

       394
       -
       impl<'a, S: settings_state::State> SettingsBuilder<'a, S> {

     

       395
       -
           /// Set the `cleanUrls` field (optional)

     

       396
       -
           pub fn clean_urls(mut self, value: impl Into<Option<bool>>) -> Self {

     

       397
       -
               self.__unsafe_private_named.0 = value.into();

     

       398
       -
               self

     

       399
       -
           }

     

       400
       -
           /// Set the `cleanUrls` field to an Option value (optional)

     

       401
       -
           pub fn maybe_clean_urls(mut self, value: Option<bool>) -> Self {

     

       402
       -
               self.__unsafe_private_named.0 = value;

     

       403
       -
               self

     

       404
       -
           }

     

       405
       -
       }

     

       406
       -
       

     

       407
       -
       impl<'a, S: settings_state::State> SettingsBuilder<'a, S> {

     

       408
       -
           /// Set the `custom404` field (optional)

     

       409
       -
           pub fn custom404(

     

       410
       -
               mut self,

     

       411
       -
               value: impl Into<Option<jacquard_common::CowStr<'a>>>,

     

       412
       -
           ) -> Self {

     

       413
       -
               self.__unsafe_private_named.1 = value.into();

     

       414
       -
               self

     

       415
       -
           }

     

       416
       -
           /// Set the `custom404` field to an Option value (optional)

     

       417
       -
           pub fn maybe_custom404(

     

       418
       -
               mut self,

     

       419
       -
               value: Option<jacquard_common::CowStr<'a>>,

     

       420
       -
           ) -> Self {

     

       421
       -
               self.__unsafe_private_named.1 = value;

     

       422
       -
               self

     

       423
       -
           }

     

       424
       -
       }

     

       425
       -
       

     

       426
       -
       impl<'a, S: settings_state::State> SettingsBuilder<'a, S> {

     

       427
       -
           /// Set the `directoryListing` field (optional)

     

       428
       -
           pub fn directory_listing(mut self, value: impl Into<Option<bool>>) -> Self {

     

       429
       -
               self.__unsafe_private_named.2 = value.into();

     

       430
       -
               self

     

       431
       -
           }

     

       432
       -
           /// Set the `directoryListing` field to an Option value (optional)

     

       433
       -
           pub fn maybe_directory_listing(mut self, value: Option<bool>) -> Self {

     

       434
       -
               self.__unsafe_private_named.2 = value;

     

       435
       -
               self

     

       436
       -
           }

     

       437
       -
       }

     

       438
       -
       

     

       439
       -
       impl<'a, S: settings_state::State> SettingsBuilder<'a, S> {

     

       440
       -
           /// Set the `headers` field (optional)

     

       441
       -
           pub fn headers(

     

       442
       -
               mut self,

     

       443
       -
               value: impl Into<Option<Vec<crate::place_wisp::settings::CustomHeader<'a>>>>,

     

       444
       -
           ) -> Self {

     

       445
       -
               self.__unsafe_private_named.3 = value.into();

     

       446
       -
               self

     

       447
       -
           }

     

       448
       -
           /// Set the `headers` field to an Option value (optional)

     

       449
       -
           pub fn maybe_headers(

     

       450
       -
               mut self,

     

       451
       -
               value: Option<Vec<crate::place_wisp::settings::CustomHeader<'a>>>,

     

       452
       -
           ) -> Self {

     

       453
       -
               self.__unsafe_private_named.3 = value;

     

       454
       -
               self

     

       455
       -
           }

     

       456
       -
       }

     

       457
       -
       

     

       458
       -
       impl<'a, S: settings_state::State> SettingsBuilder<'a, S> {

     

       459
       -
           /// Set the `indexFiles` field (optional)

     

       460
       -
           pub fn index_files(

     

       461
       -
               mut self,

     

       462
       -
               value: impl Into<Option<Vec<jacquard_common::CowStr<'a>>>>,

     

       463
       -
           ) -> Self {

     

       464
       -
               self.__unsafe_private_named.4 = value.into();

     

       465
       -
               self

     

       466
       -
           }

     

       467
       -
           /// Set the `indexFiles` field to an Option value (optional)

     

       468
       -
           pub fn maybe_index_files(

     

       469
       -
               mut self,

     

       470
       -
               value: Option<Vec<jacquard_common::CowStr<'a>>>,

     

       471
       -
           ) -> Self {

     

       472
       -
               self.__unsafe_private_named.4 = value;

     

       473
       -
               self

     

       474
       -
           }

     

       475
       -
       }

     

       476
       -
       

     

       477
       -
       impl<'a, S: settings_state::State> SettingsBuilder<'a, S> {

     

       478
       -
           /// Set the `spaMode` field (optional)

     

       479
       -
           pub fn spa_mode(

     

       480
       -
               mut self,

     

       481
       -
               value: impl Into<Option<jacquard_common::CowStr<'a>>>,

     

       482
       -
           ) -> Self {

     

       483
       -
               self.__unsafe_private_named.5 = value.into();

     

       484
       -
               self

     

       485
       -
           }

     

       486
       -
           /// Set the `spaMode` field to an Option value (optional)

     

       487
       -
           pub fn maybe_spa_mode(mut self, value: Option<jacquard_common::CowStr<'a>>) -> Self {

     

       488
       -
               self.__unsafe_private_named.5 = value;

     

       489
       -
               self

     

       490
       -
           }

     

       491
       -
       }

     

       492
       -
       

     

       493
       -
       impl<'a, S> SettingsBuilder<'a, S>

     

       494
       -
       where

     

       495
       -
           S: settings_state::State,

     

       496
       -
       {

     

       497
       -
           /// Build the final struct

     

       498
       -
           pub fn build(self) -> Settings<'a> {

     

       499
       -
               Settings {

     

       500
       -
                   clean_urls: self.__unsafe_private_named.0,

     

       501
       -
                   custom404: self.__unsafe_private_named.1,

     

       502
       -
                   directory_listing: self.__unsafe_private_named.2,

     

       503
       -
                   headers: self.__unsafe_private_named.3,

     

       504
       -
                   index_files: self.__unsafe_private_named.4,

     

       505
       -
                   spa_mode: self.__unsafe_private_named.5,

     

       506
       -
                   extra_data: Default::default(),

     

       507
       -
               }

     

       508
       -
           }

     

       509
       -
           /// Build the final struct with custom extra_data

     

       510
       -
           pub fn build_with_data(

     

       511
       -
               self,

     

       512
       -
               extra_data: std::collections::BTreeMap<

     

       513
       -
                   jacquard_common::smol_str::SmolStr,

     

       514
       -
                   jacquard_common::types::value::Data<'a>,

     

       515
       -
               >,

     

       516
       -
           ) -> Settings<'a> {

     

       517
       -
               Settings {

     

       518
       -
                   clean_urls: self.__unsafe_private_named.0,

     

       519
       -
                   custom404: self.__unsafe_private_named.1,

     

       520
       -
                   directory_listing: self.__unsafe_private_named.2,

     

       521
       -
                   headers: self.__unsafe_private_named.3,

     

       522
       -
                   index_files: self.__unsafe_private_named.4,

     

       523
       -
                   spa_mode: self.__unsafe_private_named.5,

     

       524
       -
                   extra_data: Some(extra_data),

     

       525
       -
               }

     

       526
       -
           }

     

       527
       -
       }

     

       528
       -
       

     

       529
       -
       impl<'a> Settings<'a> {

     

       530
       -
           pub fn uri(

     

       531
       -
               uri: impl Into<jacquard_common::CowStr<'a>>,

     

       532
       -
           ) -> Result<

     

       533
       -
               jacquard_common::types::uri::RecordUri<'a, SettingsRecord>,

     

       534
       -
               jacquard_common::types::uri::UriError,

     

       535
       -
           > {

     

       536
       -
               jacquard_common::types::uri::RecordUri::try_from_uri(

     

       537
       -
                   jacquard_common::types::string::AtUri::new_cow(uri.into())?,

     

       538
       -
               )

     

       539
       -
           }

     

       540
       -
       }

     

       541
       -
       

     

       542
       -
       /// Typed wrapper for GetRecord response with this collection's record type.

     

       543
       -
       #[derive(

     

       544
       -
           serde::Serialize,

     

       545
       -
           serde::Deserialize,

     

       546
       -
           Debug,

     

       547
       -
           Clone,

     

       548
       -
           PartialEq,

     

       549
       -
           Eq,

     

       550
       -
           jacquard_derive::IntoStatic

     

       551
       -
       )]

     

       552
       -
       #[serde(rename_all = "camelCase")]

     

       553
       -
       pub struct SettingsGetRecordOutput<'a> {

     

       554
       -
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       555
       -
           #[serde(borrow)]

     

       556
       -
           pub cid: std::option::Option<jacquard_common::types::string::Cid<'a>>,

     

       557
       -
           #[serde(borrow)]

     

       558
       -
           pub uri: jacquard_common::types::string::AtUri<'a>,

     

       559
       -
           #[serde(borrow)]

     

       560
       -
           pub value: Settings<'a>,

     

       561
       -
       }

     

       562
       -
       

     

       563
       -
       impl From<SettingsGetRecordOutput<'_>> for Settings<'_> {

     

       564
       -
           fn from(output: SettingsGetRecordOutput<'_>) -> Self {

     

       565
       -
               use jacquard_common::IntoStatic;

     

       566
       -
               output.value.into_static()

     

       567
       -
           }

     

       568
       -
       }

     

       569
       -
       

     

       570
       -
       impl jacquard_common::types::collection::Collection for Settings<'_> {

     

       571
       -
           const NSID: &'static str = "place.wisp.settings";

     

       572
       -
           type Record = SettingsRecord;

     

       573
       -
       }

     

       574
       -
       

     

       575
       -
       /// Marker type for deserializing records from this collection.

     

       576
       -
       #[derive(Debug, serde::Serialize, serde::Deserialize)]

     

       577
       -
       pub struct SettingsRecord;

     

       578
       -
       impl jacquard_common::xrpc::XrpcResp for SettingsRecord {

     

       579
       -
           const NSID: &'static str = "place.wisp.settings";

     

       580
       -
           const ENCODING: &'static str = "application/json";

     

       581
       -
           type Output<'de> = SettingsGetRecordOutput<'de>;

     

       582
       -
           type Err<'de> = jacquard_common::types::collection::RecordError<'de>;

     

       583
       -
       }

     

       584
       -
       

     

       585
       -
       impl jacquard_common::types::collection::Collection for SettingsRecord {

     

       586
       -
           const NSID: &'static str = "place.wisp.settings";

     

       587
       -
           type Record = SettingsRecord;

     

       588
       -
       }

     

       589
       -
       

     

       590
       -
       impl<'a> ::jacquard_lexicon::schema::LexiconSchema for Settings<'a> {

     

       591
       -
           fn nsid() -> &'static str {

     

       592
       -
               "place.wisp.settings"

     

       593
       -
           }

     

       594
       -
           fn def_name() -> &'static str {

     

       595
       -
               "main"

     

       596
       -
           }

     

       597
       -
           fn lexicon_doc() -> ::jacquard_lexicon::lexicon::LexiconDoc<'static> {

     

       598
       -
               lexicon_doc_place_wisp_settings()

     

       599
       -
           }

     

       600
       -
           fn validate(

     

       601
       -
               &self,

     

       602
       -
           ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> {

     

       603
       -
               if let Some(ref value) = self.custom404 {

     

       604
       -
                   #[allow(unused_comparisons)]

     

       605
       -
                   if <str>::len(value.as_ref()) > 500usize {

     

       606
       -
                       return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength {

     

       607
       -
                           path: ::jacquard_lexicon::validation::ValidationPath::from_field(

     

       608
       -
                               "custom404",

     

       609
       -
                           ),

     

       610
       -
                           max: 500usize,

     

       611
       -
                           actual: <str>::len(value.as_ref()),

     

       612
       -
                       });

     

       613
       -
                   }

     

       614
       -
               }

     

       615
       -
               if let Some(ref value) = self.headers {

     

       616
       -
                   #[allow(unused_comparisons)]

     

       617
       -
                   if value.len() > 50usize {

     

       618
       -
                       return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength {

     

       619
       -
                           path: ::jacquard_lexicon::validation::ValidationPath::from_field(

     

       620
       -
                               "headers",

     

       621
       -
                           ),

     

       622
       -
                           max: 50usize,

     

       623
       -
                           actual: value.len(),

     

       624
       -
                       });

     

       625
       -
                   }

     

       626
       -
               }

     

       627
       -
               if let Some(ref value) = self.index_files {

     

       628
       -
                   #[allow(unused_comparisons)]

     

       629
       -
                   if value.len() > 10usize {

     

       630
       -
                       return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength {

     

       631
       -
                           path: ::jacquard_lexicon::validation::ValidationPath::from_field(

     

       632
       -
                               "index_files",

     

       633
       -
                           ),

     

       634
       -
                           max: 10usize,

     

       635
       -
                           actual: value.len(),

     

       636
       -
                       });

     

       637
       -
                   }

     

       638
       -
               }

     

       639
       -
               if let Some(ref value) = self.spa_mode {

     

       640
       -
                   #[allow(unused_comparisons)]

     

       641
       -
                   if <str>::len(value.as_ref()) > 500usize {

     

       642
       -
                       return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength {

     

       643
       -
                           path: ::jacquard_lexicon::validation::ValidationPath::from_field(

     

       644
       -
                               "spa_mode",

     

       645
       -
                           ),

     

       646
       -
                           max: 500usize,

     

       647
       -
                           actual: <str>::len(value.as_ref()),

     

       648
       -
                       });

     

       649
       -
                   }

     

       650
       -
               }

     

       651
       -
               Ok(())

     

       652
       -
           }

     

       653
       -
       }

-1408

cli/src/place_wisp/subfs.rs

···

       1
       -
       // @generated by jacquard-lexicon. DO NOT EDIT.

     

       2
       -
       //

     

       3
       -
       // Lexicon: place.wisp.subfs

     

       4
       -
       //

     

       5
       -
       // This file was automatically generated from Lexicon schemas.

     

       6
       -
       // Any manual changes will be overwritten on the next regeneration.

     

       7
       -
       

     

       8
       -
       #[jacquard_derive::lexicon]

     

       9
       -
       #[derive(

     

       10
       -
           serde::Serialize,

     

       11
       -
           serde::Deserialize,

     

       12
       -
           Debug,

     

       13
       -
           Clone,

     

       14
       -
           PartialEq,

     

       15
       -
           Eq,

     

       16
       -
           jacquard_derive::IntoStatic

     

       17
       -
       )]

     

       18
       -
       #[serde(rename_all = "camelCase")]

     

       19
       -
       pub struct Directory<'a> {

     

       20
       -
           #[serde(borrow)]

     

       21
       -
           pub entries: Vec<crate::place_wisp::subfs::Entry<'a>>,

     

       22
       -
           #[serde(borrow)]

     

       23
       -
           pub r#type: jacquard_common::CowStr<'a>,

     

       24
       -
       }

     

       25
       -
       

     

       26
       -
       pub mod directory_state {

     

       27
       -
       

     

       28
       -
           pub use crate::builder_types::{Set, Unset, IsSet, IsUnset};

     

       29
       -
           #[allow(unused)]

     

       30
       -
           use ::core::marker::PhantomData;

     

       31
       -
           mod sealed {

     

       32
       -
               pub trait Sealed {}

     

       33
       -
           }

     

       34
       -
           /// State trait tracking which required fields have been set

     

       35
       -
           pub trait State: sealed::Sealed {

     

       36
       -
               type Type;

     

       37
       -
               type Entries;

     

       38
       -
           }

     

       39
       -
           /// Empty state - all required fields are unset

     

       40
       -
           pub struct Empty(());

     

       41
       -
           impl sealed::Sealed for Empty {}

     

       42
       -
           impl State for Empty {

     

       43
       -
               type Type = Unset;

     

       44
       -
               type Entries = Unset;

     

       45
       -
           }

     

       46
       -
           ///State transition - sets the `type` field to Set

     

       47
       -
           pub struct SetType<S: State = Empty>(PhantomData<fn() -> S>);

     

       48
       -
           impl<S: State> sealed::Sealed for SetType<S> {}

     

       49
       -
           impl<S: State> State for SetType<S> {

     

       50
       -
               type Type = Set<members::r#type>;

     

       51
       -
               type Entries = S::Entries;

     

       52
       -
           }

     

       53
       -
           ///State transition - sets the `entries` field to Set

     

       54
       -
           pub struct SetEntries<S: State = Empty>(PhantomData<fn() -> S>);

     

       55
       -
           impl<S: State> sealed::Sealed for SetEntries<S> {}

     

       56
       -
           impl<S: State> State for SetEntries<S> {

     

       57
       -
               type Type = S::Type;

     

       58
       -
               type Entries = Set<members::entries>;

     

       59
       -
           }

     

       60
       -
           /// Marker types for field names

     

       61
       -
           #[allow(non_camel_case_types)]

     

       62
       -
           pub mod members {

     

       63
       -
               ///Marker type for the `type` field

     

       64
       -
               pub struct r#type(());

     

       65
       -
               ///Marker type for the `entries` field

     

       66
       -
               pub struct entries(());

     

       67
       -
           }

     

       68
       -
       }

     

       69
       -
       

     

       70
       -
       /// Builder for constructing an instance of this type

     

       71
       -
       pub struct DirectoryBuilder<'a, S: directory_state::State> {

     

       72
       -
           _phantom_state: ::core::marker::PhantomData<fn() -> S>,

     

       73
       -
           __unsafe_private_named: (

     

       74
       -
               ::core::option::Option<Vec<crate::place_wisp::subfs::Entry<'a>>>,

     

       75
       -
               ::core::option::Option<jacquard_common::CowStr<'a>>,

     

       76
       -
           ),

     

       77
       -
           _phantom: ::core::marker::PhantomData<&'a ()>,

     

       78
       -
       }

     

       79
       -
       

     

       80
       -
       impl<'a> Directory<'a> {

     

       81
       -
           /// Create a new builder for this type

     

       82
       -
           pub fn new() -> DirectoryBuilder<'a, directory_state::Empty> {

     

       83
       -
               DirectoryBuilder::new()

     

       84
       -
           }

     

       85
       -
       }

     

       86
       -
       

     

       87
       -
       impl<'a> DirectoryBuilder<'a, directory_state::Empty> {

     

       88
       -
           /// Create a new builder with all fields unset

     

       89
       -
           pub fn new() -> Self {

     

       90
       -
               DirectoryBuilder {

     

       91
       -
                   _phantom_state: ::core::marker::PhantomData,

     

       92
       -
                   __unsafe_private_named: (None, None),

     

       93
       -
                   _phantom: ::core::marker::PhantomData,

     

       94
       -
               }

     

       95
       -
           }

     

       96
       -
       }

     

       97
       -
       

     

       98
       -
       impl<'a, S> DirectoryBuilder<'a, S>

     

       99
       -
       where

     

       100
       -
           S: directory_state::State,

     

       101
       -
           S::Entries: directory_state::IsUnset,

     

       102
       -
       {

     

       103
       -
           /// Set the `entries` field (required)

     

       104
       -
           pub fn entries(

     

       105
       -
               mut self,

     

       106
       -
               value: impl Into<Vec<crate::place_wisp::subfs::Entry<'a>>>,

     

       107
       -
           ) -> DirectoryBuilder<'a, directory_state::SetEntries<S>> {

     

       108
       -
               self.__unsafe_private_named.0 = ::core::option::Option::Some(value.into());

     

       109
       -
               DirectoryBuilder {

     

       110
       -
                   _phantom_state: ::core::marker::PhantomData,

     

       111
       -
                   __unsafe_private_named: self.__unsafe_private_named,

     

       112
       -
                   _phantom: ::core::marker::PhantomData,

     

       113
       -
               }

     

       114
       -
           }

     

       115
       -
       }

     

       116
       -
       

     

       117
       -
       impl<'a, S> DirectoryBuilder<'a, S>

     

       118
       -
       where

     

       119
       -
           S: directory_state::State,

     

       120
       -
           S::Type: directory_state::IsUnset,

     

       121
       -
       {

     

       122
       -
           /// Set the `type` field (required)

     

       123
       -
           pub fn r#type(

     

       124
       -
               mut self,

     

       125
       -
               value: impl Into<jacquard_common::CowStr<'a>>,

     

       126
       -
           ) -> DirectoryBuilder<'a, directory_state::SetType<S>> {

     

       127
       -
               self.__unsafe_private_named.1 = ::core::option::Option::Some(value.into());

     

       128
       -
               DirectoryBuilder {

     

       129
       -
                   _phantom_state: ::core::marker::PhantomData,

     

       130
       -
                   __unsafe_private_named: self.__unsafe_private_named,

     

       131
       -
                   _phantom: ::core::marker::PhantomData,

     

       132
       -
               }

     

       133
       -
           }

     

       134
       -
       }

     

       135
       -
       

     

       136
       -
       impl<'a, S> DirectoryBuilder<'a, S>

     

       137
       -
       where

     

       138
       -
           S: directory_state::State,

     

       139
       -
           S::Type: directory_state::IsSet,

     

       140
       -
           S::Entries: directory_state::IsSet,

     

       141
       -
       {

     

       142
       -
           /// Build the final struct

     

       143
       -
           pub fn build(self) -> Directory<'a> {

     

       144
       -
               Directory {

     

       145
       -
                   entries: self.__unsafe_private_named.0.unwrap(),

     

       146
       -
                   r#type: self.__unsafe_private_named.1.unwrap(),

     

       147
       -
                   extra_data: Default::default(),

     

       148
       -
               }

     

       149
       -
           }

     

       150
       -
           /// Build the final struct with custom extra_data

     

       151
       -
           pub fn build_with_data(

     

       152
       -
               self,

     

       153
       -
               extra_data: std::collections::BTreeMap<

     

       154
       -
                   jacquard_common::smol_str::SmolStr,

     

       155
       -
                   jacquard_common::types::value::Data<'a>,

     

       156
       -
               >,

     

       157
       -
           ) -> Directory<'a> {

     

       158
       -
               Directory {

     

       159
       -
                   entries: self.__unsafe_private_named.0.unwrap(),

     

       160
       -
                   r#type: self.__unsafe_private_named.1.unwrap(),

     

       161
       -
                   extra_data: Some(extra_data),

     

       162
       -
               }

     

       163
       -
           }

     

       164
       -
       }

     

       165
       -
       

     

       166
       -
       fn lexicon_doc_place_wisp_subfs() -> ::jacquard_lexicon::lexicon::LexiconDoc<'static> {

     

       167
       -
           ::jacquard_lexicon::lexicon::LexiconDoc {

     

       168
       -
               lexicon: ::jacquard_lexicon::lexicon::Lexicon::Lexicon1,

     

       169
       -
               id: ::jacquard_common::CowStr::new_static("place.wisp.subfs"),

     

       170
       -
               revision: None,

     

       171
       -
               description: None,

     

       172
       -
               defs: {

     

       173
       -
                   let mut map = ::std::collections::BTreeMap::new();

     

       174
       -
                   map.insert(

     

       175
       -
                       ::jacquard_common::smol_str::SmolStr::new_static("directory"),

     

       176
       -
                       ::jacquard_lexicon::lexicon::LexUserType::Object(::jacquard_lexicon::lexicon::LexObject {

     

       177
       -
                           description: None,

     

       178
       -
                           required: Some(

     

       179
       -
                               vec![

     

       180
       -
                                   ::jacquard_common::smol_str::SmolStr::new_static("type"),

     

       181
       -
                                   ::jacquard_common::smol_str::SmolStr::new_static("entries")

     

       182
       -
                               ],

     

       183
       -
                           ),

     

       184
       -
                           nullable: None,

     

       185
       -
                           properties: {

     

       186
       -
                               #[allow(unused_mut)]

     

       187
       -
                               let mut map = ::std::collections::BTreeMap::new();

     

       188
       -
                               map.insert(

     

       189
       -
                                   ::jacquard_common::smol_str::SmolStr::new_static("entries"),

     

       190
       -
                                   ::jacquard_lexicon::lexicon::LexObjectProperty::Array(::jacquard_lexicon::lexicon::LexArray {

     

       191
       -
                                       description: None,

     

       192
       -
                                       items: ::jacquard_lexicon::lexicon::LexArrayItem::Ref(::jacquard_lexicon::lexicon::LexRef {

     

       193
       -
                                           description: None,

     

       194
       -
                                           r#ref: ::jacquard_common::CowStr::new_static("#entry"),

     

       195
       -
                                       }),

     

       196
       -
                                       min_length: None,

     

       197
       -
                                       max_length: Some(500usize),

     

       198
       -
                                   }),

     

       199
       -
                               );

     

       200
       -
                               map.insert(

     

       201
       -
                                   ::jacquard_common::smol_str::SmolStr::new_static("type"),

     

       202
       -
                                   ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {

     

       203
       -
                                       description: None,

     

       204
       -
                                       format: None,

     

       205
       -
                                       default: None,

     

       206
       -
                                       min_length: None,

     

       207
       -
                                       max_length: None,

     

       208
       -
                                       min_graphemes: None,

     

       209
       -
                                       max_graphemes: None,

     

       210
       -
                                       r#enum: None,

     

       211
       -
                                       r#const: None,

     

       212
       -
                                       known_values: None,

     

       213
       -
                                   }),

     

       214
       -
                               );

     

       215
       -
                               map

     

       216
       -
                           },

     

       217
       -
                       }),

     

       218
       -
                   );

     

       219
       -
                   map.insert(

     

       220
       -
                       ::jacquard_common::smol_str::SmolStr::new_static("entry"),

     

       221
       -
                       ::jacquard_lexicon::lexicon::LexUserType::Object(::jacquard_lexicon::lexicon::LexObject {

     

       222
       -
                           description: None,

     

       223
       -
                           required: Some(

     

       224
       -
                               vec![

     

       225
       -
                                   ::jacquard_common::smol_str::SmolStr::new_static("name"),

     

       226
       -
                                   ::jacquard_common::smol_str::SmolStr::new_static("node")

     

       227
       -
                               ],

     

       228
       -
                           ),

     

       229
       -
                           nullable: None,

     

       230
       -
                           properties: {

     

       231
       -
                               #[allow(unused_mut)]

     

       232
       -
                               let mut map = ::std::collections::BTreeMap::new();

     

       233
       -
                               map.insert(

     

       234
       -
                                   ::jacquard_common::smol_str::SmolStr::new_static("name"),

     

       235
       -
                                   ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {

     

       236
       -
                                       description: None,

     

       237
       -
                                       format: None,

     

       238
       -
                                       default: None,

     

       239
       -
                                       min_length: None,

     

       240
       -
                                       max_length: Some(255usize),

     

       241
       -
                                       min_graphemes: None,

     

       242
       -
                                       max_graphemes: None,

     

       243
       -
                                       r#enum: None,

     

       244
       -
                                       r#const: None,

     

       245
       -
                                       known_values: None,

     

       246
       -
                                   }),

     

       247
       -
                               );

     

       248
       -
                               map.insert(

     

       249
       -
                                   ::jacquard_common::smol_str::SmolStr::new_static("node"),

     

       250
       -
                                   ::jacquard_lexicon::lexicon::LexObjectProperty::Union(::jacquard_lexicon::lexicon::LexRefUnion {

     

       251
       -
                                       description: None,

     

       252
       -
                                       refs: vec![

     

       253
       -
                                           ::jacquard_common::CowStr::new_static("#file"),

     

       254
       -
                                           ::jacquard_common::CowStr::new_static("#directory"),

     

       255
       -
                                           ::jacquard_common::CowStr::new_static("#subfs")

     

       256
       -
                                       ],

     

       257
       -
                                       closed: None,

     

       258
       -
                                   }),

     

       259
       -
                               );

     

       260
       -
                               map

     

       261
       -
                           },

     

       262
       -
                       }),

     

       263
       -
                   );

     

       264
       -
                   map.insert(

     

       265
       -
                       ::jacquard_common::smol_str::SmolStr::new_static("file"),

     

       266
       -
                       ::jacquard_lexicon::lexicon::LexUserType::Object(::jacquard_lexicon::lexicon::LexObject {

     

       267
       -
                           description: None,

     

       268
       -
                           required: Some(

     

       269
       -
                               vec![

     

       270
       -
                                   ::jacquard_common::smol_str::SmolStr::new_static("type"),

     

       271
       -
                                   ::jacquard_common::smol_str::SmolStr::new_static("blob")

     

       272
       -
                               ],

     

       273
       -
                           ),

     

       274
       -
                           nullable: None,

     

       275
       -
                           properties: {

     

       276
       -
                               #[allow(unused_mut)]

     

       277
       -
                               let mut map = ::std::collections::BTreeMap::new();

     

       278
       -
                               map.insert(

     

       279
       -
                                   ::jacquard_common::smol_str::SmolStr::new_static("base64"),

     

       280
       -
                                   ::jacquard_lexicon::lexicon::LexObjectProperty::Boolean(::jacquard_lexicon::lexicon::LexBoolean {

     

       281
       -
                                       description: None,

     

       282
       -
                                       default: None,

     

       283
       -
                                       r#const: None,

     

       284
       -
                                   }),

     

       285
       -
                               );

     

       286
       -
                               map.insert(

     

       287
       -
                                   ::jacquard_common::smol_str::SmolStr::new_static("blob"),

     

       288
       -
                                   ::jacquard_lexicon::lexicon::LexObjectProperty::Blob(::jacquard_lexicon::lexicon::LexBlob {

     

       289
       -
                                       description: None,

     

       290
       -
                                       accept: None,

     

       291
       -
                                       max_size: None,

     

       292
       -
                                   }),

     

       293
       -
                               );

     

       294
       -
                               map.insert(

     

       295
       -
                                   ::jacquard_common::smol_str::SmolStr::new_static("encoding"),

     

       296
       -
                                   ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {

     

       297
       -
                                       description: Some(

     

       298
       -
                                           ::jacquard_common::CowStr::new_static(

     

       299
       -
                                               "Content encoding (e.g., gzip for compressed files)",

     

       300
       -
                                           ),

     

       301
       -
                                       ),

     

       302
       -
                                       format: None,

     

       303
       -
                                       default: None,

     

       304
       -
                                       min_length: None,

     

       305
       -
                                       max_length: None,

     

       306
       -
                                       min_graphemes: None,

     

       307
       -
                                       max_graphemes: None,

     

       308
       -
                                       r#enum: None,

     

       309
       -
                                       r#const: None,

     

       310
       -
                                       known_values: None,

     

       311
       -
                                   }),

     

       312
       -
                               );

     

       313
       -
                               map.insert(

     

       314
       -
                                   ::jacquard_common::smol_str::SmolStr::new_static("mimeType"),

     

       315
       -
                                   ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {

     

       316
       -
                                       description: Some(

     

       317
       -
                                           ::jacquard_common::CowStr::new_static(

     

       318
       -
                                               "Original MIME type before compression",

     

       319
       -
                                           ),

     

       320
       -
                                       ),

     

       321
       -
                                       format: None,

     

       322
       -
                                       default: None,

     

       323
       -
                                       min_length: None,

     

       324
       -
                                       max_length: None,

     

       325
       -
                                       min_graphemes: None,

     

       326
       -
                                       max_graphemes: None,

     

       327
       -
                                       r#enum: None,

     

       328
       -
                                       r#const: None,

     

       329
       -
                                       known_values: None,

     

       330
       -
                                   }),

     

       331
       -
                               );

     

       332
       -
                               map.insert(

     

       333
       -
                                   ::jacquard_common::smol_str::SmolStr::new_static("type"),

     

       334
       -
                                   ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {

     

       335
       -
                                       description: None,

     

       336
       -
                                       format: None,

     

       337
       -
                                       default: None,

     

       338
       -
                                       min_length: None,

     

       339
       -
                                       max_length: None,

     

       340
       -
                                       min_graphemes: None,

     

       341
       -
                                       max_graphemes: None,

     

       342
       -
                                       r#enum: None,

     

       343
       -
                                       r#const: None,

     

       344
       -
                                       known_values: None,

     

       345
       -
                                   }),

     

       346
       -
                               );

     

       347
       -
                               map

     

       348
       -
                           },

     

       349
       -
                       }),

     

       350
       -
                   );

     

       351
       -
                   map.insert(

     

       352
       -
                       ::jacquard_common::smol_str::SmolStr::new_static("main"),

     

       353
       -
                       ::jacquard_lexicon::lexicon::LexUserType::Record(::jacquard_lexicon::lexicon::LexRecord {

     

       354
       -
                           description: Some(

     

       355
       -
                               ::jacquard_common::CowStr::new_static(

     

       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
       -
                               ),

     

       358
       -
                           ),

     

       359
       -
                           key: None,

     

       360
       -
                           record: ::jacquard_lexicon::lexicon::LexRecordRecord::Object(::jacquard_lexicon::lexicon::LexObject {

     

       361
       -
                               description: None,

     

       362
       -
                               required: Some(

     

       363
       -
                                   vec![

     

       364
       -
                                       ::jacquard_common::smol_str::SmolStr::new_static("root"),

     

       365
       -
                                       ::jacquard_common::smol_str::SmolStr::new_static("createdAt")

     

       366
       -
                                   ],

     

       367
       -
                               ),

     

       368
       -
                               nullable: None,

     

       369
       -
                               properties: {

     

       370
       -
                                   #[allow(unused_mut)]

     

       371
       -
                                   let mut map = ::std::collections::BTreeMap::new();

     

       372
       -
                                   map.insert(

     

       373
       -
                                       ::jacquard_common::smol_str::SmolStr::new_static(

     

       374
       -
                                           "createdAt",

     

       375
       -
                                       ),

     

       376
       -
                                       ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {

     

       377
       -
                                           description: None,

     

       378
       -
                                           format: Some(

     

       379
       -
                                               ::jacquard_lexicon::lexicon::LexStringFormat::Datetime,

     

       380
       -
                                           ),

     

       381
       -
                                           default: None,

     

       382
       -
                                           min_length: None,

     

       383
       -
                                           max_length: None,

     

       384
       -
                                           min_graphemes: None,

     

       385
       -
                                           max_graphemes: None,

     

       386
       -
                                           r#enum: None,

     

       387
       -
                                           r#const: None,

     

       388
       -
                                           known_values: None,

     

       389
       -
                                       }),

     

       390
       -
                                   );

     

       391
       -
                                   map.insert(

     

       392
       -
                                       ::jacquard_common::smol_str::SmolStr::new_static(

     

       393
       -
                                           "fileCount",

     

       394
       -
                                       ),

     

       395
       -
                                       ::jacquard_lexicon::lexicon::LexObjectProperty::Integer(::jacquard_lexicon::lexicon::LexInteger {

     

       396
       -
                                           description: None,

     

       397
       -
                                           default: None,

     

       398
       -
                                           minimum: Some(0i64),

     

       399
       -
                                           maximum: Some(1000i64),

     

       400
       -
                                           r#enum: None,

     

       401
       -
                                           r#const: None,

     

       402
       -
                                       }),

     

       403
       -
                                   );

     

       404
       -
                                   map.insert(

     

       405
       -
                                       ::jacquard_common::smol_str::SmolStr::new_static("root"),

     

       406
       -
                                       ::jacquard_lexicon::lexicon::LexObjectProperty::Ref(::jacquard_lexicon::lexicon::LexRef {

     

       407
       -
                                           description: None,

     

       408
       -
                                           r#ref: ::jacquard_common::CowStr::new_static("#directory"),

     

       409
       -
                                       }),

     

       410
       -
                                   );

     

       411
       -
                                   map

     

       412
       -
                               },

     

       413
       -
                           }),

     

       414
       -
                       }),

     

       415
       -
                   );

     

       416
       -
                   map.insert(

     

       417
       -
                       ::jacquard_common::smol_str::SmolStr::new_static("subfs"),

     

       418
       -
                       ::jacquard_lexicon::lexicon::LexUserType::Object(::jacquard_lexicon::lexicon::LexObject {

     

       419
       -
                           description: None,

     

       420
       -
                           required: Some(

     

       421
       -
                               vec![

     

       422
       -
                                   ::jacquard_common::smol_str::SmolStr::new_static("type"),

     

       423
       -
                                   ::jacquard_common::smol_str::SmolStr::new_static("subject")

     

       424
       -
                               ],

     

       425
       -
                           ),

     

       426
       -
                           nullable: None,

     

       427
       -
                           properties: {

     

       428
       -
                               #[allow(unused_mut)]

     

       429
       -
                               let mut map = ::std::collections::BTreeMap::new();

     

       430
       -
                               map.insert(

     

       431
       -
                                   ::jacquard_common::smol_str::SmolStr::new_static("subject"),

     

       432
       -
                                   ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {

     

       433
       -
                                       description: Some(

     

       434
       -
                                           ::jacquard_common::CowStr::new_static(

     

       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
       -
                                           ),

     

       437
       -
                                       ),

     

       438
       -
                                       format: Some(

     

       439
       -
                                           ::jacquard_lexicon::lexicon::LexStringFormat::AtUri,

     

       440
       -
                                       ),

     

       441
       -
                                       default: None,

     

       442
       -
                                       min_length: None,

     

       443
       -
                                       max_length: None,

     

       444
       -
                                       min_graphemes: None,

     

       445
       -
                                       max_graphemes: None,

     

       446
       -
                                       r#enum: None,

     

       447
       -
                                       r#const: None,

     

       448
       -
                                       known_values: None,

     

       449
       -
                                   }),

     

       450
       -
                               );

     

       451
       -
                               map.insert(

     

       452
       -
                                   ::jacquard_common::smol_str::SmolStr::new_static("type"),

     

       453
       -
                                   ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {

     

       454
       -
                                       description: None,

     

       455
       -
                                       format: None,

     

       456
       -
                                       default: None,

     

       457
       -
                                       min_length: None,

     

       458
       -
                                       max_length: None,

     

       459
       -
                                       min_graphemes: None,

     

       460
       -
                                       max_graphemes: None,

     

       461
       -
                                       r#enum: None,

     

       462
       -
                                       r#const: None,

     

       463
       -
                                       known_values: None,

     

       464
       -
                                   }),

     

       465
       -
                               );

     

       466
       -
                               map

     

       467
       -
                           },

     

       468
       -
                       }),

     

       469
       -
                   );

     

       470
       -
                   map

     

       471
       -
               },

     

       472
       -
           }

     

       473
       -
       }

     

       474
       -
       

     

       475
       -
       impl<'a> ::jacquard_lexicon::schema::LexiconSchema for Directory<'a> {

     

       476
       -
           fn nsid() -> &'static str {

     

       477
       -
               "place.wisp.subfs"

     

       478
       -
           }

     

       479
       -
           fn def_name() -> &'static str {

     

       480
       -
               "directory"

     

       481
       -
           }

     

       482
       -
           fn lexicon_doc() -> ::jacquard_lexicon::lexicon::LexiconDoc<'static> {

     

       483
       -
               lexicon_doc_place_wisp_subfs()

     

       484
       -
           }

     

       485
       -
           fn validate(

     

       486
       -
               &self,

     

       487
       -
           ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> {

     

       488
       -
               {

     

       489
       -
                   let value = &self.entries;

     

       490
       -
                   #[allow(unused_comparisons)]

     

       491
       -
                   if value.len() > 500usize {

     

       492
       -
                       return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength {

     

       493
       -
                           path: ::jacquard_lexicon::validation::ValidationPath::from_field(

     

       494
       -
                               "entries",

     

       495
       -
                           ),

     

       496
       -
                           max: 500usize,

     

       497
       -
                           actual: value.len(),

     

       498
       -
                       });

     

       499
       -
                   }

     

       500
       -
               }

     

       501
       -
               Ok(())

     

       502
       -
           }

     

       503
       -
       }

     

       504
       -
       

     

       505
       -
       #[jacquard_derive::lexicon]

     

       506
       -
       #[derive(

     

       507
       -
           serde::Serialize,

     

       508
       -
           serde::Deserialize,

     

       509
       -
           Debug,

     

       510
       -
           Clone,

     

       511
       -
           PartialEq,

     

       512
       -
           Eq,

     

       513
       -
           jacquard_derive::IntoStatic

     

       514
       -
       )]

     

       515
       -
       #[serde(rename_all = "camelCase")]

     

       516
       -
       pub struct Entry<'a> {

     

       517
       -
           #[serde(borrow)]

     

       518
       -
           pub name: jacquard_common::CowStr<'a>,

     

       519
       -
           #[serde(borrow)]

     

       520
       -
           pub node: EntryNode<'a>,

     

       521
       -
       }

     

       522
       -
       

     

       523
       -
       pub mod entry_state {

     

       524
       -
       

     

       525
       -
           pub use crate::builder_types::{Set, Unset, IsSet, IsUnset};

     

       526
       -
           #[allow(unused)]

     

       527
       -
           use ::core::marker::PhantomData;

     

       528
       -
           mod sealed {

     

       529
       -
               pub trait Sealed {}

     

       530
       -
           }

     

       531
       -
           /// State trait tracking which required fields have been set

     

       532
       -
           pub trait State: sealed::Sealed {

     

       533
       -
               type Name;

     

       534
       -
               type Node;

     

       535
       -
           }

     

       536
       -
           /// Empty state - all required fields are unset

     

       537
       -
           pub struct Empty(());

     

       538
       -
           impl sealed::Sealed for Empty {}

     

       539
       -
           impl State for Empty {

     

       540
       -
               type Name = Unset;

     

       541
       -
               type Node = Unset;

     

       542
       -
           }

     

       543
       -
           ///State transition - sets the `name` field to Set

     

       544
       -
           pub struct SetName<S: State = Empty>(PhantomData<fn() -> S>);

     

       545
       -
           impl<S: State> sealed::Sealed for SetName<S> {}

     

       546
       -
           impl<S: State> State for SetName<S> {

     

       547
       -
               type Name = Set<members::name>;

     

       548
       -
               type Node = S::Node;

     

       549
       -
           }

     

       550
       -
           ///State transition - sets the `node` field to Set

     

       551
       -
           pub struct SetNode<S: State = Empty>(PhantomData<fn() -> S>);

     

       552
       -
           impl<S: State> sealed::Sealed for SetNode<S> {}

     

       553
       -
           impl<S: State> State for SetNode<S> {

     

       554
       -
               type Name = S::Name;

     

       555
       -
               type Node = Set<members::node>;

     

       556
       -
           }

     

       557
       -
           /// Marker types for field names

     

       558
       -
           #[allow(non_camel_case_types)]

     

       559
       -
           pub mod members {

     

       560
       -
               ///Marker type for the `name` field

     

       561
       -
               pub struct name(());

     

       562
       -
               ///Marker type for the `node` field

     

       563
       -
               pub struct node(());

     

       564
       -
           }

     

       565
       -
       }

     

       566
       -
       

     

       567
       -
       /// Builder for constructing an instance of this type

     

       568
       -
       pub struct EntryBuilder<'a, S: entry_state::State> {

     

       569
       -
           _phantom_state: ::core::marker::PhantomData<fn() -> S>,

     

       570
       -
           __unsafe_private_named: (

     

       571
       -
               ::core::option::Option<jacquard_common::CowStr<'a>>,

     

       572
       -
               ::core::option::Option<EntryNode<'a>>,

     

       573
       -
           ),

     

       574
       -
           _phantom: ::core::marker::PhantomData<&'a ()>,

     

       575
       -
       }

     

       576
       -
       

     

       577
       -
       impl<'a> Entry<'a> {

     

       578
       -
           /// Create a new builder for this type

     

       579
       -
           pub fn new() -> EntryBuilder<'a, entry_state::Empty> {

     

       580
       -
               EntryBuilder::new()

     

       581
       -
           }

     

       582
       -
       }

     

       583
       -
       

     

       584
       -
       impl<'a> EntryBuilder<'a, entry_state::Empty> {

     

       585
       -
           /// Create a new builder with all fields unset

     

       586
       -
           pub fn new() -> Self {

     

       587
       -
               EntryBuilder {

     

       588
       -
                   _phantom_state: ::core::marker::PhantomData,

     

       589
       -
                   __unsafe_private_named: (None, None),

     

       590
       -
                   _phantom: ::core::marker::PhantomData,

     

       591
       -
               }

     

       592
       -
           }

     

       593
       -
       }

     

       594
       -
       

     

       595
       -
       impl<'a, S> EntryBuilder<'a, S>

     

       596
       -
       where

     

       597
       -
           S: entry_state::State,

     

       598
       -
           S::Name: entry_state::IsUnset,

     

       599
       -
       {

     

       600
       -
           /// Set the `name` field (required)

     

       601
       -
           pub fn name(

     

       602
       -
               mut self,

     

       603
       -
               value: impl Into<jacquard_common::CowStr<'a>>,

     

       604
       -
           ) -> EntryBuilder<'a, entry_state::SetName<S>> {

     

       605
       -
               self.__unsafe_private_named.0 = ::core::option::Option::Some(value.into());

     

       606
       -
               EntryBuilder {

     

       607
       -
                   _phantom_state: ::core::marker::PhantomData,

     

       608
       -
                   __unsafe_private_named: self.__unsafe_private_named,

     

       609
       -
                   _phantom: ::core::marker::PhantomData,

     

       610
       -
               }

     

       611
       -
           }

     

       612
       -
       }

     

       613
       -
       

     

       614
       -
       impl<'a, S> EntryBuilder<'a, S>

     

       615
       -
       where

     

       616
       -
           S: entry_state::State,

     

       617
       -
           S::Node: entry_state::IsUnset,

     

       618
       -
       {

     

       619
       -
           /// Set the `node` field (required)

     

       620
       -
           pub fn node(

     

       621
       -
               mut self,

     

       622
       -
               value: impl Into<EntryNode<'a>>,

     

       623
       -
           ) -> EntryBuilder<'a, entry_state::SetNode<S>> {

     

       624
       -
               self.__unsafe_private_named.1 = ::core::option::Option::Some(value.into());

     

       625
       -
               EntryBuilder {

     

       626
       -
                   _phantom_state: ::core::marker::PhantomData,

     

       627
       -
                   __unsafe_private_named: self.__unsafe_private_named,

     

       628
       -
                   _phantom: ::core::marker::PhantomData,

     

       629
       -
               }

     

       630
       -
           }

     

       631
       -
       }

     

       632
       -
       

     

       633
       -
       impl<'a, S> EntryBuilder<'a, S>

     

       634
       -
       where

     

       635
       -
           S: entry_state::State,

     

       636
       -
           S::Name: entry_state::IsSet,

     

       637
       -
           S::Node: entry_state::IsSet,

     

       638
       -
       {

     

       639
       -
           /// Build the final struct

     

       640
       -
           pub fn build(self) -> Entry<'a> {

     

       641
       -
               Entry {

     

       642
       -
                   name: self.__unsafe_private_named.0.unwrap(),

     

       643
       -
                   node: self.__unsafe_private_named.1.unwrap(),

     

       644
       -
                   extra_data: Default::default(),

     

       645
       -
               }

     

       646
       -
           }

     

       647
       -
           /// Build the final struct with custom extra_data

     

       648
       -
           pub fn build_with_data(

     

       649
       -
               self,

     

       650
       -
               extra_data: std::collections::BTreeMap<

     

       651
       -
                   jacquard_common::smol_str::SmolStr,

     

       652
       -
                   jacquard_common::types::value::Data<'a>,

     

       653
       -
               >,

     

       654
       -
           ) -> Entry<'a> {

     

       655
       -
               Entry {

     

       656
       -
                   name: self.__unsafe_private_named.0.unwrap(),

     

       657
       -
                   node: self.__unsafe_private_named.1.unwrap(),

     

       658
       -
                   extra_data: Some(extra_data),

     

       659
       -
               }

     

       660
       -
           }

     

       661
       -
       }

     

       662
       -
       

     

       663
       -
       #[jacquard_derive::open_union]

     

       664
       -
       #[derive(

     

       665
       -
           serde::Serialize,

     

       666
       -
           serde::Deserialize,

     

       667
       -
           Debug,

     

       668
       -
           Clone,

     

       669
       -
           PartialEq,

     

       670
       -
           Eq,

     

       671
       -
           jacquard_derive::IntoStatic

     

       672
       -
       )]

     

       673
       -
       #[serde(tag = "$type")]

     

       674
       -
       #[serde(bound(deserialize = "'de: 'a"))]

     

       675
       -
       pub enum EntryNode<'a> {

     

       676
       -
           #[serde(rename = "place.wisp.subfs#file")]

     

       677
       -
           File(Box<crate::place_wisp::subfs::File<'a>>),

     

       678
       -
           #[serde(rename = "place.wisp.subfs#directory")]

     

       679
       -
           Directory(Box<crate::place_wisp::subfs::Directory<'a>>),

     

       680
       -
           #[serde(rename = "place.wisp.subfs#subfs")]

     

       681
       -
           Subfs(Box<crate::place_wisp::subfs::Subfs<'a>>),

     

       682
       -
       }

     

       683
       -
       

     

       684
       -
       impl<'a> ::jacquard_lexicon::schema::LexiconSchema for Entry<'a> {

     

       685
       -
           fn nsid() -> &'static str {

     

       686
       -
               "place.wisp.subfs"

     

       687
       -
           }

     

       688
       -
           fn def_name() -> &'static str {

     

       689
       -
               "entry"

     

       690
       -
           }

     

       691
       -
           fn lexicon_doc() -> ::jacquard_lexicon::lexicon::LexiconDoc<'static> {

     

       692
       -
               lexicon_doc_place_wisp_subfs()

     

       693
       -
           }

     

       694
       -
           fn validate(

     

       695
       -
               &self,

     

       696
       -
           ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> {

     

       697
       -
               {

     

       698
       -
                   let value = &self.name;

     

       699
       -
                   #[allow(unused_comparisons)]

     

       700
       -
                   if <str>::len(value.as_ref()) > 255usize {

     

       701
       -
                       return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength {

     

       702
       -
                           path: ::jacquard_lexicon::validation::ValidationPath::from_field(

     

       703
       -
                               "name",

     

       704
       -
                           ),

     

       705
       -
                           max: 255usize,

     

       706
       -
                           actual: <str>::len(value.as_ref()),

     

       707
       -
                       });

     

       708
       -
                   }

     

       709
       -
               }

     

       710
       -
               Ok(())

     

       711
       -
           }

     

       712
       -
       }

     

       713
       -
       

     

       714
       -
       #[jacquard_derive::lexicon]

     

       715
       -
       #[derive(

     

       716
       -
           serde::Serialize,

     

       717
       -
           serde::Deserialize,

     

       718
       -
           Debug,

     

       719
       -
           Clone,

     

       720
       -
           PartialEq,

     

       721
       -
           Eq,

     

       722
       -
           jacquard_derive::IntoStatic

     

       723
       -
       )]

     

       724
       -
       #[serde(rename_all = "camelCase")]

     

       725
       -
       pub struct File<'a> {

     

       726
       -
           /// True if blob content is base64-encoded (used to bypass PDS content sniffing)

     

       727
       -
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       728
       -
           pub base64: Option<bool>,

     

       729
       -
           /// Content blob ref

     

       730
       -
           #[serde(borrow)]

     

       731
       -
           pub blob: jacquard_common::types::blob::BlobRef<'a>,

     

       732
       -
           /// Content encoding (e.g., gzip for compressed files)

     

       733
       -
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       734
       -
           #[serde(borrow)]

     

       735
       -
           pub encoding: Option<jacquard_common::CowStr<'a>>,

     

       736
       -
           /// Original MIME type before compression

     

       737
       -
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       738
       -
           #[serde(borrow)]

     

       739
       -
           pub mime_type: Option<jacquard_common::CowStr<'a>>,

     

       740
       -
           #[serde(borrow)]

     

       741
       -
           pub r#type: jacquard_common::CowStr<'a>,

     

       742
       -
       }

     

       743
       -
       

     

       744
       -
       pub mod file_state {

     

       745
       -
       

     

       746
       -
           pub use crate::builder_types::{Set, Unset, IsSet, IsUnset};

     

       747
       -
           #[allow(unused)]

     

       748
       -
           use ::core::marker::PhantomData;

     

       749
       -
           mod sealed {

     

       750
       -
               pub trait Sealed {}

     

       751
       -
           }

     

       752
       -
           /// State trait tracking which required fields have been set

     

       753
       -
           pub trait State: sealed::Sealed {

     

       754
       -
               type Type;

     

       755
       -
               type Blob;

     

       756
       -
           }

     

       757
       -
           /// Empty state - all required fields are unset

     

       758
       -
           pub struct Empty(());

     

       759
       -
           impl sealed::Sealed for Empty {}

     

       760
       -
           impl State for Empty {

     

       761
       -
               type Type = Unset;

     

       762
       -
               type Blob = Unset;

     

       763
       -
           }

     

       764
       -
           ///State transition - sets the `type` field to Set

     

       765
       -
           pub struct SetType<S: State = Empty>(PhantomData<fn() -> S>);

     

       766
       -
           impl<S: State> sealed::Sealed for SetType<S> {}

     

       767
       -
           impl<S: State> State for SetType<S> {

     

       768
       -
               type Type = Set<members::r#type>;

     

       769
       -
               type Blob = S::Blob;

     

       770
       -
           }

     

       771
       -
           ///State transition - sets the `blob` field to Set

     

       772
       -
           pub struct SetBlob<S: State = Empty>(PhantomData<fn() -> S>);

     

       773
       -
           impl<S: State> sealed::Sealed for SetBlob<S> {}

     

       774
       -
           impl<S: State> State for SetBlob<S> {

     

       775
       -
               type Type = S::Type;

     

       776
       -
               type Blob = Set<members::blob>;

     

       777
       -
           }

     

       778
       -
           /// Marker types for field names

     

       779
       -
           #[allow(non_camel_case_types)]

     

       780
       -
           pub mod members {

     

       781
       -
               ///Marker type for the `type` field

     

       782
       -
               pub struct r#type(());

     

       783
       -
               ///Marker type for the `blob` field

     

       784
       -
               pub struct blob(());

     

       785
       -
           }

     

       786
       -
       }

     

       787
       -
       

     

       788
       -
       /// Builder for constructing an instance of this type

     

       789
       -
       pub struct FileBuilder<'a, S: file_state::State> {

     

       790
       -
           _phantom_state: ::core::marker::PhantomData<fn() -> S>,

     

       791
       -
           __unsafe_private_named: (

     

       792
       -
               ::core::option::Option<bool>,

     

       793
       -
               ::core::option::Option<jacquard_common::types::blob::BlobRef<'a>>,

     

       794
       -
               ::core::option::Option<jacquard_common::CowStr<'a>>,

     

       795
       -
               ::core::option::Option<jacquard_common::CowStr<'a>>,

     

       796
       -
               ::core::option::Option<jacquard_common::CowStr<'a>>,

     

       797
       -
           ),

     

       798
       -
           _phantom: ::core::marker::PhantomData<&'a ()>,

     

       799
       -
       }

     

       800
       -
       

     

       801
       -
       impl<'a> File<'a> {

     

       802
       -
           /// Create a new builder for this type

     

       803
       -
           pub fn new() -> FileBuilder<'a, file_state::Empty> {

     

       804
       -
               FileBuilder::new()

     

       805
       -
           }

     

       806
       -
       }

     

       807
       -
       

     

       808
       -
       impl<'a> FileBuilder<'a, file_state::Empty> {

     

       809
       -
           /// Create a new builder with all fields unset

     

       810
       -
           pub fn new() -> Self {

     

       811
       -
               FileBuilder {

     

       812
       -
                   _phantom_state: ::core::marker::PhantomData,

     

       813
       -
                   __unsafe_private_named: (None, None, None, None, None),

     

       814
       -
                   _phantom: ::core::marker::PhantomData,

     

       815
       -
               }

     

       816
       -
           }

     

       817
       -
       }

     

       818
       -
       

     

       819
       -
       impl<'a, S: file_state::State> FileBuilder<'a, S> {

     

       820
       -
           /// Set the `base64` field (optional)

     

       821
       -
           pub fn base64(mut self, value: impl Into<Option<bool>>) -> Self {

     

       822
       -
               self.__unsafe_private_named.0 = value.into();

     

       823
       -
               self

     

       824
       -
           }

     

       825
       -
           /// Set the `base64` field to an Option value (optional)

     

       826
       -
           pub fn maybe_base64(mut self, value: Option<bool>) -> Self {

     

       827
       -
               self.__unsafe_private_named.0 = value;

     

       828
       -
               self

     

       829
       -
           }

     

       830
       -
       }

     

       831
       -
       

     

       832
       -
       impl<'a, S> FileBuilder<'a, S>

     

       833
       -
       where

     

       834
       -
           S: file_state::State,

     

       835
       -
           S::Blob: file_state::IsUnset,

     

       836
       -
       {

     

       837
       -
           /// Set the `blob` field (required)

     

       838
       -
           pub fn blob(

     

       839
       -
               mut self,

     

       840
       -
               value: impl Into<jacquard_common::types::blob::BlobRef<'a>>,

     

       841
       -
           ) -> FileBuilder<'a, file_state::SetBlob<S>> {

     

       842
       -
               self.__unsafe_private_named.1 = ::core::option::Option::Some(value.into());

     

       843
       -
               FileBuilder {

     

       844
       -
                   _phantom_state: ::core::marker::PhantomData,

     

       845
       -
                   __unsafe_private_named: self.__unsafe_private_named,

     

       846
       -
                   _phantom: ::core::marker::PhantomData,

     

       847
       -
               }

     

       848
       -
           }

     

       849
       -
       }

     

       850
       -
       

     

       851
       -
       impl<'a, S: file_state::State> FileBuilder<'a, S> {

     

       852
       -
           /// Set the `encoding` field (optional)

     

       853
       -
           pub fn encoding(

     

       854
       -
               mut self,

     

       855
       -
               value: impl Into<Option<jacquard_common::CowStr<'a>>>,

     

       856
       -
           ) -> Self {

     

       857
       -
               self.__unsafe_private_named.2 = value.into();

     

       858
       -
               self

     

       859
       -
           }

     

       860
       -
           /// Set the `encoding` field to an Option value (optional)

     

       861
       -
           pub fn maybe_encoding(mut self, value: Option<jacquard_common::CowStr<'a>>) -> Self {

     

       862
       -
               self.__unsafe_private_named.2 = value;

     

       863
       -
               self

     

       864
       -
           }

     

       865
       -
       }

     

       866
       -
       

     

       867
       -
       impl<'a, S: file_state::State> FileBuilder<'a, S> {

     

       868
       -
           /// Set the `mimeType` field (optional)

     

       869
       -
           pub fn mime_type(

     

       870
       -
               mut self,

     

       871
       -
               value: impl Into<Option<jacquard_common::CowStr<'a>>>,

     

       872
       -
           ) -> Self {

     

       873
       -
               self.__unsafe_private_named.3 = value.into();

     

       874
       -
               self

     

       875
       -
           }

     

       876
       -
           /// Set the `mimeType` field to an Option value (optional)

     

       877
       -
           pub fn maybe_mime_type(

     

       878
       -
               mut self,

     

       879
       -
               value: Option<jacquard_common::CowStr<'a>>,

     

       880
       -
           ) -> Self {

     

       881
       -
               self.__unsafe_private_named.3 = value;

     

       882
       -
               self

     

       883
       -
           }

     

       884
       -
       }

     

       885
       -
       

     

       886
       -
       impl<'a, S> FileBuilder<'a, S>

     

       887
       -
       where

     

       888
       -
           S: file_state::State,

     

       889
       -
           S::Type: file_state::IsUnset,

     

       890
       -
       {

     

       891
       -
           /// Set the `type` field (required)

     

       892
       -
           pub fn r#type(

     

       893
       -
               mut self,

     

       894
       -
               value: impl Into<jacquard_common::CowStr<'a>>,

     

       895
       -
           ) -> FileBuilder<'a, file_state::SetType<S>> {

     

       896
       -
               self.__unsafe_private_named.4 = ::core::option::Option::Some(value.into());

     

       897
       -
               FileBuilder {

     

       898
       -
                   _phantom_state: ::core::marker::PhantomData,

     

       899
       -
                   __unsafe_private_named: self.__unsafe_private_named,

     

       900
       -
                   _phantom: ::core::marker::PhantomData,

     

       901
       -
               }

     

       902
       -
           }

     

       903
       -
       }

     

       904
       -
       

     

       905
       -
       impl<'a, S> FileBuilder<'a, S>

     

       906
       -
       where

     

       907
       -
           S: file_state::State,

     

       908
       -
           S::Type: file_state::IsSet,

     

       909
       -
           S::Blob: file_state::IsSet,

     

       910
       -
       {

     

       911
       -
           /// Build the final struct

     

       912
       -
           pub fn build(self) -> File<'a> {

     

       913
       -
               File {

     

       914
       -
                   base64: self.__unsafe_private_named.0,

     

       915
       -
                   blob: self.__unsafe_private_named.1.unwrap(),

     

       916
       -
                   encoding: self.__unsafe_private_named.2,

     

       917
       -
                   mime_type: self.__unsafe_private_named.3,

     

       918
       -
                   r#type: self.__unsafe_private_named.4.unwrap(),

     

       919
       -
                   extra_data: Default::default(),

     

       920
       -
               }

     

       921
       -
           }

     

       922
       -
           /// Build the final struct with custom extra_data

     

       923
       -
           pub fn build_with_data(

     

       924
       -
               self,

     

       925
       -
               extra_data: std::collections::BTreeMap<

     

       926
       -
                   jacquard_common::smol_str::SmolStr,

     

       927
       -
                   jacquard_common::types::value::Data<'a>,

     

       928
       -
               >,

     

       929
       -
           ) -> File<'a> {

     

       930
       -
               File {

     

       931
       -
                   base64: self.__unsafe_private_named.0,

     

       932
       -
                   blob: self.__unsafe_private_named.1.unwrap(),

     

       933
       -
                   encoding: self.__unsafe_private_named.2,

     

       934
       -
                   mime_type: self.__unsafe_private_named.3,

     

       935
       -
                   r#type: self.__unsafe_private_named.4.unwrap(),

     

       936
       -
                   extra_data: Some(extra_data),

     

       937
       -
               }

     

       938
       -
           }

     

       939
       -
       }

     

       940
       -
       

     

       941
       -
       impl<'a> ::jacquard_lexicon::schema::LexiconSchema for File<'a> {

     

       942
       -
           fn nsid() -> &'static str {

     

       943
       -
               "place.wisp.subfs"

     

       944
       -
           }

     

       945
       -
           fn def_name() -> &'static str {

     

       946
       -
               "file"

     

       947
       -
           }

     

       948
       -
           fn lexicon_doc() -> ::jacquard_lexicon::lexicon::LexiconDoc<'static> {

     

       949
       -
               lexicon_doc_place_wisp_subfs()

     

       950
       -
           }

     

       951
       -
           fn validate(

     

       952
       -
               &self,

     

       953
       -
           ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> {

     

       954
       -
               Ok(())

     

       955
       -
           }

     

       956
       -
       }

     

       957
       -
       

     

       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
       -
       #[jacquard_derive::lexicon]

     

       960
       -
       #[derive(

     

       961
       -
           serde::Serialize,

     

       962
       -
           serde::Deserialize,

     

       963
       -
           Debug,

     

       964
       -
           Clone,

     

       965
       -
           PartialEq,

     

       966
       -
           Eq,

     

       967
       -
           jacquard_derive::IntoStatic

     

       968
       -
       )]

     

       969
       -
       #[serde(rename_all = "camelCase")]

     

       970
       -
       pub struct SubfsRecord<'a> {

     

       971
       -
           pub created_at: jacquard_common::types::string::Datetime,

     

       972
       -
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       973
       -
           pub file_count: Option<i64>,

     

       974
       -
           #[serde(borrow)]

     

       975
       -
           pub root: crate::place_wisp::subfs::Directory<'a>,

     

       976
       -
       }

     

       977
       -
       

     

       978
       -
       pub mod subfs_record_state {

     

       979
       -
       

     

       980
       -
           pub use crate::builder_types::{Set, Unset, IsSet, IsUnset};

     

       981
       -
           #[allow(unused)]

     

       982
       -
           use ::core::marker::PhantomData;

     

       983
       -
           mod sealed {

     

       984
       -
               pub trait Sealed {}

     

       985
       -
           }

     

       986
       -
           /// State trait tracking which required fields have been set

     

       987
       -
           pub trait State: sealed::Sealed {

     

       988
       -
               type Root;

     

       989
       -
               type CreatedAt;

     

       990
       -
           }

     

       991
       -
           /// Empty state - all required fields are unset

     

       992
       -
           pub struct Empty(());

     

       993
       -
           impl sealed::Sealed for Empty {}

     

       994
       -
           impl State for Empty {

     

       995
       -
               type Root = Unset;

     

       996
       -
               type CreatedAt = Unset;

     

       997
       -
           }

     

       998
       -
           ///State transition - sets the `root` field to Set

     

       999
       -
           pub struct SetRoot<S: State = Empty>(PhantomData<fn() -> S>);

     

       1000
       -
           impl<S: State> sealed::Sealed for SetRoot<S> {}

     

       1001
       -
           impl<S: State> State for SetRoot<S> {

     

       1002
       -
               type Root = Set<members::root>;

     

       1003
       -
               type CreatedAt = S::CreatedAt;

     

       1004
       -
           }

     

       1005
       -
           ///State transition - sets the `created_at` field to Set

     

       1006
       -
           pub struct SetCreatedAt<S: State = Empty>(PhantomData<fn() -> S>);

     

       1007
       -
           impl<S: State> sealed::Sealed for SetCreatedAt<S> {}

     

       1008
       -
           impl<S: State> State for SetCreatedAt<S> {

     

       1009
       -
               type Root = S::Root;

     

       1010
       -
               type CreatedAt = Set<members::created_at>;

     

       1011
       -
           }

     

       1012
       -
           /// Marker types for field names

     

       1013
       -
           #[allow(non_camel_case_types)]

     

       1014
       -
           pub mod members {

     

       1015
       -
               ///Marker type for the `root` field

     

       1016
       -
               pub struct root(());

     

       1017
       -
               ///Marker type for the `created_at` field

     

       1018
       -
               pub struct created_at(());

     

       1019
       -
           }

     

       1020
       -
       }

     

       1021
       -
       

     

       1022
       -
       /// Builder for constructing an instance of this type

     

       1023
       -
       pub struct SubfsRecordBuilder<'a, S: subfs_record_state::State> {

     

       1024
       -
           _phantom_state: ::core::marker::PhantomData<fn() -> S>,

     

       1025
       -
           __unsafe_private_named: (

     

       1026
       -
               ::core::option::Option<jacquard_common::types::string::Datetime>,

     

       1027
       -
               ::core::option::Option<i64>,

     

       1028
       -
               ::core::option::Option<crate::place_wisp::subfs::Directory<'a>>,

     

       1029
       -
           ),

     

       1030
       -
           _phantom: ::core::marker::PhantomData<&'a ()>,

     

       1031
       -
       }

     

       1032
       -
       

     

       1033
       -
       impl<'a> SubfsRecord<'a> {

     

       1034
       -
           /// Create a new builder for this type

     

       1035
       -
           pub fn new() -> SubfsRecordBuilder<'a, subfs_record_state::Empty> {

     

       1036
       -
               SubfsRecordBuilder::new()

     

       1037
       -
           }

     

       1038
       -
       }

     

       1039
       -
       

     

       1040
       -
       impl<'a> SubfsRecordBuilder<'a, subfs_record_state::Empty> {

     

       1041
       -
           /// Create a new builder with all fields unset

     

       1042
       -
           pub fn new() -> Self {

     

       1043
       -
               SubfsRecordBuilder {

     

       1044
       -
                   _phantom_state: ::core::marker::PhantomData,

     

       1045
       -
                   __unsafe_private_named: (None, None, None),

     

       1046
       -
                   _phantom: ::core::marker::PhantomData,

     

       1047
       -
               }

     

       1048
       -
           }

     

       1049
       -
       }

     

       1050
       -
       

     

       1051
       -
       impl<'a, S> SubfsRecordBuilder<'a, S>

     

       1052
       -
       where

     

       1053
       -
           S: subfs_record_state::State,

     

       1054
       -
           S::CreatedAt: subfs_record_state::IsUnset,

     

       1055
       -
       {

     

       1056
       -
           /// Set the `createdAt` field (required)

     

       1057
       -
           pub fn created_at(

     

       1058
       -
               mut self,

     

       1059
       -
               value: impl Into<jacquard_common::types::string::Datetime>,

     

       1060
       -
           ) -> SubfsRecordBuilder<'a, subfs_record_state::SetCreatedAt<S>> {

     

       1061
       -
               self.__unsafe_private_named.0 = ::core::option::Option::Some(value.into());

     

       1062
       -
               SubfsRecordBuilder {

     

       1063
       -
                   _phantom_state: ::core::marker::PhantomData,

     

       1064
       -
                   __unsafe_private_named: self.__unsafe_private_named,

     

       1065
       -
                   _phantom: ::core::marker::PhantomData,

     

       1066
       -
               }

     

       1067
       -
           }

     

       1068
       -
       }

     

       1069
       -
       

     

       1070
       -
       impl<'a, S: subfs_record_state::State> SubfsRecordBuilder<'a, S> {

     

       1071
       -
           /// Set the `fileCount` field (optional)

     

       1072
       -
           pub fn file_count(mut self, value: impl Into<Option<i64>>) -> Self {

     

       1073
       -
               self.__unsafe_private_named.1 = value.into();

     

       1074
       -
               self

     

       1075
       -
           }

     

       1076
       -
           /// Set the `fileCount` field to an Option value (optional)

     

       1077
       -
           pub fn maybe_file_count(mut self, value: Option<i64>) -> Self {

     

       1078
       -
               self.__unsafe_private_named.1 = value;

     

       1079
       -
               self

     

       1080
       -
           }

     

       1081
       -
       }

     

       1082
       -
       

     

       1083
       -
       impl<'a, S> SubfsRecordBuilder<'a, S>

     

       1084
       -
       where

     

       1085
       -
           S: subfs_record_state::State,

     

       1086
       -
           S::Root: subfs_record_state::IsUnset,

     

       1087
       -
       {

     

       1088
       -
           /// Set the `root` field (required)

     

       1089
       -
           pub fn root(

     

       1090
       -
               mut self,

     

       1091
       -
               value: impl Into<crate::place_wisp::subfs::Directory<'a>>,

     

       1092
       -
           ) -> SubfsRecordBuilder<'a, subfs_record_state::SetRoot<S>> {

     

       1093
       -
               self.__unsafe_private_named.2 = ::core::option::Option::Some(value.into());

     

       1094
       -
               SubfsRecordBuilder {

     

       1095
       -
                   _phantom_state: ::core::marker::PhantomData,

     

       1096
       -
                   __unsafe_private_named: self.__unsafe_private_named,

     

       1097
       -
                   _phantom: ::core::marker::PhantomData,

     

       1098
       -
               }

     

       1099
       -
           }

     

       1100
       -
       }

     

       1101
       -
       

     

       1102
       -
       impl<'a, S> SubfsRecordBuilder<'a, S>

     

       1103
       -
       where

     

       1104
       -
           S: subfs_record_state::State,

     

       1105
       -
           S::Root: subfs_record_state::IsSet,

     

       1106
       -
           S::CreatedAt: subfs_record_state::IsSet,

     

       1107
       -
       {

     

       1108
       -
           /// Build the final struct

     

       1109
       -
           pub fn build(self) -> SubfsRecord<'a> {

     

       1110
       -
               SubfsRecord {

     

       1111
       -
                   created_at: self.__unsafe_private_named.0.unwrap(),

     

       1112
       -
                   file_count: self.__unsafe_private_named.1,

     

       1113
       -
                   root: self.__unsafe_private_named.2.unwrap(),

     

       1114
       -
                   extra_data: Default::default(),

     

       1115
       -
               }

     

       1116
       -
           }

     

       1117
       -
           /// Build the final struct with custom extra_data

     

       1118
       -
           pub fn build_with_data(

     

       1119
       -
               self,

     

       1120
       -
               extra_data: std::collections::BTreeMap<

     

       1121
       -
                   jacquard_common::smol_str::SmolStr,

     

       1122
       -
                   jacquard_common::types::value::Data<'a>,

     

       1123
       -
               >,

     

       1124
       -
           ) -> SubfsRecord<'a> {

     

       1125
       -
               SubfsRecord {

     

       1126
       -
                   created_at: self.__unsafe_private_named.0.unwrap(),

     

       1127
       -
                   file_count: self.__unsafe_private_named.1,

     

       1128
       -
                   root: self.__unsafe_private_named.2.unwrap(),

     

       1129
       -
                   extra_data: Some(extra_data),

     

       1130
       -
               }

     

       1131
       -
           }

     

       1132
       -
       }

     

       1133
       -
       

     

       1134
       -
       impl<'a> SubfsRecord<'a> {

     

       1135
       -
           pub fn uri(

     

       1136
       -
               uri: impl Into<jacquard_common::CowStr<'a>>,

     

       1137
       -
           ) -> Result<

     

       1138
       -
               jacquard_common::types::uri::RecordUri<'a, SubfsRecordRecord>,

     

       1139
       -
               jacquard_common::types::uri::UriError,

     

       1140
       -
           > {

     

       1141
       -
               jacquard_common::types::uri::RecordUri::try_from_uri(

     

       1142
       -
                   jacquard_common::types::string::AtUri::new_cow(uri.into())?,

     

       1143
       -
               )

     

       1144
       -
           }

     

       1145
       -
       }

     

       1146
       -
       

     

       1147
       -
       /// Typed wrapper for GetRecord response with this collection's record type.

     

       1148
       -
       #[derive(

     

       1149
       -
           serde::Serialize,

     

       1150
       -
           serde::Deserialize,

     

       1151
       -
           Debug,

     

       1152
       -
           Clone,

     

       1153
       -
           PartialEq,

     

       1154
       -
           Eq,

     

       1155
       -
           jacquard_derive::IntoStatic

     

       1156
       -
       )]

     

       1157
       -
       #[serde(rename_all = "camelCase")]

     

       1158
       -
       pub struct SubfsRecordGetRecordOutput<'a> {

     

       1159
       -
           #[serde(skip_serializing_if = "std::option::Option::is_none")]

     

       1160
       -
           #[serde(borrow)]

     

       1161
       -
           pub cid: std::option::Option<jacquard_common::types::string::Cid<'a>>,

     

       1162
       -
           #[serde(borrow)]

     

       1163
       -
           pub uri: jacquard_common::types::string::AtUri<'a>,

     

       1164
       -
           #[serde(borrow)]

     

       1165
       -
           pub value: SubfsRecord<'a>,

     

       1166
       -
       }

     

       1167
       -
       

     

       1168
       -
       impl From<SubfsRecordGetRecordOutput<'_>> for SubfsRecord<'_> {

     

       1169
       -
           fn from(output: SubfsRecordGetRecordOutput<'_>) -> Self {

     

       1170
       -
               use jacquard_common::IntoStatic;

     

       1171
       -
               output.value.into_static()

     

       1172
       -
           }

     

       1173
       -
       }

     

       1174
       -
       

     

       1175
       -
       impl jacquard_common::types::collection::Collection for SubfsRecord<'_> {

     

       1176
       -
           const NSID: &'static str = "place.wisp.subfs";

     

       1177
       -
           type Record = SubfsRecordRecord;

     

       1178
       -
       }

     

       1179
       -
       

     

       1180
       -
       /// Marker type for deserializing records from this collection.

     

       1181
       -
       #[derive(Debug, serde::Serialize, serde::Deserialize)]

     

       1182
       -
       pub struct SubfsRecordRecord;

     

       1183
       -
       impl jacquard_common::xrpc::XrpcResp for SubfsRecordRecord {

     

       1184
       -
           const NSID: &'static str = "place.wisp.subfs";

     

       1185
       -
           const ENCODING: &'static str = "application/json";

     

       1186
       -
           type Output<'de> = SubfsRecordGetRecordOutput<'de>;

     

       1187
       -
           type Err<'de> = jacquard_common::types::collection::RecordError<'de>;

     

       1188
       -
       }

     

       1189
       -
       

     

       1190
       -
       impl jacquard_common::types::collection::Collection for SubfsRecordRecord {

     

       1191
       -
           const NSID: &'static str = "place.wisp.subfs";

     

       1192
       -
           type Record = SubfsRecordRecord;

     

       1193
       -
       }

     

       1194
       -
       

     

       1195
       -
       impl<'a> ::jacquard_lexicon::schema::LexiconSchema for SubfsRecord<'a> {

     

       1196
       -
           fn nsid() -> &'static str {

     

       1197
       -
               "place.wisp.subfs"

     

       1198
       -
           }

     

       1199
       -
           fn def_name() -> &'static str {

     

       1200
       -
               "main"

     

       1201
       -
           }

     

       1202
       -
           fn lexicon_doc() -> ::jacquard_lexicon::lexicon::LexiconDoc<'static> {

     

       1203
       -
               lexicon_doc_place_wisp_subfs()

     

       1204
       -
           }

     

       1205
       -
           fn validate(

     

       1206
       -
               &self,

     

       1207
       -
           ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> {

     

       1208
       -
               if let Some(ref value) = self.file_count {

     

       1209
       -
                   if *value > 1000i64 {

     

       1210
       -
                       return Err(::jacquard_lexicon::validation::ConstraintError::Maximum {

     

       1211
       -
                           path: ::jacquard_lexicon::validation::ValidationPath::from_field(

     

       1212
       -
                               "file_count",

     

       1213
       -
                           ),

     

       1214
       -
                           max: 1000i64,

     

       1215
       -
                           actual: *value,

     

       1216
       -
                       });

     

       1217
       -
                   }

     

       1218
       -
               }

     

       1219
       -
               if let Some(ref value) = self.file_count {

     

       1220
       -
                   if *value < 0i64 {

     

       1221
       -
                       return Err(::jacquard_lexicon::validation::ConstraintError::Minimum {

     

       1222
       -
                           path: ::jacquard_lexicon::validation::ValidationPath::from_field(

     

       1223
       -
                               "file_count",

     

       1224
       -
                           ),

     

       1225
       -
                           min: 0i64,

     

       1226
       -
                           actual: *value,

     

       1227
       -
                       });

     

       1228
       -
                   }

     

       1229
       -
               }

     

       1230
       -
               Ok(())

     

       1231
       -
           }

     

       1232
       -
       }

     

       1233
       -
       

     

       1234
       -
       #[jacquard_derive::lexicon]

     

       1235
       -
       #[derive(

     

       1236
       -
           serde::Serialize,

     

       1237
       -
           serde::Deserialize,

     

       1238
       -
           Debug,

     

       1239
       -
           Clone,

     

       1240
       -
           PartialEq,

     

       1241
       -
           Eq,

     

       1242
       -
           jacquard_derive::IntoStatic

     

       1243
       -
       )]

     

       1244
       -
       #[serde(rename_all = "camelCase")]

     

       1245
       -
       pub struct Subfs<'a> {

     

       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
       -
           #[serde(borrow)]

     

       1248
       -
           pub subject: jacquard_common::types::string::AtUri<'a>,

     

       1249
       -
           #[serde(borrow)]

     

       1250
       -
           pub r#type: jacquard_common::CowStr<'a>,

     

       1251
       -
       }

     

       1252
       -
       

     

       1253
       -
       pub mod subfs_state {

     

       1254
       -
       

     

       1255
       -
           pub use crate::builder_types::{Set, Unset, IsSet, IsUnset};

     

       1256
       -
           #[allow(unused)]

     

       1257
       -
           use ::core::marker::PhantomData;

     

       1258
       -
           mod sealed {

     

       1259
       -
               pub trait Sealed {}

     

       1260
       -
           }

     

       1261
       -
           /// State trait tracking which required fields have been set

     

       1262
       -
           pub trait State: sealed::Sealed {

     

       1263
       -
               type Type;

     

       1264
       -
               type Subject;

     

       1265
       -
           }

     

       1266
       -
           /// Empty state - all required fields are unset

     

       1267
       -
           pub struct Empty(());

     

       1268
       -
           impl sealed::Sealed for Empty {}

     

       1269
       -
           impl State for Empty {

     

       1270
       -
               type Type = Unset;

     

       1271
       -
               type Subject = Unset;

     

       1272
       -
           }

     

       1273
       -
           ///State transition - sets the `type` field to Set

     

       1274
       -
           pub struct SetType<S: State = Empty>(PhantomData<fn() -> S>);

     

       1275
       -
           impl<S: State> sealed::Sealed for SetType<S> {}

     

       1276
       -
           impl<S: State> State for SetType<S> {

     

       1277
       -
               type Type = Set<members::r#type>;

     

       1278
       -
               type Subject = S::Subject;

     

       1279
       -
           }

     

       1280
       -
           ///State transition - sets the `subject` field to Set

     

       1281
       -
           pub struct SetSubject<S: State = Empty>(PhantomData<fn() -> S>);

     

       1282
       -
           impl<S: State> sealed::Sealed for SetSubject<S> {}

     

       1283
       -
           impl<S: State> State for SetSubject<S> {

     

       1284
       -
               type Type = S::Type;

     

       1285
       -
               type Subject = Set<members::subject>;

     

       1286
       -
           }

     

       1287
       -
           /// Marker types for field names

     

       1288
       -
           #[allow(non_camel_case_types)]

     

       1289
       -
           pub mod members {

     

       1290
       -
               ///Marker type for the `type` field

     

       1291
       -
               pub struct r#type(());

     

       1292
       -
               ///Marker type for the `subject` field

     

       1293
       -
               pub struct subject(());

     

       1294
       -
           }

     

       1295
       -
       }

     

       1296
       -
       

     

       1297
       -
       /// Builder for constructing an instance of this type

     

       1298
       -
       pub struct SubfsBuilder<'a, S: subfs_state::State> {

     

       1299
       -
           _phantom_state: ::core::marker::PhantomData<fn() -> S>,

     

       1300
       -
           __unsafe_private_named: (

     

       1301
       -
               ::core::option::Option<jacquard_common::types::string::AtUri<'a>>,

     

       1302
       -
               ::core::option::Option<jacquard_common::CowStr<'a>>,

     

       1303
       -
           ),

     

       1304
       -
           _phantom: ::core::marker::PhantomData<&'a ()>,

     

       1305
       -
       }

     

       1306
       -
       

     

       1307
       -
       impl<'a> Subfs<'a> {

     

       1308
       -
           /// Create a new builder for this type

     

       1309
       -
           pub fn new() -> SubfsBuilder<'a, subfs_state::Empty> {

     

       1310
       -
               SubfsBuilder::new()

     

       1311
       -
           }

     

       1312
       -
       }

     

       1313
       -
       

     

       1314
       -
       impl<'a> SubfsBuilder<'a, subfs_state::Empty> {

     

       1315
       -
           /// Create a new builder with all fields unset

     

       1316
       -
           pub fn new() -> Self {

     

       1317
       -
               SubfsBuilder {

     

       1318
       -
                   _phantom_state: ::core::marker::PhantomData,

     

       1319
       -
                   __unsafe_private_named: (None, None),

     

       1320
       -
                   _phantom: ::core::marker::PhantomData,

     

       1321
       -
               }

     

       1322
       -
           }

     

       1323
       -
       }

     

       1324
       -
       

     

       1325
       -
       impl<'a, S> SubfsBuilder<'a, S>

     

       1326
       -
       where

     

       1327
       -
           S: subfs_state::State,

     

       1328
       -
           S::Subject: subfs_state::IsUnset,

     

       1329
       -
       {

     

       1330
       -
           /// Set the `subject` field (required)

     

       1331
       -
           pub fn subject(

     

       1332
       -
               mut self,

     

       1333
       -
               value: impl Into<jacquard_common::types::string::AtUri<'a>>,

     

       1334
       -
           ) -> SubfsBuilder<'a, subfs_state::SetSubject<S>> {

     

       1335
       -
               self.__unsafe_private_named.0 = ::core::option::Option::Some(value.into());

     

       1336
       -
               SubfsBuilder {

     

       1337
       -
                   _phantom_state: ::core::marker::PhantomData,

     

       1338
       -
                   __unsafe_private_named: self.__unsafe_private_named,

     

       1339
       -
                   _phantom: ::core::marker::PhantomData,

     

       1340
       -
               }

     

       1341
       -
           }

     

       1342
       -
       }

     

       1343
       -
       

     

       1344
       -
       impl<'a, S> SubfsBuilder<'a, S>

     

       1345
       -
       where

     

       1346
       -
           S: subfs_state::State,

     

       1347
       -
           S::Type: subfs_state::IsUnset,

     

       1348
       -
       {

     

       1349
       -
           /// Set the `type` field (required)

     

       1350
       -
           pub fn r#type(

     

       1351
       -
               mut self,

     

       1352
       -
               value: impl Into<jacquard_common::CowStr<'a>>,

     

       1353
       -
           ) -> SubfsBuilder<'a, subfs_state::SetType<S>> {

     

       1354
       -
               self.__unsafe_private_named.1 = ::core::option::Option::Some(value.into());

     

       1355
       -
               SubfsBuilder {

     

       1356
       -
                   _phantom_state: ::core::marker::PhantomData,

     

       1357
       -
                   __unsafe_private_named: self.__unsafe_private_named,

     

       1358
       -
                   _phantom: ::core::marker::PhantomData,

     

       1359
       -
               }

     

       1360
       -
           }

     

       1361
       -
       }

     

       1362
       -
       

     

       1363
       -
       impl<'a, S> SubfsBuilder<'a, S>

     

       1364
       -
       where

     

       1365
       -
           S: subfs_state::State,

     

       1366
       -
           S::Type: subfs_state::IsSet,

     

       1367
       -
           S::Subject: subfs_state::IsSet,

     

       1368
       -
       {

     

       1369
       -
           /// Build the final struct

     

       1370
       -
           pub fn build(self) -> Subfs<'a> {

     

       1371
       -
               Subfs {

     

       1372
       -
                   subject: self.__unsafe_private_named.0.unwrap(),

     

       1373
       -
                   r#type: self.__unsafe_private_named.1.unwrap(),

     

       1374
       -
                   extra_data: Default::default(),

     

       1375
       -
               }

     

       1376
       -
           }

     

       1377
       -
           /// Build the final struct with custom extra_data

     

       1378
       -
           pub fn build_with_data(

     

       1379
       -
               self,

     

       1380
       -
               extra_data: std::collections::BTreeMap<

     

       1381
       -
                   jacquard_common::smol_str::SmolStr,

     

       1382
       -
                   jacquard_common::types::value::Data<'a>,

     

       1383
       -
               >,

     

       1384
       -
           ) -> Subfs<'a> {

     

       1385
       -
               Subfs {

     

       1386
       -
                   subject: self.__unsafe_private_named.0.unwrap(),

     

       1387
       -
                   r#type: self.__unsafe_private_named.1.unwrap(),

     

       1388
       -
                   extra_data: Some(extra_data),

     

       1389
       -
               }

     

       1390
       -
           }

     

       1391
       -
       }

     

       1392
       -
       

     

       1393
       -
       impl<'a> ::jacquard_lexicon::schema::LexiconSchema for Subfs<'a> {

     

       1394
       -
           fn nsid() -> &'static str {

     

       1395
       -
               "place.wisp.subfs"

     

       1396
       -
           }

     

       1397
       -
           fn def_name() -> &'static str {

     

       1398
       -
               "subfs"

     

       1399
       -
           }

     

       1400
       -
           fn lexicon_doc() -> ::jacquard_lexicon::lexicon::LexiconDoc<'static> {

     

       1401
       -
               lexicon_doc_place_wisp_subfs()

     

       1402
       -
           }

     

       1403
       -
           fn validate(

     

       1404
       -
               &self,

     

       1405
       -
           ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> {

     

       1406
       -
               Ok(())

     

       1407
       -
           }

     

       1408
       -
       }

-8

cli/src/place_wisp.rs

···

       1
       -
       // @generated by jacquard-lexicon. DO NOT EDIT.

     

       2
       -
       //

     

       3
       -
       // This file was automatically generated from Lexicon schemas.

     

       4
       -
       // Any manual changes will be overwritten on the next regeneration.

     

       5
       -
       

     

       6
       -
       pub mod fs;

     

       7
       -
       pub mod settings;

     

       8
       -
       pub mod subfs;

+12 -12

cli/src/pull.rs

···

       1
        
       use crate::blob_map;

     

       2
        
       use crate::download;

     

       3
        
       use crate::metadata::SiteMetadata;

     

       4
       -
       use crate::place_wisp::fs::*;

     

       5
        
       use crate::subfs_utils;

     

       6
        
       use jacquard::CowStr;

     

       7
        
       use jacquard::prelude::IdentityResolver;

     
···

       410
        
       ) -> miette::Result<Directory<'static>> {

     

       411
        
           use jacquard_common::IntoStatic;

     

       412
        
           use jacquard_common::types::value::from_data;

     

       413
       -
           use crate::place_wisp::subfs::SubfsRecord;

     

       414
        
       

     

       415
       -
           let mut all_subfs_map: HashMap<String, crate::place_wisp::subfs::Directory> = HashMap::new();

     

       416
        
           let mut to_fetch = subfs_utils::extract_subfs_uris(directory, String::new());

     

       417
        
       

     

       418
        
           if to_fetch.is_empty() {

     
···

       516
        
       

     

       517
        
       /// Extract subfs URIs from a subfs::Directory (helper for pull)

     

       518
        
       fn extract_subfs_uris_from_subfs_dir(

     

       519
       -
           directory: &crate::place_wisp::subfs::Directory,

     

       520
        
           current_path: String,

     

       521
        
       ) -> Vec<(String, String)> {

     

       522
        
           let mut uris = Vec::new();

     
···

       529
        
               };

     

       530
        
       

     

       531
        
               match &entry.node {

     

       532
       -
                   crate::place_wisp::subfs::EntryNode::Subfs(subfs_node) => {

     

       533
        
                       uris.push((subfs_node.subject.to_string(), full_path.clone()));

     

       534
        
                   }

     

       535
       -
                   crate::place_wisp::subfs::EntryNode::Directory(subdir) => {

     

       536
        
                       let nested = extract_subfs_uris_from_subfs_dir(subdir, full_path);

     

       537
        
                       uris.extend(nested);

     

       538
        
                   }

     
···

       546
        
       /// Recursively replace subfs nodes with their actual content

     

       547
        
       fn replace_subfs_with_content(

     

       548
        
           directory: Directory,

     

       549
       -
           subfs_map: &HashMap<String, crate::place_wisp::subfs::Directory>,

     

       550
        
           current_path: String,

     

       551
        
       ) -> Directory<'static> {

     

       552
        
           use jacquard_common::IntoStatic;

     
···

       628
        
       }

     

       629
        
       

     

       630
        
       /// Convert a subfs entry to a fs entry (they have the same structure but different types)

     

       631
       -
       fn convert_subfs_entry_to_fs(subfs_entry: crate::place_wisp::subfs::Entry<'static>) -> Entry<'static> {

     

       632
        
           use jacquard_common::IntoStatic;

     

       633
        
       

     

       634
        
           let node = match subfs_entry.node {

     

       635
       -
               crate::place_wisp::subfs::EntryNode::File(file) => {

     

       636
        
                   EntryNode::File(Box::new(

     

       637
        
                       File::new()

     

       638
        
                           .r#type(file.r#type.into_static())

     
···

       643
        
                           .build()

     

       644
        
                   ))

     

       645
        
               }

     

       646
       -
               crate::place_wisp::subfs::EntryNode::Directory(dir) => {

     

       647
        
                   let converted_entries: Vec<Entry<'static>> = dir

     

       648
        
                       .entries

     

       649
        
                       .into_iter()

     
···

       657
        
                           .build()

     

       658
        
                   ))

     

       659
        
               }

     

       660
       -
               crate::place_wisp::subfs::EntryNode::Subfs(_nested_subfs) => {

     

       661
        
                   // Nested subfs should have been expanded already - if we get here, it means expansion failed

     

       662
        
                   // Treat it like a directory reference that should have been expanded

     

       663
        
                   eprintln!("  ⚠️  Warning: unexpanded nested subfs at path, treating as empty directory");

     
···

       668
        
                           .build()

     

       669
        
                   ))

     

       670
        
               }

     

       671
       -
               crate::place_wisp::subfs::EntryNode::Unknown(unknown) => {

     

       672
        
                   EntryNode::Unknown(unknown)

     

       673
        
               }

     

       674
        
           };

···

       1
        
       use crate::blob_map;

     

       2
        
       use crate::download;

     

       3
        
       use crate::metadata::SiteMetadata;

     

       4
       +
       use wisp_lexicons::place_wisp::fs::*;

     

       5
        
       use crate::subfs_utils;

     

       6
        
       use jacquard::CowStr;

     

       7
        
       use jacquard::prelude::IdentityResolver;

     
···

       410
        
       ) -> miette::Result<Directory<'static>> {

     

       411
        
           use jacquard_common::IntoStatic;

     

       412
        
           use jacquard_common::types::value::from_data;

     

       413
       +
           use wisp_lexicons::place_wisp::subfs::SubfsRecord;

     

       414
        
       

     

       415
       +
           let mut all_subfs_map: HashMap<String, wisp_lexicons::place_wisp::subfs::Directory> = HashMap::new();

     

       416
        
           let mut to_fetch = subfs_utils::extract_subfs_uris(directory, String::new());

     

       417
        
       

     

       418
        
           if to_fetch.is_empty() {

     
···

       516
        
       

     

       517
        
       /// Extract subfs URIs from a subfs::Directory (helper for pull)

     

       518
        
       fn extract_subfs_uris_from_subfs_dir(

     

       519
       +
           directory: &wisp_lexicons::place_wisp::subfs::Directory,

     

       520
        
           current_path: String,

     

       521
        
       ) -> Vec<(String, String)> {

     

       522
        
           let mut uris = Vec::new();

     
···

       529
        
               };

     

       530
        
       

     

       531
        
               match &entry.node {

     

       532
       +
                   wisp_lexicons::place_wisp::subfs::EntryNode::Subfs(subfs_node) => {

     

       533
        
                       uris.push((subfs_node.subject.to_string(), full_path.clone()));

     

       534
        
                   }

     

       535
       +
                   wisp_lexicons::place_wisp::subfs::EntryNode::Directory(subdir) => {

     

       536
        
                       let nested = extract_subfs_uris_from_subfs_dir(subdir, full_path);

     

       537
        
                       uris.extend(nested);

     

       538
        
                   }

     
···

       546
        
       /// Recursively replace subfs nodes with their actual content

     

       547
        
       fn replace_subfs_with_content(

     

       548
        
           directory: Directory,

     

       549
       +
           subfs_map: &HashMap<String, wisp_lexicons::place_wisp::subfs::Directory>,

     

       550
        
           current_path: String,

     

       551
        
       ) -> Directory<'static> {

     

       552
        
           use jacquard_common::IntoStatic;

     
···

       628
        
       }

     

       629
        
       

     

       630
        
       /// Convert a subfs entry to a fs entry (they have the same structure but different types)

     

       631
       +
       fn convert_subfs_entry_to_fs(subfs_entry: wisp_lexicons::place_wisp::subfs::Entry<'static>) -> Entry<'static> {

     

       632
        
           use jacquard_common::IntoStatic;

     

       633
        
       

     

       634
        
           let node = match subfs_entry.node {

     

       635
       +
               wisp_lexicons::place_wisp::subfs::EntryNode::File(file) => {

     

       636
        
                   EntryNode::File(Box::new(

     

       637
        
                       File::new()

     

       638
        
                           .r#type(file.r#type.into_static())

     
···

       643
        
                           .build()

     

       644
        
                   ))

     

       645
        
               }

     

       646
       +
               wisp_lexicons::place_wisp::subfs::EntryNode::Directory(dir) => {

     

       647
        
                   let converted_entries: Vec<Entry<'static>> = dir

     

       648
        
                       .entries

     

       649
        
                       .into_iter()

     
···

       657
        
                           .build()

     

       658
        
                   ))

     

       659
        
               }

     

       660
       +
               wisp_lexicons::place_wisp::subfs::EntryNode::Subfs(_nested_subfs) => {

     

       661
        
                   // Nested subfs should have been expanded already - if we get here, it means expansion failed

     

       662
        
                   // Treat it like a directory reference that should have been expanded

     

       663
        
                   eprintln!("  ⚠️  Warning: unexpanded nested subfs at path, treating as empty directory");

     
···

       668
        
                           .build()

     

       669
        
                   ))

     

       670
        
               }

     

       671
       +
               wisp_lexicons::place_wisp::subfs::EntryNode::Unknown(unknown) => {

     

       672
        
                   EntryNode::Unknown(unknown)

     

       673
        
               }

     

       674
        
           };

+1 -1

cli/src/serve.rs

···

       1
        
       use crate::pull::pull_site;

     

       2
        
       use crate::redirects::{load_redirect_rules, match_redirect_rule, RedirectRule};

     

       3
       -
       use crate::place_wisp::settings::Settings;

     

       4
        
       use axum::{

     

       5
        
           Router,

     

       6
        
           extract::Request,

···

       1
        
       use crate::pull::pull_site;

     

       2
        
       use crate::redirects::{load_redirect_rules, match_redirect_rule, RedirectRule};

     

       3
       +
       use wisp_lexicons::place_wisp::settings::Settings;

     

       4
        
       use axum::{

     

       5
        
           Router,

     

       6
        
           extract::Request,

+14 -14

cli/src/subfs_utils.rs

···

       6
        
       use miette::IntoDiagnostic;

     

       7
        
       use std::collections::HashMap;

     

       8
        
       

     

       9
       -
       use crate::place_wisp::fs::{Directory as FsDirectory, EntryNode as FsEntryNode};

     

       10
       -
       use crate::place_wisp::subfs::SubfsRecord;

     

       11
        
       

     

       12
        
       /// Extract all subfs URIs from a directory tree with their mount paths

     

       13
        
       pub fn extract_subfs_uris(directory: &FsDirectory, current_path: String) -> Vec<(String, String)> {

     
···

       145
        
       

     

       146
        
       /// Extract subfs URIs from a subfs::Directory

     

       147
        
       fn extract_subfs_uris_from_subfs_dir(

     

       148
       -
           directory: &crate::place_wisp::subfs::Directory,

     

       149
        
           current_path: String,

     

       150
        
       ) -> Vec<(String, String)> {

     

       151
        
           let mut uris = Vec::new();

     

       152
        
       

     

       153
        
           for entry in &directory.entries {

     

       154
        
               match &entry.node {

     

       155
       -
                   crate::place_wisp::subfs::EntryNode::Subfs(subfs_node) => {

     

       156
        
                       // Check if this is a chunk entry (chunk0, chunk1, etc.)

     

       157
        
                       // Chunks should be flat-merged, so use the parent's path

     

       158
        
                       let mount_path = if entry.name.starts_with("chunk") &&

     
···

       171
        
       

     

       172
        
                       uris.push((subfs_node.subject.to_string(), mount_path));

     

       173
        
                   }

     

       174
       -
                   crate::place_wisp::subfs::EntryNode::Directory(subdir) => {

     

       175
        
                       let full_path = if current_path.is_empty() {

     

       176
        
                           entry.name.to_string()

     

       177
        
                       } else {

     
···

       204
        
           for (mount_path, subfs_record) in all_subfs {

     

       205
        
               // Check if this record only contains chunk subfs references (no files)

     

       206
        
               let only_has_chunks = subfs_record.root.entries.iter().all(|e| {

     

       207
       -
                   matches!(&e.node, crate::place_wisp::subfs::EntryNode::Subfs(_)) &&

     

       208
        
                   e.name.starts_with("chunk") &&

     

       209
        
                   e.name.chars().skip(5).all(|c| c.is_ascii_digit())

     

       210
        
               });

     
···

       232
        
       /// Extract blobs from a subfs directory (works with subfs::Directory)

     

       233
        
       /// Returns a map of file paths to their blob refs and CIDs

     

       234
        
       fn extract_subfs_blobs(

     

       235
       -
           directory: &crate::place_wisp::subfs::Directory,

     

       236
        
           current_path: String,

     

       237
        
       ) -> HashMap<String, (BlobRef<'static>, String)> {

     

       238
        
           let mut blob_map = HashMap::new();

     
···

       245
        
               };

     

       246
        
       

     

       247
        
               match &entry.node {

     

       248
       -
                   crate::place_wisp::subfs::EntryNode::File(file_node) => {

     

       249
        
                       let blob_ref = &file_node.blob;

     

       250
        
                       let cid_string = blob_ref.blob().r#ref.to_string();

     

       251
        
                       blob_map.insert(

     
···

       253
        
                           (blob_ref.clone().into_static(), cid_string)

     

       254
        
                       );

     

       255
        
                   }

     

       256
       -
                   crate::place_wisp::subfs::EntryNode::Directory(subdir) => {

     

       257
        
                       let sub_map = extract_subfs_blobs(subdir, full_path);

     

       258
        
                       blob_map.extend(sub_map);

     

       259
        
                   }

     

       260
       -
                   crate::place_wisp::subfs::EntryNode::Subfs(_nested_subfs) => {

     

       261
        
                       // Nested subfs - these should be resolved recursively in the main flow

     

       262
        
                       // For now, we skip them (they'll be fetched separately)

     

       263
        
                       eprintln!("  ⚠️  Found nested subfs at {}, skipping (should be fetched separately)", full_path);

     

       264
        
                   }

     

       265
       -
                   crate::place_wisp::subfs::EntryNode::Unknown(_) => {

     

       266
        
                       // Skip unknown nodes

     

       267
        
                   }

     

       268
        
               }

     
···

       352
        
           flat: bool,

     

       353
        
       ) -> miette::Result<FsDirectory<'static>> {

     

       354
        
           use jacquard_common::CowStr;

     

       355
       -
           use crate::place_wisp::fs::{Entry, Subfs};

     

       356
        
       

     

       357
        
           let path_parts: Vec<&str> = target_path.split('/').collect();

     

       358
        
       

     
···

       430
        
       

     

       431
        
           // Construct AT-URI and convert to RecordUri

     

       432
        
           let at_uri = AtUri::new(uri).into_diagnostic()?;

     

       433
       -
           let record_uri: RecordUri<'_, crate::place_wisp::subfs::SubfsRecordRecord> = RecordUri::try_from_uri(at_uri).into_diagnostic()?;

     

       434
        
       

     

       435
        
           let rkey = record_uri.rkey()

     

       436
        
               .ok_or_else(|| miette::miette!("Invalid subfs URI: missing rkey"))?

     
···

       489
        
       }

     

       490
        
       

     

       491
        
       /// Estimate the JSON size of a single entry

     

       492
       -
       fn estimate_entry_size(entry: &crate::place_wisp::fs::Entry) -> usize {

     

       493
        
           match serde_json::to_string(entry) {

     

       494
        
               Ok(json) => json.len(),

     

       495
        
               Err(_) => 500, // Conservative estimate if serialization fails

···

       6
        
       use miette::IntoDiagnostic;

     

       7
        
       use std::collections::HashMap;

     

       8
        
       

     

       9
       +
       use wisp_lexicons::place_wisp::fs::{Directory as FsDirectory, EntryNode as FsEntryNode};

     

       10
       +
       use wisp_lexicons::place_wisp::subfs::SubfsRecord;

     

       11
        
       

     

       12
        
       /// Extract all subfs URIs from a directory tree with their mount paths

     

       13
        
       pub fn extract_subfs_uris(directory: &FsDirectory, current_path: String) -> Vec<(String, String)> {

     
···

       145
        
       

     

       146
        
       /// Extract subfs URIs from a subfs::Directory

     

       147
        
       fn extract_subfs_uris_from_subfs_dir(

     

       148
       +
           directory: &wisp_lexicons::place_wisp::subfs::Directory,

     

       149
        
           current_path: String,

     

       150
        
       ) -> Vec<(String, String)> {

     

       151
        
           let mut uris = Vec::new();

     

       152
        
       

     

       153
        
           for entry in &directory.entries {

     

       154
        
               match &entry.node {

     

       155
       +
                   wisp_lexicons::place_wisp::subfs::EntryNode::Subfs(subfs_node) => {

     

       156
        
                       // Check if this is a chunk entry (chunk0, chunk1, etc.)

     

       157
        
                       // Chunks should be flat-merged, so use the parent's path

     

       158
        
                       let mount_path = if entry.name.starts_with("chunk") &&

     
···

       171
        
       

     

       172
        
                       uris.push((subfs_node.subject.to_string(), mount_path));

     

       173
        
                   }

     

       174
       +
                   wisp_lexicons::place_wisp::subfs::EntryNode::Directory(subdir) => {

     

       175
        
                       let full_path = if current_path.is_empty() {

     

       176
        
                           entry.name.to_string()

     

       177
        
                       } else {

     
···

       204
        
           for (mount_path, subfs_record) in all_subfs {

     

       205
        
               // Check if this record only contains chunk subfs references (no files)

     

       206
        
               let only_has_chunks = subfs_record.root.entries.iter().all(|e| {

     

       207
       +
                   matches!(&e.node, wisp_lexicons::place_wisp::subfs::EntryNode::Subfs(_)) &&

     

       208
        
                   e.name.starts_with("chunk") &&

     

       209
        
                   e.name.chars().skip(5).all(|c| c.is_ascii_digit())

     

       210
        
               });

     
···

       232
        
       /// Extract blobs from a subfs directory (works with subfs::Directory)

     

       233
        
       /// Returns a map of file paths to their blob refs and CIDs

     

       234
        
       fn extract_subfs_blobs(

     

       235
       +
           directory: &wisp_lexicons::place_wisp::subfs::Directory,

     

       236
        
           current_path: String,

     

       237
        
       ) -> HashMap<String, (BlobRef<'static>, String)> {

     

       238
        
           let mut blob_map = HashMap::new();

     
···

       245
        
               };

     

       246
        
       

     

       247
        
               match &entry.node {

     

       248
       +
                   wisp_lexicons::place_wisp::subfs::EntryNode::File(file_node) => {

     

       249
        
                       let blob_ref = &file_node.blob;

     

       250
        
                       let cid_string = blob_ref.blob().r#ref.to_string();

     

       251
        
                       blob_map.insert(

     
···

       253
        
                           (blob_ref.clone().into_static(), cid_string)

     

       254
        
                       );

     

       255
        
                   }

     

       256
       +
                   wisp_lexicons::place_wisp::subfs::EntryNode::Directory(subdir) => {

     

       257
        
                       let sub_map = extract_subfs_blobs(subdir, full_path);

     

       258
        
                       blob_map.extend(sub_map);

     

       259
        
                   }

     

       260
       +
                   wisp_lexicons::place_wisp::subfs::EntryNode::Subfs(_nested_subfs) => {

     

       261
        
                       // Nested subfs - these should be resolved recursively in the main flow

     

       262
        
                       // For now, we skip them (they'll be fetched separately)

     

       263
        
                       eprintln!("  ⚠️  Found nested subfs at {}, skipping (should be fetched separately)", full_path);

     

       264
        
                   }

     

       265
       +
                   wisp_lexicons::place_wisp::subfs::EntryNode::Unknown(_) => {

     

       266
        
                       // Skip unknown nodes

     

       267
        
                   }

     

       268
        
               }

     
···

       352
        
           flat: bool,

     

       353
        
       ) -> miette::Result<FsDirectory<'static>> {

     

       354
        
           use jacquard_common::CowStr;

     

       355
       +
           use wisp_lexicons::place_wisp::fs::{Entry, Subfs};

     

       356
        
       

     

       357
        
           let path_parts: Vec<&str> = target_path.split('/').collect();

     

       358
        
       

     
···

       430
        
       

     

       431
        
           // Construct AT-URI and convert to RecordUri

     

       432
        
           let at_uri = AtUri::new(uri).into_diagnostic()?;

     

       433
       +
           let record_uri: RecordUri<'_, wisp_lexicons::place_wisp::subfs::SubfsRecordRecord> = RecordUri::try_from_uri(at_uri).into_diagnostic()?;

     

       434
        
       

     

       435
        
           let rkey = record_uri.rkey()

     

       436
        
               .ok_or_else(|| miette::miette!("Invalid subfs URI: missing rkey"))?

     
···

       489
        
       }

     

       490
        
       

     

       491
        
       /// Estimate the JSON size of a single entry

     

       492
       +
       fn estimate_entry_size(entry: &wisp_lexicons::place_wisp::fs::Entry) -> usize {

     

       493
        
           match serde_json::to_string(entry) {

     

       494
        
               Ok(json) => json.len(),

     

       495
        
               Err(_) => 500, // Conservative estimate if serialization fails

+3 -1

docs/astro.config.mjs

···

       7
        
       	integrations: [

     

       8
        
       		starlight({

     

       9
        
       			title: 'Wisp.place Docs',

     

       10
       -
       			social: [{ icon: 'github', label: 'GitHub', href: 'https://github.com/tangled-org/wisp.place' }],

     

       0
        
       
     

       0
        
       
     

       11
        
       			sidebar: [

     

       12
        
       				{

     

       13
        
       					label: 'Getting Started',

···

       7
        
       	integrations: [

     

       8
        
       		starlight({

     

       9
        
       			title: 'Wisp.place Docs',

     

       10
       +
       			components: {

     

       11
       +
       				SocialIcons: './src/components/SocialIcons.astro',

     

       12
       +
       			},

     

       13
        
       			sidebar: [

     

       14
        
       				{

     

       15
        
       					label: 'Getting Started',

docs/src/assets/tangled-icon.svg

···

       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
       +
         <defs id="defs1"/>

     

       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
       +
           <inkscape:page x="0" y="0" width="25" height="25" id="page2" margin="0" bleed="0"/>

     

       5
       +
         </sodipodi:namedview>

     

       6
       +
         <g inkscape:groupmode="layer" inkscape:label="Image" id="g1">

     

       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
       +
         </g>

     

       9
       +
       </svg>

+26

docs/src/components/SocialIcons.astro

···

       1
       +
       ---

     

       2
       +
       // Custom social icons component to use the Tangled icon

     

       3
       +
       ---

     

       4
       +
       

     

       5
       +
       <div class="sl-flex">

     

       6
       +
       	<a

     

       7
       +
       		href="https://tangled.org/nekomimi.pet/wisp.place-monorepo"

     

       8
       +
       		rel="me"

     

       9
       +
       		class="sl-flex"

     

       10
       +
       		aria-label="Tangled"

     

       11
       +
       	>

     

       12
       +
       		<svg

     

       13
       +
       			xmlns="http://www.w3.org/2000/svg"

     

       14
       +
       			viewBox="0 0 25 25"

     

       15
       +
       			width="16"

     

       16
       +
       			height="16"

     

       17
       +
       			aria-hidden="true"

     

       18
       +
       			focusable="false"

     

       19
       +
       		>

     

       20
       +
       			<path

     

       21
       +
       				style="fill:currentColor;stroke-width:1.12248"

     

       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
       +
       			></path>

     

       24
       +
       		</svg>

     

       25
       +
       	</a>

     

       26
       +
       </div>

-5

docs/src/content/docs/cli.md

···

       71
        
       

     

       72
        
       engine: 'nixery'

     

       73
        
       

     

       74
       -
       clone:

     

       75
       -
         skip: false

     

       76
       -
         depth: 1

     

       77
       -
         submodules: false

     

       78
       -
       

     

       79
        
       dependencies:

     

       80
        
         nixpkgs:

     

       81
        
           - nodejs

···

       71
        
       

     

       72
        
       engine: 'nixery'

     

       73
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       74
        
       dependencies:

     

       75
        
         nixpkgs:

     

       76
        
           - nodejs

+15 -15

docs/src/styles/custom.css

···

       5
        
       	/* Increase base font size by 10% */

     

       6
        
       	font-size: 110%;

     

       7
        
       

     

       8
       -
       	/* Light theme - Warm beige background from app */

     

       9
       -
       	--sl-color-bg: oklch(0.90 0.012 35);

     

       10
       -
       	--sl-color-bg-sidebar: oklch(0.93 0.01 35);

     

       11
       -
       	--sl-color-bg-nav: oklch(0.93 0.01 35);

     

       12
       -
       	--sl-color-text: oklch(0.18 0.01 30);

     

       13
       -
       	--sl-color-text-accent: oklch(0.78 0.15 345);

     

       14
       -
       	--sl-color-accent: oklch(0.78 0.15 345);

     

       15
       -
       	--sl-color-accent-low: oklch(0.95 0.03 345);

     

       16
       -
       	--sl-color-border: oklch(0.75 0.015 30);

     

       17
       -
       	--sl-color-gray-1: oklch(0.52 0.015 30);

     

       18
       -
       	--sl-color-gray-2: oklch(0.42 0.015 30);

     

       19
       -
       	--sl-color-gray-3: oklch(0.33 0.015 30);

     

       20
       -
       	--sl-color-gray-4: oklch(0.25 0.015 30);

     

       21
       -
       	--sl-color-gray-5: oklch(0.75 0.015 30);

     

       22
        
       	--sl-color-bg-accent: oklch(0.88 0.01 35);

     

       23
        
       }

     

       24
        
       

     
···

       70
        
       /* Sidebar active/hover state text contrast fix */

     

       71
        
       .sidebar a[aria-current="page"],

     

       72
        
       .sidebar a[aria-current="page"] span {

     

       73
       -
       	color: oklch(0.23 0.015 285) !important;

     

       74
        
       }

     

       75
        
       

     

       76
        
       [data-theme="dark"] .sidebar a[aria-current="page"],

···

       5
        
       	/* Increase base font size by 10% */

     

       6
        
       	font-size: 110%;

     

       7
        
       

     

       8
       +
       	/* Light theme - Warm beige with improved contrast */

     

       9
       +
       	--sl-color-bg: oklch(0.92 0.012 35);

     

       10
       +
       	--sl-color-bg-sidebar: oklch(0.95 0.008 35);

     

       11
       +
       	--sl-color-bg-nav: oklch(0.95 0.008 35);

     

       12
       +
       	--sl-color-text: oklch(0.15 0.015 30);

     

       13
       +
       	--sl-color-text-accent: oklch(0.65 0.18 345);

     

       14
       +
       	--sl-color-accent: oklch(0.65 0.18 345);

     

       15
       +
       	--sl-color-accent-low: oklch(0.92 0.05 345);

     

       16
       +
       	--sl-color-border: oklch(0.65 0.02 30);

     

       17
       +
       	--sl-color-gray-1: oklch(0.45 0.02 30);

     

       18
       +
       	--sl-color-gray-2: oklch(0.35 0.02 30);

     

       19
       +
       	--sl-color-gray-3: oklch(0.28 0.02 30);

     

       20
       +
       	--sl-color-gray-4: oklch(0.20 0.015 30);

     

       21
       +
       	--sl-color-gray-5: oklch(0.65 0.02 30);

     

       22
        
       	--sl-color-bg-accent: oklch(0.88 0.01 35);

     

       23
        
       }

     

       24
        
       

     
···

       70
        
       /* Sidebar active/hover state text contrast fix */

     

       71
        
       .sidebar a[aria-current="page"],

     

       72
        
       .sidebar a[aria-current="page"] span {

     

       73
       +
       	color: oklch(0.15 0.015 30) !important;

     

       74
        
       }

     

       75
        
       

     

       76
        
       [data-theme="dark"] .sidebar a[aria-current="page"],

+59

lexicons/fs.json

···

       1
       +
       {

     

       2
       +
         "lexicon": 1,

     

       3
       +
         "id": "place.wisp.fs",

     

       4
       +
         "defs": {

     

       5
       +
           "main": {

     

       6
       +
             "type": "record",

     

       7
       +
             "description": "Virtual filesystem manifest for a Wisp site",

     

       8
       +
             "record": {

     

       9
       +
               "type": "object",

     

       10
       +
               "required": ["site", "root", "createdAt"],

     

       11
       +
               "properties": {

     

       12
       +
                 "site": { "type": "string" },

     

       13
       +
                 "root": { "type": "ref", "ref": "#directory" },

     

       14
       +
                 "fileCount": { "type": "integer", "minimum": 0, "maximum": 1000 },

     

       15
       +
                 "createdAt": { "type": "string", "format": "datetime" }

     

       16
       +
               }

     

       17
       +
             }

     

       18
       +
           },

     

       19
       +
           "file": {

     

       20
       +
             "type": "object",

     

       21
       +
             "required": ["type", "blob"],

     

       22
       +
             "properties": {

     

       23
       +
               "type": { "type": "string", "const": "file" },

     

       24
       +
               "blob": { "type": "blob", "accept": ["*/*"], "maxSize": 1000000000, "description": "Content blob ref" },

     

       25
       +
               "encoding": { "type": "string", "enum": ["gzip"], "description": "Content encoding (e.g., gzip for compressed files)" },

     

       26
       +
               "mimeType": { "type": "string", "description": "Original MIME type before compression" },

     

       27
       +
               "base64": { "type": "boolean", "description": "True if blob content is base64-encoded (used to bypass PDS content sniffing)" }      }

     

       28
       +
           },

     

       29
       +
           "directory": {

     

       30
       +
             "type": "object",

     

       31
       +
             "required": ["type", "entries"],

     

       32
       +
             "properties": {

     

       33
       +
               "type": { "type": "string", "const": "directory" },

     

       34
       +
               "entries": {

     

       35
       +
                 "type": "array",

     

       36
       +
                 "maxLength": 500,

     

       37
       +
                 "items": { "type": "ref", "ref": "#entry" }

     

       38
       +
               }

     

       39
       +
             }

     

       40
       +
           },

     

       41
       +
           "entry": {

     

       42
       +
             "type": "object",

     

       43
       +
             "required": ["name", "node"],

     

       44
       +
             "properties": {

     

       45
       +
               "name": { "type": "string", "maxLength": 255 },

     

       46
       +
               "node": { "type": "union", "refs": ["#file", "#directory", "#subfs"] }

     

       47
       +
             }

     

       48
       +
           },

     

       49
       +
           "subfs": {

     

       50
       +
             "type": "object",

     

       51
       +
             "required": ["type", "subject"],

     

       52
       +
             "properties": {

     

       53
       +
               "type": { "type": "string", "const": "subfs" },

     

       54
       +
               "subject": { "type": "string", "format": "at-uri", "description": "AT-URI pointing to a place.wisp.subfs record containing this subtree." },

     

       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
       +
             }

     

       57
       +
           }

     

       58
       +
         }

     

       59
       +
       }

+76

lexicons/settings.json

···

       1
       +
       {

     

       2
       +
         "lexicon": 1,

     

       3
       +
         "id": "place.wisp.settings",

     

       4
       +
         "defs": {

     

       5
       +
           "main": {

     

       6
       +
             "type": "record",

     

       7
       +
             "description": "Configuration settings for a static site hosted on wisp.place",

     

       8
       +
             "key": "any",

     

       9
       +
             "record": {

     

       10
       +
               "type": "object",

     

       11
       +
               "properties": {

     

       12
       +
                 "directoryListing": {

     

       13
       +
                   "type": "boolean",

     

       14
       +
                   "description": "Enable directory listing mode for paths that resolve to directories without an index file. Incompatible with spaMode.",

     

       15
       +
                   "default": false

     

       16
       +
                 },

     

       17
       +
                 "spaMode": {

     

       18
       +
                   "type": "string",

     

       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
       +
                   "maxLength": 500

     

       21
       +
                 },

     

       22
       +
                 "custom404": {

     

       23
       +
                   "type": "string",

     

       24
       +
                   "description": "Custom 404 error page file path. Incompatible with directoryListing and spaMode.",

     

       25
       +
                   "maxLength": 500

     

       26
       +
                 },

     

       27
       +
                 "indexFiles": {

     

       28
       +
                   "type": "array",

     

       29
       +
                   "description": "Ordered list of files to try when serving a directory. Defaults to ['index.html'] if not specified.",

     

       30
       +
                   "items": {

     

       31
       +
                     "type": "string",

     

       32
       +
                     "maxLength": 255

     

       33
       +
                   },

     

       34
       +
                   "maxLength": 10

     

       35
       +
                 },

     

       36
       +
                 "cleanUrls": {

     

       37
       +
                   "type": "boolean",

     

       38
       +
                   "description": "Enable clean URL routing. When enabled, '/about' will attempt to serve '/about.html' or '/about/index.html' automatically.",

     

       39
       +
                   "default": false

     

       40
       +
                 },

     

       41
       +
                 "headers": {

     

       42
       +
                   "type": "array",

     

       43
       +
                   "description": "Custom HTTP headers to set on responses",

     

       44
       +
                   "items": {

     

       45
       +
                     "type": "ref",

     

       46
       +
                     "ref": "#customHeader"

     

       47
       +
                   },

     

       48
       +
                   "maxLength": 50

     

       49
       +
                 }

     

       50
       +
               }

     

       51
       +
             }

     

       52
       +
           },

     

       53
       +
           "customHeader": {

     

       54
       +
             "type": "object",

     

       55
       +
             "description": "Custom HTTP header configuration",

     

       56
       +
             "required": ["name", "value"],

     

       57
       +
             "properties": {

     

       58
       +
               "name": {

     

       59
       +
                 "type": "string",

     

       60
       +
                 "description": "HTTP header name (e.g., 'Cache-Control', 'X-Frame-Options')",

     

       61
       +
                 "maxLength": 100

     

       62
       +
               },

     

       63
       +
               "value": {

     

       64
       +
                 "type": "string",

     

       65
       +
                 "description": "HTTP header value",

     

       66
       +
                 "maxLength": 1000

     

       67
       +
               },

     

       68
       +
               "path": {

     

       69
       +
                 "type": "string",

     

       70
       +
                 "description": "Optional glob pattern to apply this header to specific paths (e.g., '*.html', '/assets/*'). If not specified, applies to all paths.",

     

       71
       +
                 "maxLength": 500

     

       72
       +
               }

     

       73
       +
             }

     

       74
       +
           }

     

       75
       +
         }

     

       76
       +
       }

+59

lexicons/subfs.json

···

       1
       +
       {

     

       2
       +
           "lexicon": 1,

     

       3
       +
           "id": "place.wisp.subfs",

     

       4
       +
           "defs": {

     

       5
       +
             "main": {

     

       6
       +
               "type": "record",

     

       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
       +
               "record": {

     

       9
       +
                 "type": "object",

     

       10
       +
                 "required": ["root", "createdAt"],

     

       11
       +
                 "properties": {

     

       12
       +
                   "root": { "type": "ref", "ref": "#directory" },

     

       13
       +
                   "fileCount": { "type": "integer", "minimum": 0, "maximum": 1000 },

     

       14
       +
                   "createdAt": { "type": "string", "format": "datetime" }

     

       15
       +
                 }

     

       16
       +
               }

     

       17
       +
             },

     

       18
       +
             "file": {

     

       19
       +
               "type": "object",

     

       20
       +
               "required": ["type", "blob"],

     

       21
       +
               "properties": {

     

       22
       +
                 "type": { "type": "string", "const": "file" },

     

       23
       +
                 "blob": { "type": "blob", "accept": ["*/*"], "maxSize": 1000000000, "description": "Content blob ref" },

     

       24
       +
                 "encoding": { "type": "string", "enum": ["gzip"], "description": "Content encoding (e.g., gzip for compressed files)" },

     

       25
       +
                 "mimeType": { "type": "string", "description": "Original MIME type before compression" },

     

       26
       +
                 "base64": { "type": "boolean", "description": "True if blob content is base64-encoded (used to bypass PDS content sniffing)" }

     

       27
       +
               }

     

       28
       +
             },

     

       29
       +
             "directory": {

     

       30
       +
               "type": "object",

     

       31
       +
               "required": ["type", "entries"],

     

       32
       +
               "properties": {

     

       33
       +
                 "type": { "type": "string", "const": "directory" },

     

       34
       +
                 "entries": {

     

       35
       +
                   "type": "array",

     

       36
       +
                   "maxLength": 500,

     

       37
       +
                   "items": { "type": "ref", "ref": "#entry" }

     

       38
       +
                 }

     

       39
       +
               }

     

       40
       +
             },

     

       41
       +
             "entry": {

     

       42
       +
               "type": "object",

     

       43
       +
               "required": ["name", "node"],

     

       44
       +
               "properties": {

     

       45
       +
                 "name": { "type": "string", "maxLength": 255 },

     

       46
       +
                 "node": { "type": "union", "refs": ["#file", "#directory", "#subfs"] }

     

       47
       +
               }

     

       48
       +
             },

     

       49
       +
             "subfs": {

     

       50
       +
               "type": "object",

     

       51
       +
               "required": ["type", "subject"],

     

       52
       +
               "properties": {

     

       53
       +
                 "type": { "type": "string", "const": "subfs" },

     

       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
       +
               }

     

       56
       +
             }

     

       57
       +
           }

     

       58
       +
         }

     

       59
       +

+7 -2

package.json

···

       11
        
           "@tailwindcss/cli": "^4.1.17",

     

       12
        
           "atproto-ui": "^0.12.0",

     

       13
        
           "bun-plugin-tailwind": "^0.1.2",

     

       0
        
       
     

       14
        
           "tailwindcss": "^4.1.17"

     

       15
        
         },

     

       16
        
         "scripts": {

     
···

       23
        
           "check": "cd apps/main-app && npm run check && cd ../hosting-service && npm run check",

     

       24
        
           "screenshot": "bun run apps/main-app/scripts/screenshot-sites.ts",

     

       25
        
           "hosting:dev": "cd apps/hosting-service && npm run dev",

     

       26
       -
           "hosting:start": "cd apps/hosting-service && npm run start"

     

       0
        
       
     

       27
        
         },

     

       28
        
         "trustedDependencies": [

     

       29
        
           "@parcel/watcher",

     

       30
        
           "bun",

     

       31
        
           "esbuild"

     

       32
       -
         ]

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       33
        
       }

···

       11
        
           "@tailwindcss/cli": "^4.1.17",

     

       12
        
           "atproto-ui": "^0.12.0",

     

       13
        
           "bun-plugin-tailwind": "^0.1.2",

     

       14
       +
           "elysia": "^1.4.18",

     

       15
        
           "tailwindcss": "^4.1.17"

     

       16
        
         },

     

       17
        
         "scripts": {

     
···

       24
        
           "check": "cd apps/main-app && npm run check && cd ../hosting-service && npm run check",

     

       25
        
           "screenshot": "bun run apps/main-app/scripts/screenshot-sites.ts",

     

       26
        
           "hosting:dev": "cd apps/hosting-service && npm run dev",

     

       27
       +
           "hosting:start": "cd apps/hosting-service && npm run start",

     

       28
       +
           "codegen": "./scripts/codegen.sh"

     

       29
        
         },

     

       30
        
         "trustedDependencies": [

     

       31
        
           "@parcel/watcher",

     

       32
        
           "bun",

     

       33
        
           "esbuild"

     

       34
       +
         ],

     

       35
       +
         "devDependencies": {

     

       36
       +
           "@types/bun": "^1.3.5"

     

       37
       +
         }

     

       38
        
       }

+244

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

···

       1
       +
       import { describe, test, expect } from 'bun:test'

     

       2
       +
       import { processUploadedFiles, type UploadedFile } from './tree'

     

       3
       +
       

     

       4
       +
       describe('processUploadedFiles', () => {

     

       5
       +
       	test('should preserve nested directory structure', () => {

     

       6
       +
       		const files: UploadedFile[] = [

     

       7
       +
       			{

     

       8
       +
       				name: 'mysite/index.html',

     

       9
       +
       				content: Buffer.from('<html>'),

     

       10
       +
       				mimeType: 'text/html',

     

       11
       +
       				size: 6

     

       12
       +
       			},

     

       13
       +
       			{

     

       14
       +
       				name: 'mysite/_astro/main.js',

     

       15
       +
       				content: Buffer.from('console.log()'),

     

       16
       +
       				mimeType: 'application/javascript',

     

       17
       +
       				size: 13

     

       18
       +
       			},

     

       19
       +
       			{

     

       20
       +
       				name: 'mysite/_astro/styles.css',

     

       21
       +
       				content: Buffer.from('body {}'),

     

       22
       +
       				mimeType: 'text/css',

     

       23
       +
       				size: 7

     

       24
       +
       			},

     

       25
       +
       			{

     

       26
       +
       				name: 'mysite/images/logo.png',

     

       27
       +
       				content: Buffer.from([0x89, 0x50, 0x4e, 0x47]),

     

       28
       +
       				mimeType: 'image/png',

     

       29
       +
       				size: 4

     

       30
       +
       			}

     

       31
       +
       		]

     

       32
       +
       

     

       33
       +
       		const result = processUploadedFiles(files)

     

       34
       +
       

     

       35
       +
       		expect(result.fileCount).toBe(4)

     

       36
       +
       		expect(result.directory.entries).toHaveLength(3) // index.html, _astro/, images/

     

       37
       +
       

     

       38
       +
       		// Check _astro directory exists

     

       39
       +
       		const astroEntry = result.directory.entries.find(e => e.name === '_astro')

     

       40
       +
       		expect(astroEntry).toBeTruthy()

     

       41
       +
       		expect('type' in astroEntry!.node && astroEntry!.node.type).toBe('directory')

     

       42
       +
       		

     

       43
       +
       		if ('entries' in astroEntry!.node) {

     

       44
       +
       			const astroDir = astroEntry!.node

     

       45
       +
       			expect(astroDir.entries).toHaveLength(2) // main.js, styles.css

     

       46
       +
       			expect(astroDir.entries.find(e => e.name === 'main.js')).toBeTruthy()

     

       47
       +
       			expect(astroDir.entries.find(e => e.name === 'styles.css')).toBeTruthy()

     

       48
       +
       		}

     

       49
       +
       

     

       50
       +
       		// Check images directory exists

     

       51
       +
       		const imagesEntry = result.directory.entries.find(e => e.name === 'images')

     

       52
       +
       		expect(imagesEntry).toBeTruthy()

     

       53
       +
       		expect('type' in imagesEntry!.node && imagesEntry!.node.type).toBe('directory')

     

       54
       +
       		

     

       55
       +
       		if ('entries' in imagesEntry!.node) {

     

       56
       +
       			const imagesDir = imagesEntry!.node

     

       57
       +
       			expect(imagesDir.entries).toHaveLength(1) // logo.png

     

       58
       +
       			expect(imagesDir.entries.find(e => e.name === 'logo.png')).toBeTruthy()

     

       59
       +
       		}

     

       60
       +
       	})

     

       61
       +
       

     

       62
       +
       	test('should handle deeply nested directories', () => {

     

       63
       +
       		const files: UploadedFile[] = [

     

       64
       +
       			{

     

       65
       +
       				name: 'site/a/b/c/d/deep.txt',

     

       66
       +
       				content: Buffer.from('deep'),

     

       67
       +
       				mimeType: 'text/plain',

     

       68
       +
       				size: 4

     

       69
       +
       			}

     

       70
       +
       		]

     

       71
       +
       

     

       72
       +
       		const result = processUploadedFiles(files)

     

       73
       +
       

     

       74
       +
       		expect(result.fileCount).toBe(1)

     

       75
       +
       

     

       76
       +
       		// Navigate through nested structure

     

       77
       +
       		const aEntry = result.directory.entries.find(e => e.name === 'a')

     

       78
       +
       		expect(aEntry).toBeTruthy()

     

       79
       +
       		expect('type' in aEntry!.node && aEntry!.node.type).toBe('directory')

     

       80
       +
       

     

       81
       +
       		if ('entries' in aEntry!.node) {

     

       82
       +
       			const bEntry = aEntry!.node.entries.find(e => e.name === 'b')

     

       83
       +
       			expect(bEntry).toBeTruthy()

     

       84
       +
       			expect('type' in bEntry!.node && bEntry!.node.type).toBe('directory')

     

       85
       +
       

     

       86
       +
       			if ('entries' in bEntry!.node) {

     

       87
       +
       				const cEntry = bEntry!.node.entries.find(e => e.name === 'c')

     

       88
       +
       				expect(cEntry).toBeTruthy()

     

       89
       +
       				expect('type' in cEntry!.node && cEntry!.node.type).toBe('directory')

     

       90
       +
       

     

       91
       +
       				if ('entries' in cEntry!.node) {

     

       92
       +
       					const dEntry = cEntry!.node.entries.find(e => e.name === 'd')

     

       93
       +
       					expect(dEntry).toBeTruthy()

     

       94
       +
       					expect('type' in dEntry!.node && dEntry!.node.type).toBe('directory')

     

       95
       +
       

     

       96
       +
       					if ('entries' in dEntry!.node) {

     

       97
       +
       						const fileEntry = dEntry!.node.entries.find(e => e.name === 'deep.txt')

     

       98
       +
       						expect(fileEntry).toBeTruthy()

     

       99
       +
       						expect('type' in fileEntry!.node && fileEntry!.node.type).toBe('file')

     

       100
       +
       					}

     

       101
       +
       				}

     

       102
       +
       			}

     

       103
       +
       		}

     

       104
       +
       	})

     

       105
       +
       

     

       106
       +
       	test('should handle files at root level', () => {

     

       107
       +
       		const files: UploadedFile[] = [

     

       108
       +
       			{

     

       109
       +
       				name: 'mysite/index.html',

     

       110
       +
       				content: Buffer.from('<html>'),

     

       111
       +
       				mimeType: 'text/html',

     

       112
       +
       				size: 6

     

       113
       +
       			},

     

       114
       +
       			{

     

       115
       +
       				name: 'mysite/robots.txt',

     

       116
       +
       				content: Buffer.from('User-agent: *'),

     

       117
       +
       				mimeType: 'text/plain',

     

       118
       +
       				size: 13

     

       119
       +
       			}

     

       120
       +
       		]

     

       121
       +
       

     

       122
       +
       		const result = processUploadedFiles(files)

     

       123
       +
       

     

       124
       +
       		expect(result.fileCount).toBe(2)

     

       125
       +
       		expect(result.directory.entries).toHaveLength(2)

     

       126
       +
       		expect(result.directory.entries.find(e => e.name === 'index.html')).toBeTruthy()

     

       127
       +
       		expect(result.directory.entries.find(e => e.name === 'robots.txt')).toBeTruthy()

     

       128
       +
       	})

     

       129
       +
       

     

       130
       +
       	test('should skip .git directories', () => {

     

       131
       +
       		const files: UploadedFile[] = [

     

       132
       +
       			{

     

       133
       +
       				name: 'mysite/index.html',

     

       134
       +
       				content: Buffer.from('<html>'),

     

       135
       +
       				mimeType: 'text/html',

     

       136
       +
       				size: 6

     

       137
       +
       			},

     

       138
       +
       			{

     

       139
       +
       				name: 'mysite/.git/config',

     

       140
       +
       				content: Buffer.from('[core]'),

     

       141
       +
       				mimeType: 'text/plain',

     

       142
       +
       				size: 6

     

       143
       +
       			},

     

       144
       +
       			{

     

       145
       +
       				name: 'mysite/.gitignore',

     

       146
       +
       				content: Buffer.from('node_modules'),

     

       147
       +
       				mimeType: 'text/plain',

     

       148
       +
       				size: 12

     

       149
       +
       			}

     

       150
       +
       		]

     

       151
       +
       

     

       152
       +
       		const result = processUploadedFiles(files)

     

       153
       +
       

     

       154
       +
       		expect(result.fileCount).toBe(2) // Only index.html and .gitignore

     

       155
       +
       		expect(result.directory.entries).toHaveLength(2)

     

       156
       +
       		expect(result.directory.entries.find(e => e.name === 'index.html')).toBeTruthy()

     

       157
       +
       		expect(result.directory.entries.find(e => e.name === '.gitignore')).toBeTruthy()

     

       158
       +
       		expect(result.directory.entries.find(e => e.name === '.git')).toBeFalsy()

     

       159
       +
       	})

     

       160
       +
       

     

       161
       +
       	test('should handle mixed root and nested files', () => {

     

       162
       +
       		const files: UploadedFile[] = [

     

       163
       +
       			{

     

       164
       +
       				name: 'mysite/index.html',

     

       165
       +
       				content: Buffer.from('<html>'),

     

       166
       +
       				mimeType: 'text/html',

     

       167
       +
       				size: 6

     

       168
       +
       			},

     

       169
       +
       			{

     

       170
       +
       				name: 'mysite/about/index.html',

     

       171
       +
       				content: Buffer.from('<html>'),

     

       172
       +
       				mimeType: 'text/html',

     

       173
       +
       				size: 6

     

       174
       +
       			},

     

       175
       +
       			{

     

       176
       +
       				name: 'mysite/about/team.html',

     

       177
       +
       				content: Buffer.from('<html>'),

     

       178
       +
       				mimeType: 'text/html',

     

       179
       +
       				size: 6

     

       180
       +
       			},

     

       181
       +
       			{

     

       182
       +
       				name: 'mysite/robots.txt',

     

       183
       +
       				content: Buffer.from('User-agent: *'),

     

       184
       +
       				mimeType: 'text/plain',

     

       185
       +
       				size: 13

     

       186
       +
       			}

     

       187
       +
       		]

     

       188
       +
       

     

       189
       +
       		const result = processUploadedFiles(files)

     

       190
       +
       

     

       191
       +
       		expect(result.fileCount).toBe(4)

     

       192
       +
       		expect(result.directory.entries).toHaveLength(3) // index.html, about/, robots.txt

     

       193
       +
       

     

       194
       +
       		const aboutEntry = result.directory.entries.find(e => e.name === 'about')

     

       195
       +
       		expect(aboutEntry).toBeTruthy()

     

       196
       +
       		expect('type' in aboutEntry!.node && aboutEntry!.node.type).toBe('directory')

     

       197
       +
       		

     

       198
       +
       		if ('entries' in aboutEntry!.node) {

     

       199
       +
       			const aboutDir = aboutEntry!.node

     

       200
       +
       			expect(aboutDir.entries).toHaveLength(2) // index.html, team.html

     

       201
       +
       			expect(aboutDir.entries.find(e => e.name === 'index.html')).toBeTruthy()

     

       202
       +
       			expect(aboutDir.entries.find(e => e.name === 'team.html')).toBeTruthy()

     

       203
       +
       		}

     

       204
       +
       	})

     

       205
       +
       

     

       206
       +
       	test('should handle empty file array', () => {

     

       207
       +
       		const files: UploadedFile[] = []

     

       208
       +
       

     

       209
       +
       		const result = processUploadedFiles(files)

     

       210
       +
       

     

       211
       +
       		expect(result.fileCount).toBe(0)

     

       212
       +
       		expect(result.directory.entries).toHaveLength(0)

     

       213
       +
       	})

     

       214
       +
       

     

       215
       +
       	test('should strip base folder name from paths', () => {

     

       216
       +
       		// This tests the behavior where file.name includes the base folder

     

       217
       +
       		// e.g., "mysite/index.html" should become "index.html" at root

     

       218
       +
       		const files: UploadedFile[] = [

     

       219
       +
       			{

     

       220
       +
       				name: 'build-output/index.html',

     

       221
       +
       				content: Buffer.from('<html>'),

     

       222
       +
       				mimeType: 'text/html',

     

       223
       +
       				size: 6

     

       224
       +
       			},

     

       225
       +
       			{

     

       226
       +
       				name: 'build-output/assets/main.js',

     

       227
       +
       				content: Buffer.from('console.log()'),

     

       228
       +
       				mimeType: 'application/javascript',

     

       229
       +
       				size: 13

     

       230
       +
       			}

     

       231
       +
       		]

     

       232
       +
       

     

       233
       +
       		const result = processUploadedFiles(files)

     

       234
       +
       

     

       235
       +
       		expect(result.fileCount).toBe(2)

     

       236
       +
       		

     

       237
       +
       		// Should have index.html at root and assets/ directory

     

       238
       +
       		expect(result.directory.entries.find(e => e.name === 'index.html')).toBeTruthy()

     

       239
       +
       		expect(result.directory.entries.find(e => e.name === 'assets')).toBeTruthy()

     

       240
       +
       		

     

       241
       +
       		// Should NOT have 'build-output' directory

     

       242
       +
       		expect(result.directory.entries.find(e => e.name === 'build-output')).toBeFalsy()

     

       243
       +
       	})

     

       244
       +
       })

-59

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

···

       1
       -
       {

     

       2
       -
         "lexicon": 1,

     

       3
       -
         "id": "place.wisp.fs",

     

       4
       -
         "defs": {

     

       5
       -
           "main": {

     

       6
       -
             "type": "record",

     

       7
       -
             "description": "Virtual filesystem manifest for a Wisp site",

     

       8
       -
             "record": {

     

       9
       -
               "type": "object",

     

       10
       -
               "required": ["site", "root", "createdAt"],

     

       11
       -
               "properties": {

     

       12
       -
                 "site": { "type": "string" },

     

       13
       -
                 "root": { "type": "ref", "ref": "#directory" },

     

       14
       -
                 "fileCount": { "type": "integer", "minimum": 0, "maximum": 1000 },

     

       15
       -
                 "createdAt": { "type": "string", "format": "datetime" }

     

       16
       -
               }

     

       17
       -
             }

     

       18
       -
           },

     

       19
       -
           "file": {

     

       20
       -
             "type": "object",

     

       21
       -
             "required": ["type", "blob"],

     

       22
       -
             "properties": {

     

       23
       -
               "type": { "type": "string", "const": "file" },

     

       24
       -
               "blob": { "type": "blob", "accept": ["*/*"], "maxSize": 1000000000, "description": "Content blob ref" },

     

       25
       -
               "encoding": { "type": "string", "enum": ["gzip"], "description": "Content encoding (e.g., gzip for compressed files)" },

     

       26
       -
               "mimeType": { "type": "string", "description": "Original MIME type before compression" },

     

       27
       -
               "base64": { "type": "boolean", "description": "True if blob content is base64-encoded (used to bypass PDS content sniffing)" }      }

     

       28
       -
           },

     

       29
       -
           "directory": {

     

       30
       -
             "type": "object",

     

       31
       -
             "required": ["type", "entries"],

     

       32
       -
             "properties": {

     

       33
       -
               "type": { "type": "string", "const": "directory" },

     

       34
       -
               "entries": {

     

       35
       -
                 "type": "array",

     

       36
       -
                 "maxLength": 500,

     

       37
       -
                 "items": { "type": "ref", "ref": "#entry" }

     

       38
       -
               }

     

       39
       -
             }

     

       40
       -
           },

     

       41
       -
           "entry": {

     

       42
       -
             "type": "object",

     

       43
       -
             "required": ["name", "node"],

     

       44
       -
             "properties": {

     

       45
       -
               "name": { "type": "string", "maxLength": 255 },

     

       46
       -
               "node": { "type": "union", "refs": ["#file", "#directory", "#subfs"] }

     

       47
       -
             }

     

       48
       -
           },

     

       49
       -
           "subfs": {

     

       50
       -
             "type": "object",

     

       51
       -
             "required": ["type", "subject"],

     

       52
       -
             "properties": {

     

       53
       -
               "type": { "type": "string", "const": "subfs" },

     

       54
       -
               "subject": { "type": "string", "format": "at-uri", "description": "AT-URI pointing to a place.wisp.subfs record containing this subtree." },

     

       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
       -
             }

     

       57
       -
           }

     

       58
       -
         }

     

       59
       -
       }

-76

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

···

       1
       -
       {

     

       2
       -
         "lexicon": 1,

     

       3
       -
         "id": "place.wisp.settings",

     

       4
       -
         "defs": {

     

       5
       -
           "main": {

     

       6
       -
             "type": "record",

     

       7
       -
             "description": "Configuration settings for a static site hosted on wisp.place",

     

       8
       -
             "key": "any",

     

       9
       -
             "record": {

     

       10
       -
               "type": "object",

     

       11
       -
               "properties": {

     

       12
       -
                 "directoryListing": {

     

       13
       -
                   "type": "boolean",

     

       14
       -
                   "description": "Enable directory listing mode for paths that resolve to directories without an index file. Incompatible with spaMode.",

     

       15
       -
                   "default": false

     

       16
       -
                 },

     

       17
       -
                 "spaMode": {

     

       18
       -
                   "type": "string",

     

       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
       -
                   "maxLength": 500

     

       21
       -
                 },

     

       22
       -
                 "custom404": {

     

       23
       -
                   "type": "string",

     

       24
       -
                   "description": "Custom 404 error page file path. Incompatible with directoryListing and spaMode.",

     

       25
       -
                   "maxLength": 500

     

       26
       -
                 },

     

       27
       -
                 "indexFiles": {

     

       28
       -
                   "type": "array",

     

       29
       -
                   "description": "Ordered list of files to try when serving a directory. Defaults to ['index.html'] if not specified.",

     

       30
       -
                   "items": {

     

       31
       -
                     "type": "string",

     

       32
       -
                     "maxLength": 255

     

       33
       -
                   },

     

       34
       -
                   "maxLength": 10

     

       35
       -
                 },

     

       36
       -
                 "cleanUrls": {

     

       37
       -
                   "type": "boolean",

     

       38
       -
                   "description": "Enable clean URL routing. When enabled, '/about' will attempt to serve '/about.html' or '/about/index.html' automatically.",

     

       39
       -
                   "default": false

     

       40
       -
                 },

     

       41
       -
                 "headers": {

     

       42
       -
                   "type": "array",

     

       43
       -
                   "description": "Custom HTTP headers to set on responses",

     

       44
       -
                   "items": {

     

       45
       -
                     "type": "ref",

     

       46
       -
                     "ref": "#customHeader"

     

       47
       -
                   },

     

       48
       -
                   "maxLength": 50

     

       49
       -
                 }

     

       50
       -
               }

     

       51
       -
             }

     

       52
       -
           },

     

       53
       -
           "customHeader": {

     

       54
       -
             "type": "object",

     

       55
       -
             "description": "Custom HTTP header configuration",

     

       56
       -
             "required": ["name", "value"],

     

       57
       -
             "properties": {

     

       58
       -
               "name": {

     

       59
       -
                 "type": "string",

     

       60
       -
                 "description": "HTTP header name (e.g., 'Cache-Control', 'X-Frame-Options')",

     

       61
       -
                 "maxLength": 100

     

       62
       -
               },

     

       63
       -
               "value": {

     

       64
       -
                 "type": "string",

     

       65
       -
                 "description": "HTTP header value",

     

       66
       -
                 "maxLength": 1000

     

       67
       -
               },

     

       68
       -
               "path": {

     

       69
       -
                 "type": "string",

     

       70
       -
                 "description": "Optional glob pattern to apply this header to specific paths (e.g., '*.html', '/assets/*'). If not specified, applies to all paths.",

     

       71
       -
                 "maxLength": 500

     

       72
       -
               }

     

       73
       -
             }

     

       74
       -
           }

     

       75
       -
         }

     

       76
       -
       }

-59

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

···

       1
       -
       {

     

       2
       -
           "lexicon": 1,

     

       3
       -
           "id": "place.wisp.subfs",

     

       4
       -
           "defs": {

     

       5
       -
             "main": {

     

       6
       -
               "type": "record",

     

       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
       -
               "record": {

     

       9
       -
                 "type": "object",

     

       10
       -
                 "required": ["root", "createdAt"],

     

       11
       -
                 "properties": {

     

       12
       -
                   "root": { "type": "ref", "ref": "#directory" },

     

       13
       -
                   "fileCount": { "type": "integer", "minimum": 0, "maximum": 1000 },

     

       14
       -
                   "createdAt": { "type": "string", "format": "datetime" }

     

       15
       -
                 }

     

       16
       -
               }

     

       17
       -
             },

     

       18
       -
             "file": {

     

       19
       -
               "type": "object",

     

       20
       -
               "required": ["type", "blob"],

     

       21
       -
               "properties": {

     

       22
       -
                 "type": { "type": "string", "const": "file" },

     

       23
       -
                 "blob": { "type": "blob", "accept": ["*/*"], "maxSize": 1000000000, "description": "Content blob ref" },

     

       24
       -
                 "encoding": { "type": "string", "enum": ["gzip"], "description": "Content encoding (e.g., gzip for compressed files)" },

     

       25
       -
                 "mimeType": { "type": "string", "description": "Original MIME type before compression" },

     

       26
       -
                 "base64": { "type": "boolean", "description": "True if blob content is base64-encoded (used to bypass PDS content sniffing)" }

     

       27
       -
               }

     

       28
       -
             },

     

       29
       -
             "directory": {

     

       30
       -
               "type": "object",

     

       31
       -
               "required": ["type", "entries"],

     

       32
       -
               "properties": {

     

       33
       -
                 "type": { "type": "string", "const": "directory" },

     

       34
       -
                 "entries": {

     

       35
       -
                   "type": "array",

     

       36
       -
                   "maxLength": 500,

     

       37
       -
                   "items": { "type": "ref", "ref": "#entry" }

     

       38
       -
                 }

     

       39
       -
               }

     

       40
       -
             },

     

       41
       -
             "entry": {

     

       42
       -
               "type": "object",

     

       43
       -
               "required": ["name", "node"],

     

       44
       -
               "properties": {

     

       45
       -
                 "name": { "type": "string", "maxLength": 255 },

     

       46
       -
                 "node": { "type": "union", "refs": ["#file", "#directory", "#subfs"] }

     

       47
       -
               }

     

       48
       -
             },

     

       49
       -
             "subfs": {

     

       50
       -
               "type": "object",

     

       51
       -
               "required": ["type", "subject"],

     

       52
       -
               "properties": {

     

       53
       -
                 "type": { "type": "string", "const": "subfs" },

     

       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
       -
               }

     

       56
       -
             }

     

       57
       -
           }

     

       58
       -
         }

     

       59
       -

+1 -1

packages/@wisp/lexicons/package.json

···

       32
        
           }

     

       33
        
         },

     

       34
        
         "scripts": {

     

       35
       -
           "codegen": "lex gen-server ./src ./lexicons"

     

       36
        
         },

     

       37
        
         "dependencies": {

     

       38
        
           "@atproto/lexicon": "^0.5.1",

···

       32
        
           }

     

       33
        
         },

     

       34
        
         "scripts": {

     

       35
       +
           "codegen": "lex gen-server ./src ../../../lexicons/*.json"

     

       36
        
         },

     

       37
        
         "dependencies": {

     

       38
        
           "@atproto/lexicon": "^0.5.1",

+1 -1

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

···

       9
        
         type MethodConfigOrHandler,

     

       10
        
         createServer as createXrpcServer,

     

       11
        
       } from '@atproto/xrpc-server'

     

       12
       -
       import { schemas } from './lexicons'

     

       13
        
       

     

       14
        
       export function createServer(options?: XrpcOptions): Server {

     

       15
        
         return new Server(options)

···

       9
        
         type MethodConfigOrHandler,

     

       10
        
         createServer as createXrpcServer,

     

       11
        
       } from '@atproto/xrpc-server'

     

       12
       +
       import { schemas } from './lexicons.js'

     

       13
        
       

     

       14
        
       export function createServer(options?: XrpcOptions): Server {

     

       15
        
         return new Server(options)

+1 -1

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

···

       7
        
         ValidationError,

     

       8
        
         type ValidationResult,

     

       9
        
       } from '@atproto/lexicon'

     

       10
       -
       import { type $Typed, is$typed, maybe$typed } from './util'

     

       11
        
       

     

       12
        
       export const schemaDict = {

     

       13
        
         PlaceWispFs: {

···

       7
        
         ValidationError,

     

       8
        
         type ValidationResult,

     

       9
        
       } from '@atproto/lexicon'

     

       10
       +
       import { type $Typed, is$typed, maybe$typed } from './util.js'

     

       11
        
       

     

       12
        
       export const schemaDict = {

     

       13
        
         PlaceWispFs: {

+1 -1

packages/@wisp/observability/README.md

+1 -2

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

···

       168
        
       	},

     

       169
        
       

     

       170
        
       	debug(message: string, service: string, context?: Record<string, any>, traceId?: string) {

     

       171
       -
       		const env = typeof Bun !== 'undefined' ? Bun.env.NODE_ENV : process.env.NODE_ENV;

     

       172
       -
       		if (env !== 'production') {

     

       173
        
       			this.log('debug', message, service, context, traceId)

     

       174
        
       		}

     

       175
        
       	},

···

       168
        
       	},

     

       169
        
       

     

       170
        
       	debug(message: string, service: string, context?: Record<string, any>, traceId?: string) {

     

       171
       +
       		if (process.env.NODE_ENV !== 'production') {

     

       0
        
       
     

       172
        
       			this.log('debug', message, service, context, traceId)

     

       173
        
       		}

     

       174
        
       	},

+9 -9

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

···

       61
        
       

     

       62
        
       		// Load from environment variables if not provided

     

       63
        
       		if (!this.config.lokiUrl) {

     

       64
       -
       			this.config.lokiUrl = process.env.GRAFANA_LOKI_URL || Bun?.env?.GRAFANA_LOKI_URL

     

       65
        
       		}

     

       66
        
       

     

       67
        
       		if (!this.config.prometheusUrl) {

     

       68
       -
       			this.config.prometheusUrl = process.env.GRAFANA_PROMETHEUS_URL || Bun?.env?.GRAFANA_PROMETHEUS_URL

     

       69
        
       		}

     

       70
        
       

     

       71
        
       		// Load Loki authentication from environment

     

       72
        
       		if (!this.config.lokiAuth?.bearerToken && !this.config.lokiAuth?.username) {

     

       73
       -
       			const token = process.env.GRAFANA_LOKI_TOKEN || Bun?.env?.GRAFANA_LOKI_TOKEN

     

       74
       -
       			const username = process.env.GRAFANA_LOKI_USERNAME || Bun?.env?.GRAFANA_LOKI_USERNAME

     

       75
       -
       			const password = process.env.GRAFANA_LOKI_PASSWORD || Bun?.env?.GRAFANA_LOKI_PASSWORD

     

       76
        
       

     

       77
        
       			if (token) {

     

       78
        
       				this.config.lokiAuth = { ...this.config.lokiAuth, bearerToken: token }

     
···

       83
        
       

     

       84
        
       		// Load Prometheus authentication from environment

     

       85
        
       		if (!this.config.prometheusAuth?.bearerToken && !this.config.prometheusAuth?.username) {

     

       86
       -
       			const token = process.env.GRAFANA_PROMETHEUS_TOKEN || Bun?.env?.GRAFANA_PROMETHEUS_TOKEN

     

       87
       -
       			const username = process.env.GRAFANA_PROMETHEUS_USERNAME || Bun?.env?.GRAFANA_PROMETHEUS_USERNAME

     

       88
       -
       			const password = process.env.GRAFANA_PROMETHEUS_PASSWORD || Bun?.env?.GRAFANA_PROMETHEUS_PASSWORD

     

       89
        
       

     

       90
        
       			if (token) {

     

       91
        
       				this.config.prometheusAuth = { ...this.config.prometheusAuth, bearerToken: token }

     
···

       120
        
       class LokiExporter {

     

       121
        
       	private buffer: LogEntry[] = []

     

       122
        
       	private errorBuffer: ErrorEntry[] = []

     

       123
       -
       	private flushTimer?: Timer | NodeJS.Timer

     

       124
        
       	private config: GrafanaConfig = {}

     

       125
        
       

     

       126
        
       	initialize(config: GrafanaConfig) {

···

       61
        
       

     

       62
        
       		// Load from environment variables if not provided

     

       63
        
       		if (!this.config.lokiUrl) {

     

       64
       +
       			this.config.lokiUrl = process.env.GRAFANA_LOKI_URL

     

       65
        
       		}

     

       66
        
       

     

       67
        
       		if (!this.config.prometheusUrl) {

     

       68
       +
       			this.config.prometheusUrl = process.env.GRAFANA_PROMETHEUS_URL

     

       69
        
       		}

     

       70
        
       

     

       71
        
       		// Load Loki authentication from environment

     

       72
        
       		if (!this.config.lokiAuth?.bearerToken && !this.config.lokiAuth?.username) {

     

       73
       +
       			const token = process.env.GRAFANA_LOKI_TOKEN

     

       74
       +
       			const username = process.env.GRAFANA_LOKI_USERNAME

     

       75
       +
       			const password = process.env.GRAFANA_LOKI_PASSWORD

     

       76
        
       

     

       77
        
       			if (token) {

     

       78
        
       				this.config.lokiAuth = { ...this.config.lokiAuth, bearerToken: token }

     
···

       83
        
       

     

       84
        
       		// Load Prometheus authentication from environment

     

       85
        
       		if (!this.config.prometheusAuth?.bearerToken && !this.config.prometheusAuth?.username) {

     

       86
       +
       			const token = process.env.GRAFANA_PROMETHEUS_TOKEN

     

       87
       +
       			const username = process.env.GRAFANA_PROMETHEUS_USERNAME

     

       88
       +
       			const password = process.env.GRAFANA_PROMETHEUS_PASSWORD

     

       89
        
       

     

       90
        
       			if (token) {

     

       91
        
       				this.config.prometheusAuth = { ...this.config.prometheusAuth, bearerToken: token }

     
···

       120
        
       class LokiExporter {

     

       121
        
       	private buffer: LogEntry[] = []

     

       122
        
       	private errorBuffer: ErrorEntry[] = []

     

       123
       +
       	private flushTimer?: NodeJS.Timeout

     

       124
        
       	private config: GrafanaConfig = {}

     

       125
        
       

     

       126
        
       	initialize(config: GrafanaConfig) {

+128 -27

packages/@wisp/safe-fetch/src/index.ts

···

       28
        
       const MAX_BLOB_SIZE = 500 * 1024 * 1024; // 500MB

     

       29
        
       const MAX_REDIRECTS = 10;

     

       30
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       31
        
       function isBlockedHost(hostname: string): boolean {

     

       32
        
       	const lowerHost = hostname.toLowerCase();

     

       33
        
       

     
···

       44
        
       	return false;

     

       45
        
       }

     

       46
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       47
        
       export async function safeFetch(

     

       48
        
       	url: string,

     

       49
       -
       	options?: RequestInit & { maxSize?: number; timeout?: number }

     

       50
        
       ): Promise<Response> {

     

       0
        
       
     

       51
        
       	const timeoutMs = options?.timeout ?? FETCH_TIMEOUT;

     

       52
        
       	const maxSize = options?.maxSize ?? MAX_RESPONSE_SIZE;

     

       53
        
       

     

       54
       -
       	// Parse and validate URL

     

       55
        
       	let parsedUrl: URL;

     

       56
        
       	try {

     

       57
        
       		parsedUrl = new URL(url);

     
···

       68
        
       		throw new Error(`Blocked host: ${hostname}`);

     

       69
        
       	}

     

       70
        
       

     

       71
       -
       	const controller = new AbortController();

     

       72
       -
       	const timeoutId = setTimeout(() => controller.abort(), timeoutMs);

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       73
        
       

     

       74
       -
       	try {

     

       75
       -
       		const response = await fetch(url, {

     

       76
       -
       			...options,

     

       77
       -
       			signal: controller.signal,

     

       78
       -
       			redirect: 'follow',

     

       79
       -
       			headers: {

     

       80
       -
       				'User-Agent': 'wisp-place hosting-service',

     

       81
       -
       				...(options?.headers || {}),

     

       82
       -
       			},

     

       83
       -
       		});

     

       84
        
       

     

       85
       -
       		const contentLength = response.headers.get('content-length');

     

       86
       -
       		if (contentLength && parseInt(contentLength, 10) > maxSize) {

     

       87
       -
       			throw new Error(`Response too large: ${contentLength} bytes`);

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       88
        
       		}

     

       0
        
       
     

       89
        
       

     

       90
       -
       		return response;

     

       91
       -
       	} catch (err) {

     

       92
       -
       		if (err instanceof Error && err.name === 'AbortError') {

     

       93
       -
       			throw new Error(`Request timeout after ${timeoutMs}ms`);

     

       94
       -
       		}

     

       95
       -
       		throw err;

     

       96
       -
       	} finally {

     

       97
       -
       		clearTimeout(timeoutId);

     

       98
        
       	}

     

       99
        
       }

     

       100
        
       

     

       101
        
       export async function safeFetchJson<T = any>(

     

       102
        
       	url: string,

     

       103
       -
       	options?: RequestInit & { maxSize?: number; timeout?: number }

     

       104
        
       ): Promise<T> {

     

       105
        
       	const maxJsonSize = options?.maxSize ?? MAX_JSON_SIZE;

     

       106
        
       	const response = await safeFetch(url, { ...options, maxSize: maxJsonSize });

     
···

       146
        
       

     

       147
        
       export async function safeFetchBlob(

     

       148
        
       	url: string,

     

       149
       -
       	options?: RequestInit & { maxSize?: number; timeout?: number }

     

       150
        
       ): Promise<Uint8Array> {

     

       151
        
       	const maxBlobSize = options?.maxSize ?? MAX_BLOB_SIZE;

     

       152
        
       	const timeoutMs = options?.timeout ?? FETCH_TIMEOUT_BLOB;

···

       28
        
       const MAX_BLOB_SIZE = 500 * 1024 * 1024; // 500MB

     

       29
        
       const MAX_REDIRECTS = 10;

     

       30
        
       

     

       31
       +
       // Retry configuration

     

       32
       +
       const MAX_RETRIES = 3;

     

       33
       +
       const INITIAL_RETRY_DELAY = 1000; // 1 second

     

       34
       +
       const MAX_RETRY_DELAY = 10000; // 10 seconds

     

       35
       +
       

     

       36
        
       function isBlockedHost(hostname: string): boolean {

     

       37
        
       	const lowerHost = hostname.toLowerCase();

     

       38
        
       

     
···

       49
        
       	return false;

     

       50
        
       }

     

       51
        
       

     

       52
       +
       /**

     

       53
       +
        * Check if an error is retryable (network/SSL errors, not HTTP errors)

     

       54
       +
        */

     

       55
       +
       function isRetryableError(err: unknown): boolean {

     

       56
       +
       	if (!(err instanceof Error)) return false;

     

       57
       +
       

     

       58
       +
       	// Network errors (ECONNRESET, ENOTFOUND, etc.)

     

       59
       +
       	const errorCode = (err as any).code;

     

       60
       +
       	if (errorCode) {

     

       61
       +
       		const retryableCodes = [

     

       62
       +
       			'ECONNRESET',

     

       63
       +
       			'ECONNREFUSED',

     

       64
       +
       			'ETIMEDOUT',

     

       65
       +
       			'ENOTFOUND',

     

       66
       +
       			'ENETUNREACH',

     

       67
       +
       			'EAI_AGAIN',

     

       68
       +
       			'EPIPE',

     

       69
       +
       			'ERR_SSL_TLSV1_ALERT_INTERNAL_ERROR', // SSL/TLS handshake failures

     

       70
       +
       			'ERR_SSL_WRONG_VERSION_NUMBER',

     

       71
       +
       			'UNABLE_TO_VERIFY_LEAF_SIGNATURE',

     

       72
       +
       		];

     

       73
       +
       		if (retryableCodes.includes(errorCode)) {

     

       74
       +
       			return true;

     

       75
       +
       		}

     

       76
       +
       	}

     

       77
       +
       

     

       78
       +
       	// Timeout errors

     

       79
       +
       	if (err.name === 'AbortError' || err.message.includes('timeout')) {

     

       80
       +
       		return true;

     

       81
       +
       	}

     

       82
       +
       

     

       83
       +
       	// Fetch failures (generic network errors)

     

       84
       +
       	if (err.message.includes('fetch failed')) {

     

       85
       +
       		return true;

     

       86
       +
       	}

     

       87
       +
       

     

       88
       +
       	return false;

     

       89
       +
       }

     

       90
       +
       

     

       91
       +
       /**

     

       92
       +
        * Sleep for a given number of milliseconds

     

       93
       +
        */

     

       94
       +
       function sleep(ms: number): Promise<void> {

     

       95
       +
       	return new Promise(resolve => setTimeout(resolve, ms));

     

       96
       +
       }

     

       97
       +
       

     

       98
       +
       /**

     

       99
       +
        * Retry a function with exponential backoff

     

       100
       +
        */

     

       101
       +
       async function withRetry<T>(

     

       102
       +
       	fn: () => Promise<T>,

     

       103
       +
       	options: { maxRetries?: number; initialDelay?: number; maxDelay?: number; context?: string } = {}

     

       104
       +
       ): Promise<T> {

     

       105
       +
       	const maxRetries = options.maxRetries ?? MAX_RETRIES;

     

       106
       +
       	const initialDelay = options.initialDelay ?? INITIAL_RETRY_DELAY;

     

       107
       +
       	const maxDelay = options.maxDelay ?? MAX_RETRY_DELAY;

     

       108
       +
       	const context = options.context ?? 'Request';

     

       109
       +
       

     

       110
       +
       	let lastError: unknown;

     

       111
       +
       

     

       112
       +
       	for (let attempt = 0; attempt <= maxRetries; attempt++) {

     

       113
       +
       		try {

     

       114
       +
       			return await fn();

     

       115
       +
       		} catch (err) {

     

       116
       +
       			lastError = err;

     

       117
       +
       

     

       118
       +
       			// Don't retry if this is the last attempt or error is not retryable

     

       119
       +
       			if (attempt === maxRetries || !isRetryableError(err)) {

     

       120
       +
       				throw err;

     

       121
       +
       			}

     

       122
       +
       

     

       123
       +
       			// Calculate delay with exponential backoff

     

       124
       +
       			const delay = Math.min(initialDelay * Math.pow(2, attempt), maxDelay);

     

       125
       +
       

     

       126
       +
       			const errorCode = (err as any)?.code;

     

       127
       +
       			const errorMsg = err instanceof Error ? err.message : String(err);

     

       128
       +
       			console.warn(

     

       129
       +
       				`${context} failed (attempt ${attempt + 1}/${maxRetries + 1}): ${errorMsg}${errorCode ? ` [${errorCode}]` : ''} - retrying in ${delay}ms`

     

       130
       +
       			);

     

       131
       +
       

     

       132
       +
       			await sleep(delay);

     

       133
       +
       		}

     

       134
       +
       	}

     

       135
       +
       

     

       136
       +
       	throw lastError;

     

       137
       +
       }

     

       138
       +
       

     

       139
        
       export async function safeFetch(

     

       140
        
       	url: string,

     

       141
       +
       	options?: RequestInit & { maxSize?: number; timeout?: number; retry?: boolean }

     

       142
        
       ): Promise<Response> {

     

       143
       +
       	const shouldRetry = options?.retry !== false; // Default to true

     

       144
        
       	const timeoutMs = options?.timeout ?? FETCH_TIMEOUT;

     

       145
        
       	const maxSize = options?.maxSize ?? MAX_RESPONSE_SIZE;

     

       146
        
       

     

       147
       +
       	// Parse and validate URL (done once, outside retry loop)

     

       148
        
       	let parsedUrl: URL;

     

       149
        
       	try {

     

       150
        
       		parsedUrl = new URL(url);

     
···

       161
        
       		throw new Error(`Blocked host: ${hostname}`);

     

       162
        
       	}

     

       163
        
       

     

       164
       +
       	const fetchFn = async () => {

     

       165
       +
       		const controller = new AbortController();

     

       166
       +
       		const timeoutId = setTimeout(() => controller.abort(), timeoutMs);

     

       167
       +
       

     

       168
       +
       		try {

     

       169
       +
       			const response = await fetch(url, {

     

       170
       +
       				...options,

     

       171
       +
       				signal: controller.signal,

     

       172
       +
       				redirect: 'follow',

     

       173
       +
       				headers: {

     

       174
       +
       					'User-Agent': 'wisp-place hosting-service',

     

       175
       +
       					...(options?.headers || {}),

     

       176
       +
       				},

     

       177
       +
       			});

     

       178
        
       

     

       179
       +
       			const contentLength = response.headers.get('content-length');

     

       180
       +
       			if (contentLength && parseInt(contentLength, 10) > maxSize) {

     

       181
       +
       				throw new Error(`Response too large: ${contentLength} bytes`);

     

       182
       +
       			}

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       183
        
       

     

       184
       +
       			return response;

     

       185
       +
       		} catch (err) {

     

       186
       +
       			if (err instanceof Error && err.name === 'AbortError') {

     

       187
       +
       				throw new Error(`Request timeout after ${timeoutMs}ms`);

     

       188
       +
       			}

     

       189
       +
       			throw err;

     

       190
       +
       		} finally {

     

       191
       +
       			clearTimeout(timeoutId);

     

       192
        
       		}

     

       193
       +
       	};

     

       194
        
       

     

       195
       +
       	if (shouldRetry) {

     

       196
       +
       		return withRetry(fetchFn, { context: `Fetch ${parsedUrl.hostname}` });

     

       197
       +
       	} else {

     

       198
       +
       		return fetchFn();

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       199
        
       	}

     

       200
        
       }

     

       201
        
       

     

       202
        
       export async function safeFetchJson<T = any>(

     

       203
        
       	url: string,

     

       204
       +
       	options?: RequestInit & { maxSize?: number; timeout?: number; retry?: boolean }

     

       205
        
       ): Promise<T> {

     

       206
        
       	const maxJsonSize = options?.maxSize ?? MAX_JSON_SIZE;

     

       207
        
       	const response = await safeFetch(url, { ...options, maxSize: maxJsonSize });

     
···

       247
        
       

     

       248
        
       export async function safeFetchBlob(

     

       249
        
       	url: string,

     

       250
       +
       	options?: RequestInit & { maxSize?: number; timeout?: number; retry?: boolean }

     

       251
        
       ): Promise<Uint8Array> {

     

       252
        
       	const maxBlobSize = options?.maxSize ?? MAX_BLOB_SIZE;

     

       253
        
       	const timeoutMs = options?.timeout ?? FETCH_TIMEOUT_BLOB;

+28

scripts/codegen.sh

···

       1
       +
       #!/bin/bash

     

       2
       +
       set -e

     

       3
       +
       

     

       4
       +
       SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"

     

       5
       +
       ROOT_DIR="$(dirname "$SCRIPT_DIR")"

     

       6
       +
       

     

       7
       +
       # Parse arguments

     

       8
       +
       AUTO_ACCEPT=""

     

       9
       +
       if [[ "$1" == "-y" || "$1" == "--yes" ]]; then

     

       10
       +
           AUTO_ACCEPT="yes |"

     

       11
       +
       fi

     

       12
       +
       

     

       13
       +
       echo "=== Generating TypeScript lexicons ==="

     

       14
       +
       cd "$ROOT_DIR/packages/@wisp/lexicons"

     

       15
       +
       eval "$AUTO_ACCEPT npm run codegen"

     

       16
       +
       

     

       17
       +
       echo "=== Generating Rust lexicons ==="

     

       18
       +
       echo "Installing jacquard-lexgen..."

     

       19
       +
       cargo install jacquard-lexgen --version 0.9.5 2>/dev/null || true

     

       20
       +
       echo "Running jacquard-codegen..."

     

       21
       +
       echo "  Input: $ROOT_DIR/lexicons"

     

       22
       +
       echo "  Output: $ROOT_DIR/cli/crates/lexicons/src"

     

       23
       +
       jacquard-codegen -i "$ROOT_DIR/lexicons" -o "$ROOT_DIR/cli/crates/lexicons/src"

     

       24
       +
       

     

       25
       +
       # Add extern crate alloc for the macro to work

     

       26
       +
       sed -i '' '1s/^/extern crate alloc;\n\n/' "$ROOT_DIR/cli/crates/lexicons/src/lib.rs"

     

       27
       +
       

     

       28
       +
       echo "=== Done ==="

+1 -1

tsconfig.json

···

       33
        
       		// "rootDirs": [],                                   /* Allow multiple folders to be treated as one when resolving modules. */

     

       34
        
       		// "typeRoots": [],                                  /* Specify multiple folders that act like './node_modules/@types'. */

     

       35
        
       		"types": [

     

       36
       -
       			"bun-types"

     

       37
        
       		] /* Specify type package names to be included without being referenced in a source file. */,

     

       38
        
       		// "allowUmdGlobalAccess": true,                     /* Allow accessing UMD globals from modules. */

     

       39
        
       		// "moduleSuffixes": [],                             /* List of file name suffixes to search when resolving a module. */

···

       33
        
       		// "rootDirs": [],                                   /* Allow multiple folders to be treated as one when resolving modules. */

     

       34
        
       		// "typeRoots": [],                                  /* Specify multiple folders that act like './node_modules/@types'. */

     

       35
        
       		"types": [

     

       36
       +
       			"bun"

     

       37
        
       		] /* Specify type package names to be included without being referenced in a source file. */,

     

       38
        
       		// "allowUmdGlobalAccess": true,                     /* Allow accessing UMD globals from modules. */

     

       39
        
       		// "moduleSuffixes": [],                             /* List of file name suffixes to search when resolving a module. */

Compare changes