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

package/dist/link-store-worker.js

@@ -1,150 +0,0 @@
-import {createHash,randomUUID} from 'node:crypto';
-import {parentPort,workerData} from 'node:worker_threads';
-import {DatabaseSync,                   } from 'node:sqlite';
-import {linkCollection,linkCode,linkData,linkVersion,randomLinkCode} from './link-records.js';
-import {HttpError} from './errors.js';
-                                                                                                              
-if(!parentPort)throw new Error('Link store worker requires a parent');
-const port=parentPort;
-const data=workerData                       ; // trust boundary: set by openConnection
-const post=(message                )      =>port.postMessage(message);
-let db                        ;
-const error=(status        ,message        )       =>{throw new HttpError(status,message);};
-                                       
-const row=(value     )         =>({...value,enabled:value.enabled===1}           ); // trust boundary: a urlcode_links row
-const integer=(value                          )        =>typeof value==='number'?value:Number(value);
-try {
-  db=new DatabaseSync(data.file,{readOnly:data.readOnly,allowExtension:false});
-  db.exec('PRAGMA busy_timeout=1000; PRAGMA trusted_schema=OFF;');
-  const schemaVersion=db.prepare('PRAGMA user_version').get()?.user_version;
-  const applicationId=db.prepare('PRAGMA application_id').get()?.application_id;
-  const empty=db.prepare("SELECT count(*) AS count FROM sqlite_master WHERE type='table'").get()?.count===0;
-  if(!(schemaVersion===1 && applicationId===1431456835) && !(schemaVersion===0 && applicationId===0 && empty && !data.readOnly))throw new Error('Unsupported database schema');
-  if(!data.readOnly){
-    db.exec('PRAGMA journal_mode=WAL; PRAGMA synchronous=FULL;');
-    if(schemaVersion===0)db.exec(`BEGIN IMMEDIATE;
-      CREATE TABLE IF NOT EXISTS urlcode_link_meta (id INTEGER PRIMARY KEY CHECK(id=1), revision INTEGER NOT NULL);
-      INSERT OR IGNORE INTO urlcode_link_meta VALUES(1,0);
-      CREATE TABLE IF NOT EXISTS urlcode_links (
-        collection TEXT NOT NULL, code TEXT NOT NULL, url TEXT NOT NULL,
-        status INTEGER NOT NULL, enabled INTEGER NOT NULL, expires TEXT,
-        version INTEGER NOT NULL, PRIMARY KEY(collection,code));
-      PRAGMA application_id=1431456835; PRAGMA user_version=1; COMMIT;`);
-  }
-  if(!data.readOnly)db.exec(`CREATE TABLE IF NOT EXISTS urlcode_link_audit (revision INTEGER PRIMARY KEY, timestamp TEXT NOT NULL, actor TEXT NOT NULL, request_id TEXT NOT NULL, collection TEXT NOT NULL, action TEXT NOT NULL, code_sha256 TEXT NOT NULL)`);
-  if(db.prepare('PRAGMA journal_mode').get()?.journal_mode!=='wal')throw new Error('Link stores require WAL mode');
-  const revision=db.prepare('SELECT revision FROM urlcode_link_meta WHERE id=1').get()?.revision;
-  if(typeof revision!=='number' || !Number.isSafeInteger(revision) || revision<0)throw new Error('Invalid store revision');
-  db.prepare('SELECT collection,code,url,status,enabled,expires,version FROM urlcode_links LIMIT 0').all();
-  post({ready:true});
-}catch{try{db?.close();}catch{/* Initialization can fail before opening. */}post({failed:true});port.close();}
-// Every handler below runs after a successful open; the failure branch closed the port.
-const store=()              =>db ?? error(503,'Link store unavailable');
-function get(collection        ,code        )               {
-  const found=store().prepare('SELECT * FROM urlcode_links WHERE collection=? AND code=?').get(collection,code);
-  return found ? row(found) : null;
-}
-function transaction                             (fn         , audit                                   , collection        , operation        , code         )    {
-  const db=store();
-  db.exec('BEGIN IMMEDIATE');
-  try{
-    const value=fn();
-    const actor=audit?.actor??'local-operator',requestId=audit?.requestId??randomUUID();
-    if(typeof actor!=='string'||!/^[A-Za-z0-9_-]{1,64}$/.test(actor)||typeof requestId!=='string'||!/^[A-Za-z0-9_-]{1,64}$/.test(requestId))error(400,'Invalid audit identity');
-    const revision=db.prepare('SELECT revision FROM urlcode_link_meta WHERE id=1').get()?.revision;
-    const subject=value!==true&&value!==null?value.code:code;
-    if(typeof subject!=='string')throw new Error('Audit subject missing');
-    db.prepare('INSERT INTO urlcode_link_audit VALUES(?,?,?,?,?,?,?)').run(integer(revision),new Date().toISOString(),actor,requestId,collection,operation,createHash('sha256').update(subject).digest('hex'));
-    db.exec('COMMIT');return value;
-  }catch(e){db.exec('ROLLBACK');throw e;}
-}
-function version()         {
-  const db=store();
-  const current=db.prepare('SELECT revision FROM urlcode_link_meta WHERE id=1').get()?.revision;
-  if(typeof current!=='number' || !Number.isSafeInteger(current) || current>=Number.MAX_SAFE_INTEGER)throw new HttpError(503,'Link store revision exhausted');
-  db.prepare('UPDATE urlcode_link_meta SET revision=? WHERE id=1').run(current+1);return current+1;
-}
-// A consistent operator export needs one read transaction spanning every page.
-// WAL gives this connection a point-in-time view while writers keep committing;
-// the transaction is deliberately bounded and belongs to a single connection.
-let exporting                                =null;
-function exportEnd()          {
-  if(!exporting)return false;
-  exporting=null;
-  try{store().exec('ROLLBACK');}catch{/* A lost transaction is already finished. */}
-  return true;
-}
-function exportBegin(collection                  )               {
-  const db=store();
-  if(exporting)error(409,'An export is already in progress on this connection');
-  if(collection!==undefined)linkCollection(collection);
-  db.exec('BEGIN DEFERRED');
-  try {
-    // The first read inside the transaction is what pins the snapshot.
-    const records=collection===undefined
-      ? db.prepare('SELECT count(*) AS count FROM urlcode_links').get()?.count
-      : db.prepare('SELECT count(*) AS count FROM urlcode_links WHERE collection=?').get(collection)?.count;
-    const revision=db.prepare('SELECT revision FROM urlcode_link_meta WHERE id=1').get()?.revision;
-    exporting={collection:collection??null};
-    return {format:'urlcode.links.v1',schemaVersion:integer(db.prepare('PRAGMA user_version').get()?.user_version),
-      applicationId:integer(db.prepare('PRAGMA application_id').get()?.application_id),
-      collection:collection??null,revision:integer(revision),records:integer(records),generatedAt:new Date().toISOString()};
-  }catch(e){try{db.exec('ROLLBACK');}catch{/* Reported through the original error. */}throw e;}
-}
-function exportPage({afterCollection='',afterCode='',limit=100}                                                                                              )            {
-  const db=store();
-  if(!exporting)throw new HttpError(409,'No export is in progress on this connection');
-  if(!Number.isInteger(limit)||limit<1||limit>100)error(400,'Limit must be 1–100');
-  if(afterCollection!=='')linkCollection(afterCollection);
-  if(afterCode!=='')linkCode(afterCode);
-  const rows=exporting.collection===null
-    ? db.prepare('SELECT collection,code,url,status,enabled,expires,version FROM urlcode_links WHERE collection>? OR (collection=? AND code>?) ORDER BY collection,code LIMIT ?').all(afterCollection,afterCollection,afterCode,limit)
-    : db.prepare('SELECT collection,code,url,status,enabled,expires,version FROM urlcode_links WHERE collection=? AND code>? ORDER BY code LIMIT ?').all(exporting.collection,afterCode,limit);
-  return rows.map(row);
-}
-port.on('message',({id,operation,args}                  )=>{ // trust boundary: posted by openConnection
-  try {
-    if(operation==='close'){exportEnd();store().close();post({id,value:true});port.close();return;}
-    if(operation==='exportBegin'){post({id,value:exportBegin(args.collection)});return;}
-    if(operation==='exportPage'){
-      try{post({id,value:exportPage(args)});}
-      catch(e){exportEnd();throw e;}
-      return;
-    }
-    if(operation==='exportEnd'){post({id,value:exportEnd()});return;}
-    const collection=linkCollection(args.collection),{code}=args;
-    let value                             ;
-    if(operation==='get'){value=get(collection,linkCode(code));}
-    else if(operation==='list'){
-      const limit=args.limit??100,after=args.after??'';
-      if(!Number.isInteger(limit)||limit<1||limit>100)error(400,'Limit must be 1–100');
-      if(after!=='')linkCode(after);
-      value=store().prepare('SELECT * FROM urlcode_links WHERE collection=? AND code>? ORDER BY code LIMIT ?').all(collection,after,limit).map(row);
-    }else{
-      if(data.readOnly)error(403,'Store is read-only');
-      if(exporting)error(409,'An export is in progress on this connection');
-      value=transaction(()                   =>{
-        const db=store();
-        if(operation==='create'){
-          const record=linkData(args.data);
-          const count=db.prepare('SELECT count(*) AS count FROM urlcode_links').get()?.count;
-          if(typeof count==='number' && count>=100000)error(507,'Link store record limit reached');
-          let assigned=code===undefined?randomLinkCode():linkCode(code);
-          if(code!==undefined && get(collection,assigned))error(409,'Short code already exists');
-          if(code===undefined){let attempts=0;while(get(collection,assigned)){if(++attempts>=5)error(503,'Code allocation failed');assigned=randomLinkCode();}}
-          db.prepare('INSERT INTO urlcode_links VALUES(?,?,?,?,?,?,?)').run(collection,assigned,record.url,record.status,Number(record.enabled),record.expires,version());
-          return get(collection,assigned);
-        }
-        if(!['update','delete'].includes(operation))error(400,'Unsupported store operation');
-        const current=linkCode(code);const expectedVersion=linkVersion(args.expectedVersion);
-        const previous=get(collection,current);if(!previous)throw new HttpError(404,'Link not found');
-        if(previous.version!==expectedVersion)error(409,'Link version changed');
-        if(operation==='delete'){version();db.prepare('DELETE FROM urlcode_links WHERE collection=? AND code=?').run(collection,current);return true;}
-        const record=linkData(args.data);
-        db.prepare('UPDATE urlcode_links SET url=?,status=?,enabled=?,expires=?,version=? WHERE collection=? AND code=?').run(record.url,record.status,Number(record.enabled),record.expires,version(),collection,current);
-        return get(collection,current);
-      },args.audit,collection,operation,code);
-    }
-    post({id,value});
-  }catch(e){post({id,error:{status:e instanceof HttpError?e.status:503,message:e instanceof HttpError?e.message:'Link store unavailable'}});}
-});

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 {};