@lunora/config 1.0.0-alpha.27 → 1.0.0-alpha.270

package/dist/packem_shared/parseDevVariable-teAAahVD.mjs

@@ -0,0 +1 @@
+import{readFileSync as n}from"node:fs";import{join as s}from"node:path";import{parseDevVariableEntries as i}from"./DEV_VARS_EXAMPLE_FILE-CqLorAxT.mjs";const a=(o,r)=>{const e=i(o).find(t=>t.key===r);return e===void 0||e.value===""?void 0:e.value},d=o=>{let r;try{r=a(n(s(o,".dev.vars"),"utf8"),"LUNORA_ADMIN_TOKEN")}catch{r=void 0}const e=process.env.LUNORA_ADMIN_TOKEN;return typeof e=="string"&&e!==""&&e!==r&&console.warn("[lunora] LUNORA_ADMIN_TOKEN is exported in this shell but differs from .dev.vars — the local worker only verifies the .dev.vars token, so the studio uses that one."),r};export{a as parseDevVariable,d as resolveAdminToken};

package/dist/packem_shared/parseSchema-D1Wbr1qv.mjs

@@ -0,0 +1 @@
+import{Project as m,SyntaxKind as n}from"ts-morph";const f=/^v\s*\.\s*optional\s*\(/u,x=/\.shardBy\(\s*["']([^"']+)["']\s*\)/u,T=/\.global\(\s*(?:\{[^{}]*\}\s*)?\)/u,p=/["']/gu,u=e=>{const t=e.getDescendantsOfKind(n.CallExpression);return e.getKind()===n.CallExpression&&t.push(e.asKindOrThrow(n.CallExpression)),t},A=e=>f.test(e.trim()),h=e=>e?.getKind()!==n.ArrayLiteralExpression?[]:e.asKindOrThrow(n.ArrayLiteralExpression).getElements().filter(t=>t.getKind()===n.StringLiteral).map(t=>t.asKindOrThrow(n.StringLiteral).getLiteralText()),E=e=>{if(e?.getKind()!==n.ObjectLiteralExpression)return!1;const t=e.asKindOrThrow(n.ObjectLiteralExpression).getProperty("unique");return t?.getKind()===n.PropertyAssignment&&t.getInitializer()?.getText()==="true"},K=e=>{const t=e.getExpression();if(t.getKind()!==n.PropertyAccessExpression||t.asKindOrThrow(n.PropertyAccessExpression).getName()!=="index")return;const[r,a,s]=e.getArguments();if(r?.getKind()===n.StringLiteral)return{fields:h(a),name:r.asKindOrThrow(n.StringLiteral).getLiteralText(),unique:E(s)}},O=e=>{const t=e.getInitializer();if(t===void 0)return[];const r=[];for(const a of u(t)){const s=K(a);s!==void 0&&r.push(s)}return r},y=e=>{const t=[],r=e.getInitializer(),s=(r===void 0?void 0:u(r).find(l=>l.getExpression().getText()==="defineTable"))?.getArguments()[0];if(s?.getKind()!==n.ObjectLiteralExpression)return t;for(const l of s.getProperties()){if(l.getKind()!==n.PropertyAssignment)continue;const i=l,o=i.getName().replaceAll(p,""),c=i.getInitializer()?.getText()??"";t.push({name:o,optional:A(c),validator:c})}return t},P=e=>{const r=new m({compilerOptions:{allowJs:!0},useInMemoryFileSystem:!0}).createSourceFile("schema.ts",e,{overwrite:!0}),a=r.getDescendantsOfKind(n.CallExpression).find(i=>i.getExpression().getText()==="defineSchema");if(a===void 0)return{ok:!1,reason:r.getImportDeclarations().some(o=>o.getNamedImports().some(c=>c.getName()==="defineSchema"&&c.getAliasNode()!==void 0))?"aliased-define-schema":"no-define-schema"};const s=a.getArguments()[0];if(s?.getKind()!==n.ObjectLiteralExpression)return{ok:!1,reason:"non-object-argument"};const l=[];for(const i of s.getProperties()){if(i.getKind()!==n.PropertyAssignment)continue;const o=i,c=o.getName().replaceAll(p,""),g=o.getInitializer()?.getText()??"",d=x.exec(g);l.push({columns:y(o),global:T.test(g),indexes:O(o),name:c,...d?.[1]===void 0?{}:{shardBy:d[1]}})}return{ok:!0,tables:l}};export{u as collectCalls,P as parseSchema};

package/dist/packem_shared/policy-scaffold.d-D2H4_G01.d.mts

@@ -0,0 +1,86 @@
+/**
+ * The server-module specifier to scaffold into a project's own source:
+ * `lunorash/server` when the project depends on the umbrella, `@lunora/server`
+ * when it installs the granular packages. Same detection codegen and the Vite
+ * compose plugin use, so a scaffolded file imports what the emitted code does.
+ */
+declare const resolveServerModule: (projectRoot: string) => string;
+/** Scaffold a new policy/role/permission stub file under `lunora/`. */
+interface ScaffoldPolicyEdit {
+  readonly kind: "scaffoldPolicy";
+  /**
+   * Base name for the generated file and its exported policy-set identifier,
+   * e.g. `invoices` → `lunora/invoices.policies.ts` exporting `invoicesPolicies`.
+   */
+  readonly name: string;
+  /** Logical table the scaffolded policy guards (used in the stub body). */
+  readonly table: string;
+}
+/** Append `.use(rls(<policies>))` to an existing procedure's builder chain. */
+interface WireRlsEdit {
+  /** Exported procedure name to wire, e.g. `listInvoices`. */
+  readonly exportName: string;
+  readonly kind: "wireRls";
+  /** Identifier of the policy set passed to `rls(...)`, e.g. `invoicesPolicies`. */
+  readonly policies: string;
+}
+/** Additive scaffolder edits — the only requests the scaffolder applies. */
+type AdditivePolicyEdit = ScaffoldPolicyEdit | WireRlsEdit;
+/**
+ * Destructive scaffolder requests — never applied. Rewriting an existing `when`
+ * body changes evaluation semantics silently, so it is refused (STOP condition
+ * in plan 025); carried as data so the editor can describe the request.
+ */
+interface DestructivePolicyEdit {
+  readonly exportName?: string;
+  readonly kind: "rewritePolicyWhen";
+  readonly table?: string;
+}
+/** Any request the scaffolder can receive. */
+type PolicyEdit = AdditivePolicyEdit | DestructivePolicyEdit;
+/**
+ * Classify a scaffolder request. Additive requests ({@link AdditivePolicyEdit})
+ * apply directly; everything else (rewriting an existing predicate) changes
+ * evaluation semantics and is destructive.
+ */
+declare const classifyPolicyEdit: (edit: PolicyEdit) => "additive" | "destructive";
+/** Failure reasons a scaffolder request can report. */
+type PolicyScaffoldFailureReason = "already-wired" | "destructive" | "invalid-identifier" | "unknown-procedure" | "unsupported-procedure-shape";
+/** Tagged result of generating a stub file. */
+type ScaffoldFileResult = {
+  fileName: string;
+  ok: true;
+  source: string;
+} | {
+  ok: false;
+  reason: PolicyScaffoldFailureReason;
+};
+/** Tagged result of wiring a procedure. */
+type WireResult = {
+  ok: false;
+  reason: PolicyScaffoldFailureReason;
+} | {
+  ok: true;
+  text: string;
+};
+/**
+ * Generate the source of a new policy/role/permission stub file. The `when`
+ * predicate is a `() => false` skeleton with a TODO — the scaffolder never
+ * authors real logic, the developer fills it in. Pure (no I/O); the handler
+ * writes the returned source and refuses to overwrite an existing file.
+ *
+ * `serverModule` is the specifier the PROJECT can resolve the builders from
+ * (see {@link resolveServerModule}) — an umbrella-only install has no
+ * `@lunora/server` on disk, so hard-coding it would scaffold a file that
+ * cannot be bundled.
+ */
+declare const scaffoldPolicyFile: (edit: ScaffoldPolicyEdit, serverModule: string) => ScaffoldFileResult;
+/**
+ * Append `.use(rls(<policies>))` to a procedure's builder chain, preserving the
+ * terminal `.query(handler)` (and its handler body) byte-for-byte. Only the
+ * **builder** form can be wired; the bare-factory form (`query({ handler })`)
+ * has no chain and is reported `unsupported-procedure-shape` so the editor can
+ * tell the developer to convert it rather than silently rewriting their code.
+ */
+declare const wireRlsIntoProcedure: (source: string, edit: WireRlsEdit, serverModule: string) => WireResult;
+export { AdditivePolicyEdit as A, DestructivePolicyEdit as D, PolicyEdit as P, ScaffoldPolicyEdit as S, WireRlsEdit as W, PolicyScaffoldFailureReason as a, ScaffoldFileResult as b, WireResult as c, classifyPolicyEdit as d, resolveServerModule as r, scaffoldPolicyFile as s, wireRlsIntoProcedure as w };

package/dist/packem_shared/policy-scaffold.d-D2H4_G01.d.ts

@@ -0,0 +1,86 @@
+/**
+ * The server-module specifier to scaffold into a project's own source:
+ * `lunorash/server` when the project depends on the umbrella, `@lunora/server`
+ * when it installs the granular packages. Same detection codegen and the Vite
+ * compose plugin use, so a scaffolded file imports what the emitted code does.
+ */
+declare const resolveServerModule: (projectRoot: string) => string;
+/** Scaffold a new policy/role/permission stub file under `lunora/`. */
+interface ScaffoldPolicyEdit {
+  readonly kind: "scaffoldPolicy";
+  /**
+   * Base name for the generated file and its exported policy-set identifier,
+   * e.g. `invoices` → `lunora/invoices.policies.ts` exporting `invoicesPolicies`.
+   */
+  readonly name: string;
+  /** Logical table the scaffolded policy guards (used in the stub body). */
+  readonly table: string;
+}
+/** Append `.use(rls(<policies>))` to an existing procedure's builder chain. */
+interface WireRlsEdit {
+  /** Exported procedure name to wire, e.g. `listInvoices`. */
+  readonly exportName: string;
+  readonly kind: "wireRls";
+  /** Identifier of the policy set passed to `rls(...)`, e.g. `invoicesPolicies`. */
+  readonly policies: string;
+}
+/** Additive scaffolder edits — the only requests the scaffolder applies. */
+type AdditivePolicyEdit = ScaffoldPolicyEdit | WireRlsEdit;
+/**
+ * Destructive scaffolder requests — never applied. Rewriting an existing `when`
+ * body changes evaluation semantics silently, so it is refused (STOP condition
+ * in plan 025); carried as data so the editor can describe the request.
+ */
+interface DestructivePolicyEdit {
+  readonly exportName?: string;
+  readonly kind: "rewritePolicyWhen";
+  readonly table?: string;
+}
+/** Any request the scaffolder can receive. */
+type PolicyEdit = AdditivePolicyEdit | DestructivePolicyEdit;
+/**
+ * Classify a scaffolder request. Additive requests ({@link AdditivePolicyEdit})
+ * apply directly; everything else (rewriting an existing predicate) changes
+ * evaluation semantics and is destructive.
+ */
+declare const classifyPolicyEdit: (edit: PolicyEdit) => "additive" | "destructive";
+/** Failure reasons a scaffolder request can report. */
+type PolicyScaffoldFailureReason = "already-wired" | "destructive" | "invalid-identifier" | "unknown-procedure" | "unsupported-procedure-shape";
+/** Tagged result of generating a stub file. */
+type ScaffoldFileResult = {
+  fileName: string;
+  ok: true;
+  source: string;
+} | {
+  ok: false;
+  reason: PolicyScaffoldFailureReason;
+};
+/** Tagged result of wiring a procedure. */
+type WireResult = {
+  ok: false;
+  reason: PolicyScaffoldFailureReason;
+} | {
+  ok: true;
+  text: string;
+};
+/**
+ * Generate the source of a new policy/role/permission stub file. The `when`
+ * predicate is a `() => false` skeleton with a TODO — the scaffolder never
+ * authors real logic, the developer fills it in. Pure (no I/O); the handler
+ * writes the returned source and refuses to overwrite an existing file.
+ *
+ * `serverModule` is the specifier the PROJECT can resolve the builders from
+ * (see {@link resolveServerModule}) — an umbrella-only install has no
+ * `@lunora/server` on disk, so hard-coding it would scaffold a file that
+ * cannot be bundled.
+ */
+declare const scaffoldPolicyFile: (edit: ScaffoldPolicyEdit, serverModule: string) => ScaffoldFileResult;
+/**
+ * Append `.use(rls(<policies>))` to a procedure's builder chain, preserving the
+ * terminal `.query(handler)` (and its handler body) byte-for-byte. Only the
+ * **builder** form can be wired; the bare-factory form (`query({ handler })`)
+ * has no chain and is reported `unsupported-procedure-shape` so the editor can
+ * tell the developer to convert it rather than silently rewriting their code.
+ */
+declare const wireRlsIntoProcedure: (source: string, edit: WireRlsEdit, serverModule: string) => WireResult;
+export { AdditivePolicyEdit as A, DestructivePolicyEdit as D, PolicyEdit as P, ScaffoldPolicyEdit as S, WireRlsEdit as W, PolicyScaffoldFailureReason as a, ScaffoldFileResult as b, WireResult as c, classifyPolicyEdit as d, resolveServerModule as r, scaffoldPolicyFile as s, wireRlsIntoProcedure as w };

package/dist/packem_shared/reconcileWranglerCompatibilityDate-7OO_xaKR.mjs

@@ -0,0 +1 @@
+import{writeFileSync as d}from"node:fs";import{modify as c,applyEdits as s}from"jsonc-parser";import{F as l}from"./jsonc-edit-BZgQIdAH.mjs";import{isCacheEnabled as f,WORKERS_CACHE_MIN_DATE as a}from"./WORKERS_CACHE_MIN_DATE-0k9ABJtF.mjs";import{findWranglerFile as m,readWranglerJsonc as p}from"./WRANGLER_FILES-UNW-xY5u.mjs";const _=i=>{const e=m(i);if(!e)return{changed:!1,date:void 0,reason:"wrangler.jsonc not found"};const{parsed:r,text:n}=p(e);if(r===void 0)return{changed:!1,date:void 0,reason:`failed to parse ${e} as JSONC`,wranglerPath:e};const t=r.compatibility_date??"";if(!f(r))return{changed:!1,date:t||void 0,reason:"cache not enabled",wranglerPath:e};if(t>=a)return{changed:!1,date:t,reason:`compatibility_date already >= ${a}`,wranglerPath:e};const o=c(n,["compatibility_date"],a,l);return o.length===0?{changed:!1,date:t||void 0,reason:"no structural edit produced",wranglerPath:e}:(d(e,s(n,o),"utf8"),{changed:!0,date:a,wranglerPath:e})};export{_ as reconcileWranglerCompatibilityDate};

package/dist/packem_shared/renderStudioHtml-ByowDtMl.mjs

@@ -0,0 +1,15 @@
+const r=t=>JSON.stringify(t).replaceAll("<",String.raw`\u003c`),i=t=>t.replaceAll("&","&amp;").replaceAll('"',"&quot;").replaceAll("<","&lt;"),_=t=>{const e=[`window.__LUNORA_BASE_PATH__=${r(t.basePath)};`];return t.adminToken!==void 0&&t.adminToken!==""&&e.push(`window.__LUNORA_ADMIN_TOKEN__=${r(t.adminToken)};`),t.dataEditable===!0&&e.push("window.__LUNORA_DATA_EDITABLE__=true;"),t.runAsIdentity===!0&&e.push("window.__LUNORA_RUN_AS_IDENTITY__=true;"),t.schemaEditable===!0&&e.push("window.__LUNORA_SCHEMA_EDITABLE__=true;"),t.rulesInstalled===!1&&e.push("window.__LUNORA_RULES_INSTALLED__=false;"),`<!doctype html>
+<html lang="en">
+    <head>
+        <meta charset="UTF-8" />
+        <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+        <title>Lunora Studio</title>
+        <script>${e.join("")}<\/script>
+        <link rel="stylesheet" href="${i(t.styleHref)}" />
+    </head>
+    <body>
+        <div id="root"></div>
+        <script type="module" src="${i(t.scriptSrc)}"><\/script>
+    </body>
+</html>
+`};export{_ as default};

package/dist/packem_shared/runPostCodegenHook-CVrOTiGB.mjs

@@ -0,0 +1 @@
+import{spawn as i}from"node:child_process";import{existsSync as d,readFileSync as u}from"node:fs";import{join as f}from"node:path";import{runScriptArgsFor as g,detectPackageManager as m}from"./addArgsFor-CWb4cPij.mjs";const o="postcodegen",l=r=>new Promise((n,s)=>{const e=i(r.command,[...r.args],{cwd:r.cwd??process.cwd(),shell:process.platform==="win32",stdio:["inherit",r.stdoutToStderr===!0?2:"inherit","inherit"]});e.on("error",s),e.on("close",a=>{n({code:a??1})})}),p=r=>{const n=f(r,"package.json");if(!d(n))return!1;try{const e=JSON.parse(u(n,"utf8"))?.scripts;return typeof e?.[o]=="string"&&e[o]!==""}catch{return!1}},P=async r=>{const{cwd:n,logger:s}=r;if(!p(n))return{ran:!1};const e=t=>(s.error(t),{error:t,ran:!0});let a;try{a=g(m(n),o)}catch(t){return e(`cannot run \`${o}\`: ${t instanceof Error?t.message:String(t)}`)}s.info(`running \`${o}\``);let c;try{c=await(r.spawner??l)({args:a.args,command:a.command,cwd:n,stdoutToStderr:r.stdoutToStderr})}catch(t){return e(`\`${o}\` failed to start: ${t instanceof Error?t.message:String(t)}`)}return c.code!==0?e(`\`${o}\` exited ${String(c.code)}`):{ran:!0}};export{P as runPostCodegenHook};

package/dist/packem_shared/schema-info.d-DvKkJ7HJ.d.mts

@@ -0,0 +1,331 @@
+import { AgentIR, ContainerIR, QueueIR, WorkflowIR } from '@lunora/codegen';
+/**
+ * `DeployDriver` — the provider-neutral seam between a Lunora command and the
+ * host CLI that carries it out (plan 114, §5.3).
+ *
+ * The seam is the **toolchain surface**: which command a host runs to deploy,
+ * serve, tail, or set a secret. A driver only *describes* that command
+ * ({@link ToolchainCommand}); it never spawns. The CLI keeps ownership of
+ * running it — package-manager resolution (`pnpm exec` / `npx --` / `bun x`)
+ * and the injected spawner its tests substitute — so the driver stays free of
+ * process concerns and remains trivially testable as a pure function.
+ *
+ * Each request type below is deliberately neutral: `preview`, `environment`,
+ * `temporary` are concepts, not wrangler flags. A second host maps the same
+ * request onto its own CLI without the caller changing.
+ *
+ * Two drivers are registered: Cloudflare (`cloudflare/cloudflare-driver.ts`),
+ * which is the only one with a toolchain, and Node (`node/node-driver.ts`),
+ * which has none — it is a codegen target, and `lunora deploy` / `lunora dev`
+ * refuse it at selection.
+ *
+ * **What this seam deliberately does NOT carry: configuration inference.** It
+ * used to, through an `infer`/`provision` pair over a provider-neutral
+ * `ResourceGraph`. Nothing ever called either one — every consumer reads
+ * `.toolchain` or just validates the target — and the arm rotted in place: the
+ * Node driver was *only* `infer` + `provision`, so its report of what that
+ * target cannot serve (containers, undispatched crons) could not reach an
+ * operator however wrong the app was. The reason it never got wired is worth
+ * keeping: writing real host configuration needs the host's own encodings —
+ * binding names, DO class wiring, migration tags — which a neutral graph
+ * necessarily discards, so `provision` re-derived them anyway and the graph was
+ * decorative. A second target that needs to share inference should grow the
+ * seam back with a caller attached, and with an encoding escape hatch.
+ */
+/**
+ * A host CLI invocation, described but not run.
+ *
+ * `tool` is the binary name only (`"wrangler"`); the caller resolves how to
+ * execute it through the project's package manager. Keeping that split means a
+ * driver never has to know whether the project uses pnpm, npm, yarn, or bun.
+ */
+interface ToolchainCommand {
+  /** Arguments for {@link ToolchainCommand.tool}. */
+  args: ReadonlyArray<string>;
+  /** The host CLI binary, e.g. `"wrangler"`. */
+  tool: string;
+}
+/** Neutral options for a deploy. */
+interface DeployRequest {
+  /** Validate and bundle without publishing — nothing ships. */
+  dryRun?: boolean;
+  /** Deploy this entry file instead of the host config's default (framework composition). */
+  entry?: string;
+  /** Named deployment environment, when the host supports them. */
+  environment?: string;
+  /** Write the built bundle (and any build metadata) to this directory. */
+  outDir?: string;
+  /** Upload a preview/versioned artifact instead of taking production traffic. */
+  preview?: boolean;
+  /** Deploy to a short-lived, unauthenticated account where the host offers one. */
+  temporary?: boolean;
+}
+/** Neutral options for a local dev server. */
+interface DevRequest {
+  /** Host config file to run against, when the flow uses a generated one. */
+  configPath?: string;
+  /** Named environment. */
+  environment?: string;
+  /** Extra host-specific flags the caller has already resolved. */
+  extraArgs?: ReadonlyArray<string>;
+}
+/** Neutral options for tailing live logs. */
+interface TailRequest {
+  /** Named environment. */
+  environment?: string;
+  /** Output format the host tail supports (`"json"`, `"pretty"`, …). */
+  format?: string;
+  /** Free-text filter. */
+  search?: string;
+  /** Status filter (`"error"`, `"ok"`, …). */
+  status?: string;
+  /** Tail a short-lived account's deployment. */
+  temporary?: boolean;
+  /** Tail a specific deployed worker/service by name, when the host addresses them individually. */
+  worker?: string;
+}
+/** Neutral options for reading or writing deployment secrets. */
+interface SecretRequest {
+  /** Named environment. */
+  environment?: string;
+  /** The secret's name — required for `put`, unused for `list`. */
+  key?: string;
+  /** Operate against a short-lived account. */
+  temporary?: boolean;
+}
+/**
+ * The host's command-line surface. Optional as a whole: a host with no vendor
+ * CLI (the Node target; a hypothetical API-driven one) declares none, and
+ * `isRunnableTarget` refuses it for the commands that would have to shell out.
+ */
+interface DriverToolchain {
+  /** The command that deploys the app. */
+  deploy: (request: DeployRequest) => ToolchainCommand;
+  /** The command that runs a local dev server. */
+  dev: (request: DevRequest) => ToolchainCommand;
+  /** The command that lists remote secret names. */
+  secretList: (request: SecretRequest) => ToolchainCommand;
+  /** The command that writes one secret. Its value is passed on stdin, never argv. */
+  secretPut: (request: SecretRequest) => ToolchainCommand;
+  /** The command that tails live logs. */
+  tail: (request: TailRequest) => ToolchainCommand;
+}
+/** A deploy target's implementation: an identity the registry resolves, and the host CLI surface (if any) behind it. */
+interface DeployDriver {
+  /** The target id this driver serves (`"cloudflare"`, …) — matches codegen's `target`. */
+  readonly id: string;
+  /** Human-readable target name, for logs. */
+  readonly name: string;
+  /**
+   * The host's command-line surface, or `undefined` for a host that has none.
+   * Pure: these build argv, they never spawn.
+   */
+  readonly toolchain?: DriverToolchain;
+}
+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 `defineAgent` declaration plus whether its generated agent
+ * `WorkflowEntrypoint` class (e.g. `SupportAgentWorkflow`) is exported by the
+ * worker entry. An agent compiles onto a Cloudflare Workflow, so — exactly like
+ * {@link InferredWorkflow} — only exported agents are safe to provision
+ * (wrangler rejects a `workflows[].class_name` the worker doesn't export), and
+ * an agent is NOT a Durable Object (no `durable_objects` binding or migration).
+ */
+interface InferredAgent extends AgentIR {
+  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 {
+  /** Agents declared in `lunora/agents.ts` (exported or not — see {@link InferredAgent.exported}); reconciled into `workflows[]`. */
+  agents: InferredAgent[];
+  /** 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/notify` is imported (Web Push needs VAPID/FCM secrets in `.dev.vars`; no binding). */
+  usesNotify: 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;
+  /** `ctx.r2sql` is used (needs the `R2_SQL_*` secrets in `.dev.vars`; no binding). */
+  usesR2sql: 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[];
+}
+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;
+}
+/**
+ * The `_generated/` modules that hold a generated Durable Object / Workflow
+ * class — one per class kind a project can declare. wrangler validates every
+ * `class_name` against the worker's exports, so this is the set a worker entry
+ * re-exports (and the set the composed class-A entry star-re-exports for the
+ * kinds the project has).
+ *
+ * Owned here because four places need it and they must not drift:
+ * `@lunora/vite` emits one star re-export per entry, the wrangler validator
+ * DECIDES the composed entry's exports from it, `reconcile-bindings` types its
+ * export-gap `module` field on it, and this module's own `detectClassExports`
+ * probes the same names.
+ *
+ * `scheduler` carries no `define*` declarations of its own — codegen writes it
+ * off `hasScheduler` purely so the composed class-A entry has a `SchedulerDO`
+ * to forward. Its presence is therefore the ONLY signal the plugin and the
+ * validator need, and it is the same signal that decides whether the builder
+ * has a `.scheduler()` method at all. `@lunora/vite` depends on `@lunora/config`, so config
+ * owning it is the direction the dependency graph allows.
+ */
+declare const GENERATED_CLASS_MODULES: readonly ["agents", "containers", "scheduler", "workflows"];
+/** One {@link GENERATED_CLASS_MODULES} entry. */
+type GeneratedClassModule = (typeof GENERATED_CLASS_MODULES)[number];
+/**
+ * The class-B composed entry. `lunora deploy` passes this file to wrangler as
+ * the positional script whenever it exists, overriding `wrangler.main` — so it
+ * is what actually gets bundled and what wrangler checks its DO/Workflow
+ * bindings against. `main` in a class-B project names the framework adapter's
+ * build output (`.svelte-kit/cloudflare/_worker.js`, `dist/_worker.js`), which
+ * exists after `vite build` and exports only the SSR fetch handler. Lexing that
+ * instead read every declared class as unexported: nothing provisioned, plus a
+ * "add `export * from …`" warning the user cannot silence.
+ *
+ * Exported, not documented-as-duplicated: the CLI's `resolveComposedWorkerEntry`
+ * imports this constant, so the deploy's positional entry and the file this
+ * module lexes for exported classes cannot drift apart.
+ */
+declare const COMPOSED_WORKER_ENTRY = "src/worker.ts";
+/**
+ * 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[];
+/** One filterable Vectorize metadata property a schema declares. */
+interface VectorMetadataDeclaration {
+  /** The vector index the property belongs to. */
+  index: string;
+  /**
+   * The validator kind behind the column, or `undefined` when the column
+   * isn't in the owning table's shape. Callers map it to the Vectorize
+   * metadata type; a kind that can't be filtered on is reported, not indexed.
+   */
+  kind: string | undefined;
+  /** Column mirrored into vector metadata. */
+  property: string;
+}
+interface SchemaInfo {
+  /**
+   * Whether the schema declares a **D1-backed** `.global()` table — the only
+   * flavour that needs the `DB` binding and the app's `.global({ d1 })` chain.
+   * A `.global({ backend: "hyperdrive" })` table needs neither, and counting it
+   * here demanded a D1 database of a project that has none.
+   */
+  hasD1GlobalTable: boolean;
+  /** Whether the schema declares a `.global({ backend: "hyperdrive" })` table — needs the app's `.hyperdriveGlobal(...)` chain instead. Required, not optional: the only producer always knows the answer, and `?` made every consumer read a two-valued fact as three-valued. */
+  hasHyperdriveGlobalTable: boolean;
+  /** Names of vector indexes declared via `.vectorize()` / `defineVectorIndex()`. */
+  vectorIndexNames?: ReadonlyArray<string>;
+  /**
+   * Metadata properties declared filterable on a vector index. Cloudflare
+   * needs an explicit metadata index per property before a `filter` can match
+   * anything, so deploy provisions these and doctor reports them.
+   */
+  vectorMetadata?: ReadonlyArray<VectorMetadataDeclaration>;
+}
+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;
+export { COMPOSED_WORKER_ENTRY as C, DeployDriver as D, GeneratedClassModule as G, InferredBindings as I, SchemaInfo as S, TailRequest as T, DeployRequest as a, DevRequest as b, DiscoverSchemaInfoResult as c, DriverToolchain as d, GENERATED_CLASS_MODULES as e, InferOptions as f, InferredAgent as g, InferredContainer as h, InferredWorkflow as i, SecretRequest as j, ToolchainCommand as k, discoverSchemaInfo as l, inferLunoraBindings as m, packageNamesFromBindings as p };