alchemy 2.0.0-beta.25 → 2.0.0-beta.26

package/lib/Cloudflare/Workers/Worker.js

@@ -1,1690 +0,0 @@
-var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
-    if (typeof path === "string" && /^\.\.?\//.test(path)) {
-        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
-            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
-        });
-    }
-    return path;
-};
-import cloudflareRolldown from "@distilled.cloud/cloudflare-rolldown-plugin";
-import cloudflareVite from "@distilled.cloud/cloudflare-vite-plugin";
-import * as workers from "@distilled.cloud/cloudflare/workers";
-import * as zones from "@distilled.cloud/cloudflare/zones";
-import * as Context from "effect/Context";
-import * as Data from "effect/Data";
-import * as Effect from "effect/Effect";
-import * as FileSystem from "effect/FileSystem";
-import * as Layer from "effect/Layer";
-import * as Option from "effect/Option";
-import * as Path from "effect/Path";
-import * as Queue from "effect/Queue";
-import * as Redacted from "effect/Redacted";
-import * as Schedule from "effect/Schedule";
-import * as Stream from "effect/Stream";
-import * as Socket from "effect/unstable/socket/Socket";
-import { createRequire } from "node:module";
-import path from "node:path";
-import { pathToFileURL } from "node:url";
-import Sonda from "sonda/rolldown";
-import { AlchemyContext } from "../../AlchemyContext.js";
-import * as Artifacts from "../../Artifacts.js";
-import * as Binding from "../../Binding.js";
-import { isArtifacts as isArtifactsBinding, } from "../Artifacts/Artifacts.js";
-import { hashDirectory } from "../../Build/Memo.js";
-import * as Bundle from "../../Bundle/Bundle.js";
-import { findCwdForBundle } from "../../Bundle/TempRoot.js";
-import { isResolved } from "../../Diff.js";
-import * as Output from "../../Output.js";
-import { createPhysicalName } from "../../PhysicalName.js";
-import { Platform, } from "../../Platform.js";
-import * as Provider from "../../Provider.js";
-import { Resource } from "../../Resource.js";
-import { Self } from "../../Self.js";
-import * as Serverless from "../../Serverless/index.js";
-import { Stack } from "../../Stack.js";
-import { CloudflareEnvironment } from "../CloudflareEnvironment.js";
-import { D1Database } from "../D1/D1Database.js";
-import { fromCloudflareFetcher } from "../Fetcher.js";
-import { SidecarLive } from "../Local/Sidecar.js";
-import { CloudflareLogs } from "../Logs.js";
-import { isAssets, readAssets, uploadAssets, } from "./Assets.js";
-import cloudflare_workers from "./cloudflare_workers.js";
-import { isDurableObjectExport, isDurableObjectNamespaceLike, } from "./DurableObjectNamespace.js";
-import { workersHttpHandler } from "./HttpServer.js";
-import { LocalWorkerProvider } from "./LocalWorkerProvider.js";
-import { Request } from "./Request.js";
-import { makeRpcStub } from "./Rpc.js";
-import { isWorkflowExport } from "./Workflow.js";
-const WorkerTypeId = "Cloudflare.Worker";
-export const isWorker = (value) => typeof value === "object" &&
-    value !== null &&
-    "Type" in value &&
-    value.Type === WorkerTypeId;
-export class WorkerEnvironment extends Context.Service()("Cloudflare.Workers.WorkerEnvironment") {
-}
-export const WorkerEnvironmentLive = Layer.effect(WorkerEnvironment, cloudflare_workers.pipe(Effect.map((m) => m.env)));
-export class ExecutionContext extends Context.Service()("Cloudflare.Workers.ExecutionContext") {
-}
-export const isWorkerEvent = (value) => value?.kind === "Cloudflare.Workers.WorkerEvent";
-export const ExportedHandlerMethods = [
-    "fetch",
-    "tail",
-    "trace",
-    "tailStream",
-    "scheduled",
-    "test",
-    "email",
-    "queue",
-];
-/**
- * A Cloudflare Worker host with deploy-time binding support and runtime export
- * collection.
- *
- * A Worker follows a two-phase pattern. The outer `Effect.gen` runs at
- * deploy time to bind resources (KV, R2, Durable Objects, etc.). It returns
- * an object whose properties are the Worker's runtime handlers — `fetch` for
- * HTTP requests and any additional RPC methods.
- *
- * ```typescript
- * Effect.gen(function* () {
- *   // Phase 1: bind resources (runs at deploy time)
- *   const kv = yield* Cloudflare.KVNamespace.bind(MyKV);
- *
- *   return {
- *     // Phase 2: runtime handlers (runs on each request)
- *     fetch: Effect.gen(function* () {
- *       const value = yield* kv.get("key");
- *       return HttpServerResponse.text(value ?? "not found");
- *     }),
- *   };
- * })
- * ```
- *
- * There are three ways to define a Worker, from simplest to most
- * flexible. See the {@link https://alchemy.run/concepts/platform | Platform concept}
- * page for the full explanation.
- *
- * - **Async** — plain `async fetch` handler, no Effect runtime in the bundle.
- * - **Effect** — Effect implementation passed directly, single file.
- * - **Layer** — class and `.make()` in a single file; Rolldown tree-shakes `.make()` from consumers.
- *
- * @section Async Workers
- * You don't have to use Effect for your runtime code. If you create
- * a Worker resource with `main` pointing at a file but provide no
- * `Effect.gen` implementation, Alchemy bundles and deploys that file
- * as-is. Your handler is a plain `async fetch` — no Effect runtime
- * is included in the bundle.
- *
- * Use the `bindings` prop to declare which resources are available
- * at runtime, and `Cloudflare.InferEnv` to extract a fully typed
- * `env` object from those bindings.
- *
- * See the {@link https://alchemy.run/guides/async-worker | Async Workers Guide}
- * for a comprehensive walkthrough of all binding types (R2, D1,
- * Durable Objects, Assets, and more).
- *
- * @example Defining an async Worker in your stack
- * ```typescript
- * // alchemy.run.ts
- * const db = yield* Cloudflare.D1Database("DB");
- * const bucket = yield* Cloudflare.R2Bucket("Bucket");
- *
- * export type WorkerEnv = Cloudflare.InferEnv<typeof Worker>;
- *
- * export const Worker = Cloudflare.Worker("Worker", {
- *   main: "./src/worker.ts",
- *   bindings: { db, bucket },
- * });
- * ```
- *
- * @example Writing the async handler
- * ```typescript
- * // src/worker.ts
- * import type { WorkerEnv } from "../alchemy.run.ts";
- *
- * export default {
- *   async fetch(request: Request, env: WorkerEnv) {
- *     if (request.method === "GET") {
- *       const object = await env.bucket.get("key");
- *       return new Response(object?.body ?? null);
- *     }
- *     return new Response("Not Found", { status: 404 });
- *   },
- * };
- * ```
- *
- * @section Effect Workers
- * Pass the Effect implementation as the third argument. This is the
- * simplest Effect-based approach — everything lives in one file.
- * Convenient for standalone Workers that don't need to be referenced
- * by other Workers.
- *
- * @example Worker Effect
- * ```typescript
- * export default class MyWorker extends Cloudflare.Worker<MyWorker>()(
- *   "MyWorker",
- *   { main: import.meta.path },
- *   Effect.gen(function* () {
- *     // init: bind resources
- *     const kv = yield* Cloudflare.KVNamespace.bind(MyKV);
- *
- *     return {
- *       // runtime: use them
- *       fetch: Effect.gen(function* () {
- *         const value = yield* kv.get("key");
- *         return HttpServerResponse.text(value ?? "not found");
- *       }),
- *     };
- *   }),
- * ) {}
- * ```
- *
- * @section Worker Layer
- * When two Workers need to reference each other (e.g. WorkerA calls
- * WorkerB and vice versa), or you simply want optimal tree-shaking,
- * define the Worker class separately from its `.make()` call. The
- * class is a lightweight identifier; `.make()` provides the runtime
- * implementation as an `export default`. Rolldown treats `.make()`
- * as pure, so any Worker that imports the class to bind it will not
- * pull in the `.make()` dependencies — the bundler tree-shakes
- * them away entirely.
- *
- * The class and `.make()` can live in the same file. This is the
- * same pattern used by `Container` and `DurableObjectNamespace`,
- * and is recommended for any cross-Worker or cross-DO bindings.
- *
- * @example Worker Layer (class + .make() in one file)
- * ```typescript
- * // src/WorkerB.ts
- * export default class WorkerB extends Cloudflare.Worker<WorkerB>()(
- *   "WorkerB",
- *   { main: import.meta.path },
- * ) {}
- *
- * export default WorkerB.make(
- *   Effect.gen(function* () {
- *     // init: bind resources
- *     const kv = yield* Cloudflare.KVNamespace.bind(MyKV);
- *
- *     return {
- *       // runtime: use them
- *       greet: (name: string) =>
- *         Effect.gen(function* () {
- *           yield* kv.put("last-greeted", name);
- *           return `Hello ${name}`;
- *         }),
- *     };
- *   }),
- * );
- * ```
- *
- * @example Binding a Worker Layer from another Worker
- * ```typescript
- * // src/WorkerA.ts — imports WorkerB; bundler tree-shakes .make()
- * import WorkerB from "./WorkerB.ts";
- *
- * export default class WorkerA extends Cloudflare.Worker<WorkerA>()(
- *   "WorkerA",
- *   { main: import.meta.path },
- *   Effect.gen(function* () {
- *     const b = yield* Cloudflare.Worker.bind(WorkerB);
- *     return {
- *       fetch: Effect.gen(function* () {
- *         return yield* b.greet("world");
- *       }),
- *     };
- *   }),
- * ) {}
- * ```
- *
- * @section Configuration
- * The props object controls compatibility flags, static assets, and
- * build options. These are evaluated at deploy time.
- *
- * @example Enabling Node.js compatibility
- * ```typescript
- * {
- *   main: import.meta.path,
- *   compatibility: {
- *     flags: ["nodejs_compat"],
- *     date: "2026-03-17",
- *   },
- * }
- * ```
- *
- * @example Serving static assets
- * ```typescript
- * {
- *   main: import.meta.path,
- *   assets: "./public",
- * }
- * ```
- *
- * @section R2 Bucket
- * Bind an R2 bucket in the init phase with `Cloudflare.R2Bucket.bind`.
- * The returned handle exposes `get`, `put`, `delete`, and `list`
- * methods you can call in your runtime handlers.
- *
- * @example Binding and using R2
- * ```typescript
- * // init
- * const bucket = yield* Cloudflare.R2Bucket.bind(MyBucket);
- *
- * return {
- *   fetch: Effect.gen(function* () {
- *     const request = yield* HttpServerRequest;
- *     const key = request.url.split("/").pop()!;
- *
- *     if (request.method === "GET") {
- *       const object = yield* bucket.get(key);
- *       return object
- *         ? HttpServerResponse.text(yield* object.text())
- *         : HttpServerResponse.empty({ status: 404 });
- *     }
- *
- *     yield* bucket.put(key, request.stream);
- *     return HttpServerResponse.empty({ status: 201 });
- *   }),
- * };
- * ```
- *
- * @section KV Namespace
- * Bind a KV namespace with `Cloudflare.KVNamespace.bind`. KV provides
- * eventually-consistent, low-latency key-value reads replicated
- * globally across Cloudflare's edge.
- *
- * @example Binding and using KV
- * ```typescript
- * // init
- * const kv = yield* Cloudflare.KVNamespace.bind(MyKV);
- *
- * return {
- *   fetch: Effect.gen(function* () {
- *     const value = yield* kv.get("my-key");
- *     return HttpServerResponse.text(value ?? "not found");
- *   }),
- * };
- * ```
- *
- * @section D1 Database
- * Bind a D1 database with `Cloudflare.D1Connection.bind`. D1 is a
- * serverless SQLite database — use `prepare` to build parameterized
- * queries and `all`, `first`, or `run` to execute them.
- *
- * @example Binding and querying D1
- * ```typescript
- * // init
- * const db = yield* Cloudflare.D1Connection.bind(MyDB);
- *
- * return {
- *   fetch: Effect.gen(function* () {
- *     const results = yield* db
- *       .prepare("SELECT * FROM users WHERE id = ?")
- *       .bind(userId)
- *       .all();
- *     return yield* HttpServerResponse.json(results);
- *   }),
- * };
- * ```
- *
- * @section Durable Objects
- * Yield a `DurableObjectNamespace` class in the init phase to get a
- * namespace handle. Call `getByName` or `getById` to get a typed RPC
- * stub, then call its methods from your runtime handlers.
- *
- * @example Using a Durable Object
- * ```typescript
- * // init
- * const counters = yield* Counter;
- *
- * return {
- *   fetch: Effect.gen(function* () {
- *     const counter = counters.getByName("user-123");
- *     const value = yield* counter.increment();
- *     return HttpServerResponse.text(String(value));
- *   }),
- * };
- * ```
- *
- * @section Containers
- * Containers run long-lived processes alongside Durable Objects. Bind
- * one with `Cloudflare.Container.bind` and start it with
- * `Cloudflare.start`. You can call typed methods on the running
- * container or make HTTP requests to its exposed ports.
- *
- * @example Binding and starting a Container
- * ```typescript
- * // init (inside a DurableObjectNamespace)
- * const sandbox = yield* Cloudflare.Container.bind(Sandbox);
- *
- * return Effect.gen(function* () {
- *   const container = yield* Cloudflare.start(sandbox);
- *
- *   return {
- *     exec: (cmd: string) => container.exec(cmd),
- *     fetch: Effect.gen(function* () {
- *       const { fetch } = yield* container.getTcpPort(3000);
- *       const res = yield* fetch(HttpClientRequest.get("http://container/"));
- *       return HttpServerResponse.fromClientResponse(res);
- *     }),
- *   };
- * });
- * ```
- *
- * @section Dynamic Workers
- * `DynamicWorkerLoader` lets you spin up ephemeral Workers at runtime
- * from inline JavaScript modules. This is useful for sandboxing
- * user-provided code or running untrusted scripts in isolation.
- *
- * @example Loading a dynamic Worker
- * ```typescript
- * // init
- * const loader = yield* Cloudflare.DynamicWorkerLoader("Loader");
- *
- * return {
- *   fetch: Effect.gen(function* () {
- *     const worker = loader.load({
- *       compatibilityDate: "2026-01-28",
- *       mainModule: "worker.js",
- *       modules: {
- *         "worker.js": `export default {
- *           async fetch(req) { return new Response("sandboxed"); }
- *         }`,
- *       },
- *     });
- *
- *     const res = yield* worker.fetch(
- *       HttpClientRequest.get("https://worker/"),
- *     );
- *     return HttpServerResponse.fromClientResponse(res);
- *   }),
- * };
- * ```
- */
-export const Worker = Platform(WorkerTypeId, {
-    onCreate: Effect.fnUntraced(function* (resource, props) {
-        if (props.bindings) {
-            for (const bindingName in props.bindings) {
-                // @ts-expect-error
-                const bindingEff = props.bindings?.[bindingName];
-                const binding = Effect.isEffect(bindingEff)
-                    ? yield* bindingEff
-                    : bindingEff;
-                const bindingMeta = isAssets(binding)
-                    ? {
-                        type: "assets",
-                        name: bindingName,
-                    }
-                    : isArtifactsBinding(binding)
-                        ? {
-                            type: "artifacts",
-                            name: bindingName,
-                            namespace: binding.namespace,
-                        }
-                        : isDurableObjectNamespaceLike(binding)
-                            ? {
-                                type: "durable_object_namespace",
-                                name: bindingName,
-                                className: binding.className ?? binding.name,
-                            }
-                            : binding.Type === "Cloudflare.D1Database"
-                                ? {
-                                    type: "d1",
-                                    id: binding.databaseId,
-                                    name: bindingName,
-                                }
-                                : binding.Type === "Cloudflare.R2Bucket"
-                                    ? {
-                                        type: "r2_bucket",
-                                        name: bindingName,
-                                        bucketName: binding.bucketName,
-                                        jurisdiction: binding.jurisdiction.pipe(Output.map((jurisdiction) => jurisdiction === "default" ? undefined : jurisdiction)),
-                                    }
-                                    : binding.Type === "Cloudflare.KVNamespace"
-                                        ? {
-                                            type: "kv_namespace",
-                                            name: bindingName,
-                                            namespaceId: binding.namespaceId,
-                                        }
-                                        : binding.Type === "Cloudflare.Queue"
-                                            ? {
-                                                type: "queue",
-                                                name: bindingName,
-                                                queueName: binding.queueName,
-                                            }
-                                            : // TODO(sam): handle others
-                                                undefined;
-                if (bindingMeta) {
-                    yield* resource.bind `${bindingName}`({
-                        bindings: [bindingMeta],
-                    });
-                }
-                else {
-                    return yield* Effect.die(`Unknown binding type: ${bindingName}`);
-                }
-            }
-        }
-    }),
-    createExecutionContext: (id) => {
-        const listeners = [];
-        const exports = {};
-        const env = {};
-        const ctx = {
-            Type: WorkerTypeId,
-            id,
-            env,
-            get: (key) => Effect.serviceOption(WorkerEnvironment).pipe(Effect.map(Option.getOrUndefined), Effect.flatMap((env) => env
-                ? Effect.succeed(env[key])
-                : Effect.die("WorkerEnvironment not found")), Effect.flatMap((value) => value
-                ? Effect.succeed(value)
-                : Effect.die(`Environment variable '${key}' not found`)), Effect.map((json) => {
-                try {
-                    const value = JSON.parse(json);
-                    // The `set` path serializes Redacted values as
-                    // `{_tag: "Redacted", value: ...}`. After JSON.parse the
-                    // result is a plain object — `Redacted.isRedacted` would
-                    // always return `false` on it — so detect the marker shape
-                    // and rebuild the Redacted wrapper. Plain values pass
-                    // through unchanged.
-                    if (value !== null &&
-                        typeof value === "object" &&
-                        value._tag === "Redacted" &&
-                        "value" in value) {
-                        return Redacted.make(value.value);
-                    }
-                    return value;
-                }
-                catch {
-                    return json;
-                }
-            })),
-            set: (id, output) => Effect.sync(() => {
-                const key = id.replaceAll(/[^a-zA-Z0-9]/g, "_");
-                // Preserve `Redacted`-ness across the Output → env → Cloudflare
-                // binding boundary so the put-worker loop can deploy secrets via
-                // `secret_text` instead of leaking them as `plain_text`. The JSON
-                // payload still carries the `{_tag: "Redacted", …}` marker so the
-                // runtime `get` accessor can rebuild the wrapper after Cloudflare
-                // hands the binding back as a plain string.
-                env[key] = output.pipe(Output.map((value) => Redacted.isRedacted(value)
-                    ? Redacted.make(JSON.stringify({
-                        _tag: "Redacted",
-                        value: Redacted.value(value),
-                    }))
-                    : JSON.stringify(value)));
-                return key;
-            }),
-            serve: (handler) => ctx.listen(workersHttpHandler(handler)),
-            listen: ((handler) => Effect.sync(() => Effect.isEffect(handler)
-                ? listeners.push(handler)
-                : listeners.push(Effect.succeed(handler)))),
-            export: (name, value) => Effect.sync(() => {
-                exports[name] = value;
-            }),
-            exports: Effect.gen(function* () {
-                const handlers = yield* Effect.all(listeners, {
-                    concurrency: "unbounded",
-                });
-                const services = yield* Effect.context();
-                const handle = (type) => (request, env, context) => {
-                    const event = {
-                        kind: "Cloudflare.Workers.WorkerEvent",
-                        type,
-                        input: request,
-                        env,
-                        context,
-                    };
-                    for (const handler of handlers) {
-                        const eff = handler(event);
-                        if (Effect.isEffect(eff)) {
-                            return eff.pipe(Effect.provideContext(services), Effect.provide(Layer.succeed(ExecutionContext, context)), Effect.runPromise);
-                        }
-                    }
-                    return Promise.reject(new Error("No event handler found"));
-                };
-                return {
-                    ...exports,
-                    default: Object.fromEntries(ExportedHandlerMethods.map((method) => [method, handle(method)])),
-                };
-            }),
-        };
-        return ctx;
-    },
-});
-export const bindWorker = Effect.fnUntraced(function* (workerEff) {
-    const worker = Effect.isEffect(workerEff) ? yield* workerEff : workerEff;
-    const self = yield* Worker;
-    yield* self.bind `${worker}`({
-        bindings: [
-            {
-                type: "service",
-                name: worker.LogicalId,
-                service: worker.workerName,
-            },
-        ],
-    });
-    const workerBinding = WorkerEnvironment.asEffect().pipe(Effect.map((env) => env[worker.LogicalId]));
-    const fetcher = workerBinding.pipe(Effect.map(fromCloudflareFetcher));
-    // TODO(sam): update makeRpcStub to support lazily evaluating the Effect<Fetcher>
-    return makeRpcStub(fetcher);
-});
-export class BindWorkerPolicy extends Binding.Policy()("Cloudflare.Worker.Bind") {
-}
-export const BindWorkerPolicyLive = BindWorkerPolicy.layer.succeed(Effect.fn(function* (host, worker) {
-    if (isWorker(host)) {
-        yield* host.bind `${worker}`({
-            bindings: [
-                {
-                    type: "service",
-                    name: worker.LogicalId,
-                    service: worker.workerName,
-                },
-            ],
-        });
-    }
-    else {
-        return yield* Effect.die(new Error(`BindWorkerPolicy does not support runtime '${host.Type}'`));
-    }
-}));
-class MissingDurableObjectNamespaces extends Data.TaggedError("MissingDurableObjectNamespaces") {
-}
-function bumpMigrationTagVersion(oldTag) {
-    if (!oldTag)
-        return undefined;
-    const version = oldTag.match(/^(alchemy:)?v(\d+)$/)?.[2];
-    if (!version)
-        return "alchemy:v1";
-    return `alchemy:v${parseInt(version, 10) + 1}`;
-}
-function getDurableObjectBindings(bindings, workerName) {
-    return bindings.flatMap((binding) => (binding.data.bindings ?? []).flatMap((item) => item.type === "durable_object_namespace" &&
-        "className" in item &&
-        item.className &&
-        (!("scriptName" in item) ||
-            !item.scriptName ||
-            item.scriptName === workerName)
-        ? [
-            {
-                logicalId: binding.sid,
-                bindingName: item.name,
-                className: item.className,
-            },
-        ]
-        : []));
-}
-function getDurableObjectTagMap(tags) {
-    return Object.fromEntries(tags.flatMap((tag) => {
-        if (!tag.startsWith("alchemy:do:")) {
-            return [];
-        }
-        const parts = tag.split(":");
-        const logicalId = parts[2];
-        const className = parts.slice(3).join(":");
-        return logicalId && className ? [[logicalId, className]] : [];
-    }));
-}
-const selectLayer = (input) => Layer.unwrap(AlchemyContext.useSync((context) => context.dev ? input.dev() : input.live()));
-export const WorkerProvider = () => selectLayer({
-    live: LiveWorkerProvider,
-    dev: () => Layer.provide(LocalWorkerProvider(), SidecarLive),
-});
-export const LiveWorkerProvider = () => Provider.effect(Worker, Effect.gen(function* () {
-    const fs = yield* FileSystem.FileSystem;
-    const path = yield* Path.Path;
-    const { accountId } = yield* CloudflareEnvironment;
-    const virtualEntryPlugin = yield* Bundle.virtualEntryPlugin;
-    const stack = yield* Stack;
-    const createScriptSubdomain = yield* workers.createScriptSubdomain;
-    const createScriptTail = yield* workers.createScriptTail;
-    const deleteScript = yield* workers.deleteScript;
-    const deleteScriptTail = yield* workers.deleteScriptTail;
-    const getScriptSubdomain = yield* workers.getScriptSubdomain;
-    const getScriptSettings = yield* workers.getScriptScriptAndVersionSetting;
-    const getSubdomain = yield* workers.getSubdomain;
-    const listScripts = yield* workers.listScripts;
-    const putScript = yield* workers.putScript;
-    const putDomain = yield* workers.putDomain;
-    const listDomains = yield* workers.listDomains;
-    const deleteDomain = yield* workers.deleteDomain;
-    const listZones = yield* zones.listZones;
-    const telemetry = yield* CloudflareLogs;
-    // TODO(sam): figure out why the later one from workerd breaks
-    const defaultCompatibilityDate = "2026-03-17";
-    // const defaultCompatibilityDate = yield* Effect.promise(() =>
-    //   // @ts-expect-error no types for workerd
-    //   import("workerd").then((m) => m.compatibilityDate as string),
-    // );
-    const getAccountSubdomain = (accountId) => getSubdomain({
-        accountId,
-    }).pipe(Effect.map((result) => result.subdomain));
-    const setWorkerSubdomain = (name, enabled) => createScriptSubdomain({
-        accountId,
-        scriptName: name,
-        enabled,
-    });
-    const createWorkerName = (id, name) => name
-        ? Effect.succeed(name)
-        : createPhysicalName({
-            id,
-            maxLength: 54,
-        }).pipe(Effect.map((name) => name.toLowerCase()));
-    // Convert non-ASCII hostnames (emoji, IDN, etc.) to punycode so the
-    // Cloudflare API receives the form it stores domains in. `new URL(...)`
-    // does IDNA via WHATWG URL parsing — `📦.alchemy.run` → `xn--5z8h.alchemy.run`.
-    const toPunycode = (hostname) => {
-        try {
-            return new URL(`https://${hostname}`).hostname;
-        }
-        catch {
-            return hostname;
-        }
-    };
-    const normalizeDomains = (domain) => domain === undefined
-        ? []
-        : Array.from(new Set((Array.isArray(domain) ? domain : [domain]).map(toPunycode)));
-    /**
-     * Infer the Cloudflare Zone ID for a given hostname by listing the
-     * account's zones and matching the hostname against each zone's name —
-     * walking up the DNS label hierarchy until a match is found.
-     */
-    const inferZoneIdForHostname = (hostname, zoneCache) => Effect.gen(function* () {
-        const cached = zoneCache.get(hostname);
-        if (cached)
-            return cached;
-        const zoneList = yield* listZones({}).pipe(Effect.map((response) => response.result ?? []));
-        for (const zone of zoneList) {
-            zoneCache.set(zone.name, zone.id);
-        }
-        const parts = hostname.split(".");
-        for (let i = 0; i < parts.length - 1; i++) {
-            const candidate = parts.slice(i).join(".");
-            const match = zoneList.find((z) => z.name === candidate);
-            if (match) {
-                zoneCache.set(hostname, match.id);
-                return match.id;
-            }
-        }
-        return yield* Effect.die(`Could not infer Cloudflare Zone for hostname "${hostname}". ` +
-            "Ensure the parent zone exists in this account.");
-    });
-    const reconcileDomains = (scriptName, desired, _previous) => Effect.gen(function* () {
-        // Always query the live state of domains attached to *this*
-        // Worker rather than trusting `_previous` from local state.
-        // State may have been wiped, populated by another machine, or
-        // simply be out of date. Without this we PUT domains that are
-        // already registered to this same Worker and Cloudflare
-        // returns a confusing "hostname already in use" error.
-        const liveAll = yield* listDomains({
-            accountId,
-            service: scriptName,
-        }).pipe(Effect.map((r) => (r.result ?? []).flatMap((d) => d.id && d.hostname && d.zoneId
-            ? [
-                {
-                    id: d.id,
-                    hostname: d.hostname,
-                    zoneId: d.zoneId,
-                    service: d.service ?? undefined,
-                },
-            ]
-            : [])), Effect.catch(() => Effect.succeed([])));
-        const desiredSet = new Set(desired);
-        const liveByHostname = new Map(liveAll.map((d) => [d.hostname, d]));
-        // Detach what's no longer wanted. Use the live list so we
-        // don't try to delete domains we no longer track.
-        const toRemove = liveAll.filter((d) => !desiredSet.has(d.hostname));
-        yield* Effect.all(toRemove.map((d) => deleteDomain({ accountId, domainId: d.id }).pipe(Effect.catchTag("DomainNotFound", () => Effect.void))), { concurrency: "unbounded" });
-        if (desired.length === 0)
-            return [];
-        const zoneCache = new Map();
-        // Attach `hostname` to this Worker. Skip the PUT entirely if
-        // the hostname is already attached to *this* Worker — that's a
-        // no-op for Cloudflare and avoids the "already in use" 409.
-        // If it's attached to a *different* Worker, refuse with a
-        // clear message rather than silently re-routing traffic.
-        const attachDomain = Effect.fnUntraced(function* (hostname) {
-            const live = liveByHostname.get(hostname);
-            if (live) {
-                return {
-                    hostname: live.hostname,
-                    id: live.id,
-                    zoneId: live.zoneId,
-                };
-            }
-            // Not attached to this Worker — but it could still belong
-            // to another Worker. Check before we try to PUT so we can
-            // emit a helpful error instead of the raw 409.
-            const otherOwner = yield* listDomains({
-                accountId,
-                hostname,
-            }).pipe(Effect.map((r) => (r.result ?? []).find((d) => d.hostname === hostname && d.service !== scriptName)), Effect.catch(() => Effect.succeed(undefined)));
-            if (otherOwner?.id) {
-                return yield* Effect.die(new Error(`Cannot attach hostname '${hostname}' to Worker '${scriptName}': ` +
-                    `it is already attached to Worker '${otherOwner.service ?? "<unknown>"}'. ` +
-                    `Detach it from that Worker first, or pick a different hostname.`));
-            }
-            const zoneId = yield* inferZoneIdForHostname(hostname, zoneCache);
-            const res = yield* putDomain({
-                accountId,
-                hostname,
-                service: scriptName,
-                zoneId,
-            });
-            return {
-                hostname,
-                id: res.id ?? "",
-                zoneId: res.zoneId ?? zoneId,
-            };
-        });
-        const applied = yield* Effect.all(desired.map(attachDomain), { concurrency: "unbounded" });
-        return applied;
-    });
-    const createAlchemyWorkerTags = (id) => [
-        `alchemy:stack:${stack.name}`,
-        `alchemy:stage:${stack.stage}`,
-        `alchemy:id:${id}`,
-    ];
-    const hasAlchemyWorkerTags = (id, tags) => {
-        const actualTags = new Set(tags ?? []);
-        return createAlchemyWorkerTags(id).every((tag) => actualTags.has(tag));
-    };
-    const getDurableObjectNamespaces = (bindings) => {
-        const namespaces = Object.fromEntries((bindings ?? []).flatMap((binding) => binding.type === "durable_object_namespace" &&
-            binding.className &&
-            binding.namespaceId
-            ? [[binding.className, binding.namespaceId]]
-            : []));
-        return namespaces;
-    };
-    const getExpectedDurableObjectClassNames = (bindings) => Array.from(new Set(bindings?.flatMap((binding) => binding.type === "durable_object_namespace" && binding.className
-        ? [binding.className]
-        : []) ?? []));
-    const getWorkerSettingsWithDurableObjects = Effect.fnUntraced(function* (scriptName, expectedClassNames) {
-        return yield* getScriptSettings({
-            accountId,
-            scriptName,
-        }).pipe(Effect.map((settings) => {
-            const namespaces = getDurableObjectNamespaces(settings.bindings);
-            const missing = expectedClassNames.filter((className) => !namespaces[className]);
-            if (missing.length > 0) {
-                return Effect.fail(new MissingDurableObjectNamespaces({
-                    scriptName,
-                    expected: missing,
-                }));
-            }
-            return Effect.succeed({
-                settings,
-                durableObjectNamespaces: namespaces,
-            });
-        }), Effect.flatten, Effect.retry({
-            while: (error) => error._tag === "MissingDurableObjectNamespaces",
-            schedule: Schedule.exponential(100).pipe(Schedule.both(Schedule.recurs(20))),
-        }));
-    });
-    const prepareAssets = Effect.fnUntraced(function* (assets) {
-        if (!assets) {
-            return undefined;
-        }
-        if (typeof assets === "object" &&
-            "path" in assets &&
-            "hash" in assets) {
-            return yield* readAssets({
-                directory: assets.path,
-                config: assets.config,
-            });
-        }
-        // Handle string path or AssetsProps
-        return yield* readAssets(typeof assets === "string" ? { directory: assets } : assets);
-    });
-    const getCompatibility = (props) => ({
-        compatibilityDate: props.compatibility?.date ?? defaultCompatibilityDate,
-        compatibilityFlags: props.compatibility?.flags
-            ? [
-                ...props.compatibility.flags,
-                ...(props.isExternal ? [] : ["nodejs_compat"]),
-            ].filter((value, index, self) => self.indexOf(value) === index)
-            : props.isExternal
-                ? []
-                : ["nodejs_compat"],
-    });
-    const prepareBundle = (id, props) => Effect.gen(function* () {
-        const main = yield* fs.realPath(props.main);
-        const cwd = yield* findCwdForBundle(main);
-        const { compatibilityDate, compatibilityFlags } = getCompatibility(props);
-        const buildBundle = (plugins) => Bundle.build({
-            input: main,
-            cwd,
-            plugins: [
-                cloudflareRolldown({ compatibilityDate, compatibilityFlags }),
-                plugins,
-                ...(props.build?.metafile ? [Sonda({ open: false })] : []),
-            ],
-            checks: {
-                // Suppress unresolved import warnings for unrelated AWS packages
-                unresolvedImport: false,
-            },
-        }, {
-            format: "esm",
-            sourcemap: "hidden",
-            minify: true,
-            keepNames: true,
-            dir: `.alchemy/bundles/${id}`,
-        }, { pure: props.build?.pure });
-        if (props.isExternal) {
-            const bundle = yield* buildBundle();
-            return bundle;
-        }
-        const exportMap = (props.exports ?? {});
-        const allExportNames = Object.keys(exportMap).filter((id) => id !== "default");
-        const doClasses = [];
-        const wfClasses = [];
-        for (const name of allExportNames) {
-            if (isWorkflowExport(exportMap[name])) {
-                wfClasses.push(name);
-            }
-            else if (isDurableObjectExport(exportMap[name])) {
-                doClasses.push(name);
-            }
-        }
-        const hasDoClasses = doClasses.length > 0;
-        const hasWfClasses = wfClasses.length > 0;
-        const script = (importPath) => `
-import * as Config from "effect/Config";
-import * as ConfigProvider from "effect/ConfigProvider";
-import * as Console from "effect/Console";
-import * as Effect from "effect/Effect";
-import * as FetchHttpClient from "effect/unstable/http/FetchHttpClient";
-import * as Layer from "effect/Layer";
-import * as Logger from "effect/Logger";
-import * as Context from "effect/Context";
-import * as Stream from "effect/Stream";
-
-import { env, DurableObject${hasWfClasses ? ", WorkflowEntrypoint" : ""} } from "cloudflare:workers";
-import { MinimumLogLevel } from "effect/References";
-import { NodeServices } from "@effect/platform-node";
-import { Stack } from "alchemy/Stack";
-import { WorkerEnvironment, makeDurableObjectBridge${hasWfClasses ? ", makeWorkflowBridge" : ""}, ExportedHandlerMethods } from "alchemy/Cloudflare";
-
-import entry from "${importPath}";
-
-const tag = Context.Service("${Self.key}")
-const layer =
-  typeof entry?.build === "function"
-    ? entry
-    : Layer.effect(tag, typeof entry?.asEffect === "function" ? entry.asEffect() : entry);
-
-const platform = Layer.mergeAll(
-  NodeServices.layer,
-  FetchHttpClient.layer,
-  // TODO(sam): wire this up to telemetry more directly
-  Logger.layer([Logger.consolePretty()]),
-);
-
-const stack = Layer.succeed(
-  Stack,
-  {
-    name: "${stack.name}",
-    stage: "${stack.stage}",
-    bindings: {},
-    resources: {}
-  }
-);
-
-const exportsEffect = tag.asEffect().pipe(
-  Effect.flatMap(func => func.ExecutionContext.exports),
-  Effect.provide(
-    layer.pipe(
-      Layer.provideMerge(stack),
-      // TODO(sam): additional credentials?
-      Layer.provideMerge(platform),
-      Layer.provideMerge(
-        Layer.succeed(
-          ConfigProvider.ConfigProvider,
-          ConfigProvider.orElse(
-            ConfigProvider.fromUnknown({ ALCHEMY_PHASE: "runtime" }),
-            ConfigProvider.fromUnknown(env),
-          ),
-        )
-      ),
-      Layer.provideMerge(
-        Layer.succeed(
-          WorkerEnvironment,
-          env,
-        )
-      ),
-      Layer.provideMerge(
-        Layer.succeed(
-          MinimumLogLevel,
-          env.DEBUG ? "Debug" : "Info",
-        )
-      ),
-    )
-  ),
-  Effect.scoped
-);
-
-// TODO(sam): we could kick this off during module init, but any I/O will break deploy
-// let exportsPromise = Effect.runPromise(exportsEffect);
-
-// for now, we delay initializing the worker until the first request
-let exportsPromise;
-
-// don't initialize the workerEffect during module init because Cloudflare does not allow I/O during module init
-// we cache it synchronously (??=) to guarnatee only one initialization ever happens
-const getExports = () => (exportsPromise ??= Effect.runPromise(exportsEffect))
-const getExport = (name) => getExports().then(exports => exports[name]?.make)
-const worker = () => getExports().then(exports => exports.default)
-
-export default Object.fromEntries(ExportedHandlerMethods.map(
-  method => [method, async (...args) => (await worker())[method](...args)])
-) satisfies Required<cf.ExportedHandler>;
-
-// export class proxy stubs for Durable Objects and Workflows
-${[
-            ...(hasDoClasses
-                ? [
-                    "const DurableObjectBridge = makeDurableObjectBridge(DurableObject, getExport);",
-                    ...doClasses.map((id) => `export class ${id} extends DurableObjectBridge("${id}") {}`),
-                ]
-                : []),
-            ...(hasWfClasses
-                ? [
-                    "const WorkflowBridgeFn = makeWorkflowBridge(WorkflowEntrypoint, getExport);",
-                    ...wfClasses.map((id) => `export class ${id} extends WorkflowBridgeFn("${id}") {}`),
-                ]
-                : []),
-        ].join("\n")}
-`;
-        return yield* buildBundle(virtualEntryPlugin(script));
-    }).pipe(Artifacts.cached("build"));
-    const viteBuild = Effect.fnUntraced(function* (props) {
-        let assetsDirectory;
-        let serverBundle;
-        const { compatibilityDate, compatibilityFlags } = getCompatibility(props);
-        yield* Effect.promise(async () => {
-            const vite = await loadVite();
-            const builder = await vite.createBuilder({
-                root: props.vite?.rootDir,
-                // Declare the ssr environment so Vite 8+ creates it.
-                // The cloudflare-vite-plugin config hook merges its
-                // SSR-specific settings on top of this stub.
-                environments: {
-                    ssr: {
-                        build: {
-                            // Prevent the SSR build from wiping the client
-                            // build's output (both share the dist/ directory).
-                            emptyOutDir: false,
-                        },
-                    },
-                },
-                builder: {
-                    sharedConfigBuild: true,
-                },
-                plugins: [
-                    cloudflareVite({
-                        compatibilityDate,
-                        compatibilityFlags,
-                    }),
-                    {
-                        name: "output:ssr",
-                        applyToEnvironment(environment) {
-                            return environment.name === "ssr";
-                        },
-                        generateBundle(_outputOptions, bundle) {
-                            serverBundle = bundle;
-                        },
-                    },
-                    {
-                        name: "output:client",
-                        applyToEnvironment(environment) {
-                            return environment.name === "client";
-                        },
-                        generateBundle(outputOptions) {
-                            assetsDirectory = outputOptions.dir;
-                        },
-                    },
-                ],
-            }, 
-            // This is the `useLegacyBuilder` option. The Vite CLI implementation uses `null` here.
-            // Originally we used `undefined` here, but this caused the static site build to fail.
-            // https://github.com/vitejs/vite/blob/a07a4bd052ac75f916391c999c408ad5f2867e61/packages/vite/src/node/cli.ts#L367
-            null);
-            await builder.buildApp();
-        });
-        if (!assetsDirectory && !serverBundle) {
-            return yield* Effect.die(new Error("Vite build produced neither server nor client output"));
-        }
-        const [assets, bundle] = yield* Effect.all([
-            assetsDirectory
-                ? readAssets({
-                    directory: assetsDirectory,
-                    config: typeof props.assets === "object" && "config" in props.assets
-                        ? props.assets.config
-                        : undefined,
-                })
-                : Effect.succeed(undefined),
-            serverBundle
-                ? Bundle.bundleOutputFromRolldownOutputBundle(serverBundle)
-                : Effect.succeed(undefined),
-        ], { concurrency: "unbounded" });
-        return { assets, bundle };
-    });
-    const prepareAssetsAndBundle = (id, props) => Effect.gen(function* () {
-        if (props.vite) {
-            const [{ assets, bundle }, input] = yield* Effect.all([viteBuild(props), hashDirectory(props.vite)], { concurrency: "unbounded" });
-            return { assets, bundle, input };
-        }
-        const [assets, bundle] = yield* Effect.all([prepareAssets(props.assets), prepareBundle(id, props)], { concurrency: "unbounded" });
-        return { assets, bundle };
-    }).pipe(Effect.map(({ assets, bundle, input }) => ({
-        assets,
-        bundle: {
-            main: bundle?.files[0].path,
-            files: bundle?.files.map((file) => new File([file.content], file.path, {
-                type: contentTypeFromExtension(path.extname(file.path)),
-            })),
-        },
-        hash: {
-            assets: assets?.hash,
-            bundle: bundle?.hash,
-            input,
-        },
-    })));
-    const putWorker = Effect.fnUntraced(function* (id, news, bindings, olds, output, session, existingSettings) {
-        const name = yield* createWorkerName(id, news.name);
-        yield* Effect.logInfo(`Cloudflare Worker ${olds ? "update" : "create"}: preparing bundle for ${name}`);
-        const { assets, bundle, hash } = yield* prepareAssetsAndBundle(id, news);
-        const metadataBindings = bindings.flatMap((b) => b.data.bindings ?? []);
-        const expectedDurableObjectClassNames = getExpectedDurableObjectClassNames(metadataBindings);
-        let metadataAssets;
-        const keepAssets = false;
-        if (assets) {
-            // Always upload assets on every deploy. The "skip if hash
-            // unchanged" optimization was the source of subtle bundle/
-            // asset desync bugs (deploy succeeds but worker serves 404s
-            // because the bundle references hashed asset filenames that
-            // aren't in the still-on-Cloudflare manifest). The upload
-            // session is content-addressed on Cloudflare's side — only
-            // genuinely-new asset bytes are PUT; unchanged assets cost
-            // a manifest check and nothing else, so the optimization
-            // wasn't worth the failure mode.
-            yield* Effect.logInfo(`Cloudflare Worker ${olds ? "update" : "create"}: uploading assets for ${name}`);
-            const { jwt } = yield* uploadAssets(accountId, name, assets, session);
-            metadataAssets = {
-                jwt,
-                config: assets.config,
-            };
-            metadataBindings.push({
-                type: "assets",
-                name: "ASSETS",
-            });
-        }
-        metadataBindings.push({
-            type: "plain_text",
-            name: "ALCHEMY_STACK_NAME",
-            text: stack.name,
-        }, {
-            type: "plain_text",
-            name: "ALCHEMY_STAGE",
-            text: stack.stage,
-        });
-        // Add environment variables as metadata bindings
-        if (news.env) {
-            for (const [key, value] of Object.entries(news.env)) {
-                if (value == null)
-                    continue;
-                if (Redacted.isRedacted(value)) {
-                    metadataBindings.push({
-                        type: "secret_text",
-                        name: key,
-                        text: Redacted.value(value),
-                    });
-                }
-                else {
-                    metadataBindings.push({
-                        type: "plain_text",
-                        name: key,
-                        text: typeof value === "string" ? value : String(value),
-                    });
-                }
-            }
-        }
-        yield* Effect.logInfo(`Cloudflare Worker ${olds ? "update" : "create"}: uploading script for ${name}`);
-        const size = bundle.files
-            ?.filter((file) => !file.name.endsWith(".map"))
-            .reduce((acc, file) => acc + file.size, 0) ?? 0;
-        const sizeKB = size / 1024;
-        const sizeMB = sizeKB / 1024;
-        const bundleSize = `${sizeKB > 1024 ? `${sizeMB.toFixed(2)} MB` : `${sizeKB.toFixed(2)} KB`}`;
-        yield* session.note(`Uploading worker (${bundleSize}) ...`);
-        // Read existing worker settings for migration tracking
-        const oldSettings = existingSettings ??
-            (yield* getScriptSettings({
-                accountId,
-                scriptName: name,
-            }).pipe(Effect.map((s) => s), Effect.catch(() => Effect.succeed(undefined))));
-        const oldTags = Array.from(new Set(oldSettings?.tags ?? []));
-        const oldBindings = oldSettings?.bindings ?? [];
-        // Parse alchemy:do:{logicalId}:{className} tags
-        const oldDoClassNameByLogicalId = getDurableObjectTagMap(oldTags);
-        const currentDoBindings = getDurableObjectBindings(bindings, name);
-        const currentDoClassNameByLogicalId = Object.fromEntries(currentDoBindings.map((binding) => [
-            binding.logicalId,
-            binding.className,
-        ]));
-        // Parse alchemy:migration-tag:{version}
-        const oldMigrationTag = oldTags.flatMap((tag) => tag.startsWith("alchemy:migration-tag:")
-            ? [tag.slice("alchemy:migration-tag:".length)]
-            : [])[0];
-        const newMigrationTag = bumpMigrationTagVersion(oldMigrationTag);
-        // Compute deleted classes
-        const deletedClasses = [];
-        for (const [logicalId, className] of Object.entries(oldDoClassNameByLogicalId)) {
-            if (!currentDoClassNameByLogicalId[logicalId]) {
-                deletedClasses.push(className);
-            }
-        }
-        // Backward compatibility for old workers that have DO bindings but no
-        // alchemy:do tags yet.
-        if (Object.keys(oldDoClassNameByLogicalId).length === 0) {
-            for (const oldBinding of oldBindings) {
-                if (oldBinding.type === "durable_object_namespace" &&
-                    "className" in oldBinding &&
-                    oldBinding.className &&
-                    (!("scriptName" in oldBinding) ||
-                        !oldBinding.scriptName ||
-                        oldBinding.scriptName === name) &&
-                    !currentDoBindings.some((binding) => binding.bindingName === oldBinding.name)) {
-                    deletedClasses.push(oldBinding.className);
-                }
-            }
-        }
-        // Collect container-backed class names so we can send container metadata
-        const containerClassNames = new Set(bindings.flatMap((b) => (b.data.containers ?? []).map((c) => c.className)));
-        // Compute new and renamed classes
-        const newClasses = [];
-        const newSqliteClasses = [];
-        const renamedClasses = [];
-        for (const binding of currentDoBindings) {
-            const previousClassName = oldDoClassNameByLogicalId[binding.logicalId];
-            if (!previousClassName) {
-                // Default all new Durable Object classes to SQLite. Cloudflare
-                // recommends SQLite for new namespaces, and container-backed
-                // Durable Objects require it.
-                newSqliteClasses.push(binding.className);
-            }
-            else if (previousClassName !== binding.className) {
-                renamedClasses.push({
-                    from: previousClassName,
-                    to: binding.className,
-                });
-            }
-        }
-        yield* Effect.logInfo(`Cloudflare Worker put: durable object reconciliation ${JSON.stringify({
-            oldDoClassNameByLogicalId,
-            currentDoClassNameByLogicalId,
-            deletedClasses,
-            renamedClasses,
-            newSqliteClasses,
-        })}`);
-        // Build alchemy:do:{logicalId}:{className} tags for each DO binding
-        const alchemyDoTags = [];
-        for (const binding of currentDoBindings) {
-            alchemyDoTags.push(`alchemy:do:${binding.logicalId}:${binding.className}`);
-        }
-        const metadataTags = Array.from(new Set([
-            ...createAlchemyWorkerTags(id),
-            ...alchemyDoTags,
-            ...(newMigrationTag
-                ? [`alchemy:migration-tag:${newMigrationTag}`]
-                : []),
-            ...(news.tags ?? []),
-        ]));
-        const migrations = {
-            oldTag: oldMigrationTag,
-            newTag: newMigrationTag,
-            newClasses,
-            deletedClasses,
-            renamedClasses,
-            transferredClasses: [],
-            newSqliteClasses,
-        };
-        const metadataContainers = [...containerClassNames].map((className) => ({
-            className,
-        }));
-        const metadata = {
-            assets: metadataAssets,
-            bindings: metadataBindings,
-            bodyPart: undefined,
-            ...getCompatibility(news),
-            containers: metadataContainers.length > 0 ? metadataContainers : undefined,
-            keepAssets,
-            keepBindings: undefined,
-            limits: news.limits,
-            logpush: news.logpush,
-            mainModule: bundle.main,
-            migrations,
-            observability: news.observability ?? {
-                enabled: true,
-                logs: {
-                    enabled: true,
-                    invocationLogs: true,
-                },
-            },
-            placement: news.placement,
-            tags: metadataTags,
-            tailConsumers: undefined,
-            usageModel: undefined,
-        };
-        const worker = yield* putScript({
-            accountId,
-            scriptName: name,
-            metadata,
-            files: bundle.files,
-        }).pipe(Effect.catch((err) => {
-            // When adopting a Worker managed by Wrangler (or after a previous
-            // deploy with mismatched migrations), the old_tag precondition
-            // fails. The only way to discover the actual tag is through the
-            // error message — getScriptSettings is meant to return it but
-            // doesn't at runtime.
-            const msg = String(typeof err === "object" && err !== null && "message" in err
-                ? err.message
-                : err);
-            const expectedTag = msg.match(/when expected tag is ['"]?([^'"]+)['"]?/)?.[1];
-            if (expectedTag) {
-                return putScript({
-                    accountId,
-                    scriptName: name,
-                    metadata: {
-                        ...metadata,
-                        migrations: {
-                            ...migrations,
-                            oldTag: expectedTag,
-                            newTag: bumpMigrationTagVersion(expectedTag),
-                        },
-                    },
-                    files: bundle.files,
-                });
-            }
-            return Effect.fail(err);
-        }));
-        const { settings, durableObjectNamespaces } = yield* getWorkerSettingsWithDurableObjects(name, expectedDurableObjectClassNames);
-        if (!olds || news.url !== olds.url) {
-            const enable = news.url !== false;
-            yield* session.note(`${enable ? "Enabling" : "Disabling"} workers.dev subdomain...`);
-            yield* setWorkerSubdomain(name, enable);
-        }
-        const desiredDomains = normalizeDomains(news.domain);
-        const previousDomains = output?.domains ?? [];
-        if (desiredDomains.length > 0 || previousDomains.length > 0) {
-            yield* session.note(`Reconciling custom domains (${desiredDomains.length}) ...`);
-        }
-        const domains = yield* reconcileDomains(name, desiredDomains, previousDomains);
-        return {
-            workerId: worker.id ?? name,
-            workerName: name,
-            logpush: worker.logpush ?? undefined,
-            url: news.url !== false
-                ? `https://${name}.${yield* getAccountSubdomain(accountId)}.workers.dev`
-                : undefined,
-            tags: settings.tags ?? metadata.tags,
-            durableObjectNamespaces,
-            accountId,
-            domains,
-            hash,
-        };
-    });
-    const hasChanged = Effect.fnUntraced(function* (id, props, output) {
-        if (props.vite) {
-            const input = yield* hashDirectory(props.vite);
-            return input !== output.hash?.input;
-        }
-        // Always recompute both hashes by walking `dist/` (assets) and
-        // re-bundling the worker. The previous short-circuit
-        // (`Effect.succeed(output.hash.assets)`) compared the cached
-        // hash to itself and could never detect drift, and the
-        // `props.assets.hash` form is the *input* (source) hash which
-        // misses non-deterministic build output (e.g. Astro/Vite
-        // shuffling content-hashed filenames between builds). The
-        // result of either shortcut was deploying a new bundle on top
-        // of stale assets and 404'ing in production. Re-walking is the
-        // only correct comparison.
-        const [assetsHash, bundleHash] = yield* Effect.all([
-            prepareAssets(props.assets).pipe(Effect.map((a) => a?.hash)),
-            prepareBundle(id, props).pipe(Effect.map((b) => b.hash)),
-        ], { concurrency: "unbounded" });
-        return (assetsHash !== output.hash?.assets ||
-            bundleHash !== output.hash?.bundle);
-    });
-    return Worker.Provider.of({
-        stables: ["workerId", "workerName"],
-        diff: Effect.fnUntraced(function* ({ id, news, olds, output }) {
-            if (!isResolved(news))
-                return undefined;
-            if ((output?.accountId ?? accountId) !== accountId) {
-                return { action: "replace" };
-            }
-            const workerName = yield* createWorkerName(id, news.name);
-            const oldWorkerName = output?.workerName
-                ? output.workerName
-                : yield* createWorkerName(id, olds?.name);
-            if (workerName !== oldWorkerName) {
-                return { action: "replace" };
-            }
-            if (!output) {
-                return;
-            }
-            const newDomains = normalizeDomains(news.domain).sort();
-            const oldDomains = (output?.domains ?? [])
-                .map((d) => d.hostname)
-                .sort();
-            const domainsChanged = newDomains.length !== oldDomains.length ||
-                newDomains.some((d, i) => d !== oldDomains[i]);
-            if (domainsChanged || (yield* hasChanged(id, news, output))) {
-                return {
-                    action: "update",
-                    stables: oldWorkerName === workerName ? ["workerName"] : undefined,
-                };
-            }
-        }),
-        precreate: Effect.fnUntraced(function* ({ id, news, session }) {
-            const name = yield* createWorkerName(id, news.name);
-            const exportMap = (news.exports ?? {});
-            const durableObjects = Object.keys(exportMap)
-                .filter((logicalId) => isDurableObjectExport(exportMap[logicalId]))
-                .map((logicalId) => ({
-                logicalId,
-                className: logicalId,
-            }));
-            const doClasses = durableObjects.map((binding) => binding.className);
-            const containers = doClasses.map((className) => ({ className }));
-            const alchemyDoTags = durableObjects.map(({ logicalId, className }) => `alchemy:do:${logicalId}:${className}`);
-            const tags = Array.from(new Set([
-                ...createAlchemyWorkerTags(id),
-                ...alchemyDoTags,
-                ...(news.tags ?? []),
-            ]));
-            yield* Effect.logInfo(`Cloudflare Worker precreate: starting ${name}`);
-            yield* Effect.logInfo(`Cloudflare Worker precreate: durable objects ${JSON.stringify(durableObjects)}`);
-            const existingSettings = yield* getScriptSettings({
-                accountId,
-                scriptName: name,
-            }).pipe(Effect.catchTag("WorkerNotFound", () => Effect.succeed(undefined)));
-            let durableObjectNamespaces = getDurableObjectNamespaces(existingSettings?.bindings);
-            if (existingSettings) {
-                if (!hasAlchemyWorkerTags(id, existingSettings.tags ?? [])) {
-                    return yield* Effect.die(`Worker "${name}" already exists but is not owned by this stack/stage/resource`);
-                }
-                yield* Effect.logInfo(`Cloudflare Worker precreate: adopting existing ${name} owned by this stack/stage/resource`);
-            }
-            else {
-                yield* session.note("Pre-creating worker...");
-                const mainModule = "main.js";
-                const placeholderScript = `${doClasses.length > 0 ? 'import { DurableObject } from "cloudflare:workers";\n\n' : ""}export default { fetch() { return new Response("Alchemy worker is being deployed...") } };\n${doClasses
-                    .map((className) => `export class ${className} extends DurableObject {}`)
-                    .join("\n")}`;
-                yield* putScript({
-                    accountId,
-                    scriptName: name,
-                    metadata: {
-                        mainModule,
-                        bindings: doClasses.length > 0
-                            ? doClasses.map((className) => ({
-                                type: "durable_object_namespace",
-                                name: className,
-                                className,
-                            }))
-                            : undefined,
-                        ...getCompatibility(news),
-                        containers,
-                        migrations: doClasses.length > 0
-                            ? {
-                                oldTag: undefined,
-                                newTag: undefined,
-                                newClasses: [],
-                                deletedClasses: [],
-                                renamedClasses: [],
-                                transferredClasses: [],
-                                newSqliteClasses: doClasses,
-                            }
-                            : undefined,
-                        observability: news.observability ?? {
-                            enabled: true,
-                            logs: {
-                                enabled: true,
-                                invocationLogs: true,
-                            },
-                        },
-                        tags,
-                    },
-                    files: [
-                        new File([placeholderScript], mainModule, {
-                            type: "application/javascript+module",
-                        }),
-                    ],
-                });
-                if (doClasses.length > 0) {
-                    ({ durableObjectNamespaces } =
-                        yield* getWorkerSettingsWithDurableObjects(name, doClasses));
-                }
-            }
-            if (existingSettings && doClasses.length > 0) {
-                ({ durableObjectNamespaces } =
-                    yield* getWorkerSettingsWithDurableObjects(name, doClasses));
-            }
-            return {
-                workerId: name,
-                workerName: name,
-                logpush: existingSettings?.logpush ?? undefined,
-                url: undefined,
-                tags: existingSettings?.tags ?? tags,
-                durableObjectNamespaces,
-                accountId,
-                domains: [],
-            };
-        }),
-        read: Effect.fnUntraced(function* ({ id, output, olds }) {
-            const workerName = output?.workerName ?? (yield* createWorkerName(id, olds?.name));
-            yield* Effect.logInfo(`Cloudflare Worker read: checking ${workerName}`);
-            const [worker, subdomain, settings, domainsList] = yield* Effect.all([
-                listScripts({
-                    accountId,
-                }).pipe(Effect.map((workers) => workers.result.find((worker) => worker.id === workerName))),
-                getScriptSubdomain({
-                    accountId,
-                    scriptName: workerName,
-                }),
-                getScriptSettings({
-                    accountId,
-                    scriptName: workerName,
-                }),
-                listDomains({
-                    accountId,
-                    service: workerName,
-                }).pipe(Effect.map((r) => r.result ?? [])),
-            ]);
-            if (!worker) {
-                yield* Effect.logInfo(`Cloudflare Worker read: ${workerName} not found in script list`);
-                return undefined;
-            }
-            yield* Effect.logInfo(`Cloudflare Worker read: found ${workerName}`);
-            return {
-                accountId,
-                workerId: worker.id ?? workerName,
-                workerName,
-                logpush: worker.logpush ?? undefined,
-                url: subdomain.enabled
-                    ? `https://${workerName}.${yield* getAccountSubdomain(accountId)}.workers.dev`
-                    : undefined,
-                tags: settings.tags ?? undefined,
-                durableObjectNamespaces: getDurableObjectNamespaces(settings.bindings),
-                domains: domainsList.flatMap((d) => d.id && d.hostname && d.zoneId
-                    ? [{ id: d.id, hostname: d.hostname, zoneId: d.zoneId }]
-                    : []),
-            };
-        }, (effect) => effect.pipe(Effect.catchTag("WorkerNotFound", () => Effect.succeed(undefined)))),
-        create: Effect.fnUntraced(function* ({ id, news, bindings, output, session, }) {
-            const name = yield* createWorkerName(id, news.name);
-            const durableObjects = getDurableObjectBindings(bindings, name).map(({ logicalId, className }) => ({
-                logicalId,
-                className,
-            }));
-            yield* Effect.logInfo(`Cloudflare Worker create: starting ${name}`);
-            yield* Effect.logInfo(`Cloudflare Worker create: durable objects ${JSON.stringify(durableObjects)}`);
-            const existingSettings = yield* getScriptSettings({
-                accountId,
-                scriptName: name,
-            }).pipe(Effect.catchTag("WorkerNotFound", () => Effect.succeed(undefined)));
-            yield* Effect.logInfo(`Cloudflare Worker create: existing durable object tags ${JSON.stringify((existingSettings?.tags ?? []).filter((tag) => tag.startsWith("alchemy:do:")))}`);
-            if (existingSettings) {
-                yield* Effect.logInfo(`Cloudflare Worker create: ${name} already exists`);
-                if (!hasAlchemyWorkerTags(id, existingSettings.tags ?? [])) {
-                    return yield* Effect.die(`Worker "${name}" already exists but is not owned by this stack/stage/resource`);
-                }
-                yield* Effect.logInfo(`Cloudflare Worker create: adopting existing ${name} owned by this stack/stage/resource`);
-            }
-            return yield* putWorker(id, news, bindings, undefined, output, session, existingSettings);
-        }),
-        update: Effect.fnUntraced(function* ({ id, olds, news, output, bindings, session, }) {
-            const durableObjects = getDurableObjectBindings(bindings, output.workerName).map(({ logicalId, className }) => ({
-                logicalId,
-                className,
-            }));
-            yield* Effect.logInfo(`Cloudflare Worker update: starting ${output.workerName}`);
-            yield* Effect.logInfo(`Cloudflare Worker update: durable objects ${JSON.stringify(durableObjects)}`);
-            yield* Effect.logInfo(`Cloudflare Worker update: previous durable object tags ${JSON.stringify((output.tags ?? []).filter((tag) => tag.startsWith("alchemy:do:")))}`);
-            return yield* putWorker(id, news, bindings, olds, output, session);
-        }),
-        delete: Effect.fnUntraced(function* ({ output }) {
-            yield* Effect.logInfo(`Cloudflare Worker delete: deleting ${output.workerName}`);
-            if (output.domains?.length) {
-                yield* Effect.all(output.domains.map((d) => deleteDomain({
-                    accountId: output.accountId,
-                    domainId: d.id,
-                }).pipe(Effect.catchTag("DomainNotFound", () => Effect.void))), { concurrency: "unbounded" });
-            }
-            yield* deleteScript({
-                accountId: output.accountId,
-                scriptName: output.workerName,
-            }).pipe(Effect.catchTag("WorkerNotFound", () => Effect.void));
-        }),
-        tail: ({ output }) => {
-            const runTailSession = Effect.gen(function* () {
-                const { id: tailId, url } = yield* createScriptTail({
-                    scriptName: output.workerName,
-                    accountId: output.accountId,
-                    body: { filters: [] },
-                });
-                const socket = yield* Socket.makeWebSocket(url, {
-                    protocols: ["trace-v1"],
-                });
-                const queue = yield* Queue.make();
-                yield* socket
-                    .runRaw((raw) => {
-                    const text = typeof raw === "string" ? raw : new TextDecoder().decode(raw);
-                    const data = JSON.parse(text);
-                    const eventTs = new Date(data.eventTimestamp ?? Date.now());
-                    if (data.event && "request" in data.event) {
-                        const reqEvent = data.event;
-                        const pathname = (() => {
-                            try {
-                                return new URL(reqEvent.request.url).pathname;
-                            }
-                            catch {
-                                return reqEvent.request.url;
-                            }
-                        })();
-                        const status = reqEvent.response?.status ?? 500;
-                        Queue.offerUnsafe(queue, {
-                            timestamp: eventTs,
-                            message: `${reqEvent.request.method} ${pathname} > ${status} (cpu: ${Math.round(data.cpuTime)}ms, wall: ${Math.round(data.wallTime)}ms)`,
-                        });
-                    }
-                    for (const log of data.logs) {
-                        const msg = log.message.join(" ");
-                        Queue.offerUnsafe(queue, {
-                            timestamp: new Date(log.timestamp),
-                            message: log.level === "log" ? msg : `${log.level}: ${msg}`,
-                        });
-                    }
-                    for (const exception of data.exceptions) {
-                        Queue.offerUnsafe(queue, {
-                            timestamp: new Date(exception.timestamp),
-                            message: `${exception.name} ${exception.message}\n${exception.stack}`,
-                        });
-                    }
-                })
-                    .pipe(Effect.ensuring(Effect.all([
-                    deleteScriptTail({
-                        scriptName: output.workerName,
-                        id: tailId,
-                        accountId: output.accountId,
-                    }).pipe(Effect.ignore),
-                    Queue.end(queue),
-                ])), Effect.ignore, Effect.forkChild());
-                return Stream.fromQueue(queue);
-            });
-            return Stream.unwrap(runTailSession).pipe(Stream.repeat(Schedule.spaced("1 second")));
-        },
-        logs: ({ output, options }) => telemetry.queryLogs({
-            accountId: output.accountId,
-            filters: [
-                {
-                    key: "$workers.scriptName",
-                    operation: "eq",
-                    type: "string",
-                    value: output.workerName,
-                },
-            ],
-            options,
-        }),
-    });
-}));
-const contentTypeFromExtension = (extension) => {
-    switch (extension) {
-        case ".wasm":
-            return "application/wasm";
-        case ".txt":
-        case ".html":
-        case ".sql":
-        case ".custom":
-            return "text/plain";
-        case ".bin":
-            return "application/octet-stream";
-        case ".mjs":
-        case ".js":
-            return "application/javascript+module";
-        case ".cjs":
-            return "application/javascript";
-        case ".map":
-            return "application/source-map";
-        default:
-            return "application/octet-stream";
-    }
-};
-let _viteModule = null;
-/**
- * Dynamically load Vite from the project root. Falls back to the bundled
- * copy if the project doesn't have its own Vite installation.
- */
-async function loadVite() {
-    if (_viteModule)
-        return _viteModule;
-    const projectRoot = process.cwd();
-    let vitePath;
-    try {
-        // Resolve "vite" from the project root, not from vinext's location
-        const require = createRequire(path.join(projectRoot, "package.json"));
-        vitePath = require.resolve("vite");
-    }
-    catch {
-        // Fallback: use the Vite that ships with vinext (works for non-linked installs)
-        vitePath = "vite";
-    }
-    // On Windows, absolute paths must be file:// URLs for ESM import().
-    // The fallback ("vite") is a bare specifier and works as-is.
-    const viteUrl = vitePath === "vite" ? vitePath : pathToFileURL(vitePath).href;
-    const vite = (await import(__rewriteRelativeImportExtension(/* @vite-ignore */ viteUrl)));
-    _viteModule = vite;
-    return vite;
-}
-//# sourceMappingURL=Worker.js.map