@lunora/codegen 1.0.0-alpha.26 → 1.0.0-alpha.260

package/dist/packem_shared/emitCrons-DsXsg1uG.mjs

@@ -0,0 +1,83 @@
+import{i as f}from"./ir-DBSvhNa-.mjs";import{G as c,d as m}from"./shared-BXUKWh7t.mjs";const u=n=>n?`${c}/**
+ * 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=(n,r)=>n.some(o=>f(o))?`${c}/**
+ * 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 "${m(r).do}";
+`:"",w=n=>{const r=new Map;for(const s of n){const a=r.get(s.cron);a?a.push(s):r.set(s.cron,[s])}const o=[...r.keys()].map(s=>`    ${JSON.stringify(s)},`).join(`
+`),e=o.length>0?`
+${o}
+`:"",t=[...r.entries()].map(([s,a])=>{const l=a.map(i=>{const h=i.workflow?`workflow: ${JSON.stringify(i.workflow.className)}`:`functionPath: ${JSON.stringify(i.functionPath)}`;return`        { name: ${JSON.stringify(i.name)}, ${h}, args: ${JSON.stringify(i.args)} },`}).join(`
+`);return`    ${JSON.stringify(s)}: [
+${l}
+    ],`}).join(`
+`),d=t.length>0?`
+${t}
+`:"";return`${c}/**
+ * 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>> = {${d}};
+`},S=n=>{const r=[...n].toSorted((e,t)=>e.name.localeCompare(t.name)).map(e=>{const t=[`name: ${JSON.stringify(e.name)}`,`table: ${JSON.stringify(e.table)}`];return e.field!==void 0&&t.push(`field: ${JSON.stringify(e.field)}`),e.dimensions!==void 0&&t.push(`dimensions: ${JSON.stringify(e.dimensions)}`),e.metric!==void 0&&t.push(`metric: ${JSON.stringify(e.metric)}`),e.metadata!==void 0&&t.push(`metadata: ${JSON.stringify(e.metadata)}`),`    { ${t.join(", ")} },`}).join(`
+`),o=r.length>0?`
+${r}
+`:"";return`${c}/**
+ * 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}];
+`},R=n=>[...new Set(n.map(r=>r.cron))];export{w as emitCrons,u as emitScheduler,y as emitShardRegistry,S as emitVectors,R as emitWranglerCronTriggers};

package/dist/packem_shared/emitDataModel-DSk9AkJe.mjs

@@ -0,0 +1,113 @@
+import{b as k}from"./qualifiers-Cw8dEDbh.mjs";import{a as s,b as i,v as d,e as v,G as M}from"./shared-BXUKWh7t.mjs";const D="schema",w=a=>{for(const e of a.tables)s(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(([h,r])=>{const o=i(h);if(r.kind==="optional"){const g=r.inner?d(r.inner):"unknown";return`    ${o}?: ${g};`}return`    ${o}: ${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(`
+`),T=a.tables.map(e=>{const t=e.shardMode==="global"?"":(e.geoIndexes??[]).map(n=>JSON.stringify(n.name)).join(" | ");return`    ${e.name}: ${t||"never"};`}).join(`
+`),f=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=>(s(n.table,"relation target table"),`        ${i(n.name)}: ${n.kind==="one"?"OneRelation":"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 {
+${T}
+}
+
+export type GeoIndexName<T extends keyof DataModel> = GeoIndexNamesByTable[T];
+
+/** Union of declared vector index names. \`never\` when none are declared. */
+export type VectorIndexName = ${f};
+
+${$}
+
+/** 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> {
+    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}
+}
+
+`,D)};export{D as SCHEMA_MODULE_PATH,w as emitDataModel};

package/dist/packem_shared/emitDrizzleSchema-DohtnI8c.mjs

@@ -0,0 +1,15 @@
+import{SCHEMA_MODULE_PATH as c}from"./emitDataModel-DSk9AkJe.mjs";import{b as m}from"./qualifiers-Cw8dEDbh.mjs";import{G as b,a as g,d as T,v as f,u as A,f as x,c as h}from"./shared-BXUKWh7t.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)=>{g(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,z)=>u.localeCompare(z)),$=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-evl8Mx1a.mjs

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