gemi 0.108.0 → 0.110.0

package/dist/{chunk-rn2kgbg4.js.map → chunk-xk930yaw.js.map}

@@ -18,7 +18,7 @@
     "import { loadConfig } from \"@smithy/node-config-provider\";\nimport { CredentialsProviderError } from \"@smithy/property-provider\";\nimport { InstanceMetadataV1FallbackError } from \"./error/InstanceMetadataV1FallbackError\";\nimport { httpRequest } from \"./remoteProvider/httpRequest\";\nimport { fromImdsCredentials, isImdsCredentials } from \"./remoteProvider/ImdsCredentials\";\nimport { providerConfigFromInit } from \"./remoteProvider/RemoteProviderInit\";\nimport { retry } from \"./remoteProvider/retry\";\nimport { getInstanceMetadataEndpoint } from \"./utils/getInstanceMetadataEndpoint\";\nimport { staticStabilityProvider } from \"./utils/staticStabilityProvider\";\nconst IMDS_PATH = \"/latest/meta-data/iam/security-credentials/\";\nconst IMDS_TOKEN_PATH = \"/latest/api/token\";\nconst AWS_EC2_METADATA_V1_DISABLED = \"AWS_EC2_METADATA_V1_DISABLED\";\nconst PROFILE_AWS_EC2_METADATA_V1_DISABLED = \"ec2_metadata_v1_disabled\";\nconst X_AWS_EC2_METADATA_TOKEN = \"x-aws-ec2-metadata-token\";\nexport const fromInstanceMetadata = (init = {}) => staticStabilityProvider(getInstanceMetadataProvider(init), { logger: init.logger });\nconst getInstanceMetadataProvider = (init = {}) => {\n    let disableFetchToken = false;\n    const { logger, profile } = init;\n    const { timeout, maxRetries } = providerConfigFromInit(init);\n    const getCredentials = async (maxRetries, options) => {\n        const isImdsV1Fallback = disableFetchToken || options.headers?.[X_AWS_EC2_METADATA_TOKEN] == null;\n        if (isImdsV1Fallback) {\n            let fallbackBlockedFromProfile = false;\n            let fallbackBlockedFromProcessEnv = false;\n            const configValue = await loadConfig({\n                environmentVariableSelector: (env) => {\n                    const envValue = env[AWS_EC2_METADATA_V1_DISABLED];\n                    fallbackBlockedFromProcessEnv = !!envValue && envValue !== \"false\";\n                    if (envValue === undefined) {\n                        throw new CredentialsProviderError(`${AWS_EC2_METADATA_V1_DISABLED} not set in env, checking config file next.`, { logger: init.logger });\n                    }\n                    return fallbackBlockedFromProcessEnv;\n                },\n                configFileSelector: (profile) => {\n                    const profileValue = profile[PROFILE_AWS_EC2_METADATA_V1_DISABLED];\n                    fallbackBlockedFromProfile = !!profileValue && profileValue !== \"false\";\n                    return fallbackBlockedFromProfile;\n                },\n                default: false,\n            }, {\n                profile,\n            })();\n            if (init.ec2MetadataV1Disabled || configValue) {\n                const causes = [];\n                if (init.ec2MetadataV1Disabled)\n                    causes.push(\"credential provider initialization (runtime option ec2MetadataV1Disabled)\");\n                if (fallbackBlockedFromProfile)\n                    causes.push(`config file profile (${PROFILE_AWS_EC2_METADATA_V1_DISABLED})`);\n                if (fallbackBlockedFromProcessEnv)\n                    causes.push(`process environment variable (${AWS_EC2_METADATA_V1_DISABLED})`);\n                throw new InstanceMetadataV1FallbackError(`AWS EC2 Metadata v1 fallback has been blocked by AWS SDK configuration in the following: [${causes.join(\", \")}].`);\n            }\n        }\n        const imdsProfile = (await retry(async () => {\n            let profile;\n            try {\n                profile = await getProfile(options);\n            }\n            catch (err) {\n                if (err.statusCode === 401) {\n                    disableFetchToken = false;\n                }\n                throw err;\n            }\n            return profile;\n        }, maxRetries)).trim();\n        return retry(async () => {\n            let creds;\n            try {\n                creds = await getCredentialsFromProfile(imdsProfile, options, init);\n            }\n            catch (err) {\n                if (err.statusCode === 401) {\n                    disableFetchToken = false;\n                }\n                throw err;\n            }\n            return creds;\n        }, maxRetries);\n    };\n    return async () => {\n        const endpoint = await getInstanceMetadataEndpoint();\n        if (disableFetchToken) {\n            logger?.debug(\"AWS SDK Instance Metadata\", \"using v1 fallback (no token fetch)\");\n            return getCredentials(maxRetries, { ...endpoint, timeout });\n        }\n        else {\n            let token;\n            try {\n                token = (await getMetadataToken({ ...endpoint, timeout })).toString();\n            }\n            catch (error) {\n                if (error?.statusCode === 400) {\n                    throw Object.assign(error, {\n                        message: \"EC2 Metadata token request returned error\",\n                    });\n                }\n                else if (error.message === \"TimeoutError\" || [403, 404, 405].includes(error.statusCode)) {\n                    disableFetchToken = true;\n                }\n                logger?.debug(\"AWS SDK Instance Metadata\", \"using v1 fallback (initial)\");\n                return getCredentials(maxRetries, { ...endpoint, timeout });\n            }\n            return getCredentials(maxRetries, {\n                ...endpoint,\n                headers: {\n                    [X_AWS_EC2_METADATA_TOKEN]: token,\n                },\n                timeout,\n            });\n        }\n    };\n};\nconst getMetadataToken = async (options) => httpRequest({\n    ...options,\n    path: IMDS_TOKEN_PATH,\n    method: \"PUT\",\n    headers: {\n        \"x-aws-ec2-metadata-token-ttl-seconds\": \"21600\",\n    },\n});\nconst getProfile = async (options) => (await httpRequest({ ...options, path: IMDS_PATH })).toString();\nconst getCredentialsFromProfile = async (profile, options, init) => {\n    const credentialsResponse = JSON.parse((await httpRequest({\n        ...options,\n        path: IMDS_PATH + profile,\n    })).toString());\n    if (!isImdsCredentials(credentialsResponse)) {\n        throw new CredentialsProviderError(\"Invalid response received from instance metadata service.\", {\n            logger: init.logger,\n        });\n    }\n    return fromImdsCredentials(credentialsResponse);\n};\n",
     "export * from \"./fromContainerMetadata\";\nexport * from \"./fromInstanceMetadata\";\nexport * from \"./remoteProvider/RemoteProviderInit\";\nexport * from \"./types\";\nexport { httpRequest } from \"./remoteProvider/httpRequest\";\nexport { getInstanceMetadataEndpoint } from \"./utils/getInstanceMetadataEndpoint\";\nexport { Endpoint } from \"./config/Endpoint\";\n"
   ],
-  "mappings": "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",
-  "debugId": "34C732466FB1912364756E2164756E21",
+  "mappings": ";iQACA,WAAS,UACT,YAAS,QACF,GAAS,CAAW,CAAC,EAAS,CACjC,OAAO,IAAI,QAAQ,CAAC,EAAS,IAAW,CACpC,IAAM,EAAM,GAAQ,CAChB,OAAQ,SACL,EACH,SAAU,EAAQ,UAAU,QAAQ,aAAc,IAAI,CAC1D,CAAC,EACD,EAAI,GAAG,QAAS,CAAC,IAAQ,CACrB,EAAO,OAAO,OAAO,IAAI,gBAAc,gDAAgD,EAAG,CAAG,CAAC,EAC9F,EAAI,QAAQ,EACf,EACD,EAAI,GAAG,UAAW,IAAM,CACpB,EAAO,IAAI,gBAAc,6CAA6C,CAAC,EACvE,EAAI,QAAQ,EACf,EACD,EAAI,GAAG,WAAY,CAAC,IAAQ,CACxB,IAAQ,aAAa,KAAQ,EAC7B,GAAI,EAAa,KAAO,KAAO,EAC3B,EAAO,OAAO,OAAO,IAAI,gBAAc,wDAAwD,EAAG,CAAE,YAAW,CAAC,CAAC,EACjH,EAAI,QAAQ,EAEhB,IAAM,EAAS,CAAC,EAChB,EAAI,GAAG,OAAQ,CAAC,IAAU,CACtB,EAAO,KAAK,CAAK,EACpB,EACD,EAAI,GAAG,MAAO,IAAM,CAChB,EAAQ,GAAO,OAAO,CAAM,CAAC,EAC7B,EAAI,QAAQ,EACf,EACJ,EACD,EAAI,IAAI,EACX,MAlCL,gCCAa,EAAoB,CAAC,IAAQ,QAAQ,CAAG,GACjD,OAAO,IAAQ,UACf,OAAO,EAAI,cAAgB,UAC3B,OAAO,EAAI,kBAAoB,UAC/B,OAAO,EAAI,QAAU,UACrB,OAAO,EAAI,aAAe,SACjB,EAAsB,CAAC,KAAW,CAC3C,YAAa,EAAM,YACnB,gBAAiB,EAAM,gBACvB,aAAc,EAAM,MACpB,WAAY,IAAI,KAAK,EAAM,UAAU,KACjC,EAAM,WAAa,CAAE,UAAW,EAAM,SAAU,CACxD,oBCZa,GAAkB,KAClB,GAAsB,EACtB,EAAyB,EAAG,aADN,EACwC,UAF5C,SAE8E,CAAE,aAAY,SAAQ,oBCFtH,EAAQ,CAAC,EAAS,IAAe,CAC1C,IAAI,EAAU,EAAQ,EACtB,QAAS,EAAI,EAAG,EAAI,EAAY,IAC5B,EAAU,EAAQ,MAAM,CAAO,EAEnC,OAAO,gBCJX,gBAAS,iBADT,EAMa,EAAoB,qCACpB,EAAwB,yCACxB,EAAsB,oCACtB,GAAwB,CAAC,EAAO,CAAC,IAAM,CAChD,IAAQ,UAAS,cAAe,EAAuB,CAAI,EAC3D,MAAO,IAAM,EAAM,SAAY,CAC3B,IAAM,EAAiB,MAAM,GAAW,CAAE,OAAQ,EAAK,MAAO,CAAC,EACzD,EAAgB,KAAK,MAAM,MAAM,GAAmB,EAAS,CAAc,CAAC,EAClF,GAAI,CAAC,EAAkB,CAAa,EAChC,MAAM,IAAI,2BAAyB,4DAA6D,CAC5F,OAAQ,EAAK,MACjB,CAAC,EAEL,OAAO,EAAoB,CAAa,GACzC,CAAU,GAEX,GAAqB,MAAO,EAAS,IAAY,CACnD,GAAI,QAAQ,IAAI,GACZ,EAAQ,QAAU,IACX,EAAQ,QACX,cAAe,QAAQ,IAAI,EAC/B,EAMJ,OAJe,MAAM,EAAY,IAC1B,EACH,SACJ,CAAC,GACa,SAAS,GAErB,GAAU,gBACV,GAIA,GAIA,GAAa,OAAS,YAAa,CACrC,GAAI,QAAQ,IAAI,GACZ,MAAO,CACH,SAAU,GACV,KAAM,QAAQ,IAAI,EACtB,EAEJ,GAAI,QAAQ,IAAI,GAAoB,CAChC,IAAM,EAAS,GAAM,QAAQ,IAAI,EAAkB,EACnD,GAAI,CAAC,EAAO,UAAY,EAAE,EAAO,YAAY,IACzC,MAAM,IAAI,2BAAyB,GAAG,EAAO,8DAA+D,CACxG,YAAa,GACb,QACJ,CAAC,EAEL,GAAI,CAAC,EAAO,UAAY,EAAE,EAAO,YAAY,IACzC,MAAM,IAAI,2BAAyB,GAAG,EAAO,8DAA+D,CACxG,YAAa,GACb,QACJ,CAAC,EAEL,MAAO,IACA,EACH,KAAM,EAAO,KAAO,SAAS,EAAO,KAAM,EAAE,EAAI,MACpD,EAEJ,MAAM,IAAI,2BAAyB,wEACvB,QAA4B,gCAChB,CACpB,YAAa,GACb,QACJ,CAAC,gBAzEL,IACA,IACA,IACA,IALA,WAoCM,GAAmB,CACrB,UAAW,GACX,YAAa,EACjB,EACM,GAAuB,CACzB,QAAS,GACT,SAAU,EACd,QC3CA,EACa,eADb,WACa,EAAN,MAAM,UAAwC,0BAAyB,CAC1E,YACA,KAAO,kCACP,WAAW,CAAC,EAAS,EAAc,GAAM,CACrC,MAAM,EAAS,CAAW,EAC1B,KAAK,YAAc,EACnB,OAAO,eAAe,KAAM,EAAgC,SAAS,EAE7E,QCTW,gBACV,QAAS,CAAC,EAAU,CACjB,EAAS,KAAU,yBACnB,EAAS,KAAU,2BACpB,IAAa,EAAW,CAAC,EAAE,QCFjB,iBAA0B,CACnC,4BAA6B,CAAC,IAAQ,EAHT,kCAI7B,mBAAoB,CAAC,IAAY,EAHD,8BAIhC,QAAS,MACb,QCNW,gBACV,QAAS,CAAC,EAAc,CACrB,EAAa,KAAU,OACvB,EAAa,KAAU,SACxB,IAAiB,EAAe,CAAC,EAAE,QCHzB,GAAyB,yCACzB,GAA4B,qCAC5B,eAHb,IAGa,EAA+B,CACxC,4BAA6B,CAAC,IAAQ,EAAI,IAC1C,mBAAoB,CAAC,IAAY,EAAQ,IACzC,QAAS,EAAa,IAC1B,QCPA,EACA,EAKa,EAA8B,SAAY,WAAU,MAAM,GAAsB,GAAO,MAAM,GAA0B,CAAE,EAChI,GAAwB,SAAY,aAAW,CAAuB,EAAE,EACxE,GAA4B,SAAY,CAC1C,IAAM,EAAe,MAAM,aAAW,CAA4B,EAAE,EACpE,OAAQ,QACC,EAAa,KACd,OAAO,EAAyB,UAC/B,EAAa,KACd,OAAO,EAAyB,aAEhC,MAAU,MAAM,8BAA8B,kBAAkC,OAAO,OAAO,CAAY,GAAG,iBAdzH,IACA,IACA,IACA,IALA,WACA,kBCEa,EAAyC,CAAC,EAAa,IAAW,CAC3E,IAAM,EAJwC,IAK1C,KAAK,MAAM,KAAK,OAAO,EAJiC,GAI0B,EAChF,EAAgB,IAAI,KAAK,KAAK,IAAI,EAAI,EAAkB,IAAI,EAClE,EAAO,KAAK,qJAC+B,IAAI,KAAK,CAAa;AAAA,oHACrC,EAC5B,IAAM,EAAqB,EAAY,oBAAsB,EAAY,WACzE,MAAO,IACA,KACC,EAAqB,CAAE,oBAAmB,EAAI,CAAC,EACnD,WAAY,CAChB,oBCdS,EAA0B,CAAC,EAAU,EAAU,CAAC,IAAM,CAC/D,IAAM,EAAS,GAAS,QAAU,QAC9B,EACJ,MAAO,UAAY,CACf,IAAI,EACJ,GAAI,CAEA,GADA,EAAc,MAAM,EAAS,EACzB,EAAY,YAAc,EAAY,WAAW,QAAQ,EAAI,KAAK,IAAI,EACtE,EAAc,EAAuC,EAAa,CAAM,EAGhF,MAAO,EAAG,CACN,GAAI,EACA,EAAO,KAAK,4BAA6B,CAAC,EAC1C,EAAc,EAAuC,EAAiB,CAAM,EAG5E,WAAM,EAId,OADA,EAAkB,EACX,iBAtBf,UCAA,GACA,EAQM,GAAY,8CACZ,GAAkB,oBAClB,EAA+B,+BAC/B,GAAuC,2BACvC,GAA2B,2BACpB,GAAuB,CAAC,EAAO,CAAC,IAAM,EAAwB,GAA4B,CAAI,EAAG,CAAE,OAAQ,EAAK,MAAO,CAAC,EAC/H,GAA8B,CAAC,EAAO,CAAC,IAAM,CAC/C,IAAI,EAAoB,IAChB,SAAQ,WAAY,GACpB,UAAS,cAAe,EAAuB,CAAI,EACrD,EAAiB,MAAO,EAAY,IAAY,CAElD,GADyB,GAAqB,EAAQ,UAAU,KAA6B,KACvE,CAClB,IAAI,EAA6B,GAC7B,EAAgC,GAC9B,GAAc,MAAM,cAAW,CACjC,4BAA6B,CAAC,IAAQ,CAClC,IAAM,EAAW,EAAI,GAErB,GADA,EAAgC,CAAC,CAAC,GAAY,IAAa,QACvD,IAAa,OACb,MAAM,IAAI,2BAAyB,GAAG,+CAA2E,CAAE,OAAQ,EAAK,MAAO,CAAC,EAE5I,OAAO,GAEX,mBAAoB,CAAC,IAAY,CAC7B,IAAM,EAAe,EAAQ,IAE7B,OADA,EAA6B,CAAC,CAAC,GAAgB,IAAiB,QACzD,GAEX,QAAS,EACb,EAAG,CACC,SACJ,CAAC,EAAE,EACH,GAAI,EAAK,uBAAyB,GAAa,CAC3C,IAAM,EAAS,CAAC,EAChB,GAAI,EAAK,sBACL,EAAO,KAAK,2EAA2E,EAC3F,GAAI,EACA,EAAO,KAAK,wBAAwB,KAAuC,EAC/E,GAAI,EACA,EAAO,KAAK,iCAAiC,IAA+B,EAChF,MAAM,IAAI,EAAgC,6FAA6F,EAAO,KAAK,IAAI,KAAK,GAGpK,IAAM,IAAe,MAAM,EAAM,SAAY,CACzC,IAAI,EACJ,GAAI,CACA,EAAU,MAAM,GAAW,CAAO,EAEtC,MAAO,EAAK,CACR,GAAI,EAAI,aAAe,IACnB,EAAoB,GAExB,MAAM,EAEV,OAAO,GACR,CAAU,GAAG,KAAK,EACrB,OAAO,EAAM,SAAY,CACrB,IAAI,EACJ,GAAI,CACA,EAAQ,MAAM,GAA0B,GAAa,EAAS,CAAI,EAEtE,MAAO,EAAK,CACR,GAAI,EAAI,aAAe,IACnB,EAAoB,GAExB,MAAM,EAEV,OAAO,GACR,CAAU,GAEjB,MAAO,UAAY,CACf,IAAM,EAAW,MAAM,EAA4B,EACnD,GAAI,EAEA,OADA,GAAQ,MAAM,4BAA6B,oCAAoC,EACxE,EAAe,EAAY,IAAK,EAAU,SAAQ,CAAC,EAEzD,KACD,IAAI,EACJ,GAAI,CACA,GAAS,MAAM,GAAiB,IAAK,EAAU,SAAQ,CAAC,GAAG,SAAS,EAExE,MAAO,EAAO,CACV,GAAI,GAAO,aAAe,IACtB,MAAM,OAAO,OAAO,EAAO,CACvB,QAAS,2CACb,CAAC,EAEA,QAAI,EAAM,UAAY,gBAAkB,CAAC,IAAK,IAAK,GAAG,EAAE,SAAS,EAAM,UAAU,EAClF,EAAoB,GAGxB,OADA,GAAQ,MAAM,4BAA6B,6BAA6B,EACjE,EAAe,EAAY,IAAK,EAAU,SAAQ,CAAC,EAE9D,OAAO,EAAe,EAAY,IAC3B,EACH,QAAS,EACJ,IAA2B,CAChC,EACA,SACJ,CAAC,KAIP,GAAmB,MAAO,IAAY,EAAY,IACjD,EACH,KAAM,GACN,OAAQ,MACR,QAAS,CACL,uCAAwC,OAC5C,CACJ,CAAC,EACK,GAAa,MAAO,KAAa,MAAM,EAAY,IAAK,EAAS,KAAM,EAAU,CAAC,GAAG,SAAS,EAC9F,GAA4B,MAAO,EAAS,EAAS,IAAS,CAChE,IAAM,EAAsB,KAAK,OAAO,MAAM,EAAY,IACnD,EACH,KAAM,GAAY,CACtB,CAAC,GAAG,SAAS,CAAC,EACd,GAAI,CAAC,EAAkB,CAAmB,EACtC,MAAM,IAAI,2BAAyB,4DAA6D,CAC5F,OAAQ,EAAK,MACjB,CAAC,EAEL,OAAO,EAAoB,CAAmB,iBAlIlD,IACA,IACA,IACA,IACA,IACA,IACA,IARA,YACA,yCCGA,IACA,IACA,IANA,IACA,KACA,IACA",
+  "debugId": "6596F02364A9F98164756E2164756E21",
   "names": []
 }

package/dist/chunk-xkc7ftnq.js

@@ -0,0 +1,9 @@
+// @bun
+import{Cg as X,Jg as K,Mg as W}from"./chunk-s6jjy4y9.js";import{AsyncLocalStorage as S}from"async_hooks";var z=new S;function g(){return z.getStore()?.tx}function U(){return z.getStore()?.connection??K}function O(j,q){let v=z.getStore();if(U()===j)return q();return y(j),z.run({...v,depth:v?.depth??0,connection:j===K?void 0:j},q)}function y(j){let q=z.getStore();if(q?.tx===void 0)return;let v=q.connection??K;if(v===j)return;throw new W(v,j)}function L(j){let q=z.getStore();if(q?.tx===void 0||q.afterCommit===void 0)return!1;return q.afterCommit.push(j),!0}function h(j){if(L(j))return Promise.resolve();let q=(v)=>{console.error("An after-commit callback threw. No transaction was open, so it ran immediately.",v)};try{return Promise.resolve(j()).catch(q)}catch(v){return q(v),Promise.resolve()}}function k(j){let q=z.getStore();if(q?.tx===void 0||q.commitDependsOn===void 0)return!1;return q.commitDependsOn.push(j),!0}class F extends Error{constructor(j){super(`A statement this transaction depended on failed after being issued on it, so the transaction rolled back instead of committing: ${j instanceof Error?j.message:String(j)}`,{cause:j});this.name="TransactionDependencyError"}}async function R(j,q){if(j.length===q)return;let B=(await Promise.allSettled(j.slice(q))).find((G)=>G.status==="rejected");if(B)throw new F(B.reason)}function N(){let j=z.getStore();return j?.tx===void 0?null:j.depth}function T(){return z.getStore()?.system===!0}function x(j){let q=z.getStore();return z.run({...q,depth:q?.depth??0,system:!0},j)}function p(j){return z.getStore()?.trashed?.get(j)}function f(j,q,v){let B=z.getStore(),G=new Map(B?.trashed);return G.set(j,q),z.run({...B,depth:B?.depth??0,trashed:G},v)}function C(){return z.getStore()?.actor}function l(j,q){let v=z.getStore();return z.run({...v,depth:v?.depth??0,system:!1,actor:{user:j??null}},q)}function _(j){if(Bun.env.NODE_ENV!=="development")return null;if(j===!1)return null;if(j===void 0)return X;if(!Number.isFinite(j)||j<=0)return X;return j}function A(j){let q=_(j);if(q===null)return()=>{};let v=Error("transaction opened here"),B=setTimeout(()=>{let G=v.stack?.split(`
+`).slice(1).join(`
+`)??"";console.warn(`[gemi] A database transaction has not settled after ${q}ms. It `+"reserves a pooled connection until it does \u2014 check for network or "+`filesystem I/O inside the callback, and move it outside the transaction if you find any.
+${G}
+(development only; set database.slowTransactionThreshold to change the threshold, or false to switch this off)`)},q);return B.unref?.(),()=>clearTimeout(B)}async function D(j,q){if(j.length===0)return;await z.run({...q,tx:void 0,afterCommit:void 0,commitDependsOn:void 0,depth:q?.depth??0},async()=>{for(let v of j)try{await v()}catch(B){console.error("An after-commit callback threw. The transaction it was waiting on had already committed and stays committed, and the callbacks after it still ran.",B)}})}function u(j,q,v){let B=z.getStore(),G=v?.connection??K;if(y(G),B?.tx){let J=B.afterCommit,Q=J?.length??0,P=B.commitDependsOn,M=P?.length??0;return B.tx.savepoint((V)=>{let H=V;return z.run({...B,tx:H,depth:B.depth+1},async()=>{let I=await q(H);if(P)await R(P,M);return I})}).catch((V)=>{if(J)J.length=Q;if(P)P.length=M;throw V})}let Y=A(v?.slowTransactionThreshold),Z=[],$=[];try{return j.begin((J)=>z.run({...B,tx:J,depth:0,connection:G===K?void 0:G,afterCommit:Z,commitDependsOn:$},async()=>{let Q=await q(J);return await R($,0),Q})).finally(Y).then(async(J)=>{return await D(Z,B),J})}catch(J){throw Y(),J}}
+export{z as jg,g as kg,U as lg,O as mg,y as ng,L as og,h as pg,k as qg,F as rg,N as sg,T as tg,x as ug,p as vg,f as wg,C as xg,l as yg,u as zg};
+
+//# debugId=A2557360C6537E2764756E2164756E21

package/dist/chunk-xkc7ftnq.js.map

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

package/dist/{chunk-564zfdd1.js → chunk-yer1r3t3.js}

@@ -1,5 +1,5 @@
 // @bun
 function M(E,C){let A=[],q=new Set;if(C)q.add(C),A.push(C);for(let G of Object.values(E))for(let j of Object.keys(G))if(!q.has(j))q.add(j),A.push(j);return A}function Q(E,C,A=M(E)){let q={};for(let[G,j]of Object.entries(E)){let H=j?.[C];if(typeof H!=="string")for(let I of A){let J=j?.[I];if(typeof J==="string"){H=J;break}}if(typeof H==="string")q[G]=H}return q}function R(E){let C,A;for(let[q,G]of Object.entries(E)){let j=Object.keys(G??{})[0];if(j===void 0)continue;if(A===void 0){A=j,C=q;continue}if(j!==A)return{key:q,first:j,againstKey:C,againstFirst:A}}return null}function P(E){return`{${Object.keys(E).sort().map((q)=>{let G=E[q]??{},H=Object.keys(G).sort().map((I)=>JSON.stringify([I,G[I]])).join(",");return`${JSON.stringify(q)}:[${H}]`}).join(",")}}`}function S(E){let C=P(E),A=2166136261,q=16777619;for(let j=0;j<C.length;j++){let H=C.charCodeAt(j);A=Math.imul(A^H,16777619),q=Math.imul(q^H,2166136261)}let G=(j)=>(j>>>0).toString(16).padStart(8,"0");return`d_${G(A)}${G(q)}`}
-export{M as sa,Q as ta,R as ua,S as va};
+export{M as ta,Q as ua,R as va,S as wa};
 
-//# debugId=C908C124412DC9B764756E2164756E21
+//# debugId=EE089F42F2A07B6A64756E2164756E21

package/dist/{chunk-564zfdd1.js.map → chunk-yer1r3t3.js.map}

@@ -5,6 +5,6 @@
     "/**\n * The one implementation of \"what is a dictionary literal, and what is its id\",\n * shared by the runtime (`defineDictionary`) and the Vite plugin.\n *\n * Both sides must agree exactly. A dictionary's id is a hash of its own\n * contents rather than of its file path, so a module that is bundled on one\n * side and evaluated raw on the other still lands on the same id — which is\n * what lets the SSR payload seed the client registry.\n */\n\nexport type DictionaryTranslations = Record<string, Record<string, string>>;\n\nexport type LocaleStrings = Record<string, string>;\n\n/**\n * Locales the dictionary declares, source language first.\n *\n * The order is meaningful: the first locale is the source language, and a key\n * missing from some other locale falls back along this list.\n *\n * `sourceLocale` pins that choice. Without it the source language is whichever\n * locale is seen first while walking the literal, which makes it an emergent\n * property of key order — adding a key at the top of a dictionary whose other\n * keys happen to lack `en-US` would silently re-point every fallback in it. Any\n * dictionary that is not uniformly translated should say which locale it is\n * authored in.\n */\nexport function dictionaryLocales(\n  translations: DictionaryTranslations,\n  sourceLocale?: string,\n): string[] {\n  const locales: string[] = [];\n  const seen = new Set<string>();\n  if (sourceLocale) {\n    seen.add(sourceLocale);\n    locales.push(sourceLocale);\n  }\n  for (const byLocale of Object.values(translations)) {\n    for (const locale of Object.keys(byLocale)) {\n      if (!seen.has(locale)) {\n        seen.add(locale);\n        locales.push(locale);\n      }\n    }\n  }\n  return locales;\n}\n\n/**\n * Flatten one locale out of a dictionary.\n *\n * A key with no string for `locale` falls back along the declared locale order\n * rather than vanishing, so a half-translated dictionary degrades one string at\n * a time instead of rendering the whole component as raw keys.\n */\nexport function localeStrings(\n  translations: DictionaryTranslations,\n  locale: string,\n  fallbackOrder: string[] = dictionaryLocales(translations),\n): LocaleStrings {\n  const out: LocaleStrings = {};\n  for (const [key, byLocale] of Object.entries(translations)) {\n    let value = byLocale?.[locale];\n    if (typeof value !== \"string\") {\n      for (const candidate of fallbackOrder) {\n        const fallback = byLocale?.[candidate];\n        if (typeof fallback === \"string\") {\n          value = fallback;\n          break;\n        }\n      }\n    }\n    if (typeof value === \"string\") {\n      out[key] = value;\n    }\n  }\n  return out;\n}\n\nexport interface SourceDisagreement {\n  key: string;\n  first: string;\n  againstKey: string;\n  againstFirst: string;\n}\n\n/**\n * Whether the inferred source language survives reordering the literal.\n *\n * `dictionaryLocales` collects locales entry by entry, so `locales[0]` is the\n * first locale of the first entry. That is invariant under key reordering\n * exactly when every entry lists the same locale first — and order-dependent\n * the moment two entries disagree, because then whichever happens to be written\n * first decides what the *whole* dictionary falls back to. Adding one key at\n * the top can flip every other key's fallback language, from a diff that reads\n * as an addition.\n *\n * Returns the disagreement so the build can name both keys; `null` when the\n * inference is stable. `sourceLocale` settles it and makes the question moot.\n */\nexport function findSourceDisagreement(\n  translations: DictionaryTranslations,\n): SourceDisagreement | null {\n  let againstKey: string | undefined;\n  let againstFirst: string | undefined;\n\n  for (const [key, byLocale] of Object.entries(translations)) {\n    const first = Object.keys(byLocale ?? {})[0];\n    // A key with no locales at all is a different problem, reported elsewhere.\n    if (first === undefined) continue;\n\n    if (againstFirst === undefined) {\n      againstFirst = first;\n      againstKey = key;\n      continue;\n    }\n    if (first !== againstFirst) {\n      return { key, first, againstKey: againstKey!, againstFirst };\n    }\n  }\n  return null;\n}\n\n/**\n * Canonical serialization — key order in the source file must not change the\n * id, or an innocuous reordering would break the payload/registry match.\n */\nexport function canonicalizeDictionary(\n  translations: DictionaryTranslations,\n): string {\n  const keys = Object.keys(translations).sort();\n  const parts = keys.map((key) => {\n    const byLocale = translations[key] ?? {};\n    const locales = Object.keys(byLocale).sort();\n    const inner = locales.map((l) => JSON.stringify([l, byLocale[l]])).join(\",\");\n    return `${JSON.stringify(key)}:[${inner}]`;\n  });\n  return `{${parts.join(\",\")}}`;\n}\n\n/**\n * FNV-1a, run twice with different offsets for a 64-bit-wide id. No crypto\n * import, and it has to work identically in the browser bundle, under Bun on\n * the server, and inside the Vite plugin.\n */\nexport function dictionaryId(translations: DictionaryTranslations): string {\n  const input = canonicalizeDictionary(translations);\n  let a = 0x811c9dc5;\n  let b = 0x01000193;\n  for (let i = 0; i < input.length; i++) {\n    const c = input.charCodeAt(i);\n    a = Math.imul(a ^ c, 0x01000193);\n    b = Math.imul(b ^ c, 0x811c9dc5);\n  }\n  const hex = (n: number) => (n >>> 0).toString(16).padStart(8, \"0\");\n  return `d_${hex(a)}${hex(b)}`;\n}\n"
   ],
   "mappings": ";AA2BO,SAAS,CAAiB,CAC/B,EACA,EACU,CACV,IAAM,EAAoB,CAAC,EACrB,EAAO,IAAI,IACjB,GAAI,EACF,EAAK,IAAI,CAAY,EACrB,EAAQ,KAAK,CAAY,EAE3B,QAAW,KAAY,OAAO,OAAO,CAAY,EAC/C,QAAW,KAAU,OAAO,KAAK,CAAQ,EACvC,GAAI,CAAC,EAAK,IAAI,CAAM,EAClB,EAAK,IAAI,CAAM,EACf,EAAQ,KAAK,CAAM,EAIzB,OAAO,EAUF,SAAS,CAAa,CAC3B,EACA,EACA,EAA0B,EAAkB,CAAY,EACzC,CACf,IAAM,EAAqB,CAAC,EAC5B,QAAY,EAAK,KAAa,OAAO,QAAQ,CAAY,EAAG,CAC1D,IAAI,EAAQ,IAAW,GACvB,GAAI,OAAO,IAAU,SACnB,QAAW,KAAa,EAAe,CACrC,IAAM,EAAW,IAAW,GAC5B,GAAI,OAAO,IAAa,SAAU,CAChC,EAAQ,EACR,OAIN,GAAI,OAAO,IAAU,SACnB,EAAI,GAAO,EAGf,OAAO,EAwBF,SAAS,CAAsB,CACpC,EAC2B,CAC3B,IAAI,EACA,EAEJ,QAAY,EAAK,KAAa,OAAO,QAAQ,CAAY,EAAG,CAC1D,IAAM,EAAQ,OAAO,KAAK,GAAY,CAAC,CAAC,EAAE,GAE1C,GAAI,IAAU,OAAW,SAEzB,GAAI,IAAiB,OAAW,CAC9B,EAAe,EACf,EAAa,EACb,SAEF,GAAI,IAAU,EACZ,MAAO,CAAE,MAAK,QAAO,WAAY,EAAa,cAAa,EAG/D,OAAO,KAOF,SAAS,CAAsB,CACpC,EACQ,CAQR,MAAO,IAPM,OAAO,KAAK,CAAY,EAAE,KAAK,EACzB,IAAI,CAAC,IAAQ,CAC9B,IAAM,EAAW,EAAa,IAAQ,CAAC,EAEjC,EADU,OAAO,KAAK,CAAQ,EAAE,KAAK,EACrB,IAAI,CAAC,IAAM,KAAK,UAAU,CAAC,EAAG,EAAS,EAAE,CAAC,CAAC,EAAE,KAAK,GAAG,EAC3E,MAAO,GAAG,KAAK,UAAU,CAAG,MAAM,KACnC,EACgB,KAAK,GAAG,KAQpB,SAAS,CAAY,CAAC,EAA8C,CACzE,IAAM,EAAQ,EAAuB,CAAY,EAC7C,EAAI,WACJ,EAAI,SACR,QAAS,EAAI,EAAG,EAAI,EAAM,OAAQ,IAAK,CACrC,IAAM,EAAI,EAAM,WAAW,CAAC,EAC5B,EAAI,KAAK,KAAK,EAAI,EAAG,QAAU,EAC/B,EAAI,KAAK,KAAK,EAAI,EAAG,UAAU,EAEjC,IAAM,EAAM,CAAC,KAAe,IAAM,GAAG,SAAS,EAAE,EAAE,SAAS,EAAG,GAAG,EACjE,MAAO,KAAK,EAAI,CAAC,IAAI,EAAI,CAAC",
-  "debugId": "C908C124412DC9B764756E2164756E21",
+  "debugId": "EE089F42F2A07B6A64756E2164756E21",
   "names": []
 }

package/dist/{chunk-v52dyw0q.js → chunk-yqavgpwd.js}

@@ -1,5 +1,5 @@
 // @bun
-import{rh as LC}from"./chunk-3s3awh38.js";var OC=LC((QC,A)=>{var P,h,j,I,b,y,g,k,f,m,u,x,l,D,z,_,d,c,E,v,n,p,i,s,a,o,t,r,w,e,CC,HC;(function(X){var R=typeof global==="object"?global:typeof self==="object"?self:typeof this==="object"?this:{};if(typeof define==="function"&&define.amd)define("tslib",["exports"],function(G){X(q(R,q(G)))});else if(typeof A==="object"&&typeof QC==="object")X(q(R,q(QC)));else X(q(R));function q(G,S){if(G!==R)if(typeof Object.create==="function")Object.defineProperty(G,"__esModule",{value:!0});else G.__esModule=!0;return function(C,H){return G[C]=S?S(C,H):H}}})(function(X){var R=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(C,H){C.__proto__=H}||function(C,H){for(var L in H)if(Object.prototype.hasOwnProperty.call(H,L))C[L]=H[L]};P=function(C,H){if(typeof H!=="function"&&H!==null)throw TypeError("Class extends value "+String(H)+" is not a constructor or null");R(C,H);function L(){this.constructor=C}C.prototype=H===null?Object.create(H):(L.prototype=H.prototype,new L)},h=Object.assign||function(C){for(var H,L=1,O=arguments.length;L<O;L++){H=arguments[L];for(var Q in H)if(Object.prototype.hasOwnProperty.call(H,Q))C[Q]=H[Q]}return C},j=function(C,H){var L={};for(var O in C)if(Object.prototype.hasOwnProperty.call(C,O)&&H.indexOf(O)<0)L[O]=C[O];if(C!=null&&typeof Object.getOwnPropertySymbols==="function"){for(var Q=0,O=Object.getOwnPropertySymbols(C);Q<O.length;Q++)if(H.indexOf(O[Q])<0&&Object.prototype.propertyIsEnumerable.call(C,O[Q]))L[O[Q]]=C[O[Q]]}return L},I=function(C,H,L,O){var Q=arguments.length,T=Q<3?H:O===null?O=Object.getOwnPropertyDescriptor(H,L):O,U;if(typeof Reflect==="object"&&typeof Reflect.decorate==="function")T=Reflect.decorate(C,H,L,O);else for(var Y=C.length-1;Y>=0;Y--)if(U=C[Y])T=(Q<3?U(T):Q>3?U(H,L,T):U(H,L))||T;return Q>3&&T&&Object.defineProperty(H,L,T),T},b=function(C,H){return function(L,O){H(L,O,C)}},y=function(C,H,L,O,Q,T){function U(K){if(K!==void 0&&typeof K!=="function")throw TypeError("Function expected");return K}var Y=O.kind,J=Y==="getter"?"get":Y==="setter"?"set":"value",W=!H&&C?O.static?C:C.prototype:null,$=H||(W?Object.getOwnPropertyDescriptor(W,O.name):{}),M,F=!1;for(var Z=L.length-1;Z>=0;Z--){var N={};for(var B in O)N[B]=B==="access"?{}:O[B];for(var B in O.access)N.access[B]=O.access[B];N.addInitializer=function(K){if(F)throw TypeError("Cannot add initializers after decoration has completed");T.push(U(K||null))};var V=(0,L[Z])(Y==="accessor"?{get:$.get,set:$.set}:$[J],N);if(Y==="accessor"){if(V===void 0)continue;if(V===null||typeof V!=="object")throw TypeError("Object expected");if(M=U(V.get))$.get=M;if(M=U(V.set))$.set=M;if(M=U(V.init))Q.unshift(M)}else if(M=U(V))if(Y==="field")Q.unshift(M);else $[J]=M}if(W)Object.defineProperty(W,O.name,$);F=!0},g=function(C,H,L){var O=arguments.length>2;for(var Q=0;Q<H.length;Q++)L=O?H[Q].call(C,L):H[Q].call(C);return O?L:void 0},k=function(C){return typeof C==="symbol"?C:"".concat(C)},f=function(C,H,L){if(typeof H==="symbol")H=H.description?"[".concat(H.description,"]"):"";return Object.defineProperty(C,"name",{configurable:!0,value:L?"".concat(L," ",H):H})},m=function(C,H){if(typeof Reflect==="object"&&typeof Reflect.metadata==="function")return Reflect.metadata(C,H)},u=function(C,H,L,O){function Q(T){return T instanceof L?T:new L(function(U){U(T)})}return new(L||(L=Promise))(function(T,U){function Y($){try{W(O.next($))}catch(M){U(M)}}function J($){try{W(O.throw($))}catch(M){U(M)}}function W($){$.done?T($.value):Q($.value).then(Y,J)}W((O=O.apply(C,H||[])).next())})},x=function(C,H){var L={label:0,sent:function(){if(T[0]&1)throw T[1];return T[1]},trys:[],ops:[]},O,Q,T,U=Object.create((typeof Iterator==="function"?Iterator:Object).prototype);return U.next=Y(0),U.throw=Y(1),U.return=Y(2),typeof Symbol==="function"&&(U[Symbol.iterator]=function(){return this}),U;function Y(W){return function($){return J([W,$])}}function J(W){if(O)throw TypeError("Generator is already executing.");while(U&&(U=0,W[0]&&(L=0)),L)try{if(O=1,Q&&(T=W[0]&2?Q.return:W[0]?Q.throw||((T=Q.return)&&T.call(Q),0):Q.next)&&!(T=T.call(Q,W[1])).done)return T;if(Q=0,T)W=[W[0]&2,T.value];switch(W[0]){case 0:case 1:T=W;break;case 4:return L.label++,{value:W[1],done:!1};case 5:L.label++,Q=W[1],W=[0];continue;case 7:W=L.ops.pop(),L.trys.pop();continue;default:if((T=L.trys,!(T=T.length>0&&T[T.length-1]))&&(W[0]===6||W[0]===2)){L=0;continue}if(W[0]===3&&(!T||W[1]>T[0]&&W[1]<T[3])){L.label=W[1];break}if(W[0]===6&&L.label<T[1]){L.label=T[1],T=W;break}if(T&&L.label<T[2]){L.label=T[2],L.ops.push(W);break}if(T[2])L.ops.pop();L.trys.pop();continue}W=H.call(C,L)}catch($){W=[6,$],Q=0}finally{O=T=0}if(W[0]&5)throw W[1];return{value:W[0]?W[1]:void 0,done:!0}}},l=function(C,H){for(var L in C)if(L!=="default"&&!Object.prototype.hasOwnProperty.call(H,L))w(H,C,L)},w=Object.create?function(C,H,L,O){if(O===void 0)O=L;var Q=Object.getOwnPropertyDescriptor(H,L);if(!Q||("get"in Q?!H.__esModule:Q.writable||Q.configurable))Q={enumerable:!0,get:function(){return H[L]}};Object.defineProperty(C,O,Q)}:function(C,H,L,O){if(O===void 0)O=L;C[O]=H[L]},D=function(C){var H=typeof Symbol==="function"&&Symbol.iterator,L=H&&C[H],O=0;if(L)return L.call(C);if(C&&typeof C.length==="number")return{next:function(){if(C&&O>=C.length)C=void 0;return{value:C&&C[O++],done:!C}}};throw TypeError(H?"Object is not iterable.":"Symbol.iterator is not defined.")},z=function(C,H){var L=typeof Symbol==="function"&&C[Symbol.iterator];if(!L)return C;var O=L.call(C),Q,T=[],U;try{while((H===void 0||H-- >0)&&!(Q=O.next()).done)T.push(Q.value)}catch(Y){U={error:Y}}finally{try{if(Q&&!Q.done&&(L=O.return))L.call(O)}finally{if(U)throw U.error}}return T},_=function(){for(var C=[],H=0;H<arguments.length;H++)C=C.concat(z(arguments[H]));return C},d=function(){for(var C=0,H=0,L=arguments.length;H<L;H++)C+=arguments[H].length;for(var O=Array(C),Q=0,H=0;H<L;H++)for(var T=arguments[H],U=0,Y=T.length;U<Y;U++,Q++)O[Q]=T[U];return O},c=function(C,H,L){if(L||arguments.length===2){for(var O=0,Q=H.length,T;O<Q;O++)if(T||!(O in H)){if(!T)T=Array.prototype.slice.call(H,0,O);T[O]=H[O]}}return C.concat(T||Array.prototype.slice.call(H))},E=function(C){return this instanceof E?(this.v=C,this):new E(C)},v=function(C,H,L){if(!Symbol.asyncIterator)throw TypeError("Symbol.asyncIterator is not defined.");var O=L.apply(C,H||[]),Q,T=[];return Q=Object.create((typeof AsyncIterator==="function"?AsyncIterator:Object).prototype),Y("next"),Y("throw"),Y("return",U),Q[Symbol.asyncIterator]=function(){return this},Q;function U(Z){return function(N){return Promise.resolve(N).then(Z,M)}}function Y(Z,N){if(O[Z]){if(Q[Z]=function(B){return new Promise(function(V,K){T.push([Z,B,V,K])>1||J(Z,B)})},N)Q[Z]=N(Q[Z])}}function J(Z,N){try{W(O[Z](N))}catch(B){F(T[0][3],B)}}function W(Z){Z.value instanceof E?Promise.resolve(Z.value.v).then($,M):F(T[0][2],Z)}function $(Z){J("next",Z)}function M(Z){J("throw",Z)}function F(Z,N){if(Z(N),T.shift(),T.length)J(T[0][0],T[0][1])}},n=function(C){var H,L;return H={},O("next"),O("throw",function(Q){throw Q}),O("return"),H[Symbol.iterator]=function(){return this},H;function O(Q,T){H[Q]=C[Q]?function(U){return(L=!L)?{value:E(C[Q](U)),done:!1}:T?T(U):U}:T}},p=function(C){if(!Symbol.asyncIterator)throw TypeError("Symbol.asyncIterator is not defined.");var H=C[Symbol.asyncIterator],L;return H?H.call(C):(C=typeof D==="function"?D(C):C[Symbol.iterator](),L={},O("next"),O("throw"),O("return"),L[Symbol.asyncIterator]=function(){return this},L);function O(T){L[T]=C[T]&&function(U){return new Promise(function(Y,J){U=C[T](U),Q(Y,J,U.done,U.value)})}}function Q(T,U,Y,J){Promise.resolve(J).then(function(W){T({value:W,done:Y})},U)}},i=function(C,H){if(Object.defineProperty)Object.defineProperty(C,"raw",{value:H});else C.raw=H;return C};var q=Object.create?function(C,H){Object.defineProperty(C,"default",{enumerable:!0,value:H})}:function(C,H){C.default=H},G=function(C){return G=Object.getOwnPropertyNames||function(H){var L=[];for(var O in H)if(Object.prototype.hasOwnProperty.call(H,O))L[L.length]=O;return L},G(C)};s=function(C){if(C&&C.__esModule)return C;var H={};if(C!=null){for(var L=G(C),O=0;O<L.length;O++)if(L[O]!=="default")w(H,C,L[O])}return q(H,C),H},a=function(C){return C&&C.__esModule?C:{default:C}},o=function(C,H,L,O){if(L==="a"&&!O)throw TypeError("Private accessor was defined without a getter");if(typeof H==="function"?C!==H||!O:!H.has(C))throw TypeError("Cannot read private member from an object whose class did not declare it");return L==="m"?O:L==="a"?O.call(C):O?O.value:H.get(C)},t=function(C,H,L,O,Q){if(O==="m")throw TypeError("Private method is not writable");if(O==="a"&&!Q)throw TypeError("Private accessor was defined without a setter");if(typeof H==="function"?C!==H||!Q:!H.has(C))throw TypeError("Cannot write private member to an object whose class did not declare it");return O==="a"?Q.call(C,L):Q?Q.value=L:H.set(C,L),L},r=function(C,H){if(H===null||typeof H!=="object"&&typeof H!=="function")throw TypeError("Cannot use 'in' operator on non-object");return typeof C==="function"?H===C:C.has(H)},e=function(C,H,L){if(H!==null&&H!==void 0){if(typeof H!=="object"&&typeof H!=="function")throw TypeError("Object expected.");var O,Q;if(L){if(!Symbol.asyncDispose)throw TypeError("Symbol.asyncDispose is not defined.");O=H[Symbol.asyncDispose]}if(O===void 0){if(!Symbol.dispose)throw TypeError("Symbol.dispose is not defined.");if(O=H[Symbol.dispose],L)Q=O}if(typeof O!=="function")throw TypeError("Object not disposable.");if(Q)O=function(){try{Q.call(this)}catch(T){return Promise.reject(T)}};C.stack.push({value:H,dispose:O,async:L})}else if(L)C.stack.push({async:!0});return H};var S=typeof SuppressedError==="function"?SuppressedError:function(C,H,L){var O=Error(L);return O.name="SuppressedError",O.error=C,O.suppressed=H,O};CC=function(C){function H(T){C.error=C.hasError?new S(T,C.error,"An error was suppressed during disposal."):T,C.hasError=!0}var L,O=0;function Q(){while(L=C.stack.pop())try{if(!L.async&&O===1)return O=0,C.stack.push(L),Promise.resolve().then(Q);if(L.dispose){var T=L.dispose.call(L.value);if(L.async)return O|=2,Promise.resolve(T).then(Q,function(U){return H(U),Q()})}else O|=1}catch(U){H(U)}if(O===1)return C.hasError?Promise.reject(C.error):Promise.resolve();if(C.hasError)throw C.error}return Q()},HC=function(C,H){if(typeof C==="string"&&/^\.\.?\//.test(C))return C.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i,function(L,O,Q,T,U){return O?H?".jsx":".js":Q&&(!T||!U)?L:Q+T+"."+U.toLowerCase()+"js"});return C},X("__extends",P),X("__assign",h),X("__rest",j),X("__decorate",I),X("__param",b),X("__esDecorate",y),X("__runInitializers",g),X("__propKey",k),X("__setFunctionName",f),X("__metadata",m),X("__awaiter",u),X("__generator",x),X("__exportStar",l),X("__createBinding",w),X("__values",D),X("__read",z),X("__spread",_),X("__spreadArrays",d),X("__spreadArray",c),X("__await",E),X("__asyncGenerator",v),X("__asyncDelegator",n),X("__asyncValues",p),X("__makeTemplateObject",i),X("__importStar",s),X("__importDefault",a),X("__classPrivateFieldGet",o),X("__classPrivateFieldSet",t),X("__classPrivateFieldIn",r),X("__addDisposableResource",e),X("__disposeResources",CC),X("__rewriteRelativeImportExtension",HC)})});
-export{OC as ja};
+import{Bh as LC}from"./chunk-1yx2e0bh.js";var OC=LC((QC,A)=>{var P,h,j,I,b,y,g,k,f,m,u,x,l,D,z,_,d,c,E,v,n,p,i,s,a,o,t,r,w,e,CC,HC;(function(X){var R=typeof global==="object"?global:typeof self==="object"?self:typeof this==="object"?this:{};if(typeof define==="function"&&define.amd)define("tslib",["exports"],function(G){X(q(R,q(G)))});else if(typeof A==="object"&&typeof QC==="object")X(q(R,q(QC)));else X(q(R));function q(G,S){if(G!==R)if(typeof Object.create==="function")Object.defineProperty(G,"__esModule",{value:!0});else G.__esModule=!0;return function(C,H){return G[C]=S?S(C,H):H}}})(function(X){var R=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(C,H){C.__proto__=H}||function(C,H){for(var L in H)if(Object.prototype.hasOwnProperty.call(H,L))C[L]=H[L]};P=function(C,H){if(typeof H!=="function"&&H!==null)throw TypeError("Class extends value "+String(H)+" is not a constructor or null");R(C,H);function L(){this.constructor=C}C.prototype=H===null?Object.create(H):(L.prototype=H.prototype,new L)},h=Object.assign||function(C){for(var H,L=1,O=arguments.length;L<O;L++){H=arguments[L];for(var Q in H)if(Object.prototype.hasOwnProperty.call(H,Q))C[Q]=H[Q]}return C},j=function(C,H){var L={};for(var O in C)if(Object.prototype.hasOwnProperty.call(C,O)&&H.indexOf(O)<0)L[O]=C[O];if(C!=null&&typeof Object.getOwnPropertySymbols==="function"){for(var Q=0,O=Object.getOwnPropertySymbols(C);Q<O.length;Q++)if(H.indexOf(O[Q])<0&&Object.prototype.propertyIsEnumerable.call(C,O[Q]))L[O[Q]]=C[O[Q]]}return L},I=function(C,H,L,O){var Q=arguments.length,T=Q<3?H:O===null?O=Object.getOwnPropertyDescriptor(H,L):O,U;if(typeof Reflect==="object"&&typeof Reflect.decorate==="function")T=Reflect.decorate(C,H,L,O);else for(var Y=C.length-1;Y>=0;Y--)if(U=C[Y])T=(Q<3?U(T):Q>3?U(H,L,T):U(H,L))||T;return Q>3&&T&&Object.defineProperty(H,L,T),T},b=function(C,H){return function(L,O){H(L,O,C)}},y=function(C,H,L,O,Q,T){function U(K){if(K!==void 0&&typeof K!=="function")throw TypeError("Function expected");return K}var Y=O.kind,J=Y==="getter"?"get":Y==="setter"?"set":"value",W=!H&&C?O.static?C:C.prototype:null,$=H||(W?Object.getOwnPropertyDescriptor(W,O.name):{}),M,F=!1;for(var Z=L.length-1;Z>=0;Z--){var N={};for(var B in O)N[B]=B==="access"?{}:O[B];for(var B in O.access)N.access[B]=O.access[B];N.addInitializer=function(K){if(F)throw TypeError("Cannot add initializers after decoration has completed");T.push(U(K||null))};var V=(0,L[Z])(Y==="accessor"?{get:$.get,set:$.set}:$[J],N);if(Y==="accessor"){if(V===void 0)continue;if(V===null||typeof V!=="object")throw TypeError("Object expected");if(M=U(V.get))$.get=M;if(M=U(V.set))$.set=M;if(M=U(V.init))Q.unshift(M)}else if(M=U(V))if(Y==="field")Q.unshift(M);else $[J]=M}if(W)Object.defineProperty(W,O.name,$);F=!0},g=function(C,H,L){var O=arguments.length>2;for(var Q=0;Q<H.length;Q++)L=O?H[Q].call(C,L):H[Q].call(C);return O?L:void 0},k=function(C){return typeof C==="symbol"?C:"".concat(C)},f=function(C,H,L){if(typeof H==="symbol")H=H.description?"[".concat(H.description,"]"):"";return Object.defineProperty(C,"name",{configurable:!0,value:L?"".concat(L," ",H):H})},m=function(C,H){if(typeof Reflect==="object"&&typeof Reflect.metadata==="function")return Reflect.metadata(C,H)},u=function(C,H,L,O){function Q(T){return T instanceof L?T:new L(function(U){U(T)})}return new(L||(L=Promise))(function(T,U){function Y($){try{W(O.next($))}catch(M){U(M)}}function J($){try{W(O.throw($))}catch(M){U(M)}}function W($){$.done?T($.value):Q($.value).then(Y,J)}W((O=O.apply(C,H||[])).next())})},x=function(C,H){var L={label:0,sent:function(){if(T[0]&1)throw T[1];return T[1]},trys:[],ops:[]},O,Q,T,U=Object.create((typeof Iterator==="function"?Iterator:Object).prototype);return U.next=Y(0),U.throw=Y(1),U.return=Y(2),typeof Symbol==="function"&&(U[Symbol.iterator]=function(){return this}),U;function Y(W){return function($){return J([W,$])}}function J(W){if(O)throw TypeError("Generator is already executing.");while(U&&(U=0,W[0]&&(L=0)),L)try{if(O=1,Q&&(T=W[0]&2?Q.return:W[0]?Q.throw||((T=Q.return)&&T.call(Q),0):Q.next)&&!(T=T.call(Q,W[1])).done)return T;if(Q=0,T)W=[W[0]&2,T.value];switch(W[0]){case 0:case 1:T=W;break;case 4:return L.label++,{value:W[1],done:!1};case 5:L.label++,Q=W[1],W=[0];continue;case 7:W=L.ops.pop(),L.trys.pop();continue;default:if((T=L.trys,!(T=T.length>0&&T[T.length-1]))&&(W[0]===6||W[0]===2)){L=0;continue}if(W[0]===3&&(!T||W[1]>T[0]&&W[1]<T[3])){L.label=W[1];break}if(W[0]===6&&L.label<T[1]){L.label=T[1],T=W;break}if(T&&L.label<T[2]){L.label=T[2],L.ops.push(W);break}if(T[2])L.ops.pop();L.trys.pop();continue}W=H.call(C,L)}catch($){W=[6,$],Q=0}finally{O=T=0}if(W[0]&5)throw W[1];return{value:W[0]?W[1]:void 0,done:!0}}},l=function(C,H){for(var L in C)if(L!=="default"&&!Object.prototype.hasOwnProperty.call(H,L))w(H,C,L)},w=Object.create?function(C,H,L,O){if(O===void 0)O=L;var Q=Object.getOwnPropertyDescriptor(H,L);if(!Q||("get"in Q?!H.__esModule:Q.writable||Q.configurable))Q={enumerable:!0,get:function(){return H[L]}};Object.defineProperty(C,O,Q)}:function(C,H,L,O){if(O===void 0)O=L;C[O]=H[L]},D=function(C){var H=typeof Symbol==="function"&&Symbol.iterator,L=H&&C[H],O=0;if(L)return L.call(C);if(C&&typeof C.length==="number")return{next:function(){if(C&&O>=C.length)C=void 0;return{value:C&&C[O++],done:!C}}};throw TypeError(H?"Object is not iterable.":"Symbol.iterator is not defined.")},z=function(C,H){var L=typeof Symbol==="function"&&C[Symbol.iterator];if(!L)return C;var O=L.call(C),Q,T=[],U;try{while((H===void 0||H-- >0)&&!(Q=O.next()).done)T.push(Q.value)}catch(Y){U={error:Y}}finally{try{if(Q&&!Q.done&&(L=O.return))L.call(O)}finally{if(U)throw U.error}}return T},_=function(){for(var C=[],H=0;H<arguments.length;H++)C=C.concat(z(arguments[H]));return C},d=function(){for(var C=0,H=0,L=arguments.length;H<L;H++)C+=arguments[H].length;for(var O=Array(C),Q=0,H=0;H<L;H++)for(var T=arguments[H],U=0,Y=T.length;U<Y;U++,Q++)O[Q]=T[U];return O},c=function(C,H,L){if(L||arguments.length===2){for(var O=0,Q=H.length,T;O<Q;O++)if(T||!(O in H)){if(!T)T=Array.prototype.slice.call(H,0,O);T[O]=H[O]}}return C.concat(T||Array.prototype.slice.call(H))},E=function(C){return this instanceof E?(this.v=C,this):new E(C)},v=function(C,H,L){if(!Symbol.asyncIterator)throw TypeError("Symbol.asyncIterator is not defined.");var O=L.apply(C,H||[]),Q,T=[];return Q=Object.create((typeof AsyncIterator==="function"?AsyncIterator:Object).prototype),Y("next"),Y("throw"),Y("return",U),Q[Symbol.asyncIterator]=function(){return this},Q;function U(Z){return function(N){return Promise.resolve(N).then(Z,M)}}function Y(Z,N){if(O[Z]){if(Q[Z]=function(B){return new Promise(function(V,K){T.push([Z,B,V,K])>1||J(Z,B)})},N)Q[Z]=N(Q[Z])}}function J(Z,N){try{W(O[Z](N))}catch(B){F(T[0][3],B)}}function W(Z){Z.value instanceof E?Promise.resolve(Z.value.v).then($,M):F(T[0][2],Z)}function $(Z){J("next",Z)}function M(Z){J("throw",Z)}function F(Z,N){if(Z(N),T.shift(),T.length)J(T[0][0],T[0][1])}},n=function(C){var H,L;return H={},O("next"),O("throw",function(Q){throw Q}),O("return"),H[Symbol.iterator]=function(){return this},H;function O(Q,T){H[Q]=C[Q]?function(U){return(L=!L)?{value:E(C[Q](U)),done:!1}:T?T(U):U}:T}},p=function(C){if(!Symbol.asyncIterator)throw TypeError("Symbol.asyncIterator is not defined.");var H=C[Symbol.asyncIterator],L;return H?H.call(C):(C=typeof D==="function"?D(C):C[Symbol.iterator](),L={},O("next"),O("throw"),O("return"),L[Symbol.asyncIterator]=function(){return this},L);function O(T){L[T]=C[T]&&function(U){return new Promise(function(Y,J){U=C[T](U),Q(Y,J,U.done,U.value)})}}function Q(T,U,Y,J){Promise.resolve(J).then(function(W){T({value:W,done:Y})},U)}},i=function(C,H){if(Object.defineProperty)Object.defineProperty(C,"raw",{value:H});else C.raw=H;return C};var q=Object.create?function(C,H){Object.defineProperty(C,"default",{enumerable:!0,value:H})}:function(C,H){C.default=H},G=function(C){return G=Object.getOwnPropertyNames||function(H){var L=[];for(var O in H)if(Object.prototype.hasOwnProperty.call(H,O))L[L.length]=O;return L},G(C)};s=function(C){if(C&&C.__esModule)return C;var H={};if(C!=null){for(var L=G(C),O=0;O<L.length;O++)if(L[O]!=="default")w(H,C,L[O])}return q(H,C),H},a=function(C){return C&&C.__esModule?C:{default:C}},o=function(C,H,L,O){if(L==="a"&&!O)throw TypeError("Private accessor was defined without a getter");if(typeof H==="function"?C!==H||!O:!H.has(C))throw TypeError("Cannot read private member from an object whose class did not declare it");return L==="m"?O:L==="a"?O.call(C):O?O.value:H.get(C)},t=function(C,H,L,O,Q){if(O==="m")throw TypeError("Private method is not writable");if(O==="a"&&!Q)throw TypeError("Private accessor was defined without a setter");if(typeof H==="function"?C!==H||!Q:!H.has(C))throw TypeError("Cannot write private member to an object whose class did not declare it");return O==="a"?Q.call(C,L):Q?Q.value=L:H.set(C,L),L},r=function(C,H){if(H===null||typeof H!=="object"&&typeof H!=="function")throw TypeError("Cannot use 'in' operator on non-object");return typeof C==="function"?H===C:C.has(H)},e=function(C,H,L){if(H!==null&&H!==void 0){if(typeof H!=="object"&&typeof H!=="function")throw TypeError("Object expected.");var O,Q;if(L){if(!Symbol.asyncDispose)throw TypeError("Symbol.asyncDispose is not defined.");O=H[Symbol.asyncDispose]}if(O===void 0){if(!Symbol.dispose)throw TypeError("Symbol.dispose is not defined.");if(O=H[Symbol.dispose],L)Q=O}if(typeof O!=="function")throw TypeError("Object not disposable.");if(Q)O=function(){try{Q.call(this)}catch(T){return Promise.reject(T)}};C.stack.push({value:H,dispose:O,async:L})}else if(L)C.stack.push({async:!0});return H};var S=typeof SuppressedError==="function"?SuppressedError:function(C,H,L){var O=Error(L);return O.name="SuppressedError",O.error=C,O.suppressed=H,O};CC=function(C){function H(T){C.error=C.hasError?new S(T,C.error,"An error was suppressed during disposal."):T,C.hasError=!0}var L,O=0;function Q(){while(L=C.stack.pop())try{if(!L.async&&O===1)return O=0,C.stack.push(L),Promise.resolve().then(Q);if(L.dispose){var T=L.dispose.call(L.value);if(L.async)return O|=2,Promise.resolve(T).then(Q,function(U){return H(U),Q()})}else O|=1}catch(U){H(U)}if(O===1)return C.hasError?Promise.reject(C.error):Promise.resolve();if(C.hasError)throw C.error}return Q()},HC=function(C,H){if(typeof C==="string"&&/^\.\.?\//.test(C))return C.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i,function(L,O,Q,T,U){return O?H?".jsx":".js":Q&&(!T||!U)?L:Q+T+"."+U.toLowerCase()+"js"});return C},X("__extends",P),X("__assign",h),X("__rest",j),X("__decorate",I),X("__param",b),X("__esDecorate",y),X("__runInitializers",g),X("__propKey",k),X("__setFunctionName",f),X("__metadata",m),X("__awaiter",u),X("__generator",x),X("__exportStar",l),X("__createBinding",w),X("__values",D),X("__read",z),X("__spread",_),X("__spreadArrays",d),X("__spreadArray",c),X("__await",E),X("__asyncGenerator",v),X("__asyncDelegator",n),X("__asyncValues",p),X("__makeTemplateObject",i),X("__importStar",s),X("__importDefault",a),X("__classPrivateFieldGet",o),X("__classPrivateFieldSet",t),X("__classPrivateFieldIn",r),X("__addDisposableResource",e),X("__disposeResources",CC),X("__rewriteRelativeImportExtension",HC)})});
+export{OC as ka};
 
-//# debugId=4EF79BBD7358458F64756E2164756E21
+//# debugId=C66D991CC6354D3664756E2164756E21

package/dist/{chunk-v52dyw0q.js.map → chunk-yqavgpwd.js.map}

@@ -5,6 +5,6 @@
     "/******************************************************************************\r\nCopyright (c) Microsoft Corporation.\r\n\r\nPermission to use, copy, modify, and/or distribute this software for any\r\npurpose with or without fee is hereby granted.\r\n\r\nTHE SOFTWARE IS PROVIDED \"AS IS\" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH\r\nREGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY\r\nAND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,\r\nINDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM\r\nLOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR\r\nOTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR\r\nPERFORMANCE OF THIS SOFTWARE.\r\n***************************************************************************** */\r\n/* global global, define, Symbol, Reflect, Promise, SuppressedError, Iterator */\r\nvar __extends;\r\nvar __assign;\r\nvar __rest;\r\nvar __decorate;\r\nvar __param;\r\nvar __esDecorate;\r\nvar __runInitializers;\r\nvar __propKey;\r\nvar __setFunctionName;\r\nvar __metadata;\r\nvar __awaiter;\r\nvar __generator;\r\nvar __exportStar;\r\nvar __values;\r\nvar __read;\r\nvar __spread;\r\nvar __spreadArrays;\r\nvar __spreadArray;\r\nvar __await;\r\nvar __asyncGenerator;\r\nvar __asyncDelegator;\r\nvar __asyncValues;\r\nvar __makeTemplateObject;\r\nvar __importStar;\r\nvar __importDefault;\r\nvar __classPrivateFieldGet;\r\nvar __classPrivateFieldSet;\r\nvar __classPrivateFieldIn;\r\nvar __createBinding;\r\nvar __addDisposableResource;\r\nvar __disposeResources;\r\nvar __rewriteRelativeImportExtension;\r\n(function (factory) {\r\n    var root = typeof global === \"object\" ? global : typeof self === \"object\" ? self : typeof this === \"object\" ? this : {};\r\n    if (typeof define === \"function\" && define.amd) {\r\n        define(\"tslib\", [\"exports\"], function (exports) { factory(createExporter(root, createExporter(exports))); });\r\n    }\r\n    else if (typeof module === \"object\" && typeof module.exports === \"object\") {\r\n        factory(createExporter(root, createExporter(module.exports)));\r\n    }\r\n    else {\r\n        factory(createExporter(root));\r\n    }\r\n    function createExporter(exports, previous) {\r\n        if (exports !== root) {\r\n            if (typeof Object.create === \"function\") {\r\n                Object.defineProperty(exports, \"__esModule\", { value: true });\r\n            }\r\n            else {\r\n                exports.__esModule = true;\r\n            }\r\n        }\r\n        return function (id, v) { return exports[id] = previous ? previous(id, v) : v; };\r\n    }\r\n})\r\n(function (exporter) {\r\n    var extendStatics = Object.setPrototypeOf ||\r\n        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\r\n        function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };\r\n\r\n    __extends = function (d, b) {\r\n        if (typeof b !== \"function\" && b !== null)\r\n            throw new TypeError(\"Class extends value \" + String(b) + \" is not a constructor or null\");\r\n        extendStatics(d, b);\r\n        function __() { this.constructor = d; }\r\n        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\r\n    };\r\n\r\n    __assign = Object.assign || function (t) {\r\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\r\n            s = arguments[i];\r\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];\r\n        }\r\n        return t;\r\n    };\r\n\r\n    __rest = function (s, e) {\r\n        var t = {};\r\n        for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)\r\n            t[p] = s[p];\r\n        if (s != null && typeof Object.getOwnPropertySymbols === \"function\")\r\n            for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {\r\n                if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))\r\n                    t[p[i]] = s[p[i]];\r\n            }\r\n        return t;\r\n    };\r\n\r\n    __decorate = function (decorators, target, key, desc) {\r\n        var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n        if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n        else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n        return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n    };\r\n\r\n    __param = function (paramIndex, decorator) {\r\n        return function (target, key) { decorator(target, key, paramIndex); }\r\n    };\r\n\r\n    __esDecorate = function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {\r\n        function accept(f) { if (f !== void 0 && typeof f !== \"function\") throw new TypeError(\"Function expected\"); return f; }\r\n        var kind = contextIn.kind, key = kind === \"getter\" ? \"get\" : kind === \"setter\" ? \"set\" : \"value\";\r\n        var target = !descriptorIn && ctor ? contextIn[\"static\"] ? ctor : ctor.prototype : null;\r\n        var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});\r\n        var _, done = false;\r\n        for (var i = decorators.length - 1; i >= 0; i--) {\r\n            var context = {};\r\n            for (var p in contextIn) context[p] = p === \"access\" ? {} : contextIn[p];\r\n            for (var p in contextIn.access) context.access[p] = contextIn.access[p];\r\n            context.addInitializer = function (f) { if (done) throw new TypeError(\"Cannot add initializers after decoration has completed\"); extraInitializers.push(accept(f || null)); };\r\n            var result = (0, decorators[i])(kind === \"accessor\" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);\r\n            if (kind === \"accessor\") {\r\n                if (result === void 0) continue;\r\n                if (result === null || typeof result !== \"object\") throw new TypeError(\"Object expected\");\r\n                if (_ = accept(result.get)) descriptor.get = _;\r\n                if (_ = accept(result.set)) descriptor.set = _;\r\n                if (_ = accept(result.init)) initializers.unshift(_);\r\n            }\r\n            else if (_ = accept(result)) {\r\n                if (kind === \"field\") initializers.unshift(_);\r\n                else descriptor[key] = _;\r\n            }\r\n        }\r\n        if (target) Object.defineProperty(target, contextIn.name, descriptor);\r\n        done = true;\r\n    };\r\n\r\n    __runInitializers = function (thisArg, initializers, value) {\r\n        var useValue = arguments.length > 2;\r\n        for (var i = 0; i < initializers.length; i++) {\r\n            value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);\r\n        }\r\n        return useValue ? value : void 0;\r\n    };\r\n\r\n    __propKey = function (x) {\r\n        return typeof x === \"symbol\" ? x : \"\".concat(x);\r\n    };\r\n\r\n    __setFunctionName = function (f, name, prefix) {\r\n        if (typeof name === \"symbol\") name = name.description ? \"[\".concat(name.description, \"]\") : \"\";\r\n        return Object.defineProperty(f, \"name\", { configurable: true, value: prefix ? \"\".concat(prefix, \" \", name) : name });\r\n    };\r\n\r\n    __metadata = function (metadataKey, metadataValue) {\r\n        if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(metadataKey, metadataValue);\r\n    };\r\n\r\n    __awaiter = function (thisArg, _arguments, P, generator) {\r\n        function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\r\n        return new (P || (P = Promise))(function (resolve, reject) {\r\n            function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\r\n            function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\r\n            function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\r\n            step((generator = generator.apply(thisArg, _arguments || [])).next());\r\n        });\r\n    };\r\n\r\n    __generator = function (thisArg, body) {\r\n        var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === \"function\" ? Iterator : Object).prototype);\r\n        return g.next = verb(0), g[\"throw\"] = verb(1), g[\"return\"] = verb(2), typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\r\n        function verb(n) { return function (v) { return step([n, v]); }; }\r\n        function step(op) {\r\n            if (f) throw new TypeError(\"Generator is already executing.\");\r\n            while (g && (g = 0, op[0] && (_ = 0)), _) try {\r\n                if (f = 1, y && (t = op[0] & 2 ? y[\"return\"] : op[0] ? y[\"throw\"] || ((t = y[\"return\"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;\r\n                if (y = 0, t) op = [op[0] & 2, t.value];\r\n                switch (op[0]) {\r\n                    case 0: case 1: t = op; break;\r\n                    case 4: _.label++; return { value: op[1], done: false };\r\n                    case 5: _.label++; y = op[1]; op = [0]; continue;\r\n                    case 7: op = _.ops.pop(); _.trys.pop(); continue;\r\n                    default:\r\n                        if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\r\n                        if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\r\n                        if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\r\n                        if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\r\n                        if (t[2]) _.ops.pop();\r\n                        _.trys.pop(); continue;\r\n                }\r\n                op = body.call(thisArg, _);\r\n            } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\r\n            if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\r\n        }\r\n    };\r\n\r\n    __exportStar = function(m, o) {\r\n        for (var p in m) if (p !== \"default\" && !Object.prototype.hasOwnProperty.call(o, p)) __createBinding(o, m, p);\r\n    };\r\n\r\n    __createBinding = Object.create ? (function(o, m, k, k2) {\r\n        if (k2 === undefined) k2 = k;\r\n        var desc = Object.getOwnPropertyDescriptor(m, k);\r\n        if (!desc || (\"get\" in desc ? !m.__esModule : desc.writable || desc.configurable)) {\r\n            desc = { enumerable: true, get: function() { return m[k]; } };\r\n        }\r\n        Object.defineProperty(o, k2, desc);\r\n    }) : (function(o, m, k, k2) {\r\n        if (k2 === undefined) k2 = k;\r\n        o[k2] = m[k];\r\n    });\r\n\r\n    __values = function (o) {\r\n        var s = typeof Symbol === \"function\" && Symbol.iterator, m = s && o[s], i = 0;\r\n        if (m) return m.call(o);\r\n        if (o && typeof o.length === \"number\") return {\r\n            next: function () {\r\n                if (o && i >= o.length) o = void 0;\r\n                return { value: o && o[i++], done: !o };\r\n            }\r\n        };\r\n        throw new TypeError(s ? \"Object is not iterable.\" : \"Symbol.iterator is not defined.\");\r\n    };\r\n\r\n    __read = function (o, n) {\r\n        var m = typeof Symbol === \"function\" && o[Symbol.iterator];\r\n        if (!m) return o;\r\n        var i = m.call(o), r, ar = [], e;\r\n        try {\r\n            while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\r\n        }\r\n        catch (error) { e = { error: error }; }\r\n        finally {\r\n            try {\r\n                if (r && !r.done && (m = i[\"return\"])) m.call(i);\r\n            }\r\n            finally { if (e) throw e.error; }\r\n        }\r\n        return ar;\r\n    };\r\n\r\n    /** @deprecated */\r\n    __spread = function () {\r\n        for (var ar = [], i = 0; i < arguments.length; i++)\r\n            ar = ar.concat(__read(arguments[i]));\r\n        return ar;\r\n    };\r\n\r\n    /** @deprecated */\r\n    __spreadArrays = function () {\r\n        for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;\r\n        for (var r = Array(s), k = 0, i = 0; i < il; i++)\r\n            for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)\r\n                r[k] = a[j];\r\n        return r;\r\n    };\r\n\r\n    __spreadArray = function (to, from, pack) {\r\n        if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {\r\n            if (ar || !(i in from)) {\r\n                if (!ar) ar = Array.prototype.slice.call(from, 0, i);\r\n                ar[i] = from[i];\r\n            }\r\n        }\r\n        return to.concat(ar || Array.prototype.slice.call(from));\r\n    };\r\n\r\n    __await = function (v) {\r\n        return this instanceof __await ? (this.v = v, this) : new __await(v);\r\n    };\r\n\r\n    __asyncGenerator = function (thisArg, _arguments, generator) {\r\n        if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n        var g = generator.apply(thisArg, _arguments || []), i, q = [];\r\n        return i = Object.create((typeof AsyncIterator === \"function\" ? AsyncIterator : Object).prototype), verb(\"next\"), verb(\"throw\"), verb(\"return\", awaitReturn), i[Symbol.asyncIterator] = function () { return this; }, i;\r\n        function awaitReturn(f) { return function (v) { return Promise.resolve(v).then(f, reject); }; }\r\n        function verb(n, f) { if (g[n]) { i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; if (f) i[n] = f(i[n]); } }\r\n        function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }\r\n        function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }\r\n        function fulfill(value) { resume(\"next\", value); }\r\n        function reject(value) { resume(\"throw\", value); }\r\n        function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }\r\n    };\r\n\r\n    __asyncDelegator = function (o) {\r\n        var i, p;\r\n        return i = {}, verb(\"next\"), verb(\"throw\", function (e) { throw e; }), verb(\"return\"), i[Symbol.iterator] = function () { return this; }, i;\r\n        function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: false } : f ? f(v) : v; } : f; }\r\n    };\r\n\r\n    __asyncValues = function (o) {\r\n        if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n        var m = o[Symbol.asyncIterator], i;\r\n        return m ? m.call(o) : (o = typeof __values === \"function\" ? __values(o) : o[Symbol.iterator](), i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i);\r\n        function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }\r\n        function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }\r\n    };\r\n\r\n    __makeTemplateObject = function (cooked, raw) {\r\n        if (Object.defineProperty) { Object.defineProperty(cooked, \"raw\", { value: raw }); } else { cooked.raw = raw; }\r\n        return cooked;\r\n    };\r\n\r\n    var __setModuleDefault = Object.create ? (function(o, v) {\r\n        Object.defineProperty(o, \"default\", { enumerable: true, value: v });\r\n    }) : function(o, v) {\r\n        o[\"default\"] = v;\r\n    };\r\n\r\n    var ownKeys = function(o) {\r\n        ownKeys = Object.getOwnPropertyNames || function (o) {\r\n            var ar = [];\r\n            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;\r\n            return ar;\r\n        };\r\n        return ownKeys(o);\r\n    };\r\n\r\n    __importStar = function (mod) {\r\n        if (mod && mod.__esModule) return mod;\r\n        var result = {};\r\n        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== \"default\") __createBinding(result, mod, k[i]);\r\n        __setModuleDefault(result, mod);\r\n        return result;\r\n    };\r\n\r\n    __importDefault = function (mod) {\r\n        return (mod && mod.__esModule) ? mod : { \"default\": mod };\r\n    };\r\n\r\n    __classPrivateFieldGet = function (receiver, state, kind, f) {\r\n        if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a getter\");\r\n        if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot read private member from an object whose class did not declare it\");\r\n        return kind === \"m\" ? f : kind === \"a\" ? f.call(receiver) : f ? f.value : state.get(receiver);\r\n    };\r\n\r\n    __classPrivateFieldSet = function (receiver, state, value, kind, f) {\r\n        if (kind === \"m\") throw new TypeError(\"Private method is not writable\");\r\n        if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a setter\");\r\n        if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot write private member to an object whose class did not declare it\");\r\n        return (kind === \"a\" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;\r\n    };\r\n\r\n    __classPrivateFieldIn = function (state, receiver) {\r\n        if (receiver === null || (typeof receiver !== \"object\" && typeof receiver !== \"function\")) throw new TypeError(\"Cannot use 'in' operator on non-object\");\r\n        return typeof state === \"function\" ? receiver === state : state.has(receiver);\r\n    };\r\n\r\n    __addDisposableResource = function (env, value, async) {\r\n        if (value !== null && value !== void 0) {\r\n            if (typeof value !== \"object\" && typeof value !== \"function\") throw new TypeError(\"Object expected.\");\r\n            var dispose, inner;\r\n            if (async) {\r\n                if (!Symbol.asyncDispose) throw new TypeError(\"Symbol.asyncDispose is not defined.\");\r\n                dispose = value[Symbol.asyncDispose];\r\n            }\r\n            if (dispose === void 0) {\r\n                if (!Symbol.dispose) throw new TypeError(\"Symbol.dispose is not defined.\");\r\n                dispose = value[Symbol.dispose];\r\n                if (async) inner = dispose;\r\n            }\r\n            if (typeof dispose !== \"function\") throw new TypeError(\"Object not disposable.\");\r\n            if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };\r\n            env.stack.push({ value: value, dispose: dispose, async: async });\r\n        }\r\n        else if (async) {\r\n            env.stack.push({ async: true });\r\n        }\r\n        return value;\r\n    };\r\n\r\n    var _SuppressedError = typeof SuppressedError === \"function\" ? SuppressedError : function (error, suppressed, message) {\r\n        var e = new Error(message);\r\n        return e.name = \"SuppressedError\", e.error = error, e.suppressed = suppressed, e;\r\n    };\r\n\r\n    __disposeResources = function (env) {\r\n        function fail(e) {\r\n            env.error = env.hasError ? new _SuppressedError(e, env.error, \"An error was suppressed during disposal.\") : e;\r\n            env.hasError = true;\r\n        }\r\n        var r, s = 0;\r\n        function next() {\r\n            while (r = env.stack.pop()) {\r\n                try {\r\n                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);\r\n                    if (r.dispose) {\r\n                        var result = r.dispose.call(r.value);\r\n                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });\r\n                    }\r\n                    else s |= 1;\r\n                }\r\n                catch (e) {\r\n                    fail(e);\r\n                }\r\n            }\r\n            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();\r\n            if (env.hasError) throw env.error;\r\n        }\r\n        return next();\r\n    };\r\n\r\n    __rewriteRelativeImportExtension = function (path, preserveJsx) {\r\n        if (typeof path === \"string\" && /^\\.\\.?\\//.test(path)) {\r\n            return path.replace(/\\.(tsx)$|((?:\\.d)?)((?:\\.[^./]+?)?)\\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {\r\n                return tsx ? preserveJsx ? \".jsx\" : \".js\" : d && (!ext || !cm) ? m : (d + ext + \".\" + cm.toLowerCase() + \"js\");\r\n            });\r\n        }\r\n        return path;\r\n    };\r\n\r\n    exporter(\"__extends\", __extends);\r\n    exporter(\"__assign\", __assign);\r\n    exporter(\"__rest\", __rest);\r\n    exporter(\"__decorate\", __decorate);\r\n    exporter(\"__param\", __param);\r\n    exporter(\"__esDecorate\", __esDecorate);\r\n    exporter(\"__runInitializers\", __runInitializers);\r\n    exporter(\"__propKey\", __propKey);\r\n    exporter(\"__setFunctionName\", __setFunctionName);\r\n    exporter(\"__metadata\", __metadata);\r\n    exporter(\"__awaiter\", __awaiter);\r\n    exporter(\"__generator\", __generator);\r\n    exporter(\"__exportStar\", __exportStar);\r\n    exporter(\"__createBinding\", __createBinding);\r\n    exporter(\"__values\", __values);\r\n    exporter(\"__read\", __read);\r\n    exporter(\"__spread\", __spread);\r\n    exporter(\"__spreadArrays\", __spreadArrays);\r\n    exporter(\"__spreadArray\", __spreadArray);\r\n    exporter(\"__await\", __await);\r\n    exporter(\"__asyncGenerator\", __asyncGenerator);\r\n    exporter(\"__asyncDelegator\", __asyncDelegator);\r\n    exporter(\"__asyncValues\", __asyncValues);\r\n    exporter(\"__makeTemplateObject\", __makeTemplateObject);\r\n    exporter(\"__importStar\", __importStar);\r\n    exporter(\"__importDefault\", __importDefault);\r\n    exporter(\"__classPrivateFieldGet\", __classPrivateFieldGet);\r\n    exporter(\"__classPrivateFieldSet\", __classPrivateFieldSet);\r\n    exporter(\"__classPrivateFieldIn\", __classPrivateFieldIn);\r\n    exporter(\"__addDisposableResource\", __addDisposableResource);\r\n    exporter(\"__disposeResources\", __disposeResources);\r\n    exporter(\"__rewriteRelativeImportExtension\", __rewriteRelativeImportExtension);\r\n});\r\n\r\n0 && (module.exports = {\r\n    __extends: __extends,\r\n    __assign: __assign,\r\n    __rest: __rest,\r\n    __decorate: __decorate,\r\n    __param: __param,\r\n    __esDecorate: __esDecorate,\r\n    __runInitializers: __runInitializers,\r\n    __propKey: __propKey,\r\n    __setFunctionName: __setFunctionName,\r\n    __metadata: __metadata,\r\n    __awaiter: __awaiter,\r\n    __generator: __generator,\r\n    __exportStar: __exportStar,\r\n    __createBinding: __createBinding,\r\n    __values: __values,\r\n    __read: __read,\r\n    __spread: __spread,\r\n    __spreadArrays: __spreadArrays,\r\n    __spreadArray: __spreadArray,\r\n    __await: __await,\r\n    __asyncGenerator: __asyncGenerator,\r\n    __asyncDelegator: __asyncDelegator,\r\n    __asyncValues: __asyncValues,\r\n    __makeTemplateObject: __makeTemplateObject,\r\n    __importStar: __importStar,\r\n    __importDefault: __importDefault,\r\n    __classPrivateFieldGet: __classPrivateFieldGet,\r\n    __classPrivateFieldSet: __classPrivateFieldSet,\r\n    __classPrivateFieldIn: __classPrivateFieldIn,\r\n    __addDisposableResource: __addDisposableResource,\r\n    __disposeResources: __disposeResources,\r\n    __rewriteRelativeImportExtension: __rewriteRelativeImportExtension,\r\n});\r\n"
   ],
   "mappings": "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",
-  "debugId": "4EF79BBD7358458F64756E2164756E21",
+  "debugId": "C66D991CC6354D3664756E2164756E21",
   "names": []
 }

package/dist/{chunk-hyfzw1fk.js → chunk-z10cas5r.js}

@@ -3,6 +3,6 @@ class g extends Error{constructor(h,r){super(h,r);this.name="ConsoleError"}}clas
 
     export default defineCommand("my-command")
       .handle(async ({ line }) => { line("hello") })`);let i=this.byName.get(f);if(i)throw new g(`Two commands are named "${f}": ${o(i)} and ${o(r)}. A command name is how it is run, so one of `+"them could never be reached \u2014 rename one.");this.byName.set(f,r)}}get commands(){return[...this.byName.values()]}get(h){return this.byName.get(h)}suggest(h){let r=h.toLowerCase(),f=r.includes(":")?r.split(":")[0]:void 0,i=[];for(let s of this.byName.keys()){let t=s.toLowerCase();if(t.startsWith(r)||r.startsWith(t))i.push([0,s]);else if(t.includes(r)||r.includes(t))i.push([1,s]);else if(f&&t.startsWith(`${f}:`))i.push([2,s]);else if(l(t,r)<=2)i.push([3,s])}return i.sort((s,t)=>s[0]-t[0]||(s[1]<t[1]?-1:1)).slice(0,3).map(([,s])=>s)}}function o(h){return h.name?`\`${h.name}\``:"an anonymous command class"}function l(h,r){if(h===r)return 0;if(Math.abs(h.length-r.length)>2)return 99;let f=Array.from({length:r.length+1},(i,s)=>s);for(let i=1;i<=h.length;i+=1){let s=[i];for(let t=1;t<=r.length;t+=1)s[t]=Math.min(f[t]+1,s[t-1]+1,f[t-1]+(h[i-1]===r[t-1]?0:1));f=s}return f[r.length]}
-export{g as Za,w as _a};
+export{g as fb,w as gb};
 
-//# debugId=BAE4C72311FA177264756E2164756E21
+//# debugId=1F67A63FBB8D426264756E2164756E21

package/dist/{chunk-hyfzw1fk.js.map → chunk-z10cas5r.js.map}

@@ -6,6 +6,6 @@
     "import type { CommandClass } from \"./Command\";\nimport { ConsoleError } from \"./errors\";\n\n/**\n * The commands an application has, and the rules about what a command may be.\n *\n * A plain class, not a container service, and that is a decision rather than an\n * omission. `QueueManager` and `Scheduler` are bound and populated during boot\n * because the server needs them: a dispatch or a tick can arrive at any moment\n * after boot finishes. A command registry has exactly one consumer — `gemi run`,\n * which builds one, uses it, and exits. Making it a boot step would import every\n * file under `app/commands` into every `gemi dev`, every `gemi start` and every\n * deployed server process, on every start, for code no request will ever reach.\n * That is the cost `bin/check-models.ts` argues against at length, and there is\n * no benefit here to weigh against it.\n *\n * What the class is for is the rules below, and the `commands` getter — the same\n * seam `QueueManager.registeredJobs` and `Scheduler.jobs` exist to give a test:\n * what was actually taken, rather than what a walk would find if asked again.\n */\nexport class CommandRegistry {\n  private readonly byName = new Map<string, CommandClass>();\n\n  /**\n   * @throws ConsoleError naming the offending class for a command that cannot\n   * be run.\n   *\n   * Every refusal here is loud and immediate. There is a human at a terminal,\n   * and every one of these is a mistake in the application's own source that\n   * they are better off seeing now than after the command they meant to run\n   * silently did not exist.\n   *\n   * `ConsoleError` rather than a plain `Error` so the runner prints the message\n   * alone. These are sentences with the fix named in them, and burying one under\n   * `at new CommandRegistry (…)` plus the runner's own frames points the reader\n   * at framework code when the mistake is in their `app/commands`.\n   */\n  constructor(commands: CommandClass[]) {\n    for (const command of commands) {\n      const name = command.commandName;\n\n      if (!name || name === \"unset\") {\n        throw new ConsoleError(\n          `${describe(command)} does not declare a command name, so there is ` +\n            `no name to run it by. Commands are written with \\`defineCommand\\`:` +\n            `\\n\\n    export default defineCommand(\"my-command\")\\n` +\n            `      .handle(async ({ line }) => { line(\"hello\") })`,\n        );\n      }\n\n      const existing = this.byName.get(name);\n      if (existing) {\n        // Deliberately a hard error, where `QueueManager.useJobs` and\n        // `Scheduler.start` take the first and warn. Those two must keep a\n        // server booting, so running one of two identically-named jobs beats\n        // refusing to start at all. Here there is no boot to protect and a\n        // person is waiting: running the wrong one of two commands called\n        // `db:seed` is strictly worse than running neither and being told why.\n        throw new ConsoleError(\n          `Two commands are named \"${name}\": ${describe(existing)} and ` +\n            `${describe(command)}. A command name is how it is run, so one of ` +\n            `them could never be reached — rename one.`,\n        );\n      }\n\n      this.byName.set(name, command);\n    }\n  }\n\n  /** What was actually taken. */\n  get commands(): CommandClass[] {\n    return [...this.byName.values()];\n  }\n\n  get(name: string): CommandClass | undefined {\n    return this.byName.get(name);\n  }\n\n  /**\n   * The nearest names to something that did not match, for the \"did you mean\"\n   * line. Prefix matches first, then substring, then names sharing a namespace —\n   * `db:sed` should find `db:seed`, and a typo in a namespace is the common case.\n   */\n  suggest(name: string): string[] {\n    const needle = name.toLowerCase();\n    const namespace = needle.includes(\":\") ? needle.split(\":\")[0] : undefined;\n    const scored: Array<[number, string]> = [];\n\n    for (const candidate of this.byName.keys()) {\n      const haystack = candidate.toLowerCase();\n      if (haystack.startsWith(needle) || needle.startsWith(haystack)) {\n        scored.push([0, candidate]);\n      } else if (haystack.includes(needle) || needle.includes(haystack)) {\n        scored.push([1, candidate]);\n      } else if (namespace && haystack.startsWith(`${namespace}:`)) {\n        scored.push([2, candidate]);\n      } else if (editDistance(haystack, needle) <= 2) {\n        scored.push([3, candidate]);\n      }\n    }\n\n    return scored\n      .sort((a, b) => a[0] - b[0] || (a[1] < b[1] ? -1 : 1))\n      .slice(0, 3)\n      .map(([, candidate]) => candidate);\n  }\n}\n\nfunction describe(command: CommandClass): string {\n  return command.name ? `\\`${command.name}\\`` : \"an anonymous command class\";\n}\n\n/** Small enough that a dependency would cost more than it saves. */\nfunction editDistance(a: string, b: string): number {\n  if (a === b) return 0;\n  if (Math.abs(a.length - b.length) > 2) return 99;\n\n  let previous = Array.from({ length: b.length + 1 }, (_, index) => index);\n\n  for (let i = 1; i <= a.length; i += 1) {\n    const current = [i];\n    for (let j = 1; j <= b.length; j += 1) {\n      current[j] = Math.min(\n        previous[j]! + 1,\n        current[j - 1]! + 1,\n        previous[j - 1]! + (a[i - 1] === b[j - 1] ? 0 : 1),\n      );\n    }\n    previous = current;\n  }\n\n  return previous[b.length]!;\n}\n"
   ],
   "mappings": ";AAaO,MAAM,UAAqB,KAAM,CACtC,WAAW,CAAC,EAAiB,EAA+B,CAC1D,MAAM,EAAS,CAAO,EACtB,KAAK,KAAO,eAEhB,CCEO,MAAM,CAAgB,CACV,OAAS,IAAI,IAgB9B,WAAW,CAAC,EAA0B,CACpC,QAAW,KAAW,EAAU,CAC9B,IAAM,EAAO,EAAQ,YAErB,GAAI,CAAC,GAAQ,IAAS,QACpB,MAAM,IAAI,EACR,GAAG,EAAS,CAAO;AAAA;AAAA;AAAA,qDAIrB,EAGF,IAAM,EAAW,KAAK,OAAO,IAAI,CAAI,EACrC,GAAI,EAOF,MAAM,IAAI,EACR,2BAA2B,OAAU,EAAS,CAAQ,SACjD,EAAS,CAAO,iDACnB,gDACJ,EAGF,KAAK,OAAO,IAAI,EAAM,CAAO,MAK7B,SAAQ,EAAmB,CAC7B,MAAO,CAAC,GAAG,KAAK,OAAO,OAAO,CAAC,EAGjC,GAAG,CAAC,EAAwC,CAC1C,OAAO,KAAK,OAAO,IAAI,CAAI,EAQ7B,OAAO,CAAC,EAAwB,CAC9B,IAAM,EAAS,EAAK,YAAY,EAC1B,EAAY,EAAO,SAAS,GAAG,EAAI,EAAO,MAAM,GAAG,EAAE,GAAK,OAC1D,EAAkC,CAAC,EAEzC,QAAW,KAAa,KAAK,OAAO,KAAK,EAAG,CAC1C,IAAM,EAAW,EAAU,YAAY,EACvC,GAAI,EAAS,WAAW,CAAM,GAAK,EAAO,WAAW,CAAQ,EAC3D,EAAO,KAAK,CAAC,EAAG,CAAS,CAAC,EACrB,QAAI,EAAS,SAAS,CAAM,GAAK,EAAO,SAAS,CAAQ,EAC9D,EAAO,KAAK,CAAC,EAAG,CAAS,CAAC,EACrB,QAAI,GAAa,EAAS,WAAW,GAAG,IAAY,EACzD,EAAO,KAAK,CAAC,EAAG,CAAS,CAAC,EACrB,QAAI,EAAa,EAAU,CAAM,GAAK,EAC3C,EAAO,KAAK,CAAC,EAAG,CAAS,CAAC,EAI9B,OAAO,EACJ,KAAK,CAAC,EAAG,IAAM,EAAE,GAAK,EAAE,KAAO,EAAE,GAAK,EAAE,GAAK,GAAK,EAAE,EACpD,MAAM,EAAG,CAAC,EACV,IAAI,GAAI,KAAe,CAAS,EAEvC,CAEA,SAAS,CAAQ,CAAC,EAA+B,CAC/C,OAAO,EAAQ,KAAO,KAAK,EAAQ,SAAW,6BAIhD,SAAS,CAAY,CAAC,EAAW,EAAmB,CAClD,GAAI,IAAM,EAAG,MAAO,GACpB,GAAI,KAAK,IAAI,EAAE,OAAS,EAAE,MAAM,EAAI,EAAG,MAAO,IAE9C,IAAI,EAAW,MAAM,KAAK,CAAE,OAAQ,EAAE,OAAS,CAAE,EAAG,CAAC,EAAG,IAAU,CAAK,EAEvE,QAAS,EAAI,EAAG,GAAK,EAAE,OAAQ,GAAK,EAAG,CACrC,IAAM,EAAU,CAAC,CAAC,EAClB,QAAS,EAAI,EAAG,GAAK,EAAE,OAAQ,GAAK,EAClC,EAAQ,GAAK,KAAK,IAChB,EAAS,GAAM,EACf,EAAQ,EAAI,GAAM,EAClB,EAAS,EAAI,IAAO,EAAE,EAAI,KAAO,EAAE,EAAI,GAAK,EAAI,EAClD,EAEF,EAAW,EAGb,OAAO,EAAS,EAAE",
-  "debugId": "BAE4C72311FA177264756E2164756E21",
+  "debugId": "1F67A63FBB8D426264756E2164756E21",
   "names": []
 }

package/dist/{chunk-h4x7cba0.js → chunk-zhs1r1z0.js}

@@ -1,5 +1,5 @@
 // @bun
-import{Wg as x}from"./chunk-2q7m8a16.js";function B(j){return j}function C(){return{supportedLocales:[],defaultLocale:"en-US",prefetch:{},components:{},detectLocale:()=>null,onLocaleChange:(j)=>{console.log(`Locale changed to ${j}`)},timeZone:x,detectTimeZone:()=>null}}
-export{B as fc,C as gc};
+import{eh as x}from"./chunk-7tx5y712.js";function B(j){return j}function C(){return{supportedLocales:[],defaultLocale:"en-US",prefetch:{},components:{},detectLocale:()=>null,onLocaleChange:(j)=>{console.log(`Locale changed to ${j}`)},timeZone:x,detectTimeZone:()=>null}}
+export{B as nc,C as oc};
 
-//# debugId=B5D490BDEEBE102764756E2164756E21
+//# debugId=F0D08490F1D7D6C664756E2164756E21

package/dist/{chunk-h4x7cba0.js.map → chunk-zhs1r1z0.js.map}

@@ -5,6 +5,6 @@
     "import { DEFAULT_TIME_ZONE } from \"./formatter\";\nimport type { Dictionary } from \"./Dictionary\";\nimport type { HttpRequest } from \"../http/HttpRequest\";\n\n// Config key: `translation`. Derived from `I18nServiceProvider`.\nexport interface TranslationConfig {\n  supportedLocales?: string[];\n  defaultLocale?: string;\n  /**\n   * @deprecated Only for `Dictionary.create` dictionaries. A `defineDictionary`\n   * dictionary needs no entry here — the component that reads it pulls it in,\n   * and the bundler ships only the active locale.\n   */\n  prefetch?: Record<string, Array<Dictionary<any>>>;\n  /** @deprecated Only for `Dictionary.create` dictionaries. See `prefetch`. */\n  components?: Record<string, Dictionary<any>>;\n\n  // Returning `null` falls back to gemi's own locale detection.\n  detectLocale?: (req: HttpRequest) => string | null;\n  onLocaleChange?: (locale: string) => Promise<void> | void;\n\n  /**\n   * The IANA time zone dates are formatted in by `useFormatter`,\n   * `useDictionary(...).format` and `Lang.formatter()`. Defaults to `UTC`.\n   *\n   * One zone for server and browser alike, so a server-rendered date and its\n   * hydrated copy print the same text. Override per call with\n   * `format.date(value, { timeZone })`.\n   */\n  timeZone?: string;\n  /**\n   * Resolve the zone for one request, e.g. from a cookie or the signed-in\n   * user's profile. Returning `null` (or a zone `Intl` does not know) falls back\n   * to `timeZone`. Runs on the server; the result ships with the page.\n   */\n  detectTimeZone?: (req: HttpRequest) => string | null;\n}\n\nexport function defineTranslationConfig(\n  config: TranslationConfig,\n): TranslationConfig {\n  return config;\n}\n\nexport function translationConfigDefaults(): Required<TranslationConfig> {\n  return {\n    supportedLocales: [],\n    defaultLocale: \"en-US\",\n    prefetch: {},\n    components: {},\n    detectLocale: () => null,\n    onLocaleChange: (locale) => {\n      console.log(`Locale changed to ${locale}`);\n    },\n    timeZone: DEFAULT_TIME_ZONE,\n    detectTimeZone: () => null,\n  };\n}\n"
   ],
   "mappings": ";yCAsCO,SAAS,CAAuB,CACrC,EACmB,CACnB,OAAO,EAGF,SAAS,CAAyB,EAAgC,CACvE,MAAO,CACL,iBAAkB,CAAC,EACnB,cAAe,QACf,SAAU,CAAC,EACX,WAAY,CAAC,EACb,aAAc,IAAM,KACpB,eAAgB,CAAC,IAAW,CAC1B,QAAQ,IAAI,qBAAqB,GAAQ,GAE3C,SAAU,EACV,eAAgB,IAAM,IACxB",
-  "debugId": "B5D490BDEEBE102764756E2164756E21",
+  "debugId": "F0D08490F1D7D6C664756E2164756E21",
   "names": []
 }

package/dist/chunks/{ThemeProvider-Cqfwr6dk.js → ThemeProvider-BgLyzzOL.js}

@@ -3066,6 +3066,8 @@ var ClientRouterProvider = (props) => {
 		return new Subject(false);
 	});
 	const { supportedLocales = [], locale } = useContext(I18nContext);
+	const { staticRoutes } = useContext(ServerDataContext);
+	const staticRoutesRef = useRef(new Set(staticRoutes ?? []));
 	const [progressManager] = useState(new ProgressManager(isNavigatingSubject));
 	const [prefetchCache] = useState(() => new PrefetchCache());
 	const pageDataRef = useRef(structuredClone(pageData));
@@ -3131,6 +3133,10 @@ var ClientRouterProvider = (props) => {
 			}
 			_pathname = _pathname === "" ? "/" : _pathname;
 			const routePath = getRoutePathnameFromHref(_pathname);
+			if (routePath && staticRoutesRef.current.has(routePath)) {
+				window.location.replace(location.pathname + location.search + location.hash);
+				return;
+			}
 			routerSubject.next({
 				views: getViewPathsFromPathname(_pathname),
 				params: getParams(_pathname),
@@ -3229,7 +3235,7 @@ var ClientRouterProvider = (props) => {
 		if (typeof window === "undefined") return;
 		const { pathname, search = "", localeSegment = "" } = target;
 		const routePath = getRoutePathnameFromHref(pathname);
-		if (!routePath) return;
+		if (!routePath || staticRoutesRef.current.has(routePath)) return;
 		const url = routeDataUrl({
 			pathname,
 			search,
@@ -3399,4 +3405,4 @@ function useTheme() {
 //#endregion
 export { useLocation as A, QueryManagerProvider as B, useRoute as C, I18nProvider as D, I18nContext as E, createMemoryHistory as F, retryDelayFor as G, pickDefined as H, toVariantKey as I, Subject as J, shouldRetryQuery as K, applyParams as L, isAbsoluteUrl as M, ProgressManager as N, ServerDataContext as O, Action as P, QueryConfigContext as R, routeDataUrl as S, useNavigate as T, DEFAULT_STALE_TIME as U, USER_QUERY_CONFIG_KEYS as V, isRetryableQueryError as W, loadDictionary as _, useRouteTransition as a, setActiveLocale as b, ComponentsContext as c, loadViewModule as d, subscribeViewModules as f, recoverFromChunkLoadError as g, isChunkLoadError as h, RouteTransitionProvider as i, domainUrl as j, ServerDataProvider as k, ComponentsProvider as l, configureChunkLoadRecovery as m, useTheme as n, ClientRouterContext as o, CHUNK_RELOAD_MARKER as p, QueryError as q, m as r, ClientRouterProvider as s, ThemeProvider as t, initialViewModulesReady as u, loadDictionaryForRender as v, useSearchParams as w, readRoutePayload as x, registerDictionary as y, QueryManagerContext as z };
 
-//# sourceMappingURL=ThemeProvider-Cqfwr6dk.js.map
+//# sourceMappingURL=ThemeProvider-BgLyzzOL.js.map