@lunora/config 1.0.0-alpha.7 → 1.0.0-alpha.70

package/dist/packem_shared/{inferLunoraBindings-XNJH4pup.mjs → inferLunoraBindings-BcvvtpSG.mjs}

@@ -1,10 +1,39 @@
 import { existsSync, statSync, readFileSync, readdirSync } from 'node:fs';
 import { init, parse } from 'es-module-lexer';
+import { discoverAgentInfo } from './discoverAgentInfo-eXA3hF4v.mjs';
 import { discoverContainerInfo } from './discoverContainerInfo-BXFs6Wav.mjs';
-import { discoverSchemaInfo } from './discoverSchemaInfo-DWtypqpP.mjs';
+import { FLAGS_FILENAME, discoverFlags, QUEUES_FILENAME, discoverQueues } from '@lunora/codegen';
+import { Project } from 'ts-morph';
+import { join } from 'node:path';
+import { discoverSchemaInfo } from './discoverSchemaInfo-BB-CKlTK.mjs';
 import { discoverWorkflowInfo } from './discoverWorkflowInfo-CedvR0mn.mjs';
 import { WRANGLER_FILES, readWranglerJsonc } from './WRANGLER_FILES-DwSuC-Kn.mjs';
-import { join } from 'node:path';
+
+const discoverFlagsInfo = (projectRoot, schemaDirectory) => {
+  const flagsPath = join(projectRoot, schemaDirectory, FLAGS_FILENAME);
+  if (!existsSync(flagsPath)) {
+    return {};
+  }
+  try {
+    const project = new Project({ skipAddingFilesFromTsConfig: true, useInMemoryFileSystem: false });
+    return { flags: discoverFlags(project, join(projectRoot, schemaDirectory)) };
+  } catch (error) {
+    return { error: error instanceof Error ? error.message : String(error) };
+  }
+};
+
+const discoverQueueInfo = (projectRoot, schemaDirectory) => {
+  const queuesPath = join(projectRoot, schemaDirectory, QUEUES_FILENAME);
+  if (!existsSync(queuesPath)) {
+    return { queues: [] };
+  }
+  try {
+    const project = new Project({ skipAddingFilesFromTsConfig: true, useInMemoryFileSystem: false });
+    return { queues: discoverQueues(project, join(projectRoot, schemaDirectory)) };
+  } catch (error) {
+    return { error: error instanceof Error ? error.message : String(error), queues: [] };
+  }
+};
 
 const SOURCE_EXTENSIONS = /* @__PURE__ */ new Set([".cjs", ".cts", ".js", ".jsx", ".mjs", ".mts", ".ts", ".tsx"]);
 const IGNORED_DIRECTORIES = /* @__PURE__ */ new Set([".git", ".lunora-cache", ".wrangler", "_generated", "dist", "node_modules"]);
@@ -23,20 +52,60 @@ const TYPE_ONLY_EXPORT_PATTERNS = {
 };
 const ENV_DB_PATTERN = /\benv\s*\.\s*DB\b/;
 const ENV_AI_PATTERN = /\benv\s*\.\s*AI\b/;
+const CTX_PIPELINES_PATTERN = /\bctx\s*\.\s*pipelines\b/;
 const TYPE_ONLY_IMPORT_PATTERN = /^\s*import\s+type\b/;
+const SANDBOX_MODULE_SPECIFIERS = /* @__PURE__ */ new Set(["@lunora/agent", "@lunora/agent/sandbox"]);
+const extractImportSpecifierList = (statementText) => {
+  const openBraceIndex = statementText.indexOf("{");
+  if (openBraceIndex === -1) {
+    return "";
+  }
+  const closeBraceIndex = statementText.indexOf("}", openBraceIndex + 1);
+  return closeBraceIndex === -1 ? statementText.slice(openBraceIndex + 1) : statementText.slice(openBraceIndex + 1, closeBraceIndex);
+};
+const TYPE_BROWSER_TOOL_SPECIFIER_PATTERN = /\btype\s+browserTool\b/;
+const BROWSER_TOOL_NAME_PATTERN = /\bbrowserTool\b/;
+const SANDBOX_BROWSER_TOOL_FALLBACK_PATTERN = /import\s+\{[^}]*\bbrowserTool\b[^}]*\}\s+from\s+["']@lunora\/agent(?:\/sandbox)?["']/;
+const isValueBrowserToolImport = (statementText) => {
+  if (TYPE_ONLY_IMPORT_PATTERN.test(statementText)) {
+    return false;
+  }
+  const specifierList = extractImportSpecifierList(statementText);
+  return BROWSER_TOOL_NAME_PATTERN.test(specifierList) && !TYPE_BROWSER_TOOL_SPECIFIER_PATTERN.test(specifierList);
+};
+const hasSandboxBrowserToolImport = (code) => {
+  try {
+    const [imports] = parse(code);
+    return imports.some(
+      (entry) => entry.n !== void 0 && SANDBOX_MODULE_SPECIFIERS.has(entry.n) && isValueBrowserToolImport(code.slice(entry.ss, entry.se))
+    );
+  } catch {
+    return SANDBOX_BROWSER_TOOL_FALLBACK_PATTERN.test(code);
+  }
+};
 const CAPABILITY_SOURCES = {
   usesAi: { pattern: /\bfrom\s+["']@lunora\/ai["']/, source: "@lunora/ai" },
-  usesAnalytics: { pattern: /\bfrom\s+["']@lunora\/analytics["']/, source: "@lunora/analytics" },
+  usesAnalytics: { pattern: /\bfrom\s+["']@lunora\/bindings\/analytics["']/, source: "@lunora/bindings/analytics" },
   usesAuth: { pattern: /\bfrom\s+["']@lunora\/auth["']/, source: "@lunora/auth" },
   usesBrowser: { pattern: /\bfrom\s+["']@lunora\/browser["']/, source: "@lunora/browser" },
   usesHyperdrive: { pattern: /\bfrom\s+["']@lunora\/hyperdrive["']/, source: "@lunora/hyperdrive" },
-  usesImages: { pattern: /\bfrom\s+["']@lunora\/images["']/, source: "@lunora/images" },
-  usesKv: { pattern: /\bfrom\s+["']@lunora\/kv["']/, source: "@lunora/kv" },
+  usesImages: { pattern: /\bfrom\s+["']@lunora\/bindings\/images["']/, source: "@lunora/bindings/images" },
+  usesKv: { pattern: /\bfrom\s+["']@lunora\/bindings\/kv["']/, source: "@lunora/bindings/kv" },
   usesMail: { pattern: /\bfrom\s+["']@lunora\/mail["']/, source: "@lunora/mail" },
   usesPayment: { pattern: /\bfrom\s+["']@lunora\/payment["']/, source: "@lunora/payment" },
-  usesPipelines: { pattern: /\bfrom\s+["']@lunora\/pipelines["']/, source: "@lunora/pipelines" },
+  // Keyed off the `ctx.pipelines` access (not an import) — see CTX_PIPELINES_PATTERN.
+  // Pipelines is codegen-wired onto ActionCtx, so apps reach it via `ctx.pipelines`
+  // rather than importing `@lunora/bindings/pipelines`; `source` names that subpath
+  // for the hint message.
+  usesPipelines: { pattern: CTX_PIPELINES_PATTERN, source: "@lunora/bindings/pipelines" },
   usesScheduler: { pattern: /\bfrom\s+["']@lunora\/scheduler["']/, source: "@lunora/scheduler" },
-  usesStorage: { pattern: /\bfrom\s+["']@lunora\/storage["']/, source: "@lunora/storage" }
+  usesStorage: { pattern: /\bfrom\s+["']@lunora\/storage["']/, source: "@lunora/storage" },
+  // x402 rails are opt-in add-on subpaths (not part of the `lunorash` umbrella),
+  // so they key off the exact `@lunora/x402/{charge,pay}` specifiers. Neither
+  // implies a `.dev.vars` secret: the charge recipient is a user-named `[vars]`
+  // entry and the pay wallet key is a Secrets Store binding — both hint-only.
+  usesX402Charge: { pattern: /\bfrom\s+["']@lunora\/x402\/charge["']/, source: "@lunora/x402/charge" },
+  usesX402Pay: { pattern: /\bfrom\s+["']@lunora\/x402\/pay["']/, source: "@lunora/x402/pay" }
 };
 const CAPABILITY_FLAGS = Object.keys(CAPABILITY_SOURCES);
 const PAYMENT_PROVIDER_SECRETS = "STRIPE_SECRET_KEY + STRIPE_WEBHOOK_SECRET (Stripe) or POLAR_ACCESS_TOKEN + POLAR_WEBHOOK_SECRET (Polar)";
@@ -90,7 +159,12 @@ const capabilitiesFromSource = (code) => {
   } catch {
     capabilities = regexCapabilities(code);
   }
-  return mergeCapabilities(capabilities, { ...NO_CAPABILITIES, needsD1: ENV_DB_PATTERN.test(code), usesAi: ENV_AI_PATTERN.test(code) });
+  return mergeCapabilities(capabilities, {
+    ...NO_CAPABILITIES,
+    needsD1: ENV_DB_PATTERN.test(code),
+    usesAi: ENV_AI_PATTERN.test(code),
+    usesPipelines: CTX_PIPELINES_PATTERN.test(code)
+  });
 };
 const collectSourceFiles = (directory, accumulator) => {
   let entries;
@@ -149,56 +223,39 @@ const detectExportedDurableObjects = (entryPath) => {
     };
   });
 };
-const CONTAINERS_STAR_REEXPORT_PATTERN = /\bexport\s*\*\s*from\s*["'][^"']*_generated\/containers(?:\.js)?["']/;
-const detectContainerExports = (entryPath, containers) => {
-  if (containers.length === 0) {
-    return [];
-  }
-  if (entryPath === void 0) {
-    return containers.map((container) => {
-      return { ...container, exported: false };
-    });
-  }
-  const code = readFileSync(entryPath, "utf8");
-  const starReexport = CONTAINERS_STAR_REEXPORT_PATTERN.test(code);
-  let exportedNames;
-  try {
-    const [, exports] = parse(code);
-    exportedNames = new Set(exports.map((entry) => entry.n));
-  } catch {
-    exportedNames = new Set(
-      containers.map((container) => container.className).filter((className) => new RegExp(String.raw`\bexport\b[^\n;]*\b${className}\b`).test(code))
-    );
-  }
-  return containers.map((container) => {
-    return { ...container, exported: starReexport || exportedNames.has(container.className) };
-  });
-};
-const WORKFLOWS_STAR_REEXPORT_PATTERN = /\bexport\s*\*\s*from\s*["'][^"']*_generated\/workflows(?:\.js)?["']/;
-const detectWorkflowExports = (entryPath, workflows) => {
-  if (workflows.length === 0) {
+const isTypeOnlyClassExport = (code, className) => (
+  // `export type Foo` / `export type { … Foo … }` / `export { type Foo }` — all
+  // three type-only forms list the name via the lexer but compile away.
+  new RegExp(String.raw`\bexport\s+type\s+${className}\b`).test(code) || new RegExp(String.raw`\bexport\s+type\s*\{[^}]*\b${className}\b`).test(code) || new RegExp(String.raw`\bexport\s+\{[^}]*\btype\s+${className}\b`).test(code)
+);
+const detectClassExports = (entryPath, definitions, generatedModule) => {
+  if (definitions.length === 0) {
     return [];
   }
   if (entryPath === void 0) {
-    return workflows.map((workflow) => {
-      return { ...workflow, exported: false };
+    return definitions.map((definition) => {
+      return { ...definition, exported: false };
     });
   }
   const code = readFileSync(entryPath, "utf8");
-  const starReexport = WORKFLOWS_STAR_REEXPORT_PATTERN.test(code);
+  const starReexport = new RegExp(String.raw`\bexport\s*\*\s*from\s*["'][^"']*_generated\/${generatedModule}(?:\.js)?["']`).test(code);
   let exportedNames;
   try {
     const [, exports] = parse(code);
     exportedNames = new Set(exports.map((entry) => entry.n));
   } catch {
     exportedNames = new Set(
-      workflows.map((workflow) => workflow.className).filter((className) => new RegExp(String.raw`\bexport\b[^\n;]*\b${className}\b`).test(code))
+      definitions.map((definition) => definition.className).filter((className) => new RegExp(String.raw`\bexport\b[^\n;]*\b${className}\b`).test(code))
     );
   }
-  return workflows.map((workflow) => {
-    return { ...workflow, exported: starReexport || exportedNames.has(workflow.className) };
+  return definitions.map((definition) => {
+    const exported = starReexport || exportedNames.has(definition.className) && !isTypeOnlyClassExport(code, definition.className);
+    return { ...definition, exported };
   });
 };
+const detectContainerExports = (entryPath, containers) => detectClassExports(entryPath, containers, "containers");
+const detectWorkflowExports = (entryPath, workflows) => detectClassExports(entryPath, workflows, "workflows");
+const detectAgentExports = (entryPath, agents) => detectClassExports(entryPath, agents, "agents");
 const schemaNeedsD1 = (projectRoot, schemaDirectory) => discoverSchemaInfo(projectRoot, schemaDirectory).info?.hasGlobalTable ?? false;
 const scanCapabilities = (projectRoot, scanDirectories) => {
   let merged = NO_CAPABILITIES;
@@ -215,12 +272,24 @@ const scanCapabilities = (projectRoot, scanDirectories) => {
   }
   return merged;
 };
-const describeDeclaredExports = (containers, workflows) => [
+const scanSandboxBrowserToolUsage = (projectRoot, lunoraDirectory) => {
+  const absolute = join(projectRoot, lunoraDirectory);
+  if (!existsSync(absolute) || !statSync(absolute).isDirectory()) {
+    return false;
+  }
+  const files = [];
+  collectSourceFiles(absolute, files);
+  return files.some((file) => hasSandboxBrowserToolImport(readFileSync(file, "utf8")));
+};
+const describeDeclaredExports = (containers, workflows, agents) => [
   ...containers.map(
     (container) => container.exported ? `${container.bindingName}/${container.className} (container "${container.exportName}" declared and exported)` : `hint: container "${container.exportName}" is declared but ${container.className} is not exported by the worker entry — add \`export * from "./lunora/_generated/containers"\``
   ),
   ...workflows.map(
     (workflow) => workflow.exported ? `${workflow.bindingName}/${workflow.className} (workflow "${workflow.exportName}" declared and exported)` : `hint: workflow "${workflow.exportName}" is declared but ${workflow.className} is not exported by the worker entry — add \`export * from "./lunora/_generated/workflows"\``
+  ),
+  ...agents.map(
+    (agent) => agent.exported ? `${agent.bindingName}/${agent.className} (agent "${agent.exportName}" declared and exported)` : `hint: agent "${agent.exportName}" is declared but ${agent.className} is not exported by the worker entry — add \`export * from "./lunora/_generated/agents"\``
   )
 ];
 const describeCapabilitySignals = (capabilities, exported) => {
@@ -237,14 +306,14 @@ const describeCapabilitySignals = (capabilities, exported) => {
     // Self-describing bindings: the binding name is the whole config (no remote
     // id to mint), so reconcile auto-writes them like the DO/D1 bindings.
     [capabilities.usesBrowser, "browser (@lunora/browser imported) — self-describing { binding: BROWSER }"],
-    [capabilities.usesImages, "images (@lunora/images imported) — self-describing { binding: IMAGES }"],
-    [capabilities.usesAnalytics, "analytics_engine_datasets (@lunora/analytics imported) — self-describing { binding: ANALYTICS, dataset }"],
+    [capabilities.usesImages, "images (@lunora/bindings/images imported) — self-describing { binding: IMAGES }"],
+    [capabilities.usesAnalytics, "analytics_engine_datasets (@lunora/bindings/analytics imported) — self-describing { binding: ANALYTICS, dataset }"],
     // Hint bindings: each needs a remote resource Lunora can't fabricate (a KV
     // namespace id, a Hyperdrive id, a Pipelines pipeline name), so they surface
     // as hints — never an auto-write — exactly like R2's user-defined bucket name.
     [
       capabilities.usesKv,
-      "hint: @lunora/kv is imported; add a kv_namespaces binding ({ binding, id }) and pass env.<BINDING> to createKv() — the namespace id can't be auto-provisioned"
+      "hint: @lunora/bindings/kv is imported; add a kv_namespaces binding ({ binding, id }) and pass env.<BINDING> to createKv() — the namespace id can't be auto-provisioned"
     ],
     [
       capabilities.usesHyperdrive,
@@ -252,39 +321,65 @@ const describeCapabilitySignals = (capabilities, exported) => {
     ],
     [
       capabilities.usesPipelines,
-      "hint: @lunora/pipelines is imported; run 'wrangler pipelines create <name>' and add a 'pipelines' binding ({ binding, pipeline }) — the pipeline resource can't be auto-provisioned"
+      "hint: ctx.pipelines is used; run 'wrangler pipelines create <name>' and add a 'pipelines' binding ({ binding, pipeline }) — the pipeline resource can't be auto-provisioned"
+    ],
+    [
+      capabilities.usesX402Charge,
+      "hint: @lunora/x402/charge is imported; set the recipient wallet address as a [vars] entry (the var name is yours to choose) and pass it to the charge config — the x402 facilitator settles USDC to that address"
+    ],
+    [
+      capabilities.usesX402Pay,
+      "hint: @lunora/x402/pay is imported (ActionCtx-only, spends real funds); add a secrets_store_secrets[] binding for the agent wallet key (name it to match signer.secretName) and pair the pay rail with a spend policy — ctx.secrets reads a Secrets Store binding, not .dev.vars, so the key can't be auto-provisioned"
     ]
   ];
   return rules.filter(([active]) => active).map(([, signal]) => signal);
 };
-const describeSignals = (durableObjects, needsD1, capabilities, containers = [], workflows = []) => {
+const describeSignals = (durableObjects, needsD1, capabilities, containers = [], workflows = [], agents = []) => {
   const exported = new Set(durableObjects.map((object) => object.className));
   const signals = durableObjects.map((object) => `${object.binding}/${object.className} (exported by worker entry)`);
   if (needsD1) {
     signals.push("DB (.global() table declared)");
   }
-  signals.push(...describeDeclaredExports(containers, workflows), ...describeCapabilitySignals(capabilities, exported));
+  signals.push(...describeDeclaredExports(containers, workflows, agents), ...describeCapabilitySignals(capabilities, exported));
   return signals;
 };
 const inferLunoraBindings = async (options) => {
   await init;
   const schemaDirectory = options.schemaDir ?? "lunora";
   const scanDirectories = options.scanDirs ?? DEFAULT_SCAN_DIRECTORIES;
-  const capabilities = scanCapabilities(options.projectRoot, scanDirectories);
+  const scannedCapabilities = scanCapabilities(options.projectRoot, scanDirectories);
+  const capabilities = {
+    ...scannedCapabilities,
+    usesBrowser: scannedCapabilities.usesBrowser || scanSandboxBrowserToolUsage(options.projectRoot, schemaDirectory)
+  };
   const entryPath = resolveWorkerEntry(options.projectRoot);
   const durableObjects = entryPath ? detectExportedDurableObjects(entryPath) : [];
   const needsD1 = capabilities.needsD1 || schemaNeedsD1(options.projectRoot, schemaDirectory);
   const containers = detectContainerExports(entryPath, discoverContainerInfo(options.projectRoot, schemaDirectory).containers);
   const workflows = detectWorkflowExports(entryPath, discoverWorkflowInfo(options.projectRoot, schemaDirectory).workflows);
+  const agents = detectAgentExports(entryPath, discoverAgentInfo(options.projectRoot, schemaDirectory).agents);
+  const queues = [...discoverQueueInfo(options.projectRoot, schemaDirectory).queues];
+  const { flags } = discoverFlagsInfo(options.projectRoot, schemaDirectory);
+  const flagshipBinding = flags?.provider === "flagship" && flags.mode === "binding" ? flags.bindingName : void 0;
   const capabilityFlags = {};
   for (const flag of CAPABILITY_FLAGS) {
     capabilityFlags[flag] = capabilities[flag];
   }
+  const signals = describeSignals(durableObjects, needsD1, capabilities, containers, workflows, agents);
+  if (flagshipBinding !== void 0) {
+    signals.push(
+      `hint: lunora/flags.ts uses Flagship in binding mode; add a flagship binding ({ binding: "${flagshipBinding}", app_id }) — the app_id can't be auto-provisioned`
+    );
+  }
   return {
+    agents,
     containers,
     durableObjects,
+    flagshipBinding,
     needsD1,
-    signals: describeSignals(durableObjects, needsD1, capabilities, containers, workflows),
+    queues,
+    signals,
+    usesFlags: flags !== void 0,
     workflows,
     ...capabilityFlags
   };

package/dist/packem_shared/jsonc-edit-SbcD7MAe.mjs

@@ -0,0 +1,9 @@
+import { modify, applyEdits } from 'jsonc-parser';
+
+const FORMATTING = { formattingOptions: { insertSpaces: true, tabSize: 4 } };
+const applyModify = (text, path, value) => {
+  const edits = modify(text, [...path], value, FORMATTING);
+  return edits.length > 0 ? applyEdits(text, edits) : text;
+};
+
+export { FORMATTING as F, applyModify as a };

package/dist/packem_shared/parseDevVariable-B0FEvfHC.mjs

@@ -0,0 +1,21 @@
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { parseDevVariableEntries } from './DEV_VARS_EXAMPLE_FILE-dJPNTEnK.mjs';
+
+const parseDevVariable = (contents, key) => {
+  const entry = parseDevVariableEntries(contents).find((candidate) => candidate.key === key);
+  return entry === void 0 || entry.value === "" ? void 0 : entry.value;
+};
+const resolveAdminToken = (root) => {
+  const fromEnv = process.env["LUNORA_ADMIN_TOKEN"];
+  if (typeof fromEnv === "string" && fromEnv !== "") {
+    return fromEnv;
+  }
+  try {
+    return parseDevVariable(readFileSync(join(root, ".dev.vars"), "utf8"), "LUNORA_ADMIN_TOKEN");
+  } catch {
+    return void 0;
+  }
+};
+
+export { parseDevVariable, resolveAdminToken };

package/dist/packem_shared/{reconcileWranglerBindings-DTHmqTbL.mjs → reconcileWranglerBindings-2Cww5VLa.mjs}

@@ -1,9 +1,8 @@
 import { writeFileSync } from 'node:fs';
 import { containerBuildTag } from '@lunora/container';
-import { modify, applyEdits } from 'jsonc-parser';
+import { a as applyModify } from './jsonc-edit-SbcD7MAe.mjs';
 import { findWranglerFile, readWranglerJsonc } from './WRANGLER_FILES-DwSuC-Kn.mjs';
 
-const FORMATTING = { formattingOptions: { insertSpaces: true, tabSize: 4 } };
 const D1_PLACEHOLDER_ID = "<replace-with-d1-create-id>";
 const collectExportGaps = (inferred) => {
   const gaps = [];
@@ -17,13 +16,19 @@ const collectExportGaps = (inferred) => {
       gaps.push({ className: workflow.className, exportName: workflow.exportName, kind: "workflow", module: "workflows" });
     }
   }
+  for (const agent of inferred.agents) {
+    if (!agent.exported) {
+      gaps.push({ className: agent.className, exportName: agent.exportName, kind: "agent", module: "agents" });
+    }
+  }
   return gaps;
 };
 const collectHintBindingWarnings = (inferred, parsed) => {
+  const flagshipBindingMissing = inferred.flagshipBinding !== void 0 && !(parsed?.flagship ?? []).some((entry) => entry.binding === inferred.flagshipBinding);
   const rules = [
     [
       inferred.usesKv && (parsed?.kv_namespaces?.length ?? 0) === 0,
-      "@lunora/kv is used but no kv_namespaces binding exists; add a kv_namespaces entry ({ binding, id }) and pass env.<BINDING> to createKv() — the namespace id can't be auto-provisioned."
+      "@lunora/bindings/kv is used but no kv_namespaces binding exists; add a kv_namespaces entry ({ binding, id }) and pass env.<BINDING> to createKv() — the namespace id can't be auto-provisioned."
     ],
     [
       inferred.usesHyperdrive && (parsed?.hyperdrive?.length ?? 0) === 0,
@@ -31,11 +36,31 @@ const collectHintBindingWarnings = (inferred, parsed) => {
     ],
     [
       inferred.usesPipelines && (parsed?.pipelines?.length ?? 0) === 0,
-      "@lunora/pipelines is used but no pipelines binding exists; run 'wrangler pipelines create <name>' and add a 'pipelines' binding ({ binding, pipeline }) — the pipeline resource can't be auto-provisioned."
+      "ctx.pipelines is used but no pipelines binding exists; run 'wrangler pipelines create <name>' and add a 'pipelines' binding ({ binding, pipeline }) — the pipeline resource can't be auto-provisioned."
+    ],
+    [
+      flagshipBindingMissing,
+      `lunora/flags.ts uses Flagship in binding mode but no flagship binding "${inferred.flagshipBinding ?? ""}" exists; add a flagship entry ({ binding: "${inferred.flagshipBinding ?? ""}", app_id }) — the app_id can't be auto-provisioned.`
     ]
   ];
   return rules.filter(([active]) => active).map(([, warning]) => warning);
 };
+const collectX402Warnings = (inferred) => {
+  const rules = [
+    [
+      inferred.usesX402Charge,
+      "@lunora/x402/charge is used; set the recipient wallet address as a [vars] entry (the var name is your choice) and pass it to the charge config — the x402 facilitator settles USDC to that address."
+    ],
+    [
+      inferred.usesX402Pay,
+      "@lunora/x402/pay is used (ActionCtx-only, spends real funds); add a secrets_store_secrets[] binding holding the agent wallet key (binding name == signer.secretName) and pair the pay rail with a spend policy — ctx.secrets reads a Secrets Store binding, not .dev.vars."
+    ]
+  ];
+  return rules.filter(([active]) => active).map(([, warning]) => warning);
+};
+const unexportedDeclarationWarnings = (kind, module, declarations) => declarations.filter((declaration) => !declaration.exported).map(
+  (declaration) => `${kind} "${declaration.exportName}" is declared but ${declaration.className} is not exported by the worker entry; add \`export * from "./lunora/_generated/${module}"\` so its binding can be provisioned.`
+);
 const collectWarnings = (inferred, parsed) => {
   const exported = new Set(inferred.durableObjects.map((object) => object.className));
   const warnings = [];
@@ -54,20 +79,11 @@ const collectWarnings = (inferred, parsed) => {
   if (inferred.usesScheduler && !exported.has("SchedulerDO")) {
     warnings.push("@lunora/scheduler is used but the worker entry exports no SchedulerDO; export it so the SCHEDULER binding can be provisioned.");
   }
-  for (const container of inferred.containers) {
-    if (!container.exported) {
-      warnings.push(
-        `container "${container.exportName}" is declared but ${container.className} is not exported by the worker entry; add \`export * from "./lunora/_generated/containers"\` so its binding can be provisioned.`
-      );
-    }
-  }
-  for (const workflow of inferred.workflows) {
-    if (!workflow.exported) {
-      warnings.push(
-        `workflow "${workflow.exportName}" is declared but ${workflow.className} is not exported by the worker entry; add \`export * from "./lunora/_generated/workflows"\` so its binding can be provisioned.`
-      );
-    }
-  }
+  warnings.push(
+    ...unexportedDeclarationWarnings("container", "containers", inferred.containers),
+    ...unexportedDeclarationWarnings("workflow", "workflows", inferred.workflows),
+    ...unexportedDeclarationWarnings("agent", "agents", inferred.agents)
+  );
   if (inferred.containers.length > 0 && parsed?.observability?.enabled === false) {
     warnings.push("containers are declared but observability is explicitly disabled in wrangler.jsonc — container logs will not be captured.");
   }
@@ -76,13 +92,9 @@ const collectWarnings = (inferred, parsed) => {
       "@lunora/payment is used; set the provider secrets in .dev.vars — STRIPE_SECRET_KEY + STRIPE_WEBHOOK_SECRET (Stripe) or POLAR_ACCESS_TOKEN + POLAR_WEBHOOK_SECRET (Polar)."
     );
   }
-  warnings.push(...collectHintBindingWarnings(inferred, parsed));
+  warnings.push(...collectX402Warnings(inferred), ...collectHintBindingWarnings(inferred, parsed));
   return warnings;
 };
-const applyModify = (text, path, value) => {
-  const edits = modify(text, [...path], value, FORMATTING);
-  return edits.length > 0 ? applyEdits(text, edits) : text;
-};
 const nextMigrationTag = (migrations) => {
   const used = new Set(migrations.map((migration) => migration.tag));
   let index = 1;
@@ -212,15 +224,77 @@ const reconcileObservability = (text, parsed) => {
 const workflowEntryFor = (workflow) => {
   return { binding: workflow.bindingName, class_name: workflow.className, name: workflow.name };
 };
-const reconcileWorkflows = (text, parsed, workflows) => {
+const agentEntryFor = (agent) => {
+  return { binding: agent.bindingName, class_name: agent.className, name: agent.name };
+};
+const reconcileWorkflows = (text, parsed, workflows, agents = []) => {
   const existing = parsed.workflows ?? [];
   const existingClasses = new Set(existing.map((entry) => entry.class_name));
-  const missing = workflows.filter((workflow) => !existingClasses.has(workflow.className));
-  if (missing.length === 0) {
+  const missingWorkflows = workflows.filter((workflow) => !existingClasses.has(workflow.className));
+  const missingAgents = agents.filter((agent) => !existingClasses.has(agent.className));
+  if (missingWorkflows.length === 0 && missingAgents.length === 0) {
+    return { added: [], text };
+  }
+  const nextText = applyModify(
+    text,
+    ["workflows"],
+    [...existing, ...missingWorkflows.map((workflow) => workflowEntryFor(workflow)), ...missingAgents.map((agent) => agentEntryFor(agent))]
+  );
+  return {
+    added: [...missingWorkflows.map((workflow) => `workflows/${workflow.className}`), ...missingAgents.map((agent) => `workflows/${agent.className}`)],
+    text: nextText
+  };
+};
+const reconcileQueues = (text, parsed, queues) => {
+  const existing = parsed.queues ?? {};
+  const existingProducers = existing.producers ?? [];
+  const existingConsumers = existing.consumers ?? [];
+  const haveProducer = new Set(existingProducers.map((entry) => entry.binding));
+  const haveConsumer = new Set(existingConsumers.map((entry) => entry.queue));
+  const missingProducers = queues.filter((queue) => !haveProducer.has(queue.bindingName));
+  const missingConsumers = queues.filter((queue) => !haveConsumer.has(queue.name));
+  if (missingProducers.length === 0 && missingConsumers.length === 0) {
     return { added: [], text };
   }
-  const nextText = applyModify(text, ["workflows"], [...existing, ...missing.map((workflow) => workflowEntryFor(workflow))]);
-  return { added: missing.map((workflow) => `workflows/${workflow.className}`), text: nextText };
+  const nextProducers = [
+    ...existingProducers,
+    ...missingProducers.map((queue) => {
+      return { binding: queue.bindingName, queue: queue.name };
+    })
+  ];
+  const nextConsumers = [
+    ...existingConsumers,
+    ...missingConsumers.map((queue) => {
+      const consumer = { queue: queue.name };
+      if (queue.mode === "pull") {
+        consumer.type = "http_pull";
+      }
+      if (queue.tuning.maxBatchSize !== void 0) {
+        consumer.max_batch_size = queue.tuning.maxBatchSize;
+      }
+      if (queue.tuning.maxBatchTimeout !== void 0) {
+        consumer.max_batch_timeout = queue.tuning.maxBatchTimeout;
+      }
+      if (queue.tuning.maxRetries !== void 0) {
+        consumer.max_retries = queue.tuning.maxRetries;
+      }
+      if (queue.tuning.deadLetterQueue !== void 0) {
+        consumer.dead_letter_queue = queue.tuning.deadLetterQueue;
+      }
+      if (queue.tuning.retryDelay !== void 0) {
+        consumer.retry_delay = queue.tuning.retryDelay;
+      }
+      return consumer;
+    })
+  ];
+  const nextText = applyModify(text, ["queues"], { consumers: nextConsumers, producers: nextProducers });
+  return {
+    added: [
+      ...missingProducers.map((queue) => `queues.producers/${queue.bindingName}`),
+      ...missingConsumers.map((queue) => `queues.consumers/${queue.name}`)
+    ],
+    text: nextText
+  };
 };
 const reconcileWranglerBindings = (projectRoot, inferred) => {
   const wranglerPath = findWranglerFile(projectRoot);
@@ -234,13 +308,20 @@ const reconcileWranglerBindings = (projectRoot, inferred) => {
   }
   const warnings = collectWarnings(inferred, parsed);
   const exportedContainers = inferred.containers.filter((container) => container.exported);
+  const voiceAgents = inferred.agents.filter(
+    (agent) => agent.exported && agent.voice === true && agent.voiceBindingName !== void 0 && agent.voiceClassName !== void 0
+  );
   const requiredDurableObjects = [
     ...inferred.durableObjects,
     ...exportedContainers.map((container) => {
       return { binding: container.bindingName, className: container.className };
+    }),
+    ...voiceAgents.map((agent) => {
+      return { binding: agent.voiceBindingName, className: agent.voiceClassName };
     })
   ];
   const exportedWorkflows = inferred.workflows.filter((workflow) => workflow.exported);
+  const exportedAgents = inferred.agents.filter((agent) => agent.exported);
   const pipeline = [
     { enabled: true, run: (text2) => reconcileDurableObjects(text2, parsed, requiredDurableObjects) },
     { enabled: inferred.needsD1, run: (text2) => reconcileD1(text2, parsed) },
@@ -250,7 +331,11 @@ const reconcileWranglerBindings = (projectRoot, inferred) => {
     { enabled: inferred.usesAnalytics, run: (text2) => reconcileAnalytics(text2, parsed) },
     { enabled: true, run: (text2) => reconcileObservability(text2, parsed) },
     { enabled: exportedContainers.length > 0, run: (text2) => reconcileContainers(text2, parsed, exportedContainers) },
-    { enabled: exportedWorkflows.length > 0, run: (text2) => reconcileWorkflows(text2, parsed, exportedWorkflows) }
+    {
+      enabled: exportedWorkflows.length > 0 || exportedAgents.length > 0,
+      run: (text2) => reconcileWorkflows(text2, parsed, exportedWorkflows, exportedAgents)
+    },
+    { enabled: inferred.queues.length > 0, run: (text2) => reconcileQueues(text2, parsed, inferred.queues) }
   ];
   let text = original;
   const added = [];

package/dist/packem_shared/reconcileWranglerCompatibilityDate-C8c497ag.mjs

@@ -0,0 +1,31 @@
+import { writeFileSync } from 'node:fs';
+import { modify, applyEdits } from 'jsonc-parser';
+import { F as FORMATTING } from './jsonc-edit-SbcD7MAe.mjs';
+import { isCacheEnabled, WORKERS_CACHE_MIN_DATE } from './WORKERS_CACHE_MIN_DATE-CaXbS7CX.mjs';
+import { findWranglerFile, readWranglerJsonc } from './WRANGLER_FILES-DwSuC-Kn.mjs';
+
+const reconcileWranglerCompatibilityDate = (projectRoot) => {
+  const wranglerPath = findWranglerFile(projectRoot);
+  if (!wranglerPath) {
+    return { changed: false, date: void 0, reason: "wrangler.jsonc not found" };
+  }
+  const { parsed, text } = readWranglerJsonc(wranglerPath);
+  if (parsed === void 0) {
+    return { changed: false, date: void 0, reason: `failed to parse ${wranglerPath} as JSONC`, wranglerPath };
+  }
+  const currentDate = parsed.compatibility_date ?? "";
+  if (!isCacheEnabled(parsed)) {
+    return { changed: false, date: currentDate || void 0, reason: "cache not enabled", wranglerPath };
+  }
+  if (currentDate >= WORKERS_CACHE_MIN_DATE) {
+    return { changed: false, date: currentDate, reason: `compatibility_date already >= ${WORKERS_CACHE_MIN_DATE}`, wranglerPath };
+  }
+  const edits = modify(text, ["compatibility_date"], WORKERS_CACHE_MIN_DATE, FORMATTING);
+  if (edits.length === 0) {
+    return { changed: false, date: currentDate || void 0, reason: "no structural edit produced", wranglerPath };
+  }
+  writeFileSync(wranglerPath, applyEdits(text, edits), "utf8");
+  return { changed: true, date: WORKERS_CACHE_MIN_DATE, wranglerPath };
+};
+
+export { reconcileWranglerCompatibilityDate };

package/dist/packem_shared/reconcileWranglerCrons-DvsceVFz.mjs

@@ -0,0 +1,29 @@
+import { writeFileSync } from 'node:fs';
+import { modify, applyEdits } from 'jsonc-parser';
+import { findWranglerFile, readWranglerJsonc } from './WRANGLER_FILES-DwSuC-Kn.mjs';
+
+const sameTriggers = (a, b) => a.length === b.length && a.every((value, index) => value === b[index]);
+const reconcileWranglerCrons = (projectRoot, cronTriggers) => {
+  const wranglerPath = findWranglerFile(projectRoot);
+  if (!wranglerPath) {
+    return { changed: false, reason: "wrangler.jsonc not found" };
+  }
+  const { parsed, text } = readWranglerJsonc(wranglerPath);
+  if (parsed === void 0) {
+    return { changed: false, reason: `failed to parse ${wranglerPath} as JSONC`, wranglerPath };
+  }
+  const existing = Array.isArray(parsed.triggers?.crons) ? parsed.triggers.crons.filter((value) => typeof value === "string") : [];
+  if (sameTriggers(existing, cronTriggers)) {
+    return { changed: false, reason: "triggers.crons already in sync", wranglerPath };
+  }
+  const edits = modify(text, ["triggers", "crons"], [...cronTriggers], {
+    formattingOptions: { insertSpaces: true, tabSize: 4 }
+  });
+  if (edits.length === 0) {
+    return { changed: false, reason: "no structural edit produced", wranglerPath };
+  }
+  writeFileSync(wranglerPath, applyEdits(text, edits), "utf8");
+  return { changed: true, wranglerPath };
+};
+
+export { reconcileWranglerCrons };

package/dist/packem_shared/{serveJsonHandler-B4OLTGLS.mjs → serveJsonHandler-Cl2Wqkv8.mjs}

@@ -57,7 +57,7 @@ const csrfRejectionReason = (request) => {
   }
   return void 0;
 };
-const serveJsonHandler = (request, response, handle, projectRoot) => {
+const serveJsonHandler = (request, response, handle, projectRoot, schemaDirectory) => {
   const run = async () => {
     try {
       const rejection = csrfRejectionReason(request);
@@ -73,7 +73,7 @@ const serveJsonHandler = (request, response, handle, projectRoot) => {
         respondJson(response, 400, { error: "invalid-json", ok: false });
         return;
       }
-      const result = handle({ body: parsed, method: request.method ?? "POST", projectRoot });
+      const result = handle({ body: parsed, method: request.method ?? "POST", projectRoot, schemaDirectory });
       respondJson(response, result.status, result.body);
     } catch (error) {
       respondJson(response, 500, { error: error instanceof Error ? error.message : String(error), ok: false });