@lunora/config 1.0.0-alpha.11 → 1.0.0-alpha.111

package/dist/index.d.mts

@@ -1,42 +1,103 @@
-import { ContainerIR, WorkflowIR } from '@lunora/codegen';
-export type { ContainerIR, WorkflowIR } from '@lunora/codegen';
+import { AgentIR, ContainerIR, WorkflowIR } from '@lunora/codegen';
+export type { AgentIR, ContainerIR, WorkflowIR } from '@lunora/codegen';
+import { Writable } from 'node:stream';
+import { D as DeployDriver } from "./packem_shared/schema-info.d-DS0bUsWE.mjs";
+export { type a as DeployRequest, type b as DevRequest, type c as DiscoverSchemaInfoResult, type d as DriverContext, type e as DriverToolchain, type f as InferOptions, type g as InferredAgent, type I as InferredBindings, type h as InferredContainer, type i as InferredWorkflow, type N as NamedResource, type P as ProvisionResult, type R as ResourceGraph, type S as SchemaInfo, type j as SecretRequest, type k as ShardNamespaceResource, type T as TailRequest, type l as ToolchainCommand, m as discoverSchemaInfo, n as inferLunoraBindings, p as packageNamesFromBindings } from "./packem_shared/schema-info.d-DS0bUsWE.mjs";
 import 'ts-morph';
-export { type A as AdditivePolicyEdit, type D as DestructivePolicyEdit, type P as PolicyEdit, type a as PolicyScaffoldFailureReason, type b as ScaffoldFileResult, type S as ScaffoldPolicyEdit, type c as WireResult, type W as WireRlsEdit, d as classifyPolicyEdit, s as scaffoldPolicyFile, w as wireRlsIntoProcedure } from "./packem_shared/policy-scaffold.d-DCmwn7zQ.mjs";
+export { type A as AdditivePolicyEdit, type D as DestructivePolicyEdit, type P as PolicyEdit, type a as PolicyScaffoldFailureReason, type b as ScaffoldFileResult, type S as ScaffoldPolicyEdit, type c as WireResult, type W as WireRlsEdit, d as classifyPolicyEdit, s as scaffoldPolicyFile, w as wireRlsIntoProcedure } from "./packem_shared/policy-scaffold.d-CFd2FlqG.mjs";
+interface DiscoverAgentInfoResult {
+  /** Discovered agent definitions; `[]` when none are declared or parsing failed. */
+  agents: ReadonlyArray<AgentIR>;
+  /** Parse error message, when `lunora/agents.ts` exists but could not be analyzed. */
+  error?: string;
+}
+/**
+ * Discover the project's `defineAgent` declarations. Returns `{ agents: [] }`
+ * when the project has no `lunora/agents.ts` (not an error), or
+ * `{ agents: [], error }` when the file exists but could not be parsed — callers
+ * decide whether that is a warning (validator) or ignorable (inference).
+ */
+declare const discoverAgentInfo: (projectRoot: string, schemaDirectory: string) => DiscoverAgentInfoResult;
+interface DiscoverContainerInfoResult {
+  /** Discovered container definitions; `[]` when none are declared or parsing failed. */
+  containers: ReadonlyArray<ContainerIR>;
+  /** Parse error message, when `lunora/containers.ts` exists but could not be analyzed. */
+  error?: string;
+}
+/**
+ * Discover the project's `defineContainer` declarations. Returns
+ * `{ containers: [] }` when the project has no `lunora/containers.ts` (not an
+ * error), or `{ containers: [], error }` when the file exists but could not be
+ * parsed — callers decide whether that is a warning (validator) or ignorable
+ * (inference).
+ */
+declare const discoverContainerInfo: (projectRoot: string, schemaDirectory: string) => DiscoverContainerInfoResult;
+interface DiscoverWorkflowInfoResult {
+  /** Parse error message, when `lunora/workflows.ts` exists but could not be analyzed. */
+  error?: string;
+  /** Discovered workflow definitions; `[]` when none are declared or parsing failed. */
+  workflows: ReadonlyArray<WorkflowIR>;
+}
 /**
-* Project-relative directory the Lunora agent skills ("rules") install into.
-* This is the portable [Agent Skills](https://tanstack.com/intent/latest/docs/registry)
-* location — Cursor, Claude Code, and GitHub Copilot all discover skills here.
-*/
+ * Discover the project's `defineWorkflow` declarations. Returns
+ * `{ workflows: [] }` when the project has no `lunora/workflows.ts` (not an
+ * error), or `{ workflows: [], error }` when the file exists but could not be
+ * parsed — callers decide whether that is a warning (validator) or ignorable
+ * (inference).
+ */
+declare const discoverWorkflowInfo: (projectRoot: string, schemaDirectory: string) => DiscoverWorkflowInfoResult;
+/** Minimal env shape — `process.env` structurally, injectable for tests. */
+type EnvLike = Readonly<Record<string, string | undefined>>;
+/** One detected agent: which tool, and which env var gave it away. */
+interface AgentDetection {
+  /** Human-readable agent name, for the "agent detected" log line. */
+  name: string;
+  /** The environment variable that matched. */
+  variable: string;
+}
+/** Env var that forces agent mode on (`1`/`true`) or off (`0`/`false`), overriding detection. */
+declare const AGENT_MODE_ENV = "LUNORA_AGENT_MODE";
+/**
+ * Detect the AI agent driving this process, or `undefined` when none is.
+ * `LUNORA_AGENT_MODE` wins over `@visulima/find-ai-runner`'s marker table in
+ * both directions. Pure — pass a custom `env` in tests.
+ */
+declare const detectAiAgent: (env?: EnvLike) => AgentDetection | undefined;
+/**
+ * Project-relative directory the Lunora agent skills ("rules") install into.
+ * This is the portable [Agent Skills](https://tanstack.com/intent/latest/docs/registry)
+ * location — Cursor, Claude Code, and GitHub Copilot all discover skills here.
+ */
 declare const AGENT_RULES_DIR = ".agents/skills";
 /** Env var the once-per-process-tree hint guard ({@link claimAgentRulesHint}) sets. */
 declare const AGENT_RULES_HINT_ENV = "LUNORA_RULES_HINT_SHOWN";
 /**
-* The Lunora agent skills shipped by `@lunora/cli`. The first entry (`lunora`)
-* is the router skill — its presence is what {@link detectAgentRules} treats as
-* "rules installed", since every other skill is reachable through it.
-*/
+ * The Lunora agent skills shipped by `@lunora/cli`. The first entry (`lunora`)
+ * is the router skill — its presence is what {@link detectAgentRules} treats as
+ * "rules installed", since every other skill is reachable through it.
+ */
 declare const LUNORA_SKILL_NAMES: ReadonlyArray<string>;
 /** The router skill whose presence marks the rule set as installed. */
 declare const ROOT_SKILL_NAME = "lunora";
 /**
-* The single "rules not installed" message shared by every surface (the CLI
-* `lunora dev` summary and the Vite dev plugin), so the wording and the
-* pointer at `lunora rules install` stay identical wherever it appears.
-*/
+ * The single "rules not installed" message shared by every surface (the CLI
+ * `lunora dev` summary and the Vite dev plugin), so the wording and the
+ * pointer at `lunora rules install` stay identical wherever it appears.
+ */
 declare const AGENT_RULES_HINT = "Lunora AI rules not installed — run `lunora rules install` so your coding agent knows how to use Lunora.";
 /**
-* Process-tree guard so the hint is emitted at most once. The first surface to
-* print it sets {@link AGENT_RULES_HINT_ENV} on `process.env`; later surfaces (a
-* Vite dev-server restart, or a child process that inherited the env) read it
-* and stay quiet. Returns `true` the first time, `false` afterwards.
-*/
+ * Process-tree guard so the hint is emitted at most once. The first surface to
+ * print it sets {@link AGENT_RULES_HINT_ENV} on `process.env`; later surfaces (a
+ * Vite dev-server restart, or a child process that inherited the env) read it
+ * and stay quiet. Returns `true` the first time, `false` afterwards.
+ */
 declare const claimAgentRulesHint: () => boolean;
 interface AgentRulesStatus {
   /**
-  * True when the `lunora` router skill is installed. We key on the router
-  * (not "all nine present") so a project that intentionally trims the set
-  * still counts as installed and isn't nagged.
-  */
+   * True when the `lunora` router skill is installed. We key on the router
+   * (not "all nine present") so a project that intentionally trims the set
+   * still counts as installed and isn't nagged.
+   */
   readonly installed: boolean;
   /** Skill names with no `SKILL.md` under `&lt;root>/.agents/skills/&lt;name>/`. */
   readonly missing: ReadonlyArray<string>;
@@ -44,39 +105,96 @@ interface AgentRulesStatus {
   readonly present: ReadonlyArray<string>;
 }
 /**
-* Detect whether the Lunora agent skills are installed in `projectRoot` by
-* checking the skills folder for each `SKILL.md`. Pure filesystem reads, safe to
-* call on every dev-server / CLI startup — the CLI, the Vite plugin, and the
-* studio host all use it to decide whether to surface the "rules not installed"
-* hint.
-*/
+ * Detect whether the Lunora agent skills are installed in `projectRoot` by
+ * checking the skills folder for each `SKILL.md`. Pure filesystem reads, safe to
+ * call on every dev-server / CLI startup — the CLI, the Vite plugin, and the
+ * studio host all use it to decide whether to surface the "rules not installed"
+ * hint.
+ */
 declare const detectAgentRules: (projectRoot: string) => AgentRulesStatus;
-interface DiscoverContainerInfoResult {
-  /** Discovered container definitions; `[]` when none are declared or parsing failed. */
-  containers: ReadonlyArray<ContainerIR>;
-  /** Parse error message, when `lunora/containers.ts` exists but could not be analyzed. */
-  error?: string;
+/** Severity a container output line is surfaced at: `stderr` → `error`, `stdout` → `info`. */
+type ContainerLogLevel = "error" | "info";
+/** One declared container to follow, identified by the names codegen lifts from `defineContainer`. */
+interface ContainerLogSource {
+  /** Generated Durable Object class name, e.g. `TranscoderContainer`. Wrangler's dev image is `cloudflare-dev/&lt;lowercased>`. */
+  className: string;
+  /** The `lunora/containers.ts` export name, e.g. `transcoder` — used as the display tag. */
+  exportName: string;
+}
+/** A single line of container output handed back to the caller. */
+interface ContainerLogLine {
+  /** `"error"` for the container's stderr, `"info"` for its stdout. */
+  level: ContainerLogLevel;
+  /** The container's export name (`transcoder`), for tagging the line. */
+  name: string;
+  /** One output line, with the trailing newline (and any `\r`) stripped. */
+  text: string;
+}
+interface ContainerLogStreamOptions {
+  /** The declared containers to follow. An empty list yields an inert handle. */
+  containers: ReadonlyArray<ContainerLogSource>;
+  /** Injected Docker client — defaults to a real lazily-imported `dockerode` instance. Tests pass a stub. */
+  docker?: DockerLike;
+  /** Called once per container output line. */
+  onLine: (line: ContainerLogLine) => void;
+  /** Called once when the Docker engine can't be reached (re-armed after it recovers). Defaults to silent. */
+  onUnavailable?: (message: string) => void;
+  /** Poll interval override, in ms. */
+  pollIntervalMs?: number;
+}
+/** Handle controlling a running log stream. */
+interface ContainerLogStreamHandle {
+  /** Stop polling and tear down every attached log stream. Idempotent. */
+  close: () => void;
+}
+/** The minimal structural slice of a `dockerode` log stream this module consumes. */
+interface DockerLogStream {
+  destroy: () => void;
+  on: (event: "data" | "end" | "error", listener: (chunk?: Buffer) => void) => void;
+}
+/** The minimal structural slice of a `dockerode` instance this module consumes. */
+interface DockerLike {
+  getContainer: (id: string) => {
+    logs: (options: {
+      follow: true;
+      stderr: true;
+      stdout: true;
+      tail: "all";
+      timestamps: false;
+    }) => Promise<DockerLogStream>;
+  };
+  listContainers: (options: {
+    filters: {
+      status: ["running"];
+    };
+  }) => Promise<{
+    Id: string;
+    Image: string;
+  }[]>;
+  modem: {
+    demuxStream: (stream: DockerLogStream, stdout: Writable, stderr: Writable) => void;
+  };
 }
 /**
-* Discover the project's `defineContainer` declarations. Returns
-* `{ containers: [] }` when the project has no `lunora/containers.ts` (not an
-* error), or `{ containers: [], error }` when the file exists but could not be
-* parsed — callers decide whether that is a warning (validator) or ignorable
-* (inference).
-*/
-declare const discoverContainerInfo: (projectRoot: string, schemaDirectory: string) => DiscoverContainerInfoResult;
+ * Follow the local Docker logs of every declared container, emitting each output
+ * line through `onLine` tagged with its export name. Polls for containers (they
+ * start lazily on first request and may be replaced on restart), attaches once
+ * per container id, and drops streams whose container has gone. Returns
+ * immediately with a `close()` handle; all work happens asynchronously.
+ */
+declare const streamContainerLogs: (options: ContainerLogStreamOptions) => ContainerLogStreamHandle;
 /**
-* The meta-frameworks Lunora can compose with, plus `"none"` for a standalone
-* SPA / SSR-less project (the current default). Mirrors PLAN4 §2.4.
-*/
+ * The meta-frameworks Lunora can compose with, plus `"none"` for a standalone
+ * SPA / SSR-less project (the current default). Mirrors PLAN4 §2.4.
+ */
 type DetectedFramework = "astro" | "none" | "nuxt" | "react-router" | "solid-start" | "sveltekit" | "tanstack-start" | "tanstack-start-solid";
 /**
-* void's class model (PLAN4 §3). Class A is Vite-native and Lunora owns the
-* worker entry (`createWorker({ httpRouter })`). Class B frameworks own their own
-* Cloudflare adapter, so Lunora injects its worker composition into the
-* framework's server entry via hooks (PLAN4 M4). Class C is non-CF / SSR-less —
-* ship the client adapter + a standalone Lunora worker (today's default).
-*/
+ * void's class model (PLAN4 §3). Class A is Vite-native and Lunora owns the
+ * worker entry (`createWorker({ httpRouter })`). Class B frameworks own their own
+ * Cloudflare adapter, so Lunora injects its worker composition into the
+ * framework's server entry via hooks (PLAN4 M4). Class C is non-CF / SSR-less —
+ * ship the client adapter + a standalone Lunora worker (today's default).
+ */
 type FrameworkClass = "A" | "B" | "C";
 interface FrameworkDetection {
   /** void's composition class for the detected framework. */
@@ -85,148 +203,201 @@ interface FrameworkDetection {
   framework: DetectedFramework;
 }
 /**
-* Detect which meta-framework a project uses by inspecting its `package.json`
-* dependencies, and classify it under void's class-A/B/C model (PLAN4 §3).
-*
-* Pure and best-effort: never throws. An unknown / missing / malformed
-* `package.json` yields `{ framework: "none", class: "C" }` so the standalone
-* SPA flow is preserved.
-*/
+ * Read and parse the project `package.json`, returning its merged
+ * `dependencies` + `devDependencies` name set (empty on any failure). Public
+ * so sibling consumers (e.g. the CLI's Vite-project detection) share one
+ * best-effort reader instead of re-parsing `package.json` themselves.
+ */
+declare const readProjectDependencyNames: (root: string) => ReadonlySet<string>;
+/**
+ * Detect which meta-framework a project uses by inspecting its `package.json`
+ * dependencies, and classify it under void's class-A/B/C model (PLAN4 §3).
+ *
+ * Pure and best-effort: never throws. An unknown / missing / malformed
+ * `package.json` yields `{ framework: "none", class: "C" }` so the standalone
+ * SPA flow is preserved.
+ */
 declare const detectFramework: (root: string) => FrameworkDetection;
-/**
-* The `.dev.vars` line grammar — one owner, shared by every reader/writer of the
-* file so the format can't drift between packages. `@lunora/cli`'s `env`
-* command (parse/serialize) and `@lunora/config`'s scaffolder (comment-
-* preserving rewrite) do different *transforms*, but they agree on these
-* primitives: the filename, what a `KEY` looks like, how lines split, and how
-* quotes strip.
-*/
+/** Directory holding per-checkout Lunora state (gitignored by convention). */
+declare const DEV_STATE_DIR = ".lunora";
+/** The dev-server state filename, relative to the project root. */
+declare const DEV_STATE_FILE: string;
+/** Log file a backgrounded dev server's output is captured to, relative to the project root. */
+declare const DEV_LOG_FILE: string;
+/**
+ * Marker env `lunora dev --background` sets on the detached server process
+ * (the daemon `lunora dev` or `vite dev`), so it records itself as
+ * `background: true` — and, for the CLI daemon, never re-detects an agent and
+ * recurses into background mode again.
+ */
+declare const DEV_DAEMON_ENV = "LUNORA_DEV_DAEMON";
+/** Env carrying the capture-log path into the detached server, recorded in the state file. */
+declare const DEV_LOG_FILE_ENV = "LUNORA_DEV_LOG_FILE";
+/**
+ * Env carrying the PID of a parent that holds a *provisional* state record it
+ * expects the child dev server to supersede. The CLI claims `.lunora/dev.json`
+ * with its own PID before spawning the real server (closing the duplicate-start
+ * race for the vite flavor and the wrangler daemon), then hands its PID down
+ * via this variable; the child's claim (see {@link claimDevServerState}'s
+ * `supersedePid`) may replace exactly that record with the authoritative
+ * URL + PID.
+ */
+declare const DEV_HANDOFF_ENV = "LUNORA_DEV_HANDOFF_PID";
+/** How the recorded dev server runs. */
+type DevServerMode = "cli" | "vite";
+/** The state record persisted to `.lunora/dev.json`. */
+interface DevServerState {
+  /** Whether the server was detached into the background (`lunora dev --background`). */
+  background?: boolean;
+  /** Absolute path of the log file capturing the server's output, when captured. */
+  logFile?: string;
+  /** `"cli"` for the `lunora dev` wrangler orchestration, `"vite"` for a Vite dev server. */
+  mode: DevServerMode;
+  /** PID of the process to signal for shutdown (the orchestrating CLI or the Vite process). */
+  pid: number;
+  /** ISO-8601 stamp written at startup, purely informational (drives `status` uptime). */
+  startedAt?: string;
+  /** The embedded studio server's URL, when it runs. */
+  studioUrl?: string;
+  /** The primary URL serving the worker/app. */
+  url: string;
+}
+/**
+ * True when a process with `pid` is currently alive AND signalable by this
+ * user. Signal `0` performs the existence check without delivering anything.
+ *
+ * `EPERM` ("alive but another user's process") deliberately counts as NOT
+ * alive here: every dev server this module tracks was spawned by the current
+ * user, so a PID we cannot signal is by definition a recycled PID — treating
+ * it as running would wedge the lockfile permanently and aim `dev stop`'s
+ * kill escalation at an innocent process.
+ */
+declare const isProcessAlive: (pid: number) => boolean;
+/**
+ * True when the record's PID verifiably still refers to the dev server that
+ * wrote the record — not merely "some process exists with that number".
+ * Guards against PID reuse: a server process necessarily starts BEFORE its
+ * record is written, so a process that started after `startedAt` (+ skew) is
+ * a recycled PID wearing the corpse's number. The start-time check runs only
+ * where the platform exposes it (Linux); elsewhere liveness alone decides.
+ */
+declare const isRecordedProcessCurrent: (state: DevServerState) => boolean;
+/**
+ * Read the state record from `.lunora/dev.json`, or `undefined` when there is
+ * no usable record. Best-effort; performs NO liveness check — use
+ * {@link readLiveDevServerState} for "is a dev server actually running".
+ */
+declare const readDevServerState: (projectRoot: string) => DevServerState | undefined;
+/**
+ * Write the state record to `.lunora/dev.json`, creating the `.lunora/`
+ * directory when absent. Returns the absolute path written, or `undefined`
+ * when the write failed (state is convenience metadata — a read-only checkout
+ * must never crash dev startup).
+ */
+declare const writeDevServerState: (projectRoot: string, state: DevServerState) => string | undefined;
+/**
+ * Merge `patch` into the existing state record, when one exists. Used by the
+ * CLI to stamp `background`/`logFile` onto the record the Vite plugin wrote.
+ * Returns the merged record, or `undefined` when there was nothing to update.
+ */
+declare const updateDevServerState: (projectRoot: string, patch: Partial<DevServerState>) => DevServerState | undefined;
+/**
+ * Remove `.lunora/dev.json`. Idempotent and never throws. When `expectedPid`
+ * is given, the file is only removed while it still records that PID — so a
+ * shutting-down server can't clobber the record a newer server just wrote.
+ */
+declare const clearDevServerState: (projectRoot: string, expectedPid?: number) => void;
+/**
+ * The state record of a dev server that is verifiably running right now, or
+ * `undefined`. A record whose PID is dead — or recycled onto a different
+ * process (see {@link isRecordedProcessCurrent}) — is stale: it is cleared on
+ * the spot so subsequent starts don't keep re-reading a corpse.
+ */
+declare const readLiveDevServerState: (projectRoot: string) => DevServerState | undefined;
+/** Result of {@link claimDevServerState}: claimed, or lost to the live server already recorded. */
+interface ClaimDevServerStateResult {
+  /** The live record that won the race, when `ok` is `false`. */
+  existing?: DevServerState;
+  /** Whether this process now owns the record. */
+  ok: boolean;
+}
+declare const claimDevServerState: (projectRoot: string, state: DevServerState, options?: {
+  supersedePid?: number;
+}) => ClaimDevServerStateResult;
+/**
+ * The `.dev.vars` line grammar — one owner, shared by every reader/writer of the
+ * file so the format can't drift between packages. `@lunora/cli`'s `env`
+ * command (parse/serialize) and `@lunora/config`'s scaffolder (comment-
+ * preserving rewrite) do different *transforms*, but they agree on these
+ * primitives: the filename, what a `KEY` looks like, how lines split, and how
+ * quotes strip.
+ */
 /** The conventional filename for local Cloudflare dev secrets (gitignored). */
 declare const DEV_VARS_FILE: string;
 /** Its committed, secret-free counterpart that scaffolding reads from. */
 declare const DEV_VARS_EXAMPLE_FILE: string;
 /** A bare `KEY` identifier — the part left of `=` in a `.dev.vars` line. */
 declare const DEV_VARS_KEY_PATTERN: RegExp;
-/** Splits file content into lines on either newline style. */
-
-/**
-* Parse `.dev.vars` content into its `{ key, value }` entries, in file order,
-* with values unquoted and comments/blank/invalid lines dropped. The canonical
-* read of the whole file — callers that just want the variables (rather than a
-* comment-preserving rewrite) use this instead of hand-rolling the split loop.
-*/
+/**
+ * Parse `.dev.vars` content into its `{ key, value }` entries, in file order,
+ * with values unquoted and comments/blank/invalid lines dropped. The canonical
+ * read of the whole file — callers that just want the variables (rather than a
+ * comment-preserving rewrite) use this instead of hand-rolling the split loop.
+ */
 declare const parseDevVariableEntries: (content: string) => {
   key: string;
   value: string;
 }[];
-interface DiscoverWorkflowInfoResult {
-  /** Parse error message, when `lunora/workflows.ts` exists but could not be analyzed. */
-  error?: string;
-  /** Discovered workflow definitions; `[]` when none are declared or parsing failed. */
-  workflows: ReadonlyArray<WorkflowIR>;
-}
-/**
-* Discover the project's `defineWorkflow` declarations. Returns
-* `{ workflows: [] }` when the project has no `lunora/workflows.ts` (not an
-* error), or `{ workflows: [], error }` when the file exists but could not be
-* parsed — callers decide whether that is a warning (validator) or ignorable
-* (inference).
-*/
-declare const discoverWorkflowInfo: (projectRoot: string, schemaDirectory: string) => DiscoverWorkflowInfoResult;
-interface DurableObjectSpec {
-  binding: string;
-  className: string;
-}
 /**
-* A `defineContainer` declaration plus whether its generated DO class is
-* exported by the worker entry. Only exported containers are safe to
-* provision — wrangler rejects a `containers[].class_name` (and its Durable
-* Object binding) that the worker doesn't export.
-*/
-interface InferredContainer extends ContainerIR {
-  exported: boolean;
-}
-/**
-* A `defineWorkflow` declaration plus whether its generated
-* `WorkflowEntrypoint` class is exported by the worker entry. Only exported
-* workflows are safe to provision — wrangler rejects a `workflows[].class_name`
-* the worker doesn't export. Workflows are NOT Durable Objects, so this never
-* implies a `durable_objects` binding or migration.
-*/
-interface InferredWorkflow extends WorkflowIR {
-  exported: boolean;
-}
-interface InferredBindings {
-  /** Containers declared in `lunora/containers.ts` (exported or not — see {@link InferredContainer.exported}). */
-  containers: InferredContainer[];
-  /** Durable Objects the worker entry exports → safe to bind. */
-  durableObjects: DurableObjectSpec[];
-  /** Schema declares a `.global()` table → needs the `DB` D1 binding. */
-  needsD1: boolean;
-  /** Human-readable provenance for each inferred binding / hint, for logging. */
-  signals: string[];
-  /** `@lunora/ai` is imported or `env.AI` is used → needs the `ai` Workers AI binding. */
-  usesAi: boolean;
-  /** `@lunora/analytics` is imported → self-describing `analytics_engine_datasets` binding (auto-writeable). */
-  usesAnalytics: boolean;
-  /** `@lunora/auth` is imported (sessions may be D1- or `SessionDO`-backed). */
-  usesAuth: boolean;
-  /** `@lunora/browser` is imported → self-describing `browser` binding (auto-writeable). */
-  usesBrowser: boolean;
-  /** `@lunora/hyperdrive` is imported (binding needs an un-mintable remote `id`; hint-only). */
-  usesHyperdrive: boolean;
-  /** `@lunora/images` is imported → self-describing `images` binding (auto-writeable). */
-  usesImages: boolean;
-  /** `@lunora/kv` is imported (namespace binding name + id are user-defined; hint-only). */
-  usesKv: boolean;
-  /** `@lunora/mail` is imported (Resend API key must be set in `.dev.vars`; no binding). */
-  usesMail: boolean;
-  /** `@lunora/payment` is imported (provider secrets must be set in `.dev.vars`; no binding). */
-  usesPayment: boolean;
-  /** `@lunora/pipelines` is imported (binding needs an un-mintable remote pipeline name; hint-only). */
-  usesPipelines: boolean;
-  /** `@lunora/scheduler` is imported. */
-  usesScheduler: boolean;
-  /** `@lunora/storage` is imported (R2 bucket binding name is user-defined). */
-  usesStorage: boolean;
-  /** Workflows declared in `lunora/workflows.ts` (exported or not — see {@link InferredWorkflow.exported}). */
-  workflows: InferredWorkflow[];
-}
-interface InferOptions {
-  projectRoot: string;
-  /** Directories (relative to root) to scan. Defaults to `lunora` + `src`. */
-  scanDirs?: ReadonlyArray<string>;
-  /** Lunora source directory holding `schema.ts`. Defaults to `lunora`. */
-  schemaDir?: string;
-}
-/**
-* Scan a Lunora project and report which Cloudflare bindings its code implies.
-* Read-only: performs no writes. Binding provisioning is driven by the worker
-* entry's Durable Object exports plus the schema's D1 need; capability imports
-* surface as hints.
-*/
-declare const inferLunoraBindings: (options: InferOptions) => Promise<InferredBindings>;
-/**
-* Derive the list of `@lunora/*` package names that are actively used by a
-* project, based on its already-resolved {@link InferredBindings}.
-*
-* This is the canonical bridge between binding inference and the package-aware
-* `.dev.vars.example` scaffolding in `scaffold-dev-variables.ts`. The result is
-* a stable, predictable slice of {@link CAPABILITY_SOURCES} source values,
-* filtered to the flags that are `true` in `bindings` — in CAPABILITY_SOURCES
-* declaration order.
-*/
-declare const packageNamesFromBindings: (bindings: InferredBindings) => string[];
+ * Escape a runtime string for safe literal interpolation into a `RegExp`
+ * source. The one canonical implementation — `@lunora/config`'s own
+ * `infer-bindings.ts` (type-only-export detection) and `@lunora/cli`'s `env`
+ * command both need this and used to carry their own (functionally
+ * identical) copy; grammar this fundamental gets one owner like everything
+ * else in this module.
+ */
+declare const escapeRegExp: (value: string) => string;
+/**
+ * Surgically upsert a single `KEY="value"` line in raw `.dev.vars` content,
+ * leaving every comment, blank line, and untouched entry verbatim. Rebuilding
+ * the whole file from the parsed entry map (an earlier approach) silently
+ * dropped all `# …` comments and blank lines — including the documentation the
+ * registry installer and scaffolder write — and re-quoted lines the user never
+ * touched. If the key already has a line it is replaced in place; otherwise the
+ * new line is appended with a single trailing newline. Always quotes the value
+ * to preserve a whitespace round-trip; callers (`env set`, `env generate --set`,
+ * `deploy`'s minted-secret disclosure) reject newline/`"`/`\` up front so the
+ * verbatim quote is safe.
+ *
+ * Duplicate `KEY=` lines are collapsed down to exactly one. The shared read
+ * path (`parseDevVariableEntries` above) is last-wins — it keeps overwriting a
+ * Map entry as it walks the file, so with duplicate lines the LAST one wins at
+ * read time. Replacing only the first match (as a plain, non-global
+ * `.replace()` does) left that later, untouched duplicate still winning at read
+ * time — a `set` that silently didn't take effect. The first matching line is
+ * replaced in place (preserving its position in the file); every later
+ * duplicate is dropped entirely (including its own trailing newline).
+ */
+declare const upsertDevVariableLine: (content: string, key: string, value: string) => string;
+/** The default deploy target — today's behavior for every project. */
+declare const DEFAULT_DEPLOY_TARGET = "cloudflare";
+/** The ids a caller may select, for error messages and `--target` help text. */
+declare const deployTargetIds: () => ReadonlyArray<string>;
+/**
+ * Resolve a target name to its driver.
+ * @throws when `target` names no registered driver — never falls back to the default.
+ */
+declare const resolveDeployDriver: (target?: string) => DeployDriver;
 /** Directory holding per-checkout Lunora state (gitignored by convention). */
 declare const LINKED_PROJECT_DIR = ".lunora";
 /** The canonical link filename, relative to the project root. */
 declare const LINKED_PROJECT_FILE: string;
 /**
-* The link record persisted to `.lunora/project.json`. Every field is optional
-* so a partially-populated link (e.g. a worker name with no URL yet) still
-* round-trips. `linkedAt` is an ISO-8601 stamp written at link time, purely
-* informational.
-*/
+ * The link record persisted to `.lunora/project.json`. Every field is optional
+ * so a partially-populated link (e.g. a worker name with no URL yet) still
+ * round-trips. `linkedAt` is an ISO-8601 stamp written at link time, purely
+ * informational.
+ */
 interface LinkedProject {
   /** Cloudflare account id the worker lives under, when known. */
   account?: string;
@@ -240,34 +411,17 @@ interface LinkedProject {
   workerUrl?: string;
 }
 /**
-* Read the link record from `.lunora/project.json`, or `undefined` when there
-* is no usable link. Best-effort: a missing file, parse error, or unexpected
-* shape all collapse to `undefined`.
-*/
+ * Read the link record from `.lunora/project.json`, or `undefined` when there
+ * is no usable link. Best-effort: a missing file, parse error, or unexpected
+ * shape all collapse to `undefined`.
+ */
 declare const readLinkedProject: (projectRoot: string) => LinkedProject | undefined;
 /**
-* Write the link record to `.lunora/project.json`, creating the `.lunora/`
-* directory when absent. Only defined fields are persisted (so an empty value
-* never clobbers a known one). Returns the absolute path written.
-*/
+ * Write the link record to `.lunora/project.json`, creating the `.lunora/`
+ * directory when absent. Only defined fields are persisted (so an empty value
+ * never clobbers a known one). Returns the absolute path written.
+ */
 declare const writeLinkedProject: (projectRoot: string, link: LinkedProject) => string;
-/**
-* Shared formatter for the structured log events the Lunora runtime emits to the
-* worker's `console` during development. Both the CLI `dev` command and the Vite
-* plugin pipe worker output through `formatLunoraEvent` so a developer sees
-* attributed, readable lines instead of raw JSON.
-*
-* The runtime emits two event shapes, each a single `console` line tagged
-* `source: "lunora"` (see `@lunora/do`'s `request-log.ts`): a `type: "log"`
-* event per `ctx.log.*` call, and a `type: "request"` event per RPC dispatch
-* (opt-in for successful calls, always for errors).
-*
-* This module is intentionally dependency-free and colour-free: it returns the
-* severity plus a plain display string, leaving ANSI/level colouring to each
-* caller (the CLI routes through its `pail` logger; the Vite plugin dims inline).
-* Any line that is not a lunora event returns `undefined`, signalling the caller
-* to pass it through unchanged.
-*/
 /** Severity a formatted line should be surfaced at, mapped onto the three logger channels. */
 type LunoraLineLevel = "error" | "info" | "warn";
 /** A formatted lunora event: the channel to surface it on, the display text, and which event produced it. */
@@ -282,11 +436,11 @@ interface LunoraFormattedLine {
 /** Stable `source` tag every lunora console event carries. Mirrors `REQUEST_LOG_EVENT_SOURCE` in `@lunora/do`. */
 declare const LUNORA_EVENT_SOURCE = "lunora";
 /**
-* Parse a single worker-output line and, when it is a lunora structured event,
-* return its severity plus display text. Returns `undefined` for anything else —
-* non-JSON lines, JSON that isn't a lunora event, or an unrecognised event type
-* — so the caller passes the original line through untouched. Pure and total.
-*/
+ * Parse a single worker-output line and, when it is a lunora structured event,
+ * return its severity plus display text. Returns `undefined` for anything else —
+ * non-JSON lines, JSON that isn't a lunora event, or an unrecognised event type
+ * — so the caller passes the original line through untouched. Pure and total.
+ */
 declare const formatLunoraEvent: (line: string) => LunoraFormattedLine | undefined;
 declare class LunoraReporter {
   #private;
@@ -295,32 +449,32 @@ declare class LunoraReporter {
   log(meta: unknown): void;
 }
 /**
-* Per-package secret-requirements registry for `.dev.vars` scaffolding.
-*
-* Each entry maps a `@lunora/*` package name → the secrets it requires at
-* runtime, expressed as `{ key, description, docsUrl }` records. The scaffolder
-* in {@link ./scaffold-dev-variables} reads this registry to emit package-aware
-* `.dev.vars.example` entries (placeholders + inline doc-pointer comments).
-*
-* ## Adding a new add-on
-*
-* When a new `@lunora/*` package requires runtime secrets, add one entry to
-* {@link PACKAGE_SECRETS_REGISTRY} keyed by its exact npm package name. Each
-* `SecretEntry` in the array needs:
-*
-* - `key`         — the env-var name the package reads from `env` (e.g. `RESEND_API_KEY`).
-* - `description` — one line describing the secret and how to obtain it.
-* - `docsUrl`     — a stable URL to the package/provider docs.
-*
-* The registry lives in `@lunora/config` so that add-ons themselves never need
-* to depend on it (no circular coupling). Add-ons document their secrets in
-* their own READMEs; the registry duplicates that knowledge in a machine-readable
-* form that the scaffolder can consume.
-*
-* **Never write a real secret value** in this file — `placeholderValue` entries
-* are the only allowed values (they must pass `isPlaceholderValue` from
-* scaffold-dev-variables).
-*/
+ * Per-package secret-requirements registry for `.dev.vars` scaffolding.
+ *
+ * Each entry maps a `@lunora/*` package name → the secrets it requires at
+ * runtime, expressed as `{ key, description, docsUrl }` records. The scaffolder
+ * in {@link ./scaffold-dev-variables} reads this registry to emit package-aware
+ * `.dev.vars.example` entries (placeholders + inline doc-pointer comments).
+ *
+ * ## Adding a new add-on
+ *
+ * When a new `@lunora/*` package requires runtime secrets, add one entry to
+ * {@link PACKAGE_SECRETS_REGISTRY} keyed by its exact npm package name. Each
+ * `SecretEntry` in the array needs:
+ *
+ * - `key`         — the env-var name the package reads from `env` (e.g. `RESEND_API_KEY`).
+ * - `description` — one line describing the secret and how to obtain it.
+ * - `docsUrl`     — a stable URL to the package/provider docs.
+ *
+ * The registry lives in `@lunora/config` so that add-ons themselves never need
+ * to depend on it (no circular coupling). Add-ons document their secrets in
+ * their own READMEs; the registry duplicates that knowledge in a machine-readable
+ * form that the scaffolder can consume.
+ *
+ * **Never write a real secret value** in this file — `placeholderValue` entries
+ * are the only allowed values (they must pass `isPlaceholderValue` from
+ * scaffold-dev-variables).
+ */
 /** A single secret variable required by a package. */
 interface SecretEntry {
   /** One sentence describing what this secret is and how to obtain it. */
@@ -330,96 +484,128 @@ interface SecretEntry {
   /** The env-var key as it appears in `.dev.vars`, e.g. `AUTH_SECRET`. */
   key: string;
   /**
-  * The placeholder value written into `.dev.vars.example`.
-  * Must pass `isPlaceholderValue` from scaffold-dev-variables so the
-  * scaffolder regenerates it when generating `.dev.vars`. Use angle-bracket
-  * conventions or a recognised marker like `replace-with-openssl-rand-hex-32`.
-  * Non-secret env-vars (e.g. `AUTH_URL`) may carry a real default value.
-  */
+   * The placeholder value written into `.dev.vars.example`.
+   * Must pass `isPlaceholderValue` from scaffold-dev-variables so the
+   * scaffolder regenerates it when generating `.dev.vars`. Use angle-bracket
+   * conventions or a recognised marker like `replace-with-openssl-rand-hex-32`.
+   * Non-secret env-vars (e.g. `AUTH_URL`) may carry a real default value.
+   */
   placeholderValue: string;
 }
 /**
-* Secrets every Lunora project needs regardless of which capability packages are
-* installed — scaffolded into `.dev.vars` always. `LUNORA_ADMIN_TOKEN` is the
-* bearer the local Studio uses to call the worker's admin endpoints (the data
-* browser, schema edits) in dev; the worker reads the SAME `.dev.vars` value via
-* its admin gate, so both agree and the Studio authenticates without a prompt.
-* Without it, every `/_lunora/admin/*` call is `ADMIN_FORBIDDEN` (403).
-*/
-
-/**
-* The canonical registry of per-package secret requirements.
-*
-* Keys are exact npm package names (e.g. `"@lunora/auth"`). Values are
-* non-empty arrays of {@link SecretEntry} — one entry per required secret key.
-*
-* The scaffolder in `scaffold-dev-variables.ts` calls
-* {@link secretsForPackages} to resolve the applicable entries from this map
-* given the set of detected capability package names.
-*/
+ * The canonical registry of per-package secret requirements.
+ *
+ * Keys are exact npm package names (e.g. `"@lunora/auth"`). Values are
+ * non-empty arrays of {@link SecretEntry} — one entry per required secret key.
+ *
+ * The scaffolder in `scaffold-dev-variables.ts` calls
+ * {@link secretsForPackages} to resolve the applicable entries from this map
+ * given the set of detected capability package names.
+ */
 declare const PACKAGE_SECRETS_REGISTRY: Readonly<Record<string, ReadonlyArray<SecretEntry>>>;
 /**
-* Collect all secret entries required by the given set of package names. The
-* order follows the order of `packageNames` (stable, predictable output), and
-* within each package the entries are returned in registry declaration order.
-*
-* Only packages present in {@link PACKAGE_SECRETS_REGISTRY} contribute entries;
-* unknown package names are silently ignored — this makes the call site resilient
-* to future capability flags whose packages have no secrets.
-*/
+ * Collect all secret entries required by the given set of package names. The
+ * order follows the order of `packageNames` (stable, predictable output), and
+ * within each package the entries are returned in registry declaration order.
+ *
+ * Only packages present in {@link PACKAGE_SECRETS_REGISTRY} contribute entries;
+ * unknown package names are silently ignored — this makes the call site resilient
+ * to future capability flags whose packages have no secrets.
+ */
 declare const secretsForPackages: (packageNames: ReadonlyArray<string>) => SecretEntry[];
 /** The canonical project-config filename probed at the project root. */
 declare const LUNORA_CONFIG_FILE = "lunora.json";
 /**
-* The parsed `remote` preference from `lunora.json`:
-*
-* - `true` / `false` — the boolean form: enable or explicitly disable remote dev.
-* - `undefined` — no usable preference (file absent, key absent, or malformed).
-*
-* The object form (scoping which binding kinds go remote) is reserved for a
-* future increment; for now an object value is treated as "enabled" (truthy
-* presence) so forward-written configs still turn remote on.
-*/
+ * The parsed `remote` preference from `lunora.json`:
+ *
+ * - `true` / `false` — the boolean form: enable or explicitly disable remote dev.
+ * - `undefined` — no usable preference (file absent, key absent, or malformed).
+ *
+ * The object form (scoping which binding kinds go remote) is reserved for a
+ * future increment; for now an object value is treated as "enabled" (truthy
+ * presence) so forward-written configs still turn remote on.
+ */
 type RemotePreference = boolean | undefined;
 /** The structural slice of `lunora.json` Lunora reads. */
 interface LunoraProjectConfig {
   remote?: unknown;
+  target?: unknown;
 }
 /**
-* Interpret a raw `remote` value into a tri-state preference. A boolean passes
-* through; an object is treated as enabled (the documented-but-not-yet-honored
-* scoping form is still an opt-in); anything else (string, number, null) is no
-* preference.
-*/
+ * Interpret a raw `remote` value into a tri-state preference. A boolean passes
+ * through; an object is treated as enabled (the documented-but-not-yet-honored
+ * scoping form is still an opt-in); anything else (string, number, null) is no
+ * preference.
+ */
 declare const interpretRemote: (value: unknown) => RemotePreference;
 /**
-* Read the project's `remote` preference from `lunora.json`, or `undefined` when
-* there's no usable preference. Best-effort: never throws — a missing file,
-* parse error, or unexpected shape all collapse to `undefined` so the caller
-* falls through to the env/flag layers.
-*/
+ * Read the project's `remote` preference, or `undefined` when there is no
+ * usable one — the caller then falls through to the env/flag layers.
+ */
 declare const readProjectRemotePreference: (projectRoot: string) => RemotePreference;
 /**
-* Whether we can interactively prompt — stdin must be a TTY. In CI / piped
-* contexts this is false, and callers should fall back to a non-interactive
-* default (skip, or require an explicit `--yes`) rather than hang on a read.
-*/
+ * Read the project's deploy `target` from `lunora.json`, or `undefined` when
+ * absent.
+ *
+ * Delegates to `@lunora/codegen` rather than re-reading the file here.
+ * `runCodegen` has to resolve the same key without this package (config
+ * depends on codegen, not the reverse), so the parser lives there and this is a
+ * re-export — two readers of one key is exactly the kind of copy that drifts.
+ */
+declare const readProjectTarget: (projectRoot: string) => string | undefined;
+/**
+ * Resolve the deploy target for a command: an explicit `--target` wins, then
+ * `lunora.json`, then the registry default.
+ *
+ * **This is the canonical resolution point, and the reason it is one place.**
+ * Codegen tailors the emitted `ctx.*` surface to a target while deploy picks
+ * the driver that ships it. Resolve those separately and they can disagree,
+ * producing an app that builds cleanly and fails at runtime with nothing in the
+ * build to explain it. Every caller — CLI commands, the Vite plugin,
+ * `runCodegen`'s own fallback — resolves through here or through
+ * {@link resolveTargetOrThrow}, so there is exactly one precedence order to
+ * reason about.
+ */
+declare const resolveProjectTarget: (projectRoot: string, explicit?: string) => string;
+/**
+ * Resolve the deploy target as {@link resolveProjectTarget} does, then reject
+ * one that no registered driver serves.
+ *
+ * Lives here rather than in `@lunora/cli` because nothing about it is
+ * CLI-shaped and the Vite plugin needs the same guard — a validator only the
+ * CLI could reach left `vite build` emitting the default surface for a
+ * mis-declared target, silently.
+ *
+ * Callers that go on to resolve a driver get this for free; the ones that never
+ * look a driver up — codegen, the Vite plugin — need it, because otherwise
+ * nothing in their path ever rejects the name.
+ * @param projectRoot Directory containing `lunora.json`.
+ * @param explicit A caller-supplied target, if any.
+ * @throws when the resolved target names no registered driver.
+ * @returns the resolved, registered target id.
+ */
+declare const resolveTargetOrThrow: (projectRoot: string, explicit?: string) => string;
+/**
+ * Whether we can interactively prompt — stdin must be a TTY. In CI / piped
+ * contexts this is false, and callers should fall back to a non-interactive
+ * default (skip, or require an explicit `--yes`) rather than hang on a read.
+ */
 declare const isInteractive: () => boolean;
 /**
-* Ask a yes/no question on stdin. With `defaultYes`, an empty answer (just
-* Enter) counts as yes and the prompt should read `[Y/n]`; otherwise empty is
-* no (`[y/N]`). Shared by the CLI (`reset`, `dev`) and the Vite dev server.
-*/
+ * Ask a yes/no question on stdin. With `defaultYes`, an empty answer (just
+ * Enter) counts as yes and the prompt should read `[Y/n]`; otherwise empty is
+ * no (`[y/N]`). Shared by the CLI (`reset`, `dev`) and the Vite dev server.
+ */
 declare const promptYesNo: (prompt: string, options?: {
   defaultYes?: boolean;
 }) => Promise<boolean>;
 /**
-* Build a default-yes `confirm(message)` for the scaffolders' `ensureDevVariables`:
-* an interactive `[Y/n]` prompt (optionally prefixed, e.g. `"[lunora] "`) when
-* stdin is a TTY, or an immediate `false` otherwise — so CI declines silently
-* instead of blocking. Keeps the "non-interactive ⇒ decline" policy in one place
-* rather than re-stated at every call site.
-*/
+ * Build a default-yes `confirm(message)` for the scaffolders' `ensureDevVariables`:
+ * an interactive `[Y/n]` prompt (optionally prefixed, e.g. `"[lunora] "`) when
+ * stdin is a TTY, or an immediate `false` otherwise — so CI declines silently
+ * instead of blocking. Keeps the "non-interactive ⇒ decline" policy in one place
+ * rather than re-stated at every call site.
+ */
 declare const createConfirm: (prefix?: string) => ((message: string) => Promise<boolean>);
 /** One choice in a {@link promptSelect} list. `value` is returned; `label` (and optional `description`) are shown. */
 interface SelectOption<T extends string> {
@@ -428,261 +614,67 @@ interface SelectOption<T extends string> {
   value: T;
 }
 /**
-* Ask the user to pick one option from a numbered list on stdin. Accepts the
-* 1-based number or the option's `value`/`label` typed verbatim; an empty answer
-* (just Enter) takes `settings.default`. In a non-interactive context (CI /
-* piped — no TTY) it never reads and returns `settings.default` (or `undefined`),
-* mirroring {@link createConfirm}'s "non-interactive ⇒ fall back" policy so
-* automation never blocks.
-*/
+ * Ask the user to pick one option from a numbered list on stdin. Accepts the
+ * 1-based number or the option's `value`/`label` typed verbatim; an empty answer
+ * (just Enter) takes `settings.default`. In a non-interactive context (CI /
+ * piped — no TTY) it never reads and returns `settings.default` (or `undefined`),
+ * mirroring {@link createConfirm}'s "non-interactive ⇒ fall back" policy so
+ * automation never blocks.
+ */
 declare const promptSelect: <T extends string>(message: string, options: ReadonlyArray<SelectOption<T>>, settings?: {
   default?: T;
 }) => Promise<T | undefined>;
+/**
+ * Ask a free-text question on stdin, returning the trimmed answer. An empty
+ * answer (just Enter) takes `settings.default`. In a non-interactive context
+ * (CI / piped — no TTY) it never reads and returns `settings.default` (or
+ * `undefined`), mirroring {@link promptSelect}'s "non-interactive ⇒ fall back"
+ * policy so automation never blocks.
+ */
+declare const promptText: (message: string, settings?: {
+  default?: string;
+}) => Promise<string | undefined>;
 /** One choice in a {@link promptMultiSelect} list. Identical shape to {@link SelectOption}; `value` is returned when picked. */
 type MultiSelectOption<T extends string> = SelectOption<T>;
 /**
-* Ask the user to pick zero or more options from a numbered list on stdin.
-* Accepts a comma- or space-separated list of 1-based numbers and/or option
-* `value`/`label`s typed verbatim; an empty answer (just Enter) takes
-* `settings.defaults`. In a non-interactive context (CI / piped — no TTY) it
-* never reads and returns `settings.defaults ?? []`, mirroring {@link promptSelect}'s
-* "non-interactive ⇒ fall back" policy so automation never blocks. Unknown
-* tokens are ignored; the returned list is de-duplicated and preserves option
-* order.
-*/
+ * Ask the user to pick zero or more options from a numbered list on stdin.
+ * Accepts a comma- or space-separated list of 1-based numbers and/or option
+ * `value`/`label`s typed verbatim; an empty answer (just Enter) takes
+ * `settings.defaults`. In a non-interactive context (CI / piped — no TTY) it
+ * never reads and returns `settings.defaults ?? []`, mirroring {@link promptSelect}'s
+ * "non-interactive ⇒ fall back" policy so automation never blocks. Unknown
+ * tokens are ignored; the returned list is de-duplicated and preserves option
+ * order.
+ */
 declare const promptMultiSelect: <T extends string>(message: string, options: ReadonlyArray<MultiSelectOption<T>>, settings?: {
   defaults?: ReadonlyArray<T>;
 }) => Promise<T[]>;
-/**
-* A container/workflow that is declared (so codegen emits its class) but the
-* worker entry never re-exports — the one wiring step the generators can't always
-* do for the developer. wrangler rejects a `class_name` the deployed worker
-* doesn't export, so a deploy fails late on this; surfacing it as structured data
-* lets the Vite plugin raise it in the dev error overlay (not just the console)
-* the moment the gap appears. The human-readable form is also folded into
-* {@link ReconcileBindingsResult.warnings}.
-*/
-interface ExportGap {
-  /** Generated class wrangler needs exported, e.g. `OrderPipelineWorkflow`. */
-  className: string;
-  /** The `lunora/{containers,workflows}.ts` export name, e.g. `orderPipeline`. */
-  exportName: string;
-  /** Which declaration is unexported. */
-  kind: "container" | "workflow";
-  /** The `_generated/{module}` to re-export from, e.g. `workflows`. */
-  module: "containers" | "workflows";
-}
-interface ReconcileBindingsResult {
-  /** Short labels for each binding written (e.g. `"SCHEDULER/SchedulerDO"`). */
-  added: string[];
-  /** `true` when `wrangler.jsonc` was rewritten. */
-  changed: boolean;
-  /**
-  * Declared containers/workflows the worker entry doesn't re-export — the
-  * structured form of the corresponding `warnings` entries, for the dev error
-  * overlay. Empty when every declaration is wired.
-  */
-  exportGaps: ExportGap[];
-  /** Reason reconciliation was skipped, for logging. */
-  reason?: string;
-  /** Non-fatal hints for capabilities that cannot be auto-provisioned. */
-  warnings: string[];
-  /** Resolved wrangler path, or `undefined` when none was found. */
-  wranglerPath?: string;
-}
-/**
-* Reconcile inferred Durable Object / D1 bindings into `wrangler.jsonc`.
-*
-* Writes only when something is missing; returns `changed: false` when the
-* config already satisfies the inferred needs.
-*/
-declare const reconcileWranglerBindings: (projectRoot: string, inferred: InferredBindings) => ReconcileBindingsResult;
-/**
-* The wrangler config sections Lunora can safely flip to remote mode in dev,
-* each with the human label used in logs and the structural `shape` the entry
-* lives in.
-*
-* `"array"` is a top-level array of binding objects (`d1_databases`,
-* `kv_namespaces`, `r2_buckets`, `vectorize`, `services`). `"producers"` is
-* `queues.producers[]` — consumers are NOT remoted (their schema has no `remote`
-* field) and the edit path is two levels deep. `"object"` is a single binding
-* object, not an array (`ai`), whose edit path targets the section key directly.
-*
-* Every kind here was confirmed against `wrangler/config-schema.json`: the
-* entry's schema declares a `remote` property. Deliberately omits
-* `durable_objects` (no CF remote-DO mode; shards stay local) and sections whose
-* schema has no `remote` field (`hyperdrive`, `analytics_engine_datasets`,
-* `secrets_store_secrets`, queue consumers, …). Widening further is a one-line
-* table edit.
-*/
-declare const REMOTE_ELIGIBLE_KEYS: {
-  readonly ai: {
-    readonly label: "AI";
-    readonly shape: "object";
-  };
-  readonly d1_databases: {
-    readonly label: "D1";
-    readonly shape: "array";
-  };
-  readonly kv_namespaces: {
-    readonly label: "KV";
-    readonly shape: "array";
-  };
-  readonly queues: {
-    readonly label: "Queue";
-    readonly shape: "producers";
-  };
-  readonly r2_buckets: {
-    readonly label: "R2";
-    readonly shape: "array";
-  };
-  readonly services: {
-    readonly label: "Service";
-    readonly shape: "array";
-  };
-  readonly vectorize: {
-    readonly label: "Vectorize";
-    readonly shape: "array";
-  };
-};
-type RemoteEligibleKey = keyof typeof REMOTE_ELIGIBLE_KEYS;
-/** One binding object as it appears in any eligible section. */
-interface BindingEntry {
-  binding?: string;
-  remote?: boolean;
-}
-/** One binding entry we mark remote, with enough provenance to log + edit it. */
-interface RemoteBindingPlan {
-  /** The binding name as declared in the config (e.g. `"DB"`, `"FILES"`). */
-  binding: string;
-  /** Short kind label for logging (`"D1"`, `"KV"`, `"R2"`, `"Vectorize"`, …). */
-  kind: string;
-  /**
-  * The jsonc edit path within {@link RemoteBindingPlan.section}, relative to
-  * the section key: `[index]` for an `"array"` section, `["producers", index]`
-  * for a queue producer, or `[]` for the single-object `ai` section. The
-  * materializer prepends the section key and appends `"remote"`.
-  */
-  path: ReadonlyArray<number | string>;
-  /** The wrangler config key the entry lives under. */
-  section: RemoteEligibleKey;
-}
-/** The structural slice of a wrangler config the remote planner reads. */
-interface RemoteWranglerShape {
-  ai?: BindingEntry | null;
-  d1_databases?: ReadonlyArray<BindingEntry | null | undefined>;
-  kv_namespaces?: ReadonlyArray<BindingEntry | null | undefined>;
-  queues?: {
-    producers?: ReadonlyArray<BindingEntry | null | undefined>;
-  } | null;
-  r2_buckets?: ReadonlyArray<BindingEntry | null | undefined>;
-  services?: ReadonlyArray<BindingEntry | null | undefined>;
-  vectorize?: ReadonlyArray<BindingEntry | null | undefined>;
-}
-/**
-* Inspect a parsed wrangler config and list every eligible binding that should
-* be flipped to remote mode. Pure — no file-system access, no mutation. An
-* entry already carrying `"remote": true` is still reported (so logging is
-* complete) but the materializer's edit is a harmless no-op for it.
-*/
-declare const planRemoteBindings: (parsed: RemoteWranglerShape) => RemoteBindingPlan[];
-/**
-* Inject `"remote": true` onto each planned binding in the config `text`,
-* comment-preservingly via jsonc edits. Pure string→string; the edits target
-* disjoint entries so applying them sequentially is safe. The edit path is
-* `[section, ...plan.path, "remote"]`, which resolves to the array element, the
-* `queues.producers[i]` entry, or the single `ai` object as the plan demands.
-*/
-declare const injectRemoteFlags: (text: string, plans: ReadonlyArray<RemoteBindingPlan>) => string;
-interface MaterializeOptions {
-  /** When `false`, the call is a no-op (returns `enabled: false`). */
-  enabled: boolean;
-  projectRoot: string;
-}
-interface MaterializeResult {
-  /**
-  * Removes the generated temp config file. Always present and always safe to
-  * call: it is idempotent, a no-op when nothing was written (disabled /
-  * fall-through cases), and never throws if the path is already gone. The dev
-  * command calls this on every exit path (normal, signal, error).
-  */
-  cleanup: () => void;
-  /**
-  * Absolute path to the generated temp config to pass to
-  * `wrangler dev --config`. `undefined` when remote mode is disabled, no
-  * wrangler config was found, it failed to parse, or it declared no eligible
-  * binding (nothing to remote — run plain local dev).
-  */
-  configPath?: string;
-  /** Whether remote mode was requested at all. */
-  enabled: boolean;
-  /** Why no temp config was produced, for logging (only set when none was). */
-  reason?: string;
-  /** The bindings flipped to remote, for the dev banner. */
-  remoteBindings: RemoteBindingPlan[];
-}
-/**
-* Produce a temporary wrangler config with `"remote": true` on every eligible
-* binding, so `lunora dev` can run `wrangler dev --config &lt;temp>` against the
-* deployed D1/KV/R2 without touching the user's file.
-*
-* The temp file is written as a sibling of the source `wrangler.jsonc` (in the
-* project root), NOT an OS temp dir: wrangler resolves a config's relative paths
-* (`main`, `assets`, `migrations_dir`, …) against the **config file's own
-* directory**, so a temp config in `/tmp` would make wrangler look for
-* `/tmp/src/server.ts` and fail to start the worker. Keeping it beside the real
-* config preserves those relative paths. Returns `configPath: undefined` (with a
-* `reason`) for every fall-through case so the caller degrades to plain local
-* dev instead of failing.
-*/
-declare const materializeRemoteWranglerConfig: (options: MaterializeOptions) => MaterializeResult;
-/**
-* Parse a `LUNORA_REMOTE` env value into the on/off decision. Truthy when set to
-* `"1"` or `"true"` (case-insensitive); anything else — unset, `"0"`, `"false"`,
-* empty — is off. Mirrors the `"1" | "true"` convention used across the runtime.
-*/
-declare const isRemoteEnvEnabled: (value: string | undefined) => boolean;
-/** The three inputs that can switch remote-binding dev on, in precedence order. */
-interface RemoteEnableInputs {
-  /**
-  * The `remote` preference from `lunora.json` (the lowest-priority signal).
-  * `undefined` means "no project preference"; an explicit `false` here loses
-  * to neither the flag nor the env when those are absent — it just stays off.
-  */
-  configPreference?: boolean;
-  /** The raw `LUNORA_REMOTE` env value (parsed with {@link isRemoteEnvEnabled}). */
-  envValue?: string;
-  /** The explicit `--remote` CLI flag — `true` when passed, `undefined`/`false` otherwise. */
-  flag?: boolean;
-}
-/**
-* Resolve whether remote-binding dev is on, with a clear precedence:
-*
-* 1. an explicit `--remote` flag (highest — a deliberate per-invocation choice),
-* 2. then `LUNORA_REMOTE` in the environment,
-* 3. then the `remote` key in `lunora.json` (lowest — a project default).
-*
-* The flag and env are one-directional (they can only turn remote *on*); only
-* the config preference carries a meaningful `false`, and it applies solely when
-* neither stronger signal is present. So a project that sets `"remote": false`
-* is still overridable per-run by `--remote` or `LUNORA_REMOTE=1`.
-*/
-declare const resolveRemoteEnabled: (inputs: RemoteEnableInputs) => boolean;
-/**
-* Whether an (already-unquoted) value looks like a fill-me-in placeholder —
-* empty, angle-bracketed, or containing a known marker — rather than a real
-* value. Used both when scaffolding (which values to regenerate) and by
-* `lunora env doctor` (which set values are still unfilled).
-*/
+/** Core (always-scaffolded) secrets followed by the package-specific ones for the detected capabilities. */
+declare const requiredSecrets: (packageNames: ReadonlyArray<string>) => SecretEntry[];
+/**
+ * Whether an (already-unquoted) value looks like a fill-me-in placeholder —
+ * empty, angle-bracketed, or containing a known marker — rather than a real
+ * value. Used both when scaffolding (which values to regenerate) and by
+ * `lunora env doctor` (which set values are still unfilled).
+ */
 declare const isPlaceholderValue: (value: string) => boolean;
 /**
-* The outcome of planning a scaffold — a discriminated union so the orchestrator
-* never has to re-derive whether `content` is present.
-*
-* `exists`: `.dev.vars` is already there; nothing to do.
-* `no-example`: nothing to scaffold from (stay silent — the project may not use secrets).
-* `generate`: write `content`, a copy of the example with secret-looking placeholders replaced by fresh random hex (`generatedKeys` lists which).
-*/
+ * True for a secret-looking key whose value Lunora can mint locally (a random
+ * 32-byte hex, like `openssl rand -hex 32`) — e.g. `AUTH_SECRET`,
+ * `LUNORA_ADMIN_TOKEN`, `STORAGE_SIGNING_SECRET`. False for provider-issued keys
+ * ({@link PROVIDER_SECRET_KEYS}) and any non-secret key.
+ */
+declare const isMintableSecretKey: (key: string) => boolean;
+/** Mint a fresh strong secret value — 64 hex chars (32 bytes), like `openssl rand -hex 32`. */
+declare const generateSecretValue: (randomHex?: (bytes: number) => string) => string;
+/**
+ * The outcome of planning a scaffold — a discriminated union so the orchestrator
+ * never has to re-derive whether `content` is present.
+ *
+ * `exists`: `.dev.vars` is already there; nothing to do.
+ * `no-example`: nothing to scaffold from (stay silent — the project may not use secrets).
+ * `generate`: write `content`, a copy of the example with secret-looking placeholders replaced by fresh random hex (`generatedKeys` lists which).
+ */
 type ScaffoldPlan = {
   content: string;
   generatedKeys: string[];
@@ -695,7 +687,8 @@ type ScaffoldPlan = {
 /** Decide whether (and what) to scaffold. Pure — given the current state of the two files. */
 declare const planDevVariablesScaffold: (input: {
   devVarsExists: boolean;
-  exampleContent: string | undefined; /** Injectable for deterministic tests; defaults to `crypto.randomBytes`. */
+  exampleContent: string | undefined;
+  /** Injectable for deterministic tests; defaults to `crypto.randomBytes`. */
   randomHex?: (bytes: number) => string;
 }) => ScaffoldPlan;
 interface AugmentPlan {
@@ -707,22 +700,23 @@ interface AugmentPlan {
   missingKeys: string[];
 }
 /**
-* Plan how to top up an existing `.dev.vars` from the example: every example key
-* not already present becomes an appended line (secret placeholders filled with
-* fresh random hex, other values copied). Pure — no I/O. Empty `missingKeys`
-* means the file is already complete.
-*/
+ * Plan how to top up an existing `.dev.vars` from the example: every example key
+ * not already present becomes an appended line (secret placeholders filled with
+ * fresh random hex, other values copied). Pure — no I/O. Empty `missingKeys`
+ * means the file is already complete.
+ */
 declare const planDevVariablesAugment: (input: {
   exampleContent: string;
-  existingContent: string; /** Injectable for deterministic tests; defaults to `crypto.randomBytes`. */
+  existingContent: string;
+  /** Injectable for deterministic tests; defaults to `crypto.randomBytes`. */
   randomHex?: (bytes: number) => string;
 }) => AugmentPlan;
 interface EnsureDevVariablesDeps {
   /**
-  * Ask the user to confirm generating the file. Return `true` to generate.
-  * Consumers pass a TTY-aware prompt; in non-interactive contexts they should
-  * resolve `false` (we then report `"declined"` and the caller can hint).
-  */
+   * Ask the user to confirm generating the file. Return `true` to generate.
+   * Consumers pass a TTY-aware prompt; in non-interactive contexts they should
+   * resolve `false` (we then report `"declined"` and the caller can hint).
+   */
   confirm: (message: string) => Promise<boolean>;
   cwd: string;
   /** Emit a human-facing line (success / hint). */
@@ -741,44 +735,121 @@ interface EnsureDevVariablesResult {
   status: EnsureDevVariablesStatus;
 }
 /**
-* Reconcile the project's `.dev.vars` with its `.dev.vars.example`:
-*
-* - file missing → offer to generate it (secret placeholders auto-filled);
-* - file present but missing keys the example lists → offer to append them;
-* - file present and complete → nothing to do.
-*
-* Prompts via `confirm` (skipped when `yes`); never overwrites existing values.
-* Returns what happened so the caller can tailor any follow-up. Shared by
-* `lunora dev` and the `@lunora/vite` dev server. All side effects funnel
-* through `confirm`/`info`/`randomHex`.
-*/
+ * Atomically (over)write a `.dev.vars`-shaped file: write the content to a
+ * sibling temp file with owner-only permissions (`mode: 0o600`), then
+ * `rename` it over the target. The rename is atomic within one filesystem,
+ * so a reader can never observe a half-written file, and an interrupt
+ * mid-write can't truncate the target — for a file holding secrets that
+ * would destroy every other local value alongside the new one, and the new
+ * value itself has no other recoverable copy if it was never disclosed
+ * anywhere else (Cloudflare secrets are write-only). On any failure the temp
+ * file is removed before the error propagates; never logs or throws the
+ * content. Exported so a caller writing to a `.dev.vars`-shaped path outside
+ * this module (`lunora deploy`'s minted-secret disclosure) reuses this
+ * instead of hand-rolling another copy of the pattern below.
+ */
+declare const writeDevVariablesFileAtomically: (path: string, content: string) => void;
+/**
+ * Reconcile the project's `.dev.vars` with its `.dev.vars.example`:
+ *
+ * - file missing → offer to generate it (secret placeholders auto-filled);
+ * - file present but missing keys the example lists → offer to append them;
+ * - file present and complete → nothing to do.
+ *
+ * Prompts via `confirm` (skipped when `yes`); never overwrites existing values.
+ * Returns what happened so the caller can tailor any follow-up. Shared by
+ * `lunora dev` and the `@lunora/vite` dev server. All side effects funnel
+ * through `confirm`/`info`/`randomHex`.
+ */
 declare const ensureDevVariables: (deps: EnsureDevVariablesDeps) => Promise<EnsureDevVariablesResult>;
 /**
-* Build the text that should be merged into `.dev.vars.example` for the given
-* set of package names. Only entries whose key is not already present in
-* `existingKeys` are included (additive / idempotent). Returns an empty string
-* when there is nothing to add.
-*
-* The output is grouped by package with a blank-line separator so the file
-* reads cleanly when multiple packages each contribute several keys.
-*
-* **Safety invariant:** this function never writes a real secret — every value
-* in the output is the entry's `placeholderValue`.
-*/
+ * Build the text that should be merged into `.dev.vars.example` for the given
+ * set of package names. Only entries whose key is not already present in
+ * `existingKeys` are included (additive / idempotent). Returns an empty string
+ * when there is nothing to add.
+ *
+ * The output is grouped by package with a blank-line separator so the file
+ * reads cleanly when multiple packages each contribute several keys.
+ *
+ * **Safety invariant:** this function never writes a real secret — every value
+ * in the output is the entry's `placeholderValue`.
+ */
 declare const buildPackageSecretsBlock: (packageNames: ReadonlyArray<string>, existingKeys: ReadonlySet<string>) => string;
 /**
-* Write (or update) `.dev.vars.example` so that it contains the secrets
-* required by `packageNames`. Existing lines are never removed or rewritten;
-* new entries are appended (with a blank-line separator after existing content).
-*
-* Idempotent: re-running with the same `packageNames` does not duplicate keys
-* already in the file. Returns the list of keys that were actually appended.
-*
-* **Safety invariant:** only placeholder values are written — no real secrets.
-*/
+ * Write (or update) `.dev.vars.example` so that it contains the secrets
+ * required by `packageNames`. Existing lines are never removed or rewritten;
+ * new entries are appended (with a blank-line separator after existing content).
+ *
+ * Idempotent: re-running with the same `packageNames` does not duplicate keys
+ * already in the file. Returns the list of keys that were actually appended.
+ *
+ * **Safety invariant:** only placeholder values are written — no real secrets.
+ */
 declare const ensureDevVariablesExample: (cwd: string, packageNames: ReadonlyArray<string>) => string[];
+interface DevSecretsFillPlan {
+  /** {@link CORE_SECRETS} keys appended because they were absent (each generated). */
+  addedKeys: string[];
+  /** The full new file content to write. */
+  content: string;
+  /** Existing empty/placeholder secret-keyed entries filled with fresh values. */
+  filledKeys: string[];
+}
+/**
+ * Plan the in-place generation of dev secrets for a `.dev.vars`. First, every
+ * line whose KEY looks like a secret (`*_SECRET`, `*_TOKEN`, `*_KEY`,
+ * `*_PASSWORD`) and whose value is empty or a placeholder gets a freshly
+ * generated value — so a `lunora add`-scaffolded `.dev.vars` (which writes each
+ * secret blank) becomes usable on `lunora dev` / `vite dev` without the user
+ * running `openssl` by hand. Second, any {@link CORE_SECRETS} key absent from
+ * the file is appended (generated) — notably `LUNORA_ADMIN_TOKEN`, which the
+ * local Studio needs to call the worker's admin gate in dev (without it the
+ * Studio shows its login gate).
+ *
+ * Pure (given `randomHex`): real (non-placeholder) values are never touched, and
+ * comments + non-secret entries are preserved verbatim.
+ */
+declare const planDevSecretsFill: (input: {
+  existingContent: string;
+  randomHex?: (bytes: number) => string;
+}) => DevSecretsFillPlan;
+interface FillDevSecretsResult {
+  /** Core secret keys appended (generated) because they were missing. */
+  addedKeys: string[];
+  /** Existing empty/placeholder secrets filled with generated values. */
+  filledKeys: string[];
+  /** `created` = no `.dev.vars` existed; `filled` = topped up an existing one; `unchanged` = nothing to do. */
+  status: "created" | "filled" | "unchanged";
+}
+/**
+ * Generate any missing/empty dev secrets in the project's `.dev.vars`, in place.
+ *
+ * Complements {@link ensureDevVariables} (which scaffolds `.dev.vars` from
+ * `.dev.vars.example`). A `lunora add`-scaffolded project writes secrets blank
+ * straight into `.dev.vars` (no example) and never includes `LUNORA_ADMIN_TOKEN`
+ * — so the worker boots with empty secrets and the Studio shows its login gate.
+ * This fills those gaps at dev startup, so both `lunora dev` and the
+ * `@lunora/vite` dev server give a working project with zero manual `openssl`.
+ *
+ * Never overwrites a real (non-placeholder) value. The write is atomic + owner-
+ * only (temp + rename, `mode: 0o600`), matching the other `.dev.vars` writers.
+ */
+declare const fillDevSecrets: (deps: {
+  cwd: string;
+  info?: (message: string) => void;
+  randomHex?: (bytes: number) => string;
+}) => FillDevSecretsResult;
+/** Storage backends `.global()` accepts. A closed union, so it is never free text. */
+type GlobalBackend = "d1" | "hyperdrive";
 /** Add a new table to `defineSchema({ ... })`. */
 interface AddTableEdit {
+  /**
+   * Mark the table `.global()`. Pass `{}` for the D1 default, or a backend for
+   * an external store — `lunora introspect` uses `{ backend: "hyperdrive" }`
+   * because the rows live in the database it read.
+   */
+  readonly global?: {
+    readonly backend?: GlobalBackend;
+  };
   readonly kind: "addTable";
   readonly table: string;
 }
@@ -788,11 +859,11 @@ interface AddOptionalColumnEdit {
   readonly kind: "addOptionalColumn";
   readonly table: string;
   /**
-  * Inner validator expression text WITHOUT the `v.optional(...)` wrapper, e.g.
-  * `v.string()`. Always wrapped in `v.optional(...)` on apply, because only
-  * optional columns are additive-safe (a required column needs a backfill
-  * migration).
-  */
+   * Inner validator expression text WITHOUT the `v.optional(...)` wrapper, e.g.
+   * `v.string()`. Always wrapped in `v.optional(...)` on apply, because only
+   * optional columns are additive-safe (a required column needs a backfill
+   * migration).
+   */
   readonly validator: string;
 }
 /** Add a secondary index to an existing table. */
@@ -806,9 +877,9 @@ interface AddIndexEdit {
 /** Additive edits — the only requests {@link applyAdditiveEdit} applies. */
 type AdditiveEdit = AddIndexEdit | AddOptionalColumnEdit | AddTableEdit;
 /**
-* Destructive edits — never applied directly; routed to the migration handoff
-* (plan 024 Item 5). Carried as data so the editor can describe the request.
-*/
+ * Destructive edits — never applied directly; routed to the migration handoff
+ * (plan 024 Item 5). Carried as data so the editor can describe the request.
+ */
 interface DestructiveEdit {
   readonly column?: string;
   readonly kind: "changeColumnType" | "dropColumn" | "dropTable" | "makeRequired" | "renameColumn";
@@ -819,9 +890,9 @@ interface DestructiveEdit {
 /** Any edit the editor can request. */
 type SchemaEdit = AdditiveEdit | DestructiveEdit;
 /**
-* Classify an edit request. Additive edits ({@link AdditiveEdit}) apply
-* directly; everything else changes stored data and is destructive.
-*/
+ * Classify an edit request. Additive edits ({@link AdditiveEdit}) apply
+ * directly; everything else changes stored data and is destructive.
+ */
 declare const classifyEdit: (edit: SchemaEdit) => "additive" | "destructive";
 /** Failure reasons an additive edit can report. */
 type ApplyFailureReason = "aliased-define-schema" | "destructive" | "duplicate-column" | "duplicate-index" | "duplicate-table" | "invalid-identifier" | "invalid-validator" | "no-define-schema" | "non-object-argument" | "unknown-table";
@@ -834,10 +905,10 @@ type ApplyEditResult = {
   text: string;
 };
 /**
-* Apply an **additive** edit to a schema source string, preserving formatting.
-* Destructive edits are refused with `{ ok: false, reason: "destructive" }`;
-* route them through the migration handoff (plan 024 Item 5).
-*/
+ * Apply an **additive** edit to a schema source string, preserving formatting.
+ * Destructive edits are refused with `{ ok: false, reason: "destructive" }`;
+ * route them through the migration handoff (plan 024 Item 5).
+ */
 declare const applyAdditiveEdit: (source: string, edit: SchemaEdit) => ApplyEditResult;
 /** A single declared column: its name and the raw validator expression text. */
 interface SchemaColumn {
@@ -876,40 +947,15 @@ type ParseSchemaResult = {
   tables: ReadonlyArray<SchemaTable>;
 };
 /**
-* Every `CallExpression` at or below a node. `getDescendantsOfKind` excludes the
-* node itself, but a table initializer often is the outermost call in the
-* `defineTable(...).global().index(...)` chain, so include it explicitly.
-*/
-
-/**
-* Parse the tables (with typed columns + indexes) out of a `lunora/schema.ts`
-* source string. Returns a tagged result so callers can render a helpful
-* message per failure mode without throwing.
-*/
+ * Parse the tables (with typed columns + indexes) out of a `lunora/schema.ts`
+ * source string. Returns a tagged result so callers can render a helpful
+ * message per failure mode without throwing.
+ */
 declare const parseSchema: (source: string) => ParseSchemaResult;
-interface SchemaInfo {
-  /** Whether the lunora schema declares any `.global()` table. */
-  hasGlobalTable: boolean;
-  /** Names of vector indexes declared via `.vectorize()` / `defineVectorIndex()`. */
-  vectorIndexNames?: ReadonlyArray<string>;
-}
-interface DiscoverSchemaInfoResult {
-  /** Parse error message, when the schema exists but could not be analyzed. */
-  error?: string;
-  /** Schema facts, or `undefined` when no `schema.ts` exists or parsing failed. */
-  info: SchemaInfo | undefined;
-}
-/**
-* Discover {@link SchemaInfo} for a project. Returns `{ info: undefined }` when
-* the project declares no `schema.ts` (not an error), or `{ info: undefined,
-* error }` when a present schema could not be parsed — callers decide whether a
-* parse failure is a warning (validator) or simply ignorable (inference).
-*/
-declare const discoverSchemaInfo: (projectRoot: string, schemaDirectory: string) => DiscoverSchemaInfoResult;
 /**
-* A badge: the short colored label that prefixes a line. `bg`/`fg` are hex so the
-* same value drives both colorize's `bgHex().hex()` and the tui `&lt;Text>` props.
-*/
+ * A badge: the short colored label that prefixes a line. `bg`/`fg` are hex so the
+ * same value drives both colorize's `bgHex().hex()` and the tui `&lt;Text>` props.
+ */
 interface BadgeSpec {
   bg: `#${string}`;
   fg: `#${string}`;
@@ -925,24 +971,24 @@ type BadgeName = LevelBadgeName | StepBadgeName;
 /** The ordered step-phase names, used to register custom pail log types. */
 declare const STEP_BADGE_NAMES: ReadonlyArray<StepBadgeName>;
 /**
-* Every badge, keyed by name. Levels get their conventional colors (red/amber/
-* green/blue/grey); step phases follow create-astro's green→purple→cyan rhythm.
-*/
+ * Every badge, keyed by name. Levels get their conventional colors (red/amber/
+ * green/blue/grey); step phases follow create-astro's green→purple→cyan rhythm.
+ */
 declare const BADGES: Record<BadgeName, BadgeSpec>;
 /**
-* Luna, the mascot: the folklore rabbit-in-the-moon — a bunny tucked inside the
-* moon disc. Pure ASCII so it renders the same everywhere (including piped logs).
-* The CLI signs off the `init` flow with it, the way create-astro closes with
-* Houston.
-*/
+ * Luna, the mascot: the folklore rabbit-in-the-moon — a bunny tucked inside the
+ * moon disc. Pure ASCII so it renders the same everywhere (including piped logs).
+ * The CLI signs off the `init` flow with it, the way create-astro closes with
+ * Houston.
+ */
 declare const LUNA_NAME = "Luna";
 declare const LUNA_SIGNOFF = "Safe travels, voyager.";
 declare const LUNA_BUNNY: string;
 /**
-* {@link LUNA_BUNNY} with its leading newline stripped, ready to render inline
-* (beside the name + sign-off). Both render paths — the tui mascot frame and the
-* pail off-TTY fallback — use this so neither re-implements the strip.
-*/
+ * {@link LUNA_BUNNY} with its leading newline stripped, ready to render inline
+ * (beside the name + sign-off). Both render paths — the tui mascot frame and the
+ * pail off-TTY fallback — use this so neither re-implements the strip.
+ */
 declare const LUNA_ART: string;
 /** The colored part of a badge — the word with one space of padding each side. */
 declare const padBadge: (text: string) => string;
@@ -956,185 +1002,4 @@ declare const badgeWidth: (_spec: BadgeSpec) => number;
 declare const paintBadge: (spec: BadgeSpec) => string;
 /** Dim continuation text (a step's chosen answer, shown under the question). */
 declare const paintAnswer: (text: string) => string;
-/** Candidate wrangler config filenames, in the order every consumer probes them. */
-declare const WRANGLER_FILES: readonly ["wrangler.jsonc", "wrangler.json"];
-/** Locate the project's wrangler config, or `undefined` when none exists. */
-declare const findWranglerFile: (projectRoot: string) => string | undefined;
-interface ReadWranglerResult<T> {
-  /** Parsed config, or `undefined` when the file was not valid JSONC. */
-  parsed: T | undefined;
-  /** Raw file text — needed for comment-preserving `modify`/`applyEdits`. */
-  text: string;
-}
-/**
-* Read and JSONC-parse a wrangler config file. Returns the raw `text` (for
-* structural edits) alongside `parsed`, which is `undefined` when the file is
-* not valid JSONC or does not parse to an object. Allows trailing commas, as
-* wrangler does.
-*/
-declare const readWranglerJsonc: <T = unknown>(wranglerPath: string) => ReadWranglerResult<T>;
-declare const REQUIRED_COMPATIBILITY_DATE: string;
-declare const REQUIRED_FLAG: string;
-interface WranglerDurableObjectBinding {
-  class_name?: string;
-  name?: string;
-}
-/**
-* A `tail_consumers` entry: a Worker that receives this Worker's tail events
-* (logs, exceptions, fetch metadata) for forwarding to an external sink. See
-* `withTailConsumer` for the wiring helper.
-*/
-interface TailConsumer {
-  /** Optional Cloudflare environment of the consumer Worker. */
-  environment?: string;
-  /** Name of the Worker that consumes tail events. */
-  service?: string;
-}
-/** A wrangler `containers[]` entry (parsed from untrusted JSONC). */
-interface WranglerContainerEntry {
-  class_name?: string;
-  image?: string;
-  instance_type?: string | {
-    disk_mb?: number;
-    memory_mib?: number;
-    vcpu?: number;
-  };
-  max_instances?: number;
-}
-/**
-* A wrangler `workflows[]` entry (parsed from untrusted JSONC). Unlike
-* containers, workflows are NOT Durable Objects — the entry stands alone (no
-* `durable_objects` binding, no migration class).
-*/
-interface WranglerWorkflowEntry {
-  binding?: string;
-  class_name?: string;
-  name?: string;
-}
-interface WranglerConfig {
-  analytics_engine_datasets?: ReadonlyArray<{
-    binding?: string;
-    dataset?: string;
-  } | null | undefined>;
-  assets?: {
-    binding?: string;
-    directory?: string;
-    html_handling?: string;
-    not_found_handling?: string;
-  };
-  browser?: {
-    binding?: string;
-  };
-  compatibility_date?: string;
-  compatibility_flags?: ReadonlyArray<string>;
-  containers?: ReadonlyArray<WranglerContainerEntry | null | undefined>;
-  d1_databases?: ReadonlyArray<{
-    binding?: string;
-  }>;
-  dispatch_namespaces?: ReadonlyArray<{
-    binding?: string;
-    namespace?: string;
-    outbound?: unknown;
-  } | null | undefined>;
-  durable_objects?: {
-    bindings?: ReadonlyArray<WranglerDurableObjectBinding>;
-  };
-  hyperdrive?: ReadonlyArray<{
-    binding?: string;
-    id?: string;
-    localConnectionString?: string;
-  } | null | undefined>;
-  images?: {
-    binding?: string;
-  };
-  kv_namespaces?: ReadonlyArray<{
-    binding?: string;
-    id?: string;
-  } | null | undefined>;
-  logpush?: boolean;
-  migrations?: ReadonlyArray<{
-    new_classes?: ReadonlyArray<string>;
-    new_sqlite_classes?: ReadonlyArray<string>;
-  } | null | undefined>;
-  mtls_certificates?: ReadonlyArray<{
-    binding?: string;
-    certificate_id?: string;
-  } | null | undefined>;
-  observability?: {
-    enabled?: boolean;
-    head_sampling_rate?: number;
-    logs?: {
-      enabled?: boolean;
-      head_sampling_rate?: number;
-    };
-  };
-  pipelines?: ReadonlyArray<{
-    binding?: string;
-    pipeline?: string;
-  } | null | undefined>;
-  placement?: {
-    mode?: string;
-  };
-  r2_buckets?: ReadonlyArray<{
-    binding?: string;
-  }>;
-  send_email?: ReadonlyArray<{
-    allowed_destination_addresses?: ReadonlyArray<string>;
-    destination_address?: string;
-    name?: string;
-  } | null | undefined>;
-  services?: ReadonlyArray<{
-    binding?: string;
-    entrypoint?: string;
-    environment?: string;
-    service?: string;
-  } | null | undefined>;
-  tail_consumers?: ReadonlyArray<TailConsumer | null | undefined>;
-  vars?: Record<string, unknown>;
-  vectorize?: ReadonlyArray<{
-    binding?: string;
-    index_name?: string;
-  } | null | undefined>;
-  workflows?: ReadonlyArray<WranglerWorkflowEntry | null | undefined>;
-}
-interface WranglerValidationReport {
-  errors: string[];
-  valid: boolean;
-  warnings: string[];
-}
-/**
-* Return a new `WranglerConfig` with `consumer` present in `tail_consumers`,
-* wiring this Worker to forward its tail events (logs/exceptions) to another
-* Worker that fans them out to an external sink. Pure and idempotent: an
-* existing entry with the same `service` + `environment` is left untouched
-* rather than duplicated, so it is safe to call on every codegen/deploy.
-*/
-declare const withTailConsumer: (wrangler: WranglerConfig, consumer: TailConsumer) => WranglerConfig;
-/**
-* Pure validator: given a parsed `WranglerConfig` object and an optional
-* `SchemaInfo`, produce a structured report. Performs no I/O.
-*/
-declare const validateWranglerConfig: (wrangler: WranglerConfig | undefined, schema?: SchemaInfo) => WranglerValidationReport;
-/**
-* Convenience alias matching the original task-spec signature
-* `validateWrangler(wranglerJson, schema)` returning
-* `{ valid, errors, warnings }`.
-*/
-declare const validateWrangler: typeof validateWranglerConfig;
-interface WranglerProjectValidationOptions {
-  projectRoot: string;
-  schemaDir?: string;
-}
-interface WranglerProjectValidationResult {
-  problems: ReadonlyArray<string>;
-  report: WranglerValidationReport;
-  wranglerPath: string | undefined;
-}
-/**
-* File-system aware variant: reads `wrangler.jsonc`/`wrangler.json` from
-* the given project root, discovers the schema (if any), and delegates to
-* `validateWranglerConfig`. Returns the legacy
-* `{ problems, wranglerPath }` shape plus the structured `report`.
-*/
-declare const validateWranglerProject: (options: WranglerProjectValidationOptions) => WranglerProjectValidationResult;
-export { ACCENT, AGENT_RULES_DIR, AGENT_RULES_HINT, AGENT_RULES_HINT_ENV, type AddIndexEdit, type AddOptionalColumnEdit, type AddTableEdit, type AdditiveEdit, type AgentRulesStatus, type ApplyEditResult, type ApplyFailureReason, type AugmentPlan, BADGES, BADGE_COLUMN_WIDTH, type BadgeName, type BadgeSpec, DEV_VARS_EXAMPLE_FILE, DEV_VARS_FILE, DEV_VARS_KEY_PATTERN, type DestructiveEdit, type DetectedFramework, type DiscoverContainerInfoResult, type DiscoverSchemaInfoResult, type DiscoverWorkflowInfoResult, type EnsureDevVariablesDeps, type EnsureDevVariablesResult, type EnsureDevVariablesStatus, type ExportGap, type FrameworkClass, type FrameworkDetection, type InferOptions, type InferredBindings, type InferredContainer, type InferredWorkflow, LINKED_PROJECT_DIR, LINKED_PROJECT_FILE, LUNA_ART, LUNA_BUNNY, LUNA_NAME, LUNA_SIGNOFF, LUNORA_CONFIG_FILE, LUNORA_EVENT_SOURCE, LUNORA_SKILL_NAMES, type LevelBadgeName, type LinkedProject, type LunoraFormattedLine, type LunoraLineLevel, type LunoraProjectConfig, LunoraReporter, type MaterializeOptions, type MaterializeResult, type MultiSelectOption, PACKAGE_SECRETS_REGISTRY, type ParseSchemaResult, REMOTE_ELIGIBLE_KEYS, REQUIRED_COMPATIBILITY_DATE, REQUIRED_FLAG, ROOT_SKILL_NAME, type ReadWranglerResult, type ReconcileBindingsResult, type RemoteBindingPlan, type RemoteEnableInputs, type RemotePreference, type RemoteWranglerShape, STEP_BADGE_NAMES, type ScaffoldPlan, type SchemaColumn, type SchemaEdit, type SchemaIndex, type SchemaInfo, type SchemaTable, type SecretEntry, type SelectOption, type StepBadgeName, type TailConsumer, WRANGLER_FILES, type WranglerConfig, type WranglerContainerEntry, type WranglerProjectValidationOptions, type WranglerProjectValidationResult, type WranglerValidationReport, type WranglerWorkflowEntry, applyAdditiveEdit, badgeLead, badgeWidth, buildPackageSecretsBlock, claimAgentRulesHint, classifyEdit, createConfirm, detectAgentRules, detectFramework, discoverContainerInfo, discoverSchemaInfo, discoverWorkflowInfo, ensureDevVariables, ensureDevVariablesExample as ensureDevVarsExample, findWranglerFile, formatLunoraEvent, inferLunoraBindings, injectRemoteFlags, interpretRemote, isInteractive, isPlaceholderValue, isRemoteEnvEnabled, materializeRemoteWranglerConfig, packageNamesFromBindings, padBadge, paintAnswer, paintBadge, parseDevVariableEntries, parseSchema, planDevVariablesAugment, planDevVariablesScaffold, planRemoteBindings, promptMultiSelect, promptSelect, promptYesNo, readLinkedProject, readProjectRemotePreference, readWranglerJsonc, reconcileWranglerBindings, resolveRemoteEnabled, secretsForPackages, validateWrangler, validateWranglerConfig, validateWranglerProject, withTailConsumer, writeLinkedProject };
+export { ACCENT, AGENT_MODE_ENV, AGENT_RULES_DIR, AGENT_RULES_HINT, AGENT_RULES_HINT_ENV, type AddIndexEdit, type AddOptionalColumnEdit, type AddTableEdit, type AdditiveEdit, type AgentDetection, type AgentRulesStatus, type ApplyEditResult, type ApplyFailureReason, type AugmentPlan, BADGES, BADGE_COLUMN_WIDTH, type BadgeName, type BadgeSpec, type ClaimDevServerStateResult, type ContainerLogLevel, type ContainerLogLine, type ContainerLogSource, type ContainerLogStreamHandle, type ContainerLogStreamOptions, DEFAULT_DEPLOY_TARGET, DEV_DAEMON_ENV, DEV_HANDOFF_ENV, DEV_LOG_FILE, DEV_LOG_FILE_ENV, DEV_STATE_DIR, DEV_STATE_FILE, DEV_VARS_EXAMPLE_FILE, DEV_VARS_FILE, DEV_VARS_KEY_PATTERN, type DeployDriver, type DestructiveEdit, type DetectedFramework, type DevSecretsFillPlan, type DevServerMode, type DevServerState, type DiscoverAgentInfoResult, type DiscoverContainerInfoResult, type DiscoverWorkflowInfoResult, type DockerLike, type EnsureDevVariablesDeps, type EnsureDevVariablesResult, type EnsureDevVariablesStatus, type FillDevSecretsResult, type FrameworkClass, type FrameworkDetection, LINKED_PROJECT_DIR, LINKED_PROJECT_FILE, LUNA_ART, LUNA_BUNNY, LUNA_NAME, LUNA_SIGNOFF, LUNORA_CONFIG_FILE, LUNORA_EVENT_SOURCE, LUNORA_SKILL_NAMES, type LevelBadgeName, type LinkedProject, type LunoraFormattedLine, type LunoraLineLevel, type LunoraProjectConfig, LunoraReporter, type MultiSelectOption, PACKAGE_SECRETS_REGISTRY, type ParseSchemaResult, ROOT_SKILL_NAME, type RemotePreference, STEP_BADGE_NAMES, type ScaffoldPlan, type SchemaColumn, type SchemaEdit, type SchemaIndex, type SchemaTable, type SecretEntry, type SelectOption, type StepBadgeName, applyAdditiveEdit, badgeLead, badgeWidth, buildPackageSecretsBlock, claimAgentRulesHint, claimDevServerState, classifyEdit, clearDevServerState, createConfirm, deployTargetIds, detectAgentRules, detectAiAgent, detectFramework, discoverAgentInfo, discoverContainerInfo, discoverWorkflowInfo, ensureDevVariables, ensureDevVariablesExample as ensureDevVarsExample, escapeRegExp, fillDevSecrets, formatLunoraEvent, generateSecretValue, interpretRemote, isInteractive, isMintableSecretKey, isPlaceholderValue, isProcessAlive, isRecordedProcessCurrent, padBadge, paintAnswer, paintBadge, parseDevVariableEntries, parseSchema, planDevSecretsFill, planDevVariablesAugment, planDevVariablesScaffold, promptMultiSelect, promptSelect, promptText, promptYesNo, readDevServerState, readLinkedProject, readLiveDevServerState, readProjectDependencyNames, readProjectRemotePreference, readProjectTarget, requiredSecrets, resolveDeployDriver, resolveProjectTarget, resolveTargetOrThrow, secretsForPackages, streamContainerLogs, updateDevServerState, upsertDevVariableLine, writeDevServerState, writeDevVariablesFileAtomically, writeLinkedProject };