@lunora/config 1.0.0-alpha.6 → 1.0.0-alpha.61

package/dist/index.d.mts

@@ -1,7 +1,25 @@
-import { ContainerIR, WorkflowIR } from '@lunora/codegen';
+import { ContainerIR, WorkflowIR, QueueIR, WranglerVariableIR } from '@lunora/codegen';
 export type { ContainerIR, WorkflowIR } from '@lunora/codegen';
+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.mjs";
+/** 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)
@@ -65,6 +83,77 @@ interface DiscoverContainerInfoResult {
 * (inference).
 */
 declare const discoverContainerInfo: (projectRoot: string, schemaDirectory: string) => DiscoverContainerInfoResult;
+/** Severity a container output line is surfaced at: `stderr` → `error`, `stdout` → `info`. */
+type ContainerLogLevel = "error" | "info";
+/** One declared container to follow, identified by the names codegen lifts from `defineContainer`. */
+interface ContainerLogSource {
+  /** Generated Durable Object class name, e.g. `TranscoderContainer`. Wrangler's dev image is `cloudflare-dev/&lt;lowercased>`. */
+  className: string;
+  /** The `lunora/containers.ts` export name, e.g. `transcoder` — used as the display tag. */
+  exportName: string;
+}
+/** A single line of container output handed back to the caller. */
+interface ContainerLogLine {
+  /** `"error"` for the container's stderr, `"info"` for its stdout. */
+  level: ContainerLogLevel;
+  /** The container's export name (`transcoder`), for tagging the line. */
+  name: string;
+  /** One output line, with the trailing newline (and any `\r`) stripped. */
+  text: string;
+}
+interface ContainerLogStreamOptions {
+  /** The declared containers to follow. An empty list yields an inert handle. */
+  containers: ReadonlyArray<ContainerLogSource>;
+  /** Injected Docker client — defaults to a real lazily-imported `dockerode` instance. Tests pass a stub. */
+  docker?: DockerLike;
+  /** Called once per container output line. */
+  onLine: (line: ContainerLogLine) => void;
+  /** Called once when the Docker engine can't be reached (re-armed after it recovers). Defaults to silent. */
+  onUnavailable?: (message: string) => void;
+  /** Poll interval override, in ms. */
+  pollIntervalMs?: number;
+}
+/** Handle controlling a running log stream. */
+interface ContainerLogStreamHandle {
+  /** Stop polling and tear down every attached log stream. Idempotent. */
+  close: () => void;
+}
+/** The minimal structural slice of a `dockerode` log stream this module consumes. */
+interface DockerLogStream {
+  destroy: () => void;
+  on: (event: "data" | "end" | "error", listener: (chunk?: Buffer) => void) => void;
+}
+/** The minimal structural slice of a `dockerode` instance this module consumes. */
+interface DockerLike {
+  getContainer: (id: string) => {
+    logs: (options: {
+      follow: true;
+      stderr: true;
+      stdout: true;
+      tail: "all";
+      timestamps: false;
+    }) => Promise<DockerLogStream>;
+  };
+  listContainers: (options: {
+    filters: {
+      status: ["running"];
+    };
+  }) => Promise<{
+    Id: string;
+    Image: string;
+  }[]>;
+  modem: {
+    demuxStream: (stream: DockerLogStream, stdout: Writable, stderr: Writable) => void;
+  };
+}
+/**
+* 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.
@@ -85,6 +174,13 @@ interface FrameworkDetection {
   framework: DetectedFramework;
 }
 /**
+* Read and parse the project `package.json`, returning its merged
+* `dependencies` + `devDependencies` name set (empty on any failure). Public
+* so sibling consumers (e.g. the CLI's Vite-project detection) share one
+* best-effort reader instead of re-parsing `package.json` themselves.
+*/
+declare const readProjectDependencyNames: (root: string) => ReadonlySet<string>;
+/**
 * Detect which meta-framework a project uses by inspecting its `package.json`
 * dependencies, and classify it under void's class-A/B/C model (PLAN4 §3).
 *
@@ -93,6 +189,112 @@ interface FrameworkDetection {
 * 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;
+/**
+* Marker env `lunora dev --background` sets on the detached server process
+* (the daemon `lunora dev` or `vite dev`), so it records itself as
+* `background: true` — and, for the CLI daemon, never re-detects an agent and
+* recurses into background mode again.
+*/
+declare const DEV_DAEMON_ENV = "LUNORA_DEV_DAEMON";
+/** Env carrying the capture-log path into the detached server, recorded in the state file. */
+declare const DEV_LOG_FILE_ENV = "LUNORA_DEV_LOG_FILE";
+/**
+* Env carrying the PID of a parent that holds a *provisional* state record it
+* expects the child dev server to supersede. The CLI claims `.lunora/dev.json`
+* with its own PID before spawning the real server (closing the duplicate-start
+* race for the vite flavor and the wrangler daemon), then hands its PID down
+* via this variable; the child's claim (see {@link claimDevServerState}'s
+* `supersedePid`) may replace exactly that record with the authoritative
+* URL + PID.
+*/
+declare const DEV_HANDOFF_ENV = "LUNORA_DEV_HANDOFF_PID";
+/** How the recorded dev server runs. */
+type DevServerMode = "cli" | "vite";
+/** The state record persisted to `.lunora/dev.json`. */
+interface DevServerState {
+  /** Whether the server was detached into the background (`lunora dev --background`). */
+  background?: boolean;
+  /** Absolute path of the log file capturing the server's output, when captured. */
+  logFile?: string;
+  /** `"cli"` for the `lunora dev` wrangler orchestration, `"vite"` for a Vite dev server. */
+  mode: DevServerMode;
+  /** PID of the process to signal for shutdown (the orchestrating CLI or the Vite process). */
+  pid: number;
+  /** ISO-8601 stamp written at startup, purely informational (drives `status` uptime). */
+  startedAt?: string;
+  /** The embedded studio server's URL, when it runs. */
+  studioUrl?: string;
+  /** The primary URL serving the worker/app. */
+  url: string;
+}
+/**
+* True when a process with `pid` is currently alive AND signalable by this
+* user. Signal `0` performs the existence check without delivering anything.
+*
+* `EPERM` ("alive but another user's process") deliberately counts as NOT
+* alive here: every dev server this module tracks was spawned by the current
+* user, so a PID we cannot signal is by definition a recycled PID — treating
+* it as running would wedge the lockfile permanently and aim `dev stop`'s
+* kill escalation at an innocent process.
+*/
+declare const isProcessAlive: (pid: number) => boolean;
+/**
+* True when the record's PID verifiably still refers to the dev server that
+* wrote the record — not merely "some process exists with that number".
+* Guards against PID reuse: a server process necessarily starts BEFORE its
+* record is written, so a process that started after `startedAt` (+ skew) is
+* a recycled PID wearing the corpse's number. The start-time check runs only
+* where the platform exposes it (Linux); elsewhere liveness alone decides.
+*/
+declare const isRecordedProcessCurrent: (state: DevServerState) => boolean;
+/**
+* Read the state record from `.lunora/dev.json`, or `undefined` when there is
+* no usable record. Best-effort; performs NO liveness check — use
+* {@link readLiveDevServerState} for "is a dev server actually running".
+*/
+declare const readDevServerState: (projectRoot: string) => DevServerState | undefined;
+/**
+* Write the state record to `.lunora/dev.json`, creating the `.lunora/`
+* directory when absent. Returns the absolute path written, or `undefined`
+* when the write failed (state is convenience metadata — a read-only checkout
+* must never crash dev startup).
+*/
+declare const writeDevServerState: (projectRoot: string, state: DevServerState) => string | undefined;
+/**
+* Merge `patch` into the existing state record, when one exists. Used by the
+* CLI to stamp `background`/`logFile` onto the record the Vite plugin wrote.
+* Returns the merged record, or `undefined` when there was nothing to update.
+*/
+declare const updateDevServerState: (projectRoot: string, patch: Partial<DevServerState>) => DevServerState | undefined;
+/**
+* Remove `.lunora/dev.json`. Idempotent and never throws. When `expectedPid`
+* is given, the file is only removed while it still records that PID — so a
+* shutting-down server can't clobber the record a newer server just wrote.
+*/
+declare const clearDevServerState: (projectRoot: string, expectedPid?: number) => void;
+/**
+* The state record of a dev server that is verifiably running right now, or
+* `undefined`. A record whose PID is dead — or recycled onto a different
+* process (see {@link isRecordedProcessCurrent}) — is stale: it is cleared on
+* the spot so subsequent starts don't keep re-reading a corpse.
+*/
+declare const readLiveDevServerState: (projectRoot: string) => DevServerState | undefined;
+/** Result of {@link claimDevServerState}: claimed, or lost to the live server already recorded. */
+interface ClaimDevServerStateResult {
+  /** The live record that won the race, when `ok` is `false`. */
+  existing?: DevServerState;
+  /** Whether this process now owns the record. */
+  ok: boolean;
+}
+declare const claimDevServerState: (projectRoot: string, state: DevServerState, options?: {
+  supersedePid?: number;
+}) => ClaimDevServerStateResult;
 /**
 * The `.dev.vars` line grammar — one owner, shared by every reader/writer of the
 * file so the format can't drift between packages. `@lunora/cli`'s `env`
@@ -156,39 +358,61 @@ interface InferredContainer extends ContainerIR {
 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/analytics` is imported → self-describing `analytics_engine_datasets` binding (auto-writeable). */
+  /** `@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/images` is imported → self-describing `images` binding (auto-writeable). */
+  /** `@lunora/bindings/images` is imported → self-describing `images` binding (auto-writeable). */
   usesImages: boolean;
-  /** `@lunora/kv` is imported (namespace binding name + id are user-defined; hint-only). */
+  /** `@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;
-  /** `@lunora/pipelines` is imported (binding needs an un-mintable remote pipeline name; hint-only). */
+  /** `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;
+  /** `@lunora/x402/charge` is imported — the charge rail settles USDC to a recipient address (a public `[vars]` entry, user-named; hint-only). */
+  usesX402Charge: boolean;
+  /** `@lunora/x402/pay` is imported — the agent-wallet pay rail signs from a Secrets Store binding paired with a spend policy (ActionCtx-only; hint-only). */
+  usesX402Pay: boolean;
   /** Workflows declared in `lunora/workflows.ts` (exported or not — see {@link InferredWorkflow.exported}). */
   workflows: InferredWorkflow[];
 }
@@ -338,6 +562,15 @@ interface SecretEntry {
   */
   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.
 *
@@ -488,6 +721,21 @@ interface ReconcileBindingsResult {
 * config already satisfies the inferred needs.
 */
 declare const reconcileWranglerBindings: (projectRoot: string, inferred: InferredBindings) => ReconcileBindingsResult;
+interface ReconcileCompatibilityDateResult {
+  /** `true` when `wrangler.jsonc` was rewritten. */
+  changed: boolean;
+  /** The new date value, or the existing one when unchanged. */
+  date: string | undefined;
+  /** Human-readable reason when reconciliation was skipped. */
+  reason?: string;
+  /** Resolved wrangler path, or `undefined` when none was found. */
+  wranglerPath?: string;
+}
+/**
+* Reconcile the `compatibility_date` in `wrangler.jsonc` when Workers Cache
+* is enabled but the date is below the minimum required.
+*/
+declare const reconcileWranglerCompatibilityDate: (projectRoot: string) => ReconcileCompatibilityDateResult;
 /**
 * 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
@@ -659,6 +907,8 @@ interface RemoteEnableInputs {
 * is still overridable per-run by `--remote` or `LUNORA_REMOTE=1`.
 */
 declare const resolveRemoteEnabled: (inputs: RemoteEnableInputs) => boolean;
+/** 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
@@ -667,6 +917,15 @@ declare const resolveRemoteEnabled: (inputs: RemoteEnableInputs) => boolean;
 */
 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.
+*/
+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.
 *
@@ -768,6 +1027,58 @@ declare const buildPackageSecretsBlock: (packageNames: ReadonlyArray<string>, ex
 * **Safety invariant:** only placeholder values are written — no real secrets.
 */
 declare const ensureDevVariablesExample: (cwd: string, packageNames: ReadonlyArray<string>) => string[];
+interface DevSecretsFillPlan {
+  /** {@link CORE_SECRETS} keys appended because they were absent (each generated). */
+  addedKeys: string[];
+  /** The full new file content to write. */
+  content: string;
+  /** Existing empty/placeholder secret-keyed entries filled with fresh values. */
+  filledKeys: string[];
+}
+/**
+* Plan the in-place generation of dev secrets for a `.dev.vars`. First, every
+* line whose KEY looks like a secret (`*_SECRET`, `*_TOKEN`, `*_KEY`,
+* `*_PASSWORD`) and whose value is empty or a placeholder gets a freshly
+* generated value — so a `lunora add`-scaffolded `.dev.vars` (which writes each
+* secret blank) becomes usable on `lunora dev` / `vite dev` without the user
+* running `openssl` by hand. Second, any {@link CORE_SECRETS} key absent from
+* the file is appended (generated) — notably `LUNORA_ADMIN_TOKEN`, which the
+* local Studio needs to call the worker's admin gate in dev (without it the
+* Studio shows its login gate).
+*
+* Pure (given `randomHex`): real (non-placeholder) values are never touched, and
+* comments + non-secret entries are preserved verbatim.
+*/
+declare const planDevSecretsFill: (input: {
+  existingContent: string;
+  randomHex?: (bytes: number) => string;
+}) => DevSecretsFillPlan;
+interface FillDevSecretsResult {
+  /** Core secret keys appended (generated) because they were missing. */
+  addedKeys: string[];
+  /** Existing empty/placeholder secrets filled with generated values. */
+  filledKeys: string[];
+  /** `created` = no `.dev.vars` existed; `filled` = topped up an existing one; `unchanged` = nothing to do. */
+  status: "created" | "filled" | "unchanged";
+}
+/**
+* Generate any missing/empty dev secrets in the project's `.dev.vars`, in place.
+*
+* Complements {@link ensureDevVariables} (which scaffolds `.dev.vars` from
+* `.dev.vars.example`). A `lunora add`-scaffolded project writes secrets blank
+* straight into `.dev.vars` (no example) and never includes `LUNORA_ADMIN_TOKEN`
+* — so the worker boots with empty secrets and the Studio shows its login gate.
+* This fills those gaps at dev startup, so both `lunora dev` and the
+* `@lunora/vite` dev server give a working project with zero manual `openssl`.
+*
+* Never overwrites a real (non-placeholder) value. The write is atomic + owner-
+* only (temp + rename, `mode: 0o600`), matching the other `.dev.vars` writers.
+*/
+declare const fillDevSecrets: (deps: {
+  cwd: string;
+  info?: (message: string) => void;
+  randomHex?: (bytes: number) => string;
+}) => FillDevSecretsResult;
 /** Add a new table to `defineSchema({ ... })`. */
 interface AddTableEdit {
   readonly kind: "addTable";
@@ -964,6 +1275,23 @@ interface ReadWranglerResult<T> {
 * wrangler does.
 */
 declare const readWranglerJsonc: <T = unknown>(wranglerPath: string) => ReadWranglerResult<T>;
+/**
+* Pure scan of a `vars` map for plaintext secrets — the FS-free core, exported for
+* unit tests. A variable is flagged when, for a **string** value that is neither a
+* placeholder nor a public/publishable key, EITHER the value matches a known
+* secret shape (`secretKindOf`) OR the key name strongly implies a secret and the
+* value is long enough to plausibly be one. `kind` is the matched shape, or
+* `secret_named_var` for the key-name path.
+*/
+declare const scanWranglerVariablesForSecrets: (variables: Record<string, unknown> | undefined, file: string) => WranglerVariableIR[];
+/**
+* Read the project's `wrangler.jsonc` and return its plaintext-secret `vars` as IR
+* for the `plaintext_secret_in_wrangler_vars` lint. Returns `[]` when there is no
+* wrangler config, it doesn't parse, or nothing looks like a secret. Scans the
+* top-level `vars` block (mirroring the existing `validateCorsVariables` scope);
+* per-environment `env.&lt;name>.vars` overrides are out of scope for now.
+*/
+declare const collectWranglerSecretVariables: (projectRoot: string) => WranglerVariableIR[];
 declare const REQUIRED_COMPATIBILITY_DATE: string;
 declare const REQUIRED_FLAG: string;
 interface WranglerDurableObjectBinding {
@@ -1002,6 +1330,22 @@ interface WranglerWorkflowEntry {
   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;
@@ -1016,6 +1360,9 @@ interface WranglerConfig {
   browser?: {
     binding?: string;
   };
+  cache?: {
+    enabled?: boolean;
+  } | null;
   compatibility_date?: string;
   compatibility_flags?: ReadonlyArray<string>;
   containers?: ReadonlyArray<WranglerContainerEntry | null | undefined>;
@@ -1030,6 +1377,16 @@ interface WranglerConfig {
   durable_objects?: {
     bindings?: ReadonlyArray<WranglerDurableObjectBinding>;
   };
+  exports?: Record<string, {
+    cache?: {
+      enabled?: boolean;
+    } | null;
+    type?: string;
+  } | null> | null;
+  flagship?: ReadonlyArray<{
+    app_id?: string;
+    binding?: string;
+  } | null | undefined>;
   hyperdrive?: ReadonlyArray<{
     binding?: string;
     id?: string;
@@ -1066,9 +1423,18 @@ interface WranglerConfig {
   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;
@@ -1128,4 +1494,4 @@ interface WranglerProjectValidationResult {
 * `{ problems, wranglerPath }` shape plus the structured `report`.
 */
 declare const validateWranglerProject: (options: WranglerProjectValidationOptions) => WranglerProjectValidationResult;
-export { ACCENT, AGENT_RULES_DIR, AGENT_RULES_HINT, AGENT_RULES_HINT_ENV, type AddIndexEdit, type AddOptionalColumnEdit, type AddTableEdit, type AdditiveEdit, type AgentRulesStatus, type ApplyEditResult, type ApplyFailureReason, type AugmentPlan, BADGES, BADGE_COLUMN_WIDTH, type BadgeName, type BadgeSpec, DEV_VARS_EXAMPLE_FILE, DEV_VARS_FILE, DEV_VARS_KEY_PATTERN, type DestructiveEdit, type DetectedFramework, type DiscoverContainerInfoResult, type DiscoverSchemaInfoResult, type DiscoverWorkflowInfoResult, type EnsureDevVariablesDeps, type EnsureDevVariablesResult, type EnsureDevVariablesStatus, type ExportGap, type FrameworkClass, type FrameworkDetection, type InferOptions, type InferredBindings, type InferredContainer, type InferredWorkflow, LINKED_PROJECT_DIR, LINKED_PROJECT_FILE, LUNA_ART, LUNA_BUNNY, LUNA_NAME, LUNA_SIGNOFF, LUNORA_CONFIG_FILE, LUNORA_EVENT_SOURCE, LUNORA_SKILL_NAMES, type LevelBadgeName, type LinkedProject, type LunoraFormattedLine, type LunoraLineLevel, type LunoraProjectConfig, LunoraReporter, type MaterializeOptions, type MaterializeResult, type MultiSelectOption, PACKAGE_SECRETS_REGISTRY, type ParseSchemaResult, REMOTE_ELIGIBLE_KEYS, REQUIRED_COMPATIBILITY_DATE, REQUIRED_FLAG, ROOT_SKILL_NAME, type ReadWranglerResult, type ReconcileBindingsResult, type RemoteBindingPlan, type RemoteEnableInputs, type RemotePreference, type RemoteWranglerShape, STEP_BADGE_NAMES, type ScaffoldPlan, type SchemaColumn, type SchemaEdit, type SchemaIndex, type SchemaInfo, type SchemaTable, type SecretEntry, type SelectOption, type StepBadgeName, type TailConsumer, WRANGLER_FILES, type WranglerConfig, type WranglerContainerEntry, type WranglerProjectValidationOptions, type WranglerProjectValidationResult, type WranglerValidationReport, type WranglerWorkflowEntry, applyAdditiveEdit, badgeLead, badgeWidth, buildPackageSecretsBlock, claimAgentRulesHint, classifyEdit, createConfirm, detectAgentRules, detectFramework, discoverContainerInfo, discoverSchemaInfo, discoverWorkflowInfo, ensureDevVariables, ensureDevVariablesExample as ensureDevVarsExample, findWranglerFile, formatLunoraEvent, inferLunoraBindings, injectRemoteFlags, interpretRemote, isInteractive, isPlaceholderValue, isRemoteEnvEnabled, materializeRemoteWranglerConfig, packageNamesFromBindings, padBadge, paintAnswer, paintBadge, parseDevVariableEntries, parseSchema, planDevVariablesAugment, planDevVariablesScaffold, planRemoteBindings, promptMultiSelect, promptSelect, promptYesNo, readLinkedProject, readProjectRemotePreference, readWranglerJsonc, reconcileWranglerBindings, resolveRemoteEnabled, secretsForPackages, validateWrangler, validateWranglerConfig, validateWranglerProject, withTailConsumer, writeLinkedProject };
+export { ACCENT, AGENT_MODE_ENV, AGENT_RULES_DIR, AGENT_RULES_HINT, AGENT_RULES_HINT_ENV, type AddIndexEdit, type AddOptionalColumnEdit, type AddTableEdit, type AdditiveEdit, type AgentDetection, type AgentRulesStatus, type ApplyEditResult, type ApplyFailureReason, type AugmentPlan, BADGES, BADGE_COLUMN_WIDTH, type BadgeName, type BadgeSpec, type ClaimDevServerStateResult, type ContainerLogLevel, type ContainerLogLine, type ContainerLogSource, type ContainerLogStreamHandle, type ContainerLogStreamOptions, DEV_DAEMON_ENV, DEV_HANDOFF_ENV, DEV_LOG_FILE, DEV_LOG_FILE_ENV, DEV_STATE_DIR, DEV_STATE_FILE, DEV_VARS_EXAMPLE_FILE, DEV_VARS_FILE, DEV_VARS_KEY_PATTERN, type DestructiveEdit, type DetectedFramework, type DevSecretsFillPlan, type DevServerMode, type DevServerState, 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 ReconcileCompatibilityDateResult, 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, claimDevServerState, classifyEdit, clearDevServerState, collectWranglerSecretVariables, createConfirm, detectAgentRules, detectAiAgent, detectFramework, discoverContainerInfo, discoverSchemaInfo, discoverWorkflowInfo, ensureDevVariables, ensureDevVariablesExample as ensureDevVarsExample, fillDevSecrets, findWranglerFile, formatLunoraEvent, generateSecretValue, inferLunoraBindings, injectRemoteFlags, interpretRemote, isInteractive, isMintableSecretKey, isPlaceholderValue, isProcessAlive, isRecordedProcessCurrent, isRemoteEnvEnabled, materializeRemoteWranglerConfig, packageNamesFromBindings, padBadge, paintAnswer, paintBadge, parseDevVariableEntries, parseSchema, planDevSecretsFill, planDevVariablesAugment, planDevVariablesScaffold, planRemoteBindings, promptMultiSelect, promptSelect, promptYesNo, readDevServerState, readLinkedProject, readLiveDevServerState, readProjectDependencyNames, readProjectRemotePreference, readWranglerJsonc, reconcileWranglerBindings, reconcileWranglerCompatibilityDate, requiredSecrets, resolveRemoteEnabled, scanWranglerVariablesForSecrets, secretsForPackages, streamContainerLogs, updateDevServerState, validateWrangler, validateWranglerConfig, validateWranglerProject, withTailConsumer, writeDevServerState, writeLinkedProject };