gemi 0.131.0 → 0.133.0

package/dist/{chunk-hr8annr1.js → chunk-feajsgns.js}

@@ -1,9 +1,9 @@
 // @bun
-import{bj as X,nj as P}from"./chunk-mym7egdq.js";function f(){return{now:new Date,resolved:{}}}var b={now:new Date(0),resolved:{}};function x(z){return(G,H=b)=>{let V=[];for(let Z=0;Z<z.length;Z++)V.push(z[Z](G,H));return V}}var j="\x00";function W(z){return{text:z,binders:[]}}function Q(z,G=""){return{text:j+G,binders:[z]}}function p(z){return z.text.split(j)}function m(z,G){return{text:z.join(j),binders:G}}function $(...z){return I(z,"")}function I(z,G){let H="",V=[];for(let Z=0;Z<z.length;Z++){if(Z>0)H+=G;H+=z[Z].text;for(let Y of z[Z].binders)V.push(Y)}return{text:H,binders:V}}function c(z,G,H){let V=z.text.split(j),Z=V.length-1;if(Z!==z.binders.length)throw Error(`Compiled ${Z} parameter placeholders but collected ${z.binders.length} binders.`);if(Z>G.maxBoundParameters)throw new P(H.model,H.operation,Z,G.maxBoundParameters,G.name,G.bindsListAsOneParameter?"That is one parameter per value in the statement.":`That is one parameter per value, and on ${G.name} each element of an 'in' list counts separately.`);let Y=V[0];for(let B=0;B<Z;B++)Y+=G.placeholder(B)+V[B+1];return{text:Y,binders:z.binders}}class K{name="postgres";supportsInsensitiveMode=!0;bindsListAsOneParameter=!0;supportsReturning=!0;maxBoundParameters=65535;typesParametersFromStatement=!0;quoteIdent(z){if(z.includes("\x00"))throw Error(`Refusing to quote the identifier ${JSON.stringify(z)}: it contains a NUL byte, which is reserved as the parameter marker.`);return`"${z.replace(/"/g,'""')}"`}placeholder(z){return`$${z+1}`}inList(z,G,H,V){return $(W(`${z} ${G?"<> all":"= any"} (`),Q((Y,B)=>C(V(Y,B))),W(")"))}static COMPOSITE_IN_TYPES={Int:"int",BigInt:"bigint",String:"text",Boolean:"boolean"};canBindCompositeIn(z){return z.length>0&&z.every((G)=>K.COMPOSITE_IN_TYPES[G])}compositeIn(z,G,H){let V=z.map((Z,Y)=>$(Q((B,J)=>C(H(B,J).map((F)=>F[Y]))),W(`::${K.COMPOSITE_IN_TYPES[G[Y]]}[]`)));return $(W(`(${z.join(", ")}) in (select * from unnest(`),...V.flatMap((Z,Y)=>Y===0?[Z]:[W(", "),Z]),W("))"))}listFilters=new Set(["equals","has","hasEvery","hasSome","isEmpty"]);listHas(z,G){return $(G,W(` = any(${z})`))}listHasEvery(z,G){return $(W(`${z} @> `),G)}listHasSome(z,G){return $(W(`${z} && `),G)}listIsEmpty(z,G){return $(W(`${z} ${G?"=":"<>"} `),Q(()=>C([])))}listPush(z,G){return $(W(`array_cat(${z}, `),G,W(")"))}jsonPathSyntax="array";jsonFilters=new Set(["equals","not","string_contains","string_starts_with","string_ends_with","array_contains","lt","lte","gt","gte"]);jsonComparesAsText=!0;jsonExtract(z,G,H){return $(W(`${z} ${H?"#>>":"#>"} `),Q((V,Z)=>C(G(V,Z))))}jsonValueAt(z,G){return $(W("("),this.jsonExtract(z,G,!1),W(")::jsonb"))}jsonHasKeys(z,G,H,V){let Z=()=>G===void 0?W(`(${z})::jsonb`):$(W("("),this.jsonExtract(z,G,!1),W(")::jsonb")),Y=V==="one"?$(Q(H),W("::text")):$(Q((J,F)=>C(H(J,F)??[])),W("::text[]")),B=V==="one"?"?":V==="some"?"?|":"?&";return $(W("(jsonb_typeof("),Z(),W(") = 'object' and "),Z(),W(` ${B} `),Y,W(")"))}distinctFrom(z,G,H){let V=H.type==="Json"&&!H.isList;return $(W(V?`(${z})::jsonb is distinct from `:`${z} is distinct from `),G)}jsonArrayContains(z,G,H){return $(W("("),this.jsonExtract(z,G,!1),W(") @> "),Q((V,Z)=>{let Y=H(V,Z);if(Y===null||Y===void 0)return null;return typeof Y==="string"||typeof Y==="object"?Y:JSON.stringify(Y)}),W("::jsonb"))}like(z,G,H){return $(W(`${z} ${G?"ilike":"like"} `),Q(H))}ignoreConflicts(){return W(" on conflict do nothing")}rowLock(z,G){let H=z.onLocked==="skipLocked"?" skip locked":z.onLocked==="noWait"?" nowait":"";return W(` for ${z.mode==="share"?"share":"update"} of ${this.quoteIdent(G)}${H}`)}paginate(z,G){let H=[];if(z)H.push($(W(" limit "),Q(z)));if(G)H.push($(W(" offset "),Q(G)));return $(...H)}constraintViolation(z){let G=z;if(!G)return null;if(String(G.errno??G.code??"")!=="23505")return null;let V=typeof G.constraint==="string"&&G.constraint!==""?G.constraint:void 0,Z=typeof G.detail==="string"?G.detail:"",Y=/\((.+?)\)=/.exec(Z);return{kind:"unique",columns:Y?(Y[1].match(/"(?:[^"]|"")*"|[^,]+/g)??[]).map((J)=>J.trim()).filter((J)=>J!=="").map((J)=>/^".*"$/s.test(J)?J.slice(1,-1).replace(/""/g,'"'):J):[],constraint:V}}castParameter(z){if(z.isList)return"";return z.type==="Json"?"::text::jsonb":""}encode(z,G){if(z===null||z===void 0)return null;if(G.isList){if(!Array.isArray(z))throw Error(`gemi ORM bug: a non-array reached the parameter binder for the scalar list '${G.column}' (received ${typeof z}). Every path that binds a list is supposed to have checked its operand.`);return C(G.type==="Json"?z.map((H)=>H===null||H===void 0?null:JSON.stringify(H)):z)}return z}encodeUntyped(z){return z}needsDecode(z){return z.isList===!0||z.type==="BigInt"||z.type==="Bytes"}decode(z,G){if(z===null||z===void 0)return null;if(G.isList)return this.decodeList(z,G);return this.decodeScalar(z,G)}decodeList(z,G){let H=Array.isArray(z)?z:typeof z==="string"?E(z,G):ArrayBuffer.isView(z)?Array.from(z):null;if(H===null)throw new X(G,z);return H.map((V)=>V===null||V===void 0?null:this.decodeScalar(V,G))}decodeScalar(z,G){switch(G.type){case"BigInt":if(typeof z==="bigint")return z;try{return BigInt(z)}catch{throw new X(G,z)}case"Json":return z;case"Bytes":return Buffer.isBuffer(z)?new Uint8Array(z.buffer,z.byteOffset,z.byteLength):z;default:return z}}}function C(z){let G="{";for(let H=0;H<z.length;H++){if(H>0)G+=",";G+=D(z[H])}return G+"}"}function D(z){if(z===null||z===void 0)return"NULL";if(z instanceof Date)return`"${z.toISOString()}"`;if(ArrayBuffer.isView(z)){let H="";for(let V of new Uint8Array(z.buffer,z.byteOffset,z.byteLength))H+=V.toString(16).padStart(2,"0");return`"\\\\x${H}"`}return`"${(typeof z==="string"?z:String(z)).replace(/\\/g,"\\\\").replace(/"/g,"\\\"")}"`}function E(z,G){if(!z.startsWith("{")||!z.endsWith("}"))throw new X(G,z);if(z==="{}")return[];let H=[],V=1,Z=z.length-1;while(V<=Z){let Y="",B=!1;if(z[V]==='"'){B=!0,V++;while(V<Z&&z[V]!=='"')Y+=z[V]==="\\"?z[++V]:z[V],V++;V++}else while(V<Z&&z[V]!==","){if(z[V]==="{")throw new X(G,z);Y+=z[V],V++}if(H.push(!B&&Y.toUpperCase()==="NULL"?null:Y),V<Z&&z[V]!==",")throw new X(G,z);V++}if(G.type!=="Json")return H;return H.map((Y)=>{if(Y===null)return null;try{return JSON.parse(Y)}catch{throw new X(G,Y)}})}var k={"Prisma.DbNull":"db","Prisma.JsonNull":"json","Prisma.AnyNull":"any"};function _(z){return new class{toString(){return z}}}var s=_("Prisma.DbNull"),y=_("Prisma.JsonNull"),u=_("Prisma.AnyNull"),r=y;function A(z){if(typeof z!=="object"||z===null)return null;for(let H in z)return null;if(Object.getOwnPropertyNames(z).length>0)return null;let G;try{G=String(z)}catch{return null}return k[G]??null}var h=/^\d{4}-\d{2}-\d{2}[ T]\d{2}:\d{2}:\d{2}(\.\d+)?$/;function q(z,G){if(z instanceof Date)return z;let H;if(typeof z==="number")H=new Date(z);else if(typeof z==="bigint")H=new Date(Number(z));else if(typeof z==="string")H=new Date(h.test(z)?`${z.replace(" ","T")}Z`:z);else throw new X(G,z);if(Number.isNaN(H.getTime()))throw new X(G,z);return H}class S{name="sqlite";supportsInsensitiveMode=!1;bindsListAsOneParameter=!1;supportsReturning=!0;maxBoundParameters=32766;typesParametersFromStatement=!1;quoteIdent(z){if(z.includes("\x00"))throw Error(`Refusing to quote the identifier ${JSON.stringify(z)}: it contains a NUL byte, which is reserved as the parameter marker.`);return`"${z.replace(/"/g,'""')}"`}placeholder(z){return"?"}inList(z,G,H,V){let Z=G?"not in":"in",Y=[];for(let B=0;B<H;B++)Y.push(Q((J,F)=>V(J,F)[B]));return $(W(`${z} ${Z} (`),I(Y,", "),W(")"))}canBindCompositeIn(){return!1}compositeIn(){throw Error("SQLite cannot bind a composite `in`; `canBindCompositeIn` is the guard.")}listFilters=new Set;listHas(){throw Error(N("has"))}listHasEvery(){throw Error(N("hasEvery"))}listHasSome(){throw Error(N("hasSome"))}listIsEmpty(){throw Error(N("isEmpty"))}listPush(){throw Error(N("push"))}jsonPathSyntax="jsonpath";jsonFilters=new Set(["equals","not","string_contains","string_starts_with","string_ends_with"]);jsonComparesAsText=!1;jsonExtract(z,G,H){return $(W(`json_extract(${z}, `),Q(G),W(")"))}jsonValueAt(z,G){return $(W(`(${z} -> `),Q(G),W(")"))}jsonHasKeys(z,G,H,V,Z){let Y=(O,U)=>G===void 0?"$":G(O,U),B=(O)=>$(W(`json_type(${z}, `),Q((U,M)=>{let w=H(U,M),L=O===void 0?w:w[O];return`${Y(U,M)}.${JSON.stringify(String(L))}`}),W(") is not null")),J=V==="one"?[B(void 0)]:Array.from({length:Z},(O,U)=>B(U)),F=J.length===0?W(V==="some"?"0":"1"):I(J,V==="every"?" and ":" or ");return $(W(`(json_type(${z}, `),Q(Y),W(") = 'object' and ("),F,W("))"))}distinctFrom(z,G,H){if(H.type==="Json"&&!H.isList)return $(W(`json(${z}) is not json(`),G,W(")"));return $(W(`${z} is not `),G)}jsonArrayContains(){throw Error("SQLite cannot express array_contains; `jsonFilters` is the guard.")}like(z,G,H){return $(W(`${z} like `),Q(H))}ignoreConflicts(){return null}rowLock(z,G){return W("")}paginate(z,G){if(!z&&!G)return W("");if(!G)return $(W(" limit "),Q(z));return $(W(" limit "),Q(z??(()=>-1)),W(" offset "),Q(G))}constraintViolation(z){let G=z?.code;if(G!=="SQLITE_CONSTRAINT_UNIQUE"&&G!=="SQLITE_CONSTRAINT_PRIMARYKEY")return null;let H=String(z.message??""),V=/constraint failed:\s*(.+)$/.exec(H);if(!V)return{kind:"unique",columns:[]};return{kind:"unique",columns:V[1].split(",").map((Y)=>Y.trim()).map((Y)=>{let B=Y.indexOf(".");return B===-1?Y:Y.slice(B+1)}).filter((Y)=>Y!=="")}}castParameter(z){return""}encode(z,G){if(z===null||z===void 0)return null;switch(G.type){case"DateTime":return z instanceof Date?z.getTime():z;case"Boolean":return typeof z==="boolean"?z?1:0:z;case"Json":{let H=A(z);if(H==="db")return null;if(H==="json")return"null";if(H==="any")throw Error("gemi ORM bug: Prisma.AnyNull reached the SQLite encoder. It is a filter operand only, and both the filter and write paths are supposed to have handled it before this point.")}return JSON.stringify(z);default:return z}}encodeUntyped(z){if(z instanceof Date)return z.getTime();if(typeof z==="boolean")return z?1:0;return z}needsDecode(z){switch(z.type){case"DateTime":case"Boolean":case"BigInt":case"Json":return!0;default:return!1}}decode(z,G){if(z===null||z===void 0)return null;switch(G.type){case"DateTime":return q(z,G);case"Boolean":if(typeof z==="boolean")return z;return Number(z)!==0;case"BigInt":if(typeof z==="bigint")return z;try{return BigInt(z)}catch{throw new X(G,z)}case"Json":try{return typeof z==="string"?JSON.parse(z):z}catch{throw new X(G,z)}default:return z}}}function N(z){return`SQLite has no array type, so it cannot express '${z}' on a scalar list; \`listFilters\` is the guard.`}class R extends Error{constructor(z){super(`The gemi ORM does not support the '${z}' dialect. Only sqlite `+"and postgres are implemented \u2014 see the supported matrix in "+`docs/orm.md.
+import{cj as X,oj as P}from"./chunk-vnw91fe1.js";function f(){return{now:new Date,resolved:{}}}var b={now:new Date(0),resolved:{}};function x(z){return(G,H=b)=>{let V=[];for(let Z=0;Z<z.length;Z++)V.push(z[Z](G,H));return V}}var j="\x00";function W(z){return{text:z,binders:[]}}function Q(z,G=""){return{text:j+G,binders:[z]}}function p(z){return z.text.split(j)}function m(z,G){return{text:z.join(j),binders:G}}function $(...z){return I(z,"")}function I(z,G){let H="",V=[];for(let Z=0;Z<z.length;Z++){if(Z>0)H+=G;H+=z[Z].text;for(let Y of z[Z].binders)V.push(Y)}return{text:H,binders:V}}function c(z,G,H){let V=z.text.split(j),Z=V.length-1;if(Z!==z.binders.length)throw Error(`Compiled ${Z} parameter placeholders but collected ${z.binders.length} binders.`);if(Z>G.maxBoundParameters)throw new P(H.model,H.operation,Z,G.maxBoundParameters,G.name,G.bindsListAsOneParameter?"That is one parameter per value in the statement.":`That is one parameter per value, and on ${G.name} each element of an 'in' list counts separately.`);let Y=V[0];for(let B=0;B<Z;B++)Y+=G.placeholder(B)+V[B+1];return{text:Y,binders:z.binders}}class K{name="postgres";supportsInsensitiveMode=!0;bindsListAsOneParameter=!0;supportsReturning=!0;maxBoundParameters=65535;typesParametersFromStatement=!0;quoteIdent(z){if(z.includes("\x00"))throw Error(`Refusing to quote the identifier ${JSON.stringify(z)}: it contains a NUL byte, which is reserved as the parameter marker.`);return`"${z.replace(/"/g,'""')}"`}placeholder(z){return`$${z+1}`}inList(z,G,H,V){return $(W(`${z} ${G?"<> all":"= any"} (`),Q((Y,B)=>C(V(Y,B))),W(")"))}static COMPOSITE_IN_TYPES={Int:"int",BigInt:"bigint",String:"text",Boolean:"boolean"};canBindCompositeIn(z){return z.length>0&&z.every((G)=>K.COMPOSITE_IN_TYPES[G])}compositeIn(z,G,H){let V=z.map((Z,Y)=>$(Q((B,J)=>C(H(B,J).map((F)=>F[Y]))),W(`::${K.COMPOSITE_IN_TYPES[G[Y]]}[]`)));return $(W(`(${z.join(", ")}) in (select * from unnest(`),...V.flatMap((Z,Y)=>Y===0?[Z]:[W(", "),Z]),W("))"))}listFilters=new Set(["equals","has","hasEvery","hasSome","isEmpty"]);listHas(z,G){return $(G,W(` = any(${z})`))}listHasEvery(z,G){return $(W(`${z} @> `),G)}listHasSome(z,G){return $(W(`${z} && `),G)}listIsEmpty(z,G){return $(W(`${z} ${G?"=":"<>"} `),Q(()=>C([])))}listPush(z,G){return $(W(`array_cat(${z}, `),G,W(")"))}jsonPathSyntax="array";jsonFilters=new Set(["equals","not","string_contains","string_starts_with","string_ends_with","array_contains","lt","lte","gt","gte"]);jsonComparesAsText=!0;jsonExtract(z,G,H){return $(W(`${z} ${H?"#>>":"#>"} `),Q((V,Z)=>C(G(V,Z))))}jsonValueAt(z,G){return $(W("("),this.jsonExtract(z,G,!1),W(")::jsonb"))}jsonHasKeys(z,G,H,V){let Z=()=>G===void 0?W(`(${z})::jsonb`):$(W("("),this.jsonExtract(z,G,!1),W(")::jsonb")),Y=V==="one"?$(Q(H),W("::text")):$(Q((J,F)=>C(H(J,F)??[])),W("::text[]")),B=V==="one"?"?":V==="some"?"?|":"?&";return $(W("(jsonb_typeof("),Z(),W(") = 'object' and "),Z(),W(` ${B} `),Y,W(")"))}distinctFrom(z,G,H){let V=H.type==="Json"&&!H.isList;return $(W(V?`(${z})::jsonb is distinct from `:`${z} is distinct from `),G)}jsonArrayContains(z,G,H){return $(W("("),this.jsonExtract(z,G,!1),W(") @> "),Q((V,Z)=>{let Y=H(V,Z);if(Y===null||Y===void 0)return null;return typeof Y==="string"||typeof Y==="object"?Y:JSON.stringify(Y)}),W("::jsonb"))}like(z,G,H){return $(W(`${z} ${G?"ilike":"like"} `),Q(H))}ignoreConflicts(){return W(" on conflict do nothing")}rowLock(z,G){let H=z.onLocked==="skipLocked"?" skip locked":z.onLocked==="noWait"?" nowait":"";return W(` for ${z.mode==="share"?"share":"update"} of ${this.quoteIdent(G)}${H}`)}paginate(z,G){let H=[];if(z)H.push($(W(" limit "),Q(z)));if(G)H.push($(W(" offset "),Q(G)));return $(...H)}constraintViolation(z){let G=z;if(!G)return null;if(String(G.errno??G.code??"")!=="23505")return null;let V=typeof G.constraint==="string"&&G.constraint!==""?G.constraint:void 0,Z=typeof G.detail==="string"?G.detail:"",Y=/\((.+?)\)=/.exec(Z);return{kind:"unique",columns:Y?(Y[1].match(/"(?:[^"]|"")*"|[^,]+/g)??[]).map((J)=>J.trim()).filter((J)=>J!=="").map((J)=>/^".*"$/s.test(J)?J.slice(1,-1).replace(/""/g,'"'):J):[],constraint:V}}castParameter(z){if(z.isList)return"";return z.type==="Json"?"::text::jsonb":""}encode(z,G){if(z===null||z===void 0)return null;if(G.isList){if(!Array.isArray(z))throw Error(`gemi ORM bug: a non-array reached the parameter binder for the scalar list '${G.column}' (received ${typeof z}). Every path that binds a list is supposed to have checked its operand.`);return C(G.type==="Json"?z.map((H)=>H===null||H===void 0?null:JSON.stringify(H)):z)}return z}encodeUntyped(z){return z}needsDecode(z){return z.isList===!0||z.type==="BigInt"||z.type==="Bytes"}decode(z,G){if(z===null||z===void 0)return null;if(G.isList)return this.decodeList(z,G);return this.decodeScalar(z,G)}decodeList(z,G){let H=Array.isArray(z)?z:typeof z==="string"?E(z,G):ArrayBuffer.isView(z)?Array.from(z):null;if(H===null)throw new X(G,z);return H.map((V)=>V===null||V===void 0?null:this.decodeScalar(V,G))}decodeScalar(z,G){switch(G.type){case"BigInt":if(typeof z==="bigint")return z;try{return BigInt(z)}catch{throw new X(G,z)}case"Json":return z;case"Bytes":return Buffer.isBuffer(z)?new Uint8Array(z.buffer,z.byteOffset,z.byteLength):z;default:return z}}}function C(z){let G="{";for(let H=0;H<z.length;H++){if(H>0)G+=",";G+=D(z[H])}return G+"}"}function D(z){if(z===null||z===void 0)return"NULL";if(z instanceof Date)return`"${z.toISOString()}"`;if(ArrayBuffer.isView(z)){let H="";for(let V of new Uint8Array(z.buffer,z.byteOffset,z.byteLength))H+=V.toString(16).padStart(2,"0");return`"\\\\x${H}"`}return`"${(typeof z==="string"?z:String(z)).replace(/\\/g,"\\\\").replace(/"/g,"\\\"")}"`}function E(z,G){if(!z.startsWith("{")||!z.endsWith("}"))throw new X(G,z);if(z==="{}")return[];let H=[],V=1,Z=z.length-1;while(V<=Z){let Y="",B=!1;if(z[V]==='"'){B=!0,V++;while(V<Z&&z[V]!=='"')Y+=z[V]==="\\"?z[++V]:z[V],V++;V++}else while(V<Z&&z[V]!==","){if(z[V]==="{")throw new X(G,z);Y+=z[V],V++}if(H.push(!B&&Y.toUpperCase()==="NULL"?null:Y),V<Z&&z[V]!==",")throw new X(G,z);V++}if(G.type!=="Json")return H;return H.map((Y)=>{if(Y===null)return null;try{return JSON.parse(Y)}catch{throw new X(G,Y)}})}var k={"Prisma.DbNull":"db","Prisma.JsonNull":"json","Prisma.AnyNull":"any"};function _(z){return new class{toString(){return z}}}var s=_("Prisma.DbNull"),y=_("Prisma.JsonNull"),u=_("Prisma.AnyNull"),r=y;function A(z){if(typeof z!=="object"||z===null)return null;for(let H in z)return null;if(Object.getOwnPropertyNames(z).length>0)return null;let G;try{G=String(z)}catch{return null}return k[G]??null}var h=/^\d{4}-\d{2}-\d{2}[ T]\d{2}:\d{2}:\d{2}(\.\d+)?$/;function q(z,G){if(z instanceof Date)return z;let H;if(typeof z==="number")H=new Date(z);else if(typeof z==="bigint")H=new Date(Number(z));else if(typeof z==="string")H=new Date(h.test(z)?`${z.replace(" ","T")}Z`:z);else throw new X(G,z);if(Number.isNaN(H.getTime()))throw new X(G,z);return H}class S{name="sqlite";supportsInsensitiveMode=!1;bindsListAsOneParameter=!1;supportsReturning=!0;maxBoundParameters=32766;typesParametersFromStatement=!1;quoteIdent(z){if(z.includes("\x00"))throw Error(`Refusing to quote the identifier ${JSON.stringify(z)}: it contains a NUL byte, which is reserved as the parameter marker.`);return`"${z.replace(/"/g,'""')}"`}placeholder(z){return"?"}inList(z,G,H,V){let Z=G?"not in":"in",Y=[];for(let B=0;B<H;B++)Y.push(Q((J,F)=>V(J,F)[B]));return $(W(`${z} ${Z} (`),I(Y,", "),W(")"))}canBindCompositeIn(){return!1}compositeIn(){throw Error("SQLite cannot bind a composite `in`; `canBindCompositeIn` is the guard.")}listFilters=new Set;listHas(){throw Error(N("has"))}listHasEvery(){throw Error(N("hasEvery"))}listHasSome(){throw Error(N("hasSome"))}listIsEmpty(){throw Error(N("isEmpty"))}listPush(){throw Error(N("push"))}jsonPathSyntax="jsonpath";jsonFilters=new Set(["equals","not","string_contains","string_starts_with","string_ends_with"]);jsonComparesAsText=!1;jsonExtract(z,G,H){return $(W(`json_extract(${z}, `),Q(G),W(")"))}jsonValueAt(z,G){return $(W(`(${z} -> `),Q(G),W(")"))}jsonHasKeys(z,G,H,V,Z){let Y=(O,U)=>G===void 0?"$":G(O,U),B=(O)=>$(W(`json_type(${z}, `),Q((U,M)=>{let w=H(U,M),L=O===void 0?w:w[O];return`${Y(U,M)}.${JSON.stringify(String(L))}`}),W(") is not null")),J=V==="one"?[B(void 0)]:Array.from({length:Z},(O,U)=>B(U)),F=J.length===0?W(V==="some"?"0":"1"):I(J,V==="every"?" and ":" or ");return $(W(`(json_type(${z}, `),Q(Y),W(") = 'object' and ("),F,W("))"))}distinctFrom(z,G,H){if(H.type==="Json"&&!H.isList)return $(W(`json(${z}) is not json(`),G,W(")"));return $(W(`${z} is not `),G)}jsonArrayContains(){throw Error("SQLite cannot express array_contains; `jsonFilters` is the guard.")}like(z,G,H){return $(W(`${z} like `),Q(H))}ignoreConflicts(){return null}rowLock(z,G){return W("")}paginate(z,G){if(!z&&!G)return W("");if(!G)return $(W(" limit "),Q(z));return $(W(" limit "),Q(z??(()=>-1)),W(" offset "),Q(G))}constraintViolation(z){let G=z?.code;if(G!=="SQLITE_CONSTRAINT_UNIQUE"&&G!=="SQLITE_CONSTRAINT_PRIMARYKEY")return null;let H=String(z.message??""),V=/constraint failed:\s*(.+)$/.exec(H);if(!V)return{kind:"unique",columns:[]};return{kind:"unique",columns:V[1].split(",").map((Y)=>Y.trim()).map((Y)=>{let B=Y.indexOf(".");return B===-1?Y:Y.slice(B+1)}).filter((Y)=>Y!=="")}}castParameter(z){return""}encode(z,G){if(z===null||z===void 0)return null;switch(G.type){case"DateTime":return z instanceof Date?z.getTime():z;case"Boolean":return typeof z==="boolean"?z?1:0:z;case"Json":{let H=A(z);if(H==="db")return null;if(H==="json")return"null";if(H==="any")throw Error("gemi ORM bug: Prisma.AnyNull reached the SQLite encoder. It is a filter operand only, and both the filter and write paths are supposed to have handled it before this point.")}return JSON.stringify(z);default:return z}}encodeUntyped(z){if(z instanceof Date)return z.getTime();if(typeof z==="boolean")return z?1:0;return z}needsDecode(z){switch(z.type){case"DateTime":case"Boolean":case"BigInt":case"Json":return!0;default:return!1}}decode(z,G){if(z===null||z===void 0)return null;switch(G.type){case"DateTime":return q(z,G);case"Boolean":if(typeof z==="boolean")return z;return Number(z)!==0;case"BigInt":if(typeof z==="bigint")return z;try{return BigInt(z)}catch{throw new X(G,z)}case"Json":try{return typeof z==="string"?JSON.parse(z):z}catch{throw new X(G,z)}default:return z}}}function N(z){return`SQLite has no array type, so it cannot express '${z}' on a scalar list; \`listFilters\` is the guard.`}class R extends Error{constructor(z){super(`The gemi ORM does not support the '${z}' dialect. Only sqlite `+"and postgres are implemented \u2014 see the supported matrix in "+`docs/orm.md.
 
 The *connection* is fine: Bun's client speaks ${z}, so raw SQL through DB.query / DB.sql and transactions all work. It is the query compiler that has no ${z} dialect, so every model operation raises this.
 
 Point DATABASE_URL at Postgres or SQLite to use the ORM, or keep using Prisma's own client for this database.`);this.name="UnsupportedDialectError"}}function Vz(z){return T[z]!==null}function Wz(){return Object.keys(T)}var T={sqlite:new S,postgres:new K,mysql:null,mariadb:null};function Yz(z){let G=T[z];if(G===null)throw new R(z);return G}
 export{f as Og,x as Pg,W as Qg,Q as Rg,p as Sg,m as Tg,$ as Ug,I as Vg,c as Wg,K as Xg,s as Yg,y as Zg,u as _g,r as $g,A as ah,S as bh,R as ch,Vz as dh,Wz as eh,Yz as fh};
 
-//# debugId=83F4E848F479D16B64756E2164756E21
+//# debugId=18FFE9491882034964756E2164756E21

package/dist/{chunk-hr8annr1.js.map → chunk-feajsgns.js.map}

@@ -9,6 +9,6 @@
     "import type { Dialect } from \"../../database/dialect\";\nimport type { Binder, Fragment } from \"../compile/fragment\";\nimport type { RowLockClause } from \"../compile/lock\";\nimport type { FieldSchema, ScalarType } from \"../schema\";\nimport { PostgresDialect } from \"./postgres\";\nimport { SqliteDialect } from \"./sqlite\";\n\n/**\n * The per-database strategy.\n *\n * The rule this interface exists to enforce: no `if (dialect === \"postgres\")`\n * ever appears inside the compiler. When something genuinely cannot be\n * expressed through the interface, the interface widens — which is why\n * `inList`, `like` and `paginate` return `Fragment`s rather than strings. Each\n * of the three is a place where SQLite and Postgres disagree about *structure*,\n * not just spelling:\n *\n * - `inList` — SQLite expands one placeholder per element, so `in: [1,2]` and\n *   `in: [1,2,3]` are different SQL and different plans. Postgres binds the\n *   whole array to one parameter with `= any($1)`, so every length shares a\n *   single plan and a single prepared statement.\n * - `like` — Postgres has `ilike` for `mode: \"insensitive\"`; SQLite has no\n *   equivalent, and Prisma rejects the argument there outright.\n * - `paginate` — SQLite cannot parse `offset` without a preceding `limit`.\n */\nexport interface SqlDialect {\n  readonly name: Dialect;\n\n  /**\n   * Whether `mode: \"insensitive\"` can be expressed at all. False on SQLite,\n   * where Prisma rejects the argument rather than emulating it.\n   */\n  readonly supportsInsensitiveMode: boolean;\n\n  /**\n   * Whether an `in` list binds as a single parameter however long it is.\n   *\n   * True on Postgres (`= any($1)`), false on SQLite (`in (?, ?, ?)`). It is the\n   * plan *cache* that needs to know: where the length does not change the SQL\n   * text, it must not change the cache key either, or every distinct list\n   * length mints another entry holding SQL identical to its neighbours'. That\n   * matters most for relations, where the list length is the parent row count\n   * and so varies with the data rather than with the code.\n   */\n  readonly bindsListAsOneParameter: boolean;\n\n  /**\n   * Whether `insert`/`update`/`delete` can return the rows they touched.\n   *\n   * True on both implemented dialects — Postgres has had `RETURNING` forever,\n   * and SQLite since 3.35 (Bun 1.3.14 bundles 3.51.0, verified by querying\n   * `sqlite_version()` rather than by reading a changelog).\n   *\n   * It is a capability rather than an assumption because MySQL and MariaDB have\n   * no `RETURNING` at all. Their fallback — `lastInsertRowid` plus a re-select,\n   * and no way to identify the rows an `updateMany` touched — is a different\n   * statement shape, not a different spelling. Iteration 4 does not build it,\n   * but it must stay expressible, so the write compiler asks rather than\n   * assumes and raises a clear error when the answer is no.\n   */\n  readonly supportsReturning: boolean;\n\n  /**\n   * How many parameters one statement may bind.\n   *\n   * A hard protocol/driver limit, not a tuning knob: Postgres sends the\n   * parameter count as an int16 in the Bind message, and SQLite compiles\n   * `SQLITE_MAX_VARIABLE_NUMBER` in.\n   *\n   * Three shapes can approach it, all of them scaling with the caller's *data*\n   * rather than with the query's shape:\n   *\n   * - `createMany`, at `rows × columns`.\n   * - An `in` list on SQLite, which binds one placeholder per element — and\n   *   such a list is routinely request-derived (`?ids=…`).\n   * - A to-many `include` on SQLite, which batches an `in` over the parent\n   *   keys, so a large enough `findMany` reaches it with no big list in sight.\n   *\n   * Postgres escapes the last two: `= any($1)` is one parameter however long\n   * the array. The check itself lives in `compile/fragment.ts`'s `render`,\n   * because that is the one place that sees a statement's final count.\n   *\n   * It lives *here* rather than as a constant in the compiler for the usual\n   * reason: the number differs per dialect, and the compiler is not allowed to\n   * know which dialect it is compiling for.\n   */\n  readonly maxBoundParameters: number;\n\n  /**\n   * Whether the **statement** decides a parameter's type, so a cast the caller\n   * wrote onto their own placeholder changes how the driver encodes the value.\n   *\n   * True on Postgres: the server describes the statement, the client is told\n   * the parameter is `jsonb`, and Bun then JSON-*encodes* whatever JS value it\n   * was handed. That is the whole of #376 — the reason `json-param.ts` retypes\n   * such a parameter through `text` and serialises it to match.\n   *\n   * False on SQLite, and not merely because the correction is unnecessary\n   * there: it would be **wrong**, and it would not parse. A parameter's type is\n   * the bound value's, and `cast(x as json)` is not a JSON cast at all — SQLite\n   * takes any type name and applies affinity rules, and a name containing none\n   * of INT/CHAR/CLOB/TEXT/BLOB/REAL/FLOA/DOUB gets NUMERIC affinity, so\n   * `cast('{\"a\":1}' as json)` is `0`. Measured through `bun:sqlite` (Bun\n   * 1.3.14):\n   *\n   *   select cast(? as jsonb)                            -> 0        (runs)\n   *   select json_set('{\"a\":1}','$.b', cast(? as json))   -> {\"a\":1,\"b\":2}\n   *   select cast(? as text)::json                        -> ERROR unrecognized token: \":\"\n   *\n   * So the retyping's rewrite — `cast(? as text)::json` — turns a statement\n   * that runs on SQLite today into a syntax error. `::` genuinely cannot fire\n   * there (it does not parse), but `cast(… as …)` is not Postgres-only syntax,\n   * and \"SQLite has no jsonb type\" is a claim about semantics rather than about\n   * what the parser accepts. Asking here rather than matching on `name` is what\n   * makes that a fact `tsc` and a test can hold.\n   */\n  readonly typesParametersFromStatement: boolean;\n\n  /** Quote a table or column name. Only ever called with names from the schema. */\n  quoteIdent(name: string): string;\n\n  /**\n   * The parameter marker for the `index`-th (0-based) parameter in a statement.\n   * SQLite ignores the index and returns `?`; Postgres returns `$1`, `$2`, ...\n   */\n  placeholder(index: number): string;\n\n  /**\n   * Prisma-shaped value -> the value the driver must be handed for this field.\n   * The mirror of `decode`, and just as load-bearing: Bun's SQLite driver binds\n   * a `Date` to `NULL`, so an unencoded `where: { createdAt: date }` would\n   * return no rows rather than failing.\n   *\n   * Applied at bind time, not compile time — it is a function of the value.\n   * Which encoder runs is still decided from the schema, so compile stays pure.\n   */\n  encode(value: unknown, field: FieldSchema): unknown;\n\n  /**\n   * SQL appended to this field's placeholder, or `\"\"` for none.\n   *\n   * The one string a dialect contributes to the statement that is not a\n   * parameter, so it must be a constant — never derived from a value, and never\n   * from anything an application supplies. `fieldParam` is the only caller, and\n   * a non-empty cast also means it serialises the value; the two travel\n   * together and neither is correct alone (#209).\n   */\n  castParameter(field: FieldSchema): string;\n\n  /**\n   * The same, for a value with **no declared column type** — a parameter\n   * interpolated into a composed raw fragment, where there is no schema to ask.\n   *\n   * It exists because \"raw\" cannot mean \"unportable\". Bun's SQLite driver\n   * rejects a `Date` outright (`Binding expected string, TypedArray, boolean,\n   * number, bigint or null`) while Postgres takes one, so\n   * ``sql`where \"createdAt\" > ${date}` `` would work on one dialect and throw on\n   * the other — and the caller has no dialect-independent value to reach for\n   * instead, because milliseconds are only correct if that is what the ORM\n   * stored. Which it is: this converts to exactly what `encode` writes for a\n   * `DateTime`, so a raw statement compares against ORM-written rows correctly.\n   *\n   * Deliberately narrow. It normalises the JavaScript types whose SQL form the\n   * ORM has already decided — a `Date`, a boolean — and touches nothing else. A\n   * plain object is *not* JSON-encoded here: the compiler only knows to do that\n   * because a field says `Json`, and guessing from the value would turn a\n   * mistyped parameter into a successfully-written string.\n   *\n   * The exception is a parameter the *caller* cast to `json`/`jsonb`, which is\n   * a declared type by another route and does not reach this at all — see\n   * `json-param.ts`. It is still not a guess from the value: the statement says\n   * so.\n   */\n  encodeUntyped(value: unknown): unknown;\n\n  /** Driver value -> the value Prisma would have returned for this field. */\n  decode(value: unknown, field: FieldSchema): unknown;\n\n  /**\n   * False when the driver already returns exactly what Prisma would for this\n   * field, letting the shaper skip the call entirely on the hot path.\n   */\n  needsDecode(field: FieldSchema): boolean;\n\n  /**\n   * `<lhs> in (...)` / `<lhs> not in (...)`.\n   *\n   * `length` is the element count, which is shape information and is already\n   * part of the plan key. `values` returns the whole array at bind time; how it\n   * is spread across parameters is the dialect's business.\n   */\n  inList(\n    lhs: string,\n    negated: boolean,\n    length: number,\n    values: Binder,\n  ): Fragment;\n\n  /** `<lhs> like <pattern>`, case-insensitively when the dialect can. */\n  like(lhs: string, insensitive: boolean, pattern: Binder): Fragment;\n\n  /**\n   * Whether this dialect can match a **tuple** of columns against a list of\n   * tuples in a statement whose text does not grow with the list.\n   *\n   * The single-column case is `inList`, and on Postgres `= any($1)` already\n   * gives one SQL text for every length — which is what lets `collapsedList`\n   * keep a batched relation query to one plan entry however many parents it\n   * has. A relation joining on *more than one* field cannot use it, so the\n   * loader falls back to an `OR` of `AND`s whose text does grow, and the plan\n   * cache churns with the parent count (#97).\n   *\n   * `unnest` closes that on Postgres — one array parameter per *column*, so the\n   * text is fixed — but it needs each column's SQL type for the cast, and the\n   * types are asked about here rather than assumed: a dialect that cannot spell\n   * one of them says so and the caller keeps the portable `OR`.\n   */\n  canBindCompositeIn(types: readonly ScalarType[]): boolean;\n\n  /**\n   * `(a, b) in (select * from unnest($1::t[], $2::u[]))`.\n   *\n   * `values` yields one tuple per parent at bind time; the dialect decides how\n   * they are transposed into per-column arrays. Only called when\n   * {@link canBindCompositeIn} returned true for these types.\n   */\n  compositeIn(\n    columns: readonly string[],\n    types: readonly ScalarType[],\n    values: Binder,\n  ): Fragment;\n\n  /**\n   * The filters this dialect can apply to a **scalar list** — `tags String[]`.\n   *\n   * **Empty is the whole of SQLite's answer**, and it is a capability rather\n   * than a gap in this ORM: SQLite has no array type, and Prisma refuses the\n   * declaration there at validation time — *\"Field `tags` in model `User` can't\n   * be a list. The current connector does not support lists of primitive\n   * types.\"* So a SQLite database cannot hold such a column to begin with.\n   *\n   * The refusal lives here rather than in the generator, which is where it used\n   * to live (#300). The generated artifact is dialect-agnostic on purpose —\n   * `DATABASE_URL` can name a different database than `prisma generate` saw —\n   * so a generator that refused a scalar list refused it for Postgres too, and\n   * one `String[]` anywhere meant no artifact for *any* model. Asking the\n   * dialect at compile time refuses exactly the combination that cannot work,\n   * and names it, which is the shape {@link UnsupportedDialectError} already\n   * has for the dialects with no compiler at all.\n   */\n  readonly listFilters: ReadonlySet<string>;\n\n  /**\n   * `<value> = any(<column>)` — is this element in the list?\n   *\n   * The mirror of {@link inList} rather than a variant of it, and the two are\n   * easy to confuse: there, one column is matched against a caller's list;\n   * here, one caller value is matched against a column that *is* a list.\n   *\n   * **These four take a `Fragment` where every other member here takes a\n   * `Binder`**, which is a deliberate exception. A list operand may need a cast\n   * on its placeholder — a single element of a `Json[]` needs #209's\n   * `::text::jsonb`, and the serialisation that must travel with it — so the\n   * parameter is built by `fieldParam` before it arrives and the dialect\n   * chooses only the operator. Handing over a `Binder` instead would oblige\n   * each dialect to restate `fieldParam`'s rule, and restating it slightly\n   * wrong is silent: `$1::jsonb = any(col)` answers *false* where\n   * `$1::text::jsonb = any(col)` answers true, with no error on either.\n   */\n  listHas(column: string, value: Fragment): Fragment;\n\n  /** `hasEvery` — every element of the operand is present in the column. */\n  listHasEvery(column: string, values: Fragment): Fragment;\n\n  /** `hasSome` — the column and the operand share at least one element. */\n  listHasSome(column: string, values: Fragment): Fragment;\n\n  /**\n   * `isEmpty: true`, or its negation when `empty` is false.\n   *\n   * The odd one out with no operand at all: the value being compared against is\n   * the empty list, which is the compiler's own constant rather than the\n   * caller's. It stays a bound parameter regardless — see `jsonNullComparison`,\n   * which declines the same exception for the same reason.\n   */\n  listIsEmpty(column: string, empty: boolean): Fragment;\n\n  /**\n   * The right-hand side of a `push`: the column's current value with the\n   * operand appended. An expression rather than a statement, because it is\n   * assigned by the write compiler like any other `set` value.\n   */\n  listPush(column: string, values: Fragment): Fragment;\n\n  /**\n   * How this dialect spells a JSON path, and which filters it can apply to one.\n   *\n   * The **path grammar itself differs**, which is unusual enough to be worth\n   * stating rather than hiding: Prisma takes `path: [\"a\", \"b\"]` on Postgres and\n   * `path: \"$.a.b\"` on SQLite, and refuses the other form on each. That is not\n   * a gemi choice — it is the shape the generated client accepts, measured on\n   * both — so reproducing it is what \"Prisma-compatible\" means here.\n   *\n   * `jsonFilters` is the set of scalar filters the dialect can apply to an\n   * extracted value. Prisma refuses `array_contains` and the numeric\n   * comparisons on SQLite with *\"Unknown argument\"*, so refusing them here is\n   * matching it rather than falling short of it.\n   */\n  readonly jsonPathSyntax: \"array\" | \"jsonpath\";\n  readonly jsonFilters: ReadonlySet<string>;\n\n  /**\n   * Whether an extracted value compares as **text**.\n   *\n   * Postgres's `#>>` yields `text`, so `equals: 3` has to bind `\"3\"` — comparing\n   * text to an integer parameter is a type error there. SQLite's `json_extract`\n   * yields a native value, so the same filter has to bind `3`: bind `\"3\"` and\n   * SQLite compares an INTEGER to a TEXT, which is silently *false* rather than\n   * an error. One filter, two encodings, and the wrong one is a returned-no-rows\n   * bug on one dialect and a raised error on the other.\n   */\n  readonly jsonComparesAsText: boolean;\n\n  /**\n   * The extracted value, as a fragment whose path is **bound**.\n   *\n   * A JSON path is the one place a caller's *value* decides part of an\n   * expression's meaning, which makes it the obvious place to interpolate by\n   * accident and break invariant 2. Both dialects can take it as a parameter —\n   * Postgres's `#>` accepts a `text[]`, SQLite's `json_extract` a string — so\n   * nothing has to be bent to keep it out of the SQL text.\n   *\n   * `asText` picks the extraction that yields SQL text rather than JSON. Every\n   * comparison in `jsonComparison` passes `true` — the string filters compare\n   * against text, and `equals` / `not` / the numeric operators compare an\n   * extracted *scalar*, which is what the text form gives them. The JSON form\n   * has exactly one caller, `jsonArrayContains`, because containment is the one\n   * operator whose right-hand side is a document.\n   *\n   * SQLite ignores the flag: `json_extract` already yields a SQL value rather\n   * than a JSON document for a scalar at the path. That is why the null\n   * sentinels need {@link jsonValueAt} instead of this — see there.\n   */\n  jsonExtract(column: string, path: Binder, asText: boolean): Fragment;\n\n  /** `<extracted> @> <value>` — Postgres only; see `jsonFilters`. */\n  jsonArrayContains(column: string, path: Binder, value: Binder): Fragment;\n\n  /**\n   * The value at `path` **as JSON**, in the form two JSON values compare in.\n   *\n   * The difference from {@link jsonExtract} is the whole of #407, and it is the\n   * distinction the null sentinels are made of. Both dialects have an\n   * extraction that collapses \"the key is absent\" into \"the key holds the JSON\n   * value `null`\", and both have one that does not:\n   *\n   * |          | collapses          | keeps the distinction |\n   * | ---      | ---                | ---                   |\n   * | postgres | `#>>` (text)       | `#>` (jsonb)          |\n   * | sqlite   | `json_extract`     | `->` (JSON text)      |\n   *\n   * `jsonExtract` is the left column at `asText: true`, which is what every\n   * scalar comparison wants — a value to compare, not a document. This is the\n   * right column, and it is what lets `equals: DbNull` compile to\n   * `<value at path> is null` while `equals: JsonNull` compiles to\n   * `<value at path> = <the JSON null>`. Refusing them because `#>>` cannot\n   * tell the two apart was true of `#>>` and not of the dialect.\n   *\n   * **Postgres casts and SQLite does not**, and the cast is not decoration:\n   * `#>` on a `json` column (a `@db.Json` field) yields `json`, which has no\n   * equality operator at all — *\"operator does not exist: json = jsonb\"*, a\n   * raised error rather than a wrong answer, but still one Prisma does not\n   * raise. Prisma emits `(…#>…)::jsonb` for exactly this reason and so does\n   * this. SQLite's `->` already yields the JSON text form.\n   *\n   * Bound, never interpolated, for the same reason `jsonExtract` is.\n   */\n  jsonValueAt(column: string, path: Binder): Fragment;\n\n  /**\n   * Whether the JSON value at `path` — the column itself when `path` is\n   * `undefined` — is an **object** holding the key, any of the keys, or all of\n   * them: `has_key`, `has_some_keys`, `has_every_key` (#664).\n   *\n   * `keys` binds a string for `\"one\"` and a string array for the other two;\n   * `count` is that array's length, which SQLite needs because it tests one\n   * key per term. Postgres binds the array whole, so its text does not depend\n   * on `count` and the plan key collapses the list (`LIST_KEYS` in `plan.ts`).\n   *\n   * **Objects only, on both dialects.** Postgres's `?` also matches a string\n   * *element* of a top-level array; SQLite's path lookup does not. Both forms\n   * are guarded with \"the value is an object\" so the two answer the same rows:\n   * `has_every_key: []` is \"is an object\", and `has_some_keys: []` is false.\n   * A key holding the JSON value `null` exists.\n   */\n  jsonHasKeys(\n    column: string,\n    path: Binder | undefined,\n    keys: Binder,\n    mode: \"one\" | \"some\" | \"every\",\n    count: number,\n  ): Fragment;\n\n  /**\n   * `lhs` differs from `rhs`, treating NULL as equal to NULL — the guard\n   * `skipIfUnchanged` adds to an update's `where` (#664).\n   *\n   * `rhs` is the same parameter the `set` binds, so the comparison is against\n   * the stored encoding of the value. A `Json` column compares as JSON rather\n   * than as text: `jsonb` equality on Postgres (key order and whitespace do not\n   * matter), and `json()`-normalised text on SQLite (whitespace does not\n   * matter; key order does).\n   */\n  distinctFrom(lhs: string, rhs: Fragment, field: FieldSchema): Fragment;\n\n  /**\n   * `limit`/`offset`. Both are values and therefore parameters — this is the\n   * single most tempting place in the compiler to inline a number.\n   */\n  paginate(take: Binder | null, skip: Binder | null): Fragment;\n\n  /**\n   * The clause that makes an insert skip rows violating a unique constraint —\n   * `createMany({ skipDuplicates: true })` — or `null` where it is not offered.\n   *\n   * **`null` is a parity decision, not a missing feature**, and that is worth\n   * knowing before someone \"fixes\" SQLite by returning `insert or ignore`.\n   * SQLite has `on conflict do nothing` and has since 3.24; Prisma nonetheless\n   * rejects the *argument* on SQLite — `Unknown argument 'skipDuplicates'`,\n   * whatever its value, verified against a generated 6.19 client. Offering it\n   * here would make gemi a silent superset of Prisma on the one dialect the\n   * differential harness could then no longer compare, which is the trade this\n   * project has declined every other time it came up.\n   *\n   * A method rather than a boolean because the SQL differs where it exists, and\n   * a `Fragment` because everything the compiler emits is one.\n   */\n  ignoreConflicts(): Fragment | null;\n\n  /**\n   * The clause a locking read ends with — `lock: \"update\"` on a `findMany` —\n   * naming `table` as the only table whose rows are locked.\n   *\n   * Scoped to the root table (`for update of \"User\"`) rather than left bare,\n   * because a folded `include` puts a lateral subquery in the `from` clause and\n   * Postgres refuses to lock through one (`FOR UPDATE is not allowed with\n   * aggregate functions`). Scoping it also matches the documented contract on\n   * both strategies: the root rows are locked, related rows never are.\n   *\n   * **Empty on SQLite, and that is a decision.** SQLite has no row locks, and\n   * does not need them for what a locking read is for: its transactions are\n   * serializable, with one writer at a time on the whole database, so the lost\n   * update a row lock prevents cannot happen there. Two transactions that race\n   * wait on (or fail with `SQLITE_BUSY` on) the database lock instead of the\n   * row's, and `skipLocked` / `noWait` have no row lock to react to. Refusing\n   * would stop code that runs on Postgres in production from running against\n   * SQLite in development and tests, for no gain. The one misuse that matters\n   * on both — a lock outside a transaction — is refused in `Model.$execute`\n   * on every dialect.\n   */\n  rowLock(lock: RowLockClause, table: string): Fragment;\n\n  /**\n   * Recognise a driver error as a constraint violation, and say which columns\n   * it names.\n   *\n   * Returns `null` for anything else, including the *other* constraint kinds:\n   * SQLite reports NOT NULL and FOREIGN KEY failures through the same exception\n   * type, and reporting one of those as a duplicate-key error would send a\n   * caller looking for a row that does not exist.\n   *\n   * Columns, not fields — the driver only knows the database's names. The\n   * caller maps them back through the schema, where `@map` is in scope.\n   */\n  constraintViolation(error: unknown): ConstraintViolation | null;\n}\n\n/** A driver error identified as a constraint failure, in dialect-neutral terms. */\nexport interface ConstraintViolation {\n  /** Only `unique` is translated today; the rest surface as the raw error. */\n  kind: \"unique\";\n  /** Database column names, in the order the driver reported them. */\n  columns: string[];\n  /** The constraint's own name, when the driver gives one. Postgres does. */\n  constraint?: string;\n}\n\n/**\n * The ORM was asked to compile against a dialect it does not implement.\n *\n * **The split this message has to convey**, because it is the surprising part:\n * `DatabaseManager` connects to MySQL and MariaDB perfectly well — Bun's client\n * speaks all four — so raw SQL through `DB.query` / `DB.sql` works, and\n * transactions work. What does not exist is a `SqlDialect` for them, so\n * everything that *compiles* a statement stops here.\n *\n * A caller who reads only \"not supported\" reasonably concludes the connection\n * is unusable, which is wrong and is the more expensive misreading: it is the\n * ORM that is unavailable, not the database.\n */\nexport class UnsupportedDialectError extends Error {\n  constructor(dialect: Dialect) {\n    super(\n      `The gemi ORM does not support the '${dialect}' dialect. Only sqlite ` +\n        `and postgres are implemented — see the supported matrix in ` +\n        `docs/orm.md.\\n\\n` +\n        `The *connection* is fine: Bun's client speaks ${dialect}, so raw SQL ` +\n        `through DB.query / DB.sql and transactions all work. It is the query ` +\n        `compiler that has no ${dialect} dialect, so every model operation ` +\n        `raises this.\\n\\n` +\n        `Point DATABASE_URL at Postgres or SQLite to use the ORM, or keep ` +\n        `using Prisma's own client for this database.`,\n    );\n    this.name = \"UnsupportedDialectError\";\n  }\n}\n\n/**\n * Whether the ORM can compile for this dialect at all.\n *\n * Exported so an application can find out at **boot** rather than on its first\n * query. That is the whole gap this closes: `DatabaseManager` constructs\n * happily against MySQL, so a deploy pointed at one starts, passes a health\n * check, serves traffic, and fails on the first model read — which is the\n * latest and most expensive moment to learn it.\n */\nexport function ormSupports(dialect: Dialect): boolean {\n  return COMPILERS[dialect] !== null;\n}\n\n/** Every dialect `Dialect` names, for anything that has to walk them all. */\nexport function everyDialect(): Dialect[] {\n  return Object.keys(COMPILERS) as Dialect[];\n}\n\n/**\n * The compiler for each dialect, or `null` where the ORM has none.\n *\n * **One map rather than two lists, and `satisfies` rather than a lookup.** The\n * supported set used to be written three times — `ormSupports`' `||` chain,\n * `dialectFor`'s `if` chain, and a test enumerating a hand-written copy of the\n * `Dialect` union — so adding a fifth member to that union changed nothing\n * anywhere: `tsc` clean, tests green, the new dialect silently reported as\n * unsupported by one function and unknown to the other.\n *\n * That moment is exactly what the guard exists for. Adding a dialect to the\n * union is the *first step of implementing one*, and it is the step where a\n * half-added dialect would disagree with itself.\n *\n * `satisfies Record<Dialect, …>` makes it a compile error in a file the build\n * actually checks. It has to live here rather than in a test: `tsconfig.json`\n * excludes test files and vitest transpiles without type-checking, so an\n * exhaustiveness check written there is a type error nothing ever evaluates.\n *\n * The sixth thing in this codebase made `tsc`'s job rather than a convention's\n * — see the note on `resolveLink`'s `operation`.\n */\nconst COMPILERS = {\n  sqlite: new SqliteDialect(),\n  postgres: new PostgresDialect(),\n  // Bun's client speaks both; the ORM has no compiler for either. See\n  // `UnsupportedDialectError`, which is careful to say that the *connection*\n  // still works.\n  mysql: null,\n  mariadb: null,\n} satisfies Record<Dialect, SqlDialect | null>;\n\n/**\n * Resolved per call from `DatabaseManager.dialect`, never baked into a\n * generated artifact — `DATABASE_URL` can point at a different database than\n * the one `prisma generate` saw.\n */\nexport function dialectFor(dialect: Dialect): SqlDialect {\n  const compiler = COMPILERS[dialect];\n  if (compiler === null) throw new UnsupportedDialectError(dialect);\n  return compiler;\n}\n\nexport { PostgresDialect, SqliteDialect };\n"
   ],
   "mappings": "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",
-  "debugId": "83F4E848F479D16B64756E2164756E21",
+  "debugId": "18FFE9491882034964756E2164756E21",
   "names": []
 }

package/dist/{chunk-2tda49mv.js → chunk-ff60bzvf.js}

@@ -1,5 +1,5 @@
 // @bun
-import{Pg as K,Qg as L,Rg as R,Sg as Y,Tg as M,Ug as Q,Vg as O,Wg as y,ah as U}from"./chunk-hr8annr1.js";import{Zi as G,_i as W}from"./chunk-mym7egdq.js";var S=/^\s*::\s*(?:text\s*::\s*)?(jsonb|json)\b(?!\s*\[)/i,I=/^\s*as\s+(jsonb|json)\s*\)/i,P=/\bcast\s*\(\s*$/i,T=new Set;function _(k,B){if(!B.typesParametersFromStatement)return{fragment:k,jsonParameters:T};let q=Y(k),z=new Set,D;for(let H=0;H<q.length-1;H++){let X=q[H+1],$=S.exec(X);if($){D??=[...q],D[H+1]=`::text::${$[1]}${X.slice($[0].length)}`,z.add(H);continue}let J=I.exec(X);if(J&&P.test((D??q)[H]))D??=[...q],D[H+1]=` as text)::${J[1]}${X.slice(J[0].length)}`,z.add(H)}if(!D)return{fragment:k,jsonParameters:z};return{fragment:M(D,k.binders),jsonParameters:z}}function C(k,B){if(k===null||k===void 0)return null;let q=U(k);if(q==="db")return null;if(q==="json")return"null";if(q==="any")throw new W(B,"DB",B,"Prisma.AnyNull is a filter operand \u2014 it asks for a SQL NULL *or* a JSON "+"null \u2014 so it has no single value to bind. Write the one you mean: "+"Prisma.DbNull for the column being NULL, Prisma.JsonNull for the JSON value.");if(typeof k==="string")return k;let z;try{z=JSON.stringify(k)}catch(D){throw new W(B,"DB",B,`A parameter cast to json could not be serialised: ${D instanceof Error?D.message:String(D)}. `+"Bind text you have serialised yourself if the value is not JSON \u2014 a "+"bigint has no JSON form, and neither does a cycle.")}if(z===void 0)throw new W(B,"DB",B,`A ${typeof k} was bound to a parameter cast to json, and has no JSON form. Bind the value it stands for.`);return z}var N=new WeakSet;function Z(k){return N.add(k),k}function V(k){return typeof k==="object"&&k!==null&&N.has(k)}function g(k,...B){if(!Array.isArray(k)||!("raw"in k))throw new G("sql","DB","sql","'sql' is a tagged template \u2014 write sql`select 1`, not sql(\"select 1\"). "+"To put text that is not a value into a statement, use 'unsafeSql', and read what it says first.");let q=[];for(let z=0;z<k.length;z++)if(q.push(L(k[z])),z<B.length)q.push(F(B[z]));return Z(Q(...q))}function m(k,B=", "){if(!Array.isArray(k))throw new W("join","DB","sql",`Expected an array of fragments or values, got ${typeof k}.`);if(k.length===0)return b;let q=k.map(F);if(V(B)){let z=[];for(let D=0;D<q.length;D++){if(D>0)z.push(B);z.push(q[D])}return Z(Q(...z))}return j(B),Z(O(q,B))}var h=/^[\s,]*$|^\s*(?:and|or)\s*$/i;function j(k){if(typeof k==="string"&&h.test(k))return;throw new W("join","DB","sql",typeof k==="string"?`A separator is written into the SQL text, so it may only be glue: whitespace, commas, or 'and' / 'or'. Got ${JSON.stringify(k)}. If that is deliberate, say so with `+"unsafeSql(...) \u2014 and never build one from anything that came from "+"outside the program.":`Expected a separator string or a fragment, got ${k===null?"null":typeof k}.`)}var b=Z(Object.freeze({text:"",binders:Object.freeze([])}));function v(k){if(typeof k!=="string")throw new W("unsafeSql","DB","sql",`Expected a string literal, got ${Array.isArray(k)?"an array":typeof k}. 'unsafeSql' is a plain call, not a tagged template \u2014 a template would `+"interpolate values into the SQL text, which is the one thing it must never do.");return Z(L(k))}function p(k,B,q="query"){if(!V(k))throw new W(q,"DB",q,`Expected a fragment built with 'sql', got ${k===null?"null":typeof k}. A plain string is not accepted here on purpose \u2014 it would be the one `+"path into the SQL text that nobody had to think about.");let z=_(k,B),D=y(z.fragment,B,{model:"DB",operation:q});return{text:D.text,values:K(D.binders)(void 0).map((H,X)=>z.jsonParameters.has(X)?C(H,q):H===null||H===void 0?H??null:B.encodeUntyped(H))}}function F(k){if(V(k))return k;return R(()=>k)}
+import{Pg as K,Qg as L,Rg as R,Sg as Y,Tg as M,Ug as Q,Vg as O,Wg as y,ah as U}from"./chunk-feajsgns.js";import{$i as W,_i as G}from"./chunk-vnw91fe1.js";var S=/^\s*::\s*(?:text\s*::\s*)?(jsonb|json)\b(?!\s*\[)/i,I=/^\s*as\s+(jsonb|json)\s*\)/i,P=/\bcast\s*\(\s*$/i,T=new Set;function _(k,B){if(!B.typesParametersFromStatement)return{fragment:k,jsonParameters:T};let q=Y(k),z=new Set,D;for(let H=0;H<q.length-1;H++){let X=q[H+1],$=S.exec(X);if($){D??=[...q],D[H+1]=`::text::${$[1]}${X.slice($[0].length)}`,z.add(H);continue}let J=I.exec(X);if(J&&P.test((D??q)[H]))D??=[...q],D[H+1]=` as text)::${J[1]}${X.slice(J[0].length)}`,z.add(H)}if(!D)return{fragment:k,jsonParameters:z};return{fragment:M(D,k.binders),jsonParameters:z}}function C(k,B){if(k===null||k===void 0)return null;let q=U(k);if(q==="db")return null;if(q==="json")return"null";if(q==="any")throw new W(B,"DB",B,"Prisma.AnyNull is a filter operand \u2014 it asks for a SQL NULL *or* a JSON "+"null \u2014 so it has no single value to bind. Write the one you mean: "+"Prisma.DbNull for the column being NULL, Prisma.JsonNull for the JSON value.");if(typeof k==="string")return k;let z;try{z=JSON.stringify(k)}catch(D){throw new W(B,"DB",B,`A parameter cast to json could not be serialised: ${D instanceof Error?D.message:String(D)}. `+"Bind text you have serialised yourself if the value is not JSON \u2014 a "+"bigint has no JSON form, and neither does a cycle.")}if(z===void 0)throw new W(B,"DB",B,`A ${typeof k} was bound to a parameter cast to json, and has no JSON form. Bind the value it stands for.`);return z}var N=new WeakSet;function Z(k){return N.add(k),k}function V(k){return typeof k==="object"&&k!==null&&N.has(k)}function g(k,...B){if(!Array.isArray(k)||!("raw"in k))throw new G("sql","DB","sql","'sql' is a tagged template \u2014 write sql`select 1`, not sql(\"select 1\"). "+"To put text that is not a value into a statement, use 'unsafeSql', and read what it says first.");let q=[];for(let z=0;z<k.length;z++)if(q.push(L(k[z])),z<B.length)q.push(F(B[z]));return Z(Q(...q))}function m(k,B=", "){if(!Array.isArray(k))throw new W("join","DB","sql",`Expected an array of fragments or values, got ${typeof k}.`);if(k.length===0)return b;let q=k.map(F);if(V(B)){let z=[];for(let D=0;D<q.length;D++){if(D>0)z.push(B);z.push(q[D])}return Z(Q(...z))}return j(B),Z(O(q,B))}var h=/^[\s,]*$|^\s*(?:and|or)\s*$/i;function j(k){if(typeof k==="string"&&h.test(k))return;throw new W("join","DB","sql",typeof k==="string"?`A separator is written into the SQL text, so it may only be glue: whitespace, commas, or 'and' / 'or'. Got ${JSON.stringify(k)}. If that is deliberate, say so with `+"unsafeSql(...) \u2014 and never build one from anything that came from "+"outside the program.":`Expected a separator string or a fragment, got ${k===null?"null":typeof k}.`)}var b=Z(Object.freeze({text:"",binders:Object.freeze([])}));function v(k){if(typeof k!=="string")throw new W("unsafeSql","DB","sql",`Expected a string literal, got ${Array.isArray(k)?"an array":typeof k}. 'unsafeSql' is a plain call, not a tagged template \u2014 a template would `+"interpolate values into the SQL text, which is the one thing it must never do.");return Z(L(k))}function p(k,B,q="query"){if(!V(k))throw new W(q,"DB",q,`Expected a fragment built with 'sql', got ${k===null?"null":typeof k}. A plain string is not accepted here on purpose \u2014 it would be the one `+"path into the SQL text that nobody had to think about.");let z=_(k,B),D=y(z.fragment,B,{model:"DB",operation:q});return{text:D.text,values:K(D.binders)(void 0).map((H,X)=>z.jsonParameters.has(X)?C(H,q):H===null||H===void 0?H??null:B.encodeUntyped(H))}}function F(k){if(V(k))return k;return R(()=>k)}
 export{g as Jg,m as Kg,b as Lg,v as Mg,p as Ng};
 
-//# debugId=2A258EE8E12A87F664756E2164756E21
+//# debugId=F9E8F26266BF56F664756E2164756E21

package/dist/{chunk-2tda49mv.js.map → chunk-ff60bzvf.js.map}

@@ -6,6 +6,6 @@
     "import type { SqlDialect } from \"./dialect\";\nimport {\n  InvalidArgumentError,\n  UnsupportedQueryError,\n} from \"./errors\";\nimport {\n  type Fragment,\n  bindValues,\n  concat,\n  joinFragments,\n  param,\n  render,\n  sql as text,\n} from \"./compile/fragment\";\nimport { jsonTextParameter, retypeJsonParameters } from \"./json-param\";\n\n/**\n * SQL fragments as first-class values: `sql`, `join`, `empty`, and one door out.\n *\n * The ORM deliberately does not implement every SQL shape — `distinct`, cursor\n * pagination, window functions, recursive CTEs. That is the right call, but it\n * is only half a decision: the shapes it declines have to have somewhere to go,\n * and \"drop to raw SQL\" is not an answer if raw SQL cannot be *composed*.\n *\n * `DB.sql` — Bun's tagged template — covers a single self-contained statement,\n * and that is genuinely all it covers. The shape it cannot express is the common\n * one: a predicate list built conditionally, passed around as a value, and\n * interpolated into a larger statement.\n *\n * ```ts\n * const filters = []\n * if (q) filters.push(sql`name ilike ${`%${q}%`}`)\n * if (organizationId) filters.push(sql`\"organizationId\" = ${organizationId}`)\n *\n * const where = filters.length ? sql`where ${join(filters, \" and \")}` : empty\n * const rows = await DB.query(sql`select * from \"Product\" ${where} limit ${20}`)\n * ```\n *\n * ## This is the compiler's own `Fragment`, made public\n *\n * Not a parallel mechanism. `compile/fragment.ts` has held exactly this shape\n * since iteration 1 — text plus positional binders, composable, never\n * concatenating a value into the text — because that is what invariant 2 needs\n * internally. Reusing it means a public fragment binds by the same rule the\n * compiler's own SQL does, and it means the parameter ceiling, the placeholder\n * numbering and the dialect split are all already handled rather than\n * reimplemented one door down.\n *\n * **Placeholders are assigned at assembly, not at authoring.** SQLite writes\n * `?` and Postgres writes `$1`, `$2`, and a fragment does not know where in the\n * final statement it will land — so `sql` records a *position* and `render`\n * turns it into a placeholder once the whole statement exists. That is what lets\n * the same fragment be nested, reused twice in one statement, or built before\n * the dialect is even known.\n */\n\n/**\n * A composable piece of SQL. Its values are bound parameters, never text.\n *\n * Opaque on purpose: an application builds one with `sql`, combines it with\n * `join`, and hands it to `DB.query` / `DB.execute`. Reading `.text` off it is\n * not part of the contract — it holds parameter *markers* rather than the\n * dialect's placeholders, so it is not the statement that runs.\n */\nexport type SqlFragment = Fragment;\n\n/**\n * Every fragment this module has produced.\n *\n * **Identity, not shape, and the difference is a SQL injection.** `interpolate`\n * splices a fragment as text and binds everything else, so \"is this a fragment\"\n * decides whether a value reaches the statement or a parameter. Asking the\n * *shape* — a `text` string and a `binders` array — makes that decision\n * answerable by anything that can name two properties, and `{\"text\": \"…\",\n * \"binders\": []}` is two lines of JSON:\n *\n * ```ts\n * const body = await request.json()\n * await DB.query(sql`select \"email\" from \"User\" where \"email\" = ${body.email}`)\n * // body.email = { text: `'' union select \"password\" from \"User\"`, binders: [] }\n * // -> select \"email\" from \"User\" where \"email\" = '' union select \"password\" from \"User\"\n * ```\n *\n * That is the intended call site with the intended safe value, and it returned\n * the password column out of a statement selecting only `email`. The internal\n * `Fragment` never had the problem because nothing outside `compile/` could\n * construct one; making the type public is what turned \"text plus binders\" from\n * an implementation detail into a shape an attacker can name. `unsafeSql` is\n * built so that reaching for the escape hatch is a decision — a structural check\n * is a second, unmarked door beside it.\n *\n * A `WeakSet` the module owns cannot be forged: membership is granted only by\n * the constructors below. It registers the *returned* object rather than\n * stamping a property, because `concat` and `joinFragments` return fresh objects\n * — a marker property on the inputs would not survive them, and the version that\n * cannot drift is the one that brands what actually comes out.\n */\nconst FRAGMENTS = new WeakSet<object>();\n\nfunction brand(fragment: Fragment): SqlFragment {\n  FRAGMENTS.add(fragment);\n  return fragment;\n}\n\n/** Whether a value is a fragment *this module made*, so it splices rather than binds. */\nfunction isFragment(value: unknown): value is Fragment {\n  return typeof value === \"object\" && value !== null && FRAGMENTS.has(value);\n}\n\n/**\n * A SQL fragment. Every `${value}` is bound as a parameter; a `${fragment}` is\n * spliced in, carrying its own parameters with it.\n *\n * ```ts\n * sql`where \"id\" = ${id}`                       // \"id\" = $1, with id bound\n * sql`where ${sql`\"a\" = ${1}`} and ${sql`\"b\" = ${2}`}`   // nests to any depth\n * ```\n *\n * An interpolated **array** is bound as one value, not expanded — that is what\n * Postgres's `= any($1)` wants, and it is the only reading that does not depend\n * on the dialect. For a comma-separated list of placeholders, say so with\n * `join`.\n *\n * A value at a `::jsonb` cast the caller wrote is the one parameter with a type\n * behind it, and it is bound as **JSON text** so that the statement means what\n * the same statement meant under Prisma's `$executeRaw`:\n *\n * ```ts\n * sql`… set payload = payload || ${JSON.stringify(patch)}::jsonb`  // merges\n * ```\n *\n * Without that the driver would JSON-encode the string and the column would\n * hold the document as a jsonb *string* — which `||` appends as an array\n * element rather than merging. `json-param.ts` has the measurements.\n */\nexport function sql(\n  strings: TemplateStringsArray,\n  ...values: unknown[]\n): SqlFragment {\n  // A defensive check rather than a type error, because the interesting misuse\n  // is `sql(userInput)` — a plain call with a string, which would otherwise\n  // reach `strings.raw` as `undefined` and produce a fragment of `undefined`\n  // text rather than an error. It is also the shape somebody reaches for when\n  // they want the escape hatch and have not found `unsafeSql`.\n  if (!Array.isArray(strings) || !(\"raw\" in (strings as object))) {\n    throw new UnsupportedQueryError(\n      \"sql\",\n      \"DB\",\n      \"sql\",\n      `'sql' is a tagged template — write sql\\`select 1\\`, not sql(\"select 1\"). ` +\n        `To put text that is not a value into a statement, use 'unsafeSql', ` +\n        `and read what it says first.`,\n    );\n  }\n\n  const parts: Fragment[] = [];\n\n  for (let i = 0; i < strings.length; i++) {\n    parts.push(text(strings[i]));\n    if (i < values.length) parts.push(interpolate(values[i]));\n  }\n\n  return brand(concat(...parts));\n}\n\n/**\n * Fragments — or values — joined by a separator, the way `Array.join` reads.\n *\n * ```ts\n * join(filters, \" and \")            // a and b and c\n * join([sql`\"a\" asc`, sql`\"b\" desc`])   // \"a\" asc, \"b\" desc\n * join(ids)                         // $1, $2, $3 — each bound\n * ```\n *\n * An **empty list produces `empty`**, not a separator and not a syntax error, so\n * `join` composes with a list that turned out to have nothing in it. That is the\n * case a caller forgets, and it is the one that would otherwise emit `where ` and\n * fail at the database rather than here.\n *\n * ## The separator is text, so it is not a free string\n *\n * It goes between the fragments *in the statement*, which makes it the one other\n * place a string could reach the SQL — and this module's whole claim is that\n * `unsafeSql` is **the** door. So a plain-string separator has to be glue and\n * nothing else: whitespace, commas, or a boolean connective. Anything more\n * expressive is legitimate and has to say so:\n *\n * ```ts\n * join(filters, \" and \")                 // fine\n * join(parts, unsafeSql(\") and (\"))      // fine, and visibly a decision\n * join(ids, request.query.sep)           // refused\n * ```\n *\n * A **blocklist would not do**, which is why this is an allowlist. The obvious\n * one — reject quotes, semicolons and comment markers — lets this through:\n *\n *     join([1, 2], \") or 1=1 union select password from Users where 1=(1\")\n *\n * No quote, no `--`, still an injection. There is no sound way to say \"this\n * arbitrary text is safe glue\", so the rule is that glue is a small closed set\n * and everything else is a fragment somebody built on purpose.\n */\nexport function join(\n  values: readonly unknown[],\n  separator: string | SqlFragment = \", \",\n): SqlFragment {\n  if (!Array.isArray(values)) {\n    throw new InvalidArgumentError(\n      \"join\",\n      \"DB\",\n      \"sql\",\n      `Expected an array of fragments or values, got ${typeof values}.`,\n    );\n  }\n  if (values.length === 0) return empty;\n\n  const parts = values.map(interpolate);\n\n  if (isFragment(separator)) {\n    const woven: Fragment[] = [];\n    for (let i = 0; i < parts.length; i++) {\n      if (i > 0) woven.push(separator);\n      woven.push(parts[i]);\n    }\n    return brand(concat(...woven));\n  }\n\n  assertGlue(separator);\n  return brand(joinFragments(parts, separator));\n}\n\n/**\n * Whitespace and commas, or a boolean connective surrounded by whitespace.\n *\n * Deliberately small. Every separator a composed statement actually needs is in\n * here — `\", \"`, `\" and \"`, `\" or \"`, `\" \"` — and everything outside it is\n * expressive enough to change what the statement *does*, which is the property\n * that makes it a `unsafeSql` decision rather than a string argument.\n */\nconst GLUE = /^[\\s,]*$|^\\s*(?:and|or)\\s*$/i;\n\nfunction assertGlue(separator: unknown): void {\n  if (typeof separator === \"string\" && GLUE.test(separator)) return;\n\n  throw new InvalidArgumentError(\n    \"join\",\n    \"DB\",\n    \"sql\",\n    typeof separator === \"string\"\n      ? `A separator is written into the SQL text, so it may only be glue: ` +\n        `whitespace, commas, or 'and' / 'or'. Got ` +\n        `${JSON.stringify(separator)}. If that is deliberate, say so with ` +\n        `unsafeSql(...) — and never build one from anything that came from ` +\n        `outside the program.`\n      : `Expected a separator string or a fragment, got ${\n          separator === null ? \"null\" : typeof separator\n        }.`,\n  );\n}\n\n/**\n * The fragment that contributes nothing.\n *\n * The point of it is that `where ${empty}` and `where ${filter}` are the same\n * expression — a conditional predicate is a value, not a branch around the\n * statement. Frozen, because it is shared by every caller and a fragment is read\n * as immutable everywhere else.\n */\nexport const empty: SqlFragment = brand(\n  Object.freeze({ text: \"\", binders: Object.freeze([]) as [] }),\n);\n\n/**\n * **Text straight into the SQL, with no parameter around it.** The one door in\n * this ORM through which a value reaches the statement text.\n *\n * Everything else in the compiler exists to make this impossible — identifiers\n * come from the generated schema, values are bound — so reaching for it should\n * feel like reaching for it. **Never give it a value that came from a request, a\n * form, a URL, a header, a queue payload or a database row.** There is no\n * escaping here and there will not be: escaping that is \"usually right\" is worse\n * than none, because it survives review.\n *\n * ## Why it exists at all, since that is the fair question\n *\n * Plan quality can depend on *not* parameterising. A partial index declared as\n *\n * ```sql\n * create index … on \"Job\" (…) where \"name\" is distinct from 'reaper'\n * ```\n *\n * is only usable if the planner can prove the query's predicate matches the\n * index's. A bound parameter is opaque at plan time, so `where \"name\" is\n * distinct from $1` does not match — and the query falls back to a sequential\n * scan over the whole table. The constant has to be *in the text*:\n *\n * ```ts\n * const REAPER = unsafeSql(`'reaper'`)   // a literal in this file, never input\n * await DB.query(sql`\n *   select … from \"Job\" where \"name\" is distinct from ${REAPER} …\n * `)\n * ```\n *\n * A builder with no escape hatch cannot express that at any price, and the\n * workaround — hand-writing the whole statement — loses composition for every\n * other part of it.\n *\n * The same applies to the other things that cannot be parameters in SQL:\n * identifiers, a sort direction, a table name chosen from a fixed set in code.\n * All of them share the rule above — the value is written in the source file, or\n * chosen from a set written in the source file, never passed in.\n */\nexport function unsafeSql(literal: string): SqlFragment {\n  if (typeof literal !== \"string\") {\n    throw new InvalidArgumentError(\n      \"unsafeSql\",\n      \"DB\",\n      \"sql\",\n      `Expected a string literal, got ${\n        Array.isArray(literal) ? \"an array\" : typeof literal\n      }. 'unsafeSql' is a plain call, not a tagged template — a template would ` +\n        `interpolate values into the SQL text, which is the one thing it must ` +\n        `never do.`,\n    );\n  }\n  return brand(text(literal));\n}\n\n/**\n * A fragment as the statement a driver can run: the dialect's placeholders in\n * the text, and the values in the order they appear.\n *\n * Separate from the executing, and exported, because it is the half that is a\n * pure function of `(fragment, dialect)` — so a test can assert what a\n * composition emits on both dialects without a database anywhere near it, which\n * is exactly how the rest of the compiler is tested.\n *\n * `render` also applies the parameter ceiling here, which matters more for a\n * hand-built fragment than for a compiled plan: `join(ids)` over a\n * request-derived list is one placeholder per element on SQLite, and 40 000 of\n * them is a driver error rather than a clear one.\n */\nexport function renderFragment(\n  fragment: SqlFragment,\n  dialect: SqlDialect,\n  operation = \"query\",\n): { text: string; values: unknown[] } {\n  if (!isFragment(fragment)) {\n    throw new InvalidArgumentError(\n      operation,\n      \"DB\",\n      operation,\n      `Expected a fragment built with 'sql', got ${\n        fragment === null ? \"null\" : typeof fragment\n      }. A plain string is not accepted here on purpose — it would be the one ` +\n        `path into the SQL text that nobody had to think about.`,\n    );\n  }\n\n  // The one thing a raw parameter can be *told* about its type: a `::jsonb` the\n  // caller wrote onto their own placeholder. Where there is one, the parameter\n  // is retyped through `text` and its value serialised, because Bun otherwise\n  // JSON-encodes a string bound to a `jsonb` parameter and stores the document\n  // as a jsonb *string* where Prisma stored the object. See `json-param.ts` —\n  // the mechanism, the measurements, and why a string is not serialised here\n  // while `fieldParam` serialises one.\n  //\n  // The dialect is passed because this is not universal, and the reason is\n  // narrower than it looks: `::` is Postgres-only syntax, but `cast(? as json)`\n  // *parses and runs* on SQLite, where it means NUMERIC affinity — so retyping\n  // it would rewrite a working statement into `cast(? as text)::json`, which\n  // SQLite cannot parse. `typesParametersFromStatement` is false there.\n  const json = retypeJsonParameters(fragment, dialect);\n\n  const rendered = render(json.fragment, dialect, { model: \"DB\", operation });\n  return {\n    text: rendered.text,\n    // `encodeUntyped` and not `encode`: there is no field here to ask, which is\n    // the whole difference between a fragment's parameters and a compiled\n    // plan's. It normalises the two JavaScript types whose SQL form the ORM has\n    // already decided — a `Date` and a boolean — so a raw statement compares\n    // against ORM-written rows on both dialects rather than only on Postgres.\n    values: bindValues(rendered.binders)(undefined).map((value, index) =>\n      json.jsonParameters.has(index)\n        ? jsonTextParameter(value, operation)\n        : value === null || value === undefined\n          ? (value ?? null)\n          : dialect.encodeUntyped(value),\n    ),\n  };\n}\n\n/**\n * One interpolated slot: a fragment splices, anything else binds.\n *\n * The binder ignores both its arguments. A compiled plan's binders read the\n * *call's* argument tree, because one plan serves many calls; a fragment is\n * built per call and closes over the value it was given, which is the whole\n * difference between the compiler's fragments and these.\n */\nfunction interpolate(value: unknown): Fragment {\n  if (isFragment(value)) return value;\n  return param(() => value);\n}\n"
   ],
   "mappings": "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",
-  "debugId": "2A258EE8E12A87F664756E2164756E21",
+  "debugId": "F9E8F26266BF56F664756E2164756E21",
   "names": []
 }

package/dist/{chunk-b00z33zg.js → chunk-gng5e7pd.js}

@@ -1,5 +1,5 @@
 // @bun
-import"./chunk-aprjvzrz.js";import Eu from"os";import Au from"fs";var Wl=new Map,hh=new Map,nh=Symbol("OriginError"),Dl={};class fl extends Promise{constructor(l,n,u,c,w={}){let E,t;super((_,B)=>{E=_,t=B});this.tagged=Array.isArray(l.raw),this.strings=l,this.args=n,this.handler=u,this.canceller=c,this.options=w,this.state=null,this.statement=null,this.resolve=(_)=>(this.active=!1,E(_)),this.reject=(_)=>(this.active=!1,t(_)),this.active=!1,this.cancelled=null,this.executed=!1,this.signature="",this[nh]=this.handler.debug?Error():this.tagged&&vn(this.strings)}get origin(){return(this.handler.debug?this[nh].stack:this.tagged&&hh.has(this.strings)?hh.get(this.strings):hh.set(this.strings,this[nh].stack).get(this.strings))||""}static get[Symbol.species](){return Promise}cancel(){return this.canceller&&(this.canceller(this),this.canceller=null)}simple(){return this.options.simple=!0,this.options.prepare=!1,this}async readable(){return this.simple(),this.streaming=!0,this}async writable(){return this.simple(),this.streaming=!0,this}cursor(l=1,n){if(this.options.simple=!1,typeof l==="function")n=l,l=1;if(this.cursorRows=l,typeof n==="function")return this.cursorFn=n,this;let u;return{[Symbol.asyncIterator]:()=>({next:()=>{if(this.executed&&!this.active)return{done:!0};u&&u();let c=new Promise((w,E)=>{this.cursorFn=(t)=>{return w({value:t,done:!1}),new Promise((_)=>u=_)},this.resolve=()=>(this.active=!1,w({done:!0})),this.reject=(t)=>(this.active=!1,E(t))});return this.execute(),c},return(){return u&&u(Dl),{done:!0}}})}}describe(){return this.options.simple=!1,this.onlyDescribe=this.options.prepare=!0,this}stream(){throw Error(".stream has been renamed to .forEach")}forEach(l){return this.forEachFn=l,this.handle(),this}raw(){return this.isRaw=!0,this}values(){return this.isRaw="values",this}async handle(){!this.executed&&(this.executed=!0)&&await 1&&this.handler(this)}execute(){return this.handle(),this}then(){return this.handle(),super.then.apply(this,arguments)}catch(){return this.handle(),super.catch.apply(this,arguments)}finally(){return this.handle(),super.finally.apply(this,arguments)}}function vn(l){if(Wl.has(l))return Wl.get(l);let n=Error.stackTraceLimit;return Error.stackTraceLimit=4,Wl.set(l,Error()),Error.stackTraceLimit=n,Wl.get(l)}class Yl extends Error{constructor(l){super(l.message);this.name=this.constructor.name,Object.assign(this,l)}}var K={connection:Th,postgres:Xh,generic:Ch,notSupported:Zh};function Th(l,n,u){let{host:c,port:w}=u||n,E=Object.assign(Error("write "+l+" "+(n.path||c+":"+w)),{code:l,errno:l,address:n.path||c},n.path?{}:{port:w});return Error.captureStackTrace(E,Th),E}function Xh(l){let n=new Yl(l);return Error.captureStackTrace(n,Xh),n}function Ch(l,n){let u=Object.assign(Error(l+": "+n),{code:l});return Error.captureStackTrace(u,Ch),u}function Zh(l){let n=Object.assign(Error(l+" (B) is not supported"),{code:"MESSAGE_NOT_SUPPORTED",name:l});return Error.captureStackTrace(n,Zh),n}var mn={string:{to:25,from:null,serialize:(l)=>""+l},number:{to:0,from:[21,23,26,700,701],serialize:(l)=>""+l,parse:(l)=>+l},json:{to:114,from:[114,3802],serialize:(l)=>JSON.stringify(l),parse:(l)=>JSON.parse(l)},boolean:{to:16,from:16,serialize:(l)=>l===!0?"t":"f",parse:(l)=>l==="t"},date:{to:1184,from:[1082,1114,1184],serialize:(l)=>(l instanceof Date?l:new Date(l)).toISOString(),parse:(l)=>new Date(l)},bytea:{to:17,from:17,serialize:(l)=>"\\x"+Buffer.from(l).toString("hex"),parse:(l)=>Buffer.from(l.slice(2),"hex")}};class ml{then(){uh()}catch(){uh()}finally(){uh()}}class il extends ml{constructor(l){super();this.value=el(l)}}class wl extends ml{constructor(l,n,u){super();this.value=l,this.type=n,this.array=u}}class bl extends ml{constructor(l,n){super();this.first=l,this.rest=n}build(l,n,u,c){let w=bn.map(([E,t])=>({fn:t,i:l.search(E)})).sort((E,t)=>E.i-t.i).pop();return w.i===-1?_h(this.first,c):w.fn(this.first,this.rest,n,u,c)}}function al(l,n,u,c){let w=l instanceof wl?l.value:l;if(w===void 0){if(l instanceof wl?l.value=c.transform.undefined:w=l=c.transform.undefined,w===void 0)throw K.generic("UNDEFINED_VALUE","Undefined values are not allowed")}return"$"+u.push(l instanceof wl?(n.push(l.value),l.array?l.array[l.type||vl(l.value)]||l.type||ih(l.value):l.type):(n.push(l),vl(l)))}var Hh=Qh(mn);function th(l,n,u,c,w,E){for(let t=1;t<l.strings.length;t++)n+=wh(n,u,c,w,E)+l.strings[t],u=l.args[t];return n}function wh(l,n,u,c,w){return n instanceof bl?n.build(l,u,c,w):n instanceof fl?ch(n,u,c,w):n instanceof il?n.value:n&&n[0]instanceof fl?n.reduce((E,t)=>E+" "+ch(t,u,c,w),""):al(n,u,c,w)}function ch(l,n,u,c){return l.fragment=!0,th(l,l.strings[0],l.args[0],n,u,c)}function zh(l,n,u,c,w){return l.map((E)=>"("+c.map((t)=>wh("values",E[t],n,u,w)).join(",")+")").join(",")}function Fh(l,n,u,c,w){let E=Array.isArray(l[0]),t=n.length?n.flat():Object.keys(E?l[0]:l);return zh(E?l:[l],u,c,t,w)}function Kl(l,n,u,c,w){if(typeof l==="string"&&(l=[l].concat(n)),Array.isArray(l))return _h(l,w);let E;return(n.length?n.flat():Object.keys(l)).map((_)=>{return E=l[_],(E instanceof fl?ch(E,u,c,w):E instanceof il?E.value:al(E,u,c,w))+" as "+el(w.transform.column.to?w.transform.column.to(_):_)}).join(",")}var bn=Object.entries({values:Fh,in:(...l)=>{let n=Fh(...l);return n==="()"?"(null)":n},select:Kl,as:Kl,returning:Kl,"\\(":Kl,update(l,n,u,c,w){return(n.length?n.flat():Object.keys(l)).map((E)=>el(w.transform.column.to?w.transform.column.to(E):E)+"="+wh("values",l[E],u,c,w))},insert(l,n,u,c,w){let E=n.length?n.flat():Object.keys(Array.isArray(l)?l[0]:l);return"("+_h(E,w)+")values"+zh(Array.isArray(l)?l:[l],u,c,E,w)}}).map(([l,n])=>[new RegExp("((?:^|[\\s(])"+l+"(?:$|[\\s(]))(?![\\s\\S]*\\1)","i"),n]);function uh(){throw K.generic("NOT_TAGGED_CALL","Query not called as a tagged template literal")}var{serializers:an,parsers:en}=Hh;function ih(l){if(Array.isArray(l))return ih(l[0]);return typeof l==="string"?1009:0}var Jh=function(l){let n=Qh(l||{});return{serializers:Object.assign({},an,n.serializers),parsers:Object.assign({},en,n.parsers)}};function Qh(l){return Object.keys(l).reduce((n,u)=>{if(l[u].from&&[].concat(l[u].from).forEach((c)=>n.parsers[c]=l[u].parse),l[u].serialize)n.serializers[l[u].to]=l[u].serialize,l[u].from&&[].concat(l[u].from).forEach((c)=>n.serializers[c]=l[u].serialize);return n},{parsers:{},serializers:{}})}function _h(l,{transform:{column:n}}){return l.map((u)=>el(n.to?n.to(u):u)).join(",")}var el=function(n){return'"'+n.replace(/"/g,'""').replace(/\./g,'"."')+'"'},vl=function l(n){return n instanceof wl?n.type:n instanceof Date?1184:n instanceof Uint8Array?17:n===!0||n===!1?16:typeof n==="bigint"?20:Array.isArray(n)?l(n[0]):0},kn=/\\/g,on=/"/g;function pn(l){return l.replace(kn,"\\\\").replace(on,"\\\"")}var Vh=function l(n,u,c,w){if(Array.isArray(n)===!1)return n;if(!n.length)return"{}";let E=n[0],t=w===1020?";":",";if(Array.isArray(E)&&!E.type)return"{"+n.map((_)=>l(_,u,c,w)).join(t)+"}";return"{"+n.map((_)=>{if(_===void 0){if(_=c.transform.undefined,_===void 0)throw K.generic("UNDEFINED_VALUE","Undefined values are not allowed")}return _===null?"null":'"'+pn(u?u(_.type?_.value:_):""+_)+'"'}).join(t)+"}"},fh={i:0,char:null,str:"",quoted:!1,last:0},Wh=function(n,u,c){return fh.i=fh.last=0,Kh(fh,n,u,c)};function Kh(l,n,u,c){let w=[],E=c===1020?";":",";for(;l.i<n.length;l.i++){if(l.char=n[l.i],l.quoted)if(l.char==="\\")l.str+=n[++l.i];else if(l.char==='"')w.push(u?u(l.str):l.str),l.str="",l.quoted=n[l.i+1]==='"',l.last=l.i+2;else l.str+=l.char;else if(l.char==='"')l.quoted=!0;else if(l.char==="{")l.last=++l.i,w.push(Kh(l,n,u,c));else if(l.char==="}"){l.quoted=!1,l.last<l.i&&w.push(u?u(n.slice(l.last,l.i)):n.slice(l.last,l.i)),l.last=l.i+1;break}else if(l.char===E&&l.p!=="}"&&l.p!=='"')w.push(u?u(n.slice(l.last,l.i)):n.slice(l.last,l.i)),l.last=l.i+1;l.p=l.char}return l.last<l.i&&w.push(u?u(n.slice(l.last,l.i+1)):n.slice(l.last,l.i+1)),w}var Sl=(l)=>{let n=l[0];for(let u=1;u<l.length;u++)n+=l[u]==="_"?l[++u].toUpperCase():l[u];return n},Gl=(l)=>{let n=l[0].toUpperCase();for(let u=1;u<l.length;u++)n+=l[u]==="_"?l[++u].toUpperCase():l[u];return n},jl=(l)=>l.replace(/_/g,"-"),Fl=(l)=>l.replace(/([A-Z])/g,"_$1").toLowerCase(),Hl=(l)=>(l.slice(0,1)+l.slice(1).replace(/([A-Z])/g,"_$1")).toLowerCase(),zl=(l)=>l.replace(/-/g,"_");function Oh(l){return function n(u,c){return typeof u==="object"&&u!==null&&(c.type===114||c.type===3802)?Array.isArray(u)?u.map((w)=>n(w,c)):Object.entries(u).reduce((w,[E,t])=>Object.assign(w,{[l(E)]:n(t,c)}),{}):u}}Sl.column={from:Sl};Sl.value={from:Oh(Sl)};Fl.column={to:Fl};var Eh={...Sl};Eh.column.to=Fl;Gl.column={from:Gl};Gl.value={from:Oh(Gl)};Hl.column={to:Hl};var Ah={...Gl};Ah.column.to=Hl;jl.column={from:jl};jl.value={from:Oh(jl)};zl.column={to:zl};var Uh={...jl};Uh.column.to=zl;import vh from"net";import qn from"tls";import Jl from"crypto";import $h from"stream";import{performance as mh}from"perf_hooks";class Ml extends Array{constructor(){super();Object.defineProperties(this,{count:{value:null,writable:!0},state:{value:null,writable:!0},command:{value:null,writable:!0},columns:{value:null,writable:!0},statement:{value:null,writable:!0}})}static get[Symbol.species](){return Array}}var hl=yn;function yn(l=[]){let n=l.slice(),u=0;return{get length(){return n.length-u},remove:(c)=>{let w=n.indexOf(c);return w===-1?null:(n.splice(w,1),c)},push:(c)=>(n.push(c),c),shift:()=>{let c=n[u++];if(u===n.length)u=0,n=[];else n[u-1]=void 0;return c}}}var p=Buffer.allocUnsafe(256),rn="BCcDdEFfHPpQSX".split("").reduce((l,n)=>{let u=n.charCodeAt(0);return l[n]=()=>{return p[0]=u,R.i=5,R},l},{}),R=Object.assign(sn,rn,{N:String.fromCharCode(0),i:0,inc(l){return R.i+=l,R},str(l){let n=Buffer.byteLength(l);return kl(n),R.i+=p.write(l,R.i,n,"utf8"),R},i16(l){return kl(2),p.writeUInt16BE(l,R.i),R.i+=2,R},i32(l,n){if(n||n===0)return p.writeUInt32BE(l,n),R;return kl(4),p.writeUInt32BE(l,R.i),R.i+=4,R},z(l){return kl(l),p.fill(0,R.i,R.i+l),R.i+=l,R},raw(l){return p=Buffer.concat([p.subarray(0,R.i),l]),R.i=p.length,R},end(l=1){p.writeUInt32BE(R.i-l,l);let n=p.subarray(0,R.i);return R.i=0,p=Buffer.allocUnsafe(256),n}}),$=R;function kl(l){if(p.length-R.i<l){let n=p,u=n.length;p=Buffer.allocUnsafe(u+(u>>1)+l),n.copy(p)}}function sn(){return R.i=0,R}var Bh=eh,xn=1,Bl=$().S().end(),bh=$().H().end(),lu=$().i32(8).i32(80877103).end(8),hu=Buffer.concat([$().E().str($.N).i32(0).end(),Bl]),nu=$().D().str("S").str($.N).end(),Rl=()=>{},uu=new Set(["FetchPreparedStatement","RevalidateCachedQuery","transformAssignedExpr"]),fu={83:"severity_local",86:"severity",67:"code",77:"message",68:"detail",72:"hint",80:"position",112:"internal_position",113:"internal_query",87:"where",115:"schema_name",116:"table_name",99:"column_name",100:"data type_name",110:"constraint_name",70:"file",76:"line",82:"routine"};function eh(l,n={},{onopen:u=Rl,onend:c=Rl,onclose:w=Rl}={}){let{sslnegotiation:E,ssl:t,max:_,user:B,host:Q,port:T,database:Y,parsers:j,transform:M,onnotice:H,onnotify:I,onparameter:b,max_pipeline:Z,keep_alive:cl,backoff:nl,target_session_attrs:x}=l,d=hl(),Ul=xn++,_l={pid:null,secret:null},Pl=gh(xl,l.idle_timeout),Il=gh(xl,l.max_lifetime),L=gh(xh,l.connect_timeout),U=null,Ol,q=null,N=new Ml,y=Buffer.alloc(0),dl=l.fetch_types,El={},O={},S=Math.random().toString(36).slice(2),F=1,v=0,V=0,G=0,D=0,i=0,J=0,m=0,r=null,X=null,Al=!1,tl=null,$l=null,e=null,z=null,C=null,ll=null,Ql=null,sl=null,A=null,Tl=null,k={queue:n.closed,idleTimer:Pl,connect(h){e=h,Lh()},terminate:Zl,execute:Xl,cancel:yh,end:xl,count:0,id:Ul};return n.closed&&n.closed.push(k),k;async function ph(){let h;try{h=l.socket?await Promise.resolve(l.socket(l)):new vh.Socket}catch(f){Nl(f);return}return h.on("error",Nl),h.on("close",Nh),h.on("drain",Ph),h}async function yh({pid:h,secret:f},g,P){try{Ol=$().i32(16).i32(80877102).i32(h).i32(f).end(16),await dh(),U.once("error",P),U.once("close",g)}catch(W){P(W)}}function Xl(h){if(Al)return Cl(h,K.connection("CONNECTION_DESTROYED",l));if(C)return Cl(h,K.generic("COPY_IN_PROGRESS","You cannot execute queries during copy"));if(h.cancelled)return;try{return h.state=_l,A?d.push(h):(A=h,A.active=!0),qh(h),a(rh(h))&&!h.describeFirst&&!h.cursorFn&&d.length<Z&&(!h.options.onexecute||h.options.onexecute(k))}catch(f){return d.length===0&&a(Bl),ul(f),!0}}function rh(h){if(h.parameters.length>=65534)throw K.generic("MAX_PARAMETERS_EXCEEDED","Max number of parameters (65534) exceeded");return h.options.simple?$().Q().str(h.statement.string+$.N).end():h.describeFirst?Buffer.concat([Gh(h),bh]):h.prepare?h.prepared?Vl(h):Buffer.concat([Gh(h),Vl(h)]):sh(h)}function Gh(h){return Buffer.concat([Yh(h.statement.string,h.parameters,h.statement.types,h.statement.name),Vn("S",h.statement.name)])}function Vl(h){return Buffer.concat([Qn(h.parameters,h.statement.types,h.statement.name,h.cursorName),h.cursorFn?Rh("",h.cursorRows):hu])}function sh(h){return Buffer.concat([Yh(h.statement.string,h.parameters,h.statement.types),nu,Vl(h)])}function qh(h){let f=[],g=[],P=th(h,h.strings[0],h.args[0],f,g,l);!h.tagged&&h.args.forEach((W)=>al(W,f,g,l)),h.prepare=l.prepare&&("prepare"in h.options?h.options.prepare:!0),h.string=P,h.signature=h.prepare&&g+P,h.onlyDescribe&&delete O[h.signature],h.parameters=h.parameters||f,h.prepared=h.prepare&&h.signature in O,h.describeFirst=h.onlyDescribe||f.length&&!h.prepared,h.statement=h.prepared?O[h.signature]:{string:P,types:g,name:h.prepare?S+F++:""},typeof l.debug==="function"&&l.debug(Ul,P,f,g)}function a(h,f){if(ll=ll?Buffer.concat([ll,h]):Buffer.from(h),f||ll.length>=1024)return jh(f);return X===null&&(X=setImmediate(jh)),!0}function jh(h){let f=U.write(ll,h);return X!==null&&clearImmediate(X),ll=X=null,f}function xh(){ul(K.connection("CONNECT_TIMEOUT",l,U)),U.destroy()}async function Mh(){if(E!=="direct"){if(a(lu),!await new Promise((g)=>U.once("data",(P)=>g(P[0]===83)))&&t==="prefer")return Ll()}let h={socket:U,servername:vh.isIP(U.host)?void 0:U.host};if(E==="direct")h.ALPNProtocols=["postgresql"];if(t==="require"||t==="allow"||t==="prefer")h.rejectUnauthorized=!1;else if(typeof t==="object")Object.assign(h,t);U.removeAllListeners(),U=qn.connect(h),U.on("secureConnect",Ll),U.on("error",Nl),U.on("close",Nh),U.on("drain",Ph)}function Ph(){!A&&u(k)}function ql(h){if(tl){if(tl.push(h),V-=h.length,V>0)return}y=tl?Buffer.concat(tl,i-V):y.length===0?h:Buffer.concat([y,h],y.length+h.length);while(y.length>4){if(i=y.readUInt32BE(1),i>=y.length){V=i-y.length,tl=[y];break}try{ln(y.subarray(0,i+1))}catch(f){A&&(A.cursorFn||A.describeFirst)&&a(Bl),ul(f)}y=y.subarray(i+1),V=0,tl=null}}async function dh(){if(Al=!1,El={},U||(U=await ph()),!U)return;if(L.start(),l.socket)return t?Mh():Ll();if(U.on("connect",t?Mh:Ll),l.path)return U.connect(l.path);U.ssl=t,U.connect(T[G],Q[G]),U.host=Q[G],U.port=T[G],G=(G+1)%T.length}function Lh(){setTimeout(dh,v?Math.max(0,v+J-mh.now()):0)}function Ll(){try{O={},dl=l.fetch_types,S=Math.random().toString(36).slice(2),F=1,Il.start(),U.on("data",ql),cl&&U.setKeepAlive&&U.setKeepAlive(!0,1000*cl);let h=Kn();a(h)}catch(h){Nl(h)}}function Nl(h){if(k.queue===n.connecting&&l.host[D+1])return;ul(h);while(d.length)Cl(d.shift(),h)}function ul(h){C&&(C.destroy(h),C=null),A&&Cl(A,h),e&&(Cl(e,h),e=null)}function Cl(h,f){if(h.reserve)return h.reject(f);if(!f||typeof f!=="object")f=Error(f);"query"in f||"parameters"in f||Object.defineProperties(f,{stack:{value:f.stack+h.origin.replace(/.*\n/,`
+import"./chunk-rnp5k8m3.js";import Eu from"os";import Au from"fs";var Wl=new Map,hh=new Map,nh=Symbol("OriginError"),Dl={};class fl extends Promise{constructor(l,n,u,c,w={}){let E,t;super((_,B)=>{E=_,t=B});this.tagged=Array.isArray(l.raw),this.strings=l,this.args=n,this.handler=u,this.canceller=c,this.options=w,this.state=null,this.statement=null,this.resolve=(_)=>(this.active=!1,E(_)),this.reject=(_)=>(this.active=!1,t(_)),this.active=!1,this.cancelled=null,this.executed=!1,this.signature="",this[nh]=this.handler.debug?Error():this.tagged&&vn(this.strings)}get origin(){return(this.handler.debug?this[nh].stack:this.tagged&&hh.has(this.strings)?hh.get(this.strings):hh.set(this.strings,this[nh].stack).get(this.strings))||""}static get[Symbol.species](){return Promise}cancel(){return this.canceller&&(this.canceller(this),this.canceller=null)}simple(){return this.options.simple=!0,this.options.prepare=!1,this}async readable(){return this.simple(),this.streaming=!0,this}async writable(){return this.simple(),this.streaming=!0,this}cursor(l=1,n){if(this.options.simple=!1,typeof l==="function")n=l,l=1;if(this.cursorRows=l,typeof n==="function")return this.cursorFn=n,this;let u;return{[Symbol.asyncIterator]:()=>({next:()=>{if(this.executed&&!this.active)return{done:!0};u&&u();let c=new Promise((w,E)=>{this.cursorFn=(t)=>{return w({value:t,done:!1}),new Promise((_)=>u=_)},this.resolve=()=>(this.active=!1,w({done:!0})),this.reject=(t)=>(this.active=!1,E(t))});return this.execute(),c},return(){return u&&u(Dl),{done:!0}}})}}describe(){return this.options.simple=!1,this.onlyDescribe=this.options.prepare=!0,this}stream(){throw Error(".stream has been renamed to .forEach")}forEach(l){return this.forEachFn=l,this.handle(),this}raw(){return this.isRaw=!0,this}values(){return this.isRaw="values",this}async handle(){!this.executed&&(this.executed=!0)&&await 1&&this.handler(this)}execute(){return this.handle(),this}then(){return this.handle(),super.then.apply(this,arguments)}catch(){return this.handle(),super.catch.apply(this,arguments)}finally(){return this.handle(),super.finally.apply(this,arguments)}}function vn(l){if(Wl.has(l))return Wl.get(l);let n=Error.stackTraceLimit;return Error.stackTraceLimit=4,Wl.set(l,Error()),Error.stackTraceLimit=n,Wl.get(l)}class Yl extends Error{constructor(l){super(l.message);this.name=this.constructor.name,Object.assign(this,l)}}var K={connection:Th,postgres:Xh,generic:Ch,notSupported:Zh};function Th(l,n,u){let{host:c,port:w}=u||n,E=Object.assign(Error("write "+l+" "+(n.path||c+":"+w)),{code:l,errno:l,address:n.path||c},n.path?{}:{port:w});return Error.captureStackTrace(E,Th),E}function Xh(l){let n=new Yl(l);return Error.captureStackTrace(n,Xh),n}function Ch(l,n){let u=Object.assign(Error(l+": "+n),{code:l});return Error.captureStackTrace(u,Ch),u}function Zh(l){let n=Object.assign(Error(l+" (B) is not supported"),{code:"MESSAGE_NOT_SUPPORTED",name:l});return Error.captureStackTrace(n,Zh),n}var mn={string:{to:25,from:null,serialize:(l)=>""+l},number:{to:0,from:[21,23,26,700,701],serialize:(l)=>""+l,parse:(l)=>+l},json:{to:114,from:[114,3802],serialize:(l)=>JSON.stringify(l),parse:(l)=>JSON.parse(l)},boolean:{to:16,from:16,serialize:(l)=>l===!0?"t":"f",parse:(l)=>l==="t"},date:{to:1184,from:[1082,1114,1184],serialize:(l)=>(l instanceof Date?l:new Date(l)).toISOString(),parse:(l)=>new Date(l)},bytea:{to:17,from:17,serialize:(l)=>"\\x"+Buffer.from(l).toString("hex"),parse:(l)=>Buffer.from(l.slice(2),"hex")}};class ml{then(){uh()}catch(){uh()}finally(){uh()}}class il extends ml{constructor(l){super();this.value=el(l)}}class wl extends ml{constructor(l,n,u){super();this.value=l,this.type=n,this.array=u}}class bl extends ml{constructor(l,n){super();this.first=l,this.rest=n}build(l,n,u,c){let w=bn.map(([E,t])=>({fn:t,i:l.search(E)})).sort((E,t)=>E.i-t.i).pop();return w.i===-1?_h(this.first,c):w.fn(this.first,this.rest,n,u,c)}}function al(l,n,u,c){let w=l instanceof wl?l.value:l;if(w===void 0){if(l instanceof wl?l.value=c.transform.undefined:w=l=c.transform.undefined,w===void 0)throw K.generic("UNDEFINED_VALUE","Undefined values are not allowed")}return"$"+u.push(l instanceof wl?(n.push(l.value),l.array?l.array[l.type||vl(l.value)]||l.type||ih(l.value):l.type):(n.push(l),vl(l)))}var Hh=Qh(mn);function th(l,n,u,c,w,E){for(let t=1;t<l.strings.length;t++)n+=wh(n,u,c,w,E)+l.strings[t],u=l.args[t];return n}function wh(l,n,u,c,w){return n instanceof bl?n.build(l,u,c,w):n instanceof fl?ch(n,u,c,w):n instanceof il?n.value:n&&n[0]instanceof fl?n.reduce((E,t)=>E+" "+ch(t,u,c,w),""):al(n,u,c,w)}function ch(l,n,u,c){return l.fragment=!0,th(l,l.strings[0],l.args[0],n,u,c)}function zh(l,n,u,c,w){return l.map((E)=>"("+c.map((t)=>wh("values",E[t],n,u,w)).join(",")+")").join(",")}function Fh(l,n,u,c,w){let E=Array.isArray(l[0]),t=n.length?n.flat():Object.keys(E?l[0]:l);return zh(E?l:[l],u,c,t,w)}function Kl(l,n,u,c,w){if(typeof l==="string"&&(l=[l].concat(n)),Array.isArray(l))return _h(l,w);let E;return(n.length?n.flat():Object.keys(l)).map((_)=>{return E=l[_],(E instanceof fl?ch(E,u,c,w):E instanceof il?E.value:al(E,u,c,w))+" as "+el(w.transform.column.to?w.transform.column.to(_):_)}).join(",")}var bn=Object.entries({values:Fh,in:(...l)=>{let n=Fh(...l);return n==="()"?"(null)":n},select:Kl,as:Kl,returning:Kl,"\\(":Kl,update(l,n,u,c,w){return(n.length?n.flat():Object.keys(l)).map((E)=>el(w.transform.column.to?w.transform.column.to(E):E)+"="+wh("values",l[E],u,c,w))},insert(l,n,u,c,w){let E=n.length?n.flat():Object.keys(Array.isArray(l)?l[0]:l);return"("+_h(E,w)+")values"+zh(Array.isArray(l)?l:[l],u,c,E,w)}}).map(([l,n])=>[new RegExp("((?:^|[\\s(])"+l+"(?:$|[\\s(]))(?![\\s\\S]*\\1)","i"),n]);function uh(){throw K.generic("NOT_TAGGED_CALL","Query not called as a tagged template literal")}var{serializers:an,parsers:en}=Hh;function ih(l){if(Array.isArray(l))return ih(l[0]);return typeof l==="string"?1009:0}var Jh=function(l){let n=Qh(l||{});return{serializers:Object.assign({},an,n.serializers),parsers:Object.assign({},en,n.parsers)}};function Qh(l){return Object.keys(l).reduce((n,u)=>{if(l[u].from&&[].concat(l[u].from).forEach((c)=>n.parsers[c]=l[u].parse),l[u].serialize)n.serializers[l[u].to]=l[u].serialize,l[u].from&&[].concat(l[u].from).forEach((c)=>n.serializers[c]=l[u].serialize);return n},{parsers:{},serializers:{}})}function _h(l,{transform:{column:n}}){return l.map((u)=>el(n.to?n.to(u):u)).join(",")}var el=function(n){return'"'+n.replace(/"/g,'""').replace(/\./g,'"."')+'"'},vl=function l(n){return n instanceof wl?n.type:n instanceof Date?1184:n instanceof Uint8Array?17:n===!0||n===!1?16:typeof n==="bigint"?20:Array.isArray(n)?l(n[0]):0},kn=/\\/g,on=/"/g;function pn(l){return l.replace(kn,"\\\\").replace(on,"\\\"")}var Vh=function l(n,u,c,w){if(Array.isArray(n)===!1)return n;if(!n.length)return"{}";let E=n[0],t=w===1020?";":",";if(Array.isArray(E)&&!E.type)return"{"+n.map((_)=>l(_,u,c,w)).join(t)+"}";return"{"+n.map((_)=>{if(_===void 0){if(_=c.transform.undefined,_===void 0)throw K.generic("UNDEFINED_VALUE","Undefined values are not allowed")}return _===null?"null":'"'+pn(u?u(_.type?_.value:_):""+_)+'"'}).join(t)+"}"},fh={i:0,char:null,str:"",quoted:!1,last:0},Wh=function(n,u,c){return fh.i=fh.last=0,Kh(fh,n,u,c)};function Kh(l,n,u,c){let w=[],E=c===1020?";":",";for(;l.i<n.length;l.i++){if(l.char=n[l.i],l.quoted)if(l.char==="\\")l.str+=n[++l.i];else if(l.char==='"')w.push(u?u(l.str):l.str),l.str="",l.quoted=n[l.i+1]==='"',l.last=l.i+2;else l.str+=l.char;else if(l.char==='"')l.quoted=!0;else if(l.char==="{")l.last=++l.i,w.push(Kh(l,n,u,c));else if(l.char==="}"){l.quoted=!1,l.last<l.i&&w.push(u?u(n.slice(l.last,l.i)):n.slice(l.last,l.i)),l.last=l.i+1;break}else if(l.char===E&&l.p!=="}"&&l.p!=='"')w.push(u?u(n.slice(l.last,l.i)):n.slice(l.last,l.i)),l.last=l.i+1;l.p=l.char}return l.last<l.i&&w.push(u?u(n.slice(l.last,l.i+1)):n.slice(l.last,l.i+1)),w}var Sl=(l)=>{let n=l[0];for(let u=1;u<l.length;u++)n+=l[u]==="_"?l[++u].toUpperCase():l[u];return n},Gl=(l)=>{let n=l[0].toUpperCase();for(let u=1;u<l.length;u++)n+=l[u]==="_"?l[++u].toUpperCase():l[u];return n},jl=(l)=>l.replace(/_/g,"-"),Fl=(l)=>l.replace(/([A-Z])/g,"_$1").toLowerCase(),Hl=(l)=>(l.slice(0,1)+l.slice(1).replace(/([A-Z])/g,"_$1")).toLowerCase(),zl=(l)=>l.replace(/-/g,"_");function Oh(l){return function n(u,c){return typeof u==="object"&&u!==null&&(c.type===114||c.type===3802)?Array.isArray(u)?u.map((w)=>n(w,c)):Object.entries(u).reduce((w,[E,t])=>Object.assign(w,{[l(E)]:n(t,c)}),{}):u}}Sl.column={from:Sl};Sl.value={from:Oh(Sl)};Fl.column={to:Fl};var Eh={...Sl};Eh.column.to=Fl;Gl.column={from:Gl};Gl.value={from:Oh(Gl)};Hl.column={to:Hl};var Ah={...Gl};Ah.column.to=Hl;jl.column={from:jl};jl.value={from:Oh(jl)};zl.column={to:zl};var Uh={...jl};Uh.column.to=zl;import vh from"net";import qn from"tls";import Jl from"crypto";import $h from"stream";import{performance as mh}from"perf_hooks";class Ml extends Array{constructor(){super();Object.defineProperties(this,{count:{value:null,writable:!0},state:{value:null,writable:!0},command:{value:null,writable:!0},columns:{value:null,writable:!0},statement:{value:null,writable:!0}})}static get[Symbol.species](){return Array}}var hl=yn;function yn(l=[]){let n=l.slice(),u=0;return{get length(){return n.length-u},remove:(c)=>{let w=n.indexOf(c);return w===-1?null:(n.splice(w,1),c)},push:(c)=>(n.push(c),c),shift:()=>{let c=n[u++];if(u===n.length)u=0,n=[];else n[u-1]=void 0;return c}}}var p=Buffer.allocUnsafe(256),rn="BCcDdEFfHPpQSX".split("").reduce((l,n)=>{let u=n.charCodeAt(0);return l[n]=()=>{return p[0]=u,R.i=5,R},l},{}),R=Object.assign(sn,rn,{N:String.fromCharCode(0),i:0,inc(l){return R.i+=l,R},str(l){let n=Buffer.byteLength(l);return kl(n),R.i+=p.write(l,R.i,n,"utf8"),R},i16(l){return kl(2),p.writeUInt16BE(l,R.i),R.i+=2,R},i32(l,n){if(n||n===0)return p.writeUInt32BE(l,n),R;return kl(4),p.writeUInt32BE(l,R.i),R.i+=4,R},z(l){return kl(l),p.fill(0,R.i,R.i+l),R.i+=l,R},raw(l){return p=Buffer.concat([p.subarray(0,R.i),l]),R.i=p.length,R},end(l=1){p.writeUInt32BE(R.i-l,l);let n=p.subarray(0,R.i);return R.i=0,p=Buffer.allocUnsafe(256),n}}),$=R;function kl(l){if(p.length-R.i<l){let n=p,u=n.length;p=Buffer.allocUnsafe(u+(u>>1)+l),n.copy(p)}}function sn(){return R.i=0,R}var Bh=eh,xn=1,Bl=$().S().end(),bh=$().H().end(),lu=$().i32(8).i32(80877103).end(8),hu=Buffer.concat([$().E().str($.N).i32(0).end(),Bl]),nu=$().D().str("S").str($.N).end(),Rl=()=>{},uu=new Set(["FetchPreparedStatement","RevalidateCachedQuery","transformAssignedExpr"]),fu={83:"severity_local",86:"severity",67:"code",77:"message",68:"detail",72:"hint",80:"position",112:"internal_position",113:"internal_query",87:"where",115:"schema_name",116:"table_name",99:"column_name",100:"data type_name",110:"constraint_name",70:"file",76:"line",82:"routine"};function eh(l,n={},{onopen:u=Rl,onend:c=Rl,onclose:w=Rl}={}){let{sslnegotiation:E,ssl:t,max:_,user:B,host:Q,port:T,database:Y,parsers:j,transform:M,onnotice:H,onnotify:I,onparameter:b,max_pipeline:Z,keep_alive:cl,backoff:nl,target_session_attrs:x}=l,d=hl(),Ul=xn++,_l={pid:null,secret:null},Pl=gh(xl,l.idle_timeout),Il=gh(xl,l.max_lifetime),L=gh(xh,l.connect_timeout),U=null,Ol,q=null,N=new Ml,y=Buffer.alloc(0),dl=l.fetch_types,El={},O={},S=Math.random().toString(36).slice(2),F=1,v=0,V=0,G=0,D=0,i=0,J=0,m=0,r=null,X=null,Al=!1,tl=null,$l=null,e=null,z=null,C=null,ll=null,Ql=null,sl=null,A=null,Tl=null,k={queue:n.closed,idleTimer:Pl,connect(h){e=h,Lh()},terminate:Zl,execute:Xl,cancel:yh,end:xl,count:0,id:Ul};return n.closed&&n.closed.push(k),k;async function ph(){let h;try{h=l.socket?await Promise.resolve(l.socket(l)):new vh.Socket}catch(f){Nl(f);return}return h.on("error",Nl),h.on("close",Nh),h.on("drain",Ph),h}async function yh({pid:h,secret:f},g,P){try{Ol=$().i32(16).i32(80877102).i32(h).i32(f).end(16),await dh(),U.once("error",P),U.once("close",g)}catch(W){P(W)}}function Xl(h){if(Al)return Cl(h,K.connection("CONNECTION_DESTROYED",l));if(C)return Cl(h,K.generic("COPY_IN_PROGRESS","You cannot execute queries during copy"));if(h.cancelled)return;try{return h.state=_l,A?d.push(h):(A=h,A.active=!0),qh(h),a(rh(h))&&!h.describeFirst&&!h.cursorFn&&d.length<Z&&(!h.options.onexecute||h.options.onexecute(k))}catch(f){return d.length===0&&a(Bl),ul(f),!0}}function rh(h){if(h.parameters.length>=65534)throw K.generic("MAX_PARAMETERS_EXCEEDED","Max number of parameters (65534) exceeded");return h.options.simple?$().Q().str(h.statement.string+$.N).end():h.describeFirst?Buffer.concat([Gh(h),bh]):h.prepare?h.prepared?Vl(h):Buffer.concat([Gh(h),Vl(h)]):sh(h)}function Gh(h){return Buffer.concat([Yh(h.statement.string,h.parameters,h.statement.types,h.statement.name),Vn("S",h.statement.name)])}function Vl(h){return Buffer.concat([Qn(h.parameters,h.statement.types,h.statement.name,h.cursorName),h.cursorFn?Rh("",h.cursorRows):hu])}function sh(h){return Buffer.concat([Yh(h.statement.string,h.parameters,h.statement.types),nu,Vl(h)])}function qh(h){let f=[],g=[],P=th(h,h.strings[0],h.args[0],f,g,l);!h.tagged&&h.args.forEach((W)=>al(W,f,g,l)),h.prepare=l.prepare&&("prepare"in h.options?h.options.prepare:!0),h.string=P,h.signature=h.prepare&&g+P,h.onlyDescribe&&delete O[h.signature],h.parameters=h.parameters||f,h.prepared=h.prepare&&h.signature in O,h.describeFirst=h.onlyDescribe||f.length&&!h.prepared,h.statement=h.prepared?O[h.signature]:{string:P,types:g,name:h.prepare?S+F++:""},typeof l.debug==="function"&&l.debug(Ul,P,f,g)}function a(h,f){if(ll=ll?Buffer.concat([ll,h]):Buffer.from(h),f||ll.length>=1024)return jh(f);return X===null&&(X=setImmediate(jh)),!0}function jh(h){let f=U.write(ll,h);return X!==null&&clearImmediate(X),ll=X=null,f}function xh(){ul(K.connection("CONNECT_TIMEOUT",l,U)),U.destroy()}async function Mh(){if(E!=="direct"){if(a(lu),!await new Promise((g)=>U.once("data",(P)=>g(P[0]===83)))&&t==="prefer")return Ll()}let h={socket:U,servername:vh.isIP(U.host)?void 0:U.host};if(E==="direct")h.ALPNProtocols=["postgresql"];if(t==="require"||t==="allow"||t==="prefer")h.rejectUnauthorized=!1;else if(typeof t==="object")Object.assign(h,t);U.removeAllListeners(),U=qn.connect(h),U.on("secureConnect",Ll),U.on("error",Nl),U.on("close",Nh),U.on("drain",Ph)}function Ph(){!A&&u(k)}function ql(h){if(tl){if(tl.push(h),V-=h.length,V>0)return}y=tl?Buffer.concat(tl,i-V):y.length===0?h:Buffer.concat([y,h],y.length+h.length);while(y.length>4){if(i=y.readUInt32BE(1),i>=y.length){V=i-y.length,tl=[y];break}try{ln(y.subarray(0,i+1))}catch(f){A&&(A.cursorFn||A.describeFirst)&&a(Bl),ul(f)}y=y.subarray(i+1),V=0,tl=null}}async function dh(){if(Al=!1,El={},U||(U=await ph()),!U)return;if(L.start(),l.socket)return t?Mh():Ll();if(U.on("connect",t?Mh:Ll),l.path)return U.connect(l.path);U.ssl=t,U.connect(T[G],Q[G]),U.host=Q[G],U.port=T[G],G=(G+1)%T.length}function Lh(){setTimeout(dh,v?Math.max(0,v+J-mh.now()):0)}function Ll(){try{O={},dl=l.fetch_types,S=Math.random().toString(36).slice(2),F=1,Il.start(),U.on("data",ql),cl&&U.setKeepAlive&&U.setKeepAlive(!0,1000*cl);let h=Kn();a(h)}catch(h){Nl(h)}}function Nl(h){if(k.queue===n.connecting&&l.host[D+1])return;ul(h);while(d.length)Cl(d.shift(),h)}function ul(h){C&&(C.destroy(h),C=null),A&&Cl(A,h),e&&(Cl(e,h),e=null)}function Cl(h,f){if(h.reserve)return h.reject(f);if(!f||typeof f!=="object")f=Error(f);"query"in f||"parameters"in f||Object.defineProperties(f,{stack:{value:f.stack+h.origin.replace(/.*\n/,`
 `),enumerable:l.debug},query:{value:h.string,enumerable:l.debug},parameters:{value:h.parameters,enumerable:l.debug},args:{value:h.args,enumerable:l.debug},types:{value:h.statement&&h.statement.types,enumerable:l.debug}}),h.reject(f)}function xl(){return z||(!k.reserved&&c(k),!k.reserved&&!e&&!A&&d.length===0?(Zl(),new Promise((h)=>U&&U.readyState!=="closed"?U.once("close",h):h())):z=new Promise((h)=>Ql=h))}function Zl(){if(Al=!0,C||A||e||d.length)Nl(K.connection("CONNECTION_DESTROYED",l));if(clearImmediate(X),U)U.removeListener("data",ql),U.removeListener("connect",Ll),U.readyState==="open"&&U.end($().X().end());Ql&&(Ql(),z=Ql=null)}async function Nh(h){if(y=Buffer.alloc(0),V=0,tl=null,clearImmediate(X),U.removeListener("data",ql),U.removeListener("connect",Ll),Pl.cancel(),Il.cancel(),L.cancel(),U.removeAllListeners(),U=null,e)return Lh();!h&&(A||d.length)&&Nl(K.connection("CONNECTION_CLOSED",l,U)),v=mh.now(),h&&l.shared.retries++,J=(typeof nl==="function"?nl(l.shared.retries):nl)*1000,w(k,K.connection("CONNECTION_CLOSED",l,U))}function ln(h,f=h[0]){(f===68?hn:f===100?Tn:f===65?dn:f===83?nn:f===90?un:f===67?fn:f===50?Dh:f===49?cn:f===116?tn:f===84?wn:f===82?_n:f===110?gn:f===75?Bn:f===69?Mn:f===115?Ln:f===51?Nn:f===71?Dn:f===78?Cn:f===72?Yn:f===99?Xn:f===73?Zn:f===86?Fn:f===118?Hn:f===87?Rn:zn)(h)}function hn(h){let f=7,g,P,W,o=A.isRaw?Array(A.statement.columns.length):{};for(let s=0;s<A.statement.columns.length;s++)P=A.statement.columns[s],g=h.readInt32BE(f),f+=4,W=g===-1?null:A.isRaw===!0?h.subarray(f,f+=g):P.parser===void 0?h.toString("utf8",f,f+=g):P.parser.array===!0?P.parser(h.toString("utf8",f+1,f+=g)):P.parser(h.toString("utf8",f,f+=g)),A.isRaw?o[s]=A.isRaw===!0?W:M.value.from?M.value.from(W,P):W:o[P.name]=M.value.from?M.value.from(W,P):W;A.forEachFn?A.forEachFn(M.row.from?M.row.from(o):o,N):N[m++]=M.row.from?M.row.from(o):o}function nn(h){let[f,g]=h.toString("utf8",5,h.length-1).split($.N);if(El[f]=g,l.parameters[f]!==g)l.parameters[f]=g,b&&b(f,g)}function un(h){if(A)if(q)A.retried?ul(A.retried):A.prepared&&uu.has(q.routine)?Pn(A,q):ul(q);else A.resolve($l||N);else if(q)ul(q);if(A=$l=q=null,N=new Ml,L.cancel(),e){if(x){if(!El.in_hot_standby||!El.default_transaction_read_only)return jn();else if(Gn(x,El))return Zl()}if(dl)return e.reserve&&(e=null),In();e&&!e.reserve&&Xl(e),l.shared.retries=D=0,e=null;return}while(d.length&&(A=d.shift())&&(A.active=!0,A.cancelled))eh(l).cancel(A.state,A.cancelled.resolve,A.cancelled.reject);if(A)return;k.reserved?!k.reserved.release&&h[5]===73?z?Zl():(k.reserved=null,u(k)):k.reserved():z?Zl():u(k)}function fn(h){m=0;for(let f=h.length-1;f>0;f--){if(h[f]===32&&h[f+1]<58&&N.count===null)N.count=+h.toString("utf8",f+1,h.length-1);if(h[f-1]>=65){N.command=h.toString("utf8",5,f),N.state=_l;break}}if(Tl&&(Tl(),Tl=null),N.command==="BEGIN"&&_!==1&&!k.reserved)return ul(K.generic("UNSAFE_TRANSACTION","Only use sql.begin, sql.reserved or max: 1"));if(A.options.simple)return Dh();if(A.cursorFn)N.count&&A.cursorFn(N),a(Bl)}function cn(){A.parsing=!1}function Dh(){!N.statement&&(N.statement=A.statement),N.columns=A.statement.columns}function tn(h){let f=h.readUInt16BE(5);for(let g=0;g<f;++g)!A.statement.types[g]&&(A.statement.types[g]=h.readUInt32BE(7+g*4));A.prepare&&(O[A.signature]=A.statement),A.describeFirst&&!A.onlyDescribe&&(a(Vl(A)),A.describeFirst=!1)}function wn(h){if(N.command)$l=$l||[N],$l.push(N=new Ml),N.count=null,A.statement.columns=null;let f=h.readUInt16BE(5),g=7,P;A.statement.columns=Array(f);for(let W=0;W<f;++W){P=g;while(h[g++]!==0);let o=h.readUInt32BE(g),s=h.readUInt16BE(g+4),gl=h.readUInt32BE(g+6);A.statement.columns[W]={name:M.column.from?M.column.from(h.toString("utf8",P,g-1)):h.toString("utf8",P,g-1),parser:j[gl],table:o,number:s,type:gl},g+=18}if(N.statement=A.statement,A.onlyDescribe)return A.resolve(A.statement),a(Bl)}async function _n(h,f=h.readUInt32BE(5)){(f===3?On:f===5?En:f===10?An:f===11?Un:f===12?$n:f!==0?Jn:Rl)(h,f)}async function On(){let h=await lh();a($().p().str(h).z(1).end())}async function En(h){let f="md5"+await ah(Buffer.concat([Buffer.from(await ah(await lh()+B)),h.subarray(9)]));a($().p().str(f).z(1).end())}async function An(){sl=(await Jl.randomBytes(18)).toString("base64"),$().p().str("SCRAM-SHA-256"+$.N);let h=$.i;a($.inc(4).str("n,,n=*,r="+sl).i32($.i-h-4,h).end())}async function Un(h){let f=h.toString("utf8",9).split(",").reduce((s,gl)=>(s[gl[0]]=gl.slice(2),s),{}),g=await Jl.pbkdf2Sync(await lh(),Buffer.from(f.s,"base64"),parseInt(f.i),32,"sha256"),P=await pl(g,"Client Key"),W="n=*,r="+sl+",r="+f.r+",s="+f.s+",i="+f.i+",c=biws,r="+f.r;r=(await pl(await pl(g,"Server Key"),W)).toString("base64");let o="c=biws,r="+f.r+",p="+tu(P,Buffer.from(await pl(await cu(P),W))).toString("base64");a($().p().str(o).end())}function $n(h){if(h.toString("utf8",9).split($.N,1)[0].slice(2)===r)return;ul(K.generic("SASL_SIGNATURE_MISMATCH","The server did not return the correct signature")),U.destroy()}function lh(){return Promise.resolve(typeof l.pass==="function"?l.pass():l.pass)}function gn(){if(N.statement=A.statement,N.statement.columns=[],A.onlyDescribe)return A.resolve(A.statement),a(Bl)}function Bn(h){_l.pid=h.readUInt32BE(5),_l.secret=h.readUInt32BE(9)}async function In(){dl=!1,(await new fl([`
       select b.oid, b.typarray
       from pg_catalog.pg_type a

package/dist/{chunk-mz73066c.js → chunk-gqgpwb88.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 Ok,f as Pk,W as Qk,E as Rk,q as Sk,N as Tk,D as Uk};
+export{R as Pk,f as Qk,W as Rk,E as Sk,q as Tk,N as Uk,D as Vk};
 
-//# debugId=9B4D463832C4363D64756E2164756E21
+//# debugId=7D71BD2DE4A855D264756E2164756E21

package/dist/{chunk-mz73066c.js.map → chunk-gqgpwb88.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": "9B4D463832C4363D64756E2164756E21",
+  "debugId": "7D71BD2DE4A855D264756E2164756E21",
   "names": []
 }

package/dist/{chunk-h0xye69a.js → chunk-ha15x5ns.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 Gk,C as Hk};
+export{A as Hk,C as Ik};
 
-//# debugId=68365DAC9634B5D764756E2164756E21
+//# debugId=C5D397B88DC2651664756E2164756E21

package/dist/{chunk-h0xye69a.js.map → chunk-ha15x5ns.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": "68365DAC9634B5D764756E2164756E21",
+  "debugId": "C5D397B88DC2651664756E2164756E21",
   "names": []
 }