gemi 0.188.0 → 0.189.0

package/dist/{chunk-m8y3y6sw.js → chunk-p23sctqt.js}

@@ -1,5 +1,5 @@
 // @bun
 var j=globalThis.__GEMI_DICTIONARY_REGISTRY__??={registry:new Map,resolved:new Map,inFlight:new Map,renderThenables:new Map,order:[],warmed:new Map,activeLocale:null},{registry:W,resolved:Z,inFlight:V,renderThenables:I,order:E,warmed:X}=j;function N(q,x){return`${q}\x00${x}`}function D(q){if(W.has(q.id))return;W.set(q.id,q),E.push(q.id)}function H(){return E.length}function P(q,x){return Z.get(q)?.get(x)}function $(q,x,A){let z=Z.get(q);if(!z)z=new Map,Z.set(q,z);z.set(x,A)}function U(q,x){let A=P(q,x);if(A)return A;let z=N(q,x),C=V.get(z);if(C)return C;let B=W.get(q);if(!B)throw Error(`Unknown dictionary "${q}". A dictionary must be created with defineDictionary() and its module must have been evaluated before it is read.`);let J=B.load(x);if(!(J instanceof Promise))return $(q,x,J),J;let O=J.then((Q)=>{return $(q,x,Q),V.delete(z),Q},(Q)=>{throw V.delete(z),Q});return V.set(z,O),O}function K(q,x){let A=N(q,x),z=P(q,x),C=I.get(A);if(C&&!(C.degraded&&z))return C;if(z)return G(A,M(z,!C));let B=U(q,x);if(!(B instanceof Promise))return G(A,M(B,!0));let J=B.then((O)=>O,(O)=>{return console.error(`Failed to load dictionary ${q} for locale ${x}; rendering keys instead.`,O),J.degraded=!0,Y});return G(A,J)}function G(q,x){return I.set(q,x),x}function M(q,x){return Object.assign(Promise.resolve(q),{status:"fulfilled",value:q,inHand:x?q:void 0})}var Y={};async function S(q,x){let A=x??X.get(q)??0,z=E.slice(A);if(z.length===0)return;let C=await Promise.all(z.map(async(B)=>{try{return await U(B,_(B,q)),!0}catch{return!1}}));if(x===void 0){let B=C.indexOf(!1),J=B===-1?z.length:B;X.set(q,Math.max(X.get(q)??0,A+J))}}function _(q,x){if(x)return x;return W.get(q)?.locales[0]??x}function L(q,x){if(!q)return;for(let[A,z]of Object.entries(q))$(A,x,z)}function R(q){if(q)j.activeLocale=q}function w(){return j.activeLocale}if(typeof window<"u"){let q=window,x=([z,C,B])=>{$(z,C,B)},A=Array.isArray(q.__GEMI_DICT__)?q.__GEMI_DICT__:[];q.__GEMI_DICT__={push:x};for(let z of A)x(z)}function F(){W.clear(),Z.clear(),V.clear(),I.clear(),X.clear(),E.length=0,j.activeLocale=null}function f(){let q=new Set,x=[],A=[];return{use(z,C,B){let J=`${z} ${C}`;if(q.has(J))return;q.add(J);let O={id:z,locale:C,strings:B};if(x.length===0){A.push(O);return}for(let Q of x)Q(O)},onUse(z){x.push(z);while(A.length>0)z(A.shift())}}}
-export{D as Pk,H as Qk,U as Rk,K as Sk,S as Tk,L as Uk,R as Vk,w as Wk,F as Xk,f as Yk};
+export{D as Qk,H as Rk,U as Sk,K as Tk,S as Uk,L as Vk,R as Wk,w as Xk,F as Yk,f as Zk};
 
-//# debugId=4773CF24A355C40B64756E2164756E21
+//# debugId=5C77BF8B2254A95D64756E2164756E21

package/dist/{chunk-m8y3y6sw.js.map → chunk-p23sctqt.js.map}

@@ -6,6 +6,6 @@
     "import type { LocaleStrings } from \"./dictionaryShape\";\n\n/**\n * Collects the dictionaries one SSR render actually read.\n *\n * Scoped per request by living in React context rather than in module state: a\n * streaming server has several renders in flight at once, so a module-level\n * collector would mix one page's dictionaries into another's payload. Context\n * is per render tree, which is exactly the boundary wanted, and it needs no\n * async-local storage to survive React's internal scheduling.\n *\n * Why stream these rather than put them in `__GEMI_DATA__`: that snapshot is\n * serialized before `renderToReadableStream` is even called, and which\n * dictionaries a page reads is only known once it has rendered. A suspended\n * segment reveals later still, long after the shell has flushed.\n *\n * The sink deliberately emits data, not markup — `streamQueryInjection` owns\n * script formatting and the `</script>`-safe encoding that goes with it.\n */\nexport interface DictionaryUse {\n  id: string;\n  locale: string;\n  strings: LocaleStrings;\n}\n\nexport interface DictionarySink {\n  /** Called during render, the first time a dictionary is read. */\n  use(id: string, locale: string, strings: LocaleStrings): void;\n  /** The response injector subscribes to receive uses as they happen. */\n  onUse(cb: (use: DictionaryUse) => void): void;\n}\n\nexport function createDictionarySink(): DictionarySink {\n  const seen = new Set<string>();\n  const listeners: Array<(use: DictionaryUse) => void> = [];\n  // Uses recorded before the injector subscribed — the render begins before the\n  // response stream is wrapped.\n  const pending: DictionaryUse[] = [];\n\n  return {\n    use(id, locale, strings) {\n      const key = `${id} ${locale}`;\n      if (seen.has(key)) return;\n      seen.add(key);\n      const entry: DictionaryUse = { id, locale, strings };\n      if (listeners.length === 0) {\n        pending.push(entry);\n        return;\n      }\n      for (const listener of listeners) listener(entry);\n    },\n    onUse(cb) {\n      listeners.push(cb);\n      while (pending.length > 0) {\n        cb(pending.shift()!);\n      }\n    },\n  };\n}\n"
   ],
   "mappings": "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",
-  "debugId": "4773CF24A355C40B64756E2164756E21",
+  "debugId": "5C77BF8B2254A95D64756E2164756E21",
   "names": []
 }

package/dist/{chunk-jsbq8qq0.js → chunk-pebp4an8.js}

@@ -1,5 +1,5 @@
 // @bun
-import{Nl as P}from"./chunk-jmgjhfya.js";class F{provider="custom";supportsIdempotencyKey=!1;async deliver(j){let x=await this.send(j);return{ok:Boolean(x),id:null}}}class G extends F{apiKey;provider="resend";supportsIdempotencyKey=!0;constructor(j=process.env.RESEND_API_KEY){super();this.apiKey=j}async send(j){return(await this.deliver(j)).ok}async deliver(j){let{Resend:x}=await import("./chunk-vmax8gjr.js"),A=new x(this.apiKey),{idempotencyKey:z,...N}=j,{data:H,error:B}=await A.emails.send(N,z?{idempotencyKey:z}:void 0);if(B)return console.error(B),{ok:!1,id:null,error:B};if(H)return{ok:!0,id:H.id??null};return{ok:!1,id:null}}}function Z(j){return j}function J(){return{driver:new G,headers:{},filterRecipients:(j)=>j}}function Q(j){for(let x=j;x;x=Object.getPrototypeOf(x)){let A=Object.prototype.hasOwnProperty.call(x,"deliver"),z=Object.prototype.hasOwnProperty.call(x,"send");if(A)return!1;if(z)return!0}return!0}async function M(j,x){if(typeof j.deliver==="function"&&!Q(j))return j.deliver(x);return{ok:Boolean(await j.send(x)),id:null}}class U{static token="mail";driver;headers;recipientFilter;constructor(j={}){let x=J();this.driver=j.driver??x.driver,this.headers=j.headers??x.headers,this.recipientFilter=j.filterRecipients??x.filterRecipients}filterRecipients(j){return this.recipientFilter(j)}send(j){return this.driver.send(j)}async deliver(j){return M(this.driver,j)}}
-export{F as Zk,G as _k,Z as $k,J as al,M as bl,U as cl};
+import{Ol as P}from"./chunk-7wkwm0tn.js";class F{provider="custom";supportsIdempotencyKey=!1;async deliver(j){let x=await this.send(j);return{ok:Boolean(x),id:null}}}class G extends F{apiKey;provider="resend";supportsIdempotencyKey=!0;constructor(j=process.env.RESEND_API_KEY){super();this.apiKey=j}async send(j){return(await this.deliver(j)).ok}async deliver(j){let{Resend:x}=await import("./chunk-4ze3f6vh.js"),A=new x(this.apiKey),{idempotencyKey:z,...N}=j,{data:H,error:B}=await A.emails.send(N,z?{idempotencyKey:z}:void 0);if(B)return console.error(B),{ok:!1,id:null,error:B};if(H)return{ok:!0,id:H.id??null};return{ok:!1,id:null}}}function Z(j){return j}function J(){return{driver:new G,headers:{},filterRecipients:(j)=>j}}function Q(j){for(let x=j;x;x=Object.getPrototypeOf(x)){let A=Object.prototype.hasOwnProperty.call(x,"deliver"),z=Object.prototype.hasOwnProperty.call(x,"send");if(A)return!1;if(z)return!0}return!0}async function M(j,x){if(typeof j.deliver==="function"&&!Q(j))return j.deliver(x);return{ok:Boolean(await j.send(x)),id:null}}class U{static token="mail";driver;headers;recipientFilter;constructor(j={}){let x=J();this.driver=j.driver??x.driver,this.headers=j.headers??x.headers,this.recipientFilter=j.filterRecipients??x.filterRecipients}filterRecipients(j){return this.recipientFilter(j)}send(j){return this.driver.send(j)}async deliver(j){return M(this.driver,j)}}
+export{F as _k,G as $k,Z as al,J as bl,M as cl,U as dl};
 
-//# debugId=4695BD0DC7D072D964756E2164756E21
+//# debugId=DA2C2DD466EB5B1D64756E2164756E21

package/dist/{chunk-jsbq8qq0.js.map → chunk-pebp4an8.js.map}

@@ -9,6 +9,6 @@
     "import { mailConfigDefaults, type MailConfig } from \"./config\";\nimport { deliverThrough } from \"./deliver\";\nimport type { EmailDriver } from \"./drivers/EmailDriver\";\nimport type { EmailDeliveryResult, SendEmailParams } from \"./drivers/types\";\n\nexport class MailManager {\n  static token = \"mail\";\n\n  readonly driver: EmailDriver;\n  readonly headers: Record<string, string>;\n\n  private readonly recipientFilter: NonNullable<MailConfig[\"filterRecipients\"]>;\n\n  constructor(config: MailConfig = {}) {\n    const defaults = mailConfigDefaults();\n\n    this.driver = config.driver ?? defaults.driver;\n    this.headers = config.headers ?? defaults.headers;\n    this.recipientFilter = config.filterRecipients ?? defaults.filterRecipients;\n  }\n\n  filterRecipients(emails: string[]): Promise<Array<string>> | Array<string> {\n    return this.recipientFilter(emails);\n  }\n\n  send(params: SendEmailParams) {\n    return this.driver.send(params);\n  }\n\n  /** Like `send`, but reports the outcome and the provider's message id. */\n  async deliver(params: SendEmailParams): Promise<EmailDeliveryResult> {\n    // A driver that doesn't extend `EmailDriver`, or a subclass that only\n    // overrides `send`, is called through `send`.\n    return deliverThrough(this.driver, params);\n  }\n}\n"
   ],
   "mappings": ";yCAEO,MAAe,CAAY,CAKvB,SAAmB,SAMnB,uBAAkC,QASrC,QAAO,CAAC,EAAuD,CACnE,IAAM,EAAK,MAAM,KAAK,KAAK,CAAM,EACjC,MAAO,CAAE,GAAI,QAAQ,CAAE,EAAG,GAAI,IAAK,EAEvC,CCvBO,MAAM,UAAqB,CAAY,CAIxB,OAHF,SAAW,SACX,uBAAyB,GAE3C,WAAW,CAAS,EAAS,QAAQ,IAAI,eAAgB,CACvD,MAAM,EADY,mBAId,KAAI,CAAC,EAAyB,CAClC,OAAQ,MAAM,KAAK,QAAQ,CAAM,GAAG,QAGvB,QAAO,CAAC,EAAuD,CAO5E,IAAQ,UAAW,KAAa,+BAC1B,EAAS,IAAI,EAAO,KAAK,MAAM,GAG7B,oBAAmB,GAAY,GAC/B,OAAM,SAAU,MAAM,EAAO,OAAO,KAC1C,EACA,EAAiB,CAAE,gBAAe,EAAI,MACxC,EAEA,GAAI,EAEF,OADA,QAAQ,MAAM,CAAK,EACZ,CAAE,GAAI,GAAO,GAAI,KAAM,OAAM,EAGtC,GAAI,EACF,MAAO,CAAE,GAAI,GAAM,GAAI,EAAK,IAAM,IAAK,EAGzC,MAAO,CAAE,GAAI,GAAO,GAAI,IAAK,EAEjC,CC7BO,SAAS,CAAgB,CAAC,EAAgC,CAC/D,OAAO,EAGF,SAAS,CAAkB,EAAyB,CACzD,MAAO,CACL,OAAQ,IAAI,EACZ,QAAS,CAAC,EACV,iBAAkB,CAAC,IAAW,CAChC,ECVF,SAAS,CAAgB,CAAC,EAAgB,CACxC,QAAS,EAAQ,EAAQ,EAAO,EAAQ,OAAO,eAAe,CAAK,EAAG,CACpE,IAAM,EAAa,OAAO,UAAU,eAAe,KAAK,EAAO,SAAS,EAClE,EAAU,OAAO,UAAU,eAAe,KAAK,EAAO,MAAM,EAClE,GAAI,EAAY,MAAO,GACvB,GAAI,EAAS,MAAO,GAEtB,MAAO,GAOT,eAAsB,CAAc,CAClC,EACA,EAC8B,CAC9B,GAAI,OAAO,EAAO,UAAY,YAAc,CAAC,EAAiB,CAAM,EAClE,OAAO,EAAO,QAAQ,CAAM,EAE9B,MAAO,CAAE,GAAI,QAAQ,MAAM,EAAO,KAAK,CAAM,CAAC,EAAG,GAAI,IAAK,EC7BrD,MAAM,CAAY,OAChB,OAAQ,OAEN,OACA,QAEQ,gBAEjB,WAAW,CAAC,EAAqB,CAAC,EAAG,CACnC,IAAM,EAAW,EAAmB,EAEpC,KAAK,OAAS,EAAO,QAAU,EAAS,OACxC,KAAK,QAAU,EAAO,SAAW,EAAS,QAC1C,KAAK,gBAAkB,EAAO,kBAAoB,EAAS,iBAG7D,gBAAgB,CAAC,EAA0D,CACzE,OAAO,KAAK,gBAAgB,CAAM,EAGpC,IAAI,CAAC,EAAyB,CAC5B,OAAO,KAAK,OAAO,KAAK,CAAM,OAI1B,QAAO,CAAC,EAAuD,CAGnE,OAAO,EAAe,KAAK,OAAQ,CAAM,EAE7C",
-  "debugId": "4695BD0DC7D072D964756E2164756E21",
+  "debugId": "DA2C2DD466EB5B1D64756E2164756E21",
   "names": []
 }

package/dist/{chunk-24vv42t6.js → chunk-pme2yb8p.js}

@@ -1,9 +1,9 @@
 // @bun
-import{Ck as Y,Jk as K,Mk as y}from"./chunk-kzny5cj2.js";import{AsyncLocalStorage as U}from"async_hooks";var z=new U;function O(){return z.getStore()?.tx}function _(){return z.getStore()?.connection??K}function h(j,q){let v=z.getStore();if(_()===j)return q();return F(j),z.run({...v,depth:v?.depth??0,connection:j===K?void 0:j},q)}function F(j){let q=z.getStore();if(q?.tx===void 0)return;let v=q.connection??K;if(v===j)return;throw new y(v,j)}function A(j){let q=z.getStore();if(q?.tx===void 0||q.afterCommit===void 0)return!1;let v=Z.get(q.afterCommit);if(v==="committed")return!1;if(v==="rolled_back")return!0;return q.afterCommit.push(j),!0}var Z=new WeakMap;function k(j){if(A(j))return Promise.resolve();let q=(v)=>{console.error("An after-commit callback threw. No transaction was open, so it ran immediately.",v)};try{return Promise.resolve(j()).catch(q)}catch(v){return q(v),Promise.resolve()}}function N(j){let q=z.getStore();if(q?.tx===void 0||q.commitDependsOn===void 0)return!1;return q.commitDependsOn.push(j),!0}class I extends Error{constructor(j){super(`A statement this transaction depended on failed after being issued on it, so the transaction rolled back instead of committing: ${j instanceof Error?j.message:String(j)}`,{cause:j});this.name="TransactionDependencyError"}}async function W(j,q){if(j.length===q)return;let B=(await Promise.allSettled(j.slice(q))).find((J)=>J.status==="rejected");if(B)throw new I(B.reason)}function T(){let j=z.getStore();return j?.tx===void 0?null:j.depth}function x(){return z.getStore()?.system===!0}function p(j){let q=z.getStore();return z.run({...q,depth:q?.depth??0,system:!0},j)}function f(j){return z.getStore()?.trashed?.get(j)}function C(j,q,v){let B=z.getStore(),J=new Map(B?.trashed);return J.set(j,q),z.run({...B,depth:B?.depth??0,trashed:J},v)}function l(){return z.getStore()?.actor}function u(j,q){let v=z.getStore();return z.run({...v,depth:v?.depth??0,system:!1,actor:{user:j??null}},q)}function D(j){if(Bun.env.NODE_ENV!=="development")return null;if(j===!1)return null;if(j===void 0)return Y;if(!Number.isFinite(j)||j<=0)return Y;return j}function w(j){let q=D(j);if(q===null)return()=>{};let v=Error("transaction opened here"),B=setTimeout(()=>{let J=v.stack?.split(`
+import{Dk as Y,Kk as K,Nk as y}from"./chunk-9fpecjxg.js";import{AsyncLocalStorage as U}from"async_hooks";var z=new U;function O(){return z.getStore()?.tx}function _(){return z.getStore()?.connection??K}function h(j,q){let v=z.getStore();if(_()===j)return q();return F(j),z.run({...v,depth:v?.depth??0,connection:j===K?void 0:j},q)}function F(j){let q=z.getStore();if(q?.tx===void 0)return;let v=q.connection??K;if(v===j)return;throw new y(v,j)}function A(j){let q=z.getStore();if(q?.tx===void 0||q.afterCommit===void 0)return!1;let v=Z.get(q.afterCommit);if(v==="committed")return!1;if(v==="rolled_back")return!0;return q.afterCommit.push(j),!0}var Z=new WeakMap;function k(j){if(A(j))return Promise.resolve();let q=(v)=>{console.error("An after-commit callback threw. No transaction was open, so it ran immediately.",v)};try{return Promise.resolve(j()).catch(q)}catch(v){return q(v),Promise.resolve()}}function N(j){let q=z.getStore();if(q?.tx===void 0||q.commitDependsOn===void 0)return!1;return q.commitDependsOn.push(j),!0}class I extends Error{constructor(j){super(`A statement this transaction depended on failed after being issued on it, so the transaction rolled back instead of committing: ${j instanceof Error?j.message:String(j)}`,{cause:j});this.name="TransactionDependencyError"}}async function W(j,q){if(j.length===q)return;let B=(await Promise.allSettled(j.slice(q))).find((J)=>J.status==="rejected");if(B)throw new I(B.reason)}function T(){let j=z.getStore();return j?.tx===void 0?null:j.depth}function x(){return z.getStore()?.system===!0}function p(j){let q=z.getStore();return z.run({...q,depth:q?.depth??0,system:!0},j)}function f(j){return z.getStore()?.trashed?.get(j)}function C(j,q,v){let B=z.getStore(),J=new Map(B?.trashed);return J.set(j,q),z.run({...B,depth:B?.depth??0,trashed:J},v)}function l(){return z.getStore()?.actor}function u(j,q){let v=z.getStore();return z.run({...v,depth:v?.depth??0,system:!1,actor:{user:j??null}},q)}function D(j){if(Bun.env.NODE_ENV!=="development")return null;if(j===!1)return null;if(j===void 0)return Y;if(!Number.isFinite(j)||j<=0)return Y;return j}function w(j){let q=D(j);if(q===null)return()=>{};let v=Error("transaction opened here"),B=setTimeout(()=>{let J=v.stack?.split(`
 `).slice(1).join(`
 `)??"";console.warn(`[gemi] A database transaction has not settled after ${q}ms. It `+"reserves a pooled connection until it does \u2014 check for network or "+`filesystem I/O inside the callback, and move it outside the transaction if you find any.
 ${J}
 (development only; set database.slowTransactionThreshold to change the threshold, or false to switch this off)`)},q);return B.unref?.(),()=>clearTimeout(B)}async function L(j,q){if(j.length===0)return;await z.run({...q,tx:void 0,afterCommit:void 0,commitDependsOn:void 0,depth:q?.depth??0},async()=>{for(let v of j)try{await v()}catch(B){console.error("An after-commit callback threw. The transaction it was waiting on had already committed and stays committed, and the callbacks after it still ran.",B)}})}function m(j,q,v){let B=z.getStore(),J=v?.connection??K;if(F(J),B?.tx){let G=B.afterCommit,V=G?.length??0,P=B.commitDependsOn,H=P?.length??0;return B.tx.savepoint((X)=>{let R=X;return z.run({...B,tx:R,depth:B.depth+1},async()=>{let S=await q(R);if(P)await W(P,H);return S})}).catch((X)=>{if(G)G.length=V;if(P)P.length=H;throw X})}let $=w(v?.slowTransactionThreshold),Q=[],M=[];try{return j.begin((G)=>z.run({...B,tx:G,depth:0,connection:J===K?void 0:J,afterCommit:Q,commitDependsOn:M},async()=>{let V=await q(G);return await W(M,0),V})).finally($).then(async(G)=>{return Z.set(Q,"committed"),await L(Q,B),G},(G)=>{throw Z.set(Q,"rolled_back"),G})}catch(G){throw $(),G}}
-export{z as jk,O as kk,_ as lk,h as mk,F as nk,A as ok,k as pk,N as qk,I as rk,T as sk,x as tk,p as uk,f as vk,C as wk,l as xk,u as yk,m as zk};
+export{z as kk,O as lk,_ as mk,h as nk,F as ok,A as pk,k as qk,N as rk,I as sk,T as tk,x as uk,p as vk,f as wk,C as xk,l as yk,u as zk,m as Ak};
 
-//# debugId=3BE9453EB47BCF2164756E2164756E21
+//# debugId=AE3625C3098D084464756E2164756E21

package/dist/{chunk-24vv42t6.js.map → chunk-pme2yb8p.js.map}

@@ -5,6 +5,6 @@
     "import type { SQL, TransactionSQL } from \"bun\";\nimport { AsyncLocalStorage } from \"node:async_hooks\";\nimport { SLOW_TRANSACTION_THRESHOLD } from \"../database/config\";\nimport {\n  CrossConnectionTransactionError,\n  DEFAULT_CONNECTION,\n} from \"../database/Connection\";\n\n/**\n * The ambient transaction: the ORM's own `AsyncLocalStorage`, holding nothing\n * but the open handle and how deep the nesting is.\n *\n * One store per scope with one owner, which is the pattern the framework\n * already follows — `kernel/context.ts` holds the Application,\n * `http/requestContext.ts` the request and its user. The reasoning for\n * not folding this into the kernel's is written up beside it, and the short\n * version is that a transaction scope has to *nest inside* an Application scope\n * without replacing it, and `foundation/app.ts` must keep reading exactly one\n * shape out of the kernel store or resolving a service becomes a transaction\n * concern.\n *\n * What makes an ALS the right home rather than a field somewhere: two concurrent\n * requests each in their own transaction must never see each other's handle.\n * Anything reachable from the Application — which is one object shared by every\n * in-flight request — fails that by construction, and fails it as silently\n * written data, not as an error. \"two concurrent transactions never see each\n * other's handle\" in `context.test.ts` is the test that would catch it.\n */\nexport interface OrmScope {\n  /**\n   * Bun's transaction handle. Every ORM statement in scope runs on it, which\n   * means they all run on one reserved connection — so nothing here may issue\n   * two statements concurrently. `Model.$exec` already runs its nested writes\n   * and its relation reads sequentially, for exactly this reason.\n   */\n  tx?: TransactionSQL;\n  /** 0 for the outermost transaction, 1+ for each savepoint inside it. */\n  depth: number;\n  /**\n   * Which named connection this subtree's queries run on, and — when `tx` is\n   * set — which connection the open transaction belongs to.\n   *\n   * Ambient rather than an argument threaded through `$exec`, for the same\n   * reason the handle above is: a relation read resolves its target through the\n   * registry and calls that class's `$exec`, so an argument would have to be\n   * carried by every intermediate that has no interest in it, and the one that\n   * forgot would silently read a nested `include` off the *other* pool. There\n   * is no error that shape produces; there are just rows from the wrong place.\n   *\n   * `undefined` means the default connection. Kept as absent-rather-than-\n   * `\"default\"` so that entering a scope on the default connection is\n   * indistinguishable from not entering one, which is what makes the\n   * cross-connection check below cost a comparison of two `undefined`s on every\n   * application that never declares a second connection.\n   */\n  connection?: string;\n  /**\n   * Whether policies are suspended for this scope. Set only by\n   * `Model.asSystem`, and never by anything ambient — the whole point is that\n   * unscoped access is a decision visible at the call site, not the accidental\n   * result of a missing user.\n   */\n  system?: boolean;\n  /**\n   * The user policies should scope to, when there is no request to read one\n   * from. Set only by `Model.asUser`.\n   *\n   * A sentinel wrapper rather than the bare value, so that \"a scope was entered\n   * with `null`\" stays distinguishable from \"no scope was entered\" — the two\n   * mean different things under deny-by-default.\n   */\n  actor?: { user: unknown };\n  /**\n   * Work that must not happen unless this transaction commits — an event whose\n   * `static afterCommit` is set, today, and nothing else.\n   *\n   * **Created by the outermost `withTransaction` and never by a savepoint.** A\n   * savepoint's scope is a spread of its parent's (`{ ...current, tx: nested }`),\n   * so the array arrives here already shared by reference with the transaction\n   * that opened it — which is the behaviour wanted rather than a leak. A\n   * dispatch made inside a savepoint that commits, in a transaction that then\n   * rolls back, must not run: rolling back the outermost transaction discards\n   * the list whole, savepoint entries included, because nothing ever drains it.\n   *\n   * The inverse — a savepoint that rolls back under a transaction that commits\n   * — is the case sharing gets wrong on its own, and `withTransaction`'s\n   * savepoint branch is where it is put right.\n   *\n   * Absent, rather than an empty array, on every scope that is not a\n   * transaction: `runAsSystem`, `runAsUser` and `runOnConnection` spread\n   * whatever they are given, so \"there is a list here\" and \"there is an open\n   * transaction here\" have to stay the same question. `deferUntilCommit`\n   * answers `false` when either half is missing and the caller runs the work\n   * now, which is what keeps a hand-built scope carrying a `tx` — the shape\n   * tests write — from swallowing a dispatch into a list nothing drains.\n   */\n  afterCommit?: AfterCommitCallback[];\n  /**\n   * Statements written on `tx` that the commit must wait for and must not\n   * outlive — today, a job row the database queue driver wrote on the\n   * transaction (#563), and nothing else. See `commitDependsOn`.\n   *\n   * Created and shared exactly as `afterCommit` is, and truncated with it\n   * when a savepoint rolls back.\n   */\n  commitDependsOn?: Promise<unknown>[];\n  /**\n   * Models whose soft-delete scope (`static $softDeletes`) is lifted or\n   * inverted for this async subtree, by name — set only by\n   * `Model.withTrashed(fn)` / `Model.onlyTrashed(fn)`.\n   *\n   * Keyed by model name rather than class because a nested relation read\n   * resolves its target through the registry by name, and the block has to\n   * reach those reads too. A fresh map per block, never mutated, so an inner\n   * block cannot leak its entry back into the enclosing one.\n   */\n  trashed?: ReadonlyMap<string, TrashedMode>;\n}\n\n/**\n * How a soft-deleted model's trashed rows are treated: `\"with\"` includes them,\n * `\"only\"` reads nothing else. Absent means the default — they are hidden.\n */\nexport type TrashedMode = \"with\" | \"only\";\n\n/**\n * Work deferred to a transaction's commit.\n *\n * Awaited when it is drained, and its rejection is caught there: a callback is\n * a side effect that the transaction is not waiting on and cannot be told\n * about, so the only thing left to do with a failure is report it.\n *\n * Not exported: a caller passes a lambda and never names this, and an export\n * nothing outside this file uses is what `orm/architecture.test.ts` is pointed\n * at. The declaration emit carries it along regardless, so `OrmScope` stays\n * readable from a `.d.ts`.\n */\ntype AfterCommitCallback = () => void | Promise<void>;\n\n/**\n * One ambient scope for the ORM, not one per feature.\n *\n * Transactions (iteration 5) and system access (iteration 6) are both\n * \"something is true for this async subtree and every query in it\", so they\n * share a store rather than minting a second `AsyncLocalStorage` each. The\n * inventory note in `kernel/context.ts` sets the bar for adding one; two\n * booleans-worth of ORM state does not clear it.\n */\nexport const ormContext = new AsyncLocalStorage<OrmScope>();\n\n/**\n * The open transaction, or `undefined` outside one. This is what `Model.$exec`\n * consults to decide which connection a statement runs on.\n *\n * Exported as the escape hatch for code that genuinely needs the handle — a raw\n * query that must join the surrounding transaction, say. **Do not store what it\n * returns.** Bun's handle stays callable after its `begin` resolves: queries on\n * it then run on the pooled connection, outside any transaction, and succeed.\n * Verified against both dialects, and it is the reason `Model.transaction`'s\n * callback takes no argument.\n */\nexport function currentTransaction(): TransactionSQL | undefined {\n  return ormContext.getStore()?.tx;\n}\n\n/**\n * The connection every query in this scope runs on unless it names another.\n *\n * `\"default\"` outside any scope, so callers get a name rather than a\n * `string | undefined` to normalise themselves — the store keeps it absent,\n * which is not the same distinction and is nobody else's business.\n */\nexport function currentConnectionName(): string {\n  return ormContext.getStore()?.connection ?? DEFAULT_CONNECTION;\n}\n\n/**\n * Run `fn` with `name` as the ambient connection.\n *\n * Merged into the current scope rather than replacing it, exactly as\n * `runAsSystem` and `runAsUser` are: naming a connection must not drop an open\n * transaction handle or re-enable policies underneath it.\n *\n * Deliberately absent from `orm/index.ts`, so it is not part of what an\n * application can reach — `Model.on(name)` and `DB.connection(name)` are the\n * two doors, and both funnel through here so that a nested relation read,\n * which resolves its own class out of the registry and calls its `$exec`,\n * inherits the connection without anything having to pass it along.\n */\nexport function runOnConnection<T>(\n  name: string,\n  fn: () => Promise<T>,\n): Promise<T> {\n  const current = ormContext.getStore();\n  if (currentConnectionName() === name) return fn();\n\n  // ENTERING A CONNECTION IS WHERE THE CROSS-CONNECTION CHECK BELONGS, not at\n  // each door — and it has to be *here*, before the scope is entered, because\n  // entering it is what makes the check impossible afterwards.\n  //\n  // The scope carries `tx` and `connection` together, so overwriting the name\n  // while an open handle stays in place produces a store that says \"a\n  // transaction on analytics\" while holding the *default* connection's handle.\n  // Every check downstream then agrees with itself and the statement runs on\n  // the wrong connection's transaction. `Model.save` found this: it routes to\n  // the row's own connection, so it is the one caller that switches connections\n  // with a transaction already open.\n  assertConnectionUsable(name);\n\n  return ormContext.run(\n    {\n      ...current,\n      depth: current?.depth ?? 0,\n      connection: name === DEFAULT_CONNECTION ? undefined : name,\n    },\n    fn,\n  );\n}\n\n/**\n * Refuse a statement that names one connection while a transaction is open on\n * another.\n *\n * The check `withTransaction`'s single-connection note asked for, and the\n * reasoning for refusing rather than routing is on\n * `CrossConnectionTransactionError`. Both doors call it — `Model.$exec` for\n * every model operation, `DB` for a raw fragment — because either one alone\n * leaves the other free to straddle the two connections, and a raw `DB.execute`\n * escaping a transaction is the more damaging of the two.\n *\n * Only ever fires on a query that *names* a connection: an unqualified one\n * resolves to the ambient name, which is the transaction's own.\n */\nexport function assertConnectionUsable(name: string): void {\n  const store = ormContext.getStore();\n  if (store?.tx === undefined) return;\n\n  const open = store.connection ?? DEFAULT_CONNECTION;\n  if (open === name) return;\n\n  throw new CrossConnectionTransactionError(open, name);\n}\n\n/**\n * Hold `callback` until the open transaction commits, and say whether that\n * happened.\n *\n * `false` means there was nothing to wait for — no transaction is open, or the\n * scope was entered by hand rather than by `withTransaction` — and the caller\n * must run the work itself, now. That return value is the whole contract: a\n * caller that ignores it turns \"no transaction here\" into a side effect queued\n * on a list nothing will ever drain, which is a dispatch that silently never\n * happens.\n *\n * `true` means the callback is on the outermost scope's list and will run after\n * `begin` resolves, outside the transaction, whatever the caller does next. It\n * will not run at all if the transaction rolls back, or if a savepoint it was\n * registered inside rolls back — both of which are the point.\n *\n * Nothing here is ordered against anything but the other deferred callbacks:\n * they run in registration order, one at a time, after the commit round-trip.\n */\nexport function deferUntilCommit(callback: AfterCommitCallback): boolean {\n  const store = ormContext.getStore();\n  if (store?.tx === undefined || store.afterCommit === undefined) return false;\n\n  // Async work started inside a transaction and not awaited by it — a sync\n  // listener still awaiting, an un-awaited emit — can reach here after the\n  // transaction settled, through a scope that still carries its handle and its\n  // list. Pushing then would queue onto a list already drained (or discarded),\n  // and the work would silently never run. A committed list answers \"run it\n  // now\"; a rolled-back one keeps the promise that nothing runs.\n  const settled = settledLists.get(store.afterCommit);\n  if (settled === \"committed\") return false;\n  if (settled === \"rolled_back\") return true;\n\n  store.afterCommit.push(callback);\n  return true;\n}\n\n/**\n * How each outermost transaction's after-commit list ended, once it has. Keyed\n * by the list itself, which every savepoint and every lingering async scope of\n * that transaction shares by reference.\n */\nconst settledLists = new WeakMap<AfterCommitCallback[], \"committed\" | \"rolled_back\">();\n\n/**\n * Run `callback` once the open transaction commits, or now when none is open.\n * Never when the transaction rolls back, nor when a savepoint it was\n * registered inside rolls back.\n *\n * The application-facing form of `deferUntilCommit`, exported from `gemi/orm`\n * (#786). The difference is the `false` branch: `deferUntilCommit` hands the\n * \"no transaction\" case back to the caller, who must remember to run the work\n * itself, and this runs it. A caller that wants a side effect only once its\n * writes are durable — waking a long-poll, notifying another process — has\n * nothing left to get wrong.\n *\n * Inside a transaction the callback joins the same list `static afterCommit`\n * events use, so it is drained after `begin` resolves, outside the\n * transaction, in registration order with them.\n *\n * The returned promise resolves once the callback has run (no transaction) or\n * been queued (inside one). It never rejects: a callback that throws is\n * reported on stderr, as a deferred one is at the drain, so a caller that does\n * not await — the usual case — cannot leave an unhandled rejection behind, and\n * the two branches fail the same way. A sync callback outside a transaction\n * runs before this returns.\n */\nexport function afterCommit(\n  callback: () => void | Promise<void>,\n): Promise<void> {\n  if (deferUntilCommit(callback)) return Promise.resolve();\n\n  const report = (error: unknown) => {\n    console.error(\n      `An after-commit callback threw. No transaction was open, so it ran ` +\n        `immediately.`,\n      error,\n    );\n  };\n  try {\n    return Promise.resolve(callback()).catch(report);\n  } catch (error) {\n    report(error);\n    return Promise.resolve();\n  }\n}\n\n/**\n * Make the open transaction's commit depend on `write`, a statement issued on\n * its handle: the transaction does not commit until `write` settles, and\n * rolls back — rejecting with `TransactionDependencyError` — if it rejected.\n *\n * For a write the caller may not await. A queued listener's dispatch never is\n * (`EventManager` pushes it and moves on), and on Postgres a statement that\n * fails aborts the whole transaction: every statement after it is refused and\n * Bun's `COMMIT` quietly becomes a rollback. Without this, the callback's\n * promise resolved, `begin` resolved, and the rows the caller wrote were gone\n * with nothing to say so. MySQL does not abort on a failed statement, and is\n * failed here anyway, so that a joined write means the same thing on both:\n * it commits with the transaction or the transaction does not commit.\n *\n * `false` when there is no transaction to depend on, as for\n * `deferUntilCommit`.\n */\nexport function commitDependsOn(write: Promise<unknown>): boolean {\n  const store = ormContext.getStore();\n  if (store?.tx === undefined || store.commitDependsOn === undefined) {\n    return false;\n  }\n  store.commitDependsOn.push(write);\n  return true;\n}\n\n/**\n * A write the transaction's commit depended on failed, so the transaction —\n * or the savepoint the write was made in — rolled back. `cause` is the write's\n * own error.\n */\nexport class TransactionDependencyError extends Error {\n  constructor(cause: unknown) {\n    super(\n      `A statement this transaction depended on failed after being issued on ` +\n        `it, so the transaction rolled back instead of committing: ` +\n        `${cause instanceof Error ? cause.message : String(cause)}`,\n      { cause },\n    );\n    this.name = \"TransactionDependencyError\";\n  }\n}\n\n/**\n * Wait for the writes registered from `mark` on, and throw if one failed.\n *\n * Called at the end of a transaction's or savepoint's callback, *inside*\n * `begin`/`savepoint`, so a throw is what makes Bun roll back rather than\n * commit — after `begin` has resolved it is too late to do anything but\n * report. Every write is settled before throwing, so none is still running on\n * the handle when the rollback is issued.\n */\nasync function awaitDependencies(\n  writes: Promise<unknown>[],\n  mark: number,\n): Promise<void> {\n  if (writes.length === mark) return;\n  const settled = await Promise.allSettled(writes.slice(mark));\n  const failed = settled.find(\n    (outcome): outcome is PromiseRejectedResult => outcome.status === \"rejected\",\n  );\n  if (failed) throw new TransactionDependencyError(failed.reason);\n}\n\n/** How deeply nested the current transaction is; `null` outside one. */\nexport function transactionDepth(): number | null {\n  const store = ormContext.getStore();\n  return store?.tx === undefined ? null : store.depth;\n}\n\n/** Whether policies are suspended for the current async scope. */\nexport function isSystemScope(): boolean {\n  return ormContext.getStore()?.system === true;\n}\n\n/**\n * Run `fn` with policies suspended.\n *\n * The escape hatch the deny-by-default rule needs to be usable: a cron tick, a\n * queue worker or a seed script has no user, and under deny-by-default every\n * policied model would refuse it. This makes that intent explicit *at the call\n * site*, which is the property that matters — unscoped access must never be\n * what happens when a user simply fails to turn up.\n *\n * It nests inside a transaction and a transaction nests inside it: the scope is\n * merged rather than replaced, so `asSystem` does not silently drop an open\n * handle.\n */\nexport function runAsSystem<T>(fn: () => Promise<T>): Promise<T> {\n  const current = ormContext.getStore();\n  return ormContext.run({ ...current, depth: current?.depth ?? 0, system: true }, fn);\n}\n\n/**\n * How `model`'s trashed rows are treated in this async scope, or `undefined`\n * for the default (hidden). See `OrmScope.trashed`.\n */\nexport function trashedMode(model: string): TrashedMode | undefined {\n  return ormContext.getStore()?.trashed?.get(model);\n}\n\n/**\n * Run `fn` with `model`'s soft-delete scope lifted (`\"with\"`) or inverted\n * (`\"only\"`). Merged into the current scope like `runAsSystem`, so it keeps an\n * open transaction, the system flag and the actor — and every other policy.\n */\nexport function runWithTrashed<T>(\n  model: string,\n  mode: TrashedMode,\n  fn: () => Promise<T>,\n): Promise<T> {\n  const current = ormContext.getStore();\n  const trashed = new Map(current?.trashed);\n  trashed.set(model, mode);\n  return ormContext.run(\n    { ...current, depth: current?.depth ?? 0, trashed },\n    fn,\n  );\n}\n\n/** The explicitly-set actor, or `undefined` when none was. */\nexport function currentActor(): { user: unknown } | undefined {\n  return ormContext.getStore()?.actor;\n}\n\n/**\n * Run `fn` with policies scoped to `user`, for code with no request to read one\n * from.\n *\n * The counterpart to `runAsSystem`, and the reason that one is not the only\n * escape hatch. A queue worker processing \"send the invoice for organisation 7\"\n * genuinely acts *as somebody*; giving it `asSystem` would suspend policies\n * entirely and leave it hand-scoping every query — which is precisely the\n * unscoped-by-accident failure the deny-by-default rule exists to prevent. The\n * narrow tool should be the easy one.\n *\n * It is also what makes policies testable without reaching into\n * `RequestContext`'s internals.\n *\n * Takes precedence over the request store, so a job that says who it is acting\n * as is not quietly overridden by an ambient request that happens to enclose it.\n *\n * It also **clears `system`**, which is the more surprising half. Acting as a\n * user is strictly narrower than acting as the system, so naming one inside an\n * `asSystem` block has to narrow back — and the spread would otherwise carry\n * `system: true` forward, leaving `$exec` to skip policies entirely while\n * `currentUser()` cheerfully returned the actor. Silently unscoped, from the\n * realistic shape: a worker enters `asSystem` to read its job queue, then\n * narrows to the job's owner for the work itself. The reverse nesting —\n * `asSystem` inside `asUser` — suspends policies, which is what it should do.\n */\nexport function runAsUser<T>(user: unknown, fn: () => Promise<T>): Promise<T> {\n  const current = ormContext.getStore();\n  return ormContext.run(\n    {\n      ...current,\n      depth: current?.depth ?? 0,\n      system: false,\n      actor: { user: user ?? null },\n    },\n    fn,\n  );\n}\n\n/**\n * The warning threshold in milliseconds, or `null` when the warning is off.\n *\n * `configured` is `database.slowTransactionThreshold` — see `DatabaseConfig`.\n * It arrives as a value rather than being read from here so that this file\n * keeps knowing nothing about the container: `withTransaction` is reachable\n * with a bare pool, and its tests use one.\n *\n * Exported for its own tests. The behaviour worth pinning is the fallback —\n * that a malformed threshold lands on the default rather than disabling — and\n * that cannot be observed through `withTransaction`: \"no warning fired\" is what\n * a disabled warning looks like too, so a behavioural test of it passes just as\n * happily when the fallback is gone. Asserting the number directly is the only\n * form of that test that can fail.\n */\nexport function slowTransactionThreshold(\n  configured?: number | false,\n): number | null {\n  // Read per call, never cached at module scope. `scripts/build.ts` rewrites\n  // `process.env.NODE_ENV` to `Bun.env.NODE_ENV` precisely so mode stays a\n  // runtime question in the built framework; caching it here would undo that.\n  if (process.env.NODE_ENV !== \"development\") return null;\n\n  // The one way to switch it off, and it has to be spelled. Everything else\n  // falls back, so the warning is never lost to a mistyped value — only to an\n  // explicit `false`.\n  if (configured === false) return null;\n\n  if (configured === undefined) return SLOW_TRANSACTION_THRESHOLD;\n  if (!Number.isFinite(configured) || configured <= 0) {\n    return SLOW_TRANSACTION_THRESHOLD;\n  }\n  return configured;\n}\n\n/**\n * Warn, in development only, about a transaction that has been open too long.\n *\n * The risk is structural rather than occasional: an open transaction holds one\n * reserved connection for as long as its callback runs, and nothing about\n * `Model.transaction(async () => { ... })` stops that callback from awaiting a\n * `fetch`, an S3 upload or a slow queue push. Under concurrency that drains the\n * pool, and the symptom — every unrelated query in the process blocking on\n * connection acquisition — names neither the callback nor the I/O in it.\n *\n * A timer rather than measuring elapsed time on the way out, for one reason:\n * the worst case is the transaction that *never* settles (a hung request, a\n * lock wait, a deadlock). After-the-fact measurement is silent for exactly that\n * case; a timer fires while it is still open and still holding the connection.\n *\n * The `Error` is constructed up front and read only if the timer fires — V8\n * formats `.stack` lazily on first access, so an ordinary fast transaction pays\n * for an object allocation and nothing else.\n *\n * The clock starts at the `begin` call, not at the moment a connection is\n * acquired, and stops when `begin` settles rather than when the callback\n * returns — so it spans the pool wait and the commit round-trip as well as the\n * callback. That is deliberate: all three are time this transaction is in\n * flight, and a warning that only covered the callback would stay silent for a\n * transaction stuck waiting on an exhausted pool, which is the exact situation\n * a long transaction elsewhere creates. Hence \"not settled\" rather than \"open\n * for\" — the message must not claim a connection was held for the whole span.\n */\nfunction watchForSlowTransaction(configured?: number | false): () => void {\n  const threshold = slowTransactionThreshold(configured);\n  if (threshold === null) return () => {};\n\n  const site = new Error(\"transaction opened here\");\n\n  const timer = setTimeout(() => {\n    const stack = site.stack?.split(\"\\n\").slice(1).join(\"\\n\") ?? \"\";\n    console.warn(\n      `[gemi] A database transaction has not settled after ${threshold}ms. It ` +\n        `reserves a pooled connection until it does — check for network or ` +\n        `filesystem I/O inside the callback, and move it outside the ` +\n        `transaction if you find any.\\n${stack}\\n` +\n        `(development only; set database.slowTransactionThreshold to change ` +\n        `the threshold, or false to switch this off)`,\n    );\n  }, threshold);\n\n  // Otherwise the warning timer is itself a reason the process stays alive,\n  // which would turn a diagnostic into a hang in short-lived commands and\n  // scripts.\n  timer.unref?.();\n\n  return () => clearTimeout(timer);\n}\n\n/**\n * Runs what a committed transaction deferred, outside the transaction it was\n * deferred by.\n *\n * `outside` is the scope that was ambient before `begin` — an `asSystem` block,\n * a named connection, or nothing at all — and re-entering it explicitly is the\n * guarantee rather than a tidy-up. The alternative is relying on where a `.then`\n * happens to have captured its context, and the failure that produces is the\n * one the whole feature is about: a listener that runs \"after commit\" while\n * still holding the closed transaction's handle joins nothing, because Bun's\n * handle stays callable and simply runs on the pool. So the scope is rebuilt\n * with `tx` and the drained list cleared, and a listener that opens its own\n * transaction gets a real one.\n *\n * Errors are caught per callback and the next one still runs, for the reason\n * the event subsystem catches per listener: these are independent side effects\n * whose order came from a filesystem walk. And the transaction is not failed by\n * one — it committed, the database kept the rows, and reporting a rejection to\n * the caller would have it roll back or retry work that is already durable.\n * stderr is all that is left, and it is enough: the caller has no decision to\n * make here.\n *\n * The transaction's own promise does not resolve until this has finished, which\n * is the one thing about `afterCommit` that a caller can feel. Deliberate: the\n * alternative is a floating promise whose rejection nobody sees and whose work\n * a short-lived process — a command, a seed — exits out from under.\n */\nasync function drainAfterCommit(\n  callbacks: AfterCommitCallback[],\n  outside: OrmScope | undefined,\n): Promise<void> {\n  if (callbacks.length === 0) return;\n\n  await ormContext.run(\n    {\n      ...outside,\n      tx: undefined,\n      afterCommit: undefined,\n      commitDependsOn: undefined,\n      depth: outside?.depth ?? 0,\n    },\n    async () => {\n      for (const callback of callbacks) {\n        try {\n          await callback();\n        } catch (error) {\n          console.error(\n            `An after-commit callback threw. The transaction it was waiting ` +\n              `on had already committed and stays committed, and the ` +\n              `callbacks after it still ran.`,\n            error,\n          );\n        }\n      }\n    },\n  );\n}\n\n/**\n * Run `fn` inside a transaction, entering the ambient scope for its whole async\n * subtree.\n *\n * The single implementation behind both `Model.transaction` and\n * `DB.transaction`, so the two cannot become transaction systems that ignore\n * each other: a `Model.create` inside a `DB.transaction` joins it, and a raw\n * `DB.sql` inside a `Model.transaction` can join it through\n * `currentTransaction()`.\n *\n * Nesting becomes a savepoint. Not a preference — Bun refuses the alternative\n * outright (`cannot call begin inside a transaction use savepoint() instead`),\n * and a savepoint is the semantics worth having anyway: an inner failure rolls\n * back to it and leaves the outer transaction usable, which a caller that\n * catches can rely on. Verified on SQLite and Postgres.\n *\n * Note Bun hands the savepoint callback the *same* handle object as the outer\n * transaction (`sp === tx`), so the depth counter is the only thing that\n * actually changes on the way in. The callback's argument is still what gets\n * stored, so this keeps working if that ever stops being true. The cast is\n * because Bun types a savepoint handle as plain `SQL` — without `savepoint` on\n * it — while the runtime object does carry the method, which is what makes\n * three levels of nesting work.\n *\n * Anything `deferUntilCommit` queued is drained once `begin` resolves, outside\n * the transaction and only on the outermost call — a savepoint has committed\n * nothing durable, so draining there would run work that a later rollback of\n * the enclosing transaction was meant to have prevented. See `drainAfterCommit`\n * for what that costs the caller.\n *\n * In development, an outermost transaction that stays open past\n * `options.slowTransactionThreshold` (2s by default, `false` to disable) warns\n * — see `watchForSlowTransaction`. Nothing here *prevents* a long transaction;\n * the warning exists because the cost of one is paid by unrelated queries\n * elsewhere in the process, which makes it hard to trace back.\n *\n * The threshold is passed in rather than read from `app(DatabaseManager)` here.\n * Every caller already holds the manager — it is where `pool` came from — and\n * taking it as an argument keeps this file free of the container, so a bare\n * `SQL` is still enough to call it. Its tests rely on that.\n *\n * `options.connection` is the name `pool` belongs to, and follows the same rule\n * for the same reason: the pool cannot be asked what it is called. Passing it\n * is what lets a nested `withTransaction` tell \"the same connection, so take a\n * savepoint\" from \"a different one, so refuse\" — omitting it means the default\n * connection, which is what a two-argument call always meant.\n *\n * The return type is asserted rather than inferred for one reason worth\n * knowing: Bun's `begin` unwraps a callback that resolves to an *array of\n * promises*, awaiting each. So `Model.transaction(async () => [a, b])` where\n * `a` and `b` are promises resolves to their values, not to the promises. That\n * is Bun's behaviour and is left alone; it is only surprising if unmentioned.\n */\nexport function withTransaction<T>(\n  pool: SQL,\n  fn: (tx: TransactionSQL) => Promise<T>,\n  options?: { slowTransactionThreshold?: number | false; connection?: string },\n): Promise<T> {\n  const current = ormContext.getStore();\n\n  // THE SINGLE-CONNECTION ASSUMPTION, WHICH IS NOW CHECKED RATHER THAN PINNED.\n  //\n  // The savepoint branch below ignores `pool` entirely. That was correct while\n  // there was one `DatabaseManager` and one `SQL` — the ambient handle and\n  // whatever pool the caller passed were necessarily the same database — and\n  // the note that stood here said what would happen when a second connection\n  // became configurable (#327): a `DB.transaction` on B inside a\n  // `Model.transaction` on A would savepoint on **A** and hand the callback A's\n  // handle, so statements landed in the wrong database with no error at all.\n  //\n  // So the name is compared before the branch is taken, and a mismatch raises.\n  // Refusing is the whole answer rather than half of one — there is no way to\n  // make one transaction span two pools, and the alternatives are covered on\n  // `CrossConnectionTransactionError`.\n  //\n  // A caller that passes no `connection` is treated as naming the default,\n  // which is what `withTransaction(pool, fn)` meant before this argument\n  // existed.\n  const name = options?.connection ?? DEFAULT_CONNECTION;\n  assertConnectionUsable(name);\n\n  // `current?.tx` rather than `current`: since iteration 6 a scope can exist\n  // with no open transaction — `Model.asSystem` enters one — and a savepoint\n  // needs an actual handle, not merely a store.\n  if (current?.tx) {\n    // WHERE THE SHARED AFTER-COMMIT LIST IS PUT RIGHT.\n    //\n    // The savepoint's scope is a spread of this one, so it appends to the\n    // transaction's list rather than to a list of its own — which is what makes\n    // \"the outer transaction rolled back, so nothing runs\" free. The case that\n    // is not free is this one: the savepoint rolls back and the transaction\n    // goes on to commit. Its entries have to go, or a dispatch made inside a\n    // block the database threw away runs anyway, which is the same wrong answer\n    // as before with an extra step.\n    //\n    // A mark on the way in and a truncate on the way out, rather than tagging\n    // each entry with its depth and dropping everything at or below the failing\n    // one. Depth cannot tell two *siblings* apart: a savepoint that committed\n    // and one that rolled back both left entries at the same depth, adjacent in\n    // the list, and dropping by depth would discard the committed sibling's\n    // work as well. The index is exact because the ORM issues one statement at\n    // a time on a transaction handle — see `OrmScope.tx` — so nothing appends\n    // between the mark and the failure but this savepoint's own subtree.\n    const deferred = current.afterCommit;\n    const mark = deferred?.length ?? 0;\n    // The same mark for the writes the commit depends on. The savepoint waits\n    // for its own before it releases, so one that failed rolls back only the\n    // savepoint — which a caller that catches can survive, exactly as it\n    // survives a statement that threw inside it — and is then forgotten\n    // rather than failing the transaction a second time.\n    const dependencies = current.commitDependsOn;\n    const dependencyMark = dependencies?.length ?? 0;\n\n    return current.tx\n      .savepoint((sp) => {\n        const nested = sp as TransactionSQL;\n        return ormContext.run(\n          { ...current, tx: nested, depth: current.depth + 1 },\n          async () => {\n            const result = await fn(nested);\n            if (dependencies) {\n              await awaitDependencies(dependencies, dependencyMark);\n            }\n            return result;\n          },\n        );\n      })\n      .catch((error: unknown) => {\n        if (deferred) deferred.length = mark;\n        if (dependencies) dependencies.length = dependencyMark;\n        throw error;\n      }) as Promise<T>;\n  }\n\n  // Only the outermost scope is watched. A savepoint reserves no connection of\n  // its own — its lifetime is bounded by the transaction it sits in, which is\n  // already being timed — so warning per depth would report one slow block as\n  // several warnings and point at the innermost frame rather than the one\n  // holding the connection.\n  const stopWatching = watchForSlowTransaction(\n    options?.slowTransactionThreshold,\n  );\n\n  // Built out here rather than inside the `begin` callback, because the drain\n  // below needs it *after* that callback's scope is gone, and reading it off\n  // the store then is exactly what is no longer possible.\n  const deferred: AfterCommitCallback[] = [];\n  const dependencies: Promise<unknown>[] = [];\n\n  // The `try` covers a *synchronous* throw from `begin` — a closed pool, say.\n  // `.finally` alone would not: it is only attached once `begin` has returned a\n  // promise, so a synchronous throw escapes with the timer still armed and\n  // eventually warns about a transaction that never opened. `unref` keeps that\n  // from holding the process, which makes it cosmetic rather than a leak, but\n  // it is the same gap the `.finally` below exists to close.\n  try {\n    // Spread rather than replace: a `Model.transaction` inside a\n    // `Model.asSystem` must not silently re-enable policies for its subtree.\n    //\n    // The connection goes into the scope alongside the handle, and the pair is\n    // what makes the check at the top of this function possible: \"which\n    // connection is this transaction on\" has to be answerable from the store,\n    // because the handle itself does not say. It is also what makes an\n    // unqualified query inside `DB.connection(\"analytics\").transaction(...)`\n    // *join* the transaction instead of being refused by it — the query\n    // inherits the name rather than defaulting to the hot path.\n    return (\n      pool\n        .begin((tx) =>\n          ormContext.run(\n            {\n              ...current,\n              tx,\n              depth: 0,\n              connection: name === DEFAULT_CONNECTION ? undefined : name,\n              // A fresh list per outermost transaction, assigned rather than\n              // left to the spread. `current` holds no list today — the drain\n              // clears the field before it runs anything — and assigning is\n              // what keeps that from being load-bearing: a transaction opened\n              // by a callback during a drain gets its own list either way,\n              // rather than appending to the array it is being run out of.\n              afterCommit: deferred,\n              commitDependsOn: dependencies,\n            },\n            async () => {\n              const result = await fn(tx);\n              await awaitDependencies(dependencies, 0);\n              return result;\n            },\n          ),\n        )\n        // `finally` and not a `then`/`catch` pair: the connection is released on\n        // rollback exactly as it is on commit, so a throwing callback must clear\n        // the timer too or every failed transaction leaves a warning armed\n        // against a connection that has already gone back to the pool.\n        //\n        // Before the drain, so that a slow after-commit listener is not\n        // reported as a transaction that will not settle. The connection went\n        // back to the pool at the commit; the warning is about holding it.\n        .finally(stopWatching)\n        // Only here, on the fulfilled path. A rejected `begin` rolled back, so\n        // the scope and everything queued on it are discarded unread — which is\n        // the whole of what `afterCommit` promises.\n        .then(\n          async (result) => {\n            settledLists.set(deferred, \"committed\");\n            await drainAfterCommit(deferred, current);\n            return result;\n          },\n          (error: unknown) => {\n            settledLists.set(deferred, \"rolled_back\");\n            throw error;\n          },\n        ) as Promise<T>\n    );\n  } catch (error) {\n    stopWatching();\n    throw error;\n  }\n}\n"
   ],
   "mappings": "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",
-  "debugId": "3BE9453EB47BCF2164756E2164756E21",
+  "debugId": "AE3625C3098D084464756E2164756E21",
   "names": []
 }

package/dist/{chunk-sbhpdhwc.js → chunk-qhz22t3a.js}

@@ -1,5 +1,5 @@
 // @bun
 class A extends Error{constructor(p,q){super(`Target [${p}] is not bound in the container.`+(q.length>0?` Bound tokens: ${q.join(", ")}.`:" No tokens are bound \u2014 was the application booted?"));this.name="BindingResolutionError"}}class C{bindings=new Map;instances=new Map;bind(p,q){this.bindings.set(p.token,{factory:q,shared:!1}),this.instances.delete(p.token)}singleton(p,q){this.bindings.set(p.token,{factory:q,shared:!0}),this.instances.delete(p.token)}instance(p,q){return this.instances.set(p.token,q),q}bound(p){return this.bindings.has(p.token)||this.instances.has(p.token)}resolved(p){return this.instances.has(p.token)}make(p){let q=p.token;if(this.instances.has(q))return this.instances.get(q);let v=this.bindings.get(q);if(!v)throw new A(q,this.keys());let x=v.factory(this);if(v.shared)this.instances.set(q,x);return x}forget(p){this.instances.delete(p.token)}keys(){return[...new Set([...this.bindings.keys(),...this.instances.keys()])]}flush(){this.bindings.clear(),this.instances.clear()}}
-export{A as nl,C as ol};
+export{A as ol,C as pl};
 
-//# debugId=1F2303D9ECCC197664756E2164756E21
+//# debugId=15791D8EEE72F03264756E2164756E21

package/dist/{chunk-sbhpdhwc.js.map → chunk-qhz22t3a.js.map}

@@ -5,6 +5,6 @@
     "/**\n * Tokens are the service classes themselves, so `make(MailManager)` is typed\n * `MailManager` without a cast. The container keys its bindings off the class's\n * `static token` string rather than the constructor object: the built binary\n * (`dist/bin/gemi.js`) bundles its own copy of gemi while the app resolves\n * `gemi/*` to source, so the same service is two distinct class objects across\n * that boundary. A string survives it. Laravel binds both `'mail'` and\n * `MailManager::class` for the same reason.\n */\nexport type ServiceToken<T> = (abstract new (...args: any[]) => T) & {\n  token: string;\n};\n\nexport type Factory<T> = (app: Container) => T;\n\ninterface Binding {\n  factory: Factory<any>;\n  shared: boolean;\n}\n\nexport class BindingResolutionError extends Error {\n  constructor(token: string, known: string[]) {\n    super(\n      `Target [${token}] is not bound in the container.` +\n        (known.length > 0\n          ? ` Bound tokens: ${known.join(\", \")}.`\n          : \" No tokens are bound — was the application booted?\"),\n    );\n    this.name = \"BindingResolutionError\";\n  }\n}\n\nexport class Container {\n  private bindings = new Map<string, Binding>();\n  private instances = new Map<string, any>();\n\n  bind<T>(token: ServiceToken<T>, factory: Factory<T>) {\n    this.bindings.set(token.token, { factory, shared: false });\n    this.instances.delete(token.token);\n  }\n\n  /**\n   * Lazy by design — `factory` is not called until the first `make()`.\n   */\n  singleton<T>(token: ServiceToken<T>, factory: Factory<T>) {\n    this.bindings.set(token.token, { factory, shared: true });\n    this.instances.delete(token.token);\n  }\n\n  instance<T>(token: ServiceToken<T>, object: T): T {\n    this.instances.set(token.token, object);\n    return object;\n  }\n\n  bound<T>(token: ServiceToken<T>): boolean {\n    return (\n      this.bindings.has(token.token) || this.instances.has(token.token)\n    );\n  }\n\n  resolved<T>(token: ServiceToken<T>): boolean {\n    return this.instances.has(token.token);\n  }\n\n  make<T>(token: ServiceToken<T>): T {\n    const key = token.token;\n\n    if (this.instances.has(key)) {\n      return this.instances.get(key) as T;\n    }\n\n    const binding = this.bindings.get(key);\n    if (!binding) {\n      throw new BindingResolutionError(key, this.keys());\n    }\n\n    const object = binding.factory(this) as T;\n    if (binding.shared) {\n      this.instances.set(key, object);\n    }\n    return object;\n  }\n\n  forget<T>(token: ServiceToken<T>) {\n    this.instances.delete(token.token);\n  }\n\n  keys(): string[] {\n    return [\n      ...new Set([...this.bindings.keys(), ...this.instances.keys()]),\n    ];\n  }\n\n  flush() {\n    this.bindings.clear();\n    this.instances.clear();\n  }\n}\n"
   ],
   "mappings": ";AAoBO,MAAM,UAA+B,KAAM,CAChD,WAAW,CAAC,EAAe,EAAiB,CAC1C,MACE,WAAW,qCACR,EAAM,OAAS,EACZ,kBAAkB,EAAM,KAAK,IAAI,KACjC,0DACR,EACA,KAAK,KAAO,yBAEhB,CAEO,MAAM,CAAU,CACb,SAAW,IAAI,IACf,UAAY,IAAI,IAExB,IAAO,CAAC,EAAwB,EAAqB,CACnD,KAAK,SAAS,IAAI,EAAM,MAAO,CAAE,UAAS,OAAQ,EAAM,CAAC,EACzD,KAAK,UAAU,OAAO,EAAM,KAAK,EAMnC,SAAY,CAAC,EAAwB,EAAqB,CACxD,KAAK,SAAS,IAAI,EAAM,MAAO,CAAE,UAAS,OAAQ,EAAK,CAAC,EACxD,KAAK,UAAU,OAAO,EAAM,KAAK,EAGnC,QAAW,CAAC,EAAwB,EAAc,CAEhD,OADA,KAAK,UAAU,IAAI,EAAM,MAAO,CAAM,EAC/B,EAGT,KAAQ,CAAC,EAAiC,CACxC,OACE,KAAK,SAAS,IAAI,EAAM,KAAK,GAAK,KAAK,UAAU,IAAI,EAAM,KAAK,EAIpE,QAAW,CAAC,EAAiC,CAC3C,OAAO,KAAK,UAAU,IAAI,EAAM,KAAK,EAGvC,IAAO,CAAC,EAA2B,CACjC,IAAM,EAAM,EAAM,MAElB,GAAI,KAAK,UAAU,IAAI,CAAG,EACxB,OAAO,KAAK,UAAU,IAAI,CAAG,EAG/B,IAAM,EAAU,KAAK,SAAS,IAAI,CAAG,EACrC,GAAI,CAAC,EACH,MAAM,IAAI,EAAuB,EAAK,KAAK,KAAK,CAAC,EAGnD,IAAM,EAAS,EAAQ,QAAQ,IAAI,EACnC,GAAI,EAAQ,OACV,KAAK,UAAU,IAAI,EAAK,CAAM,EAEhC,OAAO,EAGT,MAAS,CAAC,EAAwB,CAChC,KAAK,UAAU,OAAO,EAAM,KAAK,EAGnC,IAAI,EAAa,CACf,MAAO,CACL,GAAG,IAAI,IAAI,CAAC,GAAG,KAAK,SAAS,KAAK,EAAG,GAAG,KAAK,UAAU,KAAK,CAAC,CAAC,CAChE,EAGF,KAAK,EAAG,CACN,KAAK,SAAS,MAAM,EACpB,KAAK,UAAU,MAAM,EAEzB",
-  "debugId": "1F2303D9ECCC197664756E2164756E21",
+  "debugId": "15791D8EEE72F03264756E2164756E21",
   "names": []
 }

package/dist/{chunk-3kd3w33a.js → chunk-qwkgnt4q.js}

@@ -1,5 +1,5 @@
 // @bun
-import{Od as R}from"./chunk-bm3pyh9m.js";import{Vd as Q,ce as S,he as E}from"./chunk-attv9byj.js";import{ml as K}from"./chunk-edj701p0.js";import{Dl as A,El as $,Fl as D}from"./chunk-mx4z8c6r.js";class j extends Error{code;constructor(q,z=1){super(q);this.code=z;this.name="CommandFailed"}}class J{static commandName="unset";static description="";static args=[];static options=[];run(q){}}function p(q){return q}function C(){return{commands:[],commandsDir:"app/commands"}}var I=Symbol.for("gemi.console.builder");function k(q){if(q.trim()==="")throw Error("A command name cannot be empty.");if(/[{}]/.test(q)||/\s/.test(q))throw Error(`Invalid command name ${JSON.stringify(q)}. gemi does not parse a signature string; the name is the whole of it. Declare arguments with .arg() and flags with .option():
+import{Pd as R}from"./chunk-mndcq5z1.js";import{Wd as Q,de as S,ie as E}from"./chunk-t1abd8jv.js";import{nl as K}from"./chunk-fr6e5g2z.js";import{El as A,Fl as $,Gl as D}from"./chunk-ergrkg2f.js";class j extends Error{code;constructor(q,z=1){super(q);this.code=z;this.name="CommandFailed"}}class J{static commandName="unset";static description="";static args=[];static options=[];run(q){}}function p(q){return q}function C(){return{commands:[],commandsDir:"app/commands"}}var I=Symbol.for("gemi.console.builder");function k(q){if(q.trim()==="")throw Error("A command name cannot be empty.");if(/[{}]/.test(q)||/\s/.test(q))throw Error(`Invalid command name ${JSON.stringify(q)}. gemi does not parse a signature string; the name is the whole of it. Declare arguments with .arg() and flags with .option():
 
     defineCommand("mail:send")
       .arg("user", { required: true })
@@ -14,6 +14,6 @@ import{Od as R}from"./chunk-bm3pyh9m.js";import{Vd as Q,ce as S,he as E}from"./c
     static event = UserRegistered;
 
 If this is an abstract base its subclasses extend, move it out of the `+"listeners directory \u2014 the walk excludes gemi's `Listener` and "+"nothing else, so a base sitting beside its subclasses is registered and run like one of them.")}function v(q){for(let z of q){if(Object.getOwnPropertyDescriptor(z,"name")?.writable)continue;console.warn(`Event listener ${z.name} does not declare \`static name\`, so it is registered under its class name, which a production build renames. Nothing reads that name across a build boundary while the `+"listener is sync, which is why this is a warning \u2014 but adding "+`\`queued = true\` to it is refused at boot for the same reason, because the queue's key is that string. Add: static name = "${z.name}";`)}}function u(q){let z=new Set;for(let{event:F}of q){if(z.has(F))continue;if(Object.getOwnPropertyDescriptor(F,"name")?.writable)continue;z.add(F),console.warn(`Event ${F.name} does not declare \`static name\`, so it is dispatched under its class name. A production build minifies the code that dispatches it and renames the class, while discovery reads `+"the listener's copy from source and does not \u2014 so the dispatch would "+`reach no listener in production and nowhere else. Add: static name = "${F.name}";`)}}
-export{j as yd,J as zd,p as Ad,C as Bd,c as Cd,o as Dd,T as Ed,i as Fd,B as Gd,U as Hd,W as Id,Sq as Jd,Zq as Kd,_q as Ld,Iq as Md,Uq as Nd};
+export{j as zd,J as Ad,p as Bd,C as Cd,c as Dd,o as Ed,T as Fd,i as Gd,B as Hd,U as Id,W as Jd,Sq as Kd,Zq as Ld,_q as Md,Iq as Nd,Uq as Od};
 
-//# debugId=124C491D13F36AA864756E2164756E21
+//# debugId=268B1042A855669A64756E2164756E21

package/dist/{chunk-3kd3w33a.js.map → chunk-qwkgnt4q.js.map}

@@ -12,6 +12,6 @@
     "import { existsSync } from \"node:fs\";\nimport { dirname, isAbsolute, join } from \"node:path\";\n\nimport {\n  discoverClasses,\n  DiscoveryError,\n  projectRoot,\n} from \"../support/discover\";\nimport { Command, type CommandClass } from \"../console/Command\";\nimport { commandConfigDefaults } from \"../console/config\";\nimport { isUnfinishedBuilder } from \"../console/builder\";\nimport { CronJob } from \"./cron/CronJob\";\nimport { scheduleConfigDefaults } from \"./cron/config\";\nimport { eventConfigDefaults } from \"./events/config\";\nimport type { EventClass } from \"./events/Event\";\nimport { Listener, type ListenerClass } from \"./events/Listener\";\nimport { Job } from \"./queue/Job\";\nimport { queueConfigDefaults } from \"./queue/config\";\nimport { Workflow, type WorkflowClass } from \"./queue/workflow/Workflow\";\n\n/**\n * Reading an application's jobs off the filesystem, for the two subsystems that\n * were asking every app to write its job list twice.\n *\n * Both functions here are the same call to `discoverClasses` with a different\n * base class, which is deliberate: one walk, one set of skip rules, one answer\n * to \"what does this app have\". They are exported from `gemi/services` rather\n * than kept private to the providers because the list stopped being something\n * an app could import — a test that used to walk the exported `jobs` array\n * needs somewhere to ask the same question, and so does a script.\n *\n * What the providers add on top of these is the decision of *whether* to ask,\n * which is the config's to make and not this file's.\n */\n\n/**\n * A directory the app named, resolved the way the app meant it.\n *\n * Relative paths hang off the project root rather than `process.cwd()` at the\n * moment of the call, because a config slice saying `app/jobs` means the app's\n * `app/jobs` and not whatever directory somebody happened to launch a script\n * from. Absolute paths are taken as given, which is what makes these callable\n * from a test that has no project around it.\n */\nfunction resolveDir(dir: string): string {\n  return isAbsolute(dir) ? dir : join(projectRoot(), dir);\n}\n\n/**\n * Says something when the directory is missing *and so is the tree it lives in*.\n *\n * A missing directory has two readings and they want opposite responses. An app\n * that has never written a cron job has no `app/cron`, and warning about that on\n * every boot for the rest of its life is noise — the answer \"you have no cron\n * jobs\" is correct and uninteresting. But a deploy that ships `dist/` and\n * `node_modules/` without the source has no `app/cron` *and no `app/`*, and\n * there discovery quietly returns nothing while the app very much does have\n * jobs: the exact silence #322 and #323 exist to remove, reintroduced one layer\n * down and in production only.\n *\n * The parent directory is what tells them apart. If neither the directory nor\n * the one above it is there, the tree this was pointed into is not there\n * either, and that is worth a sentence.\n */\nfunction warnIfSourceIsMissing(\n  resolved: string,\n  subject: string,\n  slice: string,\n) {\n  if (existsSync(resolved) || existsSync(dirname(resolved))) return;\n\n  console.warn(\n    `No ${subject} were discovered: neither ${resolved} nor the directory ` +\n      `above it exists, so this process cannot see the application's source. ` +\n      `If this is a deploy that ships only the build output, list the classes ` +\n      `explicitly in app/config/${slice}.ts so they travel with it.`,\n  );\n}\n\n/**\n * The `Job` subclasses under `dir`, defaulting to the config slice's `app/jobs`.\n *\n * This is what a `queue` config slice with no `jobs` key resolves to. Call it\n * directly to ask the question a test used to answer by importing the array:\n * every job this application would register, in the order it would register\n * them.\n *\n * Every file underneath is imported, so calling this runs the app's job modules\n * — the cost `discoverClasses` documents at length, paid once per call.\n */\nexport async function discoverJobs(\n  dir: string = queueConfigDefaults().jobsDir,\n): Promise<Array<new () => Job>> {\n  const resolved = resolveDir(dir);\n  warnIfSourceIsMissing(resolved, \"queue jobs\", \"queue\");\n  const jobs = await discoverClasses(resolved, Job);\n  warnIfNameWillNotSurviveTheBuild(jobs);\n  return jobs;\n}\n\n/**\n * The `Workflow` subclasses under `dir`, defaulting to the queue slice's\n * `app/workflows`: what a `queue` slice with no `workflows` key resolves to.\n * A missing directory is no workflows, said nothing about unless the tree\n * above it is missing too.\n */\nexport async function discoverWorkflows(\n  dir: string = queueConfigDefaults().workflowsDir,\n): Promise<WorkflowClass[]> {\n  const resolved = resolveDir(dir);\n  warnIfSourceIsMissing(resolved, \"workflows\", \"queue\");\n  const workflows = (await discoverClasses(resolved, Workflow)) as WorkflowClass[];\n  for (const workflow of workflows) {\n    if (Object.getOwnPropertyDescriptor(workflow, \"name\")?.writable) continue;\n    console.warn(\n      `Workflow ${workflow.name} does not declare \\`static name\\`. A workflow ` +\n        `is stored under its name, and a production build renames the class. ` +\n        `Add: static name = \"${workflow.name}\";`,\n    );\n  }\n  return workflows;\n}\n\n/**\n * Says something about a discovered job that never declared `static name`.\n *\n * This is the one hazard discovery introduces rather than removes, and it is\n * production-only. `gemi build` minifies the server entry, and app code\n * reachable from it — a controller, and every job class that controller\n * imports to dispatch — is bundled and minified with it. Minification renames\n * the class binding, and a class's implicit `.name` is that binding: a\n * `TestJob` in the bundle reports `\"D\"`. Discovery, meanwhile, imports\n * `app/jobs/TestJob.ts` from source at runtime, where it is still `\"TestJob\"`.\n * The queue is keyed by that name, so the two halves stop agreeing and the\n * dispatch is dropped — in production, and only there.\n *\n * A declared `static name = \"TestJob\"` is a string literal, which survives\n * minification intact, and the two halves agree again. `docs/jobs-and-queues.md`\n * has always called it required; before discovery an app could get away without\n * it, because the explicit `jobs` array was bundled too and both sides were\n * wrong in the same way.\n *\n * The check is exact rather than a guess: a `static name = \"...\"` class field\n * defines a *writable* own property, while the implicit class name is\n * non-writable. Cron is unaffected — `CronJob.name` is an instance field\n * holding a string literal, not the class binding.\n */\nfunction warnIfNameWillNotSurviveTheBuild(jobs: Array<new () => Job>) {\n  for (const job of jobs) {\n    if (Object.getOwnPropertyDescriptor(job, \"name\")?.writable) continue;\n\n    console.warn(\n      `Queued job ${job.name} does not declare \\`static name\\`, so it is ` +\n        `registered under its class name. A production build minifies the ` +\n        `class that dispatches it and renames it, while discovery reads this ` +\n        `file from source and does not — so the dispatch would be dropped in ` +\n        `production and nowhere else. Add: static name = \"${job.name}\";`,\n    );\n  }\n}\n\n/**\n * The `CronJob` subclasses under `dir`, defaulting to the config slice's\n * `app/cron`.\n *\n * This is what a `schedule` config slice with no `jobs` key resolves to. Call it\n * directly to ask the question a test used to answer by importing the array —\n * though after boot `app(Scheduler).jobs` is the better one, because it is what\n * the scheduler actually took rather than what this would find if asked again.\n *\n * Every file underneath is imported, so calling this runs the app's cron\n * modules — the cost `discoverClasses` documents at length, paid once per call.\n */\nexport async function discoverCronJobs(\n  dir: string = scheduleConfigDefaults().jobsDir,\n): Promise<Array<new () => CronJob>> {\n  const resolved = resolveDir(dir);\n  warnIfSourceIsMissing(resolved, \"cron jobs\", \"schedule\");\n  return await discoverClasses(resolved, CronJob);\n}\n\n/**\n * The `Command` subclasses under `dir`, defaulting to the config slice's\n * `app/commands`.\n *\n * This is what a `commands`-less `command` slice resolves to, and what\n * `gemi run` lists. Unlike the two above it is not called during boot — a\n * command registry has one consumer, and importing every file under\n * `app/commands` into every server process would be a cost paid on every start\n * for code no request reaches.\n *\n * Every file underneath is imported, so calling this runs the app's command\n * modules — the cost `discoverClasses` documents at length, paid once per call.\n */\nexport async function discoverCommands(\n  dir: string = commandConfigDefaults().commandsDir,\n): Promise<CommandClass[]> {\n  const resolved = resolveDir(dir);\n  warnIfSourceIsMissing(resolved, \"commands\", \"command\");\n\n  const unfinished: string[] = [];\n\n  const commands = await discoverClasses(\n    resolved,\n    Command,\n    [],\n    (value, file) => {\n      if (isUnfinishedBuilder(value)) unfinished.push(file);\n    },\n  );\n\n  refuseUnfinishedBuilders(unfinished);\n\n  return commands as CommandClass[];\n}\n\n/**\n * Stops the walk for a builder chain that was never finished.\n *\n * This is the one silence the builder introduces, and it is the exact shape\n * #322 and #323 exist to remove. `defineCommand(...).arg(...)` without a\n * trailing `.handle(...)` is a plain object rather than a class, so\n * `discoverClasses` discards it along with every constant and helper a command\n * file happens to export — and the command disappears from `gemi run` with\n * nothing raised. The author sees a listing containing every command except the\n * one they just wrote.\n *\n * A throw rather than a warning, because there is no reading of an unfinished\n * builder under which the author meant it: the chain builds a description of a\n * command and then discards it.\n *\n * \"Unfinished\" is decided by `.handle()` clearing the brand, not by the export\n * still being a builder object. Those differ for the natural way to share\n * declarations —\n *\n *     export const base = defineCommand(\"reindex\").option(\"verbose\", …);\n *     export default base.handle(async () => {});\n *\n * — where `base` is a builder that *did* produce a command. Keying off the shape\n * alone made that file abort the whole of `gemi run`, taking every other command\n * in the project down with it, under a message that was untrue for it.\n */\nfunction refuseUnfinishedBuilders(files: string[]): void {\n  if (files.length === 0) return;\n\n  const subject =\n    files.length === 1\n      ? `${files[0]} exports a command builder that never called \\`.handle()\\``\n      : `${files.length} files export a command builder that never called ` +\n        `\\`.handle()\\`:\\n    ${files.join(\"\\n    \")}`;\n\n  throw new DiscoveryError(\n    `${subject}, so there is no command to run. \\`.handle()\\` is what turns ` +\n      `the chain into a command — finish it:\\n\\n` +\n      `    export default defineCommand(\"my-command\")\\n` +\n      `      .handle(async ({ line }) => { line(\"hello\") })`,\n  );\n}\n\n/**\n * The `Listener` subclasses under `dir`, defaulting to the config slice's\n * `app/listeners`.\n *\n * This is what an `events` config slice with no `listeners` key resolves to.\n * Call it directly to ask what an application would register: every listener,\n * in the order it would register them.\n *\n * Only listeners are walked. Event classes are never discovered — each is\n * imported by the listener that binds to it and by the code that dispatches it,\n * so there is nothing a walk over them would find that is not already in the\n * module graph.\n *\n * **Known residual, matching jobs and cron.** `discoverClasses` excludes the\n * `base` it is handed and not intermediates, so an abstract listener base\n * written in `listenersDir` and extended by its siblings is discovered and\n * registered alongside them — constructed, with its `handle` called, on every\n * dispatch of whatever event it declares. Keep shared bases outside the\n * directory.\n *\n * Every file underneath is imported, so calling this runs the app's listener\n * modules — the cost `discoverClasses` documents at length, paid once per call.\n *\n * @throws DiscoveryError if a discovered listener declares no `static event`.\n */\nexport async function discoverListeners(\n  dir: string = eventConfigDefaults().listenersDir,\n): Promise<ListenerClass[]> {\n  const resolved = resolveDir(dir);\n  warnIfSourceIsMissing(resolved, \"event listeners\", \"events\");\n\n  const listeners = (await discoverClasses(\n    resolved,\n    Listener,\n  )) as ListenerClass[];\n\n  refuseListenersWithNoEvent(listeners);\n  warnIfListenerNameWillNotSurviveTheBuild(listeners);\n  warnIfEventNameWillNotSurviveTheBuild(listeners);\n\n  return listeners;\n}\n\n/**\n * Stops the walk for a listener that binds to nothing.\n *\n * `static event` is declared as required on the base and the compiler still\n * cannot see it missing: every subclass inherits the declaration whether or not\n * it assigns to one, so `typeof SomeListener` type-checks either way. What the\n * author gets instead is a file that is imported, registered under no name, and\n * never called — the silence this whole module is arranged against.\n *\n * A throw rather than a warning, because there is no reading of a listener with\n * no event under which the author meant it. The usual cause is the residual\n * above: an abstract base sharing a gate between two listeners, sitting in\n * `listenersDir` where the walk finds it. Moving it out is the fix, and the\n * message says so — the alternative, excluding it by some guess about\n * abstractness, is how a discovery pass ends up quietly covering less than the\n * directory holds.\n */\nfunction refuseListenersWithNoEvent(listeners: ListenerClass[]): void {\n  const orphans = listeners.filter((listener) => !listener.event);\n  if (orphans.length === 0) return;\n\n  throw new DiscoveryError(\n    `${orphans\n      .map((listener) => listener.name)\n      .join(\", \")} declare no \\`static event\\`, so there is no event name to ` +\n      `register them under and their \\`handle\\` would never run. Every ` +\n      `listener binds to exactly one event:\\n\\n` +\n      `    static event = UserRegistered;\\n\\n` +\n      `If this is an abstract base its subclasses extend, move it out of the ` +\n      `listeners directory — the walk excludes gemi's \\`Listener\\` and ` +\n      `nothing else, so a base sitting beside its subclasses is registered ` +\n      `and run like one of them.`,\n  );\n}\n\n/**\n * Says something about a discovered listener that never declared `static name`.\n *\n * The hazard is `warnIfNameWillNotSurviveTheBuild`'s, one subsystem over: a\n * `static name = \"...\"` class field defines a *writable* own property while the\n * implicit class binding does not, and a minifier renames the binding while\n * leaving the string literal alone. The two spellings are indistinguishable by\n * value — both read `\"SendWelcomeEmail\"` in development — so the descriptor is\n * the only thing that tells them apart, and the difference only becomes visible\n * in a production build.\n *\n * A warning rather than a refusal, because a *sync* listener's name has no\n * second half to disagree with: every reader of it comes from this same\n * source-side walk, so a minified build and this walk cannot produce two\n * different strings for it. A **queued** listener does have one — the name is\n * the queue's key and it crosses a JSON boundary — and that case is refused\n * outright, by `jobForListener`, at the point the listener is registered with\n * the queue rather than here. This walk cannot tell the two apart without\n * constructing every listener it found; the registry constructs them anyway.\n */\nfunction warnIfListenerNameWillNotSurviveTheBuild(listeners: ListenerClass[]) {\n  for (const listener of listeners) {\n    if (Object.getOwnPropertyDescriptor(listener, \"name\")?.writable) continue;\n\n    console.warn(\n      `Event listener ${listener.name} does not declare \\`static name\\`, so ` +\n        `it is registered under its class name, which a production build ` +\n        `renames. Nothing reads that name across a build boundary while the ` +\n        `listener is sync, which is why this is a warning — but adding ` +\n        `\\`queued = true\\` to it is refused at boot for the same reason, ` +\n        `because the queue's key is that string. Add: static name = ` +\n        `\"${listener.name}\";`,\n    );\n  }\n}\n\n/**\n * Says something about the *event* a discovered listener binds to, when that\n * event's name is the implicit class binding.\n *\n * This is the check that matters from the first dispatch, and it is the reason\n * `discoverListeners` reads `static event` at all. The registry is keyed by the\n * event's name; the dispatcher supplies that name from the class it constructs.\n * A production build minifies the server entry and the app code reachable from\n * it — the controller, and the event class it imports in order to dispatch —\n * while discovery imports `app/listeners/*.ts` from source, and those files\n * import `app/events/*.ts` from source too. Two module graphs, two class\n * objects, and an implicit `.name` that reads `\"UserRegistered\"` on one side\n * and `\"D\"` on the other. The dispatch then finds no listeners, which is legal,\n * normal, and completely silent.\n *\n * A declared `static name` is a string literal, which survives minification\n * intact, and the two halves agree again.\n *\n * Checked through the descriptor rather than the string, and not by comparing\n * `event.name` to anything: in development the two spellings produce the same\n * value, so a check on the string would be a tautology that passes forever.\n */\nfunction warnIfEventNameWillNotSurviveTheBuild(listeners: ListenerClass[]) {\n  const warned = new Set<EventClass>();\n\n  for (const { event } of listeners) {\n    if (warned.has(event)) continue;\n    if (Object.getOwnPropertyDescriptor(event, \"name\")?.writable) continue;\n    warned.add(event);\n\n    console.warn(\n      `Event ${event.name} does not declare \\`static name\\`, so it is ` +\n        `dispatched under its class name. A production build minifies the ` +\n        `code that dispatches it and renames the class, while discovery reads ` +\n        `the listener's copy from source and does not — so the dispatch would ` +\n        `reach no listener in production and nowhere else. Add: ` +\n        `static name = \"${event.name}\";`,\n    );\n  }\n}\n"
   ],
   "mappings": "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",
-  "debugId": "124C491D13F36AA864756E2164756E21",
+  "debugId": "268B1042A855669A64756E2164756E21",
   "names": []
 }

package/dist/{chunk-zrndnz4n.js → chunk-r887spwe.js}

@@ -1,4 +1,4 @@
 // @bun
-import{S as A}from"./chunk-czw7kqtp.js";import"./chunk-bwh1n2cj.js";import{U as I}from"./chunk-6dtq4h9p.js";import{V as f}from"./chunk-kkymwxt2.js";import{Jl as t,Nl as T}from"./chunk-jmgjhfya.js";var N=t(I(),1),a=t(f(),1),d=t(A(),1);import{readFileSync as g}from"fs";var c=(e)=>async(s)=>{e.logger?.debug("@aws-sdk/credential-provider-web-identity - fromWebToken");let{roleArn:o,roleSessionName:r,webIdentityToken:i,providerId:n,policyArns:m,policy:S,durationSeconds:l}=e,{roleAssumerWithWebIdentity:E}=e;if(!E){let{getDefaultRoleAssumerWithWebIdentity:p}=await import("./chunk-ph793v5g.js").then((m)=>t(m.default,1));E=p({...e.clientConfig,credentialProviderLogger:e.logger,parentClientConfig:{...s?.callerClientConfig,...e.parentClientConfig}},e.clientPlugins)}return E({RoleArn:o,RoleSessionName:r??`aws-sdk-js-session-${Date.now()}`,WebIdentityToken:i,ProviderId:n,PolicyArns:m,Policy:S,DurationSeconds:l})};var _="AWS_WEB_IDENTITY_TOKEN_FILE",O="AWS_ROLE_ARN",k="AWS_ROLE_SESSION_NAME",L=(e={})=>async(s)=>{e.logger?.debug("@aws-sdk/credential-provider-web-identity - fromTokenFile");let o=e?.webIdentityTokenFile??process.env[_],r=e?.roleArn??process.env[O],i=e?.roleSessionName??process.env[k];if(!o||!r)throw new a.CredentialsProviderError("Web identity configuration not specified",{logger:e.logger});let n=await c({...e,webIdentityToken:d.externalDataInterceptor?.getTokenRecord?.()[o]??g(o,{encoding:"ascii"}),roleArn:r,roleSessionName:i})(s);if(o===process.env[_])N.setCredentialFeature(n,"CREDENTIALS_ENV_VARS_STS_WEB_ID_TOKEN","h");return n};export{c as fromWebToken,L as fromTokenFile};
+import{S as A}from"./chunk-a1fb8zz6.js";import"./chunk-1f9143dv.js";import{U as I}from"./chunk-45fbwj3s.js";import{V as f}from"./chunk-x7yrxhk9.js";import{Kl as t,Ol as T}from"./chunk-7wkwm0tn.js";var N=t(I(),1),a=t(f(),1),d=t(A(),1);import{readFileSync as g}from"fs";var c=(e)=>async(s)=>{e.logger?.debug("@aws-sdk/credential-provider-web-identity - fromWebToken");let{roleArn:o,roleSessionName:r,webIdentityToken:i,providerId:n,policyArns:m,policy:S,durationSeconds:l}=e,{roleAssumerWithWebIdentity:E}=e;if(!E){let{getDefaultRoleAssumerWithWebIdentity:p}=await import("./chunk-1v70g3kn.js").then((m)=>t(m.default,1));E=p({...e.clientConfig,credentialProviderLogger:e.logger,parentClientConfig:{...s?.callerClientConfig,...e.parentClientConfig}},e.clientPlugins)}return E({RoleArn:o,RoleSessionName:r??`aws-sdk-js-session-${Date.now()}`,WebIdentityToken:i,ProviderId:n,PolicyArns:m,Policy:S,DurationSeconds:l})};var _="AWS_WEB_IDENTITY_TOKEN_FILE",O="AWS_ROLE_ARN",k="AWS_ROLE_SESSION_NAME",L=(e={})=>async(s)=>{e.logger?.debug("@aws-sdk/credential-provider-web-identity - fromTokenFile");let o=e?.webIdentityTokenFile??process.env[_],r=e?.roleArn??process.env[O],i=e?.roleSessionName??process.env[k];if(!o||!r)throw new a.CredentialsProviderError("Web identity configuration not specified",{logger:e.logger});let n=await c({...e,webIdentityToken:d.externalDataInterceptor?.getTokenRecord?.()[o]??g(o,{encoding:"ascii"}),roleArn:r,roleSessionName:i})(s);if(o===process.env[_])N.setCredentialFeature(n,"CREDENTIALS_ENV_VARS_STS_WEB_ID_TOKEN","h");return n};export{c as fromWebToken,L as fromTokenFile};
 
-//# debugId=23E8FCD5B1C4505464756E2164756E21
+//# debugId=94A3DE48E283674D64756E2164756E21

package/dist/{chunk-zrndnz4n.js.map → chunk-r887spwe.js.map}

@@ -6,6 +6,6 @@
     "export const fromWebToken = (init) => async (awsIdentityProperties) => {\n    init.logger?.debug(\"@aws-sdk/credential-provider-web-identity - fromWebToken\");\n    const { roleArn, roleSessionName, webIdentityToken, providerId, policyArns, policy, durationSeconds } = init;\n    let { roleAssumerWithWebIdentity } = init;\n    if (!roleAssumerWithWebIdentity) {\n        const { getDefaultRoleAssumerWithWebIdentity } = await import(\"@aws-sdk/nested-clients/sts\");\n        roleAssumerWithWebIdentity = getDefaultRoleAssumerWithWebIdentity({\n            ...init.clientConfig,\n            credentialProviderLogger: init.logger,\n            parentClientConfig: {\n                ...awsIdentityProperties?.callerClientConfig,\n                ...init.parentClientConfig,\n            },\n        }, init.clientPlugins);\n    }\n    return roleAssumerWithWebIdentity({\n        RoleArn: roleArn,\n        RoleSessionName: roleSessionName ?? `aws-sdk-js-session-${Date.now()}`,\n        WebIdentityToken: webIdentityToken,\n        ProviderId: providerId,\n        PolicyArns: policyArns,\n        Policy: policy,\n        DurationSeconds: durationSeconds,\n    });\n};\n"
   ],
   "mappings": ";6NAAA,SACA,KACA,KACA,iBAAS,WCHF,IAAM,EAAe,CAAC,IAAS,MAAO,IAA0B,CACnE,EAAK,QAAQ,MAAM,0DAA0D,EAC7E,IAAQ,UAAS,kBAAiB,mBAAkB,aAAY,aAAY,SAAQ,mBAAoB,GAClG,8BAA+B,EACrC,GAAI,CAAC,EAA4B,CAC7B,IAAQ,wCAAyC,KAAa,yDAC9D,EAA6B,EAAqC,IAC3D,EAAK,aACR,yBAA0B,EAAK,OAC/B,mBAAoB,IACb,GAAuB,sBACvB,EAAK,kBACZ,CACJ,EAAG,EAAK,aAAa,EAEzB,OAAO,EAA2B,CAC9B,QAAS,EACT,gBAAiB,GAAmB,sBAAsB,KAAK,IAAI,IACnE,iBAAkB,EAClB,WAAY,EACZ,WAAY,EACZ,OAAQ,EACR,gBAAiB,CACrB,CAAC,GDlBL,IAAM,EAAiB,8BACjB,EAAe,eACf,EAAwB,wBACjB,EAAgB,CAAC,EAAO,CAAC,IAAM,MAAO,IAA0B,CACzE,EAAK,QAAQ,MAAM,2DAA2D,EAC9E,IAAM,EAAuB,GAAM,sBAAwB,QAAQ,IAAI,GACjE,EAAU,GAAM,SAAW,QAAQ,IAAI,GACvC,EAAkB,GAAM,iBAAmB,QAAQ,IAAI,GAC7D,GAAI,CAAC,GAAwB,CAAC,EAC1B,MAAM,IAAI,2BAAyB,2CAA4C,CAC3E,OAAQ,EAAK,MACjB,CAAC,EAEL,IAAM,EAAc,MAAM,EAAa,IAChC,EACH,iBAAkB,2BAAyB,iBAAiB,EAAE,IAC1D,EAAa,EAAsB,CAAE,SAAU,OAAQ,CAAC,EAC5D,UACA,iBACJ,CAAC,EAAE,CAAqB,EACxB,GAAI,IAAyB,QAAQ,IAAI,GACrC,uBAAqB,EAAa,wCAAyC,GAAG,EAElF,OAAO",
-  "debugId": "23E8FCD5B1C4505464756E2164756E21",
+  "debugId": "94A3DE48E283674D64756E2164756E21",
   "names": []
 }

package/dist/{chunk-yp4rbknt.js → chunk-rjvpy87k.js}

@@ -1,5 +1,5 @@
 // @bun
 import{constants as M}from"os";var Y=Symbol.for("gemi.server.shutdown");function Q(){let j=globalThis;return j[Y]??={shuttingDown:!1,drained:!1},j[Y]}function R(){return Q().shuttingDown}function f(){Q().shuttingDown=!0}function x(){Q().drained=!0}function W(j=process.env){let z={timeoutMs:U(j.GEMI_SHUTDOWN_TIMEOUT,20),delayMs:U(j.GEMI_SHUTDOWN_DELAY,0),providerTimeoutMs:U(j.GEMI_SHUTDOWN_PROVIDER_TIMEOUT,5)};if(z.delayMs>0&&z.delayMs>=z.timeoutMs)console.warn(`[gemi] GEMI_SHUTDOWN_DELAY (${z.delayMs/1000}s) leaves no time to drain within GEMI_SHUTDOWN_TIMEOUT (${z.timeoutMs/1000}s); in-flight requests will be abandoned on every shutdown. Raise the timeout.`);return z}function U(j,z){let B=j===void 0||j.trim()===""?NaN:Number(j);if(Number.isFinite(B)&&B>=0)return B*1000;if(j!==void 0)console.warn(`[gemi] Ignoring shutdown setting "${j}": expected a number of seconds.`);return z*1000}async function E(j){let{server:z,settings:B}=j,J=Date.now()+B.timeoutMs;f(),console.log(`[gemi] Shutting down: draining in-flight requests (up to ${B.timeoutMs/1000}s).`);let H=!0;if(z){if(B.delayMs>0)await _(Math.min(B.delayMs,J-Date.now()));let O=z.stop(),V=Promise.resolve();try{V=Promise.resolve(j.closeSockets?.()).catch(()=>{})}catch(F){console.error("[gemi] Closing the broadcast sockets failed:",F)}let X=J-Date.now(),$=j.closeSockets?Promise.race([O,Promise.all([V,y(z)])]):O;if(H=X>0?await G($,X):z.pendingRequests===0,!H)console.error(`[gemi] Shutdown grace period elapsed with ${z.pendingRequests} request(s) still in flight; abandoning them.`),z.stop(!0).catch(()=>{})}x();let P=await j.shutdownProviders({timeoutMs:B.providerTimeoutMs}),K=H&&P.failed.length===0&&P.timedOut.length===0;return console.log(`[gemi] Shutdown ${K?"complete":"finished with errors"}.`),K?0:1}function y(j){return new Promise((z)=>{let B=()=>{if(j.pendingRequests===0){z();return}setTimeout(B,50).unref?.()};B()})}async function G(j,z){if(z<=0)return!1;let B,J=await Promise.race([j.then(()=>!0,()=>!0),new Promise((H)=>{B=setTimeout(()=>H(!1),z)})]);return clearTimeout(B),J}function _(j){return new Promise((z)=>setTimeout(z,Math.max(0,j)))}function q(j){if(!R())return j;try{return j.headers.set("Connection","close"),j}catch{let z=new Response(j.body,j);return z.headers.set("Connection","close"),z}}function N(j){return async(z,B)=>{if(Q().drained)return new Response("Service Unavailable",{status:503,headers:{Connection:"close"}});return q(await j(z,B))}}var Z=Symbol.for("gemi.server.signalsInstalled"),w=1000;function D(j,z={}){let B=globalThis;if(B[Z])return;B[Z]=!0;let J=z.repeatWindowMs??w,H,P=(K)=>{if(H!==void 0){if(Date.now()-H<J)return;console.error(`[gemi] ${K} received again; exiting without waiting for the drain.`),process.exit(128+M.signals[K])}H=Date.now(),console.log(`[gemi] ${K} received.`),j().then((O)=>process.exit(O),(O)=>{console.error("[gemi] Shutdown failed:",O),process.exit(1)})};process.on("SIGTERM",P),process.on("SIGINT",P)}
-export{R as vl,f as wl,W as xl,E as yl,q as zl,N as Al,D as Bl};
+export{R as wl,f as xl,W as yl,E as zl,q as Al,N as Bl,D as Cl};
 
-//# debugId=2E1B638F41FE635C64756E2164756E21
+//# debugId=7E46E4EC81EE020C64756E2164756E21

package/dist/{chunk-yp4rbknt.js.map → chunk-rjvpy87k.js.map}

@@ -5,6 +5,6 @@
     "import { constants } from \"node:os\";\nimport type { ShutdownReport } from \"../foundation/Application\";\nimport type { Instrumentation } from \"./types\";\n\n// On `globalThis` under a registry symbol rather than in a module variable, so\n// the flag an app's health route reads is the one the server set even when two\n// copies of this module are loaded — the built CLI bundles its own gemi (see\n// `app/App.ts`), and `bun --hot` re-evaluates every module on a reload.\nconst STATE = Symbol.for(\"gemi.server.shutdown\");\n\ntype ShutdownState = { shuttingDown: boolean; drained: boolean };\n\nfunction state(): ShutdownState {\n  const global = globalThis as { [STATE]?: ShutdownState };\n  global[STATE] ??= { shuttingDown: false, drained: false };\n  return global[STATE];\n}\n\n/**\n * True from the moment this server process has been told to stop — before it\n * stops accepting connections — until it exits.\n *\n * gemi's built-in health route (`./health`) answers `503` while this is true,\n * and so should an app's own health route, so the platform's probe pulls the\n * instance while the in-flight requests are still draining. Every response sent in that window also carries\n * `Connection: close`, so a client that honours it opens its next request on a\n * new connection — one the load balancer can route elsewhere — instead of\n * reusing this one.\n */\nexport function isShuttingDown(): boolean {\n  return state().shuttingDown;\n}\n\nexport function markShuttingDown() {\n  state().shuttingDown = true;\n}\n\n/**\n * The request drain is over and the providers' `shutdown()` may be running:\n * from here on a request must not reach the app. See `serveForShutdown`.\n */\nexport function markDrained() {\n  state().drained = true;\n}\n\n/** Test seam: a fresh process starts false, and so should each test. */\nexport function resetShuttingDown() {\n  state().shuttingDown = false;\n  state().drained = false;\n}\n\nexport type ShutdownSettings = {\n  /**\n   * From the signal to the end of the request drain, in milliseconds — the\n   * delay below included. Requests still in flight when it runs out are\n   * abandoned. `GEMI_SHUTDOWN_TIMEOUT`, in seconds; default 20. `0` means\n   * \"close the listener and do not wait\": a shutdown with nothing in flight is\n   * still a clean one.\n   */\n  timeoutMs: number;\n  /**\n   * How long to keep accepting new requests after `isShuttingDown()` turns\n   * true, in milliseconds, so a health probe can see the `503` and the load\n   * balancer stop routing here before the listener closes.\n   * `GEMI_SHUTDOWN_DELAY`, in seconds; default 0.\n   */\n  delayMs: number;\n  /**\n   * The shared deadline for every provider's `shutdown()`, in milliseconds,\n   * after the drain. `GEMI_SHUTDOWN_PROVIDER_TIMEOUT`, in seconds; default 5.\n   * `0` skips the hooks — deliberately, so it is not reported as a failure.\n   */\n  providerTimeoutMs: number;\n};\n\n/**\n * 20s to drain plus 5s for providers is 25s: under the 30s that Kubernetes,\n * Azure Container Apps and ECS give by default between `SIGTERM` and `SIGKILL`,\n * with 5s left for the `gemi start` relay, the process exit and clock skew\n * between the platform's timer and ours. A platform with a shorter window\n * (Cloud Run's 10s, Fly's 5s) needs these lowered, not the other way round —\n * a drain that outlives the grace period ends in the same `SIGKILL` as no drain.\n *\n * The delay defaults to 0 because it only helps where a probe is watching, and\n * otherwise every shutdown would pay it for nothing.\n */\nexport function shutdownSettings(\n  env: Record<string, string | undefined> = process.env,\n): ShutdownSettings {\n  const settings = {\n    timeoutMs: seconds(env.GEMI_SHUTDOWN_TIMEOUT, 20),\n    delayMs: seconds(env.GEMI_SHUTDOWN_DELAY, 0),\n    providerTimeoutMs: seconds(env.GEMI_SHUTDOWN_PROVIDER_TIMEOUT, 5),\n  };\n  // Warned, not clamped: the delay is sized to a probe, the timeout to the\n  // platform's grace period, and which one is wrong only the operator knows.\n  // Left alone, every shutdown spends the whole timeout in the delay and then\n  // abandons whatever is in flight without draining it.\n  if (settings.delayMs > 0 && settings.delayMs >= settings.timeoutMs) {\n    console.warn(\n      `[gemi] GEMI_SHUTDOWN_DELAY (${settings.delayMs / 1000}s) leaves no time to drain within GEMI_SHUTDOWN_TIMEOUT (${settings.timeoutMs / 1000}s); in-flight requests will be abandoned on every shutdown. Raise the timeout.`,\n    );\n  }\n  return settings;\n}\n\nfunction seconds(value: string | undefined, fallback: number): number {\n  const parsed = value === undefined || value.trim() === \"\" ? NaN : Number(value);\n  if (Number.isFinite(parsed) && parsed >= 0) return parsed * 1000;\n  if (value !== undefined) {\n    console.warn(`[gemi] Ignoring shutdown setting \"${value}\": expected a number of seconds.`);\n  }\n  return fallback * 1000;\n}\n\n/** The part of `Bun.Server` a drain needs. */\nexport type Stoppable = {\n  stop(closeActiveConnections?: boolean): Promise<void>;\n  readonly pendingRequests: number;\n};\n\n/**\n * The shutdown sequence, in its order:\n *\n * 1. `isShuttingDown()` turns true — first, so the health route answers `503`\n *    and responses carry `Connection: close` while the listener is still open.\n * 2. After `delayMs`, the listener closes (`server.stop()` without force):\n *    new connections are refused, while every request in flight — a streamed\n *    response included, to its last chunk — runs to completion.\n *    Broadcast sockets are told `bye` and closed (`closeSockets`): a graceful\n *    stop waits for open WebSockets, which never close on their own.\n * 3. That completion is awaited until `timeoutMs` from the start.\n * 4. From here a request is refused with a `503` before it reaches the app\n *    (`serveForShutdown`), and every provider's `shutdown()` runs, reverse\n *    order, `providerTimeoutMs`.\n *\n * Resolves with the exit code: 0 when every step finished in time, 1 when the\n * drain was cut short or a provider failed or overran.\n *\n * Two things `stop()` does not do, both measured on Bun 1.3.14, and both why\n * the process exit that follows is what actually ends the server:\n *\n * - It does not close a kept-alive connection. One that is idle when the\n *   listener closes stays open, and a request sent down it afterwards is\n *   served. That is what the `Connection: close` on every response in the\n *   window is for: a client (or a proxy in front) that honours it opens its\n *   next request on a new connection, which the closed listener refuses. A\n *   client that does not honour it is what step 4's `503` is for — Bun does\n *   not close the socket after a `Connection: close` response either (#566).\n * - `stop(true)` issued after a graceful `stop()` does not cut the remaining\n *   requests off; it waits for the same ones. It is still called when the\n *   drain times out, for a Bun that does, but nothing here depends on it. Nor\n *   does it close an idle kept-alive connection. Only a `stop(true)` issued\n *   *first* does that, and it cuts off the requests in flight with it, which\n *   is the drain given up — so the idle ones are refused, not closed.\n */\nexport async function drain(params: {\n  server: Stoppable | undefined;\n  /**\n   * Says `bye` to the broadcast sockets and closes them, right after the\n   * listener closes, and resolves once they are closed or cut. A graceful\n   * `stop()` waits for open WebSockets, which otherwise never close on their\n   * own.\n   */\n  closeSockets?: () => void | Promise<void>;\n  shutdownProviders: (options: { timeoutMs: number }) => Promise<ShutdownReport>;\n  settings: ShutdownSettings;\n}): Promise<number> {\n  const { server, settings } = params;\n  const deadline = Date.now() + settings.timeoutMs;\n\n  markShuttingDown();\n  console.log(\n    `[gemi] Shutting down: draining in-flight requests (up to ${settings.timeoutMs / 1000}s).`,\n  );\n\n  let drained = true;\n  if (server) {\n    if (settings.delayMs > 0) {\n      await sleep(Math.min(settings.delayMs, deadline - Date.now()));\n    }\n    const stopped = server.stop();\n    let socketsClosed: Promise<unknown> = Promise.resolve();\n    try {\n      socketsClosed = Promise.resolve(params.closeSockets?.()).catch(() => {});\n    } catch (error) {\n      console.error(\"[gemi] Closing the broadcast sockets failed:\", error);\n    }\n    // No time left to wait — a `GEMI_SHUTDOWN_TIMEOUT` of 0, or a delay that\n    // spent all of it — is \"do not wait for what is in flight\", and that is\n    // only a failure when something *is* in flight. Reading it as one made\n    // every clean shutdown log an abandonment and exit 1 for the operator who\n    // zeroed the budget to fit a 5s grace period, with nothing to abandon.\n    const remaining = deadline - Date.now();\n    // With broadcast sockets, the stop's own promise has been seen to stay\n    // pending for good after every request finished and every socket was\n    // closed or terminated (Bun 1.4.2 on a loaded Linux CI runner, with its\n    // `pendingWebSockets` stuck above 0). So the drain also ends on its real\n    // condition: no request in flight, and the hub's sockets closed or cut.\n    const done = params.closeSockets\n      ? Promise.race([stopped, Promise.all([socketsClosed, noRequestInFlight(server)])])\n      : stopped;\n    drained =\n      remaining > 0 ? await settlesWithin(done, remaining) : server.pendingRequests === 0;\n    if (!drained) {\n      console.error(\n        `[gemi] Shutdown grace period elapsed with ${server.pendingRequests} request(s) still in flight; abandoning them.`,\n      );\n      void server.stop(true).catch(() => {});\n    }\n  }\n\n  // Whether or not the drain finished: a request that arrives now, down a\n  // kept-alive connection the listener's close left open, would run against\n  // providers that are being shut down underneath it.\n  markDrained();\n  const report = await params.shutdownProviders({ timeoutMs: settings.providerTimeoutMs });\n  const clean = drained && report.failed.length === 0 && report.timedOut.length === 0;\n  console.log(`[gemi] Shutdown ${clean ? \"complete\" : \"finished with errors\"}.`);\n  return clean ? 0 : 1;\n}\n\n/**\n * Resolves once `server` has no request in flight. A streamed response counts\n * until its last chunk (measured on Bun 1.4, macOS and Linux).\n */\nfunction noRequestInFlight(server: Stoppable): Promise<void> {\n  return new Promise((resolve) => {\n    const check = () => {\n      if (server.pendingRequests === 0) {\n        resolve();\n        return;\n      }\n      const timer = setTimeout(check, 50);\n      (timer as { unref?: () => void }).unref?.();\n    };\n    check();\n  });\n}\n\nasync function settlesWithin(promise: Promise<unknown>, ms: number): Promise<boolean> {\n  // `drain` decides for itself what a budget that is already spent means, so\n  // this is only a guard: a race against `setTimeout(0)` is a coin toss, and\n  // \"did not settle within no time at all\" is the honest answer to it.\n  if (ms <= 0) return false;\n  let timer: ReturnType<typeof setTimeout> | undefined;\n  const result = await Promise.race([\n    promise.then(\n      () => true,\n      () => true,\n    ),\n    new Promise<false>((resolve) => {\n      timer = setTimeout(() => resolve(false), ms);\n    }),\n  ]);\n  clearTimeout(timer);\n  return result;\n}\n\nfunction sleep(ms: number) {\n  return new Promise((resolve) => setTimeout(resolve, Math.max(0, ms)));\n}\n\n/**\n * `Connection: close` on a response sent while shutting down, so the client's\n * next request opens a connection — which the load balancer can send elsewhere\n * — instead of reusing this one.\n *\n * The spec makes some responses' headers immutable (a `Response.redirect`, a\n * proxied `fetch`), and setting one throws. Bun 1.3.14 lets both be set, so\n * the copy is for a Bun that follows the spec — a throw here would turn every\n * such response in the drain window into a 500.\n */\nexport function closeConnectionWhileShuttingDown(res: Response): Response {\n  if (!isShuttingDown()) return res;\n  try {\n    res.headers.set(\"Connection\", \"close\");\n    return res;\n  } catch {\n    const copy = new Response(res.body, res);\n    copy.headers.set(\"Connection\", \"close\");\n    return copy;\n  }\n}\n\n/**\n * What every response goes through while this process serves: the app's\n * instrumentation, with the two changes a shutdown makes to it.\n *\n * - While the requests in flight drain, a response carries `Connection: close`\n *   (`closeConnectionWhileShuttingDown`).\n * - Once they have drained, a request is answered `503` with\n *   `Connection: close` and reaches neither the app nor its instrumentation.\n *   The listener is closed by then, so only a kept-alive connection can still\n *   deliver one, and `server.stop()` leaves those open. Serving it would run a\n *   handler against providers whose `shutdown()` is closing the pool, the\n *   queue or the cache it uses — until the process exits. The instrumentation\n *   is skipped too because it is app code, and a tracer or error reporter is\n *   exactly what a provider flushes and closes at this point.\n */\nexport function serveForShutdown(instrumentation: Instrumentation): Instrumentation {\n  return async (req, next) => {\n    if (state().drained) {\n      return new Response(\"Service Unavailable\", {\n        status: 503,\n        headers: { Connection: \"close\" },\n      });\n    }\n    return closeConnectionWhileShuttingDown(await instrumentation(req, next));\n  };\n}\n\n// Installed once per process, not once per `Server`: a listener per instance\n// would each start a shutdown of its own, and read the other's signal as the\n// second one.\nconst SIGNALS_INSTALLED = Symbol.for(\"gemi.server.signalsInstalled\");\n\n/**\n * A repeat of the first signal inside this window is the same shutdown\n * delivered twice, not an operator asking to skip the drain. One shutdown\n * routinely arrives more than once, milliseconds apart: Ctrl+C on\n * `bun run start` reaches the server directly (the whole foreground group is\n * signalled), and again through `gemi start`'s relay — twice over, since\n * `bun run` forwards it to `gemi start` too. systemd's default\n * `KillMode=control-group` and `tini -g` do the same to every process in the\n * group. A person pressing Ctrl+C again is well outside a second.\n */\nconst REPEAT_WINDOW_MS = 1000;\n\n/**\n * `SIGTERM` or `SIGINT` runs `stop` and exits with the code it resolves with.\n * Another signal of either kind, more than `repeatWindowMs` after the first,\n * exits at once with `128 + n` — an operator pressing Ctrl+C again does not\n * want to wait out the grace period. Without a listener the first signal would\n * do that too: the default action for both is to terminate the process on the\n * spot.\n */\nexport function installShutdownSignals(\n  stop: () => Promise<number>,\n  options: { repeatWindowMs?: number } = {},\n) {\n  const global = globalThis as { [SIGNALS_INSTALLED]?: boolean };\n  if (global[SIGNALS_INSTALLED]) return;\n  global[SIGNALS_INSTALLED] = true;\n\n  const repeatWindowMs = options.repeatWindowMs ?? REPEAT_WINDOW_MS;\n  let receivedAt: number | undefined;\n  const onSignal = (signal: \"SIGTERM\" | \"SIGINT\") => {\n    if (receivedAt !== undefined) {\n      if (Date.now() - receivedAt < repeatWindowMs) return;\n      console.error(`[gemi] ${signal} received again; exiting without waiting for the drain.`);\n      process.exit(128 + constants.signals[signal]);\n    }\n    receivedAt = Date.now();\n    console.log(`[gemi] ${signal} received.`);\n    stop().then(\n      (code) => process.exit(code),\n      (error) => {\n        console.error(\"[gemi] Shutdown failed:\", error);\n        process.exit(1);\n      },\n    );\n  };\n  process.on(\"SIGTERM\", onSignal);\n  process.on(\"SIGINT\", onSignal);\n}\n"
   ],
   "mappings": "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",
-  "debugId": "2E1B638F41FE635C64756E2164756E21",
+  "debugId": "7E46E4EC81EE020C64756E2164756E21",
   "names": []
 }

package/dist/{chunk-attv9byj.js → chunk-t1abd8jv.js}

@@ -1,5 +1,5 @@
 // @bun
-import{ek as n,fk as k,hk as T0}from"./chunk-ktgmrjj3.js";import{ik as S0}from"./chunk-n1b6r6s9.js";import{kk as N0,lk as R0,mk as Q0,ok as D,qk as q,zk as B0}from"./chunk-24vv42t6.js";import{Ok as X0}from"./chunk-kzny5cj2.js";import{jl as W0,ml as m}from"./chunk-edj701p0.js";import{vl as M0}from"./chunk-yp4rbknt.js";class y{table;sql;dialect;connection;busyTimeout;configured;constructor(z,V={}){let Y=V.table??"gemi_locks";if(!/^[A-Za-z_][A-Za-z0-9_]*$/.test(Y))throw Error(`The lock table name "${Y}" is not a plain identifier. Use letters, digits and underscores.`);this.table=Y,this.sql=z.sql,this.dialect=z.dialect,this.connection=z.name,this.busyTimeout=V.busyTimeout??1000}async createTable(){await this.configure();for(let z of v0(this.dialect,this.table))await this.sql.unsafe(z)}async acquire(z,V,Y){await this.configure();let Z=this.sql,$=this.now(Z);if(await this.seed(Z,z),this.mysql){let H=await Z`
+import{fk as n,gk as k,ik as T0}from"./chunk-h16bfh2v.js";import{jk as S0}from"./chunk-x1s1r6ch.js";import{Ak as B0,lk as N0,mk as R0,nk as Q0,pk as D,rk as q}from"./chunk-pme2yb8p.js";import{Pk as X0}from"./chunk-9fpecjxg.js";import{kl as W0,nl as m}from"./chunk-fr6e5g2z.js";import{wl as M0}from"./chunk-rjvpy87k.js";class y{table;sql;dialect;connection;busyTimeout;configured;constructor(z,V={}){let Y=V.table??"gemi_locks";if(!/^[A-Za-z_][A-Za-z0-9_]*$/.test(Y))throw Error(`The lock table name "${Y}" is not a plain identifier. Use letters, digits and underscores.`);this.table=Y,this.sql=z.sql,this.dialect=z.dialect,this.connection=z.name,this.busyTimeout=V.busyTimeout??1000}async createTable(){await this.configure();for(let z of v0(this.dialect,this.table))await this.sql.unsafe(z)}async acquire(z,V,Y){await this.configure();let Z=this.sql,$=this.now(Z);if(await this.seed(Z,z),this.mysql){let H=await Z`
         UPDATE ${this.name(Z)}
         SET owner = ${V}, token = token + 1, expires_at = ${$} + ${this.ms(Z,Y)},
             updated_at = ${$}
@@ -411,6 +411,6 @@ ADD COLUMN IF NOT EXISTS "progress" ${Y}`,`CREATE INDEX IF NOT EXISTS "${V}_batc
         }
       };
     `],"worker.ts"),$=URL.createObjectURL(Z);return new Worker($)}async function d0(z,V){let Y=w0();return Y.postMessage({jobName:z,args:V}),await new Promise((Z,$)=>{Y.onmessage=(X)=>{let H=X.data;if("error"in H)$(H.error);else Z(H.result)}})}var c0=new k0("gemi.queue"),l0=60000;class h{static token="queue";jobs={};config;driver;application;inFlight=new Map;state="idle";looping=!1;claiming;woken=!1;claimFailures=0;resume;unsubscribe;heartbeatTimer;releasedNames=new Set;lockManager;workflowRuntime;constructor(z={},V={}){if(this.config=S0(D0(),z),this.application=V.application,this.driver=r0(this.config.driver,this.application),this.useJobs(this.config.jobs),this.config.workflows.length>0)this.useWorkflows(this.config.workflows)}useJobs(z){this.config.jobs=z,this.jobs={};for(let V of z)this.claim(V);this.registerTickJob()}useWorkflows(z){this.config.workflows=z,this.workflows.use(z),this.registerTickJob()}get registeredWorkflows(){return[...this.config.workflows]}get workflows(){return this.workflowRuntime??=new H0(this),this.workflowRuntime}registerTickJob(){if(!this.workflowRuntime||Object.keys(this.workflowRuntime.workflows).length===0)return;let z=this.workflowRuntime.tickJob;if(this.jobs[z.name]&&this.jobs[z.name]!==z){console.error(`A queued job is named "${z.name}", which the workflow runtime uses. Workflows will not run until it is renamed.`);return}this.jobs[z.name]=z}registerJob(z){this.config.jobs=[...this.config.jobs,z],this.claim(z)}claim(z){if(this.jobs[z.name]){console.error(`Two queued jobs are named "${z.name}" \u2014 the first is registered `+"and this one is not, so dispatching either would have run one of them. A class name is the queue's key, so only one job can hold it. Rename one.");return}this.jobs[z.name]=z}get registeredJobs(){return[...this.config.jobs]}dispatchJob(z,V){if(this.jobs[z])return new this.jobs[z]().run(JSON.parse(V))}push(z,V,Y={}){let Z=this.uniqueKey(z,V);if(Z)return this.pushUnique(z,V,Z,Y);let $=this.driver.joinsTransaction?.()===!0;if(!$){let X=Bun.randomUUIDv7();if(D(()=>this.record(z,V,{id:X,reportFailure:!0,committed:!0}).then(()=>{},()=>{})))return Promise.resolve(X)}return this.record(z,V,{reportFailure:Y.reportFailure,joins:$})}pushBatch(z,V,Y={}){let Z=this.buildBatch(z,V,Y),$={id:Z.id,total:V.length},X=this.driver.joinsTransaction?.()===!0;if(!X){if(D(()=>this.recordBatch(Z,{committed:!0}).then(()=>{},()=>{})))return Promise.resolve($)}return this.recordBatch(Z,{joins:X}).then(()=>$)}buildBatch(z,V,Y={}){if(!this.driver.enqueueBatch)throw Error("This queue's driver does not support batches. The memory and database drivers do.");if(new z().worker)throw Error(`${z.name} is a worker job, and a worker job cannot be dispatched in a batch: its thread has no way to report progress or reach the batch.`);if(z.prototype.uniqueId!==S.prototype.uniqueId)throw Error(`${z.name} is unique (it defines uniqueId), and a unique job cannot be dispatched in a batch: a duplicate would resolve to a job outside the batch, and the batch would wait for it forever.`);let $={};for(let X of["then","catch","finally"]){let H=Y[X];if(H===void 0)continue;if(typeof H?.name!=="string"||!Array.isArray(H.args))throw Error(`The batch's ${X} callback is not a job call. Build it with SomeJob.with(...args).`);$[X]={name:H.name,args:H.args}}return{id:Bun.randomUUIDv7(),name:Y.name??null,job:z.name,args:V,allowFailures:Y.allowFailures===!0,callbacks:$}}recordBatch(z,V){let Y=this.driver.enqueueBatch(z);this.startIfIdle();let Z=()=>!this.driver.subscribe&&this.state==="running"&&this.wake(),$=V.joins===!0&&D(Z);return Y.then(()=>$||Z(),(X)=>{if(!V.committed)return;console.error(`[gemi] The queue driver could not record a batch of ${z.job}, which was held until its transaction committed. The transaction stays committed; the batch's jobs did not run and will not be retried.`,X)}),Y}async findBatch(z){if(!this.driver.findBatch)throw Error("This queue's driver does not support batches.");return this.driver.findBatch(z)}async cancelBatch(z){if(!this.driver.cancelBatch)throw Error("This queue's driver does not support batches.");let V=await this.driver.cancelBatch(z);if(V)this.claimSoon();return V}get locks(){return this.lockManager??=new T0(this.resolveLockStore()),this.lockManager}resolveLockStore(){let z=this.config.locks;if(z==="auto"){let V=this.driver.lockStore?.();if(V)return V;if(this.durable)console.warn('[gemi] The queue driver keeps no locks, so unique jobs, withoutOverlapping and onOneServer only hold within this process. Set the queue slice\'s `locks` to "database" or a LockStore.');return new p}if(z==="memory")return new p;if(z==="database"||typeof z==="function"){if(!this.application&&(z==="database"||z.length>0))throw Error("The queue's locks need the application they belong to, and this QueueManager was built without one. Pass { application }.");if(z==="database")return new y(this.application.make(X0));return z(this.application)}if(typeof z==="string")throw Error(`Unknown queue locks "${z}". The queue slice's locks is "auto", "memory", "database", a LockStore, or a function returning one.`);return z}uniqueKey(z,V){if(z.prototype.uniqueId===S.prototype.uniqueId)return;let Y=new z,Z=Y.uniqueId(...JSON.parse(V));if(Z===void 0||Z===null||Z==="")return;return{key:L0(z.name,Z),ttl:Math.max(1,Y.uniqueFor)}}pushUnique(z,V,Y,Z){let $=Bun.randomUUIDv7();if(D(()=>this.recordUnique(z,V,Y,$,{report:!0,committed:!0}).then(()=>{},()=>{})))return Promise.resolve($);return this.recordUnique(z,V,Y,$,{report:Z.reportFailure!==!1,committed:!1})}recordUnique(z,V,Y,Z,$){let X=this.locks.store,H=(async()=>{for(let G=0;G<5;G++){if(await X.acquire(Y.key,Z,Y.ttl)!==null)try{return await this.record(z,V,{id:Z,reportFailure:!1})}catch(B){throw await X.release(Y.key,Z).catch(()=>{}),B}let Q=await X.holder(Y.key);if(Q)return Q.owner}throw Error(`The unique key "${Y.key}" kept changing hands, so ${z.name} was not queued.`)})();return H.catch((G)=>{if(!$.report)return;console.error(`[gemi] The queue could not record the unique job ${z.name}`+($.committed?", which was held until its transaction committed. The transaction stays committed; the job did not run and will not be retried.":", so it did not run and will not be retried."),G)}),H}async releaseUnique(z,V,Y){if(z.uniqueId===S.prototype.uniqueId)return;try{let Z=z.uniqueId(...V);if(Z===void 0||Z===null||Z==="")return;await this.locks.store.release(L0(Y.name,Z),Y.id)}catch(Z){console.error(`[gemi] Could not free the unique key of ${Y.name} (${Y.id}); it frees itself after uniqueFor.`,Z)}}record(z,V,Y){let Z=this.driver.enqueue({name:z.name,args:V,...Y.id===void 0?{}:{id:Y.id}});this.startIfIdle();let $=()=>!this.driver.subscribe&&this.state==="running"&&this.wake(),X=Y.joins===!0&&D($);return Z.then(()=>X||$(),(H)=>{if(Y.reportFailure===!1)return;console.error(`[gemi] The queue driver could not record ${z.name}`+(Y.committed?", which was held until its transaction committed. The transaction stays committed; the job did not run and will not be retried.":", so it did not run and will not be retried."),H)}),Z}async retryDead(z){if(!this.driver.retryDead)throw Error("This queue's driver keeps nothing of a dead-lettered job, so there is nothing to retry. The database driver keeps them.");let V=await this.driver.retryDead(z);if(V)this.claimSoon();return V}startIfIdle(){if(this.state==="idle"&&(!this.durable||this.mayClaimHere()))this.start()}claimSoon(){if(this.startIfIdle(),!this.driver.subscribe&&this.state==="running")this.wake()}start(){if(this.state==="running")return;if(this.state="running",this.durable&&this.application&&this.mayClaimHere()&&!i0())globalThis.__gemiDevQueue=this;if(this.unsubscribe=this.driver.subscribe?.(()=>this.wake()),this.looping)return this.wake();c0.runInAsyncScope(()=>void this.loop())}async drain(z=1/0){if(this.state="stopped",globalThis.__gemiDevQueue===this)globalThis.__gemiDevQueue=void 0;this.unsubscribe?.(),this.unsubscribe=void 0,this.wake();let V,Y=new Promise(($)=>{if(z!==1/0)V=setTimeout($,z)}),Z=(async()=>{await this.claiming?.catch(()=>{}),await Promise.allSettled([...this.inFlight.values()].map(($)=>$.done))})();return await Promise.race([Z,Y]),clearTimeout(V),{unfinished:[...this.inFlight.values()].map(($)=>({...$.job}))}}stop(){return this.drain(0)}get running(){return this.inFlight.size}async loop(){this.looping=!0;try{await this.claimWhileRunning()}finally{this.looping=!1}}async claimWhileRunning(){while(this.state==="running"){let z=this.durable&&M0()?0:this.config.concurrency-this.inFlight.size;if(z>0){this.woken=!1;let V=this.driver.claim(z,{...this.lease(),registered:{names:Object.keys(this.jobs),graceMs:this.config.unknownJobGrace}});this.claiming=V;let Y=[];try{Y=await V,this.claimFailures=0}catch(Z){this.claimFailures++,console.error(`The queue could not claim jobs from its driver; it will try again in ${this.retryDelay()}ms.`,Z)}finally{this.claiming=void 0}for(let Z of Y)this.execute(Z);if(Y.length===z)continue;if(this.woken&&this.inFlight.size<this.config.concurrency)continue}await this.sleep()}}sleep(){return new Promise((z)=>{let V,Y=this.claimFailures>0?this.retryDelay():this.driver.subscribe?void 0:this.config.pollInterval;if(Y!==void 0)V=setTimeout(()=>this.wake(),Y),V.unref?.();this.resume=()=>{clearTimeout(V),z()}})}retryDelay(){let z=Math.min(Math.max(0,this.claimFailures-1),30);return Math.min(this.config.pollInterval*2**z,l0)}wake(){this.woken=!0;let z=this.resume;this.resume=void 0,z?.()}get durable(){return!(this.driver instanceof i)}mayClaimHere(){return!this.application||s0()}lease(){return{visibilityTimeoutMs:this.config.visibilityTimeout}}execute(z){let V=`${z.id}:${z.attempt}`,Y=()=>this.run(z),Z=(this.application?W0.run(this.application,Y):Y()).catch(($)=>{console.error(`The queue could not record the outcome of ${z.name}.`,$)}).finally(()=>{this.inFlight.delete(V),this.wake()});this.inFlight.set(V,{job:z,done:Z}),this.heartbeat()}heartbeat(){let z=this.driver;if(!z.heartbeat||this.heartbeatTimer)return;this.heartbeatTimer=setInterval(()=>{if(this.inFlight.size===0){clearInterval(this.heartbeatTimer),this.heartbeatTimer=void 0;return}let V=[...this.inFlight.values()].map((Y)=>Y.job);z.heartbeat(V,this.lease()).catch((Y)=>{console.error("The queue could not extend its job leases.",Y)})},Math.max(1,Math.floor(this.config.visibilityTimeout/3))),this.heartbeatTimer.unref?.()}async run(z){let V=this.jobs[z.name];if(!V){let B=Date.now()-z.createdAt;if(this.durable&&B<this.config.unknownJobGrace){if(!this.releasedNames.has(z.name))this.releasedNames.add(z.name),console.error(`Left a queued "${z.name}" for another replica: nothing is registered here under that name. It is dead-lettered if no replica has run it within unknownJobGrace (${this.config.unknownJobGrace}ms) of its dispatch.`);await this.driver.release(z,{retryInMs:Math.round(this.config.pollInterval*(1+Math.random()))});return}console.error(`Dropped a queued job: nothing is registered under the name "${z.name}". If the class exists, it was not `+"discovered \u2014 check that it is under the queue slice's jobsDir "+"(app/jobs by default), or list it in app/config/queue.ts."),await this.driver.fail(z,{error:`No job is registered under the name "${z.name}".`,retryInMs:null});return}let Y;try{Y=new V}catch(B){console.error(`Dropped a queued ${z.name}: it could not be constructed.`,B),await this.driver.fail(z,{error:`The job could not be constructed: ${String(B)}`,retryInMs:null});return}let Z;try{Z=JSON.parse(z.args)}catch(B){console.error(`Dropped a queued ${z.name}: its arguments are not JSON.`,B),await this.driver.fail(z,{error:`The arguments are not JSON: ${String(B)}`,retryInMs:null});return}if(z.attempt>Math.max(1,Y.maxAttempts)){let B=Error(`${z.name} was claimed for attempt ${z.attempt} of ${Y.maxAttempts}: an earlier attempt never finished, most likely because the process running it exited. Dead-lettered without running it again.`);$0(`${z.name}.onDeadletter`,()=>Y.onDeadletter(B,...Z)),await this.driver.fail(z,{error:B.message,retryInMs:null}),await this.releaseUnique(Y,Z,z);return}if(Y.$claimed={...z},z.batchId!==void 0){if((await this.driver.findBatch?.(z.batchId,{progress:!1}))?.cancelledAt!=null){await this.driver.fail(z,{error:"Its batch was cancelled before it ran.",retryInMs:null,cancelled:!0});return}let K=this.batchHandle(z);Y.batch=K.batch,Y.$progress=K.progress}let $=await this.admit(Y,Z,z);if(!$)return;let X,H;try{H=await(Y.worker?d0(z.name,z.args):Y.run(...Z))}catch(B){X=B}finally{await $.done()}let G=Y.$outcome;if(X===void 0&&G?.kind==="release"){await this.driver.release(z,{retryInMs:Math.max(0,G.delayMs)});return}if(X===void 0&&G?.kind==="fail")X=G.error;let Q=G?.kind==="fail"?G.retry:!0;if(X===void 0)try{Y.onSuccess(H,...Z)}catch(B){X=B}if(X!==void 0){let B=String(X?.stack??X);if($0(`${z.name}.onFail`,()=>Y.onFail(X,...Z)),!Q||z.attempt>=Y.maxAttempts)$0(`${z.name}.onDeadletter`,()=>Y.onDeadletter(X,...Z)),await this.driver.fail(z,{error:B,retryInMs:null}),await this.releaseUnique(Y,Z,z);else await this.driver.fail(z,{error:B,retryInMs:s(Y.backoff,z.attempt)});return}await this.driver.complete(z),await this.releaseUnique(Y,Z,z)}batchHandle(z){let V=z.batchId,Y=this.driver;return{batch:{id:V,cancelled:async()=>(await Y.findBatch?.(V,{progress:!1}))?.cancelledAt!=null},progress:(Z)=>Y.reportProgress?.(z,Z)??Promise.resolve()}}async admit(z,V,Y){let Z=z.concurrency(...V),$=[z.throttle(...V)??[]].flat();if(!Z&&$.length===0)return{done:async()=>{}};let X=this.locks,H;if(Z&&Z.limit>0){let Q=this.config.visibilityTimeout;for(let B=0;B<Z.limit&&!H;B++)H=await X.acquire(`gemi:concurrency:${Z.key}:${B}`,{ttl:Q,renew:!0})??void 0;if(!H){await this.driver.release(Y,{retryInMs:Math.round(this.config.pollInterval*(1+Math.random()))});return}}let G=[];for(let Q of $){let B=`gemi:throttle:${Q.key}`,K=await X.store.hit(B,Q.limit,Q.window);if(!K.allowed){await Promise.all(G.map((A)=>X.store.refund(A))),await H?.release(),await this.driver.release(Y,{retryInMs:Math.max(1,K.resetInMs)});return}G.push(B)}return{done:async()=>{await H?.release().catch((Q)=>{console.error(`[gemi] Could not free a concurrency slot of ${Y.name}.`,Q)})}}}}function L0(z,V){return`gemi:job:${z}:${String(V)}`}function $0(z,V){try{V()}catch(Y){console.error(`${z} threw; the job's claim was ended anyway.`,Y)}}function i0(){return Bun.env.NODE_ENV==="production"}function s0(){if(!p0)return!1;if(a0())return!0;return process.env.ROOT_DIR!==void 0&&!n0()}function n0(z=process.env){return(z.GEMI_QUEUE_CLAIM??"").trim().toLowerCase()==="off"}var x0=Symbol.for("gemi.queue.worker");function cz(z=!0){globalThis[x0]=z}function a0(){return globalThis[x0]===!0}function r0(z,V){if(z==="memory")return new i;if(z==="database"||typeof z==="function"){if(!V&&(z==="database"||z.length>0))throw Error("The queue driver needs the application it belongs to, and this QueueManager was built without one. Pass { application }.");if(z==="database")return new z0(V.make(X0));return z(V)}if(typeof z==="string")throw Error(`Unknown queue driver "${z}". The queue slice's driver is "memory", "database", a QueueDriver, or a function returning one.`);return z}class S{static name="unset";worker=!1;maxAttempts=3;backoff=0;uniqueId(...z){return}uniqueFor=3600000;throttle(...z){return}concurrency(...z){return}release(z=0){this.$outcome={kind:"release",delayMs:z}}fail(z,V={}){this.$outcome={kind:"fail",error:z instanceof Error?z:Error(String(z)),retry:V.retry??!0}}batch=void 0;async progress(z){let V=E(z);await this.$progress?.(V)}$progress;$claimed;$outcome;run(...z){}onFail(z,...V){}onSuccess(z,...V){}onDeadletter(z,...V){}static dispatch(...z){if(this.name==="unset")throw Error("Cannot dispatch a job with no name");return m(h).push(this,JSON.stringify(z))}static dispatchBatch(z,V={}){if(this.name==="unset")throw Error("Cannot dispatch a job with no name");return m(h).pushBatch(this,z.map((Y)=>JSON.stringify(Y)),V)}static with(...z){if(this.name==="unset")throw Error("Cannot use a job with no name as a callback");return JSON.stringify(z),{name:this.name,args:z}}static findBatch(z){return m(h).findBatch(z)}static cancelBatch(z){return m(h).cancelBatch(z)}}var r=["completed","failed","cancelled"],t0=1000;class H0{queue;registry={};storeInstance;tickClass;reportedNames=new Set;constructor(z){this.queue=z}get workflows(){return this.registry}use(z){this.registry={};for(let V of z){if(V.name==="unset"||!V.name){console.error("A workflow class has no `static name`, so it was not registered. Add one.");continue}if(this.registry[V.name]){console.error(`Two workflows are named "${V.name}" \u2014 the first is registered `+"and this one is not. A workflow's name is its key in storage. Rename one.");continue}this.registry[V.name]=V}}get tickJob(){return this.tickClass??=o0(this),this.tickClass}get store(){if(!this.storeInstance){let z=this.queue.driver.workflowStore?.();if(!z||!this.queue.driver.enqueueBatch)throw Error("This queue's driver does not support workflows. The memory and database drivers do.");this.storeInstance=z}return this.storeInstance}start(z,V){if(z.name==="unset"||!z.name)throw Error("Cannot start a workflow with no name");let Y=this.store,Z={id:Bun.randomUUIDv7(),name:z.name,args:u(V,`The arguments of ${z.name}`)??"[]"},$=()=>this.queue.claimSoon(),X=Y.joinsTransaction?.()===!0;if(!X){if(D(()=>Y.create(Z).then($,(B)=>{console.error(`[gemi] The queue could not record the workflow ${z.name}, which was held until its transaction committed. The transaction stays committed; the workflow did not start.`,B)})))return Promise.resolve(Z.id)}let H=Y.create(Z),G=X&&D($);return H.then(()=>{if(!G)$();return Z.id})}async signal(z,V,Y){if(typeof V!=="string"||V.length===0||V.length>191)throw TypeError("A signal key is a string of 1 to 191 characters.");let Z=u(Y,`The payload of signal "${V}"`),$=await this.store.update(z,{key:V},({workflow:X,step:H,now:G})=>{if(r.includes(X.status)||X.status==="cancelling")return{result:!1};if(!H)return{result:!0,step:{workflowId:z,key:V,status:"signalled",attempt:0,output:Z,error:null,batchId:null,wakeAt:null,startedAt:null,finishedAt:G,createdAt:G,updatedAt:G}};if(H.status!=="waiting")return{result:!1};return{result:!0,step:{...H,status:"signalled",output:Z,wakeAt:H.wakeAt,finishedAt:G},tick:{delayMs:0}}});if($)this.queue.claimSoon();return $===!0}async cancel(z){let V=await this.store.update(z,{allSteps:!0},({workflow:Y,steps:Z})=>{if(r.includes(Y.status)||Y.status==="cancelling")return{result:!1};return{result:!0,workflow:{status:"cancelling"},cancelBatches:Z.filter(($)=>$.status==="batching"&&$.batchId!==null).map(($)=>$.batchId),tick:{delayMs:0}}});if(V)this.queue.claimSoon();return V===!0}async find(z){let V=await this.store.find(z);if(!V)return null;let{workflow:Y,steps:Z}=V,$=[];try{$=JSON.parse(Y.args)}catch{}return{id:Y.id,name:Y.name,status:Y.status,args:$,currentStep:Y.currentStep,progress:Y.progress,result:e0(Y.result),error:Y.error,steps:await Promise.all(Z.map(async(X)=>{let H={key:X.key,status:X.status,attempt:X.attempt,error:X.error,batchId:X.batchId,wakeAt:X.wakeAt,startedAt:X.startedAt,finishedAt:X.finishedAt};if(X.batchId===null)return H;let G=await this.queue.driver.findBatch?.(X.batchId);return G?{...H,progress:G.progress}:H})),createdAt:Y.createdAt,updatedAt:Y.updatedAt}}async tick(z,V){let Y=this.store,Z=V.$claimed,$=Z?`${Z.id}:${Z.attempt}`:`${crypto.randomUUID()}:1`,X=Math.max(1,this.queue.config.visibilityTimeout),H=await Y.acquire(z,$,X);if(H.kind!=="acquired")return;let{workflow:G}=H,Q=(J={})=>Y.update(z,{owner:$},()=>({...J,result:void 0,unlock:!0})).then(()=>this.queue.claimSoon()).catch((P)=>{if(!(P instanceof R))throw P});if(r.includes(G.status))return Q();let B=this.registry[G.name];if(!B)return this.unknown(G,V,Q);let K;try{K=JSON.parse(G.args)}catch(J){return Q({workflow:{status:"failed",error:`The arguments are not JSON: ${a(J)}`}})}let A=setInterval(()=>{Y.renew(z,$,X).catch((J)=>{console.error(`[gemi] Could not extend the hold on workflow ${z}.`,J)})},Math.max(1,Math.floor(X/3)));A.unref?.();let U=G.status==="cancelling",F=new Z0({workflowId:z,owner:$,store:Y,steps:H.steps,cancelling:U,findBatch:(J)=>this.queue.driver.findBatch?.(J,{progress:!1})??Promise.resolve(null),buildBatch:(J,P,N)=>this.queue.buildBatch(J,P.map((C)=>JSON.stringify(C)),{name:N.name,allowFailures:N.allowFailures,finally:{name:I,args:[z]}}),scheduled:()=>this.queue.claimSoon(),cancelCheckMs:t0});try{let J;try{let P=new B,N=await(U?P.onCancel(F,...K):P.run(F,...K));J=F.suspension?{kind:"suspended"}:{kind:"completed",result:U?null:u(N,`The result of ${G.name}`)}}catch(P){if(J=F.suspension||P instanceof g?{kind:"suspended"}:{kind:"failed",error:a(P)},P instanceof R)F.lost=!0}if(await F.settled(),F.lost)return;if(J.kind==="completed"&&F.suspension)J={kind:"suspended"};await Y.update(z,{owner:$},({workflow:P,now:N})=>this.finish(P,J,F,U,N)),this.queue.claimSoon()}catch(J){if(J instanceof R)return;throw J}finally{clearInterval(A)}}finish(z,V,Y,Z,$){let X={result:void 0,unlock:!0};if(z.status==="cancelling"&&!Z)return{...X,tick:{delayMs:0}};if(V.kind==="completed")return{...X,workflow:Z?{status:"cancelled",currentStep:null,wakeAt:null}:{status:"completed",result:V.result,progress:1,currentStep:null,wakeAt:null,error:null}};if(V.kind==="failed")return{...X,workflow:{status:Z?"cancelled":"failed",error:V.error,wakeAt:null}};let H=Y.suspension??{status:"waiting",wakes:[]},G={...X,workflow:{status:Z?"cancelling":H.status,currentStep:Y.current??z.currentStep}};if(H.wakes.length>0){let Q=Math.min(...H.wakes);if(!(z.wakeAt!==null&&z.wakeAt>$&&z.wakeAt<=Q))G.tick={delayMs:Math.max(0,Q-$)},G.workflow.wakeAt=Q}return G}async unknown(z,V,Y){let Z=Date.now()-z.createdAt;if(this.queue.durable&&Z<this.queue.config.unknownJobGrace){if(!this.reportedNames.has(z.name))this.reportedNames.add(z.name),console.error(`Left workflow "${z.name}" for another replica: nothing is registered here under that name.`);await Y(),V.release(Math.round(this.queue.config.pollInterval*(1+Math.random())));return}console.error(`Failed workflow ${z.id}: nothing is registered under the name "${z.name}". If the class exists, it was not discovered: check that it is under the queue slice's workflowsDir (app/workflows by default), or list it in app/config/queue.ts.`),await Y({workflow:{status:"failed",error:`No workflow is registered under the name "${z.name}".`}})}tickDeadLettered(z,V){console.error(`[gemi] The tick of workflow ${z} was dead-lettered.`,V),this.store.update(z,{},({workflow:Y})=>r.includes(Y.status)?{result:void 0}:{result:void 0,workflow:{status:"failed",error:`Its tick job was dead-lettered: ${V.message}`},unlock:!0}).catch(()=>{})}}function o0(z){return class extends S{static name=I;maxAttempts=20;backoff=[1000,5000,15000,30000,60000];async run(Y){await z.tick(Y,this)}onDeadletter(Y,Z){z.tickDeadLettered(Z,Y)}}}function e0(z){try{return _(z)}catch{return z}}
-export{y as Pd,p as Qd,o as Rd,U0 as Sd,z0 as Td,Az as Ud,D0 as Vd,V0 as Wd,i as Xd,I0 as Yd,Y0 as Zd,E0 as _d,O0 as $d,Z0 as ae,H0 as be,h as ce,s0 as de,n0 as ee,cz as fe,a0 as ge,S as he};
+export{y as Qd,p as Rd,o as Sd,U0 as Td,z0 as Ud,Az as Vd,D0 as Wd,V0 as Xd,i as Yd,I0 as Zd,Y0 as _d,E0 as $d,O0 as ae,Z0 as be,H0 as ce,h as de,s0 as ee,n0 as fe,cz as ge,a0 as he,S as ie};
 
-//# debugId=416AFE041018A56564756E2164756E21
+//# debugId=0075DD2E1564FBDF64756E2164756E21