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

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

@@ -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 };

package/dist/packem_shared/serveJsonHandler-Dv0EdCb9.mjs

@@ -0,0 +1 @@
+import{headerValue as a}from"./ALLOW_FORWARDED_ENV-BUndghJx.mjs";const l=1e6,g=async t=>await new Promise((o,e)=>{const n=[];let i=0;t.on("data",c=>{if(i+=c.length,i>l){e(new Error("request body too large"));return}n.push(c)}),t.on("end",()=>{o(Buffer.concat(n).toString("utf8"))}),t.on("error",e)}),s=(t,o,e)=>{t.statusCode=o,t.setHeader("Content-Type","application/json; charset=utf-8"),t.end(JSON.stringify(e))},u=new Set(["none","same-origin","same-site"]),y=t=>{const o=a(t.headers["sec-fetch-site"]);if(o!==void 0)return u.has(o)?void 0:"cross-origin request rejected";const e=a(t.headers.origin);if(e===void 0||e==="null")return;let n;try{n=new URL(e).host.toLowerCase()}catch{return"invalid origin header"}return n===a(t.headers.host)?void 0:"cross-origin request rejected"},p=t=>{const o=(t.method??"GET").toUpperCase(),e=o!=="GET"&&o!=="HEAD",n=y(t);if(n!==void 0)return n;if(e&&!a(t.headers["content-type"])?.startsWith("application/json"))return"content-type must be application/json"},v=(t,o,e,n,i={})=>{(async()=>{try{const r=p(t);if(r!==void 0){s(o,403,{error:r,ok:!1});return}const d=t.method==="GET"?"":await g(t);let h;try{h=d===""?void 0:JSON.parse(d)}catch{s(o,400,{error:"invalid-json",ok:!1});return}const f=e({...i,body:h,method:t.method??"POST",projectRoot:n});s(o,f.status,f.body)}catch(r){s(o,500,{error:r instanceof Error?r.message:String(r),ok:!1})}})().catch(()=>{})};export{v as serveJsonHandler};

package/dist/packem_shared/streamContainerLogs-0nko1qpv.mjs

@@ -0,0 +1,2 @@
+import{Writable as D}from"node:stream";import{StringDecoder as N}from"node:string_decoder";const y="cloudflare-dev/",_=1500,b=async()=>{const{default:t}=await import("dockerode");return new t},C=t=>{if(!t.startsWith(y))return;const[a]=t.slice(y.length).split(":");return a!==void 0&&a.length>0?a:void 0},I=t=>{const a=new N("utf8");let c="";const o=r=>{t(r.endsWith("\r")?r.slice(0,-1):r)};return new D({final(r){c+=a.end(),c.length>0&&(o(c),c=""),r()},write(r,m,i){c+=a.write(r);const d=c.split(`
+`);c=d.pop()??"";for(const v of d)o(v);i()}})},T=t=>{const a=new Map(t.containers.map(e=>[e.className.toLowerCase(),e.exportName]));if(a.size===0)return{close:()=>{}};const c=t.pollIntervalMs??_,o=new Map;let r=!1,m=!1,i,d;const v=async()=>(d??=t.docker?Promise.resolve(t.docker):b(),d),p=async(e,s,f)=>{try{const n=await e.getContainer(s).logs({follow:!0,stderr:!0,stdout:!0,tail:"all",timestamps:!1});if(r){n.destroy();return}const l=I(w=>{t.onLine({level:"info",name:f,text:w})}),u=I(w=>{t.onLine({level:"error",name:f,text:w})});e.modem.demuxStream(n,l,u),n.on("end",()=>{l.end(),u.end(),o.delete(s)}),n.on("error",()=>{o.delete(s)}),o.set(s,n)}catch{}},L=async()=>{try{const s=await(await v()).listContainers({filters:{status:["running"]}});return m=!1,s}catch(e){m||(m=!0,t.onUnavailable?.(e instanceof Error?e.message:String(e)));return}},k=async(e,s)=>{const f=new Set;for(const n of s){const l=C(n.Image),u=l===void 0?void 0:a.get(l);u!==void 0&&(f.add(n.Id),o.has(n.Id)||await p(e,n.Id,u))}for(const[n,l]of o)f.has(n)||(l.destroy(),o.delete(n))},E=async()=>{if(r)return;const e=await L();e!==void 0&&await k(await v(),e)};let g=!1;const h=()=>{g||r||(g=!0,E().finally(()=>{g=!1}).catch(()=>{}))};return i=setInterval(h,c),i.unref(),h(),{close:()=>{r=!0,i&&(clearInterval(i),i=void 0);for(const[e,s]of o)s.destroy(),o.delete(e)}}};export{T as streamContainerLogs};

package/dist/packem_shared/wranglerToAlchemy-SDoS_XY0.mjs

@@ -0,0 +1,6 @@
+const o=e=>JSON.stringify(e),$=/^[A-Z_a-z][\w$]*$/u,d=e=>$.test(e),u=e=>d(e)?e:`binding_${e.replaceAll(/\W/gu,"_")}`,m=(e,s=u(e))=>{const n=d(e);return n&&s===e?`${e},`:`${n?e:o(e)}: ${s},`},g=e=>{const s=new Set;for(const n of e.migrations??[])for(const r of n.new_sqlite_classes??[])s.add(r);return s},v=(e,s,n,r,c)=>{for(const a of e.durable_objects?.bindings??[])if(!(a.name===void 0||a.class_name===void 0)){if(a.script_name!==void 0){c.push(`durable_objects.${a.name} (external script_name "${a.script_name}")`);continue}n.add("DurableObjectNamespace"),r.push(m(a.name,`DurableObjectNamespace(${o(a.name)}, { className: ${o(a.class_name)}, sqlite: ${String(s.has(a.class_name))} })`))}},h=(e,s)=>{for(const[n,r]of Object.entries(e.vars??{}))s.push(m(n,o(r)))},f=["ai","analytics_engine_datasets","assets","browser","containers","flagship","hyperdrive","images","pipelines","secrets_store_secrets","send_email","services","tail_consumers","vectorize","workflows"],w=(e,s)=>{for(const n of f){const r=e[n];r!==void 0&&(!Array.isArray(r)||r.length>0)&&s.push(n)}(e.queues?.consumers?.length??0)>0&&s.push("queues.consumers")},k=e=>{const s=e.name??"worker",n=[],r=new Set(["Worker"]),c=[],a=[],p=g(e),b=[{construct:"D1Database",entries:(e.d1_databases??[]).map(t=>({binding:t.binding,name:t.database_name})),nameKey:"name"},{construct:"R2Bucket",entries:(e.r2_buckets??[]).map(t=>({binding:t.binding,name:t.bucket_name})),nameKey:"name"},{construct:"KVNamespace",entries:(e.kv_namespaces??[]).map(t=>({binding:t.binding,name:t.binding})),nameKey:"title"},{construct:"Queue",entries:(e.queues?.producers??[]).map(t=>({binding:t.binding,name:t.queue})),nameKey:"name"}];for(const{construct:t,entries:l,nameKey:y}of b)for(const i of l)i.binding!==void 0&&(r.add(t),c.push(`const ${u(i.binding)} = await ${t}(${o(i.binding)}, { adopt: true, ${y}: ${o(i.name??i.binding)} });`),a.push(m(i.binding)));v(e,p,r,a,n),h(e,a),w(e,n);const _=["adopt: true,",a.length===0?void 0:`bindings: {
+        ${a.join(`
+        `)}
+    },`,e.compatibility_date===void 0?void 0:`compatibilityDate: ${o(e.compatibility_date)},`,e.compatibility_flags===void 0||e.compatibility_flags.length===0?void 0:`compatibilityFlags: ${o([...e.compatibility_flags])},`,e.triggers?.crons===void 0||e.triggers.crons.length===0?void 0:`crons: ${o([...e.triggers.crons])},`,e.main===void 0?void 0:`entrypoint: ${o(e.main)},`,`name: ${o(s)},`].filter(t=>t!==void 0);return{source:["// GENERATED by @lunora/config from wrangler.jsonc — do not edit.","// Re-generated on every `lunora deploy`; edit wrangler.jsonc instead.","",'import alchemy from "alchemy";',`import { ${[...r].toSorted((t,l)=>t.localeCompare(l)).join(", ")} } from "alchemy/cloudflare";`,"",`const app = await alchemy(${o(s)});`,"",...c.length===0?[]:[...c,""],`export const worker = await Worker(${o(s)}, {`,`    ${_.join(`
+    `)}`,"});","","await app.finalize();",""].join(`
+`),unsupported:n}};export{g as sqliteClasses,k as wranglerToAlchemy};

package/dist/packem_shared/write-atomic-9d9xs5ON.mjs

@@ -0,0 +1 @@
+import{runCodegen as c,CodegenDiagnosticError as a}from"@lunora/codegen";import{collectWranglerSecretVariables as i}from"./collectWranglerSecretVariables-D-usPfT8.mjs";import{isCodegenDisabled as s,CODEGEN_ENV as t}from"./CODEGEN_ENV-ZsCxV1kP.mjs";import{writeFileSync as m,renameSync as p,rmSync as d}from"node:fs";const g=r=>({apiSpec:r.apiSpec,lunoraDirectory:r.schemaDirectory??"lunora",projectRoot:r.projectRoot,wranglerVariables:i(r.projectRoot)}),y=r=>{if(s(process.env[t]))return[`codegen is off (${t}=0 / \`lunora dev --no-codegen\`) — the source was written but \`_generated/\` was NOT regenerated`];try{c(g(r))}catch(e){if(e instanceof a)return[e.message];throw e}return[]},S=(r,e)=>{const o=`${r}.lunora-tmp`;try{m(o,e,"utf8"),p(o,r)}catch(n){throw d(o,{force:!0}),n}};export{y as r,S as w};