@lunora/codegen 1.0.0-alpha.54 → 1.0.0-alpha.56

package/dist/packem_shared/emit-DIbr7U31.mjs

@@ -1,3884 +0,0 @@
-import { agentComponent } from '@lunora/agent/component';
-import { LunoraError } from '@lunora/errors';
-import { s as sanitizeNamespace } from './paths-BRd6JHuF.mjs';
-
-const CAPABILITY_ROWS = [
-  // The middleware (`accessContext()` / `accessRoles()`) imports the `/context`
-  // and `/roles` subpaths, NOT the bare `@lunora/cloudflare-access` specifier —
-  // so the per-procedure middleware never trips the global `ctx.access` wiring.
-  // A handler reading `ctx.access` is the signal that wires it onto every ctx.
-  // `access` has a synchronous facade type, so its ctx field stays bespoke in
-  // `emit.ts` (no `serverCtxField` here).
-  { contextProperty: "access", key: "access", moduleSpecifier: "@lunora/cloudflare-access" },
-  {
-    appMethod: { configKey: "ai", doc: "Override the Workers AI binding backing `ctx.ai` (defaults to `env.AI`).", method: "ai" },
-    contextProperty: "ai",
-    key: "ai",
-    moduleSpecifier: "@lunora/ai"
-  },
-  {
-    appMethod: {
-      configKey: "analytics",
-      doc: "Override the Analytics Engine dataset backing `ctx.analytics` (defaults to `env.ANALYTICS`).",
-      method: "analytics"
-    },
-    contextProperty: "analytics",
-    key: "analytics",
-    moduleSpecifier: "@lunora/bindings/analytics",
-    // `ctx.analytics` — Analytics Engine write helper. EVERY ctx: a write-only,
-    // fire-and-forget side effect, not a determinism hazard for reads.
-    serverCtxField: {
-      field: `
-    /** Analytics Engine telemetry sink. Fire-and-forget and sampled; do not read it back in-handler. */
-    readonly analytics: import("@lunora/bindings/analytics").AnalyticsClient;`,
-      tier: "every"
-    }
-  },
-  {
-    appMethod: {
-      configKey: "browser",
-      doc: "Override the Browser Rendering binding backing `ctx.browser` (defaults to `env.BROWSER`).",
-      method: "browser"
-    },
-    contextProperty: "browser",
-    key: "browser",
-    moduleSpecifier: "@lunora/browser",
-    // `ctx.browser` — Browser Rendering. ActionCtx ONLY: non-deterministic network I/O.
-    serverCtxField: {
-      field: `
-    /** Browser Rendering (screenshots/PDF/scrape). Non-deterministic — available only in actions. */
-    readonly browser: import("@lunora/browser").Browser;`,
-      tier: "action"
-    }
-  },
-  // `lunora/containers.ts` imports `defineContainer` from `@lunora/container`,
-  // and handlers reach live instances via `ctx.containers` — either signals the
-  // app wires containers, so the studio should show the Containers page. The ctx
-  // field is a per-declaration emitter (kept bespoke), so no `serverCtxField`.
-  { contextProperty: "containers", key: "container", moduleSpecifier: "@lunora/container" },
-  // `ctx.flags` — OpenFeature. Umbrella-aware specifier + its own provider
-  // client, so both the ctx field and the shard fragment stay bespoke.
-  { contextProperty: "flags", key: "flags", moduleSpecifier: "@lunora/flags" },
-  {
-    appMethod: {
-      configKey: "sql",
-      doc: "Wire the Hyperdrive SQL client backing `ctx.sql` — build it with `createHyperdrive` + `fromPostgresJs`/`fromNodePg`/`fromMysql2`.",
-      method: "hyperdrive"
-    },
-    contextProperty: "sql",
-    key: "hyperdrive",
-    moduleSpecifier: "@lunora/hyperdrive",
-    // `ctx.sql` — Hyperdrive (external Postgres/MySQL). ActionCtx ONLY: external,
-    // non-deterministic I/O whose writes are invisible to Lunora live queries.
-    serverCtxField: {
-      field: `
-    /**
-     * External database access via Hyperdrive. Non-deterministic — available only in actions. Writes here are NOT tracked by Lunora live queries; subscriptions will not re-run on external DB changes.
-     */
-    readonly sql: import("@lunora/hyperdrive").SqlClient;`,
-      tier: "action"
-    }
-  },
-  {
-    appMethod: { configKey: "images", doc: "Override the Images binding backing `ctx.images` (defaults to `env.IMAGES`).", method: "images" },
-    contextProperty: "images",
-    key: "images",
-    moduleSpecifier: "@lunora/bindings/images",
-    // `ctx.images` — Cloudflare Images binding transforms. ActionCtx ONLY: non-deterministic compute/network I/O.
-    serverCtxField: {
-      field: `
-    /** Cloudflare Images transforms (resize/format/optimize). Non-deterministic — available only in actions. */
-    readonly images: import("@lunora/bindings/images").Images;`,
-      tier: "action"
-    }
-  },
-  {
-    appMethod: { configKey: "kv", doc: "Override the Workers KV binding backing `ctx.kv` (defaults to `env.KV`).", method: "kv" },
-    contextProperty: "kv",
-    key: "kv",
-    moduleSpecifier: "@lunora/bindings/kv",
-    // `ctx.kv` — Workers KV. Typed on EVERY ctx (a KV read is allowed in a
-    // deterministic read path the way `ctx.db` is; the binding is user-named).
-    serverCtxField: { field: `
-    readonly kv: import("@lunora/bindings/kv").Kv;`, tier: "every" }
-  },
-  // `mail` is import-only — no `ctx.mail` helper (mail is reached through its own
-  // client), so only a `@lunora/mail` import flips it.
-  { key: "mail", moduleSpecifier: "@lunora/mail" },
-  {
-    appMethod: { configKey: "payment", doc: "Wire the payment options backing `ctx.payments`.", method: "payment" },
-    contextProperty: "payments",
-    key: "payments",
-    moduleSpecifier: "@lunora/payment"
-  },
-  // `ctx.x402` — the x402 agent-wallet pay rail. ActionCtx ONLY: it signs and
-  // settles real USDC over the network per request. Like `payments`, its ctx
-  // field is bespoke (a lazily-built, per-run-metered rail), so no
-  // `serverCtxField` — `emit.ts` hand-wires it.
-  {
-    appMethod: {
-      configKey: "x402",
-      doc: "Wire the x402 agent-wallet pay rail backing `ctx.x402` — a payment-enabled `fetch` that answers `402` challenges under a mandatory spend policy (ActionCtx-only; spends real funds).",
-      method: "x402"
-    },
-    contextProperty: "x402",
-    key: "x402",
-    moduleSpecifier: "@lunora/x402/pay"
-  },
-  // Pipelines is its own `@lunora/bindings/pipelines` subpath (distinct from
-  // `/analytics`), so a real import is a clean signal that won't be flipped by a
-  // plain analytics import; `ctx.pipelines` reads flip it too.
-  {
-    contextProperty: "pipelines",
-    key: "pipelines",
-    moduleSpecifier: "@lunora/bindings/pipelines",
-    // `ctx.pipelines` — Pipelines (R2-backed) ingestion sink. ActionCtx ONLY
-    // (write-only fire-and-forget, but external I/O — kept off query/mutation).
-    serverCtxField: {
-      field: `
-    /** Pipelines ingestion sink (durable, R2-backed). Fire-and-forget and batched; do not read it back in-handler. */
-    readonly pipelines: import("@lunora/bindings/pipelines").PipelineClient;`,
-      tier: "action"
-    }
-  },
-  {
-    appMethod: {
-      configKey: "r2sql",
-      doc: "Wire the R2 SQL client backing `ctx.r2sql` — build it with `createR2Sql({ accountId, apiToken, bucket })` (defaults to env `R2_SQL_TOKEN` / `R2_SQL_ACCOUNT_ID` / `R2_SQL_BUCKET`).",
-      method: "r2sql"
-    },
-    contextProperty: "r2sql",
-    key: "r2sql",
-    moduleSpecifier: "@lunora/bindings/r2sql",
-    // `ctx.r2sql` — R2 SQL (serverless query engine over Apache Iceberg tables).
-    // ActionCtx ONLY: external REST I/O, non-deterministic, and non-reactive
-    // (reads are not tracked by Lunora live queries).
-    serverCtxField: {
-      field: `
-    /**
-     * R2 SQL over Apache Iceberg tables (window functions, DISTINCT, set operations). Non-deterministic — available only in actions. Reads here are NOT tracked by Lunora live queries.
-     */
-    readonly r2sql: import("@lunora/bindings/r2sql").R2SqlClient;`,
-      tier: "action"
-    }
-  },
-  { contextProperty: "scheduler", key: "scheduler", moduleSpecifier: "@lunora/scheduler" },
-  { contextProperty: "storage", key: "storage", moduleSpecifier: "@lunora/storage" },
-  {
-    appMethod: { configKey: "vectors", doc: "Wire the Vectorize index map backing `ctx.vectors`.", method: "vectors" },
-    contextProperty: "vectors",
-    key: "vectors",
-    moduleSpecifier: "@lunora/bindings/vectors"
-  },
-  { contextProperty: "workflows", key: "workflows", moduleSpecifier: "@lunora/workflow" }
-];
-const CAPABILITIES = CAPABILITY_ROWS;
-const SERVER_CTX_FIELDS = new Map(
-  CAPABILITIES.flatMap((capability) => capability.serverCtxField ? [[capability.key, capability.serverCtxField]] : [])
-);
-const APP_METHOD_CAPABILITIES = CAPABILITY_ROWS.flatMap(
-  (capability) => "appMethod" in capability ? [{ appMethod: capability.appMethod, key: capability.key }] : []
-);
-
-const LITERAL_VALUE_RE = /^(?:"(?:[^"\\]|\\(?:["\\/bfnrt]|u[0-9A-Fa-f]{4}))*"|'[^'\\]*'|-?\d+(?:\.\d+)?|true|false|null)$/u;
-
-const PASS_THROUGH_KINDS = /* @__PURE__ */ new Set(["any", "bigint", "boolean", "date", "id", "null", "number", "storage", "string", "timestamp"]);
-const hasColumnModifier = (node) => node.column !== void 0;
-const emitScalarGuard = (kind, inExpr) => {
-  switch (kind) {
-    case "bigint": {
-      return `if (typeof ${inExpr} !== "bigint") return DEFER;
-`;
-    }
-    case "boolean": {
-      return `if (typeof ${inExpr} !== "boolean") return DEFER;
-`;
-    }
-    case "date":
-    case "number":
-    case "timestamp": {
-      return `if (typeof ${inExpr} !== "number" || !Number.isFinite(${inExpr})) return DEFER;
-`;
-    }
-    case "null": {
-      return `if (${inExpr} !== null) return DEFER;
-`;
-    }
-    // string / id / storage all parse as a bare string at runtime.
-    default: {
-      return `if (typeof ${inExpr} !== "string") return DEFER;
-`;
-    }
-  }
-};
-const compileLiteral = (node, inExpr) => {
-  const literal = node.literalValue?.trim();
-  if (literal === void 0 || !LITERAL_VALUE_RE.test(literal)) {
-    return void 0;
-  }
-  return { out: inExpr, pre: `if (${inExpr} !== ${literal}) return DEFER;
-` };
-};
-const compileNode = (node, inExpr, context) => {
-  if (hasColumnModifier(node)) {
-    return void 0;
-  }
-  if (node.hasRefinement || node.sourceText !== void 0) {
-    return void 0;
-  }
-  if (PASS_THROUGH_KINDS.has(node.kind)) {
-    if (node.kind === "any") {
-      return { out: inExpr, pre: "" };
-    }
-    return { out: inExpr, pre: emitScalarGuard(node.kind, inExpr) };
-  }
-  switch (node.kind) {
-    case "array": {
-      return compileArray(node, inExpr, context);
-    }
-    case "literal": {
-      return compileLiteral(node, inExpr);
-    }
-    case "object": {
-      return compileObject(node, inExpr, context);
-    }
-    default: {
-      return void 0;
-    }
-  }
-};
-const compileArray = (node, inExpr, context) => {
-  const { inner } = node;
-  if (!inner) {
-    return void 0;
-  }
-  const id = context.next();
-  const array = `__arr${String(id)}`;
-  const index = `__i${String(id)}`;
-  const element = `__e${String(id)}`;
-  const innerEmit = compileNode(inner, element, context);
-  if (!innerEmit) {
-    return void 0;
-  }
-  const pre = `if (!Array.isArray(${inExpr})) return DEFER;
-const ${array} = new Array(${inExpr}.length);
-for (let ${index} = 0; ${index} < ${inExpr}.length; ${index}++) {
-const ${element} = ${inExpr}[${index}];
-${innerEmit.pre}${array}[${index}] = ${innerEmit.out};
-}
-`;
-  return { out: array, pre };
-};
-const compileField = (key, node, access, context) => {
-  const keyLiteral = JSON.stringify(key);
-  if (node.kind === "optional") {
-    if (node.hasRefinement || node.sourceText !== void 0 || hasColumnModifier(node)) {
-      return void 0;
-    }
-    const { inner } = node;
-    if (!inner) {
-      return void 0;
-    }
-    const innerEmit = compileNode(inner, access, context);
-    if (!innerEmit) {
-      return void 0;
-    }
-    const id = context.next();
-    const has = `__has${String(id)}`;
-    const value = `__val${String(id)}`;
-    const pre = `let ${has} = false;
-let ${value};
-if (${access} !== undefined) {
-${innerEmit.pre}${value} = ${innerEmit.out};
-${has} = true;
-}
-`;
-    return { entry: `...(${has} ? { ${keyLiteral}: ${value} } : {})`, pre };
-  }
-  const emit = compileNode(node, access, context);
-  if (!emit) {
-    return void 0;
-  }
-  return { entry: `${keyLiteral}: ${emit.out}`, pre: emit.pre };
-};
-const compileFields = (shape, accessFor, context) => {
-  let pre = "";
-  const entries = [];
-  for (const key of Object.keys(shape)) {
-    const node = shape[key];
-    if (!node) {
-      return void 0;
-    }
-    const field = compileField(key, node, accessFor(key), context);
-    if (!field) {
-      return void 0;
-    }
-    pre += field.pre;
-    entries.push(field.entry);
-  }
-  return { entries: entries.join(", "), pre };
-};
-const compileObject = (node, inExpr, context) => {
-  const shape = node.shape ?? {};
-  const fields = compileFields(shape, (key) => `${inExpr}[${JSON.stringify(key)}]`, context);
-  if (!fields) {
-    return void 0;
-  }
-  const id = context.next();
-  const object = `__obj${String(id)}`;
-  const pre = `if (typeof ${inExpr} !== "object" || ${inExpr} === null || Array.isArray(${inExpr})) return DEFER;
-${fields.pre}const ${object} = { ${fields.entries} };
-`;
-  return { out: object, pre };
-};
-const compileArgsValidator = (args) => {
-  let counter = 0;
-  const context = {
-    next: () => {
-      counter += 1;
-      return counter;
-    }
-  };
-  const fields = compileFields(args, (key) => `source[${JSON.stringify(key)}]`, context);
-  if (!fields) {
-    return void 0;
-  }
-  return `(source) => {
-if (typeof source !== "object" || source === null || Array.isArray(source)) return DEFER;
-${fields.pre}return { ${fields.entries} };
-}`;
-};
-
-const GENERATED_HEADER = "// GENERATED by @lunora/codegen — do not edit.\n// Run `lunora codegen` to regenerate.\n\n";
-const baseSpecifiers = (useUmbrella = false) => useUmbrella ? {
-  client: "lunorash/client",
-  do: "lunorash/do",
-  flags: "lunorash/flags",
-  server: "lunorash/server",
-  serverDataModel: "lunorash/server/data-model",
-  serverDrizzle: "lunorash/server/drizzle",
-  serverTypes: "lunorash/server/types",
-  values: "lunorash/values"
-} : {
-  client: "@lunora/client",
-  do: "@lunora/do",
-  flags: "@lunora/flags",
-  server: "@lunora/server",
-  serverDataModel: "@lunora/server/data-model",
-  serverDrizzle: "@lunora/server/drizzle",
-  serverTypes: "@lunora/server/types",
-  values: "@lunora/values"
-};
-const IDENTIFIER_RE = /^[A-Za-z_$][\w$]*$/u;
-const IMPORT_PATH_RE = /^[\w./-]+$/u;
-const assertIdentifier = (value, context) => {
-  if (!IDENTIFIER_RE.test(value)) {
-    throw new LunoraError("INTERNAL", `@lunora/codegen: ${context} is not a valid JS identifier: ${JSON.stringify(value)}`);
-  }
-};
-const renderPropertyKey = (fieldName) => IDENTIFIER_RE.test(fieldName) ? fieldName : JSON.stringify(fieldName);
-const SCALAR_TYPE_BY_KIND = {
-  any: "unknown",
-  bigint: "bigint",
-  boolean: "boolean",
-  bytes: "ArrayBuffer",
-  // Epoch-millisecond numbers; the distinction is semantic only.
-  date: "number",
-  // v.from() wraps an external Standard Schema validator whose output type is
-  // not statically recoverable at codegen time — emit `unknown` so the
-  // generated api types still compile without depending on the library.
-  from: "unknown",
-  // A geographic point stored as a `{ lat, lng }` JSON object.
-  geoPoint: "{ lat: number; lng: number }",
-  null: "null",
-  number: "number",
-  // The key of a stored R2 object — a string; the distinction is semantic only.
-  storage: "string",
-  string: "string",
-  timestamp: "number"
-};
-const literalToType = (value) => {
-  if (value === void 0) {
-    return "unknown";
-  }
-  if (!LITERAL_VALUE_RE.test(value)) {
-    throw new LunoraError(
-      "INTERNAL",
-      `@lunora/codegen: v.literal() argument is not a parseable string/number/boolean/null literal: ${JSON.stringify(value)}`
-    );
-  }
-  return value;
-};
-const validatorToType = (validator) => {
-  const scalar = SCALAR_TYPE_BY_KIND[validator.kind];
-  if (scalar !== void 0) {
-    return scalar;
-  }
-  switch (validator.kind) {
-    case "array": {
-      return `Array<${validator.inner ? validatorToType(validator.inner) : "unknown"}>`;
-    }
-    case "id": {
-      const tableName = validator.tableName ?? "_unknown_";
-      assertIdentifier(tableName, "v.id() table name");
-      return `Id<"${tableName}">`;
-    }
-    case "literal": {
-      return literalToType(validator.literalValue);
-    }
-    case "object": {
-      if (!validator.shape) {
-        return "Record<string, unknown>";
-      }
-      const fields = Object.entries(validator.shape).map(([key, child]) => `${renderPropertyKey(key)}: ${validatorToType(child)}`).join("; ");
-      return `{ ${fields} }`;
-    }
-    case "optional": {
-      return `${validator.inner ? validatorToType(validator.inner) : "unknown"} | undefined`;
-    }
-    case "record": {
-      const key = validator.keyType ? validatorToType(validator.keyType) : "string";
-      const value = validator.valueType ? validatorToType(validator.valueType) : "unknown";
-      return `Record<${key}, ${value}>`;
-    }
-    case "union": {
-      return validator.members && validator.members.length > 0 ? validator.members.map((member) => validatorToType(member)).join(" | ") : "never";
-    }
-    default: {
-      return "unknown";
-    }
-  }
-};
-const renderArgsType = (args) => {
-  const entries = Object.entries(args);
-  if (entries.length === 0) {
-    return "{}";
-  }
-  return `{ ${entries.map(([key, validator]) => {
-    const propertyKey = renderPropertyKey(key);
-    if (validator.kind === "optional") {
-      const inner = validator.inner ? validatorToType(validator.inner) : "unknown";
-      return `${propertyKey}?: ${inner}`;
-    }
-    return `${propertyKey}: ${validatorToType(validator)}`;
-  }).join("; ")} }`;
-};
-const isOptionalOnInsert = (validator) => validator.kind === "optional" || Boolean(validator.column?.hasDefault);
-const renderInsertInterface = (table) => {
-  assertIdentifier(table.name, "table name");
-  const fields = Object.entries(table.shape).map(([fieldName, validator]) => {
-    const inner = validator.kind === "optional" && validator.inner ? validator.inner : validator;
-    const type = validatorToType(inner);
-    const propertyKey = renderPropertyKey(fieldName);
-    return isOptionalOnInsert(validator) ? `    ${propertyKey}?: ${type};` : `    ${propertyKey}: ${type};`;
-  }).join("\n");
-  const body = fields ? `
-${fields}
-` : "";
-  return `export interface Insert_${table.name} {
-    _id?: Id<"${table.name}">;
-    _creationTime?: number;${body}}`;
-};
-const emitDataModel = (schema, useUmbrella = false) => {
-  const base = baseSpecifiers(useUmbrella);
-  for (const table of schema.tables) {
-    assertIdentifier(table.name, "table name");
-  }
-  const tableNames = schema.tables.map((table) => `"${table.name}"`).join(" | ") || "never";
-  const documents = schema.tables.map((table) => {
-    const fields = Object.entries(table.shape).map(([fieldName, validator]) => {
-      const propertyKey = renderPropertyKey(fieldName);
-      if (validator.kind === "optional") {
-        const inner = validator.inner ? validatorToType(validator.inner) : "unknown";
-        return `    ${propertyKey}?: ${inner};`;
-      }
-      return `    ${propertyKey}: ${validatorToType(validator)};`;
-    }).join("\n");
-    const body = fields ? `
-${fields}
-` : "";
-    return `export interface Doc_${table.name} {
-    _id: Id<"${table.name}">;
-    _creationTime: number;${body}}`;
-  }).join("\n\n");
-  const documentMap = schema.tables.map((table) => `    ${table.name}: Doc_${table.name};`).join("\n");
-  const indexNamesByTable = schema.tables.map((table) => {
-    const names = table.indexes.map((index) => JSON.stringify(index.name)).join(" | ");
-    return `    ${table.name}: ${names || "never"};`;
-  }).join("\n");
-  const searchIndexNamesByTable = schema.tables.map((table) => {
-    const names = table.shardMode === "global" ? "" : table.searchIndexes.map((index) => JSON.stringify(index.name)).join(" | ");
-    return `    ${table.name}: ${names || "never"};`;
-  }).join("\n");
-  const rankIndexNamesByTable = schema.tables.map((table) => {
-    const names = table.rankIndexes.map((index) => JSON.stringify(index.name)).join(" | ");
-    return `    ${table.name}: ${names || "never"};`;
-  }).join("\n");
-  const geoIndexNamesByTable = schema.tables.map((table) => {
-    const names = table.shardMode === "global" ? "" : (table.geoIndexes ?? []).map((index) => JSON.stringify(index.name)).join(" | ");
-    return `    ${table.name}: ${names || "never"};`;
-  }).join("\n");
-  const vectorIndexNames = schema.vectorIndexes.map((index) => JSON.stringify(index.name)).join(" | ") || "never";
-  const insertInterfaces = schema.tables.map((table) => renderInsertInterface(table)).join("\n\n");
-  const insertMap = schema.tables.map((table) => `    ${table.name}: Insert_${table.name};`).join("\n");
-  const relationsMap = schema.tables.map((table) => {
-    const entries = table.relations.map((relation) => {
-      assertIdentifier(relation.table, "relation target table");
-      return `        ${renderPropertyKey(relation.name)}: ${relation.kind === "one" ? "OneRelation" : "ManyRelation"}<"${relation.table}">;`;
-    }).join("\n");
-    return entries ? `    ${table.name}: {
-${entries}
-    };` : `    ${table.name}: {};`;
-  }).join("\n");
-  return `${GENERATED_HEADER}import type {
-    DatabaseReaderFacade as DatabaseReaderFacadeOf,
-    DatabaseWriterFacade as DatabaseWriterFacadeOf,
-    LoadWith as LoadWithOf,
-    TableReaderFacade as TableReaderFacadeOf,
-    TableWriterFacade as TableWriterFacadeOf,
-    WithArg as WithArgOf,
-} from "${base.serverDataModel}";
-
-export type {
-    AggregateOp,
-    GroupByEntry,
-    OrderBy,
-    QueryArgs,
-    QueryPage,
-    RankPage,
-    RankResult,
-    RestrictableQueryOptions,
-    RestrictableQueryOptionsOf,
-    SearchFilterBuilder,
-    SearchReader,
-    TableAggregateOptions,
-    TableAggregateOptionsOf,
-    TableGroupByOptions,
-    TableGroupByOptionsOf,
-    TableRankOptions,
-    TableRankPageOptions,
-    Where,
-    WhereOf,
-    WhereOperators,
-} from "${base.serverDataModel}";
-
-export type TableName = ${tableNames};
-
-export type Id<TName extends string> = string & { readonly __table: TName };
-
-${documents}
-
-export interface DataModel {
-${documentMap}
-}
-
-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 {
-${indexNamesByTable}
-}
-
-export type IndexName<T extends keyof DataModel> = IndexNamesByTable[T];
-
-/** Per-table search-index name union. \`never\` for tables without searchIndex. */
-export interface SearchIndexNamesByTable {
-${searchIndexNamesByTable}
-}
-
-export type SearchIndexName<T extends keyof DataModel> = SearchIndexNamesByTable[T];
-
-/** Per-table rank-index name union. \`never\` for tables without a rankIndex. */
-export interface RankIndexNamesByTable {
-${rankIndexNamesByTable}
-}
-
-export type RankIndexName<T extends keyof DataModel> = RankIndexNamesByTable[T];
-
-/** Per-table geo-index name union. \`never\` for tables without a geoIndex. */
-export interface GeoIndexNamesByTable {
-${geoIndexNamesByTable}
-}
-
-export type GeoIndexName<T extends keyof DataModel> = GeoIndexNamesByTable[T];
-
-/** Union of declared vector index names. \`never\` when none are declared. */
-export type VectorIndexName = ${vectorIndexNames};
-
-${insertInterfaces}
-
-/** Per-table insert shape, accepted by \`ctx.db.<table>.insert(...)\`. */
-export interface InsertModel {
-${insertMap}
-}
-
-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 {
-${relationsMap}
-}
-
-/** The \`with\` argument for table \`T\` — see \`@lunora/server/data-model\`. */
-export type WithArg<T extends keyof DataModel> = WithArgOf<DataModel, Relations, T>;
-
-/** \`Doc<T>\` narrowed to exactly the relations requested in the with-arg \`W\`. */
-export type LoadWith<T extends keyof DataModel, W> = LoadWithOf<DataModel, Relations, T, W>;
-
-/** Read-only typed table accessor exposed on \`QueryCtx.db.<table>\`. */
-export type TableReaderFacade<T extends keyof DataModel> = TableReaderFacadeOf<DataModel, Relations, RankIndexNamesByTable, SearchIndexNamesByTable, T, GeoIndexNamesByTable>;
-
-/** Read-write typed table accessor exposed on \`MutationCtx.db.<table>\` / \`ActionCtx.db.<table>\`. */
-export type TableWriterFacade<T extends keyof DataModel> = TableWriterFacadeOf<DataModel, InsertModel, Relations, RankIndexNamesByTable, SearchIndexNamesByTable, T, GeoIndexNamesByTable>;
-
-/** Per-table read facade — \`ctx.db.<table>\` on a \`QueryCtx\`. */
-export type DatabaseReaderFacade = DatabaseReaderFacadeOf<DataModel, Relations, RankIndexNamesByTable, SearchIndexNamesByTable, GeoIndexNamesByTable>;
-
-/** Per-table read-write facade — \`ctx.db.<table>\` on a \`MutationCtx\` / \`ActionCtx\`. */
-export type DatabaseWriterFacade = DatabaseWriterFacadeOf<DataModel, InsertModel, Relations, RankIndexNamesByTable, SearchIndexNamesByTable, GeoIndexNamesByTable>;
-
-/** Insert builder returned by \`ctx.orm.insert(table)\`. */
-export interface OrmInsertBuilder<T extends keyof DataModel> {
-    values: (values: Insert<T>) => Promise<Id<T>>;
-}
-
-/** Replace builder returned by \`ctx.orm.replace(table, id)\` — swaps the whole document. */
-export interface OrmReplaceBuilder<T extends keyof DataModel> {
-    with: (values: Insert<T>) => Promise<void>;
-}
-
-/** Update builder returned by \`ctx.orm.update(table, id)\` — patches the named fields. */
-export interface OrmUpdateBuilder<T extends keyof DataModel> {
-    set: (values: Partial<Insert<T>>) => Promise<void>;
-}
-
-/** Read-only ORM surface — \`ctx.orm\` on a \`QueryCtx\`. Mirrors \`ctx.db\` reads under a kitcn-style \`query\` namespace. */
-export interface OrmReader {
-    query: DatabaseReaderFacade;
-}
-
-/** Read-write ORM surface — \`ctx.orm\` on a \`MutationCtx\` / \`ActionCtx\`. Writes are addressed by id, like \`ctx.db\`. */
-export interface OrmWriter extends OrmReader {
-    delete: <T extends keyof DataModel>(table: T, id: Id<T>) => Promise<void>;
-    insert: <T extends keyof DataModel>(table: T) => OrmInsertBuilder<T>;
-    replace: <T extends keyof DataModel>(table: T, id: Id<T>) => OrmReplaceBuilder<T>;
-    update: <T extends keyof DataModel>(table: T, id: Id<T>) => OrmUpdateBuilder<T>;
-}
-`;
-};
-const GENERATED_IMPORT_RE = /import\("(?<spec>(?:\.\.?\/)*_generated\/[^"]+)"\)/gu;
-const GENERATED_PREFIX_RE = /^(?:\.\.?\/)*_generated\//u;
-const relocateGeneratedImports = (returnType) => returnType.replaceAll(GENERATED_IMPORT_RE, (_match, spec) => {
-  const stripped = spec.replace(GENERATED_PREFIX_RE, "./");
-  return `import("${stripped}")`;
-});
-const referencedDataModelImports = (body) => ["Doc", "Id"].filter((name) => new RegExp(String.raw`\b${name}<`, "u").test(body));
-const renderApiBody = (functions) => {
-  const namespaces = /* @__PURE__ */ new Map();
-  for (const definition of functions) {
-    const list = namespaces.get(definition.filePath) ?? [];
-    list.push(definition);
-    namespaces.set(definition.filePath, list);
-  }
-  const renderNamespace = ([file, list]) => {
-    const members = list.map((definition) => {
-      const argsType = renderArgsType(definition.args);
-      const returnType = relocateGeneratedImports(definition.returnType);
-      return `        ${definition.exportName}: FunctionReference<"${definition.kind}", ${argsType}, ${returnType}>;`;
-    }).join("\n");
-    return `    ${renderPropertyKey(sanitizeNamespace(file))}: {
-${members}
-    };`;
-  };
-  return [...namespaces.entries()].toSorted(([a], [b]) => a.localeCompare(b)).map((entry) => renderNamespace(entry)).join("\n");
-};
-const renderSchedulerReferences = (workflows, agents) => {
-  if (workflows.length === 0 && agents.length === 0) {
-    return { block: "", importLine: "" };
-  }
-  const importLines = [];
-  let block = "";
-  if (workflows.length > 0) {
-    block += `
-/** Params type carried by a \`defineWorkflow\` definition (its phantom \`__params\`). */
-type WorkflowParamsOf<Definition> = Definition extends { __params?: infer Params } ? (unknown extends Params ? Record<string, unknown> : Params) : Record<string, unknown>;
-`;
-  }
-  block += `
-/** A typed reference to a durable workflow, addressable for \`cronJobs()\` targets. Mirrors \`@lunora/scheduler\`'s \`WorkflowReference\` structurally. */
-export interface WorkflowReference<Params = Record<string, unknown>> {
-    readonly isLunoraWorkflow: true;
-    readonly __params?: Params;
-    readonly binding: string;
-    readonly name: string;
-}
-`;
-  if (workflows.length > 0) {
-    const sorted = [...workflows].toSorted((a, b) => a.exportName.localeCompare(b.exportName));
-    const refMembers = sorted.map((workflow) => `    ${workflow.exportName}: WorkflowReference<WorkflowParamsOf<typeof lunoraWorkflowDefinitions.${workflow.exportName}>>;`).join("\n");
-    const objectMembers = sorted.map(
-      (workflow) => `    ${workflow.exportName}: { isLunoraWorkflow: true, binding: ${JSON.stringify(workflow.bindingName)}, name: ${JSON.stringify(workflow.exportName)} },`
-    ).join("\n");
-    block += `
-/** This project's durable workflows, addressable as typed references (e.g. \`crons.daily("digest", …, workflows.digestPipeline, params)\`). */
-export interface WorkflowsRef {
-${refMembers}
-}
-
-export const workflows: WorkflowsRef = {
-${objectMembers}
-};
-`;
-    importLines.push(`import type * as lunoraWorkflowDefinitions from "../workflows.js";
-`);
-  }
-  if (agents.length > 0) {
-    const sorted = [...agents].toSorted((a, b) => a.exportName.localeCompare(b.exportName));
-    const refMembers = sorted.map((agent) => `    ${agent.exportName}: WorkflowReference<AgentRunInput>;`).join("\n");
-    const objectMembers = sorted.map(
-      (agent) => `    ${agent.exportName}: { isLunoraWorkflow: true, binding: ${JSON.stringify(agent.bindingName)}, name: ${JSON.stringify(agent.name)} },`
-    ).join("\n");
-    block += `
-/** This project's durable agents, addressable as typed references for \`cronJobs()\` — each fire starts a fresh agent run (e.g. \`crons.daily("sweep", …, agents.support, { input, threadKey })\`). */
-export interface AgentsRef {
-${refMembers}
-}
-
-export const agents: AgentsRef = {
-${objectMembers}
-};
-`;
-    importLines.push(`import type { AgentRunInput } from "@lunora/agent";
-`);
-  }
-  return { block, importLine: importLines.join("") };
-};
-const agentRuntimeFunctionNames = () => Object.keys(agentComponent().functions).toSorted((a, b) => a.localeCompare(b));
-const takenAgentFunctionNames = (functions) => new Set(functions.filter((definition) => sanitizeNamespace(definition.filePath) === "agents").map((definition) => definition.exportName));
-const internalAgentRuntimeFunctionNames = () => new Set(
-  Object.entries(agentComponent().functions).filter(([, definition]) => definition.visibility === "internal").map(([name]) => name)
-);
-const renderAgentFunctionRegistry = (agents, functions) => {
-  const empty = { importLine: "", lines: "", prelude: "" };
-  if (agents.length === 0) {
-    return empty;
-  }
-  const taken = takenAgentFunctionNames(functions);
-  const internal = internalAgentRuntimeFunctionNames();
-  const shadowedInternal = functions.find((definition) => sanitizeNamespace(definition.filePath) === "agents" && internal.has(definition.exportName));
-  if (shadowedInternal) {
-    throw new LunoraError(
-      "INTERNAL",
-      `@lunora/codegen: "agents:${shadowedInternal.exportName}" is reserved for the durable agent loop's internal dispatch — rename the "${shadowedInternal.exportName}" export in ${shadowedInternal.filePath}`
-    );
-  }
-  const names = agentRuntimeFunctionNames().filter((name) => !taken.has(name));
-  if (names.length === 0) {
-    return empty;
-  }
-  return {
-    importLine: 'import { agentComponent } from "@lunora/agent/component";\n',
-    lines: names.map((name) => `    "agents:${name}": lunoraAgentRuntimeFunctions.${name} as unknown as RegisteredLunoraFunction,`).join("\n"),
-    prelude: "\n/**\n * The `@lunora/agent` runtime component — auto-registered because `lunora/agents.ts`\n * declares agents. The durable loop dispatches the internal mutations; clients\n * subscribe to the public queries (`agents:agentMessages` is the live thread view).\n */\nconst lunoraAgentRuntimeFunctions = agentComponent().functions;\n"
-  };
-};
-const renderSandboxFunctionRegistry = (usesSandbox, functions) => {
-  if (!usesSandbox) {
-    return { importLine: "", lines: "", prelude: "" };
-  }
-  const collision = functions.find((definition) => sanitizeNamespace(definition.filePath) === "sandbox" && definition.exportName === "invoke");
-  if (collision) {
-    throw new LunoraError(
-      "INTERNAL",
-      `@lunora/codegen: "sandbox:invoke" is reserved for the batteries-included sandbox tool dispatcher (browserTool/containerTool) — rename the "invoke" export in ${collision.filePath}`
-    );
-  }
-  return {
-    importLine: 'import { sandboxComponent } from "@lunora/agent/component";\n',
-    lines: '    "sandbox:invoke": lunoraSandbox.invoke as unknown as RegisteredLunoraFunction,',
-    prelude: "\n/**\n * The `@lunora/agent` sandbox dispatcher — auto-registered because `lunora/`\n * imports a sandbox tool (`browserTool`/`containerTool`). The batteries-included\n * tools dispatch to this internal action, which runs on an action ctx carrying\n * `ctx.browser` + `ctx.containers` (the durable tool step itself has neither).\n */\nconst lunoraSandbox = sandboxComponent();\n"
-  };
-};
-const syntheticAgentApiFunctions = (agents, functions) => {
-  if (agents.length === 0) {
-    return [];
-  }
-  const taken = takenAgentFunctionNames(functions);
-  const definitions = [
-    {
-      args: { key: { kind: "string" }, limit: { inner: { kind: "number" }, kind: "optional" } },
-      exportName: "agentMessages",
-      filePath: "agents",
-      kind: "query",
-      returnType: "Record<string, unknown>[]"
-    },
-    {
-      args: {
-        decision: {
-          kind: "union",
-          members: [
-            { kind: "literal", literalValue: '"approve"' },
-            { kind: "literal", literalValue: '"reject"' }
-          ]
-        },
-        instanceId: { kind: "string" },
-        note: { inner: { kind: "string" }, kind: "optional" },
-        threadKey: { kind: "string" },
-        toolCallId: { kind: "string" }
-      },
-      exportName: "agentResolveApproval",
-      filePath: "agents",
-      kind: "mutation",
-      returnType: "{ resolved: boolean }"
-    },
-    {
-      args: {
-        agent: { kind: "string" },
-        input: { kind: "string" },
-        threadKey: { kind: "string" },
-        title: { inner: { kind: "string" }, kind: "optional" }
-      },
-      exportName: "agentRun",
-      filePath: "agents",
-      kind: "mutation",
-      returnType: "{ id: string; threadKey: string }"
-    },
-    {
-      args: { key: { kind: "string" } },
-      exportName: "agentState",
-      filePath: "agents",
-      kind: "query",
-      returnType: "Record<string, unknown> | undefined"
-    },
-    {
-      args: { key: { kind: "string" } },
-      exportName: "agentThread",
-      filePath: "agents",
-      kind: "query",
-      returnType: "Record<string, unknown> | undefined"
-    }
-  ];
-  for (const agent of agents) {
-    if (agent.voice) {
-      definitions.push({
-        args: { threadKey: { kind: "string" } },
-        exportName: `${agent.exportName}Voice`,
-        filePath: "agents",
-        kind: "stream",
-        returnType: "Record<string, unknown>"
-      });
-    }
-  }
-  return definitions.filter((definition) => !taken.has(definition.exportName));
-};
-const renderHttpStreamsRef = (httpRoutes) => {
-  const streams = httpRoutes.filter((route) => route.stream);
-  if (streams.length === 0) {
-    return { block: "", body: "" };
-  }
-  const namespaces = /* @__PURE__ */ new Map();
-  for (const route of streams) {
-    const list = namespaces.get(route.filePath) ?? [];
-    list.push(route);
-    namespaces.set(route.filePath, list);
-  }
-  const sortedNamespaces = [...namespaces.entries()].toSorted(([a], [b]) => a.localeCompare(b));
-  const typeBody = sortedNamespaces.map(([file, list]) => {
-    const members = list.map((route) => {
-      const chunkType = relocateGeneratedImports(route.chunkType ?? "unknown");
-      return `        ${renderPropertyKey(route.exportName)}: HttpStreamRef<${chunkType}, ${renderArgsType(route.searchParams)}, ${renderArgsType(route.params)}>;`;
-    }).join("\n");
-    return `    ${renderPropertyKey(sanitizeNamespace(file))}: {
-${members}
-    };`;
-  }).join("\n");
-  const valueBody = sortedNamespaces.map(([file, list]) => {
-    const members = list.map(
-      (route) => `        ${renderPropertyKey(route.exportName)}: { method: ${JSON.stringify(route.method)}, path: ${JSON.stringify(route.path)} },`
-    ).join("\n");
-    return `    ${renderPropertyKey(sanitizeNamespace(file))}: {
-${members}
-    },`;
-  }).join("\n");
-  const block = `
-/** This project's HTTP-SSE stream routes (\`httpRoute.<verb>(path).stream()\`), addressable as typed references for \`client.httpStream\` / \`useHttpStream\`. */
-export interface HttpStreamsRef {
-${typeBody}
-}
-
-export const httpStreams: HttpStreamsRef = {
-${valueBody}
-};
-`;
-  return { block, body: typeBody };
-};
-const emitApi = (options) => {
-  const { agents = [], functions, httpRoutes = [], useUmbrella = false, workflows = [] } = options;
-  const base = baseSpecifiers(useUmbrella);
-  const publicFunctions = [...functions.filter((definition) => definition.visibility !== "internal"), ...syntheticAgentApiFunctions(agents, functions)];
-  const internalFunctions = functions.filter((definition) => definition.visibility === "internal");
-  const publicBody = renderApiBody(publicFunctions);
-  const internalBody = renderApiBody(internalFunctions);
-  const httpStreamsRef = renderHttpStreamsRef(httpRoutes);
-  const combinedBody = `${publicBody}
-${internalBody}
-${httpStreamsRef.body}`;
-  const dataModelImports = referencedDataModelImports(combinedBody);
-  const dataModelImportLine = dataModelImports.length > 0 ? `
-import type { ${dataModelImports.join(", ")} } from "./dataModel.js";
-` : "";
-  const apiBlock = publicBody ? `
-${publicBody}
-` : "";
-  const internalBlock = internalBody ? `
-${internalBody}
-` : "";
-  const schedulerReferences = renderSchedulerReferences(workflows, agents);
-  const clientImports = httpStreamsRef.block === "" ? "FunctionReference" : "FunctionReference, HttpStreamRef";
-  return `${GENERATED_HEADER}import { anyApi } from "${base.serverTypes}";
-import type { ${clientImports} } from "${base.client}";
-${schedulerReferences.importLine}${dataModelImportLine}
-export interface ApiTypes {${apiBlock}}
-
-export const api = anyApi as unknown as ApiTypes;
-
-/** Internal functions — callable only server-side via \`ctx.run*\`, never from a client. */
-export interface InternalApiTypes {${internalBlock}}
-
-export const internal = anyApi as unknown as InternalApiTypes;
-${schedulerReferences.block}${httpStreamsRef.block}`;
-};
-const emitSeed = (enabled) => {
-  if (!enabled) {
-    return "";
-  }
-  return `${GENERATED_HEADER}import { createSeedClient as createSeedClientBase } from "@lunora/seed";
-import type { SeedClient, SeedClientOptions } from "@lunora/seed";
-
-import schema from "../schema.js";
-import type { InsertModel } from "./dataModel.js";
-
-/**
- * Schema-aware seed client with this project's \`InsertModel\` and runtime schema
- * pre-bound. Each table is a method; call it with a count, a range, explicit
- * partial rows, or per-field overrides. Foreign keys connect to rows seeded
- * earlier in the run, and FK-parent tables are seeded automatically.
- * @example
- * const seed = createSeedClient({ seed: 1 });
- * const { users } = await seed.users(5);
- * const { posts } = await seed.posts((x) => x([10, 20]));
- */
-export const createSeedClient = (options?: SeedClientOptions): SeedClient<InsertModel> => createSeedClientBase<InsertModel>(schema, options);
-`;
-};
-const emitCollections = (shapes, hasDatabase, useUmbrella = false) => {
-  if (shapes.length === 0 || !hasDatabase) {
-    return "";
-  }
-  const base = baseSpecifiers(useUmbrella);
-  const factories = shapes.map((shape) => {
-    assertIdentifier(shape.exportName, "shape export name");
-    return `/** Live collection for the \`${shape.exportName}\` replication shape — pass the shape's validated \`args\` (its partition selector). */
-export const ${shape.exportName}Collection = (client: LunoraClient, args?: Record<string, unknown>): Collection<Row, string> =>
-    createCollection(lunoraCollectionOptions({ client, shape: { args, name: "${shape.exportName}" } }).config);`;
-  }).join("\n\n");
-  return `${GENERATED_HEADER}import type { LunoraClient } from "${base.client}";
-import { lunoraCollectionOptions } from "@lunora/db/collections";
-import type { Row } from "@lunora/db";
-import type { Collection } from "@tanstack/db";
-import { createCollection } from "@tanstack/db";
-
-${factories}
-`;
-};
-const moduleAlias = (filePath, index) => `lunora_${sanitizeNamespace(filePath)}_${String(index)}`;
-const CALL_REGISTERED_HELPER = `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}\`);
-    }
-
-    return (await registered.handler(context, args ?? {})) as R;
-};`;
-const renderFunctionRegistry = (functions, migrations, mutators = [], shapes = []) => {
-  const aliasByPath = /* @__PURE__ */ new Map();
-  const registerPath = (filePath) => {
-    if (!aliasByPath.has(filePath)) {
-      aliasByPath.set(filePath, moduleAlias(filePath, aliasByPath.size));
-    }
-  };
-  for (const definition of functions) {
-    registerPath(definition.filePath);
-  }
-  for (const migration of migrations) {
-    registerPath(migration.filePath);
-  }
-  for (const mutator of mutators) {
-    registerPath(mutator.filePath);
-  }
-  for (const shape of shapes) {
-    registerPath(shape.filePath);
-  }
-  const importLines = [...aliasByPath.entries()].map(([filePath, alias]) => {
-    if (!IMPORT_PATH_RE.test(filePath)) {
-      throw new LunoraError("INTERNAL", `@lunora/codegen: refusing to emit import for unsafe file path: ${JSON.stringify(filePath)}`);
-    }
-    return `import * as ${alias} from "../${filePath}.js";`;
-  }).join("\n");
-  const dispatchEntries = functions.map(
-    (definition) => `    "${sanitizeNamespace(definition.filePath)}:${definition.exportName}": ${aliasByPath.get(definition.filePath) ?? ""}.${definition.exportName} as unknown as RegisteredLunoraFunction,`
-  ).join("\n");
-  const migrationEntries = migrations.map(
-    (migration) => `    ${JSON.stringify(migration.id)}: ${aliasByPath.get(migration.filePath) ?? ""}.${migration.exportName} as unknown as RegisteredDataMigration,`
-  ).join("\n");
-  const mutatorEntries = mutators.map(
-    (mutator) => `    "${sanitizeNamespace(mutator.filePath)}:${mutator.exportName}": ${aliasByPath.get(mutator.filePath) ?? ""}.${mutator.exportName} as unknown as RegisteredLunoraFunction,`
-  ).join("\n");
-  const shapeEntries = shapes.map((shape) => `    "${shape.exportName}": ${aliasByPath.get(shape.filePath) ?? ""}.${shape.exportName} as unknown as RegisteredShape,`).join("\n");
-  const mutatorPaths = mutators.map((mutator) => `${sanitizeNamespace(mutator.filePath)}:${mutator.exportName}`);
-  const combinedDispatch = [dispatchEntries, mutatorEntries].filter((entries) => entries.length > 0).join("\n");
-  const installLines = functions.map((definition) => {
-    if (definition.lifecycle || Object.keys(definition.args).length === 0) {
-      return void 0;
-    }
-    const compiled = compileArgsValidator(definition.args);
-    if (compiled === void 0) {
-      return void 0;
-    }
-    const alias = aliasByPath.get(definition.filePath) ?? "";
-    return `installCompiledValidatorMap(${alias}.${definition.exportName}.args, ${compiled});`;
-  }).filter((line) => line !== void 0).join("\n");
-  return {
-    dispatchBody: combinedDispatch.length > 0 ? `
-${combinedDispatch}
-` : "",
-    importBlock: importLines.length > 0 ? `${importLines}
-
-` : "",
-    installBlock: installLines,
-    migrationBody: migrationEntries.length > 0 ? `
-${migrationEntries}
-` : "",
-    mutatorPaths,
-    shapeBody: shapeEntries.length > 0 ? `
-${shapeEntries}
-` : ""
-  };
-};
-const renderCaller = (functions) => {
-  const namespaces = /* @__PURE__ */ new Map();
-  for (const definition of functions) {
-    const list = namespaces.get(definition.filePath) ?? [];
-    list.push(definition);
-    namespaces.set(definition.filePath, list);
-  }
-  const ordered = [...namespaces.entries()].toSorted(([a], [b]) => a.localeCompare(b));
-  const types = ordered.map(([file, list]) => {
-    const members = list.map((definition) => {
-      const argsType = renderArgsType(definition.args);
-      const optional = argsType === "{}" ? "?" : "";
-      const returnType = relocateGeneratedImports(definition.returnType);
-      if (definition.kind === "stream") {
-        return `        ${definition.exportName}: (args${optional}: ${argsType}) => Promise<AsyncIterable<${returnType}>>;`;
-      }
-      return `        ${definition.exportName}: (args${optional}: ${argsType}) => Promise<${returnType}>;`;
-    }).join("\n");
-    return `    ${renderPropertyKey(sanitizeNamespace(file))}: {
-${members}
-    };`;
-  }).join("\n");
-  const implementation = ordered.map(([file, list]) => {
-    const namespace = sanitizeNamespace(file);
-    const leaves = list.map((definition) => `        ${definition.exportName}: (args) => callRegistered(context, "${namespace}:${definition.exportName}", args),`).join("\n");
-    return `    ${renderPropertyKey(namespace)}: {
-${leaves}
-    },`;
-  }).join("\n");
-  return { implementation, types };
-};
-const buildStorageBucketNames = (schema, ruleBuckets = []) => {
-  const named = /* @__PURE__ */ new Set();
-  for (const table of schema.tables) {
-    for (const validator of Object.values(table.shape)) {
-      const resolved = validator.kind === "optional" && validator.inner ? validator.inner : validator;
-      if (resolved.kind === "storage" && typeof resolved.bucket === "string" && resolved.bucket !== "") {
-        named.add(resolved.bucket);
-      }
-    }
-  }
-  for (const bucket of ruleBuckets) {
-    if (bucket !== "" && bucket !== "default") {
-      named.add(bucket);
-    }
-  }
-  return ["default", ...[...named].toSorted((a, b) => a.localeCompare(b))];
-};
-const emitServer = ({
-  agents = [],
-  containers = [],
-  env,
-  hasAccessFacade = false,
-  hasAi = false,
-  hasAnalytics = false,
-  hasBrowser = false,
-  hasFlags = false,
-  hasHyperdrive = false,
-  hasImages = false,
-  hasKv = false,
-  hasNotify = false,
-  hasPayments = false,
-  hasPipelines = false,
-  hasR2sql = false,
-  hasX402 = false,
-  identity,
-  queues = [],
-  schema,
-  storageRuleBuckets = [],
-  useUmbrella = false,
-  workflows = []
-} = {}) => {
-  const base = baseSpecifiers(useUmbrella);
-  const storageBucketUnion = buildStorageBucketNames(schema ?? { tables: []}, storageRuleBuckets).map((name) => JSON.stringify(name)).join(" | ");
-  const aiTypeImport = hasAi ? `import type { LunoraAi } from "@lunora/ai";
-` : "";
-  const aiActionField = hasAi ? `
-    readonly ai: LunoraAi;` : "";
-  const paymentsTypeImport = hasPayments ? `import type { LunoraPayment } from "@lunora/payment";
-` : "";
-  const paymentsActionField = hasPayments ? `
-    readonly payments: LunoraPayment;` : "";
-  const x402TypeImport = hasX402 ? `import type { X402Pay } from "@lunora/x402/pay";
-` : "";
-  const x402ActionField = hasX402 ? `
-    readonly x402: X402Pay;` : "";
-  const containersTypeImport = containers.length > 0 ? `import type { ContainerAccessor } from "@lunora/container";
-` : "";
-  const containersActionField = containers.length > 0 ? `
-    readonly containers: {${containers.map((container) => `
-        readonly ${container.exportName}: ContainerAccessor;`).join("")}
-    };` : "";
-  const envBindingFields = [
-    ...hasAi ? [`    /** Workers AI binding (the conventional \`env.AI\`), narrowing \`ctx.ai\`. */
-    readonly AI?: unknown;`] : [],
-    ...containers.map((container) => {
-      assertIdentifier(container.bindingName, `container binding "${container.bindingName}"`);
-      return `    /** Durable Object namespace for the \`${container.exportName}\` container. */
-    readonly ${container.bindingName}?: unknown;`;
-    }),
-    ...workflows.map((workflow) => {
-      assertIdentifier(workflow.bindingName, `workflow binding "${workflow.bindingName}"`);
-      return `    /** Workflow binding for the \`${workflow.exportName}\` workflow. */
-    readonly ${workflow.bindingName}?: unknown;`;
-    }),
-    ...queues.map((queue) => {
-      assertIdentifier(queue.bindingName, `queue binding "${queue.bindingName}"`);
-      return `    /** Queue producer binding for the \`${queue.exportName}\` queue. */
-    readonly ${queue.bindingName}?: unknown;`;
-    }),
-    ...agents.map((agent) => {
-      assertIdentifier(agent.bindingName, `agent binding "${agent.bindingName}"`);
-      return `    /** Workflow binding for the \`${agent.exportName}\` agent. */
-    readonly ${agent.bindingName}?: unknown;`;
-    })
-  ].join("\n");
-  const envBlock = `
-
-/**
- * This project's Cloudflare bindings, as far as codegen can discover them from
- * \`lunora/\` source — the container/workflow Durable Object namespaces and the
- * conventional Workers AI binding. Bindings the config layer reconciles from
- * user-named wrangler config (R2/KV/D1/\`services\`/queues/…) aren't statically
- * visible here, so the open index signature keeps them reachable (cast at the
- * use site). Service bindings (\`env.<SERVICE>.fetch(...)\` / RPC stubs) live
- * under this signature too — Lunora can't type a third-party worker's RPC
- * surface, so treat them as \`Fetcher\`/\`Service<unknown>\` and cast.
- */
-export interface CloudflareBindings {
-    readonly [binding: string]: unknown;${envBindingFields ? `
-${envBindingFields}` : ""}
-}
-
-/** Alias for {@link CloudflareBindings} — the typed shape of \`env\`. */
-export type Env = CloudflareBindings;`;
-  const serverCapabilityField = (key, enabled) => enabled ? SERVER_CTX_FIELDS.get(key)?.field ?? "" : "";
-  const kvContextField = serverCapabilityField("kv", hasKv);
-  const analyticsContextField = serverCapabilityField("analytics", hasAnalytics);
-  const hyperdriveActionField = serverCapabilityField("hyperdrive", hasHyperdrive);
-  const browserActionField = serverCapabilityField("browser", hasBrowser);
-  const imagesActionField = serverCapabilityField("images", hasImages);
-  const pipelinesActionField = serverCapabilityField("pipelines", hasPipelines);
-  const r2sqlActionField = serverCapabilityField("r2sql", hasR2sql);
-  const accessContextField = hasAccessFacade ? `
-    /** Verified Cloudflare Access identity — a synchronous facade over the resolved claims (email / groups / hasGroup / claims). Anonymous when no Access token is present. */
-    readonly access: import("@lunora/cloudflare-access/context").AccessFacade;` : "";
-  const flagsContextField = hasFlags ? `
-    /** Feature-flag evaluation (OpenFeature). Reads are memoized per request; evaluations never throw — a provider error resolves to the supplied default. */
-    readonly flags: import("${base.flags}").LunoraFlags;` : "";
-  const notifyContextField = hasNotify ? `
-    /** Multi-channel notifications (@lunora/notify): send / chat / inApp / webhook plus the push device sub-facade. Sends are external I/O — confine them to action handlers. */
-    readonly notify: import("@lunora/notify").LunoraNotify;
-    /** Device push sub-facade — the same object as ctx.notify.push (register / send / broadcast). Sends belong in action handlers. */
-    readonly push: import("@lunora/notify").LunoraPush;` : "";
-  const hasWorkflows = workflows.length > 0;
-  const workflowsTypeImport = hasWorkflows ? `import type { WorkflowHandle } from "@lunora/workflow";
-import type * as lunoraWorkflowDefinitions from "../workflows.js";
-` : "";
-  const workflowsTypeBlock = hasWorkflows ? `
-
-/** Params type carried by a \`defineWorkflow\` definition (its phantom \`__params\`). */
-type WorkflowParamsOf<Definition> = Definition extends { __params?: infer Params }
-    ? unknown extends Params
-        ? Record<string, unknown>
-        : NonNullable<Params>
-    : Record<string, unknown>;
-
-/** This project's declared workflows, addressable from \`ctx.workflows\` by their \`lunora/workflows.ts\` export name. */
-export interface LunoraWorkflows {
-${workflows.map((workflow) => `    get(name: ${JSON.stringify(workflow.exportName)}): WorkflowHandle<WorkflowParamsOf<typeof lunoraWorkflowDefinitions.${workflow.exportName}>>;`).join("\n")}
-}` : "";
-  const workflowsOmit = hasWorkflows ? ` | "workflows"` : "";
-  const workflowsContextField = hasWorkflows ? `
-    readonly workflows: LunoraWorkflows;` : "";
-  const hasQueues = queues.length > 0;
-  const queuesTypeImport = hasQueues ? `import type { QueueProducer } from "@lunora/queue";
-import type * as lunoraQueueDefinitions from "../queues.js";
-` : "";
-  const queuesTypeBlock = hasQueues ? `
-
-/** Message body type carried by a \`defineQueue\` definition (its phantom \`__lunoraBody\`). */
-type QueueBodyOf<Definition> = Definition extends { __lunoraBody?: infer Body } ? (unknown extends Body ? unknown : NonNullable<Body>) : unknown;
-
-/** This project's declared queues, addressable from \`ctx.queues\` by their \`lunora/queues.ts\` export name. */
-export interface LunoraQueues {
-${queues.map((queue) => `    readonly ${queue.exportName}: QueueProducer<QueueBodyOf<typeof lunoraQueueDefinitions.${queue.exportName}>>;`).join("\n")}
-}` : "";
-  const queuesContextField = hasQueues ? `
-    readonly queues: LunoraQueues;` : "";
-  const hasAgents = agents.length > 0;
-  const agentsTypeImport = hasAgents ? `import type { AgentHandle } from "@lunora/agent";
-` : "";
-  const agentsTypeBlock = hasAgents ? `
-
-/** This project's declared agents, addressable from \`ctx.agents\` by their \`lunora/agents.ts\` export name. */
-export interface LunoraAgents {
-${agents.map((agent) => {
-    assertIdentifier(agent.exportName, `agent export "${agent.exportName}"`);
-    return `    readonly ${agent.exportName}: AgentHandle;`;
-  }).join("\n")}
-}` : "";
-  const agentsContextField = hasAgents ? `
-    readonly agents: LunoraAgents;` : "";
-  const identityTypeImport = identity ? `import type { InferIdentity } from "${base.server}";
-import type * as lunoraIdentityContract from "../identity.js";
-` : "";
-  const identityTypeBlock = identity ? `
-
-/** This app's declared identity claim contract (\`defineIdentity\` in \`lunora/identity.ts\`) — the typed shape of \`ctx.auth.getIdentity()\`, the RLS policy \`ctx.auth.identity\`, and the \`authorizeShard\`/\`authorizeFanOut\` identity argument. */
-export type Identity = InferIdentity<typeof lunoraIdentityContract.${identity.exportName}>;
-
-/** \`ctx.auth\` narrowed so \`getIdentity()\` resolves the declared {@link Identity} contract instead of the untyped claim bag. */
-type NarrowedAuth = Omit<QueryCtxBase["auth"], "getIdentity"> & { getIdentity: () => Promise<Identity | null> };` : "";
-  const authOmit = identity ? ` | "auth"` : "";
-  const authContextField = identity ? `
-    readonly auth: NarrowedAuth;` : "";
-  const policyIdentityArgument = identity ? ", Identity" : "";
-  const envTypeImport = env ? `import type * as lunoraEnvContract from "../env.js";
-` : "";
-  const envTypeBlock = env ? `
-
-/** This app's declared env contract (\`defineEnv\` in \`lunora/env.ts\`) — the validated, coercion-aware shape of \`ctx.env\`. */
-export type LunoraEnv = ReturnType<typeof lunoraEnvContract.${env.exportName}>;` : "";
-  const envOmit = env ? ` | "env"` : "";
-  const envContextField = env ? `
-    /** Validated, typed environment declared by \`defineEnv\` in \`lunora/env.ts\` — parsed & coercion-aware config values (\`ctx.env.STRIPE_KEY\`); a missing or invalid value throws at read time. */
-    readonly env: LunoraEnv;` : "";
-  const server = `${GENERATED_HEADER}import { createPolicyDsl, initLunora, v as vBase } from "${base.server}";
-import type {
-    ActionBuilder,
-    ActionCtx as ActionCtxBase,
-    ColumnValidator,
-    DatabaseReader,
-    DatabaseWriter,
-    EmptyArgs,
-    InternalActionBuilder,
-    InternalMutationBuilder,
-    InternalQueryBuilder,
-    MutationBuilder,
-    MutationCtx as MutationCtxBase,
-    QueryBuilder,
-    QueryCtx as QueryCtxBase,
-    ReadOnlyStorage,
-    Storage as StorageBase,
-    TableReader,
-} from "${base.server}";
-
-import type { DataModel, DatabaseReaderFacade, DatabaseWriterFacade, Doc, Id as IdOfTable, OrmReader, OrmWriter, Relations, TableName } from "./dataModel.js";
-${aiTypeImport}${paymentsTypeImport}${x402TypeImport}${containersTypeImport}${workflowsTypeImport}${queuesTypeImport}${agentsTypeImport}${identityTypeImport}${envTypeImport}
-export type { DataModel, Doc, Id, TableName } from "./dataModel.js";
-
-/** Storage buckets this schema declares (\`v.storage("name")\`), narrowing \`ctx.storage.bucket(name)\`. */
-export type StorageBucketName = ${storageBucketUnion};${envBlock}${workflowsTypeBlock}${queuesTypeBlock}${agentsTypeBlock}${identityTypeBlock}${envTypeBlock}
-
-/**
- * Project-typed contexts. The base contexts from \`@lunora/server\` are
- * untyped against the schema; here \`db\` is widened to the generated per-table
- * facade (\`ctx.db.<table>.findMany(...)\`) while keeping the legacy structural
- * \`db.get\`/\`db.query\` surface for back-compat, and \`storage\` is narrowed so
- * \`ctx.storage.bucket(name)\` autocompletes the declared buckets.
- */
-/**
- * The Convex-style fluent reader \`ctx.db.query(table)\`, bound to this schema:
- * a table-name literal narrows the row type, so \`.collect()\` / \`.first()\` /
- * \`.take()\` (and the \`.withIndex()\` / \`.filter()\` / \`.order()\` chain) resolve
- * as \`Doc<table>\` with no \`as unknown as Doc<...>\` casts. The per-table accessor
- * \`ctx.db.<table>\` stays available alongside it via the facade.
- *
- * Intersected with the wide \`(string) => TableReader\` signature so the bound
- * \`ctx.db\` is still structurally assignable to schema-agnostic consumers that
- * call \`db.query(someString)\` (e.g. \`@lunora/ratelimit\`'s \`createDbStore\`).
- */
-type TypedTableQuery = (<T extends TableName>(table: T) => TableReader<Doc<T>>) & ((table: string) => TableReader);
-
-/**
- * The point read \`ctx.db.get(id)\`, bound to this schema: an \`Id<"table">\`
- * carries its table name, so the resolved document is typed \`Doc<table>\` (or
- * \`null\` when absent) with no \`as Doc<...>\` cast. Mirrors {@link TypedTableQuery}.
- */
-type TypedTableGet = <T extends TableName>(id: IdOfTable<T>) => Promise<Doc<T> | null>;
-
-export interface QueryCtx extends Omit<QueryCtxBase, "db" | "storage"${authOmit}${envOmit}> {
-    readonly db: Omit<DatabaseReader, "query" | "get"> & DatabaseReaderFacade & { query: TypedTableQuery; get: TypedTableGet };
-    readonly orm: OrmReader;
-    readonly storage: ReadOnlyStorage<StorageBucketName>;${accessContextField}${kvContextField}${flagsContextField}${notifyContextField}${analyticsContextField}${envContextField}${authContextField}
-}
-
-export interface MutationCtx extends Omit<MutationCtxBase, "db" | "storage"${workflowsOmit}${authOmit}${envOmit}> {
-    readonly db: Omit<DatabaseWriter, "query" | "get"> & DatabaseWriterFacade & { query: TypedTableQuery; get: TypedTableGet };
-    readonly orm: OrmWriter;
-    readonly storage: ReadOnlyStorage<StorageBucketName>;${accessContextField}${kvContextField}${flagsContextField}${notifyContextField}${analyticsContextField}${envContextField}${workflowsContextField}${queuesContextField}${agentsContextField}${authContextField}
-}
-
-export interface ActionCtx extends Omit<ActionCtxBase, "db" | "storage"${workflowsOmit}${authOmit}${envOmit}> {
-    readonly db: Omit<DatabaseWriter, "query" | "get"> & DatabaseWriterFacade & { query: TypedTableQuery; get: TypedTableGet };
-    readonly orm: OrmWriter;
-    readonly storage: StorageBase<StorageBucketName>;${accessContextField}${aiActionField}${paymentsActionField}${x402ActionField}${containersActionField}${kvContextField}${flagsContextField}${notifyContextField}${hyperdriveActionField}${browserActionField}${imagesActionField}${analyticsContextField}${pipelinesActionField}${r2sqlActionField}${envContextField}${workflowsContextField}${queuesContextField}${agentsContextField}${authContextField}
-}
-
-/**
- * Procedure builders bound to this project's typed contexts. Chain
- * \`.input({...})\` to declare args, \`.use(middleware)\` for rate limiting / RLS /
- * masking (each middleware may refine \`ctx\`), then the terminal
- * \`.query()\` / \`.mutation()\` / \`.action()\` with a \`({ ctx, args }) => ...\`
- * handler. \`.output(validator)\` and (queries) \`.stream()\` are also available.
- */
-const lunoraBuilders = initLunora.dataModel<DataModel>().create();
-
-/** \`query\` builder bound to this project's typed {@link QueryCtx}. */
-export const query = lunoraBuilders.query as unknown as QueryBuilder<QueryCtx, EmptyArgs>;
-
-/** \`mutation\` builder bound to this project's typed {@link MutationCtx}. */
-export const mutation = lunoraBuilders.mutation as unknown as MutationBuilder<MutationCtx, EmptyArgs>;
-
-/** \`action\` builder bound to this project's typed {@link ActionCtx}. */
-export const action = lunoraBuilders.action as unknown as ActionBuilder<ActionCtx, EmptyArgs>;
-
-/** \`internalQuery\` builder bound to this project's typed {@link QueryCtx} — never exposed on \`api\`. */
-export const internalQuery = lunoraBuilders.internalQuery as unknown as InternalQueryBuilder<QueryCtx, EmptyArgs>;
-
-/** \`internalMutation\` builder bound to this project's typed {@link MutationCtx} — never exposed on \`api\`. */
-export const internalMutation = lunoraBuilders.internalMutation as unknown as InternalMutationBuilder<MutationCtx, EmptyArgs>;
-
-/** \`internalAction\` builder bound to this project's typed {@link ActionCtx} — never exposed on \`api\`. */
-export const internalAction = lunoraBuilders.internalAction as unknown as InternalActionBuilder<ActionCtx, EmptyArgs>;
-
-/**
- * \`definePolicy\` bound to THIS schema's {@link DataModel} + {@link Relations}.
- * Import it from here (\`./_generated/server\`) instead of \`@lunora/server\` to get
- * a relation-aware RLS authoring surface: \`table\` autocompletes to a real table
- * name and the \`when\` predicate type-checks against the table's columns **and**
- * its declared relations — \`{ author: { is: {...} } }\`, \`{ posts: { some: {...} } }\`,
- * etc. (the \`@lunora/do\` pre-resolver resolves relation predicates on reads).
- * Runtime-identical to \`@lunora/server\`'s \`definePolicy\`; only the types narrow,
- * so the \`rls()\` chain discovers a policy authored either way the same.
- */
-export const definePolicy = createPolicyDsl<DataModel, Relations${policyIdentityArgument}>();
-
-/**
- * The validator builder \`v\`, with \`v.id(...)\` constrained to THIS schema's
- * table names — so the argument autocompletes and returns a precise
- * \`Id<"table">\`. Identical to \`@lunora/server\`'s \`v\` at runtime; the only
- * difference is the tightened \`id\` type.
- *
- * Import \`v\` from here (\`./_generated/server\`) in your queries/mutations/actions
- * to get table-name autocomplete. \`lunora/schema.ts\` can't use it — it is the
- * file that defines the table names, so they aren't known yet there; pass the
- * names as string literals and the generated \`Id<"table">\` types still catch a
- * typo wherever the id is used.
- */
-export const v = vBase as unknown as Omit<typeof vBase, "id"> & {
-    id: <T extends TableName>(table: T) => ColumnValidator<IdOfTable<T>, IdOfTable<T>>;
-};
-`;
-  return server;
-};
-const renderLifecycleManifest = (functions) => {
-  const manifest = { connect: [], disconnect: [] };
-  for (const definition of functions) {
-    if (!definition.lifecycle) {
-      continue;
-    }
-    manifest[definition.lifecycle].push(`${sanitizeNamespace(definition.filePath)}:${definition.exportName}`);
-  }
-  return manifest;
-};
-const emitFunctions = (options) => {
-  const { agents = [], functions, migrations = [], mutators = [], shapes = [], useUmbrella = false, usesSandbox = false } = options;
-  const hasFunctions = functions.length > 0;
-  const base = baseSpecifiers(useUmbrella);
-  const { dispatchBody, importBlock, installBlock, migrationBody, mutatorPaths, shapeBody } = renderFunctionRegistry(functions, migrations, mutators, shapes);
-  const agentRegistry = renderAgentFunctionRegistry(agents, functions);
-  const sandboxRegistry = renderSandboxFunctionRegistry(usesSandbox, functions);
-  const autoLines = [agentRegistry.lines, sandboxRegistry.lines].filter((block) => block.length > 0).join("\n");
-  let dispatchBodyWithAgents = dispatchBody;
-  if (autoLines.length > 0) {
-    dispatchBodyWithAgents = dispatchBody.length > 0 ? `${dispatchBody.trimEnd()}
-${autoLines}
-` : `
-${autoLines}
-`;
-  }
-  const lifecycleHooks = renderLifecycleManifest(functions);
-  const shapeTypeImport = shapes.length > 0 ? `import type { RegisteredShape } from "${base.server}";
-` : "";
-  const shapeRegistry = shapes.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> = {${shapeBody}};
-` : "";
-  const mutatorPathsRegistry = mutatorPaths.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([${mutatorPaths.map((path) => JSON.stringify(path)).join(", ")}]);
-` : "";
-  const compiledArgsImport = installBlock.length > 0 ? `import { DEFER_VALIDATION as DEFER, installCompiledValidatorMap } from "${base.values}";
-` : "";
-  const compiledArgsInstall = installBlock.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.
- */
-${installBlock}
-` : "";
-  const caller = renderCaller(functions);
-  const callerTypes = caller.types ? `
-${caller.types}
-` : "";
-  const callerImpl = caller.implementation ? `
-${caller.implementation}
-` : "";
-  const callerDataModelImports = referencedDataModelImports(caller.types);
-  const dataModelImport = callerDataModelImports.length > 0 ? `import type { ${callerDataModelImports.join(", ")} } from "./dataModel.js";
-` : "";
-  const callerParameter = hasFunctions ? "context" : "_context";
-  const callRegisteredHelper = hasFunctions ? `${CALL_REGISTERED_HELPER}
-
-` : "";
-  return `${GENERATED_HEADER}${importBlock}${agentRegistry.importLine}${sandboxRegistry.importLine}${compiledArgsImport}${shapeTypeImport}import { LunoraError } from "${base.server}";
-import type { ActionCtx, MutationCtx, QueryCtx } from "./server.js";
-${dataModelImport}
-/**
- * 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>;
-    /**
-     * 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>);
-    /** \`"internal"\` functions are rejected on the external RPC path; absence === public. */
-    visibility?: "internal" | "public";
-}
-${agentRegistry.prelude}${sandboxRegistry.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> = {${dispatchBodyWithAgents}};
-${compiledArgsInstall}${shapeRegistry}${mutatorPathsRegistry}
-/**
- * Connection-lifecycle manifest: the function paths the generated ShardDO
- * dispatches when a client's WebSocket connects (\`connect\`) or disconnects
- * (\`disconnect\`). Each path also resolves through {@link LUNORA_FUNCTIONS}; the
- * DO runs every hook under the socket's verified identity via system dispatch.
- */
-export const LUNORA_LIFECYCLE_HOOKS: { connect: readonly string[]; disconnect: readonly string[] } = {
-    connect: [${lifecycleHooks.connect.map((path) => JSON.stringify(path)).join(", ")}],
-    disconnect: [${lifecycleHooks.disconnect.map((path) => JSON.stringify(path)).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 {${callerTypes}}
-
-${callRegisteredHelper}/** Build a {@link Caller} bound to \`context\` (typically a handler's \`ctx\`). */
-export const createCaller = (${callerParameter}: CallerCtx): Caller => ({${callerImpl}});
-
-/**
- * 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> = {${migrationBody}};
-`;
-};
-const buildTableReferences = (schema) => {
-  const references = {};
-  for (const table of schema.tables) {
-    const fields = {};
-    for (const [field, validator] of Object.entries(table.shape)) {
-      const resolved = validator.kind === "optional" && validator.inner ? validator.inner : validator;
-      if (resolved.kind === "id" && resolved.tableName !== void 0) {
-        fields[field] = resolved.tableName;
-      }
-    }
-    if (Object.keys(fields).length > 0) {
-      references[table.name] = fields;
-    }
-  }
-  return references;
-};
-const buildStorageColumns = (schema) => {
-  const byTable = {};
-  for (const table of schema.tables) {
-    const fields = [];
-    for (const [field, validator] of Object.entries(table.shape)) {
-      const resolved = validator.kind === "optional" && validator.inner ? validator.inner : validator;
-      if (resolved.kind === "storage") {
-        fields.push(field);
-      }
-    }
-    if (fields.length > 0) {
-      byTable[table.name] = fields;
-    }
-  }
-  return byTable;
-};
-const buildTableIndexes = (schema) => {
-  const byTable = {};
-  for (const table of schema.tables) {
-    const entries = [
-      ...table.indexes.map((index) => {
-        return { fields: [...index.fields], name: index.name, type: "index", ...index.unique === true ? { unique: true } : {} };
-      }),
-      ...table.searchIndexes.map((index) => {
-        return { fields: [index.field, ...index.filterFields ?? []], name: index.name, type: "search" };
-      }),
-      ...(table.geoIndexes ?? []).map((index) => {
-        return { fields: [index.field], name: index.name, type: "geo" };
-      }),
-      ...table.rankIndexes.map((index) => {
-        return { fields: index.sortBy.map((key) => key.field), name: index.name, type: "rank" };
-      }),
-      ...table.vectorIndexes.map((index) => {
-        return { fields: index.field === void 0 ? [] : [index.field], name: index.name, type: "vector" };
-      })
-    ];
-    if (entries.length > 0) {
-      byTable[table.name] = entries;
-    }
-  }
-  return byTable;
-};
-const buildTtlSweeps = (schema) => {
-  const sweeps = [];
-  for (const table of schema.tables) {
-    if (!table.ttl || table.shardMode === "global") {
-      continue;
-    }
-    sweeps.push({
-      ...table.ttl.after === void 0 ? {} : { after: table.ttl.after },
-      field: table.ttl.field,
-      ...table.softDelete ? { softDeleteField: table.softDelete.field } : {},
-      table: table.name
-    });
-  }
-  return sweeps;
-};
-const buildTableColumns = (schema) => {
-  const byTable = {};
-  for (const table of schema.tables) {
-    const columns = [
-      { name: "_id", optional: false, pk: true, type: "id" },
-      { name: "_creationTime", optional: false, type: "number" }
-    ];
-    for (const [field, validator] of Object.entries(table.shape)) {
-      const optional = validator.kind === "optional" || Boolean(validator.column?.hasDefault);
-      const resolved = validator.kind === "optional" && validator.inner ? validator.inner : validator;
-      const column = { name: field, optional, type: resolved.kind };
-      if (resolved.kind === "id" && resolved.tableName !== void 0) {
-        column.ref = resolved.tableName;
-      }
-      if (resolved.kind === "storage") {
-        column.isStorage = true;
-      }
-      columns.push(column);
-    }
-    byTable[table.name] = columns;
-  }
-  return byTable;
-};
-const emitRelationFanout = (hasGlobalTables) => {
-  if (!hasGlobalTables) {
-    return { importFragment: "", override: "" };
-  }
-  return {
-    importFragment: "serveRelationFanout, ",
-    override: `
-        protected override async runRelationFanoutRead(functionPath: string, args: Record<string, unknown>): Promise<unknown> {
-            this.ensureMigrated();
-
-            const { db } = this.buildCtx({ functionPath }) as { db: DatabaseWriterLike };
-
-            return serveRelationFanout(schema as unknown as SchemaLike, db, functionPath, args);
-        }
-`
-  };
-};
-const emitAiFragments = (hasAi) => {
-  if (!hasAi) {
-    return { build: "", configField: "", contextField: "", stub: "" };
-  }
-  const aiMissing = `throw new Error("ctx.ai: no AI binding found. Add an \\\`ai\\\` binding (env.AI) to wrangler.jsonc, or pass \\\`ai\\\` to createShardDO().");`;
-  return {
-    // Build ctx.ai from the resolved Workers AI binding (a `config.ai` thunk
-    // override, else `env.AI`). createAi is provider-agnostic — a model-id
-    // string resolves Workers AI, any AI SDK model object passes through — so
-    // a handler is never locked to Workers AI. Falls back to `aiStub`.
-    build: `
-            const aiBinding = config.ai?.(env) ?? (env as Record<string, unknown>).AI;
-            // Correlate AI-Gateway-routed calls with the Lunora trace: thread the
-            // function path + trace id into createAi, which folds them into the
-            // gateway's native \`metadata\` only when a gateway is configured (absent
-            // otherwise). Mirror the tracer's anchor guard — a deferred subscription
-            // re-run must not borrow a concurrent dispatch's trace, so read
-            // \`getCurrentTrace()\` only on the synchronous (non-threaded-identity) path.
-            const aiTrace = options.identity ? undefined : this.getCurrentTrace();
-            const ai: LunoraAi = aiBinding
-                ? createAi({ binding: aiBinding as AiBindingLike, env: env as Record<string, unknown>, metadata: { functionPath: options.functionPath, traceId: aiTrace?.traceId } })
-                : aiStub;
-`,
-    // Optional override for the Workers AI binding. When omitted, ctx.ai is
-    // built from `env.AI` (the conventional binding the config layer
-    // auto-reconciles); the thunk lets a caller point it elsewhere or inject
-    // a double in tests.
-    configField: `
-    ai?: (env: Record<string, unknown>) => AiBindingLike;`,
-    contextField: `
-                ai,`,
-    stub: `
-const aiStub: LunoraAi = {
-    embeddingModel: () => {
-        ${aiMissing}
-    },
-    model: () => {
-        ${aiMissing}
-    },
-    run: async () => {
-        ${aiMissing}
-    },
-    // workersai is a callable-with-properties; a bare throwing arrow isn't
-    // structurally assignable, so cast it. Never invoked (the stub throws first).
-    workersai: (() => {
-        ${aiMissing}
-    }) as unknown as LunoraAi["workersai"],
-};
-`
-  };
-};
-const EMPTY_HELPER_FRAGMENTS = { build: "", configField: "", contextField: "", importLines: [], stub: "" };
-const emitKvFragments = (hasKv) => {
-  if (!hasKv) {
-    return EMPTY_HELPER_FRAGMENTS;
-  }
-  const kvMissing = `throw new Error("ctx.kv: no KV binding found. Add a \\\`kv_namespaces\\\` binding (env.KV) to wrangler.jsonc, or pass \\\`kv\\\` to createShardDO().");`;
-  return {
-    build: `
-            const kvBinding = config.kv?.(env) ?? (env as Record<string, unknown>).KV;
-            const kv: Kv = kvBinding ? createKv({ namespace: kvBinding as KVNamespaceLike }) : kvStub;
-`,
-    configField: `
-    kv?: (env: Record<string, unknown>) => KVNamespaceLike;`,
-    contextField: `
-                kv,`,
-    importLines: [`import type { Kv, KVNamespaceLike } from "@lunora/bindings/kv";`, `import { createKv } from "@lunora/bindings/kv";`],
-    stub: `
-const kvStub: Kv = {
-    delete: async () => {
-        ${kvMissing}
-    },
-    get: async () => {
-        ${kvMissing}
-    },
-    getRaw: async () => {
-        ${kvMissing}
-    },
-    getWithMetadata: async () => {
-        ${kvMissing}
-    },
-    list: async () => {
-        ${kvMissing}
-    },
-    put: async () => {
-        ${kvMissing}
-    },
-};
-`
-  };
-};
-const emitFlagsFragments = (hasFlags, flagsSpecifier) => {
-  if (!hasFlags) {
-    return EMPTY_HELPER_FRAGMENTS;
-  }
-  return {
-    build: `
-            const flags: import("${flagsSpecifier}").LunoraFlags = createFlags({
-                hooks: flagsConfig.hooks,
-                logger: flagsConfig.logger,
-                provider: () => config.flags?.(env) ?? flagsConfig.provider(env),
-                targetingKey: () => flagsConfig.identify?.({ identity: identity ?? null, userId: userId ?? null }),
-            });
-`,
-    configField: `
-    flags?: (env: Record<string, unknown>) => import("${flagsSpecifier}").Provider;`,
-    contextField: `
-                flags,`,
-    importLines: [`import { createFlags } from "${flagsSpecifier}";`, `import flagsConfig from "../flags.js";`],
-    stub: ""
-  };
-};
-const emitNotifyFragments = (hasNotify) => {
-  if (!hasNotify) {
-    return EMPTY_HELPER_FRAGMENTS;
-  }
-  return {
-    // Threads the request's `ctx.log` / `ctx.metrics` into the facade so a send
-    // emits the `notify.send` / `notify.skipped` observability signals. Because
-    // `log`/`metrics` are built LATER in the context builder, this fragment is
-    // injected after them (see `notifyBuild` below), NOT inside `everyContextBuild`.
-    build: `
-            const { notify, push } = createNotify(notifyConfig, env, { log, metrics });
-`,
-    configField: "",
-    contextField: `
-                notify,
-                push,`,
-    importLines: [`import { createNotify } from "@lunora/notify";`, `import notifyConfig from "../notify.js";`],
-    stub: ""
-  };
-};
-const emitEnvFragments = (env) => {
-  if (!env) {
-    return EMPTY_HELPER_FRAGMENTS;
-  }
-  return {
-    build: `
-            const envConfig = lunoraEnvContract.${env.exportName}(env);
-`,
-    configField: "",
-    contextField: `
-                env: envConfig,`,
-    importLines: [`import * as lunoraEnvContract from "../env.js";`],
-    stub: ""
-  };
-};
-const emitAccessFragments = (hasAccessFacade) => {
-  if (!hasAccessFacade) {
-    return EMPTY_HELPER_FRAGMENTS;
-  }
-  return {
-    build: `
-            const access = accessFacade(identity, userId);
-`,
-    configField: "",
-    contextField: `
-                access,`,
-    importLines: [`import { accessFacade } from "@lunora/cloudflare-access/context";`],
-    stub: ""
-  };
-};
-const emitFlagsOverrides = (flagKeys, hasFlags, flagsSpecifier) => {
-  if (!hasFlags) {
-    return { constant: "", evaluateOverride: "", subscriptionOverride: "" };
-  }
-  const clientBuild = (targetingKey) => `
-            const env = (this.env ?? {}) as Record<string, unknown>;
-            const flags: import("${flagsSpecifier}").LunoraFlags = createFlags({
-                hooks: flagsConfig.hooks,
-                logger: flagsConfig.logger,
-                provider: () => config.flags?.(env) ?? flagsConfig.provider(env),
-                targetingKey: ${targetingKey},
-            });`;
-  const constant = `
-/** Statically-discovered feature flags (\`ctx.flags.<type>("key")\` reads) served via \`__lunora_admin__:listFlags\` + the reactive \`__lunora_flags__:\` channel. */
-const LUNORA_FLAG_KEYS: ReadonlyArray<{ key: string; type: "boolean" | "number" | "object" | "string" }> = ${JSON.stringify(flagKeys, void 0, 4)};
-`;
-  const evaluateOverride = `
-        protected override async evaluateFlags(context?: Record<string, unknown>): Promise<FlagsResult> {${clientBuild("undefined")}
-            const evalContext = context as import("${flagsSpecifier}").EvaluationContext | undefined;
-            const evaluations: FlagsResult["flags"] = [];
-
-            for (const entry of LUNORA_FLAG_KEYS) {
-                // eslint-disable-next-line no-await-in-loop -- flags evaluate sequentially; each shares the single memoized provider client
-                const details =
-                    entry.type === "boolean"
-                        ? await flags.details.boolean(entry.key, false, evalContext)
-                        : entry.type === "number"
-                          ? await flags.details.number(entry.key, 0, evalContext)
-                          : entry.type === "string"
-                            ? await flags.details.string(entry.key, "", evalContext)
-                            : await flags.details.object(entry.key, {}, evalContext);
-
-                evaluations.push({ errorCode: details.errorCode, key: entry.key, reason: details.reason, type: entry.type, value: details.value, variant: details.variant });
-            }
-
-            return { configured: true, flags: evaluations };
-        }
-`;
-  const subscriptionOverride = `
-        protected override runFlagSubscriptionRead(_functionPath: string, args: Record<string, unknown>, identity?: { identity?: Record<string, unknown>; userId?: string }): Promise<unknown> {${clientBuild("() => flagsConfig.identify?.({ identity: identity?.identity ?? null, userId: identity?.userId ?? null })")}
-            const key = typeof args.key === "string" ? args.key : "";
-
-            // SECURITY: the reactive channel is public (any socket, no auth). Serve
-            // ONLY statically-discovered flag keys — an arbitrary client-supplied key
-            // would let a subscriber probe the value of internal/unreleased flags the
-            // app never exposes. Unknown key ⇒ the "nothing to deliver" sentinel.
-            // eslint-disable-next-line unicorn/no-null -- the base hook's "nothing to deliver" sentinel
-            if (key.length === 0 || !LUNORA_FLAG_KEYS.some((entry) => entry.key === key)) {
-                return Promise.resolve(null);
-            }
-
-            // SECURITY: evaluate under the socket's server-verified identity ONLY
-            // (the targetingKey resolved above). Client-supplied targeting context is
-            // NOT honored on this public channel — otherwise a subscriber could spoof
-            // targeting attributes (e.g. plan/role) to unlock a flag gated on them.
-            const context = undefined;
-
-            if (args.type === "number") {
-                return flags.number(key, typeof args.default === "number" ? args.default : 0, context);
-            }
-
-            if (args.type === "string") {
-                return flags.string(key, typeof args.default === "string" ? args.default : "", context);
-            }
-
-            if (args.type === "object") {
-                return flags.object(key, (args.default ?? {}) as import("${flagsSpecifier}").JsonValue, context);
-            }
-
-            return flags.boolean(key, typeof args.default === "boolean" ? args.default : false, context);
-        }
-`;
-  return { constant, evaluateOverride, subscriptionOverride };
-};
-const emitAnalyticsFragments = (hasAnalytics) => {
-  if (!hasAnalytics) {
-    return EMPTY_HELPER_FRAGMENTS;
-  }
-  const analyticsMissing = `throw new Error("ctx.analytics: no Analytics Engine binding found. Add an \\\`analytics_engine_datasets\\\` binding (env.ANALYTICS) to wrangler.jsonc, or pass \\\`analytics\\\` to createShardDO().");`;
-  return {
-    build: `
-            const analyticsBinding = config.analytics?.(env) ?? (env as Record<string, unknown>).ANALYTICS;
-            const analytics: AnalyticsClient = analyticsBinding ? createAnalytics(analyticsBinding as AnalyticsEngineDatasetLike) : analyticsStub;
-`,
-    configField: `
-    analytics?: (env: Record<string, unknown>) => AnalyticsEngineDatasetLike;`,
-    contextField: `
-                analytics,`,
-    importLines: [
-      `import type { AnalyticsClient, AnalyticsEngineDatasetLike } from "@lunora/bindings/analytics";`,
-      `import { createAnalytics } from "@lunora/bindings/analytics";`
-    ],
-    stub: `
-const analyticsStub: AnalyticsClient = {
-    track: () => {
-        ${analyticsMissing}
-    },
-    writeDataPoint: () => {
-        ${analyticsMissing}
-    },
-};
-`
-  };
-};
-const emitImagesFragments = (hasImages) => {
-  if (!hasImages) {
-    return EMPTY_HELPER_FRAGMENTS;
-  }
-  const imagesMissing = `throw new Error("ctx.images: no Images binding found. Add an \\\`images\\\` binding (env.IMAGES) to wrangler.jsonc, or pass \\\`images\\\` to createShardDO().");`;
-  return {
-    build: `
-            const imagesBinding = config.images?.(env) ?? (env as Record<string, unknown>).IMAGES;
-            const images: Images = imagesBinding ? createImages({ binding: imagesBinding as ImagesBindingLike }) : imagesStub;
-`,
-    configField: `
-    images?: (env: Record<string, unknown>) => ImagesBindingLike;`,
-    // ActionCtx-only: woven onto the action ctx object, never query/mutation.
-    contextField: `
-                images,`,
-    importLines: [`import type { Images, ImagesBindingLike } from "@lunora/bindings/images";`, `import { createImages } from "@lunora/bindings/images";`],
-    stub: `
-const imagesStub: Images = {
-    info: async () => {
-        ${imagesMissing}
-    },
-    transform: async () => {
-        ${imagesMissing}
-    },
-};
-`
-  };
-};
-const emitHyperdriveFragments = (hasHyperdrive) => {
-  if (!hasHyperdrive) {
-    return EMPTY_HELPER_FRAGMENTS;
-  }
-  const sqlMissing = `throw new Error("ctx.sql: provide a \\\`sql\\\` config thunk that builds a SqlClient from your driver, e.g. \\\`sql: (env) => fromPostgresJs(postgres(env.HYPERDRIVE.connectionString))\\\`.");`;
-  return {
-    build: `
-            const sql: SqlClient = config.sql ? config.sql(env) : sqlStub;
-`,
-    configField: `
-    sql?: (env: Record<string, unknown>) => SqlClient;`,
-    // ActionCtx-only: woven onto the action ctx object, never query/mutation.
-    contextField: `
-                sql,`,
-    importLines: [`import type { SqlClient } from "@lunora/hyperdrive";`],
-    stub: `
-const sqlStub: SqlClient = {
-    query: async () => {
-        ${sqlMissing}
-    },
-};
-`
-  };
-};
-const emitBrowserFragments = (hasBrowser) => {
-  if (!hasBrowser) {
-    return EMPTY_HELPER_FRAGMENTS;
-  }
-  const browserMissing = `throw new Error("ctx.browser: provide a \\\`browser\\\` config thunk, e.g. \\\`browser: (env) => createBrowser({ binding: env.BROWSER, launch })\\\` with \\\`import { launch } from '@cloudflare/playwright'\\\`.");`;
-  return {
-    build: `
-            const browser: Browser = config.browser ? config.browser(env) : browserStub;
-`,
-    configField: `
-    browser?: (env: Record<string, unknown>) => Browser;`,
-    // ActionCtx-only: woven onto the action ctx object, never query/mutation.
-    contextField: `
-                browser,`,
-    // Type-only import: the generated build never calls `createBrowser`
-    // (the `config.browser` thunk owns construction, injecting the optional
-    // `@cloudflare/playwright` peer the worker stays free of), so only the
-    // `Browser` type is referenced here.
-    importLines: [`import type { Browser } from "@lunora/browser";`],
-    stub: `
-const browserStub: Browser = {
-    content: async () => {
-        ${browserMissing}
-    },
-    launch: async () => {
-        ${browserMissing}
-    },
-    pdf: async () => {
-        ${browserMissing}
-    },
-    scrape: async () => {
-        ${browserMissing}
-    },
-    screenshot: async () => {
-        ${browserMissing}
-    },
-};
-`
-  };
-};
-const emitR2sqlFragments = (hasR2sql) => {
-  if (!hasR2sql) {
-    return EMPTY_HELPER_FRAGMENTS;
-  }
-  const r2sqlMissing = `throw new Error("ctx.r2sql: no R2 SQL credentials found. Set \\\`R2_SQL_TOKEN\\\`, \\\`R2_SQL_ACCOUNT_ID\\\` (or \\\`CLOUDFLARE_ACCOUNT_ID\\\`), and \\\`R2_SQL_BUCKET\\\` in your env/.dev.vars, or pass an \\\`r2sql\\\` config thunk to createShardDO().");`;
-  return {
-    build: `
-            const r2sqlEnv = env as Record<string, unknown>;
-            const r2sqlAccountId = (r2sqlEnv.R2_SQL_ACCOUNT_ID ?? r2sqlEnv.CLOUDFLARE_ACCOUNT_ID) as string | undefined;
-            const r2sqlToken = r2sqlEnv.R2_SQL_TOKEN as string | undefined;
-            const r2sqlBucket = r2sqlEnv.R2_SQL_BUCKET as string | undefined;
-            const r2sql: R2SqlClient = config.r2sql
-                ? config.r2sql(env)
-                : r2sqlAccountId && r2sqlToken && r2sqlBucket
-                  ? createR2Sql({ accountId: r2sqlAccountId, apiToken: r2sqlToken, bucket: r2sqlBucket })
-                  : r2sqlStub;
-`,
-    configField: `
-    r2sql?: (env: Record<string, unknown>) => R2SqlClient;`,
-    // ActionCtx-only: attached via the \`ctx.r2sql = r2sql\` assignment in the
-    // \`isAction\` block, never the every-ctx object literal.
-    contextField: "",
-    importLines: [`import type { R2SqlClient } from "@lunora/bindings/r2sql";`, `import { createR2Sql } from "@lunora/bindings/r2sql";`],
-    // The stub is typed `R2SqlClient`, so TS flags a missing method at build
-    // time — but it must stay structurally in sync with that interface
-    // (`@lunora/bindings/r2sql` client.ts) when a method is added there.
-    stub: `
-const r2sqlStub: R2SqlClient = {
-    describe: async () => {
-        ${r2sqlMissing}
-    },
-    explain: async () => {
-        ${r2sqlMissing}
-    },
-    from: () => {
-        ${r2sqlMissing}
-    },
-    query: async () => {
-        ${r2sqlMissing}
-    },
-    showDatabases: async () => {
-        ${r2sqlMissing}
-    },
-    showTables: async () => {
-        ${r2sqlMissing}
-    },
-};
-`
-  };
-};
-const emitPipelinesFragments = (hasPipelines) => {
-  if (!hasPipelines) {
-    return EMPTY_HELPER_FRAGMENTS;
-  }
-  const pipelinesMissing = `throw new Error("ctx.pipelines: no Pipelines binding found. Add a \\\`pipelines\\\` binding (env.PIPELINES) to wrangler.jsonc, or pass \\\`pipelines\\\` to createShardDO().");`;
-  return {
-    build: `
-            const pipelinesBinding = config.pipelines?.(env) ?? (env as Record<string, unknown>).PIPELINES;
-            const pipelines: PipelineClient = pipelinesBinding ? createPipelines({ binding: pipelinesBinding as PipelineBindingLike }) : pipelinesStub;
-`,
-    configField: `
-    pipelines?: (env: Record<string, unknown>) => PipelineBindingLike;`,
-    // ActionCtx-only: attached via the \`ctx.pipelines = pipelines\` assignment
-    // in the \`isAction\` block, never the every-ctx object literal.
-    contextField: "",
-    importLines: [
-      `import type { PipelineBindingLike, PipelineClient } from "@lunora/bindings/pipelines";`,
-      `import { createPipelines } from "@lunora/bindings/pipelines";`
-    ],
-    stub: `
-const pipelinesStub: PipelineClient = {
-    send: async () => {
-        ${pipelinesMissing}
-    },
-};
-`
-  };
-};
-const emitContainers = (containers, jurisdiction) => {
-  if (containers.length === 0) {
-    return "";
-  }
-  const jurisdictionArgument = jurisdiction ? `, ${JSON.stringify(jurisdiction)}` : "";
-  const classes = containers.map((container) => {
-    assertIdentifier(container.exportName, `container export "${container.exportName}"`);
-    assertIdentifier(container.className, `container class "${container.className}"`);
-    return `/** Container DO for the \`${container.exportName}\` definition (binding \`${container.bindingName}\`). */
-export class ${container.className} extends LunoraContainer {
-    public constructor(ctx: ConstructorParameters<typeof LunoraContainer>[0], env: Record<string, unknown>) {
-        super(ctx, env, ${container.exportName}, "${container.exportName}"${jurisdictionArgument});
-    }
-}
-`;
-  }).join("\n");
-  const imports = containers.map((container) => container.exportName).join(", ");
-  return `${GENERATED_HEADER}/**
- * Container-enabled Durable Object classes for the containers declared in
- * \`lunora/containers.ts\`. Re-export them from your worker entry — wrangler
- * requires each \`containers[].class_name\` to be exported by the worker:
- *
- * \`export * from "./lunora/_generated/containers.js";\`
- *
- * \`ContainerProxy\` is re-exported alongside them: the egress-interception path
- * (\`allowedHosts\`/\`deniedHosts\`/\`interceptHttps\` and the runtime
- * \`handle.egress\` controls) routes container outbound traffic through this
- * WorkerEntrypoint, so it too must be exported by the deployed worker.
- */
-import { LunoraContainer } from "@lunora/container/do";
-
-import { ${imports} } from "../containers.js";
-
-export { ContainerProxy } from "@lunora/container/do";
-
-${classes}`;
-};
-const emitContainerFragments = (containers, jurisdiction) => {
-  if (containers.length === 0) {
-    return { build: "", contextField: "", importLines: [], specs: "" };
-  }
-  for (const container of containers) {
-    assertIdentifier(container.exportName, `container export "${container.exportName}"`);
-    assertIdentifier(container.bindingName, `container binding "${container.bindingName}"`);
-  }
-  const specEntries = containers.map((container) => {
-    const maxInstances = container.maxInstances === void 0 ? "" : `, maxInstances: ${String(container.maxInstances)}`;
-    return `    { binding: "${container.bindingName}", exportName: "${container.exportName}"${maxInstances} },`;
-  }).join("\n");
-  return {
-    // Schema `.jurisdiction("…")` pins every container DO this shard reaches
-    // to the data-residency region (`undefined` when undeclared). The trailing
-    // `this.getCurrentTraceparent()` forwards the inbound RPC's W3C trace
-    // context onto outbound container fetches so their spans join the trace.
-    build: `
-            const containers = createContainerContext(env, LUNORA_CONTAINERS, ${jurisdiction ? JSON.stringify(jurisdiction) : "undefined"}, this.getCurrentTraceparent());
-`,
-    contextField: `
-                containers,`,
-    importLines: [`import type { ContainerBindingSpec } from "@lunora/container";`, `import { createContainerContext } from "@lunora/container";`],
-    // eslint-disable-next-line no-secrets/no-secrets -- the emitted readonly-array type annotation is dense generated TS, not a credential
-    specs: `
-/** Wiring specs for \`ctx.containers\` (codegen-derived from \`lunora/containers.ts\`). */
-const LUNORA_CONTAINERS: ReadonlyArray<ContainerBindingSpec> = [
-${specEntries}
-];
-`
-  };
-};
-const emitWorkflows = (workflows) => {
-  if (workflows.length === 0) {
-    return "";
-  }
-  const classes = workflows.map((workflow) => {
-    assertIdentifier(workflow.exportName, `workflow export "${workflow.exportName}"`);
-    assertIdentifier(workflow.className, `workflow class "${workflow.className}"`);
-    return `/** WorkflowEntrypoint for the \`${workflow.exportName}\` definition (binding \`${workflow.bindingName}\`). */
-export class ${workflow.className} extends LunoraWorkflow<WorkflowParamsOf<typeof ${workflow.exportName}>, WorkflowOutputOf<typeof ${workflow.exportName}>> {
-    public constructor(ctx: ConstructorParameters<typeof LunoraWorkflow>[0], env: Record<string, unknown>) {
-        super(ctx, env, ${workflow.exportName}, "${workflow.exportName}");
-    }
-}
-`;
-  }).join("\n");
-  const imports = workflows.map((workflow) => workflow.exportName).join(", ");
-  return `${GENERATED_HEADER}/**
- * WorkflowEntrypoint classes for the workflows declared in
- * \`lunora/workflows.ts\`. Re-export them from your worker entry — wrangler
- * requires each \`workflows[].class_name\` to be exported by the worker:
- *
- * \`export * from "./lunora/_generated/workflows.js";\`
- */
-import LunoraWorkflow from "@lunora/workflow/do";
-
-import { ${imports} } from "../workflows.js";
-
-/** Params type carried by a \`defineWorkflow\` definition (its phantom \`__params\`), so each entrypoint keeps the authored \`ctx.params\` type. */
-type WorkflowParamsOf<Definition> = Definition extends { __params?: infer Params }
-    ? unknown extends Params
-        ? Record<string, unknown>
-        : NonNullable<Params>
-    : Record<string, unknown>;
-
-/** Output type carried by a \`defineWorkflow\` definition (its phantom \`__output\`), so each entrypoint keeps the authored return type. */
-type WorkflowOutputOf<Definition> = Definition extends { __output?: infer Output } ? Output : unknown;
-
-${classes}`;
-};
-const emitAgents = (agents) => {
-  if (agents.length === 0) {
-    return "";
-  }
-  const voiceAgents = agents.filter((agent) => agent.voice);
-  const hasVoice = voiceAgents.length > 0;
-  const classes = agents.map((agent) => {
-    assertIdentifier(agent.exportName, `agent export "${agent.exportName}"`);
-    assertIdentifier(agent.className, `agent class "${agent.className}"`);
-    const workflowClass = `/** WorkflowEntrypoint for the \`${agent.exportName}\` agent (binding \`${agent.bindingName}\`). */
-export class ${agent.className} extends LunoraWorkflow<AgentRunInput, AgentRunResult> {
-    public constructor(ctx: ConstructorParameters<typeof LunoraWorkflow>[0], env: Record<string, unknown>) {
-        super(ctx, env, compileAgentWorkflow(${agent.exportName}, "${agent.exportName}"), "${agent.exportName}");
-    }
-}
-`;
-    if (!agent.voice) {
-      return workflowClass;
-    }
-    const voiceClassName = agent.voiceClassName ?? "";
-    const voiceBindingName = agent.voiceBindingName ?? "";
-    assertIdentifier(voiceClassName, `agent voice class "${voiceClassName}"`);
-    const voiceClass = `
-/** Voice-session Durable Object for the \`${agent.exportName}\` agent (binding \`${voiceBindingName}\`). */
-export class ${voiceClassName} extends VoiceSessionDO {
-    public constructor(ctx: ConstructorParameters<typeof VoiceSessionDO>[0], env: Record<string, unknown>) {
-        super(ctx, env, ${agent.exportName}, "${agent.exportName}");
-    }
-}
-`;
-    return `${workflowClass}${voiceClass}`;
-  }).join("\n");
-  const imports = agents.map((agent) => agent.exportName).join(", ");
-  const runtimeImport = hasVoice ? `import { compileAgentWorkflow, VoiceSessionDO } from "@lunora/agent";` : `import { compileAgentWorkflow } from "@lunora/agent";`;
-  const voiceHeaderNote = hasVoice ? `
- *
- * Voice-enabled agents ALSO get a \`VoiceSessionDO\` subclass here — a real
- * Durable Object (unlike the Workflow), so wrangler needs both its
- * \`durable_objects\` binding and its \`class_name\` export (the same re-export
- * line covers it).` : "";
-  return `${GENERATED_HEADER}/**
- * WorkflowEntrypoint classes for the agents declared in \`lunora/agents.ts\`.
- * Each \`defineAgent\` compiles a replay-safe tool-loop onto a Cloudflare
- * Workflow. Re-export them from your worker entry — wrangler requires each
- * \`workflows[].class_name\` to be exported by the worker:
- *
- * \`export * from "./lunora/_generated/agents.js";\`${voiceHeaderNote}
- */
-import LunoraWorkflow from "@lunora/workflow/do";
-${runtimeImport}
-import type { AgentRunInput, AgentRunResult } from "@lunora/agent";
-
-import { ${imports} } from "../agents.js";
-
-${classes}`;
-};
-const emitQueues = (queues) => {
-  const pushQueues = queues.filter((queue) => queue.mode === "push");
-  if (pushQueues.length === 0) {
-    return "";
-  }
-  for (const queue of pushQueues) {
-    assertIdentifier(queue.exportName, `queue export "${queue.exportName}"`);
-  }
-  const imports = pushQueues.map((queue) => queue.exportName).join(", ");
-  const entries = pushQueues.map((queue) => `    ${JSON.stringify(queue.name)}: { definition: ${queue.exportName}, exportName: ${JSON.stringify(queue.exportName)} },`).join("\n");
-  return `${GENERATED_HEADER}/**
- * Push-consumer registry for the queues declared in \`lunora/queues.ts\`. The
- * composed worker's \`queue(batch, env, ctx)\` entry routes each delivered batch
- * by \`batch.queue\` to the matching \`defineQueue\` handler. Wired automatically
- * by \`defineApp\` — you don't import this directly.
- */
-import type { QueueRegistry } from "@lunora/queue";
-
-import { ${imports} } from "../queues.js";
-
-/** Stable wrangler queue name → { definition, exportName } for batch routing. */
-export const LUNORA_QUEUE_REGISTRY: QueueRegistry = {
-${entries}
-};
-`;
-};
-const emitWorkflowFragments = (workflows) => {
-  if (workflows.length === 0) {
-    return { build: "", contextField: "", importLines: [], specs: "" };
-  }
-  for (const workflow of workflows) {
-    assertIdentifier(workflow.exportName, `workflow export "${workflow.exportName}"`);
-    assertIdentifier(workflow.bindingName, `workflow binding "${workflow.bindingName}"`);
-  }
-  const specEntries = workflows.map((workflow) => `    { binding: "${workflow.bindingName}", exportName: "${workflow.exportName}" },`).join("\n");
-  return {
-    build: `
-            const workflows = createWorkflowContext(env, LUNORA_WORKFLOWS);
-`,
-    contextField: `
-                workflows,`,
-    importLines: [`import type { WorkflowBindingSpec } from "@lunora/workflow";`, `import { createWorkflowContext } from "@lunora/workflow";`],
-    // eslint-disable-next-line no-secrets/no-secrets -- the emitted readonly-array type annotation is dense generated TS, not a credential
-    specs: `
-/** Wiring specs for \`ctx.workflows\` (codegen-derived from \`lunora/workflows.ts\`). */
-const LUNORA_WORKFLOWS: ReadonlyArray<WorkflowBindingSpec> = [
-${specEntries}
-];
-`
-  };
-};
-const emitQueueFragments = (queues) => {
-  if (queues.length === 0) {
-    return { build: "", contextField: "", importLines: [], specs: "" };
-  }
-  for (const queue of queues) {
-    assertIdentifier(queue.exportName, `queue export "${queue.exportName}"`);
-    assertIdentifier(queue.bindingName, `queue binding "${queue.bindingName}"`);
-  }
-  const specEntries = queues.map((queue) => `    { binding: "${queue.bindingName}", exportName: "${queue.exportName}", name: ${JSON.stringify(queue.name)} },`).join("\n");
-  return {
-    build: `
-            const queues = createQueueContext(env, LUNORA_QUEUES);
-`,
-    contextField: `
-                queues,`,
-    importLines: [`import type { QueueBindingSpec } from "@lunora/queue";`, `import { createQueueContext } from "@lunora/queue";`],
-    // eslint-disable-next-line no-secrets/no-secrets -- the emitted readonly-array type annotation is dense generated TS, not a credential
-    specs: `
-/** Wiring specs for \`ctx.queues\` (codegen-derived from \`lunora/queues.ts\`). */
-const LUNORA_QUEUES: ReadonlyArray<QueueBindingSpec> = [
-${specEntries}
-];
-`
-  };
-};
-const emitAgentFragments = (agents) => {
-  if (agents.length === 0) {
-    return { build: "", contextField: "", importLines: [], specs: "" };
-  }
-  for (const agent of agents) {
-    assertIdentifier(agent.exportName, `agent export "${agent.exportName}"`);
-    assertIdentifier(agent.bindingName, `agent binding "${agent.bindingName}"`);
-  }
-  const specEntries = agents.map((agent) => `    { binding: "${agent.bindingName}", exportName: "${agent.exportName}"${agent.publicRun === true ? ", publicRun: true" : ""} },`).join("\n");
-  return {
-    build: `
-            const agents = createAgentContext(env, LUNORA_AGENTS);
-`,
-    contextField: `
-                agents,`,
-    importLines: [`import { createAgentContext } from "@lunora/agent";`, `import type { AgentBindingSpec } from "@lunora/agent";`],
-    // eslint-disable-next-line no-secrets/no-secrets -- the emitted readonly-array type annotation is dense generated TS, not a credential
-    specs: `
-/** Wiring specs for \`ctx.agents\` (codegen-derived from \`lunora/agents.ts\`). */
-const LUNORA_AGENTS: ReadonlyArray<AgentBindingSpec> = [
-${specEntries}
-];
-`
-  };
-};
-const emitWorkflowsMetadataFragments = (workflows) => {
-  if (workflows.length === 0) {
-    return { constant: "", override: "" };
-  }
-  const metadata = {
-    workflows: workflows.map((workflow) => {
-      return {
-        binding: workflow.bindingName,
-        className: workflow.className,
-        exportName: workflow.exportName,
-        name: workflow.name
-      };
-    })
-  };
-  return {
-    constant: `
-/** Read-only declared-workflow metadata (discovered from \`lunora/workflows.ts\`) served via \`__lunora_admin__:listWorkflows\` for the studio's workflows view. */
-const LUNORA_WORKFLOWS_INFO: WorkflowsResult = ${JSON.stringify(metadata, void 0, 4)};
-`,
-    override: `
-        protected override workflowsMetadata(): WorkflowsResult {
-            return LUNORA_WORKFLOWS_INFO;
-        }
-`
-  };
-};
-const emitQueuesMetadataFragments = (queues) => {
-  if (queues.length === 0) {
-    return { constant: "", override: "" };
-  }
-  const metadata = {
-    queues: queues.map((queue) => {
-      return {
-        binding: queue.bindingName,
-        ...queue.tuning.deadLetterQueue === void 0 ? {} : { deadLetterQueue: queue.tuning.deadLetterQueue },
-        exportName: queue.exportName,
-        mode: queue.mode,
-        name: queue.name
-      };
-    })
-  };
-  return {
-    constant: `
-/** Read-only declared-queue metadata (discovered from \`lunora/queues.ts\`) served via \`__lunora_admin__:listQueues\` for the studio's queues view. */
-const LUNORA_QUEUES_INFO: QueuesResult = ${JSON.stringify(metadata, void 0, 4)};
-`,
-    override: `
-        protected override queuesMetadata(): QueuesResult {
-            return LUNORA_QUEUES_INFO;
-        }
-`
-  };
-};
-const emitPaymentFragments = (hasPayments) => {
-  if (!hasPayments) {
-    return { build: "", configField: "", contextField: "", imports: [], stub: "" };
-  }
-  const missing = `throw new Error("ctx.payments: no payment configured. Pass \\\`payment\\\` to createShardDO().");`;
-  return {
-    imports: [
-      `import type { LunoraDatabaseLike as LunoraPaymentDbLike, LunoraPayment, PaymentsFromContextOptions } from "@lunora/payment";`,
-      `import { paymentsFromContext } from "@lunora/payment";`
-    ],
-    // Built after `db` (the store rides ctx.db) and `userId` (the default authorizer ties a
-    // referenceId to the caller). The adapter — which carries provider secrets — comes from
-    // the `config.payment` thunk over env. Falls back to `paymentStub`.
-    build: `
-            const payments: LunoraPayment = config.payment
-                ? paymentsFromContext({ auth: { userId: userId ?? null }, db: db as unknown as LunoraPaymentDbLike }, config.payment(env))
-                : paymentStub;
-`,
-    configField: `
-    payment?: (env: Record<string, unknown>) => PaymentsFromContextOptions;`,
-    contextField: `
-                payments,`,
-    stub: `
-const paymentStub: LunoraPayment = {
-    attach: () => {
-        ${missing}
-    },
-    cancelSubscription: () => {
-        ${missing}
-    },
-    check: () => {
-        ${missing}
-    },
-    createCheckout: () => {
-        ${missing}
-    },
-    createPortalSession: () => {
-        ${missing}
-    },
-    handleWebhook: () => {
-        ${missing}
-    },
-    listBalances: () => {
-        ${missing}
-    },
-    listSubscriptions: () => {
-        ${missing}
-    },
-    track: () => {
-        ${missing}
-    },
-} as unknown as LunoraPayment;
-`
-  };
-};
-const emitX402Fragments = (hasX402) => {
-  if (!hasX402) {
-    return { build: "", configField: "", contextField: "", imports: [], stub: "" };
-  }
-  return {
-    imports: [`import type { X402Pay, X402PayConfig } from "@lunora/x402/pay";`, `import { lazyX402Pay } from "@lunora/x402/pay";`],
-    // Built lazily off `secrets` (the Secrets Store facade already in scope) and
-    // the `config.x402` thunk over env; falls back to `x402Stub`.
-    build: `
-            const x402: X402Pay = config.x402
-                ? lazyX402Pay(config.x402(env), { getSecret: (name: string) => secrets.get(name) })
-                : x402Stub;
-`,
-    configField: `
-    x402?: (env: Record<string, unknown>) => X402PayConfig;`,
-    contextField: `
-                x402,`,
-    stub: `
-const x402Stub: X402Pay = {
-    fetch: () => {
-        throw new Error("ctx.x402: no pay rail configured. Pass \\\`x402\\\` to createShardDO().");
-    },
-} as unknown as X402Pay;
-`
-  };
-};
-const buildDoTypeImports = (hasVectors, hasWorkflows, hasQueues, hasFlags) => [
-  "AdvisoryFinding",
-  "DatabaseWriterLike",
-  "DataMigrationLike",
-  ...hasFlags ? ["FlagsResult"] : [],
-  "LogSink",
-  "MaskPoliciesResult",
-  "MigrationRunResult",
-  ...hasQueues ? ["QueuesResult"] : [],
-  "RunShardApplyCdcArgs",
-  "RunShardMigrationArgs",
-  "RlsPoliciesResult",
-  "RunShardRankBeforeArgs",
-  "RunShardRankPageArgs",
-  "RunShardWriteArgs",
-  "RunShardWriteResult",
-  "SchedulerLike",
-  "SchemaLike",
-  "ShardDOState",
-  "ShardRankPageResult",
-  "SqlExec",
-  "StorageRulesResult",
-  "StudioFeaturesResult",
-  "SystemReaderStorageLike",
-  ...hasWorkflows ? ["WorkflowsResult"] : [],
-  ...hasVectors ? ["WriteHook"] : []
-];
-const emitShard = ({
-  advisories = [],
-  agents = [],
-  containers = [],
-  env,
-  flagKeys = [],
-  hasAccessFacade = false,
-  hasAi = false,
-  hasAnalytics = false,
-  hasBrowser = false,
-  hasFlags = false,
-  hasHyperdrive = false,
-  hasImages = false,
-  hasKv = false,
-  hasNotify = false,
-  hasPayments = false,
-  hasPipelines = false,
-  hasR2sql = false,
-  hasX402 = false,
-  maskMetadata,
-  mutators = [],
-  queues = [],
-  rlsMetadata,
-  schema,
-  shapes = [],
-  storageRules,
-  studioFeatures,
-  useUmbrella = false,
-  workflows = []
-}) => {
-  const base = baseSpecifiers(useUmbrella);
-  const hasMutators = mutators.length > 0;
-  const hasShapes = shapes.length > 0;
-  const { build: aiBuild, configField: aiConfigField, contextField: aiContextField, stub: aiStub } = emitAiFragments(hasAi);
-  const accessFragments = emitAccessFragments(hasAccessFacade);
-  const kvFragments = emitKvFragments(hasKv);
-  const flagsFragments = emitFlagsFragments(hasFlags, base.flags);
-  const flagsOverrides = emitFlagsOverrides(flagKeys, hasFlags, base.flags);
-  const notifyFragments = emitNotifyFragments(hasNotify);
-  const envFragments = emitEnvFragments(env);
-  const analyticsFragments = emitAnalyticsFragments(hasAnalytics);
-  const imagesFragments = emitImagesFragments(hasImages);
-  const hyperdriveFragments = emitHyperdriveFragments(hasHyperdrive);
-  const browserFragments = emitBrowserFragments(hasBrowser);
-  const r2sqlFragments = emitR2sqlFragments(hasR2sql);
-  const pipelinesFragments = emitPipelinesFragments(hasPipelines);
-  const { build: queuesBuild, contextField: queuesContextField, importLines: queueImportLines, specs: queueSpecs } = emitQueueFragments(queues);
-  const {
-    build: containersBuild,
-    contextField: containersContextField,
-    importLines: containerImportLines,
-    specs: containerSpecs
-  } = emitContainerFragments(containers, schema.jurisdiction);
-  const {
-    build: workflowsBuild,
-    contextField: workflowsContextField,
-    importLines: workflowImportLines,
-    specs: workflowSpecs
-  } = emitWorkflowFragments(workflows);
-  const { build: agentsBuild, contextField: agentsContextField, importLines: agentImportLines, specs: agentSpecs } = emitAgentFragments(agents);
-  const {
-    build: paymentsBuild,
-    configField: paymentsConfigField,
-    contextField: paymentsContextField,
-    imports: paymentsImports,
-    stub: paymentStub
-  } = emitPaymentFragments(hasPayments);
-  const { build: x402Build, configField: x402ConfigField, imports: x402Imports, stub: x402Stub } = emitX402Fragments(hasX402);
-  const advisoryData = advisories;
-  const rlsData = rlsMetadata ?? { policies: [], roles: [] };
-  const maskData = maskMetadata ?? { columns: [] };
-  const storageRulesData = storageRules ?? { rules: [] };
-  const studioFeaturesData = studioFeatures ?? {
-    analytics: false,
-    auth: false,
-    containers: false,
-    flags: false,
-    kv: false,
-    mail: false,
-    payments: false,
-    queues: false,
-    scheduler: false,
-    storage: false,
-    vectors: false,
-    workflows: false
-  };
-  const { constant: workflowsMetadataConst, override: workflowsMetadataOverride } = emitWorkflowsMetadataFragments(workflows);
-  const { constant: queuesMetadataConst, override: queuesMetadataOverride } = emitQueuesMetadataFragments(queues);
-  const hasVectors = schema.vectorIndexes.length > 0;
-  const hasGlobalTables = schema.tables.some((table) => table.shardMode === "global");
-  const hasHyperdriveGlobal = schema.tables.some((table) => table.shardMode === "global" && table.globalBackend === "hyperdrive");
-  const hasD1Global = schema.tables.some((table) => table.shardMode === "global" && table.globalBackend !== "hyperdrive");
-  const hasSourcedTables = schema.tables.some((table) => table.externalSource !== void 0);
-  if (hasD1Global && hasHyperdriveGlobal) {
-    throw new LunoraError(
-      "INTERNAL",
-      'lunora codegen: mixing `.global()` (D1) and `.global({ backend: "hyperdrive" })` tables in one app is not supported yet — use a single global backend.'
-    );
-  }
-  const hasTables = schema.tables.length > 0;
-  const tableReferences = buildTableReferences(schema);
-  const tableIndexes = buildTableIndexes(schema);
-  const tableColumns = buildTableColumns(schema);
-  const storageColumns = buildStorageColumns(schema);
-  const ttlSweeps = buildTtlSweeps(schema);
-  const doTypeImports = buildDoTypeImports(hasVectors, workflows.length > 0, queues.length > 0, hasFlags);
-  if (hasShapes) {
-    doTypeImports.push("WhereInput");
-  }
-  const relationFanout = emitRelationFanout(hasGlobalTables);
-  const shapeResolveOverride = hasShapes ? `
-        protected override resolveShape(name: string, args: Record<string, unknown>, identity?: { identity?: Record<string, unknown>; userId?: string }): { columns?: readonly string[]; effectiveWhere?: WhereInput; global?: boolean; table: string } | undefined {
-            const shape = LUNORA_SHAPES[name];
-
-            if (!shape) {
-                return undefined;
-            }
-
-            this.ensureMigrated();
-
-            // Trusted ctx from the socket's OWN verified identity — the client
-            // supplies only the shape name + args; \`compileWhere\` validates the
-            // args then runs the shape's \`where(ctx, args)\` under that identity,
-            // so which rows replicate is a server decision (reads-as-permissions).
-            const ctx = this.buildCtx({ functionPath: \`__shape__:\${name}\`, identity });
-            const shapeWhere = shape.compileWhere(ctx, args) as unknown as WhereInput;
-
-            // AND-compose with the table's RLS read base-where. A shape runs no
-            // procedure, so the \`.use(rls(...))\` middleware never fires; without
-            // this merge its reads would bypass every read policy on the table
-            // (rows the caller can't see would replicate). \`composeShapeReadWhere\`
-            // evaluates the table's read policies under this same trusted ctx —
-            // exactly the request-time path — and fails closed under a
-            // \`.rls("required")\` schema for a non-\`.public()\`, policy-less table.
-            const effectiveWhere = composeShapeReadWhere(LUNORA_RLS_READ_REGISTRY, {
-                ctx,
-                identity: identity?.identity ?? null,
-                rlsRequired: (schema as unknown as { rlsMode?: string }).rlsMode === "required",
-                roles: (ctx as { auth?: { roles?: readonly string[] } }).auth?.roles ?? [],
-                shapeWhere,
-                table: shape.table,
-                tablePublic: (schema as unknown as { tables: Record<string, { isPublic?: boolean }> }).tables[shape.table]?.isPublic === true,
-                userId: identity?.userId ?? null,
-            });
-
-            // A live shape pokes only from its OWN shard's op-log, so a \`where()\`
-            // that joins to a \`.shardBy()\` table (rows in another DO) is rejected
-            // here — the first point the compiled predicate + shard modes are both
-            // known. Remedy: denormalize, or move the joined table to \`.global()\`.
-            assertShapeShardable(effectiveWhere, schema as unknown as SchemaLike, shape.table);
-
-            // A \`.global()\` table lives in D1 (no per-DO op-log): flag it so the
-            // base serves it through the latency-tiered poll path (\`readGlobalShapeRows\`)
-            // instead of the CDC poke path.
-            const isGlobal = (schema as unknown as SchemaLike).tables[shape.table]?.shardMode?.kind === "global";
-
-            return { columns: shape.columns, effectiveWhere, global: isGlobal, table: shape.table };
-        }
-` : "";
-  const customMutatorOverride = hasMutators ? `
-        protected override isCustomMutator(functionPath: string): boolean {
-            return LUNORA_MUTATOR_PATHS.has(functionPath);
-        }
-` : "";
-  const shapeReadRegistryConst = hasShapes ? `
-/** Per-table RLS read policies (hoisted from \`.use(rls(...))\` chains) the shape resolver AND-merges into each \`defineShape\` predicate so partial replication honours read policies. */
-const LUNORA_RLS_READ_REGISTRY = buildRlsReadRegistry(Object.values(LUNORA_FUNCTIONS));
-` : "";
-  const shapeGuardImport = hasShapes ? "assertShapeShardable, " : "";
-  const importLines = [
-    `import type { ${doTypeImports.join(", ")} } from "${base.do}";`,
-    `import { applyCdcChanges, ${shapeGuardImport}createShardCtxDb, ${hasSourcedTables ? "isSourceDue, pullExternalSourceIncrementalTick, pullExternalSourceTick, " : ""}runDataMigration, runShardMigrations, ${relationFanout.importFragment}ShardDO as ShardDOBase } from "${base.do}";`,
-    ...hasSourcedTables ? [`import type { ExternalSourceLike, SourceClientLike } from "${base.do}";`] : [],
-    // `asBucketStorage` (the bucket-aware `ctx.storage` wrapper) and
-    // `createSecrets` (the `ctx.secrets` core built-in) live in
-    // `@lunora/server`, the single source — imported here rather than stamped
-    // inline into every generated shard. With shapes, also pull the RLS
-    // read-registry builder + `composeShapeReadWhere` so `resolveShape` can
-    // AND-merge a shape's predicate with the table's read base-where.
-    hasShapes ? `import { asBucketStorage, buildRlsReadRegistry, composeShapeReadWhere, createSecrets, LunoraError } from "${base.server}";` : `import { asBucketStorage, createSecrets, LunoraError } from "${base.server}";`
-  ];
-  if (hasTables) {
-    importLines.push(`import { bindOrm, bindTableFacade } from "${base.server}";`);
-  }
-  if (hasVectors) {
-    importLines.push(
-      `import type { SchemaLike as VectorSchemaLike, VectorizeIndexLike, VectorSearchLike } from "@lunora/bindings/vectors";`,
-      `import { createContextVectors, createVectors, createVectorSyncHook } from "@lunora/bindings/vectors";`
-    );
-  }
-  if (hasAi) {
-    importLines.push(`import type { AiBindingLike, LunoraAi } from "@lunora/ai";`, `import { createAi } from "@lunora/ai";`);
-  }
-  importLines.push(
-    ...accessFragments.importLines,
-    ...kvFragments.importLines,
-    ...flagsFragments.importLines,
-    ...notifyFragments.importLines,
-    ...envFragments.importLines,
-    ...analyticsFragments.importLines,
-    ...imagesFragments.importLines,
-    ...hyperdriveFragments.importLines,
-    ...browserFragments.importLines,
-    ...r2sqlFragments.importLines,
-    ...pipelinesFragments.importLines,
-    ...containerImportLines,
-    ...workflowImportLines,
-    ...queueImportLines,
-    ...agentImportLines,
-    ...paymentsImports,
-    ...x402Imports,
-    ``,
-    `import schema from "../schema.js";`,
-    // Local-first sync registries are pulled in alongside the function table
-    // only when the project declares them, so the import list stays minimal.
-    `import { ${["LUNORA_FUNCTIONS", "LUNORA_LIFECYCLE_HOOKS", "LUNORA_MIGRATIONS", ...hasMutators ? ["LUNORA_MUTATOR_PATHS"] : [], ...hasShapes ? ["LUNORA_SHAPES"] : []].join(", ")} } from "./functions.js";`
-  );
-  const vectorsConfigField = hasVectors ? `
-    vectors?: (env: Record<string, unknown>) => Record<string, VectorizeIndexLike>;` : "";
-  const d1ConfigField = hasD1Global ? `
-    d1?: (env: Record<string, unknown>, request?: { identity?: Record<string, unknown>; userId?: string }) => DatabaseWriterLike | undefined;` : "";
-  const hyperdriveGlobalConfigField = hasHyperdriveGlobal ? `
-    hyperdriveGlobal?: (env: Record<string, unknown>, request?: { identity?: Record<string, unknown>; userId?: string }) => DatabaseWriterLike | undefined;` : "";
-  const sourceClientConfigField = hasSourcedTables ? `
-    sourceClient?: (env: Record<string, unknown>, binding: string) => { query: <Row = Record<string, unknown>>(text: string, params?: readonly unknown[]) => Promise<Row[]> } | undefined;` : "";
-  const globalDatabaseStub = hasGlobalTables ? `
-const globalDbStub: DatabaseWriterLike = {
-    aggregate: async () => {
-        throw new Error("ctx.db.<globalTable>: no global backend configured. Pass \`d1\` or \`hyperdriveGlobal\` to createShardDO().");
-    },
-    count: async () => {
-        throw new Error("ctx.db.<globalTable>: no global backend configured. Pass \`d1\` or \`hyperdriveGlobal\` to createShardDO().");
-    },
-    delete: async () => {
-        throw new Error("ctx.db.<globalTable>: no global backend configured. Pass \`d1\` or \`hyperdriveGlobal\` to createShardDO().");
-    },
-    findFirst: async () => {
-        throw new Error("ctx.db.<globalTable>: no global backend configured. Pass \`d1\` or \`hyperdriveGlobal\` to createShardDO().");
-    },
-    findFirstOrThrow: async () => {
-        throw new Error("ctx.db.<globalTable>: no global backend configured. Pass \`d1\` or \`hyperdriveGlobal\` to createShardDO().");
-    },
-    findMany: async () => {
-        throw new Error("ctx.db.<globalTable>: no global backend configured. Pass \`d1\` or \`hyperdriveGlobal\` to createShardDO().");
-    },
-    get: async () => {
-        throw new Error("ctx.db.<globalTable>: no global backend configured. Pass \`d1\` or \`hyperdriveGlobal\` to createShardDO().");
-    },
-    groupBy: async () => {
-        throw new Error("ctx.db.<globalTable>: no global backend configured. Pass \`d1\` or \`hyperdriveGlobal\` to createShardDO().");
-    },
-    insert: async () => {
-        throw new Error("ctx.db.<globalTable>: no global backend configured. Pass \`d1\` or \`hyperdriveGlobal\` to createShardDO().");
-    },
-    normalizeId: () => {
-        throw new Error("ctx.db.<globalTable>: no global backend configured. Pass \`d1\` or \`hyperdriveGlobal\` to createShardDO().");
-    },
-    patch: async () => {
-        throw new Error("ctx.db.<globalTable>: no global backend configured. Pass \`d1\` or \`hyperdriveGlobal\` to createShardDO().");
-    },
-    query: () => {
-        throw new Error("ctx.db.<globalTable>: no global backend configured. Pass \`d1\` or \`hyperdriveGlobal\` to createShardDO().");
-    },
-    rank: async () => {
-        throw new Error("ctx.db.<globalTable>: no global backend configured. Pass \`d1\` or \`hyperdriveGlobal\` to createShardDO().");
-    },
-    rankPage: async () => {
-        throw new Error("ctx.db.<globalTable>: no global backend configured. Pass \`d1\` or \`hyperdriveGlobal\` to createShardDO().");
-    },
-    replace: async () => {
-        throw new Error("ctx.db.<globalTable>: no global backend configured. Pass \`d1\` or \`hyperdriveGlobal\` to createShardDO().");
-    },
-};
-` : "";
-  const vectorsStub = hasVectors ? `
-const vectorsStub: VectorSearchLike = {
-    deleteByIds: async () => {
-        throw new Error("ctx.vectors: no vectors configured. Pass \`vectors\` to createShardDO().");
-    },
-    getByIds: async () => {
-        throw new Error("ctx.vectors: no vectors configured. Pass \`vectors\` to createShardDO().");
-    },
-    query: async () => {
-        throw new Error("ctx.vectors: no vectors configured. Pass \`vectors\` to createShardDO().");
-    },
-    upsert: async () => {
-        throw new Error("ctx.vectors: no vectors configured. Pass \`vectors\` to createShardDO().");
-    },
-    upsertNow: async () => {
-        throw new Error("ctx.vectors: no vectors configured. Pass \`vectors\` to createShardDO().");
-    },
-};
-` : "";
-  const vectorsBuild = hasVectors ? `
-            let vectors: VectorSearchLike;
-            let onWrite: WriteHook | undefined;
-
-            if (config.vectors) {
-                const lunora = createVectors({ indexes: config.vectors(env) });
-
-                vectors = createContextVectors(lunora);
-                onWrite = createVectorSyncHook({ schema: schema as unknown as VectorSchemaLike, vectors });
-            } else {
-                vectors = vectorsStub;
-                onWrite = undefined;
-            }
-` : "";
-  const globalDatabaseField = hasGlobalTables ? "\n                globalDb," : "";
-  const authField = "\n                auth: { identity: identity ?? null, userId: userId ?? null },";
-  const databaseOptions = hasVectors ? `{${authField}
-                broadcast: (delta) => {
-                    this.recordChangedTable(delta.table);
-                },
-                cdc: config.cdc ?? false,
-                enforceRls: true,
-                onIndexUse: this.getCtxDbIndexUseHook(),
-                onRead: options.onRead ?? this.getCtxDbReadHook(),
-                onWrite,
-                scheduler,
-                schema: schema as unknown as SchemaLike,
-                sql: this.sql as SqlExec,
-                storage,${globalDatabaseField}
-            }` : `{${authField}
-                broadcast: (delta) => {
-                    this.recordChangedTable(delta.table);
-                },
-                cdc: config.cdc ?? false,
-                enforceRls: true,
-                onIndexUse: this.getCtxDbIndexUseHook(),
-                onRead: options.onRead ?? this.getCtxDbReadHook(),
-                scheduler,
-                schema: schema as unknown as SchemaLike,
-                sql: this.sql as SqlExec,
-                storage,${globalDatabaseField}
-            }`;
-  const vectorsContextField = hasVectors ? `
-                vectors,` : "";
-  const ormContextField = hasTables ? `
-                orm: bindOrm(facade),` : "";
-  const bindTableHelper = "";
-  const globalDatabaseThunk = hasHyperdriveGlobal ? "config.hyperdriveGlobal" : "config.d1";
-  const globalDatabaseLine = hasGlobalTables ? `            const globalDb: DatabaseWriterLike = ${globalDatabaseThunk}?.(env, { identity, userId }) ?? globalDbStub;
-` : "";
-  const globalShapeReaderOverride = hasShapes && hasGlobalTables ? `
-        protected override async readGlobalShapeRows(resolved: { columns?: readonly string[]; effectiveWhere?: WhereInput; global?: boolean; table: string }, identity?: { identity?: Record<string, unknown>; userId?: string }): Promise<Array<{ doc: Record<string, unknown>; id: string }>> {
-            const env = this.env as Record<string, unknown>;
-            const globalDb: DatabaseWriterLike = ${globalDatabaseThunk}?.(env, identity) ?? globalDbStub;
-            const rows: Array<{ doc: Record<string, unknown>; id: string }> = [];
-
-            let cursor: null | string = null;
-
-            // Drain every page of the global membership so the seed/diff sees the
-            // full rowset (D1 \`findMany\` is paginated). Stop one row past the cap:
-            // a broad \`.global()\` shape would otherwise materialize an unbounded
-            // array before the caller's \`withinGlobalShapeBound\` check rejects it,
-            // so bail early and let the caller fail it closed.
-            do {
-                // eslint-disable-next-line no-await-in-loop -- sequential page drain to assemble the full membership
-                const page = await globalDb.findMany(resolved.table, { cursor, where: resolved.effectiveWhere });
-
-                for (const doc of page.page) {
-                    rows.push({ doc, id: String((doc as { _id?: unknown })._id) });
-
-                    if (rows.length > ShardDOBase.GLOBAL_SHAPE_MAX_ROWS) {
-                        return rows;
-                    }
-                }
-
-                cursor = page.isDone ? null : page.continueCursor;
-            } while (cursor !== null);
-
-            return rows;
-        }
-` : "";
-  const sourceClientCacheConst = hasSourcedTables ? `
-const sourceClientCache = new WeakMap<object, Map<string, SourceClientLike>>();
-const sourcePollAtCache = new WeakMap<object, Map<string, number>>();
-` : "";
-  const externalSourceOverride = hasSourcedTables ? `
-        protected override async pollExternalSources(): Promise<number | undefined> {
-            const env = (this.env ?? {}) as Record<string, unknown>;
-            const sourced = Object.entries((schema as unknown as SchemaLike).tables)
-                .map(([table, definition]) => [table, (definition as { externalSource?: ExternalSourceLike }).externalSource] as const)
-                .filter((entry): entry is [string, ExternalSourceLike] => entry[1] !== undefined);
-
-            if (sourced.length === 0) {
-                return undefined;
-            }
-
-            const shardKey = this.currentShardKey();
-            const scheduler = (config.scheduler?.(env) ?? schedulerStub) as SchedulerLike;
-            const writer = createShardCtxDb({
-                broadcast: (delta) => {
-                    this.recordChangedTable(delta.table);
-                },
-                cdc: config.cdc ?? false,
-                scheduler,
-                schema: schema as unknown as SchemaLike,
-                sql: this.sql as SqlExec,
-            });
-
-            let clients = sourceClientCache.get(this);
-
-            if (clients === undefined) {
-                clients = new Map();
-                sourceClientCache.set(this, clients);
-            }
-
-            let polledAt = sourcePollAtCache.get(this);
-
-            if (polledAt === undefined) {
-                polledAt = new Map();
-                sourcePollAtCache.set(this, polledAt);
-            }
-
-            const now = Date.now();
-            // \`nextDueAt\` tracks the EARLIEST next-due timestamp across every
-            // non-manual source; the shared alarm re-arms there instead of the
-            // fixed 2 s global-shape floor, so a large \`refresh.everyMs\` actually
-            // sleeps until it's due. Stays \`undefined\` when every source is
-            // \`refresh: "manual"\`, so the shared alarm goes idle for this tier.
-            let nextDueAt: number | undefined;
-
-            for (const [table, source] of sourced) {
-                if (source.refresh === "manual") {
-                    continue;
-                }
-
-                if (isSourceDue(source.refresh, polledAt.get(table), now)) {
-                    try {
-                        let client = clients.get(source.binding);
-
-                        if (client === undefined) {
-                            client = config.sourceClient?.(env, source.binding);
-
-                            if (client !== undefined) {
-                                clients.set(source.binding, client);
-                            }
-                        }
-
-                        if (client === undefined) {
-                            // No SqlClient resolved for this binding (host never wired
-                            // \`config.sourceClient\`, or wired it wrong). Surface it in the
-                            // Logs panel and stamp \`polledAt\` so a persistent misconfig backs
-                            // off to \`refresh.everyMs\` instead of retrying every alarm tick.
-                            this.recordExternalSourceError(table, new Error(\`external-source: no sourceClient resolved for binding "\${source.binding}"\`));
-                        } else if (source.mode === "incremental") {
-                            // Incremental (plan 136): pull only rows past the durable
-                            // watermark (or a full-pull seed/reconcile), upsert-only.
-                            // eslint-disable-next-line no-await-in-loop -- one sourced table at a time; sequential keeps the writer transaction simple
-                            await pullExternalSourceIncrementalTick(this.sql as SqlExec, writer, client, table, source, shardKey, now);
-                        } else {
-                            // eslint-disable-next-line no-await-in-loop -- one sourced table at a time; slices are independent but small and sequential keeps the writer transaction simple
-                            await pullExternalSourceTick(this.sql as SqlExec, writer, client, table, source, shardKey);
-                        }
-
-                        // Timestamp AFTER the poll finishes, not the batch-start \`now\` — a
-                        // poll that outruns \`everyMs\` must not make \`nextDueAt\` (below)
-                        // stale-immediate and re-arm the alarm in a hammering loop.
-                        polledAt.set(table, Date.now());
-                    } catch (error) {
-                        this.recordExternalSourceError(table, error);
-                        // Stamp on failure too, so a persistently failing source throttles
-                        // to \`refresh.everyMs\` rather than being hammered every tick.
-                        polledAt.set(table, Date.now());
-                    }
-                }
-
-                // This source's own next-due time, read AFTER the poll-or-skip above
-                // so a just-polled source reports \`now + everyMs\` (its FRESH due
-                // time), not the stale pre-poll one. An omitted \`refresh\` (poll
-                // every tick) is due again immediately.
-                const sourceNextDueAt = source.refresh === undefined ? now : (polledAt.get(table) ?? now) + source.refresh.everyMs;
-
-                nextDueAt = nextDueAt === undefined ? sourceNextDueAt : Math.min(nextDueAt, sourceNextDueAt);
-            }
-
-            return nextDueAt;
-        }
-` : "";
-  const hasTtlTables = ttlSweeps.length > 0;
-  const sourceBootstrap = hasSourcedTables ? `
-            const autoSourced = Object.values((schema as unknown as SchemaLike).tables).some((definition) => {
-                const source = (definition as { externalSource?: ExternalSourceLike }).externalSource;
-
-                return source !== undefined && source.refresh !== "manual";
-            });
-
-            if (autoSourced) {
-                void this.scheduleSourcePoll();
-            }
-` : "";
-  const ttlBootstrap = hasTtlTables ? `
-            if (LUNORA_TTL_SWEEPS.length > 0) {
-                void this.scheduleTtlSweep();
-            }
-` : "";
-  const sourceConstructorOverride = hasSourcedTables || hasTtlTables ? `
-        public constructor(state: ShardDOState, env: unknown) {
-            super(state, env);
-${sourceBootstrap}${ttlBootstrap}        }
-` : "";
-  const facadeBlock = hasTables ? `
-            const facade = db as unknown as Record<string, ReturnType<typeof bindTableFacade>>;
-${schema.tables.map(
-    // Always bind through `db` (the shard ctx-db) — even for `.global()`
-    // tables. `createShardCtxDb` routes global ops to the D1 `globalDb`
-    // internally AND stamps the read-dependency / change-broadcast hooks that
-    // drive live subscriptions; binding a global facade straight to `globalDb`
-    // would skip those, so a `ctx.db.<global>` read/write would never refresh
-    // a subscriber of that table.
-    (table) => `            facade[${JSON.stringify(table.name)}] = bindTableFacade(db, ${JSON.stringify(table.name)});`
-  ).join("\n")}
-` : "";
-  const secretsBuild = `
-            const secrets = createSecrets(env);
-`;
-  const everyContextBuild = `${accessFragments.build}${kvFragments.build}${flagsFragments.build}${analyticsFragments.build}${envFragments.build}${secretsBuild}`;
-  const everyContextField = `${accessFragments.contextField}${kvFragments.contextField}${flagsFragments.contextField}${notifyFragments.contextField}${analyticsFragments.contextField}${envFragments.contextField}
-                secrets,`;
-  const notifyBuild = notifyFragments.build;
-  const actionOnlyHasAny = hasImages || hasHyperdrive || hasBrowser || hasR2sql || hasPipelines || hasX402;
-  const actionOnlyBlock = actionOnlyHasAny ? `
-            // ActionCtx-only helpers (external, non-deterministic I/O): constructed
-            // and attached only for an \`action\` so query/mutation ctx never carry them.
-            if (isAction) {
-${imagesFragments.build}${hyperdriveFragments.build}${browserFragments.build}${r2sqlFragments.build}${pipelinesFragments.build}${x402Build}${[
-    ...hasImages ? ["                ctx.images = images;"] : [],
-    ...hasHyperdrive ? ["                ctx.sql = sql;"] : [],
-    ...hasBrowser ? ["                ctx.browser = browser;"] : [],
-    ...hasR2sql ? ["                ctx.r2sql = r2sql;"] : [],
-    ...hasPipelines ? ["                ctx.pipelines = pipelines;"] : [],
-    ...hasX402 ? ["                ctx.x402 = x402;"] : []
-  ].join("\n")}
-            }
-` : "";
-  const isActionLine = actionOnlyHasAny ? `            const isAction = LUNORA_FUNCTIONS[options.functionPath ?? ""]?.kind === "action";
-` : "";
-  return `${GENERATED_HEADER}${importLines.join("\n")}
-
-type FunctionKind = "action" | "mutation" | "query";
-
-interface FunctionReference {
-    __lunoraRef: string;
-}
-
-/** Foreign-key columns per table (\`v.id("target")\` fields) for the data browser. */
-const LUNORA_TABLE_REFS: Record<string, Record<string, string>> = ${JSON.stringify(tableReferences, void 0, 4)};
-
-/** Declared indexes per table (secondary, search, geo, rank, vector) for the schema viewer. */
-const LUNORA_TABLE_INDEXES: Record<string, Array<{ fields: string[]; name: string; type: "geo" | "index" | "rank" | "search" | "vector"; unique?: boolean }>> = ${JSON.stringify(tableIndexes, void 0, 4)};
-
-/** Columns per table (typed, with PK/FK markers) for the studio's schema diagram, served via \`__lunora_admin__:describeTable\`. */
-const LUNORA_TABLE_COLUMNS: Record<string, Array<{ isStorage?: boolean; name: string; optional: boolean; pk?: boolean; ref?: string; type: string }>> = ${JSON.stringify(tableColumns, void 0, 4)};
-
-/** Storage-key columns per table (\`v.storage(...)\` fields) for the file browser's records↔files join. */
-const LUNORA_STORAGE_COLUMNS: Record<string, string[]> = ${JSON.stringify(storageColumns, void 0, 4)};
-
-/** Declarative TTL policies (\`.ttl(field, { after? })\`) the DO alarm sweep auto-expires rows for. */
-const LUNORA_TTL_SWEEPS: Array<{ after?: number; field: string; softDeleteField?: string; table: string }> = ${JSON.stringify(ttlSweeps, void 0, 4)};
-
-/** Static schema advisories (computed by @lunora/advisor at codegen time) served via \`__lunora_admin__:getAdvisories\`. */
-const LUNORA_ADVISORIES: AdvisoryFinding[] = ${JSON.stringify(advisoryData, void 0, 4)};
-
-/** Read-only RLS metadata (policies + roles discovered from \`.use(rls(...))\` chains) served via \`__lunora_admin__:rlsPolicies\` for the studio's RLS inspector. */
-const LUNORA_RLS_METADATA: RlsPoliciesResult = ${JSON.stringify(rlsData, void 0, 4)};
-
-/** Read-only masking metadata (table + column + strategy discovered from \`.use(mask(...))\` chains) served via \`__lunora_admin__:maskPolicies\` for the studio's data-browser mask preview. */
-const LUNORA_MASK_METADATA: MaskPoliciesResult = ${JSON.stringify(maskData, void 0, 4)};
-
-/** Read-only storage access-rule metadata (discovered from \`.use(storageRules(...))\` chains) served via \`__lunora_admin__:storageRules\` for the studio's access-rules view. */
-const LUNORA_STORAGE_RULES: StorageRulesResult = ${JSON.stringify(storageRulesData, void 0, 4)};
-
-/** Which optional package-backed features this app wires up (discovered from imports / \`ctx.*\` reads / schema signals) served via \`__lunora_admin__:studioFeatures\` so the studio hides nav pages whose package isn't enabled. */
-const LUNORA_STUDIO_FEATURES: StudioFeaturesResult = ${JSON.stringify(studioFeaturesData, void 0, 4)};
-${flagsOverrides.constant}${shapeReadRegistryConst}${workflowsMetadataConst}${queuesMetadataConst}${containerSpecs}${workflowSpecs}${queueSpecs}${agentSpecs}
-export interface ShardDOConfig {
-    /** Opt into change-data-capture: records a post-image to \`__cdc_log\` on every write (backs streaming export + replay-PITR). */
-    cdc?: boolean;
-    /** Optional telemetry sink. When supplied, each \`ctx.log.*\` call is forwarded to \`sink.onLog\`. Pass the SAME sink you give \`createWorker({ observability })\` (which drives \`onRpc\`) to route both RPC and log events. */
-    observability?: (env: Record<string, unknown>) => LogSink | undefined;
-    scheduler?: (env: Record<string, unknown>) => unknown;
-    storage?: (env: Record<string, unknown>) => unknown;${vectorsConfigField}${aiConfigField}${kvFragments.configField}${flagsFragments.configField}${analyticsFragments.configField}${imagesFragments.configField}${hyperdriveFragments.configField}${browserFragments.configField}${r2sqlFragments.configField}${pipelinesFragments.configField}${paymentsConfigField}${x402ConfigField}${d1ConfigField}${hyperdriveGlobalConfigField}${sourceClientConfigField}
-}
-
-const schedulerStub = {
-    cancel: async () => {
-        throw new Error("ctx.scheduler: no scheduler configured. Pass \`scheduler\` to createShardDO().");
-    },
-    runAfter: async () => {
-        throw new Error("ctx.scheduler: no scheduler configured. Pass \`scheduler\` to createShardDO().");
-    },
-    runAt: async () => {
-        throw new Error("ctx.scheduler: no scheduler configured. Pass \`scheduler\` to createShardDO().");
-    },
-};
-
-const storageStub = {
-    delete: async () => {
-        throw new Error("ctx.storage: no storage configured. Pass \`storage\` to createShardDO().");
-    },
-    download: async () => {
-        throw new Error("ctx.storage: no storage configured. Pass \`storage\` to createShardDO().");
-    },
-    getMetadata: async () => {
-        throw new Error("ctx.storage: no storage configured. Pass \`storage\` to createShardDO().");
-    },
-    getSignedUrl: async () => {
-        throw new Error("ctx.storage: no storage configured. Pass \`storage\` to createShardDO().");
-    },
-    getUrl: () => {
-        throw new Error("ctx.storage: no storage configured. Pass \`storage\` to createShardDO().");
-    },
-    list: async () => {
-        throw new Error("ctx.storage: no storage configured. Pass \`storage\` to createShardDO().");
-    },
-    upload: async () => {
-        throw new Error("ctx.storage: no storage configured. Pass \`storage\` to createShardDO().");
-    },
-};
-${globalDatabaseStub}${sourceClientCacheConst}${vectorsStub}${aiStub}${kvFragments.stub}${flagsFragments.stub}${analyticsFragments.stub}${imagesFragments.stub}${hyperdriveFragments.stub}${browserFragments.stub}${r2sqlFragments.stub}${pipelinesFragments.stub}${paymentStub}${x402Stub}${bindTableHelper}
-// Bound in-process \`ctx.run*\` composition depth so a self- or cyclically-
-// referencing call fails loudly with a clear error instead of overflowing the
-// stack. Tracked across the awaited handler chain (one DO invocation is
-// single-threaded), so the counter reflects true nesting depth.
-const MAX_RUN_DEPTH = 32;
-let runDepth = 0;
-
-const dispatchRun = async (expected: FunctionKind, functionPath: string, args: Record<string, unknown>, ctx: unknown): Promise<unknown> => {
-    const registered = LUNORA_FUNCTIONS[functionPath];
-
-    if (!registered) {
-        throw new Error(\`unknown function: \${functionPath}\`);
-    }
-
-    if (registered.kind !== expected) {
-        throw new Error(\`ctx.run\${expected[0]!.toUpperCase()}\${expected.slice(1)}: "\${functionPath}" is registered as a \${registered.kind}, not a \${expected}\`);
-    }
-
-    if (runDepth >= MAX_RUN_DEPTH) {
-        throw new LunoraError("RUN_DEPTH_EXCEEDED", \`ctx.run*: composition depth limit (\${MAX_RUN_DEPTH}) exceeded — likely a cyclic runQuery/runMutation\`);
-    }
-
-    runDepth += 1;
-
-    try {
-        return await registered.handler(ctx, args);
-    } finally {
-        runDepth -= 1;
-    }
-};
-
-/**
- * Build the project's shard Durable Object. Export the result as \`ShardDO\`
- * from the worker entry so wrangler binds it by name.
- */
-export const createShardDO = (config: ShardDOConfig = {}): new (state: ShardDOState, env: unknown) => ShardDOBase =>
-    class extends ShardDOBase {${sourceConstructorOverride}
-        private migrated = false;
-
-        public override async handleRpc(functionPath: string, args: Record<string, unknown>): Promise<unknown> {
-            const registered = LUNORA_FUNCTIONS[functionPath];
-
-            // Internal functions are reachable server-side only: via \`ctx.run*\`
-            // composition, or a trusted system dispatch (scheduler/cron, marked by
-            // \`isSystemDispatch()\`). A client RPC never carries that flag, so its
-            // internals stay not-found and never leak across the external boundary.
-            if (!registered || (registered.visibility === "internal" && !this.isSystemDispatch())) {
-                throw new LunoraError("FUNCTION_NOT_FOUND", \`function not registered: \${functionPath}\`);
-            }
-
-            this.ensureMigrated();
-
-            const ctx = this.buildCtx({ functionPath });
-
-            // A mutation's writes must commit all-or-nothing: wrap its dispatch in
-            // the DO's BEGIN/COMMIT span so any throw (a validator, an RLS denial,
-            // an OCC conflict, a failed row mid-\`insertMany\`/\`patchMany\`) rolls
-            // back every write the mutation made. Queries are read-only and actions
-            // do external I/O that can't be rolled back, so both dispatch directly.
-            // \`ctx.run*\` composition runs inside this span (it never re-enters
-            // handleRpc); runInTransaction's own guard rejects accidental nesting.
-            //
-            // The replay bookkeeping (idempotency dedup row + custom-mutator
-            // watermark advance) commits INSIDE this span via
-            // \`commitMutationBookkeeping\`, so the writes, the dedup row, and the
-            // watermark are atomic — a crash can't leave the writes durable without
-            // the replay guard.
-            if (registered.kind === "mutation") {
-                return this.runInTransaction(async () => {
-                    const result = await registered.handler(ctx, args);
-
-                    this.commitMutationBookkeeping(result);
-
-                    return result;
-                });
-            }
-
-            return registered.handler(ctx, args);
-        }
-${relationFanout.override}
-        protected override async executeSubscription(functionPath: string, args: Record<string, unknown>, identity?: { identity?: Record<string, unknown>; userId?: string }): Promise<{ result: unknown; tables: Set<string> } | null> {
-            const registered = LUNORA_FUNCTIONS[functionPath];
-
-            if (!registered || registered.kind !== "query" || registered.visibility === "internal") {
-                return null;
-            }
-
-            this.ensureMigrated();
-
-            const tables = new Set<string>();
-            // Identity is threaded EXPLICITLY from the (deferred/interleaved)
-            // subscription caller — never read from the shared per-request field
-            // here — so a concurrent RPC can't leak its identity into this re-run.
-            const ctx = this.buildCtx({ functionPath, identity, onRead: (table) => tables.add(table) });
-            const result = await registered.handler(ctx, args);
-
-            return { result, tables };
-        }
-
-        protected override executeStream(functionPath: string, args: Record<string, unknown>): null | { iterator: (signal: AbortSignal) => AsyncIterable<unknown> } {
-            const registered = LUNORA_FUNCTIONS[functionPath];
-
-            if (!registered || registered.kind !== "stream" || registered.visibility === "internal") {
-                return null;
-            }
-
-            this.ensureMigrated();
-
-            return {
-                iterator: (signal) => (registered.handler as (context: unknown, args: Record<string, unknown>, signal: AbortSignal) => AsyncIterable<unknown>)(this.buildCtx({ functionPath }), args, signal),
-            };
-        }
-${customMutatorOverride}${shapeResolveOverride}${globalShapeReaderOverride}${externalSourceOverride}
-        protected override lifecycleHookPaths(event: "connect" | "disconnect"): readonly string[] {
-            return LUNORA_LIFECYCLE_HOOKS[event];
-        }
-
-        protected override tableRefs(table: string): Record<string, string> | undefined {
-            return LUNORA_TABLE_REFS[table];
-        }
-
-        protected override tableIndexes(table: string): Array<{ fields: string[]; name: string; type: "geo" | "index" | "rank" | "search" | "vector"; unique?: boolean }> {
-            return LUNORA_TABLE_INDEXES[table] ?? [];
-        }
-
-        protected override ttlSweeps(): ReadonlyArray<{ after?: number; field: string; softDeleteField?: string; table: string }> {
-            return LUNORA_TTL_SWEEPS;
-        }
-
-        protected override tableColumns(table: string): Array<{ isStorage?: boolean; name: string; optional: boolean; pk?: boolean; ref?: string; type: string }> {
-            return LUNORA_TABLE_COLUMNS[table] ?? [];
-        }
-
-        protected override storageColumns(): Record<string, string[]> {
-            return LUNORA_STORAGE_COLUMNS;
-        }
-
-        protected override rlsMetadata(): RlsPoliciesResult {
-            return LUNORA_RLS_METADATA;
-        }
-
-        protected override maskMetadata(): MaskPoliciesResult {
-            return LUNORA_MASK_METADATA;
-        }
-
-        protected override storageRulesMetadata(): StorageRulesResult {
-            return LUNORA_STORAGE_RULES;
-        }
-
-        protected override studioFeatures(): StudioFeaturesResult {
-            return LUNORA_STUDIO_FEATURES;
-        }
-${flagsOverrides.evaluateOverride}${flagsOverrides.subscriptionOverride}${workflowsMetadataOverride}${queuesMetadataOverride}
-        protected override advisories(): AdvisoryFinding[] {
-            return LUNORA_ADVISORIES;
-        }
-
-        protected override async runShardDataMigration(args: RunShardMigrationArgs): Promise<MigrationRunResult> {
-            const migration = LUNORA_MIGRATIONS[args.id];
-
-            if (!migration) {
-                throw new LunoraError("MIGRATION_NOT_FOUND", \`data migration "\${args.id}" is not registered\`, { status: 404 });
-            }
-
-            this.ensureMigrated();
-
-            const env = (this.env ?? {}) as Record<string, unknown>;
-            const scheduler = (config.scheduler?.(env) ?? schedulerStub) as SchedulerLike;
-            const writer = createShardCtxDb({
-                broadcast: (delta) => {
-                    this.recordChangedTable(delta.table);
-                },
-                cdc: config.cdc ?? false,
-                scheduler,
-                schema: schema as unknown as SchemaLike,
-                sql: this.sql as SqlExec,
-            });
-
-            return runDataMigration({
-                batchSize: args.batchSize,
-                direction: args.direction,
-                dryRun: args.dryRun,
-                maxBatches: args.maxBatches,
-                migration: migration as unknown as DataMigrationLike,
-                // Flush after each batch so live migrationStatus subscribers see
-                // progress mid-run (the base method records the reserved state
-                // table the raw-SQL progress write is invisible to the tracker).
-                onBatch: () => this.flushMigrationProgress(),
-                sql: this.sql as SqlExec,
-                writer,
-            });
-        }
-
-        protected override async runShardWrite(args: RunShardWriteArgs): Promise<RunShardWriteResult> {
-            const definition = (schema as unknown as SchemaLike).tables[args.table];
-
-            if (!definition) {
-                throw new LunoraError("UNKNOWN_TABLE", \`unknown table: \${args.table}\`, { status: 404 });
-            }
-
-            // \`.global()\` tables live in D1, not this DO's SQLite — editing them
-            // here would corrupt nothing but would fail confusingly, so reject up
-            // front with a clear code the studio can surface.
-            if (definition.shardMode?.kind === "global") {
-                throw new LunoraError("GLOBAL_TABLE_NOT_EDITABLE", \`table "\${args.table}" is global; edit it through D1, not the shard\`, { status: 400 });
-            }
-
-            this.ensureMigrated();
-
-            const env = (this.env ?? {}) as Record<string, unknown>;
-            const scheduler = (config.scheduler?.(env) ?? schedulerStub) as SchedulerLike;
-            const writer = createShardCtxDb({
-                broadcast: (delta) => {
-                    this.recordChangedTable(delta.table);
-                },
-                cdc: config.cdc ?? false,
-                scheduler,
-                schema: schema as unknown as SchemaLike,
-                sql: this.sql as SqlExec,
-            });
-
-            if (args.op === "insert") {
-                const id = await writer.insert(args.table, args.doc ?? {});
-
-                return { id, op: "insert" };
-            }
-
-            if (args.op === "delete") {
-                await writer.delete(args.id ?? "");
-
-                return { id: args.id ?? null, op: "delete" };
-            }
-
-            if (args.op === "replace") {
-                await writer.replace(args.id ?? "", args.doc ?? {});
-
-                return { id: args.id ?? null, op: "replace" };
-            }
-
-            await writer.patch(args.id ?? "", args.doc ?? {});
-
-            return { id: args.id ?? null, op: "patch" };
-        }
-
-        protected override async deleteRowThroughWriter(table: string, id: string): Promise<void> {
-            const definition = (schema as unknown as SchemaLike).tables[table];
-
-            if (!definition) {
-                throw new LunoraError("UNKNOWN_TABLE", \`unknown table: \${table}\`, { status: 404 });
-            }
-
-            // \`.global()\` tables live in D1, not this DO's SQLite — the same
-            // guard \`runShardWrite\` applies to single-row edits.
-            if (definition.shardMode?.kind === "global") {
-                throw new LunoraError("GLOBAL_TABLE_NOT_EDITABLE", \`table "\${table}" is global; edit it through D1, not the shard\`, { status: 400 });
-            }
-
-            this.ensureMigrated();
-
-            const env = (this.env ?? {}) as Record<string, unknown>;
-            const scheduler = (config.scheduler?.(env) ?? schedulerStub) as SchedulerLike;
-            const writer = createShardCtxDb({
-                broadcast: (delta) => {
-                    this.recordChangedTable(delta.table);
-                },
-                cdc: config.cdc ?? false,
-                scheduler,
-                schema: schema as unknown as SchemaLike,
-                sql: this.sql as SqlExec,
-            });
-
-            // Routes through the writer (not raw SQL) so FTS / aggregate / rank
-            // shadow tables stay in sync and \`onDelete\` cascades fire — the
-            // bounded loop lives in the base \`runShardBulkDelete\`.
-            await writer.delete(id);
-        }
-
-        protected override async runShardRankBefore(args: RunShardRankBeforeArgs): Promise<{ before: number; total: number }> {
-            this.ensureMigrated();
-
-            const env = (this.env ?? {}) as Record<string, unknown>;
-            const scheduler = (config.scheduler?.(env) ?? schedulerStub) as SchedulerLike;
-            const writer = createShardCtxDb({
-                broadcast: (delta) => {
-                    this.recordChangedTable(delta.table);
-                },
-                cdc: config.cdc ?? false,
-                scheduler,
-                schema: schema as unknown as SchemaLike,
-                sql: this.sql as SqlExec,
-            });
-
-            // \`rankBefore\` is optional on \`DatabaseWriterLike\` (the D1 twin omits it),
-            // but the shard writer from \`createShardCtxDb\` always defines it.
-            if (!writer.rankBefore) {
-                throw new LunoraError("NOT_IMPLEMENTED", "rankBefore is unavailable on the shard writer", { status: 500 });
-            }
-
-            return writer.rankBefore(args.table, args.index, {
-                partitionKey: args.partitionKey,
-                rowId: args.rowId,
-                sortValues: args.sortValues,
-            });
-        }
-
-        protected override async runShardRankPage(args: RunShardRankPageArgs): Promise<ShardRankPageResult> {
-            this.ensureMigrated();
-
-            const env = (this.env ?? {}) as Record<string, unknown>;
-            const scheduler = (config.scheduler?.(env) ?? schedulerStub) as SchedulerLike;
-            const writer = createShardCtxDb({
-                broadcast: (delta) => {
-                    this.recordChangedTable(delta.table);
-                },
-                cdc: config.cdc ?? false,
-                scheduler,
-                schema: schema as unknown as SchemaLike,
-                sql: this.sql as SqlExec,
-            });
-
-            // \`rankPageRows\` is optional on \`DatabaseWriterLike\` (the D1 twin omits it),
-            // but the shard writer from \`createShardCtxDb\` always defines it. The sort
-            // directions live in the schema's rankIndex, so the shard reads them itself;
-            // \`args.directions\` is only the coordinator's comparator hint and isn't forwarded.
-            if (!writer.rankPageRows) {
-                throw new LunoraError("NOT_IMPLEMENTED", "rankPage is unavailable on the shard writer", { status: 500 });
-            }
-
-            return writer.rankPageRows(args.table, args.index, {
-                after: args.after,
-                cursor: args.cursor,
-                partitionKey: args.partitionKey,
-                take: args.take,
-            });
-        }
-
-        protected override async runShardApplyCdc(args: RunShardApplyCdcArgs): Promise<{ applied: number }> {
-            this.ensureMigrated();
-
-            const env = (this.env ?? {}) as Record<string, unknown>;
-            const scheduler = (config.scheduler?.(env) ?? schedulerStub) as SchedulerLike;
-            const writer = createShardCtxDb({
-                broadcast: (delta) => {
-                    this.recordChangedTable(delta.table);
-                },
-                cdc: config.cdc ?? false,
-                scheduler,
-                schema: schema as unknown as SchemaLike,
-                sql: this.sql as SqlExec,
-            });
-
-            await applyCdcChanges(writer, args.changes);
-
-            return { applied: args.changes.length };
-        }
-
-        protected override ensureMigrated(): void {
-            if (this.migrated) {
-                return;
-            }
-
-            runShardMigrations(this.sql as SqlExec, schema as unknown as SchemaLike, { cdc: config.cdc ?? false });
-            this.migrated = true;
-        }
-
-        private buildCtx(options: { functionPath?: string; identity?: { identity?: Record<string, unknown>; userId?: string }; onRead?: (table: string) => void } = {}): unknown {
-            const env = (this.env ?? {}) as Record<string, unknown>;
-            // When the caller threads an explicit identity (subscription seed /
-            // refresh — both run in deferred/interleaved contexts), use it by
-            // value and NEVER read the shared per-request identity field, which a
-            // concurrent RPC may have re-set. Otherwise (the synchronous RPC
-            // dispatch path) fall back to the per-request fields as before.
-            const userId = options.identity ? options.identity.userId : this.getCurrentUserId();
-            const identity = options.identity ? options.identity.identity : this.getCurrentIdentity();
-${vectorsBuild}${aiBuild}${everyContextBuild}${containersBuild}${workflowsBuild}${queuesBuild}${agentsBuild}
-            const scheduler = (config.scheduler?.(env) ?? schedulerStub) as SchedulerLike;
-            // Build the storage adapter once and share it between \`ctx.storage\`
-            // and \`ctx.db.system._storage\` so both read the same R2 binding. The
-            // \`storageStub\` fallback satisfies SystemReaderStorageLike structurally
-            // (its \`list\`/\`getMetadata\` throw the "no storage configured" error).
-            const storage = asBucketStorage(config.storage?.(env) ?? storageStub) as unknown as SystemReaderStorageLike;
-${globalDatabaseLine}            const db: DatabaseWriterLike = createShardCtxDb(${databaseOptions});
-${facadeBlock}${paymentsBuild}
-            // \`ctx.log\`: the DO base builds the attributed logger (structured
-            // fields + \`.with(...)\` child + trace correlation) and routes each call
-            // to the optional \`observability\` sink. It also buffers the line (studio
-            // Logs panel) and emits a structured console event the dev-server formats.
-            const observability = config.observability?.(env);
-            const logFunctionPath = options.functionPath ?? "";
-            const log = this.makeLogger(logFunctionPath, observability);
-
-            // \`ctx.trace\` / \`ctx.metrics\`: spans and measurements to the same sink.
-            // The trace anchor is threaded explicitly for the same reason \`identity\`
-            // is — a deferred caller (a subscription re-run) must not inherit the
-            // writing mutation's trace from the shared per-request field.
-            const trace = this.makeTracer(logFunctionPath, observability, options.identity ? undefined : this.getCurrentTrace());
-            const metrics = this.makeMetrics(logFunctionPath, observability);
-${notifyBuild}
-            // \`ctx.now\`: the wall-clock instant (epoch ms) this function began,
-            // captured ONCE so the whole handler body sees a single stable value.
-            // Query/mutation handlers must be deterministic (they may be re-run on
-            // OCC retry / subscription re-eval), so they must read time through
-            // \`ctx.now\` instead of \`Date.now()\` — the \`nondeterministic_query_mutation\`
-            // advisor flags the latter. Actions may still use ambient \`Date.now()\`.
-            const now = Date.now();
-
-            const ctx: Record<string, unknown> = {
-                auth: {
-                    getIdentity: async () => identity ?? null,
-                    userId: userId ?? null,
-                },
-                db,
-                fetch: globalThis.fetch.bind(globalThis),
-                ip: this.getCurrentIp(),
-                log,
-                metrics,
-                now,${ormContextField}
-                scheduler,
-                storage,
-                trace,${vectorsContextField}${aiContextField}${everyContextField}${paymentsContextField}${containersContextField}${workflowsContextField}${queuesContextField}${agentsContextField}
-            };
-${isActionLine}${actionOnlyBlock}
-            ctx.runAction = (reference: FunctionReference, fnArgs: Record<string, unknown>) => dispatchRun("action", reference.__lunoraRef, fnArgs, ctx);
-            ctx.runMutation = (reference: FunctionReference, fnArgs: Record<string, unknown>) => dispatchRun("mutation", reference.__lunoraRef, fnArgs, ctx);
-            ctx.runQuery = (reference: FunctionReference, fnArgs: Record<string, unknown>) => dispatchRun("query", reference.__lunoraRef, fnArgs, ctx);
-
-            return ctx;
-        }
-    };
-`;
-};
-const validatorToDrizzleColumn = (validator) => {
-  switch (validator.kind) {
-    case "array":
-    case "object":
-    case "record":
-    case "union": {
-      return {
-        builder: "text",
-        mode: "json",
-        notNull: true,
-        typeAnnotation: validatorToType(validator)
-      };
-    }
-    case "bigint": {
-      return { builder: "blob", mode: "bigint", notNull: true };
-    }
-    case "boolean": {
-      return { builder: "integer", mode: "boolean", notNull: true };
-    }
-    case "bytes": {
-      return { builder: "blob", mode: "buffer", notNull: true };
-    }
-    case "date":
-    case "timestamp": {
-      return { builder: "integer", notNull: true };
-    }
-    case "id": {
-      return { builder: "text", notNull: true };
-    }
-    case "literal": {
-      const value = validator.literalValue ?? "";
-      if (value.startsWith('"') || value.startsWith("'")) {
-        return { builder: "text", notNull: true };
-      }
-      if (value === "true" || value === "false") {
-        return { builder: "integer", mode: "boolean", notNull: true };
-      }
-      if (value === "null") {
-        return { builder: "text", notNull: true };
-      }
-      return { builder: "real", notNull: true };
-    }
-    case "null": {
-      return { builder: "text", notNull: true };
-    }
-    case "number": {
-      return { builder: "real", notNull: true };
-    }
-    case "optional": {
-      const inner = validator.inner ? validatorToDrizzleColumn(validator.inner) : { builder: "text", notNull: false };
-      return { ...inner, notNull: false };
-    }
-    case "storage":
-    case "string": {
-      return { builder: "text", notNull: true };
-    }
-    default: {
-      return { builder: "text", notNull: true };
-    }
-  }
-};
-const renderDrizzleColumn = (name, validator, knownTables) => {
-  assertIdentifier(name, "drizzle column name");
-  const column = validatorToDrizzleColumn(validator);
-  const isOptional = validator.kind === "optional";
-  const innerValidator = isOptional && validator.inner ? validator.inner : validator;
-  const modeArgument = column.mode ? `, { mode: "${column.mode}" }` : "";
-  let expression = `${column.builder}("${name}"${modeArgument})`;
-  if (column.typeAnnotation) {
-    expression += `.$type<${column.typeAnnotation}>()`;
-  }
-  if (innerValidator.kind === "id" && innerValidator.tableName && knownTables.has(innerValidator.tableName)) {
-    expression += `.references(() => ${innerValidator.tableName}._id)`;
-  }
-  if (column.notNull) {
-    expression += ".notNull()";
-  }
-  return expression;
-};
-const renderIndexEntry = (index) => {
-  assertIdentifier(index.name, "drizzle index name");
-  const constructor = index.unique ? "uniqueIndex" : "index";
-  const fields = index.fields.map((field) => {
-    assertIdentifier(field, "drizzle index field");
-    return `t.${field}`;
-  }).join(", ");
-  return `    ${index.name}: ${constructor}("${index.name}").on(${fields}),`;
-};
-const renderDrizzleTable = (table, knownTables) => {
-  assertIdentifier(table.name, "table name");
-  const columns = [
-    `    _id: text("_id").primaryKey(),`,
-    `    _creationTime: integer("_creationTime").notNull(),`,
-    ...Object.entries(table.shape).map(([fieldName, validator]) => `    ${fieldName}: ${renderDrizzleColumn(fieldName, validator, knownTables)},`)
-  ].join("\n");
-  const indexBody = table.indexes.length > 0 ? `, (t) => ({
-${table.indexes.map((index) => renderIndexEntry(index)).join("\n")}
-})` : "";
-  return `export const ${table.name} = sqliteTable("${table.name}", {
-${columns}
-}${indexBody});`;
-};
-const usedImports = (tables) => {
-  const columns = /* @__PURE__ */ new Set();
-  const indexes = /* @__PURE__ */ new Set();
-  columns.add("text");
-  columns.add("integer");
-  columns.add("sqliteTable");
-  for (const table of tables) {
-    for (const validator of Object.values(table.shape)) {
-      const column = validatorToDrizzleColumn(validator);
-      columns.add(column.builder);
-    }
-    for (const index of table.indexes) {
-      indexes.add(index.unique ? "uniqueIndex" : "index");
-    }
-  }
-  return { columns: [...columns].toSorted((a, b) => a.localeCompare(b)), indexes: [...indexes].toSorted((a, b) => a.localeCompare(b)) };
-};
-const renderDrizzleFile = (tables, useUmbrella = false) => {
-  if (tables.length === 0) {
-    return `${GENERATED_HEADER}export {};
-`;
-  }
-  const base = baseSpecifiers(useUmbrella);
-  const { columns, indexes } = usedImports(tables);
-  const importParts = [...indexes, ...columns].toSorted((a, b) => a.localeCompare(b));
-  const knownTables = new Set(tables.map((table) => table.name));
-  const tableBlocks = tables.map((table) => renderDrizzleTable(table, knownTables)).join("\n\n");
-  return `${GENERATED_HEADER}import { ${importParts.join(", ")} } from "${base.serverDrizzle}";
-
-${tableBlocks}
-`;
-};
-const emitDrizzleSchema = (schema, useUmbrella = false) => {
-  const globalTables = schema.tables.filter((table) => table.shardMode === "global");
-  const shardTables = schema.tables.filter((table) => table.shardMode !== "global");
-  return {
-    global: renderDrizzleFile(globalTables, useUmbrella),
-    shard: renderDrizzleFile(shardTables, useUmbrella)
-  };
-};
-const emitCrons = (crons) => {
-  const triggers = [];
-  const byExpression = /* @__PURE__ */ new Map();
-  for (const cron of crons) {
-    const existing = byExpression.get(cron.cron);
-    if (existing) {
-      existing.push(cron);
-    } else {
-      byExpression.set(cron.cron, [cron]);
-      triggers.push(cron.cron);
-    }
-  }
-  const triggerEntries = triggers.map((expression) => `    ${JSON.stringify(expression)},`).join("\n");
-  const triggerBody = triggerEntries.length > 0 ? `
-${triggerEntries}
-` : "";
-  const mapEntries = [...byExpression.entries()].map(([expression, jobs]) => {
-    const jobEntries = jobs.map((job) => {
-      const targetField = job.workflow ? `workflow: ${JSON.stringify(job.workflow.binding)}` : `functionPath: ${JSON.stringify(job.functionPath)}`;
-      return `        { name: ${JSON.stringify(job.name)}, ${targetField}, args: ${JSON.stringify(job.args)} },`;
-    }).join("\n");
-    return `    ${JSON.stringify(expression)}: [
-${jobEntries}
-    ],`;
-  }).join("\n");
-  const mapBody = mapEntries.length > 0 ? `
-${mapEntries}
-` : "";
-  return `${GENERATED_HEADER}/**
- * 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_*\` binding name 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> = [${triggerBody}];
-
-/**
- * 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>> = {${mapBody}};
-`;
-};
-const emitVectors = (vectorIndexes) => {
-  const entries = [...vectorIndexes].toSorted((a, b) => a.name.localeCompare(b.name)).map((index) => {
-    const parts = [`name: ${JSON.stringify(index.name)}`, `table: ${JSON.stringify(index.table)}`];
-    if (index.field !== void 0) {
-      parts.push(`field: ${JSON.stringify(index.field)}`);
-    }
-    if (index.dimensions !== void 0) {
-      parts.push(`dimensions: ${JSON.stringify(index.dimensions)}`);
-    }
-    if (index.metric !== void 0) {
-      parts.push(`metric: ${JSON.stringify(index.metric)}`);
-    }
-    if (index.metadata !== void 0) {
-      parts.push(`metadata: ${JSON.stringify(index.metadata)}`);
-    }
-    return `    { ${parts.join(", ")} },`;
-  }).join("\n");
-  const body = entries.length > 0 ? `
-${entries}
-` : "";
-  return `${GENERATED_HEADER}/**
- * 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> = [${body}];
-`;
-};
-const emitWranglerCronTriggers = (crons) => {
-  const seen = /* @__PURE__ */ new Set();
-  const triggers = [];
-  for (const cron of crons) {
-    if (!seen.has(cron.cron)) {
-      seen.add(cron.cron);
-      triggers.push(cron.cron);
-    }
-  }
-  return triggers;
-};
-
-export { APP_METHOD_CAPABILITIES as A, CAPABILITIES as C, GENERATED_HEADER as G, emitApi as a, emitCollections as b, emitContainers as c, emitCrons as d, emitAgents as e, emitDataModel as f, emitDrizzleSchema as g, emitFunctions as h, emitServer as i, emitShard as j, emitVectors as k, emitWorkflows as l, emitWranglerCronTriggers as m, buildStorageColumns as n, emitQueues as o, emitSeed as p };