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

package/dist/link-cli.js

@@ -1,141 +0,0 @@
-import {createHash} from 'node:crypto';
-import {createReadStream} from 'node:fs';
-import {createInterface} from 'node:readline';
-import {isAbsolute} from 'node:path';
-import {managementPolicy} from './management-policy.js';
-import {openLinkStore} from './link-store.js';
-                                                                
-import {startLinkApi,loadLinkToken} from './link-api.js';
-import {linkCollection,linkCode,linkData} from './link-records.js';
-import {assert} from './errors.js';
-/** The parsed command-line values the links commands read; every flag is a string or absent. */
-                             
-                                                                                                               
-                                                                                                                    
-                                                                                                                                                
-                                                                                                                    
-                                                                                                                 
- 
-                                            
-                                                                                            
-                                                                                         
-const poolFlags=[['link-readers','readers',8],['link-read-limit','maxReads',32],['link-write-limit','maxWrites',32]]         ;
-export function linkPoolOptions(values                   )                  {
-  const result                 ={};
-  for(const [flag,key,max] of poolFlags){
-    const value=values[flag];
-    if(value===undefined)continue;
-    assert(/^\d+$/.test(value)&&Number(value)>=1&&Number(value)<=max,`Invalid --${flag}`);result[key]=Number(value);
-  }
-  return result;
-}
-export function parseLinkBinding(value                  ,options                 ={})                        {
-  if(value===undefined)return undefined;
-  const index=value.indexOf('=');assert(index>0,'Use --link-store collection=/absolute/path.sqlite');
-  return {collection:linkCollection(value.slice(0,index)),file:value.slice(index+1),...options};
-}
-const isRecord=(value         )                                 =>value!==null && typeof value==='object' && !Array.isArray(value);
-export async function runLinkCommand(action                  ,values                   ,print       )                {
-  assert(action!==undefined && ['init','create','get','list','update','delete','export','import','api'].includes(action),'Use links init/create/get/list/update/delete/export/import/api');
-  assert(values.store,'Links commands require --store with an absolute database path');
-  const collection=linkCollection(values.collection||'links');
-  const poolOptions=linkPoolOptions(values);
-  // Authentication material is checked before creating or opening a writable store.
-  if(values['auth-file'] && values['token-file'])throw new Error('Use either --auth-file or --token-file');
-  const project=values.project??'.';
-  const authorize=action==='api' && values['auth-file']?await managementPolicy(values['auth-file'],project):undefined;
-  if(authorize)await authorize('');
-  const token=action==='api' && !authorize?await loadLinkToken(values['token-file'],project):undefined;
-  const storeOptions                  ={file:values.store,project:values.project,readOnly:['get','list','export'].includes(action),...poolOptions};
-  const store=await openLinkStore(storeOptions);
-  try {
-    if(action==='api'){
-      const port=Number(values.port);assert(values.port!==undefined&&/^\d+$/.test(values.port)&&port>=0&&port<=65535,'Invalid port');
-      const api=await startLinkApi({store,collection,token,authorize,host:values.host,port});
-      print({event:'link-management-listening',address:api.address.address,port:api.address.port,collection});
-      await new Promise      (resolve=>{
-        const stop=()=>{process.off('SIGINT',stop);process.off('SIGTERM',stop);resolve();};
-        process.once('SIGINT',stop);process.once('SIGTERM',stop);
-      });
-      await api.close();return;
-    }
-    let value         ;
-    if(action==='init')value={event:'link-store-initialized'};
-    if(action==='get'){value=await store.get(collection,values.code??'');assert(value,'Link not found');}
-    if(action==='list')value=await store.list(collection,{limit:values.limit===undefined?100:Number(values.limit),after:values.after||''});
-    if(action==='create'||action==='update'){
-      assert(values.destination,'Use --destination with an HTTP(S) URL');
-      assert(values.enabled===undefined||['true','false'].includes(values.enabled),'Enabled must be true or false');
-      const data={url:values.destination,status:values.status===undefined?302:Number(values.status),enabled:values.enabled!=='false',expires:values.expires||null};
-      value=action==='create'?await store.create(collection,data,values.code):await store.update(collection,values.code??'',data,Number(values['if-version']));
-    }
-    if(action==='delete')value={deleted:await store.delete(collection,values.code??'',Number(values['if-version']))};
-    // Export and import stream their own NDJSON; they never buffer the store.
-    if(action==='export'){await exportLinks(store,values,print);return;}
-    if(action==='import'){print(await importLinks(store,values));return;}
-    print(value);
-  }finally{await store.close();}
-}
-
-// A restorable point-in-time snapshot: a header line carrying format, schema and
-// snapshot identity, one line per record, and a completion line with the record
-// count and a digest over every preceding line. Operator data goes to stdout
-// deliberately; redirect it to a file only operators can read.
-async function exportLinks(store           ,values                   ,print       )                {
-  const pageSize=values['page-size']===undefined?100:Number(values['page-size']);
-  assert(Number.isInteger(pageSize)&&pageSize>=1&&pageSize<=100,'Use --page-size 1–100');
-  const hash=createHash('sha256');
-  const line=(value         )=>{hash.update(JSON.stringify(value)+'\n');print(value);};
-  const summary=await store.exportSnapshot(
-    {collection:values.collection===undefined?undefined:linkCollection(values.collection),pageSize},
-    {
-      onHeader:header=>line({event:'link-export-begin',format:header.format,schemaVersion:header.schemaVersion,
-        applicationId:header.applicationId,collection:header.collection,revision:header.revision,
-        records:header.records,generatedAt:header.generatedAt}),
-      onRecords:records=>{for(const record of records)line({record});},
-    });
-  print({event:'link-export-complete',exported:summary.exported,sha256:hash.digest('hex')});
-}
-async function importLinks(store           ,values                   )                  {
-  assert(typeof values.input==='string' && isAbsolute(values.input),'Use --input with an absolute export file path');
-  const hash=createHash('sha256');
-  const counts=new Map               ();let imported=0,header                                  ,complete                                  ;
-  const stream=createReadStream(values.input,{encoding:'utf8'});
-  try {
-    for await (const text of createInterface({input:stream,crlfDelay:Infinity})) {
-      if(text==='')continue;
-      assert(Buffer.byteLength(text)<=65536,'Export line exceeds 65536 bytes');
-      assert(!complete,'Export file has content after its completion line');
-      let parsed         ;try{parsed=JSON.parse(text);}catch{throw new Error('Export file is not valid NDJSON');}
-      const line                        =isRecord(parsed)?parsed:{};
-      if(line.event==='link-export-complete'){
-        assert(header,'Export file has no header line');
-        assert(hash.copy().digest('hex')===line.sha256,'Export digest does not match its content');
-        assert(line.exported===imported,'Export record count does not match its record lines');
-        complete=line;continue;
-      }
-      hash.update(text+'\n');
-      if(line.event==='link-export-begin'){
-        assert(!header && !imported,'Export file has more than one header line');
-        assert(line.format==='urlcode.links.v1' && line.schemaVersion===1 && line.applicationId===1431456835,
-          'Unsupported export format, schema version or store identity');
-        header=line;continue;
-      }
-      assert(header,'Export records precede the header line');
-      assert(isRecord(line.record),'Unsupported export line');
-      const collection=linkCollection(line.record.collection),code=linkCode(line.record.code);
-      // Restore into empty collections only: this never overwrites live records.
-      if(!counts.has(collection)){
-        assert((await store.list(collection,{limit:1})).length===0,'Target collection already contains records');
-        counts.set(collection,0);
-      }
-      await store.create(collection,linkData({url:line.record.url,status:line.record.status,enabled:line.record.enabled,expires:line.record.expires}),code);
-      counts.set(collection,(counts.get(collection)??0)+1);imported++;
-    }
-  } finally { stream.destroy(); }
-  assert(complete,'Export file has no completion line; it is truncated');
-  // Versions and audit revisions are reassigned by this store, so management
-  // ETags taken against the exported database do not survive a restore.
-  return {event:'link-import-complete',imported,collections:Object.fromEntries(counts),
-    source:{revision:header?.revision,generatedAt:header?.generatedAt,sha256:complete.sha256},versionsReassigned:true};
-}

package/dist/link-events.js

@@ -1,76 +0,0 @@
-import {assert} from './errors.js';
-
-                                                                                              
-                                                                                                                                             
-                                                                                                                                            
-                                                                                                                               
-                                                    
-
-// Trusted-operator observation of finished link requests. The observer is
-// supplied by the embedding operator process, never by route YAML or guest
-// code, and it runs after the response is over: it can never change, delay or
-// fail a redirect. Work is bounded by an explicit queue; overload drops events
-// and counts the drops rather than growing memory behind the operator's back.
-const outcomes=new Set(['completed','aborted','missing','disabled','expired','invalid_code','invalid_record','unavailable']);
-export function createLinkObserver(options         , log      = () => {})                           {
-  if(options===undefined)return undefined;
-  assert(options && typeof options==='object' && !Array.isArray(options),'Link events must be an options object');
-  const {observe,includeCode=false,maxQueue=256,timeoutMs=1000}=options                                ;
-  assert(Object.keys(options).every(key=>['observe','includeCode','maxQueue','timeoutMs'].includes(key)),'Unsupported link event option');
-  assert(typeof observe==='function','Link events require an observe(event) function');
-  assert(typeof includeCode==='boolean','Link event code disclosure must be a boolean');
-  assert(Number.isInteger(maxQueue)&&maxQueue>=1&&maxQueue<=4096,'Link event queue must be 1–4096');
-  assert(Number.isInteger(timeoutMs)&&timeoutMs>=1&&timeoutMs<=10000,'Link event timeout must be 1–10000 ms');
-  const queue             =[];
-  let delivered=0,dropped=0,failed=0,timedOut=0,closed=false,draining                         ;
-  const report     =event=>{try{log(event);}catch{/* Logging cannot fail the observer. */}};
-  async function deliver(event           )                {
-    let timer                                         ;
-    try {
-      // A slow collector must not pin the queue: the budget is per event and the
-      // observer keeps running afterwards, whatever the abandoned call does.
-      await Promise.race([
-        Promise.resolve(observe (event)),
-        new Promise((_resolve,reject)=>{timer=setTimeout(()=>reject(new Error('timeout')),timeoutMs);timer.unref?.();}),
-      ]);
-      delivered++;
-    } catch(error) {
-      failed++;
-      const timeout=(error                                      )?.message==='timeout';
-      if(timeout)timedOut++;
-      report({event:'link_observer',status:'failed',reason:timeout?'timeout':'error'});
-    } finally { clearTimeout(timer); }
-  }
-  async function pump()                {
-    if(draining)return;
-    draining=(async()=>{while(queue.length)await deliver(queue.shift() );})();
-    try{await draining;}finally{draining=undefined;}
-  }
-  return {
-    // Called from the request path. It must stay synchronous and total.
-    emit(event           )       {
-      try {
-        if(closed||!outcomes.has(event.outcome)){dropped++;return;}
-        if(queue.length>=maxQueue){
-          dropped++;
-          if(dropped===1||dropped%maxQueue===0)report({event:'link_observer',status:'dropped',dropped});
-          return;
-        }
-        const {code:_code,...redacted}=event;
-        queue.push(includeCode?{...event}:redacted);
-        void pump();
-      } catch { dropped++; }
-    },
-    stats:()=>({queued:queue.length,delivered,dropped,failed,timedOut,closed}),
-    async close()                             {
-      closed=true;
-      // Drain what was already accepted, then stop; a stuck collector cannot
-      // hold shutdown open past its own per-event budget plus this deadline.
-      void pump();
-      const deadline=new Promise         (resolve=>{const timer=setTimeout(()=>resolve(false),timeoutMs*2+1000);timer.unref?.();});
-      while(draining)if(!await Promise.race([draining.then(()=>true,()=>true),deadline]))break;
-      dropped+=queue.length;queue.length=0;
-      return this.stats();
-    },
-  };
-}

package/dist/link-records.js

@@ -1,31 +0,0 @@
-import {randomBytes} from 'node:crypto';
-import {HttpError} from './errors.js';
-                                                                                                     
-const check                                                     = (value,message) => { if(!value)throw new HttpError(400,message); };
-export function linkCollection(value         )         {
-  check(typeof value==='string' && /^[A-Za-z][A-Za-z0-9_-]{0,63}$/.test(value),'Invalid link collection');return value;
-}
-export function linkCode(value         )         {
-  check(typeof value==='string' && /^[A-Za-z0-9_-]{1,128}$/.test(value),'Invalid short code');return value;
-}
-export function linkVersion(value         )         {
-  check(typeof value==='number' && Number.isSafeInteger(value) && value>0,'A positive expected version is required');return value;
-}
-export function linkData(value         )             {
-  check(value && typeof value==='object' && !Array.isArray(value),'Invalid link record');
-  check(Object.keys(value).every(k=>['url','status','enabled','expires'].includes(k)),'Unsupported link field');
-  const record=value                                                                           ;
-  check(typeof record.url==='string' && record.url.length<=8192 && !/[\s\u0000-\u001f\u007f\\]/u.test(record.url),'Invalid destination');
-  let url     ;try{url=new URL(record.url);}catch{throw new HttpError(400,'Invalid destination');}
-  check(['http:','https:'].includes(url.protocol) && !url.username && !url.password,'Destination must be HTTP(S) without credentials');
-  check(Buffer.byteLength(url.href)<=8192,'Destination exceeds 8192 bytes');
-  const status=record.status??302,enabled=record.enabled??true,expires=record.expires??null;
-  check(typeof status==='number' && [301,302,303,307,308].includes(status),'Invalid redirect status');
-  check(typeof enabled==='boolean','Invalid enabled flag');
-  if(expires!==null){
-    check(typeof expires==='string' && /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{3})?Z$/.test(expires) && Number.isFinite(Date.parse(expires)),'Invalid expiry');
-    check(new Date(expires).toISOString().replace('.000Z','Z')===expires.replace('.000Z','Z'),'Invalid expiry');
-  }
-  return {url:url.href,status,enabled,expires};
-}
-export const randomLinkCode=()        =>randomBytes(12).toString('base64url');

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'}});}
-});