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

package/dist/packem_shared/discoverSchemaInfo-BBRlXZop.mjs

@@ -0,0 +1 @@
+import{existsSync as d}from"node:fs";import{discoverSchema as l,isHyperdriveGlobalTable as f,isD1GlobalTable as b}from"@lunora/codegen";import{Project as u}from"ts-morph";import{join as p}from"node:path";const a=e=>{if(e?.kind==="optional")return a(e.inner);if(e?.kind==="union"){const s=new Set((e.members??[]).filter(i=>i.kind!=="null").map(i=>a(i)));return s.size===1?[...s][0]:e.kind}return e?.kind},m=(e,s)=>{const i=p(e,s,"schema.ts");if(!d(i))return{info:void 0};try{const o=new u({skipAddingFilesFromTsConfig:!0,useInMemoryFileSystem:!1}),r=l(o,i,e),c=n=>r.tables.find(t=>t.name===n)?.shape??{};return{info:{hasD1GlobalTable:r.tables.some(n=>b(n)),hasHyperdriveGlobalTable:r.tables.some(n=>f(n)),...r.jurisdiction===void 0?{}:{jurisdiction:r.jurisdiction},vectorIndexNames:r.vectorIndexes.map(n=>n.name),vectorMetadata:r.vectorIndexes.flatMap(n=>(n.metadata??[]).map(t=>({index:n.name,kind:a(c(n.table)[t]),property:t})))}}}catch(o){return{error:o instanceof Error?o.message:String(o),info:void 0}}},I=(e,s,i)=>i===void 0?m(e,s):i.memo(`schema:${e}:${s}`,()=>m(e,s));export{I as discoverSchemaInfo};

package/dist/packem_shared/discoverWorkflowInfo-zW7Tt0Tn.mjs

@@ -0,0 +1 @@
+import{discoverWorkflows as f,WORKFLOWS_FILENAME as i}from"@lunora/codegen";import{d as t}from"./discover-info-DC2MrAIM.mjs";const d=(r,s)=>{const{error:o,value:e}=t(r,s,i,f);return o===void 0?{workflows:e??[]}:{error:o,workflows:[]}};export{d as discoverWorkflowInfo};

package/dist/packem_shared/guards-Buu_E7mP.mjs

@@ -0,0 +1 @@
+const n=t=>typeof t=="object"&&t!==null&&!Array.isArray(t),s=t=>typeof t=="string"&&t.length>0;export{s as a,n as i};

package/dist/packem_shared/hasCloudflareCredentials-byvHpEiD.mjs

@@ -0,0 +1 @@
+import{readFileSync as d,readdirSync as m}from"node:fs";import{homedir as L}from"node:os";import{join as r}from"node:path";const u=[".env",".env.local",".env.development",".env.development.local"],l=["CLOUDFLARE_API_TOKEN","CF_API_TOKEN"],f=["CLOUDFLARE_API_KEY","CF_API_KEY"],A=["CLOUDFLARE_EMAIL","CF_EMAIL"],v=new Set([...l,...f,...A]),O=/^export\s+/u,S=/\r?\n/u,p=/^(["'])(.*)\1$/u,E=t=>t!==void 0&&t.trim()!=="",C=(t,o)=>[o,t.XDG_CONFIG_HOME,r(o,"Library","Preferences"),r(o,".config"),t.APPDATA===void 0?void 0:r(t.APPDATA,"xdg.config"),r(o,"AppData","Roaming","xdg.config")].filter(s=>E(s)),I=t=>{try{return m(t).length>0}catch{return!1}},K=t=>{const o=new Set;for(const s of u){let n;try{n=d(r(t,s),"utf8")}catch{continue}for(const e of n.split(S)){const c=e.trim().replace(O,""),i=c.indexOf("=");if(c.startsWith("#")||i===-1)continue;const a=c.slice(0,i).trim(),_=c.slice(i+1).trim().replace(p,"$2");v.has(a)&&E(_)&&o.add(a)}}return o},F=(t={})=>{const o=t.env??process.env,s=t.projectRoot===void 0?new Set:K(t.projectRoot),n=e=>E(o[e])||s.has(e);return l.some(e=>n(e))||f.some(e=>n(e))&&A.some(e=>n(e))?!0:C(o,t.home??L()).some(e=>I(r(e,".wrangler","config")))};export{F as hasCloudflareCredentials};

package/dist/packem_shared/infer-bindings-C1NFOdMi.mjs

@@ -0,0 +1 @@
+import{existsSync as P,statSync as j,readFileSync as F,readdirSync as B}from"node:fs";import{discoverFlags as L,FLAGS_FILENAME as k,discoverQueues as G,CAPABILITY_PROBES as N,readServiceBindings as W,discoverNotifyChannels as Y,NOTIFY_FILENAME as K,mayReadCapabilityContext as q,foldCapabilitySignals as C,capabilitiesUsedBy as M,sourceCapabilitySignals as U}from"@lunora/codegen";import{init as H}from"es-module-lexer";import{Project as X}from"ts-morph";import{discoverAgentInfo as Q}from"./discoverAgentInfo-pqFMJBtJ.mjs";import{discoverContainerInfo as V}from"./discoverContainerInfo-DzXr7Vm3.mjs";import{escapeRegExp as J}from"./DEV_VARS_EXAMPLE_FILE-CqLorAxT.mjs";import{d as _}from"./discover-info-DC2MrAIM.mjs";import{relative as z,sep as Z,isAbsolute as ee,join as b}from"node:path";import{P as se}from"./package-secrets-registry-BeheNwsP.mjs";import{discoverSchemaInfo as te}from"./discoverSchemaInfo-BBRlXZop.mjs";import{resolveWorkerEntry as re,composedEntryDurableObjects as ne,GENERATED_DIRECTORY as I,DURABLE_OBJECT_BINDINGS as oe,detectExportedDurableObjects as ae,detectClassExports as x,isMergedProject as ie}from"./COMPOSED_WORKER_ENTRY-Ciiba5g_.mjs";import{discoverWorkflowInfo as ce}from"./discoverWorkflowInfo-zW7Tt0Tn.mjs";const de="https://api.cloudflare.com/client/v4/accounts/<ACCOUNT_ID>/artifacts/namespaces",ue=e=>{const s='add an "artifacts" binding ({ binding: "ARTIFACTS", namespace }) — codegen reads env.ARTIFACTS unless `.artifacts()` on defineApp points ctx.artifacts at another binding';return e===void 0?`ctx.artifacts is used; ${s}. The namespace is created by the first repo create() if it does not exist yet.`:`ctx.artifacts is used and the schema pins data to "${e}"; create the namespace in that jurisdiction BEFORE the first repo, with POST ${de} and body { "namespace": "<name>", "jurisdiction": "${e}" }, then ${s}. A namespace's jurisdiction cannot be changed, and one created implicitly by the first repo create() is unrestricted.`},le=(e,s)=>{const{error:r,value:t}=_(e,s,k,L);return r===void 0?{flags:t}:{error:r}},me=(e,s)=>{const r=z(s,e);return r!==""&&r!==".."&&!r.startsWith(`..${Z}`)&&!ee(r)},pe=(e,s)=>{const{error:r,value:t}=_(e,s,void 0,G);return r===void 0?{queues:t??[]}:{error:r,queues:[]}},he=new Set([".cjs",".cts",".js",".jsx",".mjs",".mts",".ts",".tsx"]),fe=new Set([".git",".lunora-cache",".wrangler","dist",I,"node_modules"]),ge=["lunora","src"],be=/\benv\s*\.\s*DB\b/,ye=/\benv\s*\.\s*AI\b/,$=["ai","aiSearch","analytics","analyticsSql","artifacts","browser","hyperdrive","images","kv","mail","notify","payments","pipelines","r2sql","scheduler","storage","x402"],D=e=>`uses${e.charAt(0).toUpperCase()}${e.slice(1)}`,T=[["usesAuth","@lunora/auth"],["usesCimdWorkers","@lunora/auth/cimd/workers"],["usesX402Charge","@lunora/x402/charge"],["usesPaymentAutumn","@lunora/payment/autumn"],["usesPaymentCreem","@lunora/payment/creem"],["usesPaymentDodopayments","@lunora/payment/dodopayments"],["usesPaymentPolar","@lunora/payment/polar"],["usesPaymentStripe","@lunora/payment/stripe"]],O=[...$.map(e=>[D(e),N[e].moduleSpecifier]),...T].toSorted(([e],[s])=>e.localeCompare(s)),Se=[["usesNotifyFcm","@lunora/notify:fcm"],["usesNotifyWebPush","@lunora/notify:webPush"]],ve=["@lunora/agent","@lunora/agent/sandbox"],Ee=new RegExp(String.raw`["'\x60](?:${[...O.map(([,e])=>e),...ve].map(e=>J(e)).join("|")})["'\x60]`,"u"),a=e=>{const{contextProperty:s,moduleSpecifier:r}=N[e];return s===void 0?`${r} is imported`:`${r} is imported or ctx.${s} is read`},Ae="STRIPE_SECRET_KEY + STRIPE_WEBHOOK_SECRET (Stripe) or POLAR_ACCESS_TOKEN + POLAR_WEBHOOK_SECRET (Polar)",xe=()=>{let e;return()=>(e??=new X({compilerOptions:{allowJs:!0},useInMemoryFileSystem:!0}),e)},Ie=(e,s,r)=>{const t=r(),n=t.createSourceFile(`/scan/${s.slice(s.lastIndexOf("/")+1)}`,e,{overwrite:!0}),o=U(n);return t.removeSourceFile(n),o},w=(e,s)=>{let r;try{r=B(e,{withFileTypes:!0})}catch{return}for(const t of r){if(t.isDirectory()){fe.has(t.name)||w(b(e,t.name),s);continue}const n=t.name.lastIndexOf(".");n!==-1&&he.has(t.name.slice(n))&&s.push(b(e,t.name))}},_e=(e,s,r)=>{const{info:t}=te(e,s,r);return{jurisdiction:t?.jurisdiction,needsD1:t?.hasD1GlobalTable??!1}},Re=(e,s,r)=>{const t=xe(),n=b(e,r),o=[],d=[];let u=!1,i=!1;for(const l of s){const p=b(e,l);if(!P(p)||!j(p).isDirectory())continue;const f=[];w(p,f);for(const m of f){const c=F(m,"utf8"),A=me(m,n);u||=ye.test(c),i||=be.test(c),(Ee.test(c)||A&&q(c))&&(A?o:d).push(Ie(c,m,t))}}const h=C(o),y=C([h,...d]),S=new Set([...y.valueImports,...y.dynamicImports]),v=M({contextReads:h.contextReads,valueImports:S});return{...Object.fromEntries([...$.map(l=>[D(l),v.has(l)]),...T.map(([l,p])=>[l,S.has(p)])]),needsD1:i,usesAi:v.has("ai")||u,usesBrowser:v.has("browser")||h.sandboxTools.usesSandboxBrowser,usesWorkerLoader:h.sandboxTools.usesSandboxLoader}},Ce=(e,s,r)=>[...e.map(t=>t.exported?`${t.bindingName}/${t.className} (container "${t.exportName}" declared and exported)`:`hint: container "${t.exportName}" is declared but ${t.className} is not exported by the worker entry — add \`export * from "./lunora/_generated/containers"\``),...s.map(t=>t.exported?`exports.${t.className} (workflow "${t.exportName}" declared and exported)`:`hint: workflow "${t.exportName}" is declared but ${t.className} is not exported by the worker entry — add \`export * from "./lunora/_generated/workflows"\``),...r.map(t=>t.exported?`exports.${t.className} (agent "${t.exportName}" declared and exported)`:`hint: agent "${t.exportName}" is declared but ${t.className} is not exported by the worker entry — add \`export * from "./lunora/_generated/agents"\``)],Ne=(e,s,r)=>[[e.usesAi,`AI (${a("ai")}, or env.AI is used)`],[e.usesAuth&&!s.has("SessionDO"),"hint: @lunora/auth is imported; its tables are D1-backed by default. For DO-backed auth (what @better-auth/scim needs), pass `namespace` to .auth() and export the generated auth DO class"],[e.usesScheduler&&!s.has("SchedulerDO"),`hint: ${a("scheduler")}, but no SchedulerDO is exported by the worker entry`],[e.usesStorage,`hint: ${a("storage")}; add an r2_buckets binding (bucket binding names are user-defined)`],[e.usesMail,`hint: ${a("mail")}; set RESEND_API_KEY in .dev.vars (obtain at https://resend.com/api-keys)`],[e.usesPayments,`hint: ${a("payments")}; set the provider secrets in .dev.vars — ${Ae}`],[e.usesBrowser,`browser (${a("browser")}, or a sandbox browserTool imported in lunora/) — self-describing { binding: BROWSER }`],[e.usesImages,`images (${a("images")}) — self-describing { binding: IMAGES }`],[e.usesAnalytics,`analytics_engine_datasets (${a("analytics")}) — self-describing { binding: ANALYTICS, dataset }`],[e.usesWorkerLoader,"worker_loaders (jsCodeTool imported in lunora/) — self-describing { binding: LOADER }"],[e.usesAiSearch,`ai_search_namespaces (${a("aiSearch")}) — self-describing { binding: AI_SEARCH, namespace: "default" }; remote-only, so \`lunora dev\` reaches the deployed AI Search service`],[e.usesAnalyticsSql,`analytics (${a("analyticsSql")}) — self-describing { binding: ANALYTICS_SQL }; needs wrangler >= 4.145.0, and is remote-only, so \`lunora dev\` queries the account's live analytics`],[e.usesKv,`hint: ${a("kv")}; add a kv_namespaces binding ({ binding, id }) and pass env.<BINDING> to createKv() — the namespace id can't be auto-provisioned`],[e.usesHyperdrive,`hint: ${a("hyperdrive")}; run 'wrangler hyperdrive create' and add a 'hyperdrive' binding ({ binding, id }) — the id can't be auto-provisioned`],[e.usesPipelines,`hint: ${a("pipelines")}; run 'wrangler pipelines create <name>' and add a 'pipelines' binding ({ binding, stream }) — the pipeline resource can't be auto-provisioned`],[e.usesArtifacts,`hint: ${ue(r.jurisdiction)}`],[e.usesX402Charge,"hint: @lunora/x402/charge is imported; set the recipient wallet address as a [vars] entry (the var name is yours to choose) and pass it to the charge config — the x402 facilitator settles USDC to that address"],[e.usesX402,`hint: ${a("x402")} (ActionCtx-only, spends real funds); add a secrets_store_secrets[] binding for the agent wallet key (name it to match signer.secretName) and pair the pay rail with a spend policy — ctx.secrets reads a Secrets Store binding, not .dev.vars, so the key can't be auto-provisioned`]].filter(([n])=>n).map(([,n])=>n),$e=(e,s,r,t=[],n=[],o=[])=>{const d=new Set(e.map(i=>i.className)),u=e.map(i=>`${i.binding}/${i.className} (exported by worker entry)`);return s.needsD1&&u.push("DB (.global() table declared)"),u.push(...Ce(t,n,o),...Ne(r,d,s)),u},Ke=async e=>{await H;const s=e.schemaDir??"lunora",r=e.scanDirs??ge,t=()=>Re(e.projectRoot,r,s),n=e.cache===void 0?t():e.cache.memo(`capabilities:${e.projectRoot}:${s}:${r.join(",")}`,t),o=re(e.projectRoot);let d;o.composed?d=ne(b(e.projectRoot,s,I)).map(R=>({binding:oe[R],className:R})):d=o.path===void 0?[]:ae(o.path);const u=_e(e.projectRoot,s,e.cache),i={...u,needsD1:n.needsD1||u.needsD1},h=x(o,V(e.projectRoot,s,e.cache).containers,"containers"),y=x(o,ce(e.projectRoot,s).workflows,"workflows"),S=x(o,Q(e.projectRoot,s).agents,"agents"),v=[...pe(e.projectRoot,s).queues],{flags:E}=le(e.projectRoot,s),l=_(e.projectRoot,s,K,Y),p=l.error===void 0?l.value:{hasFcm:!0,hasWebPush:!0},f=E?.provider==="flagship"&&E.mode==="binding"?E.bindingName:void 0,m=$e(d,i,n,h,y,S);!o.composed&&ie(b(e.projectRoot,s,I))&&!d.some(g=>g.className==="LunoraDO")&&m.push("hint: durableObjects.merge is set, but the worker entry exports no LunoraDO — export one built with mergeDurableObjects, or the classes stay separate"),f!==void 0&&m.push(`hint: lunora/flags.ts uses Flagship in binding mode; add a flagship binding ({ binding: "${f}", app_id }) — the app_id can't be auto-provisioned`);const c=W(e.projectRoot),A=c.error===void 0?c.services:void 0;return c.error!==void 0&&m.push(`hint: lunora.config \`services\` not reconciled — ${c.error}`),m.push(...c.services.map(g=>`${g.binding} → ${g.worker} (lunora.config services.${g.name})`)),{...n,agents:S,containers:h,durableObjects:d,flagshipBinding:f,...i.jurisdiction===void 0?{}:{jurisdiction:i.jurisdiction},needsD1:i.needsD1,queues:v,services:A,signals:m,usesFlags:E!==void 0,usesNotifyFcm:p?.hasFcm??!1,usesNotifyWebPush:p?.hasWebPush??!1,workflows:y}},qe=e=>[...O,...Se].filter(([s,r])=>e[s]&&se[r]!==void 0).map(([,s])=>s);export{ue as a,Ke as i,qe as s};

package/dist/packem_shared/infer-bindings.d-CFxssIAC.d.mts

@@ -0,0 +1,480 @@
+import { SchemaIR, AgentIR, ContainerIR, QueueIR, ServiceBindingIR, 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.
+ *
+ * Three drivers are registered: Cloudflare (`cloudflare/cloudflare-driver.ts`)
+ * and celld (`celld/celld-driver.ts`), which ship toolchains, 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 (see `toolchainExecArgs`).
+ * 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 tool is a standalone binary installed on `PATH`, not a project
+   * dependency: run it directly. Going through the package manager would be
+   * wrong for it — `npx --` / `bun x` fetch an npm package of the same name
+   * when none is installed locally, which for a non-npm binary is somebody
+   * else's code.
+   */
+  onPath?: boolean;
+  /** The host CLI binary, e.g. `"wrangler"`. */
+  tool: string;
+}
+/** Neutral options for a deploy. */
+interface DeployRequest {
+  /** Host config file to deploy, when the flow uses a projected one (see {@link DeployDriver.projectConfig}). */
+  configPath?: string;
+  /** 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.
+ *
+ * `deploy` and `dev` are what make a target runnable. The secret and tail
+ * commands are optional on their own, because a runnable host can simply not
+ * have them — celld keeps configuration in plain `vars` and has no log tail —
+ * and the commands that need one say so rather than guessing a substitute.
+ */
+interface DriverToolchain {
+  /** The command that deploys the app. */
+  deploy: (request: DeployRequest) => ToolchainCommand;
+  /** The command that runs a local dev server. */
+  dev: (request: DevRequest) => ToolchainCommand;
+  /**
+   * Where `lunora dev` runs the worker. `"workerd"`: `wrangler dev`, or the
+   * Vite plugin's `@cloudflare/vite-plugin`, whichever flavor the project
+   * picks. `"own"`: the host's dev server ({@link DriverToolchain.dev}) on
+   * the projected config, always the standalone flavor — neither Vite nor a
+   * framework sidecar can serve the worker on that runtime.
+   */
+  readonly devServer: "own" | "workerd";
+  /**
+   * Whether `lunora deploy` builds and pushes container images itself
+   * (railpack, into the host's registry) before `deploy`. `false` when the
+   * host CLI builds each image from its Dockerfile during the deploy.
+   */
+  readonly prebuildsContainerImages: boolean;
+  /** The command that writes many secrets in one call, as a JSON object of name to value on stdin. Optional: hosts without it get one `secretPut` per key. */
+  secretBulk?: (request: SecretRequest) => ToolchainCommand;
+  /** The command that lists remote secret names, when the host has a secret store. */
+  secretList?: (request: SecretRequest) => ToolchainCommand;
+  /** The command that writes one secret, when the host has a secret store. Its value is passed on stdin, never argv. */
+  secretPut?: (request: SecretRequest) => ToolchainCommand;
+  /** The command that tails live logs, when the host has one. */
+  tail?: (request: TailRequest) => ToolchainCommand;
+}
+/** What a {@link DeployDriver.projectConfig} projection is for — a dev server may need a different source than a deploy. */
+type ProjectionPurpose = "deploy" | "dev";
+/**
+ * The result of {@link DeployDriver.projectConfig}: a plan, not yet on disk.
+ * The caller validates the request it is for (the toolchain's argv builder
+ * refuses unsupported options), then calls `write` — so a refused command
+ * changes nothing.
+ */
+interface ProjectedConfig {
+  /** Where the projection goes, to pass as the request's `configPath`. */
+  configPath: string;
+  /** Every key removed, as a dotted path (`observability`, `containers[0].rollout_step_percentage`). */
+  dropped: ReadonlyArray<string>;
+  /** Write the projection (and any build-artifact cleanup it planned). */
+  write: () => void;
+}
+/** 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;
+  /**
+   * Rewrite the project's wrangler config into the form this host's CLI
+   * accepts, and return the file to hand `deploy`/`dev` as `configPath`.
+   * Absent when the host reads the project's config as-is (Cloudflare).
+   *
+   * Needed because Lunora's reconcilers and templates write Cloudflare-only
+   * keys (`observability`, `limits`, …) that a Workers-compatible host with a
+   * strict config reader refuses outright. `dropped` names what was removed,
+   * so the caller can say so instead of silently deploying less than the
+   * config describes.
+   */
+  readonly projectConfig?: (projectRoot: string, purpose: ProjectionPurpose) => ProjectedConfig;
+  /**
+   * The host's command-line surface, or `undefined` for a host that has none.
+   * Pure: these build argv, they never spawn.
+   */
+  readonly toolchain?: DriverToolchain;
+}
+/**
+ * An invocation-scoped memo for project discovery. A CLI command creates one,
+ * threads it through every `discover*` / `inferLunoraBindings` call it makes,
+ * and clears it after anything rewrites the sources discovery reads (codegen).
+ * Deliberately not module-level: tests and long-lived processes never see a
+ * stale result.
+ */
+interface DiscoveryCache {
+  /** Drop every memoised result. */
+  clear: () => void;
+  /** Return the result memoised under `key`, computing it on first use. */
+  memo: <T>(key: string, compute: () => T) => T;
+}
+declare const createDiscoveryCache: () => DiscoveryCache;
+/** 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, with `v.optional(...)` and a
+   * nullable union unwrapped (metadata columns are usually optional), 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;
+  /**
+   * Data-residency jurisdiction declared via `defineSchema(...).jurisdiction("…")`.
+   * It pins the app's Durable Objects only; KV namespaces and R2 buckets carry
+   * their own jurisdiction, set when they are created.
+   */
+  jurisdiction?: SchemaIR["jurisdiction"];
+  /** 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 the schema facts, memoised on `cache` when one is given. */
+declare const discoverSchemaInfo: (projectRoot: string, schemaDirectory: string, cache?: DiscoveryCache) => DiscoverSchemaInfoResult;
+interface DurableObjectSpec {
+  binding: string;
+  className: string;
+}
+/**
+ * Canonical Durable Object class → binding name. wrangler requires the worker
+ * to export a class of this exact name, so detection keys on the class name.
+ */
+declare const DURABLE_OBJECT_BINDINGS: {
+  readonly LunoraDO: "SHARD";
+  readonly SchedulerDO: "SCHEDULER";
+  readonly SessionDO: "SESSION";
+  readonly ShardDO: "SHARD";
+  readonly ShardRegistryDO: "SHARD_REGISTRY";
+};
+type DurableObjectClass = keyof typeof DURABLE_OBJECT_BINDINGS;
+/**
+ * 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", "shardRegistry", "workflows"];
+/** One {@link GENERATED_CLASS_MODULES} entry. */
+type GeneratedClassModule = (typeof GENERATED_CLASS_MODULES)[number];
+/**
+ * The framework Durable Object each class module forwards, for the modules that
+ * carry one: codegen writes them off the same signal that gives the builder the
+ * matching method, so the module's existence means the composed entry exports
+ * the class.
+ */
+declare const GENERATED_MODULE_DURABLE_OBJECTS: Partial<Record<GeneratedClassModule, DurableObjectClass>>;
+/** The `_generated/` module codegen writes when `lunora.config` opts in to the merge. */
+declare const MERGED_DURABLE_OBJECTS_MODULE: "durableObjects";
+/**
+ * Whether the project merges its Durable Objects: codegen wrote the merge
+ * module. The one test the composed entry, binding inference and the export
+ * validator all ask — the same "module existence is the signal" rule the
+ * scheduler and registry modules follow.
+ */
+declare const isMergedProject: (generatedDirectory: string) => boolean;
+/** Whether `module` holds a class the merged class hosts — imported into it, never re-exported. */
+declare const isMergedRoleModule: (module: string) => boolean;
+/**
+ * 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";
+/**
+ * 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.
+ */
+type InferredContainer = 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 an `exports.<Class>`
+ * workflow 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 an `exports.<Class>` workflow 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 wrangler `exports`. */
+  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;
+  /**
+   * The schema's `.jurisdiction("…")`, when it declares one. Read by the binding
+   * hints whose resource takes its residency at creation (Artifacts), so the
+   * hint can name the jurisdiction to create it in.
+   */
+  jurisdiction?: SchemaInfo["jurisdiction"];
+  /** 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[];
+  /**
+   * Sibling Workers declared in `lunora.config` `services` → reconciled into
+   * `services[]` (plan 457). `undefined` when the declaration is unreadable, so
+   * reconcile leaves every entry alone rather than removing the owned ones.
+   */
+  services: ServiceBindingIR[] | undefined;
+  /** Human-readable provenance for each inferred binding / hint, for logging. */
+  signals: string[];
+  /** `@lunora/ai` is imported, `ctx.ai` read, or `env.AI` used → needs the `ai` Workers AI binding. */
+  usesAi: boolean;
+  /** `@lunora/bindings/ai-search` is value-imported or `ctx.aiSearch` read → self-describing `ai_search_namespaces` binding (`AI_SEARCH` on namespace `default`; auto-writeable). */
+  usesAiSearch: boolean;
+  /** `@lunora/bindings/analytics` is imported or `ctx.analytics` read → self-describing `analytics_engine_datasets` binding (auto-writeable). */
+  usesAnalytics: boolean;
+  /** `@lunora/bindings/analytics-sql` is value-imported or `ctx.analyticsSql` read → self-describing `analytics` binding (`{ binding: ANALYTICS_SQL }`; auto-writeable, wrangler >= 4.145.0). */
+  usesAnalyticsSql: boolean;
+  /**
+   * `ctx.artifacts` is read or `@lunora/bindings/artifacts` value-imported.
+   * Hint-only: the first repo `create()` against a missing namespace creates it
+   * UNRESTRICTED, and a namespace's jurisdiction can never change after that,
+   * so Lunora never writes the binding for you.
+   */
+  usesArtifacts: boolean;
+  /** `@lunora/auth` is imported (sessions may be D1- or `SessionDO`-backed). */
+  usesAuth: boolean;
+  /** `@lunora/browser` is imported or `ctx.browser` read → self-describing `browser` binding (auto-writeable). */
+  usesBrowser: boolean;
+  /** `@lunora/auth/cimd/workers` is imported → needs the `global_fetch_strictly_public` compatibility flag (no binding; `lunora doctor` checks it). */
+  usesCimdWorkers: boolean;
+  /** `lunora/flags.ts` declares a feature-flag provider (any OpenFeature provider — Flagship or custom). */
+  usesFlags: boolean;
+  /** `@lunora/hyperdrive` is imported or `ctx.sql` read (binding needs an un-mintable remote `id`; hint-only). */
+  usesHyperdrive: boolean;
+  /** `@lunora/bindings/images` is imported or `ctx.images` read → self-describing `images` binding (auto-writeable). */
+  usesImages: boolean;
+  /** `@lunora/bindings/kv` is imported or `ctx.kv` read (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). No `ctx.mail` helper exists, so only the import counts. */
+  usesMail: boolean;
+  /** `@lunora/notify` is imported or `ctx.notify` read (no binding; channel secrets ride `usesNotifyFcm` / `usesNotifyWebPush`). */
+  usesNotify: boolean;
+  /** `lunora/notify.ts` configures the `fcm` channel → the `FCM_*` secrets in `.dev.vars`. */
+  usesNotifyFcm: boolean;
+  /** `lunora/notify.ts` configures the `webPush` channel → the `VAPID_*` secrets in `.dev.vars`. */
+  usesNotifyWebPush: boolean;
+  /** `@lunora/payment/autumn` is imported → the Autumn secrets in `.dev.vars` (no binding). */
+  usesPaymentAutumn: boolean;
+  /** `@lunora/payment/creem` is imported → the Creem secrets in `.dev.vars` (no binding). */
+  usesPaymentCreem: boolean;
+  /** `@lunora/payment/dodopayments` is imported → the Dodo Payments secrets in `.dev.vars` (no binding). */
+  usesPaymentDodopayments: boolean;
+  /** `@lunora/payment/polar` is imported → the Polar secrets in `.dev.vars` (no binding). */
+  usesPaymentPolar: boolean;
+  /** `@lunora/payment` is imported or `ctx.payments` read (provider secrets must be set in `.dev.vars`; no binding). */
+  usesPayments: boolean;
+  /** `@lunora/payment/stripe` is imported → the Stripe secrets in `.dev.vars` (no binding). */
+  usesPaymentStripe: boolean;
+  /** `@lunora/bindings/pipelines` is value-imported or `ctx.pipelines` read (binding needs an un-mintable remote pipeline name; hint-only). */
+  usesPipelines: boolean;
+  /** `@lunora/bindings/r2sql` is value-imported or `ctx.r2sql` read (needs the `R2_SQL_*` secrets in `.dev.vars`; no binding). */
+  usesR2sql: boolean;
+  /** `@lunora/scheduler` is imported or `ctx.scheduler` read. */
+  usesScheduler: boolean;
+  /** `@lunora/storage` is imported or `ctx.storage` read under `lunora/` (R2 bucket binding name is user-defined). */
+  usesStorage: boolean;
+  /** `jsCodeTool` is imported from `@lunora/agent` in `lunora/` → self-describing `worker_loaders` binding (`LOADER`). */
+  usesWorkerLoader: boolean;
+  /** `@lunora/x402/pay` is imported or `ctx.x402` read — the agent-wallet pay rail signs from a Secrets Store binding paired with a spend policy (ActionCtx-only; hint-only). */
+  usesX402: 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;
+  /** Workflows declared in `lunora/workflows.ts` (exported or not — see {@link InferredWorkflow.exported}). */
+  workflows: InferredWorkflow[];
+}
+interface InferOptions {
+  /** Memoises the source scans, so one CLI invocation parses the project once. */
+  cache?: DiscoveryCache;
+  projectRoot: string;
+  /** Directories (relative to root) to scan. Defaults to `lunora` + `src`. */
+  scanDirs?: ReadonlyArray<string>;
+  /** Lunora source directory holding `schema.ts`. Defaults to `lunora`. */
+  schemaDir?: string;
+}
+/**
+ * Scan a Lunora project and report which Cloudflare bindings its code implies.
+ * Read-only: performs no writes. Binding provisioning is driven by the worker
+ * entry's Durable Object exports plus the schema's D1 need; capability imports
+ * surface as hints.
+ */
+declare const inferLunoraBindings: (options: InferOptions) => Promise<InferredBindings>;
+/**
+ * The secret sources a project uses — the {@link PACKAGE_SECRETS_REGISTRY} keys
+ * whose secrets it needs, derived from its already-resolved {@link InferredBindings}.
+ *
+ * This is the canonical bridge between binding inference and the
+ * `.dev.vars.example` scaffolding in `scaffold-dev-variables.ts`. The result is
+ * {@link FLAG_PACKAGES}' sources whose flag is `true` in `bindings` — in
+ * flag-name order — followed by the configured `@lunora/notify` channels
+ * ({@link NOTIFY_CHANNEL_SECRETS}), keeping only sources that carry secrets.
+ */
+declare const secretSourcesFromBindings: (bindings: InferredBindings) => string[];
+export { COMPOSED_WORKER_ENTRY as C, DeployDriver as D, GeneratedClassModule as G, InferredBindings as I, MERGED_DURABLE_OBJECTS_MODULE as M, ProjectionPurpose as P, SchemaInfo as S, ToolchainCommand as T, DiscoveryCache as a, DURABLE_OBJECT_BINDINGS as b, DeployRequest as c, DevRequest as d, DiscoverSchemaInfoResult as e, DriverToolchain as f, GENERATED_CLASS_MODULES as g, GENERATED_MODULE_DURABLE_OBJECTS as h, InferOptions as i, InferredAgent as j, InferredContainer as k, InferredWorkflow as l, ProjectedConfig as m, SecretRequest as n, TailRequest as o, createDiscoveryCache as p, discoverSchemaInfo as q, inferLunoraBindings as r, isMergedProject as s, isMergedRoleModule as t, secretSourcesFromBindings as u };