@lunora/codegen 1.0.0-alpha.5 → 1.0.0-alpha.50

package/dist/packem_shared/{GENERATED_HEADER-DF1hQcix.mjs → emit-ClTbCLy4.mjs}

@@ -1,27 +1,379 @@
+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"
+  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"
+  serverTypes: "@lunora/server/types",
+  values: "@lunora/values"
 };
 const IDENTIFIER_RE = /^[A-Za-z_$][\w$]*$/u;
-const LITERAL_VALUE_RE = /^(?:"[^"\\]*"|'[^'\\]*'|-?\d+(?:\.\d+)?|true|false|null)$/u;
 const IMPORT_PATH_RE = /^[\w./-]+$/u;
 const assertIdentifier = (value, context) => {
   if (!IDENTIFIER_RE.test(value)) {
-    throw new Error(`@lunora/codegen: ${context} is not a valid JS identifier: ${JSON.stringify(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);
@@ -48,7 +400,10 @@ const literalToType = (value) => {
     return "unknown";
   }
   if (!LITERAL_VALUE_RE.test(value)) {
-    throw new Error(`@lunora/codegen: v.literal() argument is not a parseable string/number/boolean/null literal: ${JSON.stringify(value)}`);
+    throw new LunoraError(
+      "INTERNAL",
+      `@lunora/codegen: v.literal() argument is not a parseable string/number/boolean/null literal: ${JSON.stringify(value)}`
+    );
   }
   return value;
 };
@@ -342,19 +697,19 @@ ${members}
   };
   return [...namespaces.entries()].toSorted(([a], [b]) => a.localeCompare(b)).map((entry) => renderNamespace(entry)).join("\n");
 };
-const renderWorkflowsRef = (workflows) => {
-  if (workflows.length === 0) {
+const renderSchedulerReferences = (workflows, agents) => {
+  if (workflows.length === 0 && agents.length === 0) {
     return { block: "", importLine: "" };
   }
-  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");
-  const block = `
+  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;
@@ -362,7 +717,14 @@ export interface WorkflowReference<Params = Record<string, unknown>> {
     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}
@@ -372,17 +734,200 @@ export const workflows: WorkflowsRef = {
 ${objectMembers}
 };
 `;
-  return { block, importLine: `import type * as lunoraWorkflowDefinitions from "../workflows.js";
-` };
+    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 emitApi = (functions, workflows = [], useUmbrella = false) => {
+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");
+  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}`;
+${internalBody}
+${httpStreamsRef.body}`;
   const dataModelImports = referencedDataModelImports(combinedBody);
   const dataModelImportLine = dataModelImports.length > 0 ? `
 import type { ${dataModelImports.join(", ")} } from "./dataModel.js";
@@ -393,10 +938,11 @@ ${publicBody}
   const internalBlock = internalBody ? `
 ${internalBody}
 ` : "";
-  const workflowsRef = renderWorkflowsRef(workflows);
+  const schedulerReferences = renderSchedulerReferences(workflows, agents);
+  const clientImports = httpStreamsRef.block === "" ? "FunctionReference" : "FunctionReference, HttpStreamRef";
   return `${GENERATED_HEADER}import { anyApi } from "${base.serverTypes}";
-import type { FunctionReference } from "${base.client}";
-${workflowsRef.importLine}${dataModelImportLine}
+import type { ${clientImports} } from "${base.client}";
+${schedulerReferences.importLine}${dataModelImportLine}
 export interface ApiTypes {${apiBlock}}
 
 export const api = anyApi as unknown as ApiTypes;
@@ -405,7 +951,7 @@ export const api = anyApi as unknown as ApiTypes;
 export interface InternalApiTypes {${internalBlock}}
 
 export const internal = anyApi as unknown as InternalApiTypes;
-${workflowsRef.block}`;
+${schedulerReferences.block}${httpStreamsRef.block}`;
 };
 const emitSeed = (enabled) => {
   if (!enabled) {
@@ -430,21 +976,37 @@ import type { InsertModel } from "./dataModel.js";
 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 Object.assign(new Error(\`function not registered: \${functionPath}\`), {
-            name: "LunoraError",
-            code: "FUNCTION_NOT_FOUND",
-            status: 404,
-        });
+        throw new LunoraError("FUNCTION_NOT_FOUND", \`function not registered: \${functionPath}\`);
     }
 
     return (await registered.handler(context, args ?? {})) as R;
 };`;
-const renderFunctionRegistry = (functions, migrations) => {
+const renderFunctionRegistry = (functions, migrations, mutators = [], shapes = []) => {
   const aliasByPath = /* @__PURE__ */ new Map();
   const registerPath = (filePath) => {
     if (!aliasByPath.has(filePath)) {
@@ -457,9 +1019,15 @@ const renderFunctionRegistry = (functions, migrations) => {
   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 Error(`@lunora/codegen: refusing to emit import for unsafe file path: ${JSON.stringify(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");
@@ -469,15 +1037,37 @@ const renderFunctionRegistry = (functions, migrations) => {
   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: dispatchEntries.length > 0 ? `
-${dispatchEntries}
+    dispatchBody: combinedDispatch.length > 0 ? `
+${combinedDispatch}
 ` : "",
     importBlock: importLines.length > 0 ? `${importLines}
 
 ` : "",
+    installBlock: installLines,
     migrationBody: migrationEntries.length > 0 ? `
 ${migrationEntries}
+` : "",
+    mutatorPaths,
+    shapeBody: shapeEntries.length > 0 ? `
+${shapeEntries}
 ` : ""
   };
 };
@@ -530,16 +1120,23 @@ const buildStorageBucketNames = (schema, ruleBuckets = []) => {
   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,
   hasPayments = false,
   hasPipelines = false,
   hasR2sql = false,
+  hasX402 = false,
+  identity,
+  queues = [],
   schema,
   storageRuleBuckets = [],
   useUmbrella = false,
@@ -555,6 +1152,10 @@ const emitServer = ({
 ` : "";
   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 ? `
@@ -573,6 +1174,16 @@ const emitServer = ({
       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 = `
@@ -594,30 +1205,20 @@ ${envBindingFields}` : ""}
 
 /** Alias for {@link CloudflareBindings} — the typed shape of \`env\`. */
 export type Env = CloudflareBindings;`;
-  const kvContextField = hasKv ? `
-    readonly kv: import("@lunora/kv").Kv;` : "";
-  const hyperdriveActionField = hasHyperdrive ? `
-    /**
-     * 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;` : "";
-  const browserActionField = hasBrowser ? `
-    /** Browser Rendering (screenshots/PDF/scrape). Non-deterministic — available only in actions. */
-    readonly browser: import("@lunora/browser").Browser;` : "";
-  const imagesActionField = hasImages ? `
-    /** Cloudflare Images transforms (resize/format/optimize). Non-deterministic — available only in actions. */
-    readonly images: import("@lunora/images").Images;` : "";
-  const analyticsContextField = hasAnalytics ? `
-    /** Analytics Engine telemetry sink. Fire-and-forget and sampled; do not read it back in-handler. */
-    readonly analytics: import("@lunora/analytics").AnalyticsClient;` : "";
-  const pipelinesActionField = hasPipelines ? `
-    /** Pipelines ingestion sink (durable, R2-backed). Fire-and-forget and batched; do not read it back in-handler. */
-    readonly pipelines: import("@lunora/pipelines").PipelineClient;` : "";
-  const r2sqlActionField = hasR2sql ? `
-    /**
-     * 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/r2sql").R2SqlClient;` : "";
+  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 hasWorkflows = workflows.length > 0;
   const workflowsTypeImport = hasWorkflows ? `import type { WorkflowHandle } from "@lunora/workflow";
 import type * as lunoraWorkflowDefinitions from "../workflows.js";
@@ -638,6 +1239,59 @@ ${workflows.map((workflow) => `    get(name: ${JSON.stringify(workflow.exportNam
   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,
@@ -659,11 +1313,11 @@ import type {
 } from "${base.server}";
 
 import type { DataModel, DatabaseReaderFacade, DatabaseWriterFacade, Doc, Id as IdOfTable, OrmReader, OrmWriter, Relations, TableName } from "./dataModel.js";
-${aiTypeImport}${paymentsTypeImport}${containersTypeImport}${workflowsTypeImport}
+${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}
+export type StorageBucketName = ${storageBucketUnion};${envBlock}${workflowsTypeBlock}${queuesTypeBlock}${agentsTypeBlock}${identityTypeBlock}${envTypeBlock}
 
 /**
  * Project-typed contexts. The base contexts from \`@lunora/server\` are
@@ -692,22 +1346,22 @@ type TypedTableQuery = (<T extends TableName>(table: T) => TableReader<Doc<T>>)
  */
 type TypedTableGet = <T extends TableName>(id: IdOfTable<T>) => Promise<Doc<T> | null>;
 
-export interface QueryCtx extends Omit<QueryCtxBase, "db" | "storage"> {
+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>;${kvContextField}${analyticsContextField}
+    readonly storage: ReadOnlyStorage<StorageBucketName>;${accessContextField}${kvContextField}${flagsContextField}${analyticsContextField}${envContextField}${authContextField}
 }
 
-export interface MutationCtx extends Omit<MutationCtxBase, "db" | "storage"${workflowsOmit}> {
+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>;${kvContextField}${analyticsContextField}${workflowsContextField}
+    readonly storage: ReadOnlyStorage<StorageBucketName>;${accessContextField}${kvContextField}${flagsContextField}${analyticsContextField}${envContextField}${workflowsContextField}${queuesContextField}${agentsContextField}${authContextField}
 }
 
-export interface ActionCtx extends Omit<ActionCtxBase, "db" | "storage"${workflowsOmit}> {
+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>;${aiActionField}${paymentsActionField}${containersActionField}${kvContextField}${hyperdriveActionField}${browserActionField}${imagesActionField}${analyticsContextField}${pipelinesActionField}${r2sqlActionField}${workflowsContextField}
+    readonly storage: StorageBase<StorageBucketName>;${accessContextField}${aiActionField}${paymentsActionField}${x402ActionField}${containersActionField}${kvContextField}${flagsContextField}${hyperdriveActionField}${browserActionField}${imagesActionField}${analyticsContextField}${pipelinesActionField}${r2sqlActionField}${envContextField}${workflowsContextField}${queuesContextField}${agentsContextField}${authContextField}
 }
 
 /**
@@ -747,7 +1401,7 @@ export const internalAction = lunoraBuilders.internalAction as unknown as Intern
  * 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>();
+export const definePolicy = createPolicyDsl<DataModel, Relations${policyIdentityArgument}>();
 
 /**
  * The validator builder \`v\`, with \`v.id(...)\` constrained to THIS schema's
@@ -777,10 +1431,52 @@ const renderLifecycleManifest = (functions) => {
   }
   return manifest;
 };
-const emitFunctions = (functions, migrations = []) => {
+const emitFunctions = (options) => {
+  const { agents = [], functions, migrations = [], mutators = [], shapes = [], useUmbrella = false, usesSandbox = false } = options;
   const hasFunctions = functions.length > 0;
-  const { dispatchBody, importBlock, migrationBody } = renderFunctionRegistry(functions, migrations);
+  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}
@@ -795,7 +1491,8 @@ ${caller.implementation}
   const callRegisteredHelper = hasFunctions ? `${CALL_REGISTERED_HELPER}
 
 ` : "";
-  return `${GENERATED_HEADER}${importBlock}import type { ActionCtx, MutationCtx, QueryCtx } from "./server.js";
+  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.
@@ -815,13 +1512,13 @@ export interface RegisteredLunoraFunction {
     /** \`"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> = {${dispatchBody}};
-
+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
@@ -843,11 +1540,7 @@ export const dispatchLunoraFunction = async (functionPath: string, context: unkn
     const registered = LUNORA_FUNCTIONS[functionPath];
 
     if (!registered || registered.visibility === "internal") {
-        throw Object.assign(new Error(\`function not registered: \${functionPath}\`), {
-            name: "LunoraError",
-            code: "FUNCTION_NOT_FOUND",
-            status: 404,
-        });
+        throw new LunoraError("FUNCTION_NOT_FOUND", \`function not registered: \${functionPath}\`);
     }
 
     return registered.handler(context, args);
@@ -1042,7 +1735,7 @@ const emitKvFragments = (hasKv) => {
     kv?: (env: Record<string, unknown>) => KVNamespaceLike;`,
     contextField: `
                 kv,`,
-    importLines: [`import type { Kv, KVNamespaceLike } from "@lunora/kv";`, `import { createKv } from "@lunora/kv";`],
+    importLines: [`import type { Kv, KVNamespaceLike } from "@lunora/bindings/kv";`, `import { createKv } from "@lunora/bindings/kv";`],
     stub: `
 const kvStub: Kv = {
     delete: async () => {
@@ -1067,6 +1760,131 @@ const kvStub: Kv = {
 `
   };
 };
+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 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;
@@ -1082,8 +1900,8 @@ const emitAnalyticsFragments = (hasAnalytics) => {
     contextField: `
                 analytics,`,
     importLines: [
-      `import type { AnalyticsClient, AnalyticsEngineDatasetLike } from "@lunora/analytics";`,
-      `import { createAnalytics } from "@lunora/analytics";`
+      `import type { AnalyticsClient, AnalyticsEngineDatasetLike } from "@lunora/bindings/analytics";`,
+      `import { createAnalytics } from "@lunora/bindings/analytics";`
     ],
     stub: `
 const analyticsStub: AnalyticsClient = {
@@ -1112,7 +1930,7 @@ const emitImagesFragments = (hasImages) => {
     // ActionCtx-only: woven onto the action ctx object, never query/mutation.
     contextField: `
                 images,`,
-    importLines: [`import type { Images, ImagesBindingLike } from "@lunora/images";`, `import { createImages } from "@lunora/images";`],
+    importLines: [`import type { Images, ImagesBindingLike } from "@lunora/bindings/images";`, `import { createImages } from "@lunora/bindings/images";`],
     stub: `
 const imagesStub: Images = {
     info: async () => {
@@ -1211,10 +2029,10 @@ const emitR2sqlFragments = (hasR2sql) => {
     // 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/r2sql";`, `import { createR2Sql } from "@lunora/r2sql";`],
+    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/r2sql` client.ts) when a method is added there.
+    // (`@lunora/bindings/r2sql` client.ts) when a method is added there.
     stub: `
 const r2sqlStub: R2SqlClient = {
     describe: async () => {
@@ -1239,17 +2057,46 @@ const r2sqlStub: R2SqlClient = {
 `
   };
 };
-const emitContainers = (containers) => {
+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}");
+        super(ctx, env, ${container.exportName}, "${container.exportName}"${jurisdictionArgument});
     }
 }
 `;
@@ -1261,14 +2108,21 @@ export class ${container.className} extends LunoraContainer {
  * 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 { LunoraContainer } from "@lunora/container/do";
 
 import { ${imports} } from "../containers.js";
 
+export { ContainerProxy } from "@lunora/container/do";
+
 ${classes}`;
 };
-const emitContainerFragments = (containers) => {
+const emitContainerFragments = (containers, jurisdiction) => {
   if (containers.length === 0) {
     return { build: "", contextField: "", importLines: [], specs: "" };
   }
@@ -1281,8 +2135,12 @@ const emitContainerFragments = (containers) => {
     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);
+            const containers = createContainerContext(env, LUNORA_CONTAINERS, ${jurisdiction ? JSON.stringify(jurisdiction) : "undefined"}, this.getCurrentTraceparent());
 `,
     contextField: `
                 containers,`,
@@ -1335,6 +2193,88 @@ type WorkflowOutputOf<Definition> = Definition extends { __output?: infer Output
 
 ${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: "" };
@@ -1360,6 +2300,56 @@ ${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: "" };
@@ -1386,6 +2376,33 @@ const LUNORA_WORKFLOWS_INFO: WorkflowsResult = ${JSON.stringify(metadata, void 0
 `
   };
 };
+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: "" };
@@ -1441,13 +2458,41 @@ const paymentStub: LunoraPayment = {
 `
   };
 };
-const buildDoTypeImports = (hasVectors, hasWorkflows) => [
+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",
@@ -1468,43 +2513,62 @@ const buildDoTypeImports = (hasVectors, hasWorkflows) => [
 ];
 const emitShard = ({
   advisories = [],
+  agents = [],
   containers = [],
+  env,
+  flagKeys = [],
+  hasAccessFacade = false,
   hasAi = false,
   hasAnalytics = false,
   hasBrowser = false,
+  hasFlags = false,
   hasHyperdrive = false,
   hasImages = false,
   hasKv = 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 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);
+  } = 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,
@@ -1512,25 +2576,35 @@ const emitShard = ({
     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 Error(
+    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.'
     );
   }
@@ -1539,41 +2613,116 @@ const emitShard = ({
   const tableIndexes = buildTableIndexes(schema);
   const tableColumns = buildTableColumns(schema);
   const storageColumns = buildStorageColumns(schema);
-  const doTypeImports = buildDoTypeImports(hasVectors, workflows.length > 0);
+  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, createShardCtxDb, runDataMigration, runShardMigrations, ${relationFanout.importFragment}ShardDO as ShardDOBase } from "${base.do}";`,
-    // `asBucketStorage` (the bucket-aware `ctx.storage` wrapper) lives in
+    `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.
-    `import { asBucketStorage } from "${base.server}";`
+    // 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/vectors";`,
-      `import { createContextVectors, createVectors, createVectorSyncHook } from "@lunora/vectors";`
+      `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,
+    ...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";`,
-    `import { LUNORA_FUNCTIONS, LUNORA_LIFECYCLE_HOOKS, LUNORA_MIGRATIONS } from "./functions.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>;` : "";
@@ -1581,6 +2730,8 @@ const emitShard = ({
     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 () => {
@@ -1698,6 +2849,158 @@ const vectorsStub: VectorSearchLike = {
   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 sourceConstructorOverride = hasSourcedTables ? `
+        public constructor(state: ShardDOState, env: unknown) {
+            super(state, env);
+
+            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 facadeBlock = hasTables ? `
             const facade = db as unknown as Record<string, ReturnType<typeof bindTableFacade>>;
@@ -1711,18 +3014,24 @@ ${schema.tables.map(
     (table) => `            facade[${JSON.stringify(table.name)}] = bindTableFacade(db, ${JSON.stringify(table.name)});`
   ).join("\n")}
 ` : "";
-  const everyContextBuild = `${kvFragments.build}${analyticsFragments.build}`;
-  const everyContextField = `${kvFragments.contextField}${analyticsFragments.contextField}`;
-  const actionOnlyHasAny = hasImages || hasHyperdrive || hasBrowser || hasR2sql;
+  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}${analyticsFragments.contextField}${envFragments.contextField}
+                secrets,`;
+  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}${[
+${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;"] : []
+    ...hasR2sql ? ["                ctx.r2sql = r2sql;"] : [],
+    ...hasPipelines ? ["                ctx.pipelines = pipelines;"] : [],
+    ...hasX402 ? ["                ctx.x402 = x402;"] : []
   ].join("\n")}
             }
 ` : "";
@@ -1762,14 +3071,14 @@ const LUNORA_STORAGE_RULES: StorageRulesResult = ${JSON.stringify(storageRulesDa
 
 /** 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)};
-${workflowsMetadataConst}${containerSpecs}${workflowSpecs}
+${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}${analyticsFragments.configField}${imagesFragments.configField}${hyperdriveFragments.configField}${browserFragments.configField}${r2sqlFragments.configField}${paymentsConfigField}${d1ConfigField}${hyperdriveGlobalConfigField}
+    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 = {
@@ -1807,7 +3116,7 @@ const storageStub = {
         throw new Error("ctx.storage: no storage configured. Pass \`storage\` to createShardDO().");
     },
 };
-${globalDatabaseStub}${vectorsStub}${aiStub}${kvFragments.stub}${analyticsFragments.stub}${imagesFragments.stub}${hyperdriveFragments.stub}${browserFragments.stub}${r2sqlFragments.stub}${paymentStub}${bindTableHelper}
+${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
@@ -1827,11 +3136,7 @@ const dispatchRun = async (expected: FunctionKind, functionPath: string, args: R
     }
 
     if (runDepth >= MAX_RUN_DEPTH) {
-        throw Object.assign(new Error(\`ctx.run*: composition depth limit (\${MAX_RUN_DEPTH}) exceeded — likely a cyclic runQuery/runMutation\`), {
-            name: "LunoraError",
-            code: "RUN_DEPTH_EXCEEDED",
-            status: 500,
-        });
+        throw new LunoraError("RUN_DEPTH_EXCEEDED", \`ctx.run*: composition depth limit (\${MAX_RUN_DEPTH}) exceeded — likely a cyclic runQuery/runMutation\`);
     }
 
     runDepth += 1;
@@ -1848,7 +3153,7 @@ const dispatchRun = async (expected: FunctionKind, functionPath: string, args: R
  * from the worker entry so wrangler binds it by name.
  */
 export const createShardDO = (config: ShardDOConfig = {}): new (state: ShardDOState, env: unknown) => ShardDOBase =>
-    class extends ShardDOBase {
+    class extends ShardDOBase {${sourceConstructorOverride}
         private migrated = false;
 
         public override async handleRpc(functionPath: string, args: Record<string, unknown>): Promise<unknown> {
@@ -1859,11 +3164,7 @@ export const createShardDO = (config: ShardDOConfig = {}): new (state: ShardDOSt
             // \`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 Object.assign(new Error(\`function not registered: \${functionPath}\`), {
-                    name: "LunoraError",
-                    code: "FUNCTION_NOT_FOUND",
-                    status: 404,
-                });
+                throw new LunoraError("FUNCTION_NOT_FOUND", \`function not registered: \${functionPath}\`);
             }
 
             this.ensureMigrated();
@@ -1877,8 +3178,20 @@ export const createShardDO = (config: ShardDOConfig = {}): new (state: ShardDOSt
             // 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(() => registered.handler(ctx, args));
+                return this.runInTransaction(async () => {
+                    const result = await registered.handler(ctx, args);
+
+                    this.commitMutationBookkeeping(result);
+
+                    return result;
+                });
             }
 
             return registered.handler(ctx, args);
@@ -1916,7 +3229,7 @@ ${relationFanout.override}
                 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];
         }
@@ -1952,7 +3265,7 @@ ${relationFanout.override}
         protected override studioFeatures(): StudioFeaturesResult {
             return LUNORA_STUDIO_FEATURES;
         }
-${workflowsMetadataOverride}
+${flagsOverrides.evaluateOverride}${flagsOverrides.subscriptionOverride}${workflowsMetadataOverride}${queuesMetadataOverride}
         protected override advisories(): AdvisoryFinding[] {
             return LUNORA_ADVISORIES;
         }
@@ -1961,11 +3274,7 @@ ${workflowsMetadataOverride}
             const migration = LUNORA_MIGRATIONS[args.id];
 
             if (!migration) {
-                throw Object.assign(new Error(\`data migration "\${args.id}" is not registered\`), {
-                    name: "LunoraError",
-                    code: "MIGRATION_NOT_FOUND",
-                    status: 404,
-                });
+                throw new LunoraError("MIGRATION_NOT_FOUND", \`data migration "\${args.id}" is not registered\`, { status: 404 });
             }
 
             this.ensureMigrated();
@@ -2001,18 +3310,14 @@ ${workflowsMetadataOverride}
             const definition = (schema as unknown as SchemaLike).tables[args.table];
 
             if (!definition) {
-                throw Object.assign(new Error(\`unknown table: \${args.table}\`), { name: "LunoraError", code: "UNKNOWN_TABLE", status: 404 });
+                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 Object.assign(new Error(\`table "\${args.table}" is global; edit it through D1, not the shard\`), {
-                    name: "LunoraError",
-                    code: "GLOBAL_TABLE_NOT_EDITABLE",
-                    status: 400,
-                });
+                throw new LunoraError("GLOBAL_TABLE_NOT_EDITABLE", \`table "\${args.table}" is global; edit it through D1, not the shard\`, { status: 400 });
             }
 
             this.ensureMigrated();
@@ -2056,17 +3361,13 @@ ${workflowsMetadataOverride}
             const definition = (schema as unknown as SchemaLike).tables[table];
 
             if (!definition) {
-                throw Object.assign(new Error(\`unknown table: \${table}\`), { name: "LunoraError", code: "UNKNOWN_TABLE", status: 404 });
+                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 Object.assign(new Error(\`table "\${table}" is global; edit it through D1, not the shard\`), {
-                    name: "LunoraError",
-                    code: "GLOBAL_TABLE_NOT_EDITABLE",
-                    status: 400,
-                });
+                throw new LunoraError("GLOBAL_TABLE_NOT_EDITABLE", \`table "\${table}" is global; edit it through D1, not the shard\`, { status: 400 });
             }
 
             this.ensureMigrated();
@@ -2107,7 +3408,7 @@ ${workflowsMetadataOverride}
             // \`rankBefore\` is optional on \`DatabaseWriterLike\` (the D1 twin omits it),
             // but the shard writer from \`createShardCtxDb\` always defines it.
             if (!writer.rankBefore) {
-                throw Object.assign(new Error("rankBefore is unavailable on the shard writer"), { name: "LunoraError", code: "NOT_IMPLEMENTED", status: 500 });
+                throw new LunoraError("NOT_IMPLEMENTED", "rankBefore is unavailable on the shard writer", { status: 500 });
             }
 
             return writer.rankBefore(args.table, args.index, {
@@ -2137,7 +3438,7 @@ ${workflowsMetadataOverride}
             // 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 Object.assign(new Error("rankPage is unavailable on the shard writer"), { name: "LunoraError", code: "NOT_IMPLEMENTED", status: 500 });
+                throw new LunoraError("NOT_IMPLEMENTED", "rankPage is unavailable on the shard writer", { status: 500 });
             }
 
             return writer.rankPageRows(args.table, args.index, {
@@ -2186,7 +3487,7 @@ ${workflowsMetadataOverride}
             // 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}
+${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
@@ -2195,19 +3496,20 @@ ${vectorsBuild}${aiBuild}${everyContextBuild}${containersBuild}${workflowsBuild}
             const storage = asBucketStorage(config.storage?.(env) ?? storageStub) as unknown as SystemReaderStorageLike;
 ${globalDatabaseLine}            const db: DatabaseWriterLike = createShardCtxDb(${databaseOptions});
 ${facadeBlock}${paymentsBuild}
-            // \`ctx.log\`: each call is captured + attributed to the executing
-            // function and routed to the optional \`observability\` sink. The DO base
-            // also buffers it (studio Logs panel) and emits a structured console
-            // event the dev-server formats in the terminal.
+            // \`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 = {
-                debug: (...args: unknown[]) => { this.recordUserLog(logFunctionPath, "debug", args, observability); },
-                error: (...args: unknown[]) => { this.recordUserLog(logFunctionPath, "error", args, observability); },
-                info: (...args: unknown[]) => { this.recordUserLog(logFunctionPath, "info", args, observability); },
-                log: (...args: unknown[]) => { this.recordUserLog(logFunctionPath, "log", args, observability); },
-                warn: (...args: unknown[]) => { this.recordUserLog(logFunctionPath, "warn", args, observability); },
-            };
+            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);
 
             // \`ctx.now\`: the wall-clock instant (epoch ms) this function began,
             // captured ONCE so the whole handler body sees a single stable value.
@@ -2226,9 +3528,11 @@ ${facadeBlock}${paymentsBuild}
                 fetch: globalThis.fetch.bind(globalThis),
                 ip: this.getCurrentIp(),
                 log,
+                metrics,
                 now,${ormContextField}
                 scheduler,
-                storage,${vectorsContextField}${aiContextField}${everyContextField}${paymentsContextField}${containersContextField}${workflowsContextField}
+                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);
@@ -2492,4 +3796,4 @@ const emitWranglerCronTriggers = (crons) => {
   return triggers;
 };
 
-export { GENERATED_HEADER, buildStorageColumns, emitApi, emitContainers, emitCrons, emitDataModel, emitDrizzleSchema, emitFunctions, emitSeed, emitServer, emitShard, emitVectors, emitWorkflows, emitWranglerCronTriggers };
+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 };