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

package/dist/packem_shared/emitFunctions-amc10WSc.mjs

@@ -1,291 +0,0 @@
-import{LunoraError as Q}from"@lunora/errors";import{L as G,G as z,I as V,d as W,b as A,r as K,c as Y}from"./shared-DnCokNcE.mjs";import{renderAgentFunctionRegistry as X,renderSandboxFunctionRegistry as Z}from"./emitApi-CDgIPAG2.mjs";import{a as ee,b as te,r as _,c as ne}from"./qualifiers-DEdXn5wP.mjs";import{s as g}from"./dispatch-namespace-DwTjD7BU.mjs";const re=new Set(["any","bigint","boolean","date","id","null","number","storage","string","timestamp"]),L=n=>n.column!==void 0,oe=(n,e)=>{switch(n){case"bigint":return`if (typeof ${e} !== "bigint") return DEFER;
-`;case"boolean":return`if (typeof ${e} !== "boolean") return DEFER;
-`;case"date":case"number":case"timestamp":return`if (typeof ${e} !== "number" || !Number.isFinite(${e})) return DEFER;
-`;case"null":return`if (${e} !== null) return DEFER;
-`;default:return`if (typeof ${e} !== "string") return DEFER;
-`}},se=(n,e)=>n.stringMaxLength===void 0?"":`if (${e}.length > ${String(n.stringMaxLength)}) return DEFER;
-`,ae=(n,e)=>{const r=n.literalValue?.trim();if(!(r===void 0||!G.test(r)))return{out:e,pre:`if (${e} !== ${r}) return DEFER;
-`}},N=(n,e,r)=>{if(!L(n)&&!(n.unmodelledRefinement||n.sourceText!==void 0)){if(re.has(n.kind))return n.kind==="any"?{out:e,pre:""}:{out:e,pre:oe(n.kind,e)+se(n,e)};switch(n.kind){case"array":return ie(n,e,r);case"literal":return ae(n,e);case"object":return ue(n,e,r);default:return}}},ie=(n,e,r)=>{const{inner:o}=n;if(!o)return;const s=r.next(),a=`__arr${String(s)}`,i=`__i${String(s)}`,c=`__e${String(s)}`,u=N(o,c,r);if(!u)return;const l=`if (!Array.isArray(${e})) return DEFER;
-const ${a} = new Array(${e}.length);
-for (let ${i} = 0; ${i} < ${e}.length; ${i}++) {
-const ${c} = ${e}[${i}];
-${u.pre}${a}[${i}] = ${u.out};
-}
-`;return{out:a,pre:l}},ce=(n,e,r,o)=>{const s=JSON.stringify(n);if(e.kind==="optional"){if(e.hasRefinement||e.sourceText!==void 0||L(e))return;const{inner:i}=e;if(!i)return;const c=N(i,r,o);if(!c)return;const u=o.next(),l=`__has${String(u)}`,h=`__val${String(u)}`,f=`let ${l} = false;
-let ${h};
-if (${r} !== undefined) {
-${c.pre}${h} = ${c.out};
-${l} = true;
-}
-`;return{entry:`...(${l} ? { ${s}: ${h} } : {})`,pre:f}}const a=N(e,r,o);if(a)return{entry:`${s}: ${a.out}`,pre:a.pre}},le=new Set(Object.getOwnPropertyNames(Object.prototype)),P=(n,e,r)=>{let o="";const s=[];for(const a of Object.keys(n)){const i=n[a];if(!i)return;const c=JSON.stringify(a);let u=`${e}[${c}]`;if(le.has(a)){const h=`__f${String(r.next())}`;o+=`const ${h} = Object.hasOwn(${e}, ${c}) ? ${e}[${c}] : undefined;
-`,u=h}const l=ce(a,i,u,r);if(!l)return;o+=l.pre,s.push(l.entry)}return{entries:s.join(", "),pre:o}},M=n=>{const e=`Object.getPrototypeOf(${n})`;return`if (${e} !== Object.prototype && ${e} !== null) return DEFER;
-`},ue=(n,e,r)=>{const o=n.shape??{},s=P(o,e,r);if(!s)return;const a=r.next(),i=`__obj${String(a)}`,c=`if (typeof ${e} !== "object" || ${e} === null || Array.isArray(${e})) return DEFER;
-${M(e)}${s.pre}const ${i} = { ${s.entries} };
-`;return{out:i,pre:c}},de=n=>{let e=0;const o=P(n,"source",{next:()=>(e+=1,e)});if(o)return`(source) => {
-if (typeof source !== "object" || source === null || Array.isArray(source)) return DEFER;
-${M("source")}${o.pre}return { ${o.entries} };
-}`},he=(n,e)=>`lunora_${g(n)}_${String(e)}`,me=`const callRegistered = async <R>(context: CallerCtx, functionPath: string, args: Record<string, unknown> | undefined): Promise<R> => {
-    const registered = LUNORA_FUNCTIONS[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;
-};`,pe=(n,e,r=[],o=[])=>{const s=new Map,a=t=>{s.has(t)||s.set(t,he(t,s.size))};for(const t of n)a(t.filePath);for(const t of e)a(t.filePath);for(const t of r)a(t.filePath);for(const t of o)a(t.filePath);const i=[...s.entries()].map(([t,p])=>{if(!V.test(t))throw new Q("INTERNAL",`@lunora/codegen: refusing to emit import for unsafe file path: ${JSON.stringify(t)}`);return`import * as ${p} from "../${t}.js";`}).join(`
-`),c=n.map(t=>`    "${g(t.filePath)}:${t.exportName}": ${s.get(t.filePath)??""}.${t.exportName} as unknown as RegisteredLunoraFunction,`).join(`
-`),u=e.map(t=>`    ${JSON.stringify(t.id)}: ${s.get(t.filePath)??""}.${t.exportName} as unknown as RegisteredDataMigration,`).join(`
-`),l=r.map(t=>`    "${g(t.filePath)}:${t.exportName}": ${s.get(t.filePath)??""}.${t.exportName} as unknown as RegisteredLunoraFunction,`).join(`
-`),h=o.map(t=>`    "${t.exportName}": ${s.get(t.filePath)??""}.${t.exportName} as unknown as RegisteredShape,`).join(`
-`),f=r.map(t=>`${g(t.filePath)}:${t.exportName}`),m=[c,l].filter(t=>t.length>0).join(`
-`),b=n.map(t=>{if(t.lifecycle||Object.keys(t.args).length===0)return;const p=de(t.args);return p===void 0?void 0:`installCompiledValidatorMap(${s.get(t.filePath)??""}.${t.exportName}.args, ${p});`}).filter(t=>t!==void 0).join(`
-`),R=n.filter(t=>t.channel?.kind==="room").map(t=>`    ${JSON.stringify(t.channel?.name??"")}: RoomMessageOf<typeof ${s.get(t.filePath)??""}[${JSON.stringify(t.exportName)}]>;`).join(`
-`);return{dispatchBody:m.length>0?`
-${m}
-`:"",importBlock:i.length>0?`${i}
-
-`:"",installBlock:b,migrationBody:u.length>0?`
-${u}
-`:"",mutatorPaths:f,roomMessagesBody:R,shapeBody:h.length>0?`
-${h}
-`:""}},ge=n=>{const e=A(n,o=>{const s=_(K(o.args),o.filePath),a=s==="{}"?"?":"",i=_(ne(o),o.filePath);return o.kind==="stream"?`${o.exportName}: (args${a}: ${s}) => Promise<AsyncIterable<${i}>>;`:`${o.exportName}: (args${a}: ${s}) => Promise<${i}>;`},"type");return{implementation:A(n,o=>`${Y(o.exportName)}: (args) => callRegistered(context, "${g(o.filePath)}:${o.exportName}", args),`,"value"),types:e}},fe=n=>{const e={connect:[],disconnect:[],init:[],reactor:[],whisper:[]};for(const r of n)r.lifecycle&&e[r.lifecycle].push(`${g(r.filePath)}:${r.exportName}`);return e},ye=(n,e,r)=>n?{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 = {
-${r}
-};
-`,typeImport:`import type { RoomMessageOf } from "${e}";
-`}:{channelField:"",messagesBlock:"",typeImport:""},ve=n=>{const{agents:e=[],functions:r,migrations:o=[],mutators:s=[],shapes:a=[],useUmbrella:i=!1,usesSandbox:c=!1}=n,u=r.length>0,l=W(i),{dispatchBody:h,importBlock:f,installBlock:m,migrationBody:b,mutatorPaths:R,roomMessagesBody:t,shapeBody:p}=pe(r,o,s,a),w=X(e,r),k=Z(c,r),v=[w.lines,k.lines].filter(d=>d.length>0).join(`
-`);let S=h;v.length>0&&(S=h.length>0?`${h.trimEnd()}
-${v}
-`:`
-${v}
-`);const y=fe(r),E=a.length>0?`import type { RegisteredShape } from "${l.server}";
-`:"",x=r.some(d=>d.channel?.kind==="room"),O=ye(x,l.server,t),C=a.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> = {${p}};
-`:"",F=R.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([${R.map(d=>JSON.stringify(d)).join(", ")}]);
-`:"",j=x?`
-/**
- * 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;
-})();
-`:"",I=m.length>0?`import { DEFER_VALIDATION as DEFER, installCompiledValidatorMap } from "${l.values}";
-`:"",D=m.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.
- */
-${m}
-`:"",$=ge(r),U=$.types?`
-${$.types}
-`:"",B=$.implementation?`
-${$.implementation}
-`:"",T=ee($.types),H=T.length>0?`import type { ${T.join(", ")} } from "./dataModel.js";
-`:"",J=u?"context":"_context",q=u?`${me}
-
-`:"";return te(`${z}${f}${w.importLine}${k.importLine}${I}${E}${O.typeImport}import { LunoraError } from "${l.server}";
-import type { ActionCtx, MutationCtx, QueryCtx } from "./server.js";
-${H}
-/**
- * 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";
-${O.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 };
-}
-${w.prelude}${k.prelude}
-/**
- * Static dispatch table. The key matches the \`__lunoraRef\` the client
- * emits (\`api[namespace][fn].__lunoraRef === "namespace:fn"\`).
- */
-export const LUNORA_FUNCTIONS: Record<string, RegisteredLunoraFunction> = {${S}};
-${D}${C}${F}${j}${O.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: [${y.connect.map(d=>JSON.stringify(d)).join(", ")}],
-    disconnect: [${y.disconnect.map(d=>JSON.stringify(d)).join(", ")}],
-    init: [${y.init.map(d=>JSON.stringify(d)).join(", ")}],
-    reactor: [${y.reactor.map(d=>JSON.stringify(d)).join(", ")}],
-    whisper: [${y.whisper.map(d=>JSON.stringify(d)).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> => {
-    const registered = LUNORA_FUNCTIONS[functionPath];
-
-    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 {${U}}
-
-${q}/** Build a {@link Caller} bound to \`context\` (typically a handler's \`ctx\`). */
-export const createCaller = (${J}: CallerCtx): Caller => ({${B}});
-
-/**
- * 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> = {${b}};
-`,i)};export{ve as default};