@jimhoyd/urlcode 0.4.0-alpha.1 → 0.4.0-alpha.3

package/dist/link-store.js

@@ -1,250 +0,0 @@
-import {Worker} from 'node:worker_threads';
-import {realpath,lstat,open} from 'node:fs/promises';
-import {dirname,basename,join,relative,isAbsolute,sep} from 'node:path';
-import {ConfigError,HttpError,assert} from './errors.js';
-import {supportsConcurrentWal} from './sqlite-version.js';
-                                                  
-                                      
-/** A stored link as the worker returns it. */
-                                                                                                 
-                                                                                   
-                                                                                         
-                                                                                                                                                                               
-                                                                                                                                 
-                                                                                                                            
-                                                                                                                                                 
-                                                                        
-                                                                                                                                                                                        
-                                                                                                          
-
-// The worker protocol: one command per operation, one reply per command. The
-// worker validates every argument again; these types name the contract.
-                                                                        
-                                                                                                                      
-                                                                       
-                                                                                                                            
- 
-                                                                                                    
-                           
-                                  
-                                
-                                                           
-
-/** One worker-backed SQLite connection. */
-                                 
-                            
-                                                              
-                                                                     
-                                                                                
-                                                              
-                                
-                                                                                                            
-                                                                                                                                   
-                                                                                                                     
-                         
- 
-/** The pooled store openLinkStore returns. */
-                            
-                                                                                           
-                             
-                          
-                                                                                            
-                                                              
-                                                                     
-                                                                                                            
-                                                                                                                                   
-                                                                                                                     
-                         
- 
-                                                                                                                                                                                                                                     
-
-export async function outsideProject(file         ,project        )                  {
-  assert(typeof file==='string' && isAbsolute(file),'Operator file must use an absolute path');
-  const parent=await realpath(dirname(file));const actual=join(parent,basename(file));
-  const root=await realpath(project);const rel=relative(root,actual);
-  assert(isAbsolute(rel)||rel==='..'||rel.startsWith('..'+sep),'Operator file must be outside the application project');
-  return actual;
-}
-// A backstop against a worker that will never answer, not a performance budget:
-// a bad build or an unreadable file reports itself in milliseconds, while a cold,
-// heavily loaded machine can legitimately take seconds to boot a worker thread
-// and open SQLite. Set well clear of that, because refusing to start a store the
-// machine would have opened is the worse failure.
-const startupMs=15000;
-                                                                                                              
-const isCode=(error         ,code        )         =>error instanceof Error && 'code' in error && error.code===code;
-async function openConnection({file,project='.',readOnly=false,log=()=>{}}                                                                                                  )                          {
-  assert(supportsConcurrentWal(process.versions.sqlite),`Live links require a Node build with patched SQLite (3.51.3+, 3.50.7 or 3.44.6); this build has ${process.versions.sqlite}. Upgrade Node`);
-  const path=await outsideProject(file,project);
-  if(!readOnly){try{const handle=await open(path,'wx',0o600);await handle.close();}catch(e){if(!isCode(e,'EEXIST'))throw e;}}
-  const info=await lstat(path);
-  assert(info.isFile() && !info.isSymbolicLink() && info.nlink===1,'Link store must be a regular operator-owned file');
-  const pending=new Map                    ();
-  let worker                  ,sequence=0,healthy=false,closed=false,closing                         ,attempts=0,respawnTimer                          ;
-  const report=(status        ,extra        ={})=>{try{log({event:'link_store_worker',status,readOnly,...extra});}catch{/* Logging cannot fail the store. */}};
-  const fail=()=>{healthy=false;for(const {reject,timer} of pending.values()){clearTimeout(timer);reject(new HttpError(503,'Link store unavailable'));}pending.clear();};
-  // A dead connection must not latch the store off: one slow query or an abrupt
-  // worker exit is recoverable, and the records themselves live on disk.
-  function scheduleRespawn() {
-    if(closed)return;
-    attempts++;
-    const delayMs=Math.min(30000,250*2**Math.min(attempts-1,7));
-    report('restarting',{attempt:attempts,delayMs});
-    respawnTimer=setTimeout(()=>{respawnTimer=undefined;if(closed)return;void launch().catch(()=>scheduleRespawn());},delayMs);
-    respawnTimer.unref();
-  }
-  async function launch() {
-    const workerData                     ={file:path,readOnly};
-    const instance=new Worker(new URL('./link-store-worker.js',import.meta.url),{workerData,env:{},execArgv:[],stdout:true,stderr:true,resourceLimits:{maxOldGenerationSizeMb:64}});
-    worker=instance;instance.stdout.resume();instance.stderr.resume();
-    try {
-      await new Promise      ((resolve,reject)=>{
-        let started=false,settled=false;
-        const settle=(error        )=>{if(settled)return;settled=true;if(error)reject(error);else resolve();};
-        const timer=setTimeout(()=>settle(new ConfigError(`Link store initialization failed: no ready signal within ${startupMs}ms`)),startupMs);
-        instance.on('message',(message                )=>{ // trust boundary: the worker's own protocol
-          if('ready' in message){if(!started){started=true;healthy=true;clearTimeout(timer);report('started');settle();}return;}
-          if('failed' in message){clearTimeout(timer);healthy=false;settle(new ConfigError('Link store initialization failed: the worker could not open the store'));return;}
-          const request=pending.get(message.id);if(!request)return;
-          // An answered operation, success or rejection, proves this connection is
-          // serving again; a worker that starts cleanly but dies on every operation
-          // must keep backing off rather than restarting in a tight loop.
-          attempts=0;clearTimeout(request.timer);pending.delete(message.id);
-          if('error' in message)request.reject(new HttpError(message.error.status,message.error.message));else request.resolve(message.value);
-        });
-        const down=()=>{
-          clearTimeout(timer);
-          const wasStarted=started;started=false;
-          if(worker===instance)fail();
-          settle(new ConfigError('Link store initialization failed: the worker exited or errored during start'));
-          // Replace only a connection that had been serving; a failed activation
-          // is reported to the caller instead of retried behind its back.
-          if(wasStarted&&!closed&&worker===instance)scheduleRespawn();
-        };
-        instance.on('error',down);instance.on('exit',down);
-      });
-    } catch(error) {
-      // An initialization error must not escape while its worker still owns the DB.
-      await instance.terminate();
-      throw error;
-    }
-  }
-  await launch();
-  function call   (operation                    ,args               ={},internal=false)             {
-    const instance=worker;
-    if(!healthy||!instance||(!internal&&(closed||pending.size>=32)))return Promise.reject(new HttpError(503,'Link store capacity unavailable'));
-    const id=++sequence;
-    return new Promise   ((resolve,reject)=>{
-      const timer=setTimeout(()=>{if(worker===instance){fail();void instance.terminate();}},5000);
-      pending.set(id,{resolve:value=>resolve(value     ),reject,timer}); // trust boundary: the worker answers each operation with its own value type
-      const command                  ={id,operation,args};
-      try{instance.postMessage(command);}
-      catch{clearTimeout(timer);pending.delete(id);reject(new HttpError(400,'Invalid store arguments'));}
-    });
-  }
-  return {
-    get healthy(){return healthy&&!closed;},
-    get:(collection,code)=>call('get',{collection,code}),
-    list:(collection,options={})=>call('list',{collection,...options}),
-    exportBegin:(options={})=>call('exportBegin',options),
-    exportPage:(options={})=>call('exportPage',options),
-    exportEnd:()=>call('exportEnd',{}),
-    create:(collection,data,code,audit)=>call('create',{collection,data,code,audit}),
-    update:(collection,code,data,expectedVersion,audit)=>call('update',{collection,code,data,expectedVersion,audit}),
-    delete:(collection,code,expectedVersion,audit)=>call('delete',{collection,code,expectedVersion,audit}),
-    close(){
-      if(closing)return closing;
-      closed=true;
-      if(respawnTimer){clearTimeout(respawnTimer);respawnTimer=undefined;}
-      // Reserve shutdown admission and enqueue it after all accepted operations.
-      closing=(async()=>{const instance=worker;try{if(healthy)await call('close',{},true);}finally{fail();await instance?.terminate();}})();
-      return closing;
-    },
-  };
-}
-
-// SQLite permits concurrent readers but serializes writes. Keep independent
-// admission budgets so management work cannot consume redirect read capacity.
-export async function openLinkStore({file,project='.',readOnly=false,readers=2,maxReads=32,maxWrites=32,log=()=>{}}                  ={})                     {
-  assert(Number.isInteger(readers)&&readers>=1&&readers<=8,'Link readers must be 1–8');
-  for(const value of [maxReads,maxWrites])assert(Number.isInteger(value)&&value>=1&&value<=32,'Link pool limits must be 1–32');
-  const connections                  =[];let writer                          ;
-  try {
-    // Initialize before opening read-only connections on a new database.
-    if(!readOnly){writer=await openConnection({file,project,log});connections.push(writer);}
-    const read                  =[];
-    for(let i=0;i<readers;i++){const connection=await openConnection({file,project,readOnly:true,log});connections.push(connection);read.push(connection);}
-    return pooledStore(read,writer,maxReads,maxWrites);
-  }catch(error){await Promise.allSettled(connections.map(connection=>connection.close()));throw error;}
-}
-                                                                   
-                                                                                                                                                    
-function pooledStore(read                  ,writer                          ,maxReads        ,maxWrites        )            {
-  const group=(connections                  ,limit        )      =>({connections:connections.map(connection=>({connection,inFlight:0})),limit,inFlight:0,completed:0,failed:0,rejected:0,durationMs:0});
-  const reads=group(read,maxReads),writes=group(writer?[writer]:[],maxWrites);
-  let closed=false,closing                         ,exporting=false;
-  const healthy=(pool      )=>!closed&&pool.connections.length>0&&pool.connections.every(slot=>slot.connection.healthy);
-  async function run   (pool      ,operation                                          )            {
-    if(closed){pool.rejected++;throw new HttpError(503,'Link store unavailable');}
-    if(!pool.connections.length){pool.rejected++;throw new HttpError(403,'Store is read-only');}
-    const slot=pool.connections.filter(slot=>slot.connection.healthy).sort((a,b)=>a.inFlight-b.inFlight)[0];
-    if(!slot || pool.inFlight>=pool.limit){pool.rejected++;throw new HttpError(503,'Link pool capacity unavailable');}
-    pool.inFlight++;slot.inFlight++;const started=performance.now();
-    try{const value=await operation(slot.connection);pool.completed++;return value;}
-    catch(error){pool.failed++;throw error;}
-    finally{pool.inFlight--;slot.inFlight--;pool.durationMs+=performance.now()-started;}
-  }
-  // One bounded, point-in-time export at a time, pinned to a single reader and
-  // holding that reader's admission for its whole life so it cannot outgrow the
-  // pool's budget. Writers keep committing; this view does not see them.
-  async function exportSnapshot({collection,pageSize=100,deadlineMs=60000}               ={},{onHeader=()=>{},onRecords=()=>{}}                ={})                         {
-    assert(Number.isInteger(pageSize)&&pageSize>=1&&pageSize<=100,'Export page size must be 1–100');
-    assert(Number.isInteger(deadlineMs)&&deadlineMs>=1000&&deadlineMs<=600000,'Export deadline must be 1000–600000 ms');
-    assert(typeof onHeader==='function' && typeof onRecords==='function','Export handlers must be functions');
-    if(closed){reads.rejected++;throw new HttpError(503,'Link store unavailable');}
-    if(exporting){reads.rejected++;throw new HttpError(409,'An export is already in progress');}
-    const slot=reads.connections.filter(slot=>slot.connection.healthy).sort((a,b)=>a.inFlight-b.inFlight)[0];
-    if(!slot||reads.inFlight>=reads.limit){reads.rejected++;throw new HttpError(503,'Link pool capacity unavailable');}
-    exporting=true;reads.inFlight++;slot.inFlight++;
-    const started=performance.now(),expires=Date.now()+deadlineMs;
-    try {
-      const header=await slot.connection.exportBegin(collection===undefined?{}:{collection});
-      let exported=0,afterCollection='',afterCode='';
-      try {
-        // Identity and the snapshot's revision are handed over before any record,
-        // so a truncated stream is recognizable rather than silently short.
-        await onHeader(header);
-        for(;;){
-          if(Date.now()>expires)throw new HttpError(503,'Export deadline exceeded');
-          const records=await slot.connection.exportPage({afterCollection,afterCode,limit:pageSize});
-          const last=records.at(-1);
-          if(!last)break;
-          await onRecords(records);
-          exported+=records.length;
-          afterCollection=last.collection;afterCode=last.code;
-        }
-      } finally { await slot.connection.exportEnd().catch(()=>{}); }
-      reads.completed++;
-      return {...header,exported};
-    } catch(error){reads.failed++;throw error;}
-    finally{exporting=false;reads.inFlight--;slot.inFlight--;reads.durationMs+=performance.now()-started;}
-  }
-  const stats=(pool      )           =>({connections:pool.connections.length,healthyConnections:pool.connections.filter(s=>s.connection.healthy).length,limit:pool.limit,inFlight:pool.inFlight,completed:pool.completed,failed:pool.failed,rejected:pool.rejected,durationMs:pool.durationMs});
-  return {
-    get readHealthy(){return healthy(reads);},
-    get writeHealthy(){return healthy(writes);},
-    get healthy(){return healthy(reads)&&(!writer||healthy(writes));},
-    atomicAudit:true,
-    stats:()=>({closed,exporting,read:stats(reads),write:stats(writes)}),
-    exportSnapshot,
-    get:(collection,code)=>run(reads,c=>c.get(collection,code)),list:(collection,options)=>run(reads,c=>c.list(collection,options)),
-    create:(collection,data,code,audit)=>run(writes,c=>c.create(collection,data,code,audit)),update:(collection,code,data,expectedVersion,audit)=>run(writes,c=>c.update(collection,code,data,expectedVersion,audit)),delete:(collection,code,expectedVersion,audit)=>run(writes,c=>c.delete(collection,code,expectedVersion,audit)),
-    close(){
-      if(closing)return closing;closed=true;
-      closing=(async()=>{
-        const results=await Promise.allSettled([...read,...(writer?[writer]:[])].map(connection=>connection.close()));
-        const failed=results.find((result)                                 =>result.status==='rejected');if(failed)throw failed.reason;
-      })();return closing;
-    },
-  };
-}

package/dist/management-policy.js

@@ -1,40 +0,0 @@
-import {constants} from 'node:fs';
-import {open} from 'node:fs/promises';
-import {createHash,timingSafeEqual} from 'node:crypto';
-import {outsideProject} from './link-store.js';
-import {assert} from './errors.js';
-/** A credential from the operator's management policy file, once it authenticated a request. */
-                                                                                             
-                                                                                         
-                                                                                                       
-const actions                   =['get','list','create','update','delete'];
-const isRecord=(value         )                                 =>value!==null && typeof value==='object' && !Array.isArray(value);
-export async function managementPolicy(file         ,project        )                                {
-  const path=await outsideProject(file,project);
-  return async token=>{
-    const handle=await open(path,constants.O_RDONLY | (constants.O_NOFOLLOW||0));
-    let document         ;
-    try {
-      const info=await handle.stat();
-      assert(info.isFile() && info.nlink===1 && info.size<=65536 && (process.platform==='win32'||(info.mode&0o077)===0),'Invalid private management policy');
-      const buffer=Buffer.alloc(65537);let offset=0;
-      while(offset<buffer.length){const {bytesRead}=await handle.read(buffer,offset,buffer.length-offset,null);if(!bytesRead)break;offset+=bytesRead;}
-      assert(offset<=65536,'Management policy exceeds 64 KiB');
-      document=JSON.parse(new TextDecoder('utf-8',{fatal:true}).decode(buffer.subarray(0,offset)));
-    } finally {await handle.close();}
-    assert(isRecord(document) && document.version===1 && Object.keys(document).every(k=>['version','credentials'].includes(k)) && Array.isArray(document.credentials) && document.credentials.length<=128,'Invalid management policy');
-    const ids=new Set        (),hashes=new Set        ();let principal                               ;
-    const digest=createHash('sha256').update(token).digest();
-    for(const entry of document.credentials             ){
-      assert(isRecord(entry) && Object.keys(entry).every(k=>['id','sha256','expires','revoked','collections','actions'].includes(k)) && typeof entry.id==='string' && /^[A-Za-z0-9_-]{1,64}$/.test(entry.id) && !ids.has(entry.id),'Invalid credential identity');ids.add(entry.id);
-      assert(typeof entry.sha256==='string' && /^[a-f0-9]{64}$/.test(entry.sha256) && !hashes.has(entry.sha256),'Invalid credential hash');hashes.add(entry.sha256);
-      assert(typeof entry.expires==='string' && /^\d{4}-\d\d-\d\dT\d\d:\d\d:\d\dZ$/.test(entry.expires) && Number.isFinite(Date.parse(entry.expires)) && new Date(entry.expires).toISOString()===entry.expires.replace('Z','.000Z'),'Credential expiry required');
-      assert(entry.revoked===undefined || typeof entry.revoked==='boolean','Invalid revocation');
-      assert(Array.isArray(entry.collections) && entry.collections.length>0 && entry.collections.length<=100 && entry.collections.every(v=>typeof v==='string' && /^[A-Za-z][A-Za-z0-9_-]{0,63}$/.test(v)),'Invalid collection scope');
-      assert(Array.isArray(entry.actions) && entry.actions.length>0 && entry.actions.every(a=>actions.includes(a)),'Invalid action scope');
-      const c=entry                         ; // validated field by field above
-      if(timingSafeEqual(digest,Buffer.from(c.sha256,'hex')) && !c.revoked && Date.parse(c.expires)>Date.now())principal=c;
-    }
-    return principal;
-  };
-}

package/dist/sqlite-version.js

@@ -1,6 +0,0 @@
-// https://www.sqlite.org/wal.html#the_wal_reset_bug
-export function supportsConcurrentWal(version         )          {
-  const [major=NaN,minor=NaN,patch=NaN]=String(version).split('.').map(Number);
-  if(![major,minor,patch].every(Number.isInteger))return false;
-  return major>3 || major===3 && (minor>51 || minor===51&&patch>=3 || minor===50&&patch>=7 || minor===44&&patch>=6);
-}

package/dist/types/link-api.d.ts

@@ -1,30 +0,0 @@
-import type { AddressInfo } from 'node:net';
-import type { AuditIdentity, LinkRow, ListOptions } from './link-store.ts';
-import type { ManagementAuthorizer } from './management-policy.ts';
-import type { LogFn } from './types.ts';
-/** The store surface management needs: the pooled link store, or anything with the same contract. */
-export interface ManagementStore {
-    readonly atomicAudit?: boolean;
-    get(collection: string, code: string): Promise<LinkRow | null>;
-    list(collection: string, options?: ListOptions): Promise<LinkRow[]>;
-    create(collection: string, data: unknown, code?: unknown, audit?: AuditIdentity | undefined): Promise<LinkRow>;
-    update(collection: string, code: string, data: unknown, expectedVersion: unknown, audit?: AuditIdentity | undefined): Promise<LinkRow>;
-    delete(collection: string, code: string, expectedVersion: unknown, audit?: AuditIdentity | undefined): Promise<boolean>;
-}
-export interface LinkApiOptions {
-    store: ManagementStore;
-    collection: string;
-    token?: string | undefined;
-    authorize?: ManagementAuthorizer | undefined;
-    host?: string | undefined;
-    port?: number | undefined;
-    maxInFlightRequests?: number | undefined;
-    socketTimeoutMs?: number | undefined;
-    log?: LogFn | undefined;
-}
-export interface LinkApi {
-    address: AddressInfo;
-    close(): Promise<void>;
-}
-export declare function loadLinkToken(file: unknown, project: string): Promise<string>;
-export declare function startLinkApi({ store, collection, token, authorize, host, port, maxInFlightRequests, socketTimeoutMs, log }: LinkApiOptions): Promise<LinkApi>;

package/dist/types/link-cli.d.ts

@@ -1,37 +0,0 @@
-/** The parsed command-line values the links commands read; every flag is a string or absent. */
-interface LinkCommandValues {
-    project?: string | undefined;
-    store?: string | undefined;
-    collection?: string | undefined;
-    code?: string | undefined;
-    destination?: string | undefined;
-    status?: string | undefined;
-    enabled?: string | undefined;
-    expires?: string | undefined;
-    'if-version'?: string | undefined;
-    limit?: string | undefined;
-    after?: string | undefined;
-    input?: string | undefined;
-    'page-size'?: string | undefined;
-    'auth-file'?: string | undefined;
-    'token-file'?: string | undefined;
-    port?: string | undefined;
-    host?: string | undefined;
-    'link-readers'?: string | undefined;
-    'link-read-limit'?: string | undefined;
-    'link-write-limit'?: string | undefined;
-}
-export type Print = (value: unknown) => unknown;
-export interface LinkPoolOptions {
-    readers?: number;
-    maxReads?: number;
-    maxWrites?: number;
-}
-export interface LinkBinding extends LinkPoolOptions {
-    collection: string;
-    file: string;
-}
-export declare function linkPoolOptions(values: LinkCommandValues): LinkPoolOptions;
-export declare function parseLinkBinding(value: string | undefined, options?: LinkPoolOptions): LinkBinding | undefined;
-export declare function runLinkCommand(action: string | undefined, values: LinkCommandValues, print: Print): Promise<void>;
-export {};

package/dist/types/link-events.d.ts

@@ -1,27 +0,0 @@
-export interface LinkEvent {
-    outcome: string;
-    code?: string | null;
-    [field: string]: unknown;
-}
-export interface LinkObserverOptions {
-    observe: (event: LinkEvent) => unknown;
-    includeCode?: boolean;
-    maxQueue?: number;
-    timeoutMs?: number;
-}
-export interface LinkObserverStats {
-    queued: number;
-    delivered: number;
-    dropped: number;
-    failed: number;
-    timedOut: number;
-    closed: boolean;
-}
-export interface LinkObserver {
-    emit(event: LinkEvent): void;
-    stats(): LinkObserverStats;
-    close(): Promise<LinkObserverStats>;
-}
-type Log = (event: Record<string, unknown>) => void;
-export declare function createLinkObserver(options: unknown, log?: Log): LinkObserver | undefined;
-export {};

package/dist/types/link-records.d.ts

@@ -1,11 +0,0 @@
-export interface LinkRecord {
-    url: string;
-    status: number;
-    enabled: boolean;
-    expires: string | null;
-}
-export declare function linkCollection(value: unknown): string;
-export declare function linkCode(value: unknown): string;
-export declare function linkVersion(value: unknown): number;
-export declare function linkData(value: unknown): LinkRecord;
-export declare const randomLinkCode: () => string;

package/dist/types/link-store-worker.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/types/link-store.d.ts

@@ -1,130 +0,0 @@
-import type { LinkRecord } from './link-records.ts';
-import type { LogFn } from './types.ts';
-/** A stored link as the worker returns it. */
-export interface LinkRow extends LinkRecord {
-    collection: string;
-    code: string;
-    version: number;
-}
-export interface ListOptions {
-    limit?: number | undefined;
-    after?: string | undefined;
-}
-export interface AuditIdentity {
-    actor?: string | undefined;
-    requestId?: string | undefined;
-}
-export interface ExportHeader {
-    format: string;
-    schemaVersion: number;
-    applicationId: number;
-    collection: string | null;
-    revision: number;
-    records: number;
-    generatedAt: string;
-}
-export interface ExportPageOptions {
-    afterCollection?: string | undefined;
-    afterCode?: string | undefined;
-    limit?: number | undefined;
-}
-export interface ExportOptions {
-    collection?: string | undefined;
-    pageSize?: number | undefined;
-    deadlineMs?: number | undefined;
-}
-export interface ExportHandlers {
-    onHeader?: ((header: ExportHeader) => unknown) | undefined;
-    onRecords?: ((records: LinkRow[]) => unknown) | undefined;
-}
-export interface ExportSummary extends ExportHeader {
-    exported: number;
-}
-export interface PoolStats {
-    connections: number;
-    healthyConnections: number;
-    limit: number;
-    inFlight: number;
-    completed: number;
-    failed: number;
-    rejected: number;
-    durationMs: number;
-}
-export interface LinkStoreStats {
-    closed: boolean;
-    exporting: boolean;
-    read: PoolStats;
-    write: PoolStats;
-}
-export interface LinkStoreWorkerData {
-    file: string;
-    readOnly: boolean;
-}
-export type LinkStoreOperation = 'get' | 'list' | 'create' | 'update' | 'delete' | 'exportBegin' | 'exportPage' | 'exportEnd' | 'close';
-export interface LinkStoreArgs extends ListOptions, ExportPageOptions {
-    collection?: string | undefined;
-    code?: unknown;
-    data?: unknown;
-    expectedVersion?: unknown;
-    audit?: AuditIdentity | undefined;
-}
-export interface LinkStoreCommand {
-    id: number;
-    operation: LinkStoreOperation;
-    args: LinkStoreArgs;
-}
-export type LinkStoreReply = {
-    ready: true;
-} | {
-    failed: true;
-} | {
-    id: number;
-    value: unknown;
-} | {
-    id: number;
-    error: {
-        status: number;
-        message: string;
-    };
-};
-/** One worker-backed SQLite connection. */
-export interface LinkConnection {
-    readonly healthy: boolean;
-    get(collection: string, code: string): Promise<LinkRow | null>;
-    list(collection: string, options?: ListOptions): Promise<LinkRow[]>;
-    exportBegin(options?: {
-        collection?: string | undefined;
-    }): Promise<ExportHeader>;
-    exportPage(options?: ExportPageOptions): Promise<LinkRow[]>;
-    exportEnd(): Promise<boolean>;
-    create(collection: string, data: unknown, code?: unknown, audit?: AuditIdentity | undefined): Promise<LinkRow>;
-    update(collection: string, code: string, data: unknown, expectedVersion: unknown, audit?: AuditIdentity | undefined): Promise<LinkRow>;
-    delete(collection: string, code: string, expectedVersion: unknown, audit?: AuditIdentity | undefined): Promise<boolean>;
-    close(): Promise<void>;
-}
-/** The pooled store openLinkStore returns. */
-export interface LinkStore {
-    readonly readHealthy: boolean;
-    readonly writeHealthy: boolean;
-    readonly healthy: boolean;
-    readonly atomicAudit: true;
-    stats(): LinkStoreStats;
-    exportSnapshot(options?: ExportOptions, handlers?: ExportHandlers): Promise<ExportSummary>;
-    get(collection: string, code: string): Promise<LinkRow | null>;
-    list(collection: string, options?: ListOptions): Promise<LinkRow[]>;
-    create(collection: string, data: unknown, code?: unknown, audit?: AuditIdentity | undefined): Promise<LinkRow>;
-    update(collection: string, code: string, data: unknown, expectedVersion: unknown, audit?: AuditIdentity | undefined): Promise<LinkRow>;
-    delete(collection: string, code: string, expectedVersion: unknown, audit?: AuditIdentity | undefined): Promise<boolean>;
-    close(): Promise<void>;
-}
-export interface LinkStoreOptions {
-    file?: string | undefined;
-    project?: string | undefined;
-    readOnly?: boolean | undefined;
-    readers?: number | undefined;
-    maxReads?: number | undefined;
-    maxWrites?: number | undefined;
-    log?: LogFn | undefined;
-}
-export declare function outsideProject(file: unknown, project: string): Promise<string>;
-export declare function openLinkStore({ file, project, readOnly, readers, maxReads, maxWrites, log }?: LinkStoreOptions): Promise<LinkStore>;

package/dist/types/management-policy.d.ts

@@ -1,8 +0,0 @@
-/** A credential from the operator's management policy file, once it authenticated a request. */
-export interface ManagementPrincipal {
-    id: string;
-    collections: string[];
-    actions: string[];
-}
-export type ManagementAuthorizer = (token: string) => Promise<ManagementPrincipal | undefined>;
-export declare function managementPolicy(file: unknown, project: string): Promise<ManagementAuthorizer>;

package/dist/types/sqlite-version.d.ts

@@ -1 +0,0 @@
-export declare function supportsConcurrentWal(version: unknown): boolean;

package/docs/DYNAMIC-LINKS.md

@@ -1,61 +0,0 @@
-# Dynamic short links without reloads
-
-Define a stable route once and create, update and delete short-code records
-while `serve` keeps running, from optional SQLite storage on one host. Each
-section below lives on its own page; the headings here keep existing links working.
-
-## Node build requirement
-
-SQLite 3.51.3+ (or 3.50.7 / 3.44.6) bundled with Node; `urlcode doctor` reports it. Read [setup](links/setup.md#node-build-requirement).
-
-## Behavior in YAML, data outside Git
-
-The `link` handler and the operator store binding. Read [setup](links/setup.md#behavior-in-yaml-data-outside-git).
-
-## Run the included example
-
-`links init`, `links create` and `serve --link-store` against a private data directory. Read [setup](links/setup.md#run-the-included-example).
-
-## Update, disable, expire, list and delete
-
-`links get/list/update/delete` and the optimistic version rules. Read [cli](links/cli.md#update-disable-expire-list-and-delete).
-
-## Consistent operator export and restore
-
-`links export` holds one read transaction; `links import` refuses occupied collections. Read [cli](links/cli.md#consistent-operator-export-and-restore).
-
-## A separate authenticated management API
-
-`links api`: bearer token, endpoints, status codes and scope. Read [management-api](links/management-api.md#a-separate-authenticated-management-api).
-
-## Persistence, bounds and recovery
-
-Pools, deadlines, worker replacement with backoff, record caps and backups. Read [limits](links/limits.md#persistence-bounds-and-recovery).
-
-## Middleware, sandbox and tests
-
-What guest code can and cannot see; fixtures for `test` and `audit`. Read [setup](links/setup.md#middleware-sandbox-and-tests).
-
-## Opt-in completed-redirect events
-
-The `linkEvents` observer: outcomes, redaction, bounded delivery. Read [limits](links/limits.md#opt-in-completed-redirect-events).
-
-## Shutdown and management defaults
-
-Loopback defaults, drain on close, unknown outcomes after a timeout. Read [pools](links/pools.md#shutdown-and-management-defaults).
-
-## Explicit project opt-in
-
-`dynamicLinks: true` in the entry file only; what enabling changes. Read [setup](links/setup.md#explicit-project-opt-in).
-
-## Separate reader and writer pools
-
-`--link-readers`, `--link-read-limit`, `--link-write-limit` and `stats()`. Read [pools](links/pools.md#separate-reader-and-writer-pools).
-
-## Management HTTP and audit safeguards
-
-Admission, socket timeout and `management_request` events. Read [management-api](links/management-api.md#management-http-and-audit-safeguards).
-
-## Management hardening baseline
-
-Loopback only, `--auth-file` credentials, durable audit rows. Read [management-api](links/management-api.md#management-hardening-baseline).