@lunora/codegen 1.0.0-alpha.319 → 1.0.0-alpha.320

package/dist/packem_shared/{discoverStorageRulesMetadata-BBMy9JVZ.mjs → discoverStorageRulesMetadata-ClzKLdCV.mjs}

@@ -1 +1 @@
-import{Node as u}from"ts-morph";import{listLunoraSourceFiles as f,lunoraRelativePath as p,stringPropertyOf as l}from"./isTestPath-B81lOULB.mjs";import{w as d}from"./classify-procedure-call-CcgP-9I0.mjs";import{e as m}from"./exported-procedure-chains-DAl7xBBx.mjs";const h=new Set(["delete","list","read","write"]),g=t=>d(t,"use","storageRules"),x=(t,s,n)=>{const e=t.getArguments()[0];if(!e||!u.isArrayLiteralExpression(e))return[];const i=[];for(const o of e.getElements()){if(!u.isObjectLiteralExpression(o))continue;const r=l(o,"on");if(r===void 0||!h.has(r))continue;const a=l(o,"prefix"),c={bucket:l(o,"bucket")??"",file:s,on:r,procedure:n};a!==void 0&&(c.prefix=a),i.push(c)}return i},A=(t,s)=>{const n=[];for(const e of f(s)){const i=t.getSourceFile(e)??t.addSourceFileAtPath(e),o=p(s,e);for(const{name:r,receiver:a}of m(i))for(const c of g(a))n.push(...x(c,o,r))}return{rules:n}};export{A as default};
+import{Node as u}from"ts-morph";import{listLunoraSourceFiles as f,lunoraRelativePath as p,stringPropertyOf as l}from"./isTestPath-B81lOULB.mjs";import{w as d}from"./classify-procedure-call-DVxdUhZt.mjs";import{e as m}from"./exported-procedure-chains-BNBUkXui.mjs";const h=new Set(["delete","list","read","write"]),g=t=>d(t,"use","storageRules"),x=(t,s,n)=>{const e=t.getArguments()[0];if(!e||!u.isArrayLiteralExpression(e))return[];const i=[];for(const o of e.getElements()){if(!u.isObjectLiteralExpression(o))continue;const r=l(o,"on");if(r===void 0||!h.has(r))continue;const a=l(o,"prefix"),c={bucket:l(o,"bucket")??"",file:s,on:r,procedure:n};a!==void 0&&(c.prefix=a),i.push(c)}return i},A=(t,s)=>{const n=[];for(const e of f(s)){const i=t.getSourceFile(e)??t.addSourceFileAtPath(e),o=p(s,e);for(const{name:r,receiver:a}of m(i))for(const c of g(a))n.push(...x(c,o,r))}return{rules:n}};export{A as default};

package/dist/packem_shared/{emitAgents-DuSp0uSJ.mjs → emitAgents-CR2_X_ov.mjs}

@@ -1 +1 @@
-import"./json-data-Chfs2Cz5.mjs";import{o as i,j as r,s as n,h as o,t as g,k as u,d as F,w as p,m as l,g as d,f,i as k,u as w,l as A,v as Q}from"./shard-runtime-BQ6ZNigW.mjs";import"./shared-DnCokNcE.mjs";import"./platform-8oj7iXQy.mjs";export{i as buildDoTypeImports,r as emitAgentFragments,n as emitAgents,o as emitContainerFragments,g as emitContainers,u as emitPaymentFragments,F as emitQueueFragments,p as emitQueues,l as emitQueuesMetadataFragments,d as emitServiceFragments,f as emitTopicFragments,k as emitWorkflowFragments,w as emitWorkflows,A as emitWorkflowsMetadataFragments,Q as queueAliasFindings};
+import"./json-data-Chfs2Cz5.mjs";import{o as i,j as r,s as n,h as o,t as g,k as u,d as F,w as p,m as l,g as d,f,i as k,u as w,l as A,v as Q}from"./shard-runtime-BpoCV-aM.mjs";import"./shared-DnCokNcE.mjs";import"./platform-8oj7iXQy.mjs";export{i as buildDoTypeImports,r as emitAgentFragments,n as emitAgents,o as emitContainerFragments,g as emitContainers,u as emitPaymentFragments,F as emitQueueFragments,p as emitQueues,l as emitQueuesMetadataFragments,d as emitServiceFragments,f as emitTopicFragments,k as emitWorkflowFragments,w as emitWorkflows,A as emitWorkflowsMetadataFragments,Q as queueAliasFindings};

package/dist/packem_shared/emitFunctions-rjyb7h7k.mjs

@@ -0,0 +1,422 @@
+import{LunoraError as P}from"@lunora/errors";import{L as oe,G as C,d as j,I as M,b as F,r as se,c as ae}from"./shared-DnCokNcE.mjs";import{renderAgentFunctionRegistry as ie,renderSandboxFunctionRegistry as ce}from"./emitApi-CDgIPAG2.mjs";import{b as le,a as de,r as _,c as ue}from"./qualifiers-DEdXn5wP.mjs";import{s as f}from"./dispatch-namespace-DwTjD7BU.mjs";const he=new Set(["any","bigint","boolean","date","id","null","number","storage","string","timestamp"]),D=r=>r.column!==void 0,me=(r,t)=>{switch(r){case"bigint":return`if (typeof ${t} !== "bigint") return DEFER;
+`;case"boolean":return`if (typeof ${t} !== "boolean") return DEFER;
+`;case"date":case"number":case"timestamp":return`if (typeof ${t} !== "number" || !Number.isFinite(${t})) return DEFER;
+`;case"null":return`if (${t} !== null) return DEFER;
+`;default:return`if (typeof ${t} !== "string") return DEFER;
+`}},pe=(r,t)=>r.stringMaxLength===void 0?"":`if (${t}.length > ${String(r.stringMaxLength)}) return DEFER;
+`,ge=(r,t)=>{const n=r.literalValue?.trim();if(!(n===void 0||!oe.test(n)))return{out:t,pre:`if (${t} !== ${n}) return DEFER;
+`}},T=(r,t,n)=>{if(!D(r)&&!(r.unmodelledRefinement||r.sourceText!==void 0)){if(he.has(r.kind))return r.kind==="any"?{out:t,pre:""}:{out:t,pre:me(r.kind,t)+pe(r,t)};switch(r.kind){case"array":return fe(r,t,n);case"literal":return ge(r,t);case"object":return we(r,t,n);default:return}}},fe=(r,t,n)=>{const{inner:o}=r;if(!o)return;const a=n.next(),i=`__arr${String(a)}`,s=`__i${String(a)}`,d=`__e${String(a)}`,u=T(o,d,n);if(!u)return;const c=`if (!Array.isArray(${t})) return DEFER;
+const ${i} = new Array(${t}.length);
+for (let ${s} = 0; ${s} < ${t}.length; ${s}++) {
+const ${d} = ${t}[${s}];
+${u.pre}${i}[${s}] = ${u.out};
+}
+`;return{out:i,pre:c}},ye=(r,t,n,o)=>{const a=JSON.stringify(r);if(t.kind==="optional"){if(t.hasRefinement||t.sourceText!==void 0||D(t))return;const{inner:s}=t;if(!s)return;const d=T(s,n,o);if(!d)return;const u=o.next(),c=`__has${String(u)}`,l=`__val${String(u)}`,g=`let ${c} = false;
+let ${l};
+if (${n} !== undefined) {
+${d.pre}${l} = ${d.out};
+${c} = true;
+}
+`;return{entry:`...(${c} ? { ${a}: ${l} } : {})`,pre:g}}const i=T(t,n,o);if(i)return{entry:`${a}: ${i.out}`,pre:i.pre}},$e=new Set(Object.getOwnPropertyNames(Object.prototype)),U=(r,t,n)=>{let o="";const a=[];for(const i of Object.keys(r)){const s=r[i];if(!s)return;const d=JSON.stringify(i);let u=`${t}[${d}]`;if($e.has(i)){const l=`__f${String(n.next())}`;o+=`const ${l} = Object.hasOwn(${t}, ${d}) ? ${t}[${d}] : undefined;
+`,u=l}const c=ye(i,s,u,n);if(!c)return;o+=c.pre,a.push(c.entry)}return{entries:a.join(", "),pre:o}},J=r=>{const t=`Object.getPrototypeOf(${r})`;return`if (${t} !== Object.prototype && ${t} !== null) return DEFER;
+`},we=(r,t,n)=>{const o=r.shape??{},a=U(o,t,n);if(!a)return;const i=n.next(),s=`__obj${String(i)}`,d=`if (typeof ${t} !== "object" || ${t} === null || Array.isArray(${t})) return DEFER;
+${J(t)}${a.pre}const ${s} = { ${a.entries} };
+`;return{out:s,pre:d}},B=r=>{let t=0;const o=U(r,"source",{next:()=>(t+=1,t)});if(o)return`(source) => {
+if (typeof source !== "object" || source === null || Array.isArray(source)) return DEFER;
+${J("source")}${o.pre}return { ${o.entries} };
+}`},Re=(r,t)=>`lunora_${f(r)}_${String(t)}`,I=r=>JSON.stringify(Object.entries(r).toSorted(([t],[n])=>t.localeCompare(n)).map(([t,n])=>{const o=n.kind==="optional",a=o?n.inner??{kind:"unknown"}:n,i=a.kind==="array"?a.inner?.kind:void 0,s=a.kind==="id"?a.tableName:void 0;return{kind:a.kind,name:t,optional:o,...s===void 0?{}:{table:s},...i===void 0||i==="unknown"?{}:{element:i}}})),H=(r,t,n,o)=>{const a=new Map,i=s=>{a.has(s)||a.set(s,Re(s,a.size))};for(const s of r)i(s.filePath);for(const s of t)i(s.filePath);for(const s of n)i(s.filePath);for(const s of o)i(s.filePath);return a},q=(r,t,n)=>new Set([...r.map(o=>o.filePath),...t.map(o=>o.filePath),...n.map(o=>o.filePath)]),k=r=>`${r}[functionPath]`,Ne=`const callRegistered = async <R>(context: CallerCtx, functionPath: string, args: Record<string, unknown> | undefined): Promise<R> => {
+    const registered = await loadFunction(functionPath);
+
+    if (!registered) {
+        throw new LunoraError("FUNCTION_NOT_FOUND", \`function not registered: \${functionPath}\`);
+    }
+
+    // A mutation is routed through the caller's own \`ctx.runMutation\` rather than
+    // invoked directly, so \`createCaller(ctx).ns.someMutation()\` gets exactly what
+    // \`ctx.runMutation(api.ns.someMutation)\` gets: the BEGIN/COMMIT span (or the
+    // enclosing one, when the caller is already inside a transaction), the jobs it
+    // schedules held until that span commits, and the deferred object deletes
+    // flushed only once it has. Called straight, a mutation composed from an action
+    // or a stream had none of the three — its writes autocommitted one row at a
+    // time and its \`ctx.scheduler\` calls dispatched immediately, so a mid-handler
+    // throw left the earlier writes durable and the job already enqueued.
+    //
+    // The fallback covers a context that is not a shard dispatch (\`runMutation\` is
+    // installed by \`buildCtx\` on every kind but a query's TYPE omits it); there is
+    // no transaction to join in that case, so a direct call is all there is.
+    //
+    // A query is routed through \`ctx.runQuery\` for the same reason: that is what
+    // hands it a query view of a mutation's or action's ctx (no request origin,
+    // query-guarded \`run*\`) instead of the caller's own.
+    if (registered.kind === "mutation" || registered.kind === "query") {
+        const run = (context as { runMutation?: unknown; runQuery?: unknown })[registered.kind === "mutation" ? "runMutation" : "runQuery"];
+
+        if (typeof run === "function") {
+            return (await run.call(context, { __lunoraRef: functionPath }, args ?? {})) as R;
+        }
+    }
+
+    return (await registered.handler(context, args ?? {})) as R;
+};`,be=(r,t,n=[],o=[],a=!1)=>{const i=H(r,t,n,o),s=q(t,n,o),d=[...i.entries()].filter(([e])=>!a||s.has(e)?!0:r.some(m=>m.filePath===e&&m.channel?.kind==="room")).map(([e,m])=>{if(!M.test(e))throw new P("INTERNAL",`@lunora/codegen: refusing to emit import for unsafe file path: ${JSON.stringify(e)}`);return`import ${a&&!s.has(e)?"type ":""}* as ${m} from "../${e}.js";`}).join(`
+`),u=r.map(e=>!a||s.has(e.filePath)?`    "${f(e.filePath)}:${e.exportName}": ${i.get(e.filePath)??""}.${e.exportName} as unknown as RegisteredLunoraFunction,`:`    "${f(e.filePath)}:${e.exportName}": { args: {}, handler: unloadedFunctionHandler, ...${JSON.stringify({argumentDescriptors:JSON.parse(I(e.args)),kind:e.kind,...e.channel?{channel:e.channel}:{},...e.expose?{expose:e.expose}:{},...e.lifecycle?{lifecycle:e.lifecycle}:{},...e.visibility?{visibility:e.visibility}:{},...e.x402?.price===void 0?{}:{x402:{price:e.x402.price}}})} } satisfies RegisteredLunoraFunction & Pick<FunctionManifestEntry, "argumentDescriptors" | "channel" | "expose">,`).join(`
+`),c=t.map(e=>`    ${JSON.stringify(e.id)}: ${i.get(e.filePath)??""}.${e.exportName} as unknown as RegisteredDataMigration,`).join(`
+`),l=n.map(e=>`    "${f(e.filePath)}:${e.exportName}": ${i.get(e.filePath)??""}.${e.exportName} as unknown as RegisteredLunoraFunction,`).join(`
+`),g=o.map(e=>`    "${e.exportName}": ${i.get(e.filePath)??""}.${e.exportName} as unknown as RegisteredShape,`).join(`
+`),y=n.map(e=>`${f(e.filePath)}:${e.exportName}`),$=[u,l].filter(e=>e.length>0).join(`
+`),v=r.filter(e=>!a||s.has(e.filePath)).map(e=>{if(e.lifecycle||Object.keys(e.args).length===0)return;const m=B(e.args);return m===void 0?void 0:`installCompiledValidatorMap(${i.get(e.filePath)??""}.${e.exportName}.args, ${m});`}).filter(e=>e!==void 0).join(`
+`),O=r.filter(e=>e.channel?.kind==="room").map(e=>`    ${JSON.stringify(e.channel?.name??"")}: RoomMessageOf<typeof ${i.get(e.filePath)??""}[${JSON.stringify(e.exportName)}]>;`).join(`
+`),N=[...r.map(e=>({args:e.args,definition:e,path:`${f(e.filePath)}:${e.exportName}`})),...n.map(e=>({args:e.args,definition:{...e,expose:void 0,kind:"mutation",lifecycle:void 0,visibility:void 0,x402:void 0},path:`${f(e.filePath)}:${e.exportName}`}))],x=a?N.filter(({definition:e})=>!s.has(e.filePath)):[];for(const{definition:e}of N)if(a&&e.x402&&e.x402.price===void 0)throw new P("INTERNAL",`@lunora/codegen: lazy function registry needs a literal \`.x402({ price })\` value in ${e.filePath}:${e.exportName}`);const b=a?x.map(({definition:e,path:m})=>{const R=i.get(e.filePath)??"",S="channel"in e?e.channel:void 0,A={argumentDescriptors:JSON.parse(I(e.args)),exportName:e.exportName,kind:e.kind,moduleId:R,...S?{channel:S}:{},...e.expose?{expose:e.expose}:{},...e.lifecycle?{lifecycle:e.lifecycle}:{},...e.visibility?{visibility:e.visibility}:{},...e.x402?.price===void 0?{}:{x402:{price:e.x402.price}}};return`    ${JSON.stringify(m)}: ${JSON.stringify(A)},`}).join(`
+`):"",h=[...new Set(x.map(({definition:e})=>e.filePath))],w=a?h.map(e=>{if(!M.test(e))throw new P("INTERNAL",`@lunora/codegen: refusing to emit import for unsafe file path: ${JSON.stringify(e)}`);const m=i.get(e)??"";return`    ${JSON.stringify(m)}: () => import(${JSON.stringify(`./fn/${m}.js`)}),`}).join(`
+`):"";return{dispatchBody:$.length>0?`
+${$}
+`:"",importBlock:d.length>0?`${d}
+
+`:"",installBlock:v,manifestBody:b.length>0?`
+${b}
+`:"",migrationBody:c.length>0?`
+${c}
+`:"",moduleLoaders:w.length>0?`
+${w}
+`:"",mutatorPaths:y,roomMessagesBody:O,shapeBody:g.length>0?`
+${g}
+`:""}},ke=r=>{const t=F(r,o=>{const a=_(se(o.args),o.filePath),i=a==="{}"?"?":"",s=_(ue(o),o.filePath);return o.kind==="stream"?`${o.exportName}: (args${i}: ${a}) => Promise<AsyncIterable<${s}>>;`:`${o.exportName}: (args${i}: ${a}) => Promise<${s}>;`},"type");return{implementation:F(r,o=>`${ae(o.exportName)}: (args) => callRegistered(context, "${f(o.filePath)}:${o.exportName}", args),`,"value"),types:t}},ve=r=>{const t={connect:[],disconnect:[],init:[],reactor:[],whisper:[]};for(const n of r)n.lifecycle&&t[n.lifecycle].push(`${f(n.filePath)}:${n.exportName}`);return t},Oe=(r,t,n)=>r?{channelField:`    /**
+     * Set on a \`defineRoom\` registration: the room's name (without the \`room:\`
+     * topic prefix). The generated \`LUNORA_ROOMS\` map keys it on the room's
+     * \`room:<name>\` whisper topic so the ShardDO resolves a room topic to this
+     * path.
+     */
+    channel?: { readonly kind: "room"; readonly name: string };
+`,messagesBlock:`
+/**
+ * The message type each \`defineRoom\` carries, read off the room's own registration. The generated \`rooms\` references type a client's \`connectRoom\` from it.
+ */
+export type LunoraRoomMessages = {
+${n}
+};
+`,typeImport:`import type { RoomMessageOf } from "${t}";
+`}:{channelField:"",messagesBlock:"",typeImport:""},xe=(r,t,n)=>r?t?`
+/**
+ * Room routes are static metadata so building the worker never evaluates user handlers.
+ */
+export const LUNORA_ROOMS: Readonly<Record<string, string>> = (() => {
+    const registry: Record<string, string> = {};
+    const owners = new Map<string, string>();
+
+    for (const { owner, path, topic } of [
+${n.filter(o=>o.channel?.kind==="room").map(o=>`        { owner: ${JSON.stringify(o.filePath)}, path: ${JSON.stringify(`${f(o.filePath)}:${o.exportName}`)}, topic: ${JSON.stringify(`room:${o.channel?.name??""}`)} },`).join(`
+`)}
+    ]) {
+        const prior = owners.get(topic);
+
+        if (prior !== undefined && prior !== owner) {
+            throw new Error(\`two defineRoom registrations are named "\${topic.slice("room:".length)}"; room names must be unique\`);
+        }
+
+        if (prior === undefined) {
+            owners.set(topic, owner);
+            registry[topic] = path;
+        }
+    }
+
+    return registry;
+})();
+`:`
+/**
+ * Room registry: the whisper topic of each \`defineRoom\` registration → its
+ * function path. The generated ShardDO's \`roomHandlerPath\` override resolves a
+ * room topic through this map so a room's typed \`onJoin\`/\`onMessage\`/\`onLeave\`
+ * dispatch server-side, reusing the whisper channel for membership and fan-out.
+ * Two registrations under one name throw at module load: the map would otherwise
+ * silently keep whichever came last.
+ */
+export const LUNORA_ROOMS: Readonly<Record<string, string>> = (() => {
+    const registry: Record<string, string> = {};
+    const owners = new Map<string, unknown>();
+
+    for (const [path, fn] of Object.entries(LUNORA_FUNCTIONS)) {
+        if (fn.channel?.kind !== "room") {
+            continue;
+        }
+
+        const topic = \`room:\${fn.channel.name}\`;
+        const owner = owners.get(topic);
+
+        // The same registration exported under two names (an alias) is one room.
+        if (owner !== undefined && owner !== fn) {
+            throw new Error(\`two defineRoom registrations are named "\${fn.channel.name}"; room names must be unique\`);
+        }
+
+        if (owner === undefined) {
+            owners.set(topic, fn);
+            registry[topic] = path;
+        }
+    }
+
+    return registry;
+})();
+`:"",Se=(r,t)=>{const n=ke(r),o=n.types?`
+${n.types}
+`:"",a=n.implementation?`
+${n.implementation}
+`:"",i=de(n.types),s=i.length>0?`import type { ${i.join(", ")} } from "./dataModel.js";
+`:"",d=r.length>0?"context":"_context";let u="";if(r.length>0){let c=Ne;t||(c=c.replace("await loadFunction(functionPath)",k("LUNORA_FUNCTIONS"))),u=`${c}
+
+`}return{callRegisteredHelper:u,dataModelImport:s,implementation:a,parameter:d,types:o}},Ee=r=>{const{agents:t=[],functions:n,lazyFunctions:o=!1,migrations:a=[],mutators:i=[],shapes:s=[],useUmbrella:d=!1,usesSandbox:u=!1}=r,c=j(d),{dispatchBody:l,importBlock:g,installBlock:y,manifestBody:$,migrationBody:v,moduleLoaders:O,mutatorPaths:N,roomMessagesBody:x,shapeBody:b}=be(n,a,i,s,o),h=ie(t,n),w=ce(u,n),e=[h.lines,w.lines].filter(p=>p.length>0).join(`
+`);let m=l;e.length>0&&(m=l.length>0?`${l.trimEnd()}
+${e}
+`:`
+${e}
+`);const R=ve(n),S=o?"await loadFunction(functionPath)":k("LUNORA_FUNCTIONS"),A=o?`    if (${k("LUNORA_FUNCTION_MANIFEST")}?.visibility === "internal") {
+        throw new LunoraError("FUNCTION_NOT_FOUND", \`function not registered: \${functionPath}\`);
+    }
+
+`:"",Q=s.length>0?`import type { RegisteredShape } from "${c.server}";
+`:"",E=n.some(p=>p.channel?.kind==="room"),L=Oe(E,c.server,x),G=s.length>0?`
+/**
+ * Replication-shape registry — one entry per \`defineShape\` in \`lunora/shapes.ts\`.
+ * The generated ShardDO's \`resolveShape\` override looks a shape up by name and
+ * evaluates its trusted \`compileWhere(ctx, args)\` to authorize + scope a
+ * \`shape_subscribe\` (reads-as-permissions).
+ */
+export const LUNORA_SHAPES: Record<string, RegisteredShape> = {${b}};
+`:"",V=N.length>0?`
+/**
+ * Custom-mutator function paths — the \`LUNORA_FUNCTIONS\` keys the generated
+ * ShardDO's \`isCustomMutator\` override routes through the client-watermark push
+ * protocol (\`x-lunora-client-id\`/\`x-lunora-client-seq\` ordering).
+ */
+export const LUNORA_MUTATOR_PATHS: ReadonlySet<string> = new Set([${N.map(p=>JSON.stringify(p)).join(", ")}]);
+`:"",z=xe(E,o,n),W=y.length>0?`import { DEFER_VALIDATION as DEFER, installCompiledValidatorMap } from "${c.values}";
+`:"",K=y.length>0?`
+/**
+ * AOT-compiled argument validators (Worker-safe, no \`eval\`). Each is installed
+ * onto its function's live \`.args\` object and consulted by the interpreted
+ * parser as a zero-allocation fast path; anything it can't model is deferred.
+ */
+${y}
+`:"",Y=Se(n,o),{callRegisteredHelper:X,dataModelImport:Z,implementation:ee,parameter:te,types:re}=Y,ne=o?`
+export interface FunctionManifestEntry {
+    argumentDescriptors: ReadonlyArray<{ element?: string; kind: string; name: string; optional: boolean; table?: string }>;
+    channel?: { kind: "room"; name: string };
+    exportName: string;
+    expose?: { cache?: { credentialHeaders?: ReadonlyArray<string>; maxAge?: number; scope?: "private" | "public"; staleWhileRevalidate?: number; tag?: string; vary?: string }; rest?: boolean };
+    kind: "action" | "mutation" | "query" | "stream";
+    lifecycle?: "connect" | "disconnect" | "init" | "reactor" | "whisper";
+    moduleId: string;
+    visibility?: "internal" | "public";
+    x402?: { readonly price: number | string };
+}
+
+/** Static, codegen-derived facts. Request gates can inspect these without evaluating a user module. */
+export const LUNORA_FUNCTION_MANIFEST: Readonly<Record<string, FunctionManifestEntry>> = {${$}};
+
+const MODULE_LOADERS: Record<string, () => Promise<Record<string, unknown>>> = {${O}};
+const loadedModules = new Map<string, Promise<Record<string, unknown>>>();
+const resolvedModules = new Map<string, Record<string, unknown>>();
+const unloadedFunctionHandler = (): never => {
+    throw new Error("a lazy function was invoked before it was prepared");
+};
+
+/** Reuse an evaluated module synchronously, so dispatch does not yield after restoring request scope. */
+export const getLoadedFunction = (functionPath: string): RegisteredLunoraFunction | undefined => {
+    const registered = ${k("LUNORA_FUNCTIONS")};
+    const manifest = ${k("LUNORA_FUNCTION_MANIFEST")};
+
+    if (!registered || !manifest) {
+        return registered;
+    }
+
+    const module = resolvedModules.get(manifest.moduleId);
+
+    if (module === undefined) {
+        return undefined;
+    }
+
+    const loaded = module[manifest.exportName];
+
+    if (typeof loaded !== "object" || loaded === null) {
+        throw new Error(\`lazy module export for "\${functionPath}" is not a registered function\`);
+    }
+
+    Object.assign(registered, loaded);
+
+    return registered;
+};
+
+/** Load one function's owning module once per isolate, then merge its live builder result into the registry entry. */
+export const loadFunction = async (functionPath: string): Promise<RegisteredLunoraFunction | undefined> => {
+    const registered = getLoadedFunction(functionPath);
+    const manifest = ${k("LUNORA_FUNCTION_MANIFEST")};
+
+    if (registered || !manifest) {
+        return registered;
+    }
+
+    let pending = loadedModules.get(manifest.moduleId);
+
+    if (pending === undefined) {
+        const loader = MODULE_LOADERS[manifest.moduleId];
+
+        if (loader === undefined) {
+            throw new Error(\`no lazy module loader registered for "\${functionPath}"\`);
+        }
+
+        pending = loader();
+        loadedModules.set(manifest.moduleId, pending);
+    }
+
+    let module: Record<string, unknown>;
+
+    try {
+        module = await pending;
+    } catch (error: unknown) {
+        if (loadedModules.get(manifest.moduleId) === pending) {
+            loadedModules.delete(manifest.moduleId);
+        }
+
+        throw error;
+    }
+
+    resolvedModules.set(manifest.moduleId, module);
+
+    return getLoadedFunction(functionPath);
+};
+`:"";return le(`${C}${g}${h.importLine}${w.importLine}${W}${Q}${L.typeImport}import { LunoraError } from "${c.server}";
+import type { ActionCtx, MutationCtx, QueryCtx } from "./server.js";
+${Z}
+/**
+ * Single registered function, narrowed to the shape \`handleRpc\` needs.
+ * The real argument validators / return types are checked elsewhere — at
+ * the dispatch site we erase to \`unknown\` so a single map can host every
+ * registered function.
+ */
+export interface RegisteredLunoraFunction {
+    kind: "action" | "mutation" | "query" | "stream";
+    args: Record<string, unknown>;
+    /**
+     * Present on a \`"stream"\` declared \`durable\`: its run is persisted and
+     * survives the socket that opened it. Absent on every other kind, and on an
+     * ephemeral stream.
+     */
+    durable?: { ttlMs?: number };
+    /**
+     * For \`"action" | "mutation" | "query"\` the handler is awaited and its result returned.
+     * For \`"stream"\` the handler returns an \`AsyncIterable\` synchronously and takes an
+     * \`AbortSignal\` as a third argument — the runtime drives it frame-by-frame.
+     */
+    handler: ((context: unknown, args: Record<string, unknown>) => Promise<unknown> | unknown) | ((context: unknown, args: Record<string, unknown>, signal?: AbortSignal) => AsyncIterable<unknown>);
+    /**
+     * The lifecycle moment a hook fires on, when this registration came from
+     * \`onConnect\`/\`onDisconnect\`/\`onShardInit\`/\`onQueryChange\`/\`onWhisper\`.
+     * Read at dispatch to decide whether the function runs system-trusted:
+     * \`init\` and \`reactor\` have no caller identity, so RLS has no user to scope
+     * to. \`whisper\` does have one — it runs under the asking socket's identity.
+     */
+    lifecycle?: "connect" | "disconnect" | "init" | "reactor" | "whisper";
+${L.channelField}    /**
+     * Hoisted by the builder when the \`.use()\` chain carries a step with a
+     * per-dispatch effect — \`rateLimit(...)\` consuming budget, a single-use
+     * captcha token being burned. Read by \`isCacheableQuery\`: the chain runs
+     * inside the dispatch callback, and a reactive-cache HIT skips that
+     * callback, so such a query must never be memoized.
+     */
+    perDispatch?: boolean;
+    /** \`"internal"\` functions are rejected on the external RPC path; absence === public. */
+    visibility?: "internal" | "public";
+    /**
+     * \`.x402({ price })\` tag on a paid public procedure. The origin worker
+     * paywalls it; the shard refuses to subscribe it (\`isPaidFunction\`).
+     */
+    x402?: { readonly price: number | string };
+}
+${h.prelude}${w.prelude}${ne}
+/**
+ * Static dispatch table. The key matches the \`__lunoraRef\` the client
+ * emits (\`api[namespace][fn].__lunoraRef === "namespace:fn"\`).
+ */
+export const LUNORA_FUNCTIONS: Record<string, RegisteredLunoraFunction> = {${m}};
+${K}${G}${V}${z}${L.messagesBlock}
+/**
+ * Lifecycle manifest: the function paths the generated ShardDO dispatches when a
+ * client's WebSocket connects (\`connect\`) or disconnects (\`disconnect\`), once
+ * per Durable Object instance before any handler runs (\`init\`), after a
+ * write flush when a watched read's result changed (\`reactor\`), and before a
+ * socket joins or broadcasts to a whisper topic (\`whisper\`). Each path also
+ * resolves through {@link LUNORA_FUNCTIONS}. The socket-scoped moments run under
+ * the socket's verified identity; \`init\` and \`reactor\` have no caller, so they
+ * run anonymous — all via system dispatch.
+ */
+export const LUNORA_LIFECYCLE_HOOKS: {
+    connect: readonly string[];
+    disconnect: readonly string[];
+    init: readonly string[];
+    reactor: readonly string[];
+    whisper: readonly string[];
+} = {
+    connect: [${R.connect.map(p=>JSON.stringify(p)).join(", ")}],
+    disconnect: [${R.disconnect.map(p=>JSON.stringify(p)).join(", ")}],
+    init: [${R.init.map(p=>JSON.stringify(p)).join(", ")}],
+    reactor: [${R.reactor.map(p=>JSON.stringify(p)).join(", ")}],
+    whisper: [${R.whisper.map(p=>JSON.stringify(p)).join(", ")}],
+};
+
+/**
+ * Resolve and invoke a registered function from an external caller. Throws a
+ * LunoraError-shaped object (404) when the path is unknown — the runtime's
+ * structural error mapper turns that into the right HTTP status. Internal
+ * functions are treated as not-found so their existence never leaks to clients.
+ */
+export const dispatchLunoraFunction = async (functionPath: string, context: unknown, args: Record<string, unknown>): Promise<unknown> => {
+${A}    const registered = ${S};
+
+    if (!registered || registered.visibility === "internal") {
+        throw new LunoraError("FUNCTION_NOT_FOUND", \`function not registered: \${functionPath}\`);
+    }
+
+    return registered.handler(context, args);
+};
+
+/**
+ * A handler context accepted by {@link createCaller}. The runtime context the
+ * shard DO builds is uniform across kinds, so any handler's \`ctx\` works here.
+ */
+export type CallerCtx = ActionCtx | MutationCtx | QueryCtx;
+
+/**
+ * Typed, in-process server-to-server caller. Every registered function — public
+ * *and* internal — is reachable; each call dispatches against the same shard
+ * with the supplied \`context\`, exactly like \`ctx.runQuery\`/\`runMutation\`/
+ * \`runAction\` but without re-stating the function path.
+ */
+export interface Caller {${re}}
+
+${X}/** Build a {@link Caller} bound to \`context\` (typically a handler's \`ctx\`). */
+export const createCaller = (${te}: CallerCtx): Caller => ({${ee}});
+
+/**
+ * Single registered data migration, narrowed to the shape the per-shard runner
+ * consumes. \`up\`/\`down\` are erased to a structural transform; the authoring
+ * validation lives in \`defineMigration\`.
+ */
+export interface RegisteredDataMigration {
+    batchSize?: number;
+    down?: (document: Record<string, unknown>) => Record<string, unknown> | undefined;
+    id: string;
+    table: string;
+    up: (document: Record<string, unknown>) => Record<string, unknown> | undefined;
+}
+
+/**
+ * Registry of online data migrations keyed by \`defineMigration\`'s \`id\`. The
+ * shard DO's admin RPC and the CLI resolve migrations to run through this map.
+ */
+export const LUNORA_MIGRATIONS: Record<string, RegisteredDataMigration> = {${v}};
+`,d)},Fe=r=>{if(r.lazyFunctions!==!0)return{};const{functions:t}=r,n=r.migrations??[],o=r.mutators??[],a=r.shapes??[],i=H(t,n,o,a),s=q(n,o,a),d=[...new Set(t.filter(l=>!s.has(l.filePath)).map(l=>l.filePath))],u=j(r.useUmbrella??!1),c={};for(const l of d){if(!M.test(l))throw new P("INTERNAL",`@lunora/codegen: refusing to emit import for unsafe file path: ${JSON.stringify(l)}`);const g=i.get(l)??"",y=`../../${l}.js`,$=t.filter(h=>h.filePath===l&&!h.lifecycle&&Object.keys(h.args).length>0).flatMap(h=>{const w=B(h.args);return w===void 0?[]:[`installCompiledValidatorMap(${g}.${h.exportName}.args, ${w});`]}),v=$.length>0?`import { DEFER_VALIDATION as DEFER, installCompiledValidatorMap } from "${u.values}";
+`:"",O=$.length>0?`import * as ${g} from "${y}";
+`:"",N=$.length>0?`
+/** Install the precompiled argument parsers before the module is dispatched. */
+${$.join(`
+`)}
+`:"",b=t.some(h=>h.filePath===l&&h.exportName==="default")||n.some(h=>h.filePath===l&&h.exportName==="default")?`export { default } from "${y}";
+`:"";c[`fn/${g}.ts`]=`${C}${v}${O}${N}export * from "${y}";
+${b}`}return c};export{Ee as emitFunctions,Fe as emitLazyFunctionModules};

package/dist/packem_shared/{emitShard-Ddgmq6De.mjs → emitShard-D3Po46nf.mjs}

@@ -1 +1 @@
-import"./SCHEMA_SNAPSHOT_VERSION-C0oHwiJZ.mjs";import"./isD1GlobalTable-udvHAAzD.mjs";import"./json-data-Chfs2Cz5.mjs";import{e as d}from"./shard-DYYhXxEG.mjs";import"./shard-runtime-BQ6ZNigW.mjs";import"./shared-DnCokNcE.mjs";import"./platform-8oj7iXQy.mjs";import"./schema-BgM8A3XV.mjs";export{d as default};
+import"./SCHEMA_SNAPSHOT_VERSION-C0oHwiJZ.mjs";import"./isD1GlobalTable-udvHAAzD.mjs";import"./json-data-Chfs2Cz5.mjs";import{e as d}from"./shard-CsOnD3Na.mjs";import"./shard-runtime-BpoCV-aM.mjs";import"./shared-DnCokNcE.mjs";import"./platform-8oj7iXQy.mjs";import"./schema-BgM8A3XV.mjs";export{d as default};

package/dist/packem_shared/{exported-procedure-chains-DAl7xBBx.mjs → exported-procedure-chains-BNBUkXui.mjs}

@@ -1 +1 @@
-import{Node as s}from"ts-morph";import{b as t,d as c}from"./attribution-hVBriwzy.mjs";import{c as n}from"./classify-procedure-call-CcgP-9I0.mjs";const m=a=>{const i=[];for(const e of t(a)){const r=e.getInitializer(),o=r&&s.isCallExpression(r)?n(r):void 0;o?.receiver&&i.push({name:c(e)??e.getName(),receiver:o.receiver})}return i};export{m as e};
+import{Node as s}from"ts-morph";import{b as t,d as c}from"./attribution-hVBriwzy.mjs";import{c as n}from"./classify-procedure-call-DVxdUhZt.mjs";const m=a=>{const i=[];for(const e of t(a)){const r=e.getInitializer(),o=r&&s.isCallExpression(r)?n(r):void 0;o?.receiver&&i.push({name:c(e)??e.getName(),receiver:o.receiver})}return i};export{m as e};

package/dist/packem_shared/{index-DvmKcoFV.mjs → index-JnqBWRYO.mjs}

@@ -1 +1 @@
-import{Node as r}from"ts-morph";import{listLunoraSourceFiles as u,lunoraRelativePath as f}from"./isTestPath-B81lOULB.mjs";import{b as m,d as p}from"./attribution-hVBriwzy.mjs";import{t as d}from"./database-calls-BnVUlTx_.mjs";import{w as g,c as h}from"./classify-procedure-call-CcgP-9I0.mjs";import{a as k}from"./project-config-file-BV7RR-l6.mjs";const l=e=>{if(!(!r.isPropertyAssignment(e)&&!r.isShorthandPropertyAssignment(e)&&!r.isMethodDeclaration(e)&&!r.isGetAccessorDeclaration(e)))return k(e)},v=e=>g(e,"use","mask"),D=e=>{if(r.isPropertyAssignment(e)){const s=e.getInitializer();if(s&&r.isStringLiteral(s)){const t=s.getLiteralText();if(t==="redact"||t==="hash")return t}}return"custom"},P=e=>{const s=e.getArguments()[0];if(!s||!r.isObjectLiteralExpression(s))return[];const t=[];for(const i of s.getProperties()){const o=l(i);if(o===void 0||!r.isPropertyAssignment(i))continue;const n=i.getInitializer();if(!(!n||!r.isObjectLiteralExpression(n)))for(const a of n.getProperties()){const c=l(a);c!==void 0&&t.push({column:c,table:o})}}return t},y=e=>{const s=v(e);return{maskColumns:s.flatMap(t=>P(t)),usesMask:s.length>0}},C=new Set(["explain","findFirst","findFirstOrThrow","findMany","get","query"]),M=new Set(["delete","insert","patch","replace"]),x=(e,s)=>{if(!r.isVariableDeclaration(e))return;const t=e.getInitializer();if(!t||!r.isCallExpression(t))return;const i=h(t);if(!i)return;const o=i.receiver?y(i.receiver):{maskColumns:[],usesMask:!1},{tablesRead:n,tablesWritten:a}=d(e,C,M);return{exportName:p(e)??e.getName(),file:s,maskColumns:o.maskColumns,tablesRead:n,tablesWritten:a,usesMask:o.usesMask,visibility:i.visibility}},E=(e,s)=>{const t=[];for(const i of u(s)){const o=e.getSourceFile(i)??e.addSourceFileAtPath(i),n=f(s,i);for(const a of m(o)){const c=x(a,n);c&&t.push(c)}}return t};export{l as a,E as d,v as m,D as s};
+import{Node as r}from"ts-morph";import{listLunoraSourceFiles as u,lunoraRelativePath as f}from"./isTestPath-B81lOULB.mjs";import{b as m,d as p}from"./attribution-hVBriwzy.mjs";import{t as d}from"./database-calls-BKozZUEW.mjs";import{w as g,c as h}from"./classify-procedure-call-DVxdUhZt.mjs";import{a as k}from"./project-config-file-BV7RR-l6.mjs";const l=e=>{if(!(!r.isPropertyAssignment(e)&&!r.isShorthandPropertyAssignment(e)&&!r.isMethodDeclaration(e)&&!r.isGetAccessorDeclaration(e)))return k(e)},v=e=>g(e,"use","mask"),D=e=>{if(r.isPropertyAssignment(e)){const s=e.getInitializer();if(s&&r.isStringLiteral(s)){const t=s.getLiteralText();if(t==="redact"||t==="hash")return t}}return"custom"},P=e=>{const s=e.getArguments()[0];if(!s||!r.isObjectLiteralExpression(s))return[];const t=[];for(const i of s.getProperties()){const o=l(i);if(o===void 0||!r.isPropertyAssignment(i))continue;const n=i.getInitializer();if(!(!n||!r.isObjectLiteralExpression(n)))for(const a of n.getProperties()){const c=l(a);c!==void 0&&t.push({column:c,table:o})}}return t},y=e=>{const s=v(e);return{maskColumns:s.flatMap(t=>P(t)),usesMask:s.length>0}},C=new Set(["explain","findFirst","findFirstOrThrow","findMany","get","query"]),M=new Set(["delete","insert","patch","replace"]),x=(e,s)=>{if(!r.isVariableDeclaration(e))return;const t=e.getInitializer();if(!t||!r.isCallExpression(t))return;const i=h(t);if(!i)return;const o=i.receiver?y(i.receiver):{maskColumns:[],usesMask:!1},{tablesRead:n,tablesWritten:a}=d(e,C,M);return{exportName:p(e)??e.getName(),file:s,maskColumns:o.maskColumns,tablesRead:n,tablesWritten:a,usesMask:o.usesMask,visibility:i.visibility}},E=(e,s)=>{const t=[];for(const i of u(s)){const o=e.getSourceFile(i)??e.addSourceFileAtPath(i),n=f(s,i);for(const a of m(o)){const c=x(a,n);c&&t.push(c)}}return t};export{l as a,E as d,v as m,D as s};