@lunora/codegen 1.0.0-alpha.32 → 1.0.0-alpha.321

package/dist/packem_shared/emitCrons-BQW2lviZ.mjs

@@ -0,0 +1,96 @@
+import{G as i,d as c}from"./shared-DnCokNcE.mjs";import{i as m}from"./schema-BgM8A3XV.mjs";const u=r=>r?`${i}/**
+ * The \`SchedulerDO\` Durable Object class, re-exported so a worker entry can
+ * forward it — wrangler binds only what the entry exports:
+ *
+ * \`export * from "./lunora/_generated/scheduler.js";\`
+ *
+ * A Vite-first (class-A) app needs no such line: the generated worker entry
+ * forwards this module for you whenever it exists.
+ */
+export { SchedulerDO } from "@lunora/scheduler";
+`:"",y=(r,t)=>r.some(o=>m(o))?`${i}/**
+ * The \`ShardRegistryDO\` Durable Object class — the live set of shard keys per
+ * \`.shardBy()\` table, which cross-shard export, CDC sync and migrations fan out
+ * to. Re-exported so a worker entry can forward it (wrangler binds only what the
+ * entry exports), next to \`.shardRegistry((env) => env.SHARD_REGISTRY)\`:
+ *
+ * \`export { ShardRegistryDO } from "./lunora/_generated/shardRegistry.js";\`
+ *
+ * Name the class in a hand-written entry: binding inference provisions
+ * \`SHARD_REGISTRY\` off the entry's named exports, and cannot see through an
+ * \`export *\`. A Vite-first (class-A) app needs neither line — its generated
+ * worker entry does both whenever this module exists.
+ */
+export { ShardRegistryDO } from "${c(t).do}";
+`:"",w=r=>`${i}/**
+ * Host the shard, the scheduler and the shard registry in ONE Durable Object
+ * class, so the app spends one of the account's classes instead of three. A
+ * Vite-first (class-A) app needs nothing more: its generated worker entry builds
+ * \`LunoraDO\` from these. A hand-written entry does the same by hand:
+ *
+ * \`export const LunoraDO = mergeDurableObjects({ shard: app.ShardDO, scheduler: SchedulerDO, shardRegistry: ShardRegistryDO });\`
+ *
+ * and passes \`roleNamespace(env.SHARD, "scheduler")\` / \`roleNamespace(env.SHARD, "shardRegistry")\`
+ * to \`.scheduler()\` / \`.shardRegistry()\`. Merge before the first deploy only:
+ * data already in \`ShardDO\` does not move, and a deployed merge cannot be undone.
+ */
+export { mergeDurableObjects, roleNamespace } from "${c(r).do}";
+`,O=r=>{const t=new Map;for(const n of r){const d=t.get(n.cron);d?d.push(n):t.set(n.cron,[n])}const o=[...t.keys()].map(n=>`    ${JSON.stringify(n)},`).join(`
+`),e=o.length>0?`
+${o}
+`:"",s=[...t.entries()].map(([n,d])=>{const l=d.map(a=>{const f=a.workflow?`workflow: ${JSON.stringify(a.workflow.className)}`:`functionPath: ${JSON.stringify(a.functionPath)}`;return`        { name: ${JSON.stringify(a.name)}, ${f}, args: ${JSON.stringify(a.args)} },`}).join(`
+`);return`    ${JSON.stringify(n)}: [
+${l}
+    ],`}).join(`
+`),h=s.length>0?`
+${s}
+`:"";return`${i}/**
+ * One scheduled cron invocation. Exactly one target is set: \`functionPath\` is
+ * the \`namespace:fn\` dispatch ref (matches \`__lunoraRef\`), invoked on the
+ * shard; \`workflow\` is a workflow class name (its \`ctx.exports\` key) whose durable workflow is
+ * started fresh per fire. \`args\` are forwarded verbatim (a workflow's become
+ * its \`params\`).
+ */
+export interface LunoraCronJob {
+    args: Record<string, unknown>;
+    functionPath?: string;
+    name: string;
+    workflow?: string;
+}
+
+/**
+ * Deduplicated cron schedules — mirror of wrangler's \`triggers.crons\`. The
+ * Lunora vite plugin keeps \`wrangler.jsonc\` in sync with this array.
+ */
+export const LUNORA_CRON_TRIGGERS: ReadonlyArray<string> = [${e}];
+
+/**
+ * Dispatcher map keyed by cron expression. The Worker's \`scheduled()\` handler
+ * looks up \`event.cron\` here and dispatches every job in the list.
+ */
+export const LUNORA_CRONS: Record<string, ReadonlyArray<LunoraCronJob>> = {${h}};
+`},S=r=>{const t=[...r].toSorted((e,s)=>e.name.localeCompare(s.name)).map(e=>{const s=[`name: ${JSON.stringify(e.name)}`,`table: ${JSON.stringify(e.table)}`];return e.field!==void 0&&s.push(`field: ${JSON.stringify(e.field)}`),e.dimensions!==void 0&&s.push(`dimensions: ${JSON.stringify(e.dimensions)}`),e.metric!==void 0&&s.push(`metric: ${JSON.stringify(e.metric)}`),e.metadata!==void 0&&s.push(`metadata: ${JSON.stringify(e.metadata)}`),`    { ${s.join(", ")} },`}).join(`
+`),o=t.length>0?`
+${t}
+`:"";return`${i}/**
+ * One vector index declared in \`schema.ts\` — an inline \`.vectorize()\` column
+ * or a standalone \`defineVectorIndex()\`. \`field\` is the source column (absent
+ * for a \`select\`-derived Shape B index); \`metadata\` lists the row fields
+ * mirrored into Vectorize for filtering.
+ */
+export interface LunoraVectorIndex {
+    dimensions?: number;
+    field?: string;
+    metadata?: ReadonlyArray<string>;
+    metric?: "cosine" | "dot-product" | "euclidean";
+    name: string;
+    table: string;
+}
+
+/**
+ * Static registry of every vector index in the schema, sorted by name.
+ * Vectorize cannot enumerate indexes at runtime, so the worker passes this to
+ * \`createWorker({ vectorIntrospector })\` to back the studio's vector browser.
+ */
+export const LUNORA_VECTOR_INDEXES: ReadonlyArray<LunoraVectorIndex> = [${o}];
+`},b=r=>[...new Set(r.map(t=>t.cron))];export{O as emitCrons,w as emitDurableObjects,u as emitScheduler,y as emitShardRegistry,S as emitVectors,b as emitWranglerCronTriggers};

package/dist/packem_shared/emitDataModel-BskFt9Wv.mjs

@@ -0,0 +1,114 @@
+import{r as k}from"./qualifiers-DEdXn5wP.mjs";import{a as i,e as o,v as d,f as v,G as M}from"./shared-DnCokNcE.mjs";const _="schema",w=a=>{for(const e of a.tables)i(e.name,"table name");const l=a.tables.map(e=>`"${e.name}"`).join(" | ")||"never",m=a.tables.filter(e=>e.extensionKey===void 0).map(e=>`"${e.name}"`).join(" | ")||"never",p=a.tables.map(e=>{const t=Object.entries(e.shape).map(([g,r])=>{const s=o(g);if(r.kind==="optional"){const h=r.inner?d(r.inner):"unknown";return`    ${s}?: ${h};`}return`    ${s}: ${d(r)};`}).join(`
+`),n=t?`
+${t}
+`:"",N=e.commitOrdered===!0?`
+    _commitSeq: number;`:"";return`export interface Doc_${e.name} {
+    _id: Id<"${e.name}">;
+    _creationTime: number;${N}${n}}`}).join(`
+
+`),c=a.tables.map(e=>`    ${e.name}: Doc_${e.name};`).join(`
+`),y=a.tables.map(e=>{const t=e.indexes.map(n=>JSON.stringify(n.name)).join(" | ");return`    ${e.name}: ${t||"never"};`}).join(`
+`),x=a.tables.map(e=>{const t=e.searchIndexes.map(n=>JSON.stringify(n.name)).join(" | ");return`    ${e.name}: ${t||"never"};`}).join(`
+`),b=a.tables.map(e=>{const t=e.rankIndexes.map(n=>JSON.stringify(n.name)).join(" | ");return`    ${e.name}: ${t||"never"};`}).join(`
+`),f=a.tables.map(e=>{const t=e.shardMode==="global"?"":(e.geoIndexes??[]).map(n=>JSON.stringify(n.name)).join(" | ");return`    ${e.name}: ${t||"never"};`}).join(`
+`),T=a.vectorIndexes.map(e=>JSON.stringify(e.name)).join(" | ")||"never",$=a.tables.map(e=>v(e)).join(`
+
+`),u=a.tables.map(e=>`    ${e.name}: Insert_${e.name};`).join(`
+`),I=a.tables.map(e=>{const t=e.relations.map(n=>(i(n.table,"relation target table"),n.kind==="one"?`        ${o(n.name)}: OneRelation<"${n.table}", ${JSON.stringify(n.field)}>;`:`        ${o(n.name)}: ManyRelation<"${n.table}">;`)).join(`
+`);return t?`    ${e.name}: {
+${t}
+    };`:`    ${e.name}: {};`}).join(`
+`);return k(`${M}export type TableName = ${l};
+
+/**
+ * The tables **this app declared** — every {@link TableName} except those an add-on
+ * contributed through \`defineSchema(...).extend(...)\`.
+ *
+ * An add-on's tables are real tables and stay in \`TableName\` (they are queryable,
+ * they appear in \`DataModel\`), but an app enumerating "my tables" should not have to
+ * know they exist: an account-deletion sweep, an export, a migration allowlist, or a
+ * helper generic over a table union is about the app's own data, and every add-on
+ * added or removed would otherwise silently change the correct answer.
+ *
+ * \`\`\`ts
+ * // Doesn't need to mention \`ratelimit_buckets\`, and won't drift when an add-on lands.
+ * const EXPORTED: readonly AppTableName[] = ["nodes", "tagColors"];
+ * \`\`\`
+ */
+export type AppTableName = ${m};
+
+export type Id<TName extends string> = string & { readonly __table: TName };
+
+${p}
+
+export interface DataModel {
+${c}
+}
+
+export type Doc<T extends keyof DataModel> = DataModel[T];
+
+/**
+ * Per-table index name union. \`never\` for tables without secondary indexes.
+ * Used by \`TableReader.withIndex()\` to constrain callers to declared names.
+ */
+export interface IndexNamesByTable {
+${y}
+}
+
+export type IndexName<T extends keyof DataModel> = IndexNamesByTable[T];
+
+/** Per-table search-index name union. \`never\` for tables without searchIndex. */
+export interface SearchIndexNamesByTable {
+${x}
+}
+
+export type SearchIndexName<T extends keyof DataModel> = SearchIndexNamesByTable[T];
+
+/** Per-table rank-index name union. \`never\` for tables without a rankIndex. */
+export interface RankIndexNamesByTable {
+${b}
+}
+
+export type RankIndexName<T extends keyof DataModel> = RankIndexNamesByTable[T];
+
+/** Per-table geo-index name union. \`never\` for tables without a geoIndex. */
+export interface GeoIndexNamesByTable {
+${f}
+}
+
+export type GeoIndexName<T extends keyof DataModel> = GeoIndexNamesByTable[T];
+
+/** Union of declared vector index names. \`never\` when none are declared. */
+export type VectorIndexName = ${T};
+
+${$}
+
+/** Per-table insert shape, accepted by \`ctx.db.<table>.insert(...)\`. */
+export interface InsertModel {
+${u}
+}
+
+export type Insert<T extends keyof DataModel> = InsertModel[T];
+
+/**
+ * Phantom relation descriptors. They carry the relation kind and target table
+ * as type parameters only — there is no runtime value — so the \`with\` argument
+ * and its return type can be inferred from {@link Relations}.
+ */
+export interface OneRelation<Target extends keyof DataModel, Field extends string> {
+    readonly __field: Field;
+    readonly __relationKind: "one";
+    readonly __target: Target;
+}
+
+export interface ManyRelation<Target extends keyof DataModel> {
+    readonly __relationKind: "many";
+    readonly __target: Target;
+}
+
+/** Per-table relation map keyed by accessor name. \`{}\` for tables with none. */
+export interface Relations {
+${I}
+}
+
+`,_)};export{_ as SCHEMA_MODULE_PATH,w as emitDataModel};

package/dist/packem_shared/emitDrizzleSchema-DitcRZ1a.mjs

@@ -0,0 +1,15 @@
+import{SCHEMA_MODULE_PATH as c}from"./emitDataModel-BskFt9Wv.mjs";import{r as m}from"./qualifiers-DEdXn5wP.mjs";import{G as b,a as z,d as T,v as f,u as A,g as x,c as h}from"./shared-DnCokNcE.mjs";const d=e=>{switch(e.kind){case"array":case"object":case"record":case"union":return{builder:"text",mode:"json",notNull:!0,typeAnnotation:f(e)};case"bigint":return{builder:"blob",mode:"bigint",notNull:!0};case"boolean":return{builder:"integer",mode:"boolean",notNull:!0};case"bytes":return{builder:"blob",mode:"buffer",notNull:!0};case"date":case"timestamp":return{builder:"integer",notNull:!0};case"from":return{builder:"text",notNull:!0,typeAnnotation:f(e)};case"id":return{builder:"text",notNull:!0};case"literal":{const t=e.literalValue??"";return t.startsWith('"')||t.startsWith("'")?{builder:"text",notNull:!0}:t==="true"||t==="false"?{builder:"integer",mode:"boolean",notNull:!0}:t==="null"?{builder:"text",notNull:!0}:{builder:"real",notNull:!0}}case"null":return{builder:"text",notNull:!0};case"number":return{builder:"real",notNull:!0};case"optional":return{...e.inner?d(e.inner):{builder:"text",notNull:!1},notNull:!1};case"storage":case"string":return{builder:"text",notNull:!0};default:return{builder:"text",notNull:!0}}},N=(e,t)=>{const r=A(e);return r.kind==="id"&&r.tableName!==void 0&&t.has(r.tableName)?r.tableName:void 0},j=(e,t,r)=>{x(e,"drizzle column name");const n=d(t),o=n.mode?`, { mode: "${n.mode}" }`:"";let l=`${n.builder}("${e}"${o})`;n.typeAnnotation&&(l+=`.$type<${n.typeAnnotation}>()`);const s=N(t,r);return s!==void 0&&(l+=`.references((): AnySQLiteColumn => ${s}._id)`),n.notNull&&t.column?.notNull!==!1&&(l+=".notNull()"),l},I=e=>{const t=e.unique?"uniqueIndex":"index",r=e.fields.map(n=>(x(n,"drizzle index field"),`t.${n}`)).join(", ");return`    ${h(e.name)}: ${t}(${JSON.stringify(e.name)}).on(${r}),`},S=(e,t)=>{z(e.name,"table name");const r=['    _id: text("_id").primaryKey(),','    _creationTime: integer("_creationTime").notNull(),',...Object.entries(e.shape).map(([o,l])=>`    ${o}: ${j(o,l,t)},`)].join(`
+`),n=e.indexes.length>0?`, (t) => ({
+${e.indexes.map(o=>I(o)).join(`
+`)}
+})`:"";return`export const ${e.name} = sqliteTable("${e.name}", {
+${r}
+}${n});`},C=e=>e.typeAnnotation?.includes('Id<"')??!1,D=(e,t)=>{const r=new Set(["integer","sqliteTable","text"]),n=new Set;let o=!1,l=!1;for(const s of e){for(const i of Object.values(s.shape)){const a=d(i);r.add(a.builder),l=l||C(a),o=o||N(i,t)!==void 0}for(const i of s.indexes)n.add(i.unique?"uniqueIndex":"index")}return{columns:[...r].toSorted((s,i)=>s.localeCompare(i)),indexes:[...n].toSorted((s,i)=>s.localeCompare(i)),needsAnyColumn:o,needsId:l}},p=(e,t=!1)=>{if(e.length===0)return`${b}export {};
+`;const r=T(t),n=new Set(e.map(u=>u.name)),{columns:o,indexes:l,needsAnyColumn:s,needsId:i}=D(e,n),a=[...l,...o].toSorted((u,g)=>u.localeCompare(g)),$=e.map(u=>S(u,n)).join(`
+
+`),y=[s?`import type { AnySQLiteColumn } from "${r.serverDrizzle}";
+`:"",i?`import type { Id } from "./dataModel.js";
+`:""].join("");return`${b}import { ${a.join(", ")} } from "${r.serverDrizzle}";
+${y}
+${$}
+`},v=(e,t=!1)=>{const r=e.tables.filter(o=>o.shardMode==="global"),n=e.tables.filter(o=>o.shardMode!=="global");return{global:m(p(r,t),c),shard:m(p(n,t),c)}};export{v as default};

package/dist/packem_shared/emitFunctions-CuZzKaU4.mjs

@@ -0,0 +1,419 @@
+import{LunoraError as P}from"@lunora/errors";import{L as oe,G as C,d as j,I as F,b as M,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]`,be=`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;
+};`,Ne=(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(!F.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(`
+`),b=[...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?b.filter(({definition:e})=>!s.has(e.filePath)):[];for(const{definition:e}of b)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 N=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(!F.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:N.length>0?`
+${N}
+`:"",migrationBody:c.length>0?`
+${c}
+`:"",moduleLoaders:w.length>0?`
+${w}
+`:"",mutatorPaths:y,roomMessagesBody:O,shapeBody:g.length>0?`
+${g}
+`:""}},ke=r=>{const t=M(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:M(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=be;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:b,roomMessagesBody:x,shapeBody:N}=Ne(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}\`);
+    }
+
+`:"",z=s.length>0?`import type { RegisteredShape } from "${c.server}";
+`:"",E=n.some(p=>p.channel?.kind==="room"),L=Oe(E,c.server,x),Q=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> = {${N}};
+`:"",G=b.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([${b.map(p=>JSON.stringify(p)).join(", ")}]);
+`:"",V=xe(E,o,n),W=y.length>0?`import { DEFER_VALIDATION as DEFER, installCompiledValidatorMap } from "${c.values}";
+`:"",Y=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}
+`:"",K=Se(n,o),{callRegisteredHelper:Z,dataModelImport:X,implementation:ee,parameter:te,types:re}=K,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 boundFunctions = new Set<string>();
+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;
+    }
+
+    if (boundFunctions.has(functionPath)) {
+        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);
+    boundFunctions.add(functionPath);
+
+    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);
+    }
+
+    // A module that failed to evaluate stays failed for the isolate: the runtime has already cached
+    // the failed evaluation, and a bundler's lazy initializer can hand a retry a half-initialized
+    // namespace, so every later call rethrows the original error instead.
+    resolvedModules.set(manifest.moduleId, await pending);
+
+    return getLoadedFunction(functionPath);
+};
+`:"";return le(`${C}${g}${h.importLine}${w.importLine}${W}${z}${L.typeImport}import { LunoraError } from "${c.server}";
+import type { ActionCtx, MutationCtx, QueryCtx } from "./server.js";
+${X}
+/**
+ * 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}};
+${Y}${Q}${G}${V}${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}}
+
+${Z}/** 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)},Me="fn",_e=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(!F.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}";
+`:"",b=$.length>0?`
+/** Install the precompiled argument parsers before the module is dispatched. */
+${$.join(`
+`)}
+`:"",N=t.some(h=>h.filePath===l&&h.exportName==="default")||n.some(h=>h.filePath===l&&h.exportName==="default")?`export { default } from "${y}";
+`:"";c[`${g}.ts`]=`${C}${v}${O}${b}export * from "${y}";
+${N}`}return c};export{Me as LAZY_FUNCTION_DIRECTORY,Ee as emitFunctions,_e as emitLazyFunctionModules};

package/dist/packem_shared/emitServer-D1vA5_X1.mjs

@@ -0,0 +1 @@
+import"./CAPABILITY_PROBES-brcmKenl.mjs";import{e}from"./server-DAvi_bv_.mjs";import"./shared-DnCokNcE.mjs";import"./platform-8oj7iXQy.mjs";export{e as default};