@lunora/config 1.0.0-alpha.35 → 1.0.0-alpha.351

package/dist/index.d.ts

@@ -1,76 +1,219 @@
-import { ContainerIR, WorkflowIR, QueueIR } from '@lunora/codegen';
-export type { ContainerIR, WorkflowIR } from '@lunora/codegen';
+import { AgentIR, ContainerIR, WorkflowIR, CodegenResult } from '@lunora/codegen';
+export type { AgentIR, ContainerIR, WorkflowIR } from '@lunora/codegen';
+import { ChildProcess } from 'node:child_process';
+import { a as DiscoveryCache, T as ToolchainCommand, D as DeployDriver, P as ProjectionPurpose } from "./packem_shared/infer-bindings.d-CFxssIAC.js";
+export { C as COMPOSED_WORKER_ENTRY, b as DURABLE_OBJECT_BINDINGS, type c as DeployRequest, type d as DevRequest, type e as DiscoverSchemaInfoResult, type f as DriverToolchain, g as GENERATED_CLASS_MODULES, h as GENERATED_MODULE_DURABLE_OBJECTS, type G as GeneratedClassModule, type i as InferOptions, type j as InferredAgent, type I as InferredBindings, type k as InferredContainer, type l as InferredWorkflow, M as MERGED_DURABLE_OBJECTS_MODULE, type m as ProjectedConfig, type S as SchemaInfo, type n as SecretRequest, type o as TailRequest, p as createDiscoveryCache, q as discoverSchemaInfo, r as inferLunoraBindings, s as isMergedProject, t as isMergedRoleModule, u as secretSourcesFromBindings } from "./packem_shared/infer-bindings.d-CFxssIAC.js";
 import { Writable } from 'node:stream';
-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.js";
+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, r as resolveServerModule, s as scaffoldPolicyFile, w as wireRlsIntoProcedure } from "./packem_shared/policy-scaffold.d-D2H4_G01.js";
+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 container facts, memoised on `cache` when one is given. */
+declare const discoverContainerInfo: (projectRoot: string, schemaDirectory: string, cache?: DiscoveryCache) => 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.
+ *
+ * `lunora rules install` enumerates `@lunora/cli`'s `skills/` directory rather
+ * than reading this list, so a skill missing here still installs — but
+ * `lunora rules check` counts against it, and reported "9/9 skills" with an
+ * empty "Missing:" line for a project holding all 14. The CLI's rules test
+ * pins the two together, since this package cannot see that directory.
+ */
 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>/`. */
+  /** Skill names with no `SKILL.md` under `<root>/.agents/skills/<name>/`. */
   readonly missing: ReadonlyArray<string>;
-  /** Skill names found under `&lt;root>/.agents/skills/&lt;name>/SKILL.md`. */
+  /** Skill names found under `<root>/.agents/skills/<name>/SKILL.md`. */
   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;
+/** Spawns the process — injectable so tests run without the binary. */
+type DevProcessSpawner = (command: string, args: ReadonlyArray<string>, options: {
+  cwd: string;
+  shell: boolean;
+}) => ChildProcess;
+interface DevProcessOptions {
+  args: ReadonlyArray<string>;
+  command: string;
+  cwd: string;
+  /** Names the process in errors, e.g. `wrangler dev`. */
+  label: string;
+  /** The error when `command` is not on PATH, naming the fix. */
+  notFound: string;
+  /** One line of output; the remainder after the last newline is flushed when the stream ends. */
+  onLine: (line: string, stream: "stderr" | "stdout") => void;
+  port: number;
+  readyTimeoutMs: number;
+  /** Windows `.cmd` shims only launch through a shell. */
+  shell?: boolean;
+  /** Aborting it stops the process while it is still starting; the start then rejects. */
+  signal?: AbortSignal;
+  spawn?: DevProcessSpawner;
+}
+interface DevProcess {
+  /** Resolves with the exit code when the process exits without {@link DevProcess.stop} asking it to. */
+  crashed: Promise<number>;
+  /** Terminate it; resolves once it has exited. */
+  stop: () => Promise<void>;
+}
+/** `true` once something accepts a TCP connection on `port`. */
+declare const acceptsConnection: (port: number) => Promise<boolean>;
+/**
+ * Spawn the process and resolve once it accepts connections on `port`; reject,
+ * with the process stopped, when it cannot be spawned, exits first, or misses
+ * the deadline. The caller checks the port is free beforehand: the probe cannot
+ * tell this process from another one already listening there.
+ */
+declare const startDevProcess: (options: DevProcessOptions) => Promise<DevProcess>;
+/**
+ * Where a line came from: `celld` (the app, and the session's own notices) or
+ * `celld:<worker>`, and `stderr` for a session notice that reports a failure.
+ */
+interface CelldLineOrigin {
+  stream: "stderr" | "stdout";
+  tag: string;
+}
+interface CelldDevSessionOptions {
+  /** Prints one non-empty line of the session's output. */
+  log: (line: string, origin: CelldLineOrigin) => void;
+  /** Port the app serves on. */
+  port: number;
+  projectRoot: string;
+  spawn?: DevProcessSpawner;
+}
+interface CelldDevSession {
+  /**
+   * Resolves with an exit code once the app is gone without {@link CelldDevSession.stop}
+   * asking: its `celld dev` crashed, or did not come back after a restart.
+   */
+  exited: Promise<number>;
+  /** Stop watching, cut short a restart in flight, then stop the app. */
+  stop: () => Promise<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;
+ * Start the session: register every service, run the app, then watch the
+ * service folders. Resolves once the app accepts connections; rejects, with
+ * nothing left running, when a service or the app cannot start — including an
+ * app `celld dev` cannot run at all (a Vite virtual `main`).
+ */
+declare const startCelldDevSession: (options: CelldDevSessionOptions) => Promise<CelldDevSession>;
+/**
+ * The environment switch that turns codegen off — the other spelling of
+ * `lunora dev --no-codegen`.
+ *
+ * The flag alone could not reach the Vite flavors: there the codegen watch lives
+ * in `@lunora/vite`, inside the framework dev server the CLI spawns as a separate
+ * process, which re-parses its own argv and never sees it. So the flag travels as
+ * this variable, and both the plugin and the CLI's own watcher read it — one
+ * switch, one meaning, every flavor.
+ *
+ * It is a DEV switch. `vite build` ignores it deliberately: skipping generation
+ * there would also skip the ERROR-level advisory gate that fails the build.
+ *
+ * One-directional, like `LUNORA_REMOTE`: it can turn codegen off, nothing turns
+ * it back on. Settable by hand for a project that runs its framework dev script
+ * directly rather than through `lunora dev`.
+ */
+/** Env var that turns codegen off when it spells `0` / `false`. Unset means on. */
+declare const CODEGEN_ENV = "LUNORA_CODEGEN";
+/**
+ * Whether a {@link CODEGEN_ENV} value spells an explicit "off".
+ *
+ * Takes the VALUE, not the environment, mirroring `isRemoteEnvEnabled` in
+ * `./cloudflare/remote-bindings` — the same package's existing answer to the same
+ * question, with the opposite polarity.
+ */
+declare const isCodegenDisabled: (value: string | undefined) => boolean;
 /** 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>`. */
+  /** Generated Durable Object class name, e.g. `TranscoderContainer`. Wrangler's dev image is `cloudflare-dev/<lowercased>`. */
   className: string;
   /** The `lunora/containers.ts` export name, e.g. `transcoder` — used as the display tag. */
   exportName: string;
@@ -130,25 +273,25 @@ interface DockerLike {
   };
 }
 /**
-* 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.
-*/
+ * 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.
-*/
-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).
-*/
+ * 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" | "vinext";
+/**
+ * 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. */
@@ -157,170 +300,334 @@ 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.
-*/
+ * Whether the project depends on the unscoped `lunorash` umbrella rather than
+ * the granular `@lunora/*` packages.
+ *
+ * Every generator that writes an import INTO the user's project has to ask:
+ * an umbrella-only install — the default for every starter template — never
+ * installs `@lunora/server`, so under pnpm's strict layout a scaffolded
+ * `from "@lunora/server"` is unresolvable and the worker stops bundling.
+ * Codegen answers the same question from its own dependency set
+ * (`dependencies.has("lunorash")`); this is that answer for every consumer
+ * that has only a project root.
+ */
+declare const projectUsesUmbrella: (root: string) => boolean;
+/**
+ * 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;
+/** 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;
+/**
+ * Where `lunora dev` writes the binding manifest by default, relative to the
+ * project root.
+ *
+ * A fixed path so a supervisor can read it without being told one, and next to
+ * the state record because the two are read together: this says what the Worker
+ * needs and where it will serve, `dev.json` says whether it is serving yet.
+ */
+declare const DEV_BINDINGS_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 marking when the server at {@link DevServerState.url} was
+   * first observed accepting requests — absent until then.
+   *
+   * The rest of this record exists as soon as the server is STARTING: `url` is
+   * the origin it intends to serve on and `pid` is a process that exists, both
+   * written before anything is listening. That is enough to find and stop a
+   * server, and not enough for a task runner deciding when to start the next
+   * thing — which is what this field is for. Poll it rather than sleeping.
+   *
+   * Deliberately a claim about `url` and nothing else. `lunora dev` observes it
+   * by probing; `@lunora/vite` observes it from the listen callback, since its
+   * record is only written once Vite has resolved that URL. Both are honest
+   * about the one origin this record advertises — neither says anything about a
+   * sidecar on another port.
+   *
+   * Absent forever is a legitimate outcome: a server that never binds, or one
+   * slower than the probe was willing to wait. Treat missing as "not ready
+   * yet", never as "will never be ready".
+   */
+  readyAt?: string;
+  /** 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 public quick-tunnel URL `lunora dev --tunnel` was assigned, once
+   * cloudflared reports it — absent without `--tunnel`, before the URL
+   * arrives, and after the tunnel closes. Lets a `--background` start and
+   * `lunora dev status` show a URL that otherwise only reaches the log.
+   */
+  tunnelUrl?: string;
+  /** The primary URL serving the worker/app. */
+  url: string;
+}
 /**
-* 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.
-*/
+ * 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.
+ *
+ * Pass `expectedPid` to patch only while the record still belongs to that
+ * process — the counterpart to {@link clearDevServerState}'s guard, and needed
+ * by any patch that can land LATE. A readiness stamp is the case in point: this
+ * process's server can answer after a newer one has replaced the record, and an
+ * unguarded merge would mark that newer server ready on the old one's behalf.
+ */
+declare const updateDevServerState: (projectRoot: string, patch: Partial<DevServerState>, options?: {
+  expectedPid?: number;
+}) => DevServerState | undefined;
+/**
+ * Whether a record reports a server that is accepting requests, as opposed to
+ * one that has merely started. Lives here so the CLI's `status`, its JSON
+ * output, and any future reader cannot each invent their own answer.
+ */
+declare const isDevServerReady: (state: Pick<DevServerState, "readyAt"> | undefined) => boolean;
+/**
+ * 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 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. */
+/**
+ * A bare `KEY` identifier accepted on the **write** path — `lunora env set`,
+ * `env unset`, `env generate`, and {@link upsertDevVariableLine}'s line
+ * targeting. Deliberately stricter than what the reader accepts: dotenv keys
+ * are `[\w.-]+`, but a key we *write* stays a conventional env-var name so it
+ * needs no quoting and round-trips through every consumer. Never use this to
+ * decide whether a line in an existing file counts — that is the reader's job.
+ */
 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.
+ *
+ * Delegates to dotenv's own `parse()` — the literal function `wrangler dev` /
+ * `@cloudflare/vite-plugin` run over this file before handing the variables to
+ * the worker. Using the library rather than a compatible reimplementation is
+ * the point: every line the worker sees, Lunora reads identically, including
+ * `export `-prefixed lines, dotted/dashed keys, `KEY: value` separators,
+ * quote stripping (single/double/backtick), `\n`/`\r` expansion inside double
+ * quotes, `#` comments ending unquoted values, and multi-line quoted values.
+ * Duplicate keys resolve last-wins, at the key's first position — dotenv
+ * returns an object, so a repeated key overwrites in place.
+ *
+ * The canonical read of the whole file: every reader of `.dev.vars` (and of
+ * `.dev.vars.example`) goes through here or through {@link
+ * parseDevVariableLine} below, so the format cannot drift between packages.
+ */
 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;
-}
-/**
-* A queue declared in `lunora/queues.ts`. Unlike workflows, a queue needs no
-* worker-entry class export (its `queue()` handler rides `createWorker`), so
-* there is no `exported` flag — every declared queue is reconcilable into the
-* wrangler `queues.producers[]` / `queues.consumers[]`.
-*/
-type InferredQueue = QueueIR;
-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[];
-  /**
-  * The wrangler `flagship[].binding` name implied by `lunora/flags.ts` when it
-  * uses the Flagship provider in binding mode — `undefined` for HTTP-mode
-  * Flagship, a custom OpenFeature provider, or no flags. The binding needs an
-  * un-mintable `app_id`, so it is reconciled as a hint, not auto-written.
-  */
-  flagshipBinding?: string;
-  /** Schema declares a `.global()` table → needs the `DB` D1 binding. */
-  needsD1: boolean;
-  /** Queues declared in `lunora/queues.ts` → reconciled into `queues.producers[]` / `queues.consumers[]`. */
-  queues: InferredQueue[];
-  /** 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/bindings/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/flags.ts` declares a feature-flag provider (any OpenFeature provider — Flagship or custom). */
-  usesFlags: boolean;
-  /** `@lunora/hyperdrive` is imported (binding needs an un-mintable remote `id`; hint-only). */
-  usesHyperdrive: boolean;
-  /** `@lunora/bindings/images` is imported → self-describing `images` binding (auto-writeable). */
-  usesImages: boolean;
-  /** `@lunora/bindings/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;
-  /** `ctx.pipelines` is used (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;
+ * 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 lines for the key are collapsed down to exactly one. The shared
+ * read path is last-wins — dotenv overwrites the key as it walks the file — so
+ * replacing only the first match would leave a later, untouched duplicate
+ * still winning at read time, i.e. a `set` that silently didn't take effect.
+ */
+declare const upsertDevVariableLine: (content: string, key: string, value: string) => string;
+/**
+ * Surgically remove every `.dev.vars` line defining `key` (and its own line
+ * terminator), preserving all other lines, comments, and blanks verbatim.
+ * Backs `lunora env unset`.
+ */
+declare const removeDevVariableLine: (content: string, key: string) => string;
+/**
+ * Worker env var the dev tooling sets so the Lunora runtime recognises a
+ * development deployment (`@lunora/do`'s `isDevEnvironment`) and therefore
+ * streams every RPC dispatch summary to the terminal, keeps argument/error
+ * detail unredacted, and runs the studio security audit with `dev: true`.
+ */
+declare const DEV_WORKER_ENV_VAR = "WORKER_ENV";
+/** The value that flags a dev deployment. */
+declare const DEV_WORKER_ENV_VALUE = "development";
+/**
+ * Top up `.dev.vars` with the dev-environment flag unless the project already
+ * declares it (in `.dev.vars` itself, or in the wrangler config's `vars`).
+ */
+declare const ensureDevWorkerEnv: (projectRoot: string, info: (message: string) => void) => void;
+/** 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;
+/**
+ * Whether `target`'s driver ships a `toolchain` — i.e. whether any tool can
+ * actually build, serve or deploy it, as opposed to merely generate for it.
+ *
+ * One predicate rather than one per caller: the CLI (`deploy`, `dev`) and the
+ * Vite plugin (`build`, `dev`) must refuse the same set, and a second copy
+ * fails silently — the tool that forgot runs the WRONG pipeline for the target
+ * instead of rejecting it.
+ * @param target A target id already resolved by `resolveTargetOrThrow`. Unknown
+ * ids answer `false` rather than throwing, so this is safe to ask about
+ * arbitrary input.
+ * @returns `true` when the target can be run.
+ */
+declare const isRunnableTarget: (target: string) => boolean;
+/**
+ * The subset of {@link deployTargetIds} that {@link isRunnableTarget} accepts,
+ * in the same (alphabetical) order.
+ * @returns every target id a tool can build, serve or deploy — used to name the
+ * alternatives when one is refused.
+ */
+declare const runnableTargetIds: () => ReadonlyArray<string>;
+/**
+ * Whether `lunora dev` serves `target`'s worker with the host's own dev server
+ * (`DriverToolchain.devServer === "own"`) instead of workerd. The CLI's flavor
+ * choice and the Vite plugin's warning both ask this, so it is answered once.
+ */
+declare const targetRunsOwnDevServer: (target: string) => boolean;
+/** A toolchain command planned against the driver's config projection, with nothing written yet. */
+interface ToolchainInvocation {
+  command: ToolchainCommand;
+  /** Write the projection, if the driver has one. Call only once the command is going to run. */
+  commit: () => void;
+  /** The projection the command reads, and every key it left out — `undefined` when the host reads the project config as-is. */
+  projection: {
+    configPath: string;
+    dropped: ReadonlyArray<string>;
+  } | undefined;
 }
 /**
-* 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[];
+ * Plan a toolchain call in the one safe order: project the config (in memory),
+ * build the argv against the projection's path — which is where a host refuses
+ * an option it cannot honour, so a refusal throws here — and only then offer the
+ * write. A refused command therefore leaves nothing on disk, and `configPath`
+ * is set on every request whose driver projects.
+ */
+declare const planToolchainInvocation: (driver: DeployDriver, projectRoot: string, purpose: ProjectionPurpose, build: (configPath: string | undefined) => ToolchainCommand) => ToolchainInvocation;
 /** 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;
-  /** Cloudflare environment name (`wrangler … --env &lt;env>`), when scoped. */
+  /** Cloudflare environment name (`wrangler … --env <env>`), when scoped. */
   env?: string;
   /** ISO-8601 timestamp recorded when the link was written. */
   linkedAt?: string;
@@ -330,34 +637,112 @@ 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.
-*/
+ * The generated and derived paths a linter or formatter should skip, in
+ * gitignore syntax relative to the project root.
+ *
+ * Committed-on-purpose entries are in here too, deliberately: being tracked by
+ * git says nothing about whether a human should be asked to reformat it.
+ */
+declare const LUNORA_IGNORED_PATHS: ReadonlyArray<string>;
+/** A linter or formatter this module knows how to configure. */
+type LintTool = "biome" | "eslint" | "oxlint" | "prettier";
+/**
+ * What happened to one tool's configuration.
+ *
+ * `"manual"` is not a failure — it means the change is correct but not safe to
+ * make automatically, and {@link LintIgnoreOutcome.snippet} carries what to
+ * paste. `"failed"` IS a failure, but only of this step: the command that
+ * triggered it had already done its real work, so it is reported rather than
+ * thrown.
+ */
+type LintIgnoreStatus = "created" | "failed" | "manual" | "unchanged" | "updated";
+interface LintIgnoreOutcome {
+  /** For `"failed"`: why the writer could not run. The command itself still succeeded. */
+  message?: string;
+  /** Config file that was written, or the one the user must edit for `"manual"`. */
+  path: string;
+  /** For `"manual"`: the exact text to add. */
+  snippet?: string;
+  status: LintIgnoreStatus;
+  tool: LintTool;
+}
+/**
+ * Which linters/formatters this project already uses, by declared dependency or
+ * config file on disk.
+ *
+ * Both signals matter: a dependency without a config is a tool about to be
+ * configured, and a config without a dependency is a tool installed globally or
+ * hoisted from a monorepo root. Missing either one means silently skipping a
+ * tool the project genuinely runs.
+ */
+declare const detectLintTools: (projectRoot: string) => LintTool[];
+/**
+ * Add {@link LUNORA_IGNORED_PATHS} to each tool's configuration.
+ *
+ * Idempotent: every writer appends only what is missing, so re-running after a
+ * `lunora add` neither duplicates entries nor disturbs a project's own rules.
+ * @param projectRoot The project to configure.
+ * @param tools Which tools to configure — normally {@link detectLintTools}'s result, or the user's selection at `init`.
+ * @returns one outcome per tool, in the order given.
+ */
+declare const applyLintIgnores: (projectRoot: string, tools: ReadonlyArray<LintTool>) => LintIgnoreOutcome[];
+/** The painted ` lunora ` badge, prepended to the plugin's branded log lines. */
+declare const LUNORA_TAG: string;
+/** Prefix a message with the Lunora badge (e.g. `lunoraLine("codegen done")`). */
+declare const lunoraLine: (message: string) => string;
+/**
+ * A branded schema-advisory line: the level-coloured badge (`warn`/`error`/`info`)
+ * — same badges the CLI reporter uses, so the dev server reads as one tool — then
+ * the rule name, the detail, and the remediation. Replaces the old dense
+ * `lunora-badge … schema advisory [WARN] …` line with the level-appropriate badge.
+ */
+declare const advisoryLine: (level: "ERROR" | "INFO" | "WARN", name: string, detail: string, remediation: string) => string;
+/** The three channels a bundler plugin reports through; `console` satisfies it, as does Rspack's `Logger`. */
+interface FindingLogger {
+  error: (message: string) => void;
+  warn: (message: string) => void;
+}
+/**
+ * Print every schema advisory and platform-portability diagnostic a codegen run
+ * produced, each on its own level-appropriate channel.
+ *
+ * Codegen returns these without printing — each caller presents them through its
+ * own channel. Both bundler plugins present them identically, so this is that one
+ * presentation: severity → logger method, rendered by {@link advisoryLine}. It
+ * lives here rather than in either plugin because the loops were copied verbatim
+ * between them, and a copy is how `vite build` and `rspack build` start
+ * disagreeing about what a schema problem looks like.
+ *
+ * Reporting only — {@link blockingFindingsMessage} decides what BLOCKS.
+ */
+declare const reportCodegenFindings: (result: Pick<CodegenResult, "advisories" | "platformDiagnostics">, logger: FindingLogger) => void;
+/**
+ * The one aggregated line a bundler plugin fails a production build with, or
+ * `undefined` when nothing is ERROR-level.
+ *
+ * An ERROR advisory says a call throws at runtime; an `error` platform
+ * diagnostic says the emitted surface does not match the declared target. Both
+ * are wrong output, not style, so `vite build` / `rspack build` / `lunora deploy`
+ * all refuse them.
+ *
+ * The filter+dedup+sort behind it stays in `@lunora/codegen` (shared with the CLI
+ * gates); only the wording and the fold of the two categories live here, which is
+ * presentation — and presentation is what this module owns, which is also why
+ * this needs no `tag` parameter: {@link LUNORA_TAG} is right above it.
+ */
+declare const blockingFindingsMessage: (result: Pick<CodegenResult, "advisories" | "platformDiagnostics">) => string | undefined;
 /** 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. */
@@ -372,11 +757,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;
@@ -384,33 +769,83 @@ declare class LunoraReporter {
   setStderr(stderr: NodeJS.WriteStream): void;
   log(meta: unknown): void;
 }
+type PackageManager = "pnpm" | "npm" | "yarn" | "bun";
+/** True when `manager` is on PATH — probed by running `<manager> --version`. Injectable for tests. */
+type PackageManagerProbe = (manager: PackageManager) => boolean;
+/**
+ * The package managers actually installed on this machine, in preference order
+ * ({@link INSTALL_PREFERENCE} — pnpm > bun > yarn > npm). The first entry is the
+ * recommended default for the install prompt; the whole list is what the user
+ * picks from. Empty when none are found.
+ */
+declare const detectInstalledManagers: (probe?: PackageManagerProbe) => PackageManager[];
+/** The argv that installs a project's dependencies with `manager` (`<manager> install`). */
+declare const installArgsFor: (manager: PackageManager) => {
+  args: string[];
+  command: string;
+};
+/**
+ * The argv that adds `packages` as new dependencies with `manager` — the
+ * counterpart to {@link installArgsFor}, which reinstalls what package.json
+ * already declares rather than adding something new to it.
+ *
+ * npm's dev flag is `--save-dev` (its own docs lead with the long form); bun's
+ * is the lowercase `-d` (uppercase `-D` is not one of its recognized flags);
+ * pnpm and yarn both take `-D`.
+ */
+declare const addArgsFor: (manager: PackageManager, packages: ReadonlyArray<string>, options?: {
+  dev?: boolean;
+}) => {
+  args: string[];
+  command: string;
+};
 /**
-* 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).
-*/
+ * Resolve the package manager to drive for the project rooted at (or above)
+ * `startDirectory`. Every step is a real signal — Lunora never blindly assumes a
+ * particular manager, and there is no hardcoded fallback:
+ *
+ * 1. `@visulima/package` — the nearest lock file (`pnpm-lock.yaml`, `yarn.lock`,
+ * `package-lock.json`, `bun.lockb`) or the `packageManager` field of the nearest
+ * `package.json`.
+ * 2. The manager that launched this CLI, read from `npm_config_user_agent` (so
+ * `pnpm dlx lunora …` / `npx lunora …` resolve to the right manager).
+ * 3. The first package manager actually installed on this machine
+ * ({@link detectInstalledManagers}).
+ *
+ * Throws when none of those resolve — i.e. there is no lock file / `packageManager`
+ * field, the CLI wasn't launched by a known manager, and none is on `PATH`.
+ * Surfacing that is better than silently guessing a manager that can't run.
+ */
+declare const detectPackageManager: (startDirectory: string) => PackageManager;
+/** Map a package manager to the argv pair that runs an installed CLI. */
+declare const execArgsFor: (manager: PackageManager, command: string, args: ReadonlyArray<string>) => {
+  args: string[];
+  command: string;
+};
+/**
+ * The argv that runs a driver's {@link ToolchainCommand}: through the package
+ * manager for a project dependency, directly for a binary on `PATH`.
+ */
+declare const toolchainExecArgs: (manager: PackageManager, command: ToolchainCommand) => {
+  args: string[];
+  command: string;
+};
+/**
+ * The argv that runs a project SCRIPT with `manager` — the counterpart to
+ * {@link execArgsFor}, which runs a BINARY.
+ *
+ * All four managers accept `<manager> run <script>`, so this is uniform. It is a
+ * separate function because reaching for `execArgsFor(manager, "run", [script])`
+ * silently produces something else entirely: `pnpm exec run <script>` fails with
+ * `Command "run" not found`, and `npx -- run <script>` resolves the registry
+ * PACKAGE named `run` and executes it.
+ */
+declare const runScriptArgsFor: (manager: PackageManager, script: string) => {
+  args: string[];
+  command: string;
+};
+/** The shell command that runs a project script with `manager` (`pnpm dev`, `npm run dev`, …). */
+declare const runScriptCommand: (manager: PackageManager, script: string) => string;
 /** A single secret variable required by a package. */
 interface SecretEntry {
   /** One sentence describing what this secret is and how to obtain it. */
@@ -420,96 +855,185 @@ 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.
-*/
 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.
-*/
-type RemotePreference = boolean | undefined;
-/** The structural slice of `lunora.json` Lunora reads. */
-interface LunoraProjectConfig {
-  remote?: unknown;
+/**
+ * The two channels this needs from a caller's logger. Deliberately structural
+ * and this small: the CLI's `Logger`, Vite's `server.config.logger` shim, and a
+ * two-line test double all satisfy it without any of them being imported here.
+ */
+interface HookLogger {
+  error: (message: string) => void;
+  info: (message: string) => void;
+}
+/** What a spawner is handed. A superset-accepting spawner (the CLI's) satisfies this. */
+interface HookSpawnDescriptor {
+  args: ReadonlyArray<string>;
+  command: string;
+  cwd?: string;
+  /**
+   * Route the child's stdout to the parent's stderr (fd 2). Set whenever the
+   * caller's own stdout is a machine-readable stream — `--format json`, or
+   * `lunora dev`'s NDJSON — since a `postcodegen` script that prints anything
+   * would otherwise interleave with and corrupt it.
+   */
+  stdoutToStderr?: boolean;
+}
+/** Run a child process and resolve with its exit code. Injectable so tests need no subprocess. */
+type HookSpawner = (descriptor: HookSpawnDescriptor) => Promise<{
+  code: number;
+}>;
+interface PostCodegenHookResult {
+  /**
+   * The hook's failure message, when it ran and did not succeed.
+   *
+   * Already logged by the time a caller sees it — read it only to decide
+   * whether to ABORT, and to carry into a structured result. Logging it again
+   * double-reports.
+   */
+  error?: string;
+  /** True when a `postcodegen` script existed and was invoked. */
+  ran: boolean;
 }
 /**
-* 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.
-*/
+ * Run the project's `postcodegen` script, if it declares one.
+ *
+ * A failure is reported here and returned rather than thrown, so every caller
+ * gets identical reporting and is left with only the decision that actually
+ * differs between them: whether it blocks. `deploy` and `prepare` must abort —
+ * the whole point is not shipping output the project considers unfinished —
+ * while a dev watch loop must not, since the next edit is the chance to fix it.
+ *
+ * Reporting used to be the caller's job, and all three copied the same
+ * `logger.error(result.error)` line. That made "was this surfaced?" a convention
+ * rather than a guarantee, and a fourth caller had no way to know it owed one.
+ * @returns whether the hook ran, and its (already-logged) error message when it failed.
+ */
+declare const runPostCodegenHook: (options: {
+  cwd: string;
+  logger: HookLogger;
+  spawner?: HookSpawner;
+  /** See {@link HookSpawnDescriptor.stdoutToStderr}. */
+  stdoutToStderr?: boolean;
+}) => Promise<PostCodegenHookResult>;
+/**
+ * The parsed `remote` preference from `lunora.config.*`:
+ *
+ * - `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;
+/**
+ * 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.config.*`, 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.config.*`, 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.config.*`.
+ * @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;
+/**
+ * The `package.json` at `root` as a plain object, or `undefined` when it is
+ * missing, unreadable, or not a JSON object. Best-effort on purpose: every
+ * caller reads one fact off it (a script, a key, the dependencies) and falls
+ * back to its default rather than failing over a broken manifest.
+ */
+declare const readProjectManifest: (root: string) => Readonly<Record<string, unknown>> | undefined;
+/**
+ * The manifest's merged `devDependencies` + `dependencies` map — a runtime
+ * dependency wins a name declared in both — or `{}` when it cannot be read.
+ */
+declare const readProjectDependencies: (root: string) => Readonly<Record<string, string>>;
+/** The names {@link readProjectDependencies} reads — empty when the manifest cannot be read. */
+declare const readProjectDependencyNames: (root: string) => ReadonlySet<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> {
@@ -518,272 +1042,87 @@ 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;
+ * The project's Lunora source directory (the plugin's `schemaDir`), read the way
+ * `@lunora/vite` sees it: the `schemaDir` string literal passed to the `lunora()`
+ * call in `vite.config.*`, else `"lunora"`. The CLI commands that scan the
+ * project (`dev`, `deploy`, `doctor`, `env`, `codegen`) resolve it here, so a
+ * project that moved its functions to `backend/` gets its `ctx.*` reads and
+ * schema facts read from `backend/` instead of from a directory that does not
+ * exist.
+ *
+ * Parsed, never evaluated: a CLI command must not run the project's build
+ * config. A computed `schemaDir`, or a plugin reached any other way, is not seen
+ * and falls back to the default — the same answer as before this was read.
+ */
+declare const resolveSchemaDirectory: (projectRoot: string) => string;
 /** 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).
-*/
+ * 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;
 /**
-* 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.
-*/
+ * True for a secret key the registry says Lunora can mint locally (a random
+ * 32-byte hex, like `openssl rand -hex 32`) — `AUTH_SECRET`,
+ * `LUNORA_ADMIN_TOKEN`, `STORAGE_SIGNING_SECRET`, …
+ *
+ * Registry membership, NOT the key's name shape, is the rule. A secret-looking
+ * key nothing in the registry declares (`OPENAI_API_KEY`,
+ * `GITHUB_CLIENT_SECRET`, a project's own `*_TOKEN`) is provider-issued as far
+ * as Lunora knows, so minting for it would write a value the provider rejects at
+ * runtime — over the developer's own half-filled `.dev.vars` — and hide the gap
+ * from `lunora env doctor`, whose job is to report it as unfilled.
+ */
 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).
-*/
+ * 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[];
@@ -796,7 +1135,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 {
@@ -808,22 +1148,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). */
@@ -842,41 +1183,51 @@ 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, owner-only. For a file
+ * holding secrets a torn write 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).
+ * 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.
+ */
+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). */
@@ -887,19 +1238,21 @@ interface DevSecretsFillPlan {
   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.
-*/
+ * Plan the in-place generation of dev secrets for a `.dev.vars`. First, every
+ * line whose key is {@link isMintableSecretKey mintable} — registry membership,
+ * NOT the key's name shape — 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. A provider-issued key (`OPENAI_API_KEY`,
+ * `STRIPE_SECRET_KEY`) is left verbatim so `lunora env doctor` can still report
+ * it as unfilled. 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;
@@ -913,25 +1266,38 @@ interface FillDevSecretsResult {
   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.
-*/
+ * 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. Two writers, on purpose: when
+ * the file does not exist yet, the create goes through {@link createExclusively}
+ * and loses to a peer that creates it first; when it exists, the fill rewrites
+ * it through {@link atomicWrite} (temp + rename, owner-only) with the keys it
+ * just read and planned against.
+ */
 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;
 }
@@ -941,11 +1307,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. */
@@ -959,9 +1325,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";
@@ -972,9 +1338,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";
@@ -987,10 +1353,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 {
@@ -1029,40 +1395,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 `<Text>` props.
+ */
 interface BadgeSpec {
   bg: `#${string}`;
   fg: `#${string}`;
@@ -1078,24 +1419,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;
@@ -1109,214 +1450,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;
-}
-/** A wrangler `queues.producers[]` entry — a `Queue` binding sending to `queue`. */
-interface WranglerQueueProducer {
-  binding?: string;
-  delivery_delay?: number;
-  queue?: string;
-}
-/** A wrangler `queues.consumers[]` entry — push (worker) or `type: "http_pull"`. */
-interface WranglerQueueConsumer {
-  dead_letter_queue?: string;
-  max_batch_size?: number;
-  max_batch_timeout?: number;
-  max_retries?: number;
-  queue?: string;
-  retry_delay?: number;
-  type?: 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>;
-  };
-  flagship?: ReadonlyArray<{
-    app_id?: string;
-    binding?: string;
-  } | null | undefined>;
-  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;
-  };
-  queues?: {
-    consumers?: ReadonlyArray<WranglerQueueConsumer | null | undefined>;
-    producers?: ReadonlyArray<WranglerQueueProducer | null | undefined>;
-  };
-  r2_buckets?: ReadonlyArray<{
-    binding?: string;
-  }>;
-  secrets_store_secrets?: ReadonlyArray<{
-    binding?: string;
-    secret_name?: string;
-    store_id?: string;
-  } | null | undefined>;
-  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, type ContainerLogLevel, type ContainerLogLine, type ContainerLogSource, type ContainerLogStreamHandle, type ContainerLogStreamOptions, DEV_VARS_EXAMPLE_FILE, DEV_VARS_FILE, DEV_VARS_KEY_PATTERN, type DestructiveEdit, type DetectedFramework, type DevSecretsFillPlan, type DiscoverContainerInfoResult, type DiscoverSchemaInfoResult, type DiscoverWorkflowInfoResult, type DockerLike, type EnsureDevVariablesDeps, type EnsureDevVariablesResult, type EnsureDevVariablesStatus, type ExportGap, type FillDevSecretsResult, 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, fillDevSecrets, findWranglerFile, formatLunoraEvent, generateSecretValue, inferLunoraBindings, injectRemoteFlags, interpretRemote, isInteractive, isMintableSecretKey, isPlaceholderValue, isRemoteEnvEnabled, materializeRemoteWranglerConfig, packageNamesFromBindings, padBadge, paintAnswer, paintBadge, parseDevVariableEntries, parseSchema, planDevSecretsFill, planDevVariablesAugment, planDevVariablesScaffold, planRemoteBindings, promptMultiSelect, promptSelect, promptYesNo, readLinkedProject, readProjectRemotePreference, readWranglerJsonc, reconcileWranglerBindings, requiredSecrets, resolveRemoteEnabled, secretsForPackages, streamContainerLogs, 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, CODEGEN_ENV, type CelldDevSession, type CelldDevSessionOptions, type CelldLineOrigin, type ClaimDevServerStateResult, type ContainerLogLevel, type ContainerLogLine, type ContainerLogSource, type ContainerLogStreamHandle, type ContainerLogStreamOptions, DEFAULT_DEPLOY_TARGET, DEV_BINDINGS_FILE, 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, DEV_WORKER_ENV_VALUE, DEV_WORKER_ENV_VAR, type DeployDriver, type DestructiveEdit, type DetectedFramework, type DevProcess, type DevProcessOptions, type DevProcessSpawner, type DevSecretsFillPlan, type DevServerMode, type DevServerState, type DiscoverAgentInfoResult, type DiscoverContainerInfoResult, type DiscoverWorkflowInfoResult, type DiscoveryCache, type DockerLike, type EnsureDevVariablesDeps, type EnsureDevVariablesResult, type EnsureDevVariablesStatus, type FillDevSecretsResult, type FindingLogger, type FrameworkClass, type FrameworkDetection, type HookLogger, type HookSpawnDescriptor, type HookSpawner, LINKED_PROJECT_DIR, LINKED_PROJECT_FILE, LUNA_ART, LUNA_BUNNY, LUNA_NAME, LUNA_SIGNOFF, LUNORA_EVENT_SOURCE, LUNORA_IGNORED_PATHS, LUNORA_SKILL_NAMES, LUNORA_TAG, type LevelBadgeName, type LinkedProject, type LintIgnoreOutcome, type LintIgnoreStatus, type LintTool, type LunoraFormattedLine, type LunoraLineLevel, LunoraReporter, type MultiSelectOption, PACKAGE_SECRETS_REGISTRY, type PackageManager, type PackageManagerProbe, type ParseSchemaResult, type PostCodegenHookResult, type ProjectionPurpose, ROOT_SKILL_NAME, type RemotePreference, STEP_BADGE_NAMES, type ScaffoldPlan, type SchemaColumn, type SchemaEdit, type SchemaIndex, type SchemaTable, type SecretEntry, type SelectOption, type StepBadgeName, type ToolchainCommand, type ToolchainInvocation, acceptsConnection, addArgsFor, advisoryLine, applyAdditiveEdit, applyLintIgnores, badgeLead, badgeWidth, blockingFindingsMessage, buildPackageSecretsBlock, claimAgentRulesHint, claimDevServerState, classifyEdit, clearDevServerState, createConfirm, deployTargetIds, detectAgentRules, detectAiAgent, detectFramework, detectInstalledManagers, detectLintTools, detectPackageManager, discoverAgentInfo, discoverContainerInfo, discoverWorkflowInfo, ensureDevVariables, ensureDevVariablesExample as ensureDevVarsExample, ensureDevWorkerEnv, escapeRegExp, execArgsFor, fillDevSecrets, formatLunoraEvent, generateSecretValue, installArgsFor, interpretRemote, isCodegenDisabled, isDevServerReady, isInteractive, isMintableSecretKey, isPlaceholderValue, isProcessAlive, isRecordedProcessCurrent, isRunnableTarget, lunoraLine, padBadge, paintAnswer, paintBadge, parseDevVariableEntries, parseSchema, planDevSecretsFill, planDevVariablesAugment, planDevVariablesScaffold, planToolchainInvocation, projectUsesUmbrella, promptMultiSelect, promptSelect, promptText, promptYesNo, readDevServerState, readLinkedProject, readLiveDevServerState, readProjectDependencies, readProjectDependencyNames, readProjectManifest, readProjectRemotePreference, readProjectTarget, removeDevVariableLine, reportCodegenFindings, requiredSecrets, resolveDeployDriver, resolveProjectTarget, resolveSchemaDirectory, resolveTargetOrThrow, runPostCodegenHook, runScriptArgsFor, runScriptCommand, runnableTargetIds, secretsForPackages, startCelldDevSession, startDevProcess, streamContainerLogs, targetRunsOwnDevServer, toolchainExecArgs, updateDevServerState, upsertDevVariableLine, writeDevServerState, writeDevVariablesFileAtomically, writeLinkedProject };