alchemy 2.0.0-beta.73 → 2.0.0-beta.75

package/lib/Cloudflare/Workers/EmailEventSource.d.ts

@@ -0,0 +1,196 @@
+import type * as cf from "@cloudflare/workers-types";
+import * as Cause from "effect/Cause";
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import type { Input } from "../../Input.ts";
+import { type Matcher } from "../Email/Rule.ts";
+import type { Reference } from "../Zone/lookup.ts";
+import { Worker } from "./Worker.ts";
+/**
+ * Effect-native wrapper around Cloudflare's
+ * [`ForwardableEmailMessage`](https://developers.cloudflare.com/email-routing/email-workers/runtime-api/#forwardableemailmessage).
+ *
+ * Follows the same shape as the other Cloudflare bindings (R2, KV, …):
+ *
+ * - `raw` is the underlying `cf.ForwardableEmailMessage` — an escape
+ *   hatch for any field or future API not yet wrapped.
+ * - Ergonomic fields (`from`, `to`, `headers`, `body`, `bodySize`) are
+ *   forwarded verbatim.
+ * - Action methods (`forward`, `reply`, `setReject`) return `Effect`s
+ *   instead of `Promise`/`void`.
+ */
+export interface ForwardableEmailMessage {
+    /** Underlying Cloudflare message — escape hatch for unwrapped APIs. */
+    readonly raw: cf.ForwardableEmailMessage;
+    /** Envelope From address. */
+    readonly from: string;
+    /** Envelope To address. */
+    readonly to: string;
+    /** RFC 5322 headers. */
+    readonly headers: cf.Headers;
+    /** Raw message body stream (RFC 5322 wire bytes). */
+    readonly body: cf.ReadableStream<Uint8Array>;
+    /** Size of the raw message body in bytes. */
+    readonly bodySize: number;
+    /**
+     * Reject this message back to the connecting client with a permanent
+     * SMTP error and the given reason.
+     */
+    setReject(reason: string): Effect.Effect<void>;
+    /**
+     * Forward this message to a verified destination address on the
+     * account. Fails with `EmailError` if Cloudflare rejects the forward
+     * (e.g. unverified destination).
+     */
+    forward(rcptTo: string, headers?: cf.Headers): Effect.Effect<void, EmailError>;
+    /**
+     * Reply to the sender with a new outbound message. Fails with
+     * `EmailError` if Cloudflare rejects the reply.
+     */
+    reply(message: cf.EmailMessage): Effect.Effect<void, EmailError>;
+}
+declare const EmailError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => Cause.YieldableError & {
+    readonly _tag: "EmailError";
+} & Readonly<A>;
+export declare class EmailError extends EmailError_base<{
+    action: "forward" | "reply";
+    message: string;
+    cause: unknown;
+}> {
+}
+/**
+ * Settings for {@link email} — both halves of the consumer in one place.
+ * `zone` opts in to the deploy-time setup: an `Email.Routing` toggle on the
+ * zone plus the routing resource that hands matched mail to the host
+ * Worker. Omit `zone` to manage routing yourself.
+ *
+ * Which routing resource depends on {@link EmailSubscribeProps.matchers}:
+ * a catch-all subscription yields `Email.CatchAll` (Cloudflare models the
+ * zone catch-all as a singleton behind its own endpoint), anything more
+ * specific yields `Email.Rule`.
+ */
+export interface EmailSubscribeProps {
+    /**
+     * Zone to enable email routing on and attach the routing resource to.
+     * Accepts a zone id, a zone name (`example.com`), or a
+     * `{ zoneId, name? }` object (a `Cloudflare.Zone` resource works).
+     * Required to auto-create routing resources; omit if you're managing
+     * `Email.Routing` and `Email.Rule`/`Email.CatchAll` yourself.
+     */
+    zone?: Input<Reference>;
+    /**
+     * Which envelopes Cloudflare delivers to this Worker. Ignored when
+     * `zone` is omitted.
+     *
+     * Omitting this (or passing a lone `{ type: "all" }`) subscribes to the
+     * zone's catch-all, provisioned as `Email.CatchAll`. There is exactly one
+     * catch-all per zone, so a second Worker subscribing to it takes the
+     * zone's mail from the first.
+     *
+     * @default [{ type: "all" }]
+     */
+    matchers?: Matcher[];
+    /**
+     * Display name for the auto-created `Email.Rule` / `Email.CatchAll`.
+     *
+     * @default the host worker's logical id
+     */
+    ruleName?: string;
+    /**
+     * Priority of the auto-created `Email.Rule`. Lower numbers run first.
+     * Ignored for a catch-all subscription — the catch-all is always
+     * evaluated last.
+     *
+     * @default 0
+     */
+    priority?: number;
+    /**
+     * Whether the auto-created `Email.Rule` / `Email.CatchAll` is enabled.
+     *
+     * @default true
+     */
+    enabled?: boolean;
+}
+/**
+ * Subscribe to Cloudflare Email Worker events with an Effect handler.
+ *
+ * Wires both halves of the consumer in one call:
+ *
+ * - **Runtime**: registers an `email` event listener on the Worker.
+ *   The handler receives a {@link ForwardableEmailMessage} whose
+ *   action methods (`forward`, `reply`, `setReject`) return `Effect`s.
+ * - **Deploy-time** (when `zone` is set): yields a
+ *   `Cloudflare.Email.Routing` toggle on the zone plus the routing
+ *   resource whose `actions: [{ type: "worker", … }]` targets this
+ *   Worker — `Cloudflare.Email.CatchAll` for a catch-all subscription,
+ *   `Cloudflare.Email.Rule` for anything more specific. No manual
+ *   wiring needed in `alchemy.run.ts`.
+ *
+ * Requires `EmailEventSourceLive` provided on the Worker's Effect.
+ *
+ * **Failure semantics**: a failing handler is logged and the failure is
+ * re-raised. Cloudflare turns that into a temporary SMTP failure, so the
+ * sending server keeps the message and retries later — mail is never
+ * accepted and then silently dropped. Handle the failures you consider
+ * final inside the handler (`Effect.retry`, `Effect.catchTag`, or
+ * `message.setReject(...)` to bounce permanently); anything you let
+ * escape becomes a retryable delivery failure.
+ *
+ * ### Subscribing to Inbound Mail
+ * **Example:** Catch-all on a zone — auto-creates routing + catch-all
+ * ```typescript
+ * import * as Cloudflare from "alchemy/Cloudflare";
+ * import * as Effect from "effect/Effect";
+ *
+ * export default Cloudflare.Worker(
+ *   "Inbox",
+ *   { main: import.meta.url },
+ *   Effect.gen(function* () {
+ *     yield* Cloudflare.email({ zone: "example.com" }).subscribe(
+ *       (message) => message.forward("ops@example.com"),
+ *     );
+ *     return {};
+ *   }).pipe(Effect.provide(Cloudflare.EmailEventSourceLive)),
+ * );
+ * ```
+ *
+ * **Example:** Match a specific address
+ * ```typescript
+ * yield* Cloudflare.email({
+ *   zone: "example.com",
+ *   matchers: [{ type: "literal", field: "to", value: "hello@example.com" }],
+ * }).subscribe((message) => message.forward("ops@example.com"));
+ * ```
+ *
+ * **Example:** Reject (bounce) a message
+ * ```typescript
+ * yield* Cloudflare.email({ zone: "example.com" }).subscribe((message) =>
+ *   message.setReject("Mailbox closed"),
+ * );
+ * ```
+ *
+ * **Example:** Bring-your-own routing — no `zone`, no auto-create
+ * ```typescript
+ * // Manage `Email.Routing` / `Email.Rule` yourself in alchemy.run.ts.
+ * yield* Cloudflare.email().subscribe((message) =>
+ *   Effect.log(`from ${message.from}`),
+ * );
+ * ```
+ *
+ * @see https://developers.cloudflare.com/email-routing/email-workers/
+ *
+ * @binding
+ * @product Workers
+ * @category Workers & Compute
+ */
+export declare const email: (props?: EmailSubscribeProps) => {
+    subscribe: <E = never, Req = never>(process: (message: ForwardableEmailMessage) => Effect.Effect<void, E, Req>) => Effect.Effect<void, never, EmailEventSource>;
+};
+export type EmailEventSourceService = <E = never, Req = never>(props: EmailSubscribeProps, process: (message: ForwardableEmailMessage) => Effect.Effect<void, E, Req>) => Effect.Effect<void, never, never>;
+declare const EmailEventSource_base: Context.ServiceClass<EmailEventSource, "Cloudflare.Workers.EmailEventSource", EmailEventSourceService>;
+export declare class EmailEventSource extends EmailEventSource_base {
+}
+export declare const EmailEventSourceLive: Layer.Layer<EmailEventSource, never, Worker<any>>;
+export {};
+//# sourceMappingURL=EmailEventSource.d.ts.map

package/lib/Cloudflare/Workers/EmailEventSource.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EmailEventSource.d.ts","sourceRoot":"","sources":["../../../src/Cloudflare/Workers/EmailEventSource.ts"],"names":[],"mappings":"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"}

package/lib/Cloudflare/Workers/EmailEventSource.js

@@ -0,0 +1,198 @@
+import * as Cause from "effect/Cause";
+import * as Context from "effect/Context";
+import * as Data from "effect/Data";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Namespace from "../../Namespace.js";
+import * as RemovalPolicy from "../../RemovalPolicy.js";
+import { RuntimeContext } from "../../RuntimeContext.js";
+import { CatchAll } from "../Email/CatchAll.js";
+import { Routing } from "../Email/Routing.js";
+import { Rule } from "../Email/Rule.js";
+import { isWorkerEvent, Worker } from "./Worker.js";
+export class EmailError extends Data.TaggedError("EmailError") {
+}
+const wrap = (raw) => ({
+    raw,
+    from: raw.from,
+    to: raw.to,
+    headers: raw.headers,
+    body: raw.raw,
+    bodySize: raw.rawSize,
+    setReject: (reason) => Effect.sync(() => raw.setReject(reason)),
+    forward: (rcptTo, headers) => Effect.tryPromise({
+        try: () => raw.forward(rcptTo, headers),
+        catch: (cause) => new EmailError({
+            action: "forward",
+            message: `Cloudflare email forward failed: ${formatCause(cause)}`,
+            cause,
+        }),
+    }),
+    reply: (msg) => Effect.tryPromise({
+        try: () => raw.reply(msg),
+        catch: (cause) => new EmailError({
+            action: "reply",
+            message: `Cloudflare email reply failed: ${formatCause(cause)}`,
+            cause,
+        }),
+    }),
+});
+/**
+ * Whether a subscription's matchers describe the zone's catch-all — either
+ * omitted entirely (the documented default) or a lone `{ type: "all" }`.
+ * Cloudflare models that as a per-zone singleton behind `/rules/catch_all`,
+ * so it maps to `Email.CatchAll` rather than `Email.Rule`.
+ */
+const isCatchAll = (matchers) => matchers === undefined ||
+    (matchers.length === 1 && matchers[0]?.type === "all");
+const formatCause = (cause) => cause instanceof Error ? cause.message : String(cause);
+/**
+ * Subscribe to Cloudflare Email Worker events with an Effect handler.
+ *
+ * Wires both halves of the consumer in one call:
+ *
+ * - **Runtime**: registers an `email` event listener on the Worker.
+ *   The handler receives a {@link ForwardableEmailMessage} whose
+ *   action methods (`forward`, `reply`, `setReject`) return `Effect`s.
+ * - **Deploy-time** (when `zone` is set): yields a
+ *   `Cloudflare.Email.Routing` toggle on the zone plus the routing
+ *   resource whose `actions: [{ type: "worker", … }]` targets this
+ *   Worker — `Cloudflare.Email.CatchAll` for a catch-all subscription,
+ *   `Cloudflare.Email.Rule` for anything more specific. No manual
+ *   wiring needed in `alchemy.run.ts`.
+ *
+ * Requires `EmailEventSourceLive` provided on the Worker's Effect.
+ *
+ * **Failure semantics**: a failing handler is logged and the failure is
+ * re-raised. Cloudflare turns that into a temporary SMTP failure, so the
+ * sending server keeps the message and retries later — mail is never
+ * accepted and then silently dropped. Handle the failures you consider
+ * final inside the handler (`Effect.retry`, `Effect.catchTag`, or
+ * `message.setReject(...)` to bounce permanently); anything you let
+ * escape becomes a retryable delivery failure.
+ *
+ * ### Subscribing to Inbound Mail
+ * **Example:** Catch-all on a zone — auto-creates routing + catch-all
+ * ```typescript
+ * import * as Cloudflare from "alchemy/Cloudflare";
+ * import * as Effect from "effect/Effect";
+ *
+ * export default Cloudflare.Worker(
+ *   "Inbox",
+ *   { main: import.meta.url },
+ *   Effect.gen(function* () {
+ *     yield* Cloudflare.email({ zone: "example.com" }).subscribe(
+ *       (message) => message.forward("ops@example.com"),
+ *     );
+ *     return {};
+ *   }).pipe(Effect.provide(Cloudflare.EmailEventSourceLive)),
+ * );
+ * ```
+ *
+ * **Example:** Match a specific address
+ * ```typescript
+ * yield* Cloudflare.email({
+ *   zone: "example.com",
+ *   matchers: [{ type: "literal", field: "to", value: "hello@example.com" }],
+ * }).subscribe((message) => message.forward("ops@example.com"));
+ * ```
+ *
+ * **Example:** Reject (bounce) a message
+ * ```typescript
+ * yield* Cloudflare.email({ zone: "example.com" }).subscribe((message) =>
+ *   message.setReject("Mailbox closed"),
+ * );
+ * ```
+ *
+ * **Example:** Bring-your-own routing — no `zone`, no auto-create
+ * ```typescript
+ * // Manage `Email.Routing` / `Email.Rule` yourself in alchemy.run.ts.
+ * yield* Cloudflare.email().subscribe((message) =>
+ *   Effect.log(`from ${message.from}`),
+ * );
+ * ```
+ *
+ * @see https://developers.cloudflare.com/email-routing/email-workers/
+ *
+ * @binding
+ * @product Workers
+ * @category Workers & Compute
+ */
+export const email = (props = {}) => ({
+    subscribe: (process) => EmailEventSource.use((source) => source(props, process)),
+});
+export class EmailEventSource extends Context.Service()("Cloudflare.Workers.EmailEventSource") {
+}
+export const EmailEventSourceLive = Layer.effect(EmailEventSource, Effect.gen(function* () {
+    const host = yield* Worker;
+    return Effect.fn(function* (props, process) {
+        // Deploy-time: provision the Email.Routing toggle plus the routing
+        // resource that hands matched mail to this Worker. Skipped once
+        // running inside the deployed Worker (the global guard) and when
+        // `zone` is omitted (bring-your-own routing). Namespaced under the
+        // host so logical identity is stable per Worker.
+        if (!globalThis.__ALCHEMY_RUNTIME__ && props.zone !== undefined) {
+            const zone = props.zone;
+            const matchers = props.matchers;
+            yield* Namespace.push(host.LogicalId, Effect.gen(function* () {
+                // Routing is a per-zone singleton shared with other rules on
+                // the zone, so destroying this Worker must not disable it.
+                yield* Routing("EmailRouting", {
+                    zone,
+                    enabled: true,
+                }).pipe(RemovalPolicy.retain());
+                const action = {
+                    type: "worker",
+                    value: [host.workerName],
+                };
+                // Catch-all is a per-zone SINGLETON living behind
+                // `/rules/catch_all`, not an ordinary rule. Cloudflare surfaces
+                // it in `listRules` but rejects mutating it through the rule
+                // endpoint ("Invalid rule operation"), so creating it as an
+                // `Email.Rule` would produce a row the engine cannot delete.
+                // Route an all-matcher subscription to `Email.CatchAll`
+                // instead — the resource that owns that endpoint.
+                if (isCatchAll(matchers)) {
+                    yield* CatchAll("EmailCatchAll", {
+                        zone,
+                        name: props.ruleName ?? host.LogicalId,
+                        enabled: props.enabled ?? true,
+                        actions: [action],
+                    });
+                    return;
+                }
+                yield* Rule("EmailRule", {
+                    zone,
+                    name: props.ruleName ?? host.LogicalId,
+                    enabled: props.enabled ?? true,
+                    priority: props.priority ?? 0,
+                    matchers: matchers,
+                    actions: [action],
+                });
+            }));
+        }
+        // Resolve the runtime context per-call rather than at layer
+        // construction (mirrors `Queues.EventSourceLive`).
+        const ctx = (yield* RuntimeContext);
+        yield* ctx.listen((event) => {
+            if (!isWorkerEvent(event) || event.type !== "email")
+                return;
+            const message = wrap(event.input);
+            // Log, then let the failure propagate. Cloudflare turns an
+            // exception out of the `email` handler into a temporary SMTP
+            // failure, so the sending server keeps the message and retries.
+            // Swallowing it here would instead ACCEPT the envelope and then
+            // drop it: a transient dependency outage would silently destroy
+            // mail with nothing left to retry from.
+            return process(message).pipe(Effect.tapCause((cause) => Effect.sync(() => {
+                console.error(`[EmailEventSource] handler failed for message to ` +
+                    `"${message.to}": ${Cause.pretty(cause)}`);
+            })), 
+            // The listener contract is `E = never`, so surface the failure as
+            // a defect rather than discarding it: the invocation fails, which
+            // is what Cloudflare turns into the temporary SMTP failure.
+            Effect.orDie);
+        });
+    });
+}));
+//# sourceMappingURL=EmailEventSource.js.map

package/lib/Cloudflare/Workers/EmailEventSource.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"EmailEventSource.js","sourceRoot":"","sources":["../../../src/Cloudflare/Workers/EmailEventSource.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,KAAK,MAAM,cAAc,CAAC;AACtC,OAAO,KAAK,OAAO,MAAM,gBAAgB,CAAC;AAC1C,OAAO,KAAK,IAAI,MAAM,aAAa,CAAC;AACpC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AACxC,OAAO,KAAK,KAAK,MAAM,cAAc,CAAC;AAEtC,OAAO,KAAK,SAAS,MAAM,oBAAoB,CAAC;AAChD,OAAO,KAAK,aAAa,MAAM,wBAAwB,CAAC;AACxD,OAAO,EAAE,cAAc,EAAE,MAAM,yBAAyB,CAAC;AAEzD,OAAO,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAChD,OAAO,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAC;AAC9C,OAAO,EAAE,IAAI,EAAgB,MAAM,kBAAkB,CAAC;AAEtD,OAAO,EAAE,aAAa,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAiDpD,MAAM,OAAO,UAAW,SAAQ,IAAI,CAAC,WAAW,CAAC,YAAY,CAI3D;CAAG;AAEL,MAAM,IAAI,GAAG,CAAC,GAA+B,EAA2B,EAAE,CAAC,CAAC;IAC1E,GAAG;IACH,IAAI,EAAE,GAAG,CAAC,IAAI;IACd,EAAE,EAAE,GAAG,CAAC,EAAE;IACV,OAAO,EAAE,GAAG,CAAC,OAAO;IACpB,IAAI,EAAE,GAAG,CAAC,GAAG;IACb,QAAQ,EAAE,GAAG,CAAC,OAAO;IACrB,SAAS,EAAE,CAAC,MAAM,EAAE,EAAE,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC;IAC/D,OAAO,EAAE,CAAC,MAAM,EAAE,OAAO,EAAE,EAAE,CAC3B,MAAM,CAAC,UAAU,CAAC;QAChB,GAAG,EAAE,GAAG,EAAE,CAAC,GAAG,CAAC,OAAO,CAAC,MAAM,EAAE,OAAO,CAAC;QACvC,KAAK,EAAE,CAAC,KAAK,EAAE,EAAE,CACf,IAAI,UAAU,CAAC;YACb,MAAM,EAAE,SAAS;YACjB,OAAO,EAAE,oCAAoC,WAAW,CAAC,KAAK,CAAC,EAAE;YACjE,KAAK;SACN,CAAC;KACL,CAAC;IACJ,KAAK,EAAE,CAAC,GAAG,EAAE,EAAE,CACb,MAAM,CAAC,UAAU,CAAC;QAChB,GAAG,EAAE,GAAG,EAAE,CAAC,GAAG,CAAC,KAAK,CAAC,GAAG,CAAC;QACzB,KAAK,EAAE,CAAC,KAAK,EAAE,EAAE,CACf,IAAI,UAAU,CAAC;YACb,MAAM,EAAE,OAAO;YACf,OAAO,EAAE,kCAAkC,WAAW,CAAC,KAAK,CAAC,EAAE;YAC/D,KAAK;SACN,CAAC;KACL,CAAC;CACL,CAAC,CAAC;AAEH;;;;;GAKG;AACH,MAAM,UAAU,GAAG,CAAC,QAA+B,EAAW,EAAE,CAC9D,QAAQ,KAAK,SAAS;IACtB,CAAC,QAAQ,CAAC,MAAM,KAAK,CAAC,IAAI,QAAQ,CAAC,CAAC,CAAC,EAAE,IAAI,KAAK,KAAK,CAAC,CAAC;AAEzD,MAAM,WAAW,GAAG,CAAC,KAAc,EAAU,EAAE,CAC7C,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;AAwDzD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuEG;AACH,MAAM,CAAC,MAAM,KAAK,GAAG,CAAC,KAAK,GAAwB,EAAE,EAAE,EAAE,CAAC,CAAC;IACzD,SAAS,EAAE,CACT,OAA0E,EAC1E,EAAE,CAAC,gBAAgB,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,MAAM,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;CAC9D,CAAC,CAAC;AAOH,MAAM,OAAO,gBAAiB,SAAQ,OAAO,CAAC,OAAO,EAGlD,CAAC,qCAAqC,CAAC;CAAG;AAE7C,MAAM,CAAC,MAAM,oBAAoB,GAAG,KAAK,CAAC,MAAM,CAC9C,gBAAgB,EAChB,MAAM,CAAC,GAAG,CAAC,QAAQ,CAAC;IAClB,MAAM,IAAI,GAAG,KAAK,CAAC,CAAC,MAAM,CAAC;IAC3B,OAAO,MAAM,CAAC,EAAE,CAAC,QAAQ,CAAC,EACxB,KAA0B,EAC1B,OAEgC;QAEhC,mEAAmE;QACnE,gEAAgE;QAChE,iEAAiE;QACjE,mEAAmE;QACnE,iDAAiD;QACjD,IAAI,CAAC,UAAU,CAAC,mBAAmB,IAAI,KAAK,CAAC,IAAI,KAAK,SAAS,EAAE,CAAC;YAChE,MAAM,IAAI,GAAG,KAAK,CAAC,IAAI,CAAC;YACxB,MAAM,QAAQ,GAAG,KAAK,CAAC,QAAQ,CAAC;YAChC,KAAK,CAAC,CAAC,SAAS,CAAC,IAAI,CACnB,IAAI,CAAC,SAAS,EACd,MAAM,CAAC,GAAG,CAAC,QAAQ,CAAC;gBAClB,6DAA6D;gBAC7D,2DAA2D;gBAC3D,KAAK,CAAC,CAAC,OAAO,CAAC,cAAc,EAAE;oBAC7B,IAAI;oBACJ,OAAO,EAAE,IAAI;iBACd,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,MAAM,EAAE,CAAC,CAAC;gBAEhC,MAAM,MAAM,GAAG;oBACb,IAAI,EAAE,QAAiB;oBACvB,KAAK,EAAE,CAAC,IAAI,CAAC,UAAU,CAAC;iBACzB,CAAC;gBAEF,kDAAkD;gBAClD,gEAAgE;gBAChE,6DAA6D;gBAC7D,4DAA4D;gBAC5D,6DAA6D;gBAC7D,wDAAwD;gBACxD,kDAAkD;gBAClD,IAAI,UAAU,CAAC,QAAQ,CAAC,EAAE,CAAC;oBACzB,KAAK,CAAC,CAAC,QAAQ,CAAC,eAAe,EAAE;wBAC/B,IAAI;wBACJ,IAAI,EAAE,KAAK,CAAC,QAAQ,IAAI,IAAI,CAAC,SAAS;wBACtC,OAAO,EAAE,KAAK,CAAC,OAAO,IAAI,IAAI;wBAC9B,OAAO,EAAE,CAAC,MAAM,CAAC;qBAClB,CAAC,CAAC;oBACH,OAAO;gBACT,CAAC;gBAED,KAAK,CAAC,CAAC,IAAI,CAAC,WAAW,EAAE;oBACvB,IAAI;oBACJ,IAAI,EAAE,KAAK,CAAC,QAAQ,IAAI,IAAI,CAAC,SAAS;oBACtC,OAAO,EAAE,KAAK,CAAC,OAAO,IAAI,IAAI;oBAC9B,QAAQ,EAAE,KAAK,CAAC,QAAQ,IAAI,CAAC;oBAC7B,QAAQ,EAAE,QAAS;oBACnB,OAAO,EAAE,CAAC,MAAM,CAAC;iBAClB,CAAC,CAAC;YACL,CAAC,CAAC,CACH,CAAC;QACJ,CAAC;QAED,4DAA4D;QAC5D,mDAAmD;QACnD,MAAM,GAAG,GAAG,CAAC,KAAK,CAAC,CAAC,cAAc,CAA+B,CAAC;QAClE,KAAK,CAAC,CAAC,GAAG,CAAC,MAAM,CAAY,CAAC,KAAK,EAAE,EAAE;YACrC,IAAI,CAAC,aAAa,CAAC,KAAK,CAAC,IAAI,KAAK,CAAC,IAAI,KAAK,OAAO;gBAAE,OAAO;YAE5D,MAAM,OAAO,GAAG,IAAI,CAAC,KAAK,CAAC,KAAmC,CAAC,CAAC;YAChE,2DAA2D;YAC3D,6DAA6D;YAC7D,gEAAgE;YAChE,gEAAgE;YAChE,gEAAgE;YAChE,wCAAwC;YACxC,OAAO,OAAO,CAAC,OAAO,CAAC,CAAC,IAAI,CAC1B,MAAM,CAAC,QAAQ,CAAC,CAAC,KAAK,EAAE,EAAE,CACxB,MAAM,CAAC,IAAI,CAAC,GAAG,EAAE;gBACf,OAAO,CAAC,KAAK,CACX,mDAAmD;oBACjD,IAAI,OAAO,CAAC,EAAE,MAAM,KAAK,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE,CAC5C,CAAC;YACJ,CAAC,CAAC,CACH;YACD,kEAAkE;YAClE,kEAAkE;YAClE,4DAA4D;YAC5D,MAAM,CAAC,KAAK,CACb,CAAC;QACJ,CAAC,CAAC,CAAC;IACL,CAAC,CAA4B,CAAC;AAChC,CAAC,CAAC,CACH,CAAC"}

package/lib/Cloudflare/Workers/LocalWorkerProvider.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"LocalWorkerProvider.d.ts","sourceRoot":"","sources":["../../../src/Cloudflare/Workers/LocalWorkerProvider.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,eAAe,EAQrB,MAAM,sCAAsC,CAAC;AAE9C,OAAO,KAAK,WAAW,MAAM,wDAAwD,CAAC;AAKtF,OAAO,KAAK,KAAK,UAAU,MAAM,mBAAmB,CAAC;AAGrD,OAAO,KAAK,IAAI,MAAM,aAAa,CAAC;AAEpC,OAAO,KAAK,KAAK,MAAM,cAAc,CAAC;AAGtC,OAAO,KAAK,KAAK,mBAAmB,MAAM,6CAA6C,CAAC;AAIxF,OAAO,EAAE,KAAK,EAAE,MAAM,gBAAgB,CAAC;AAEvC,OAAO,EAAE,qBAAqB,EAAE,MAAM,6BAA6B,CAAC;AACpE,OAAO,EAGL,iBAAiB,EAElB,MAAM,oBAAoB,CAAC;AAa5B,OAAO,EAAa,MAAM,EAAE,MAAM,aAAa,CAAC;AAmDhD,eAAO,MAAM,mBAAmB,yXAosC7B,CAAC"}
+{"version":3,"file":"LocalWorkerProvider.d.ts","sourceRoot":"","sources":["../../../src/Cloudflare/Workers/LocalWorkerProvider.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,eAAe,EAQrB,MAAM,sCAAsC,CAAC;AAE9C,OAAO,KAAK,WAAW,MAAM,wDAAwD,CAAC;AAMtF,OAAO,KAAK,KAAK,UAAU,MAAM,mBAAmB,CAAC;AAIrD,OAAO,KAAK,IAAI,MAAM,aAAa,CAAC;AAEpC,OAAO,KAAK,KAAK,MAAM,cAAc,CAAC;AAGtC,OAAO,KAAK,KAAK,mBAAmB,MAAM,6CAA6C,CAAC;AAIxF,OAAO,EAAE,KAAK,EAAE,MAAM,gBAAgB,CAAC;AAGvC,OAAO,EAAE,qBAAqB,EAAE,MAAM,6BAA6B,CAAC;AACpE,OAAO,EAGL,iBAAiB,EAElB,MAAM,oBAAoB,CAAC;AAa5B,OAAO,EAAa,MAAM,EAAE,MAAM,aAAa,CAAC;AAmDhD,eAAO,MAAM,mBAAmB,yXAu3C7B,CAAC"}

package/lib/Cloudflare/Workers/LocalWorkerProvider.js

@@ -4,6 +4,8 @@ import * as Cause from "effect/Cause";
 import * as Effect from "effect/Effect";
 import * as Equal from "effect/Equal";
 import * as Exit from "effect/Exit";
+import * as Fiber from "effect/Fiber";
+import * as PlatformFileSystem from "effect/FileSystem";
 import * as MutableHashMap from "effect/MutableHashMap";
 import * as Option from "effect/Option";
 import * as Path from "effect/Path";
@@ -15,6 +17,7 @@ import * as os from "node:os";
 import * as LocalProvider from "../../Local/LocalProvider.js";
 import { Stack } from "../../Stack.js";
 import { unwrapRedacted } from "../../Util/index.js";
+import { sha256 } from "../../Util/sha256.js";
 import { CloudflareEnvironment } from "../CloudflareEnvironment.js";
 import { isLiveId, LOCAL_ENTRY_URL, LocalRuntimeState, localStorageDirectory, } from "../LocalRuntime.js";
 import { readAssetsConfigFiles } from "./Assets.js";
@@ -238,6 +241,12 @@ export const LocalWorkerProvider = () => LocalProvider.make(Worker, LOCAL_ENTRY_
         // opt-out restarts the instance.
         const devRemote = {};
         const containers = {};
+        // Content hashes of the container images, keyed like `containers`.
+        // `ContainerImage` itself only carries stable paths (context /
+        // dockerfile / imageUri), so without the hash an image CONTENT
+        // change (a Dockerfile edit, a rebuilt bundle) would never change
+        // the config and the running container would serve stale code.
+        const containerHashes = {};
         for (const { data } of bindings) {
             for (const binding of data.bindings ?? []) {
                 if (binding.type === "durable_object_namespace" &&
@@ -296,6 +305,9 @@ export const LocalWorkerProvider = () => LocalProvider.make(Worker, LOCAL_ENTRY_
                         ...container.dev,
                         env: unwrapRedacted(container.dev.env),
                     };
+                    if (container.hash !== undefined) {
+                        containerHashes[container.className] = container.hash;
+                    }
                 }
             }
         }
@@ -345,6 +357,14 @@ export const LocalWorkerProvider = () => LocalProvider.make(Worker, LOCAL_ENTRY_
             durableObjectNamespaces: Object.values(durableObjectNamespaces),
             workflows: Object.values(workflows),
             hyperdrives,
+            /**
+             * Container image CONTENT hashes (className → hash). The DO
+             * namespace records above only carry the image's stable paths, so
+             * this is what makes an image content change — a Dockerfile edit,
+             * a rebuilt effectful bundle — restart the instance (which is
+             * what re-runs the docker build).
+             */
+            containerHashes,
             /**
              * External source-provider descriptor (plain JSON). Part of the
              * hashed config so changing the provider or its options restarts
@@ -447,6 +467,115 @@ export const LocalWorkerProvider = () => LocalProvider.make(Worker, LOCAL_ENTRY_
     // last good instance keeps serving until the replacement's first
     // serve completes. Ownership is tracked in `workerdScopes`, closed by
     // the next successful serve, by `delete`, or by provider shutdown.
+    /**
+     * One container-context watcher per worker id, keyed by the watched
+     * path set. Registry-held (NOT per-serve-scope): a worker restarts
+     * through several code paths that overlap scopes, and a watcher per
+     * serve produced DUPLICATES whose simultaneous restarts storm the
+     * instance until the DO's container link breaks.
+     */
+    const containerWatchers = new Map();
+    const stopContainerWatcher = (id) => Effect.suspend(() => {
+        const existing = containerWatchers.get(id);
+        if (existing === undefined)
+            return Effect.void;
+        containerWatchers.delete(id);
+        return Fiber.interrupt(existing.fiber).pipe(Effect.asVoid);
+    });
+    /**
+     * Watch a worker's Build-variant container contexts and restart the
+     * instance when their CONTENT changes — the docker build happens at
+     * instance start, so a restart IS the image rebuild.
+     *
+     * This is the reload path for USER-supplied Dockerfile/context
+     * containers: those files are not imported by the stack, so
+     * `bun --watch` never re-runs the exec child for them and no replan
+     * (hence no config-hash restart) ever fires. Generated contexts
+     * (under `.alchemy/`) are excluded — the effectful `main` variant
+     * rewrites its bundle there on every plan, which would loop; that
+     * variant reloads through the config's `containerHashes` instead.
+     *
+     * Events are debounced and gated on a content fingerprint
+     * (`node_modules`/`.git` skipped), so editor double-saves and
+     * metadata-only churn don't bounce the instance.
+     */
+    const ensureContainerWatcher = (worker, restart) => Effect.gen(function* () {
+        const fs = yield* PlatformFileSystem.FileSystem;
+        const watched = new Map();
+        for (const namespace of worker.durableObjectNamespaces) {
+            const image = namespace.container;
+            if (image === undefined || !("dockerfile" in image))
+                continue;
+            const context = path.resolve(image.context ?? ".");
+            if (context.split(path.sep).includes(".alchemy"))
+                continue;
+            watched.set(context, {
+                dockerfile: image.dockerfile !== undefined
+                    ? path.resolve(context, image.dockerfile)
+                    : undefined,
+            });
+        }
+        const key = JSON.stringify([...watched.entries()].sort());
+        const existing = containerWatchers.get(worker.id);
+        if (existing !== undefined) {
+            if (existing.key === key)
+                return; // same watcher keeps running
+            yield* stopContainerWatcher(worker.id);
+        }
+        if (watched.size === 0)
+            return;
+        const fingerprint = Effect.gen(function* () {
+            const hashes = [];
+            const walk = (dir) => Effect.gen(function* () {
+                const entries = yield* fs.readDirectory(dir);
+                for (const entry of entries.sort()) {
+                    if (entry === "node_modules" || entry === ".git")
+                        continue;
+                    const file = path.join(dir, entry);
+                    const stat = yield* fs.stat(file);
+                    if (stat.type === "Directory") {
+                        yield* walk(file);
+                    }
+                    else {
+                        hashes.push(`${file}:${yield* fs.readFile(file).pipe(Effect.flatMap(sha256))}`);
+                    }
+                }
+            });
+            for (const [context, { dockerfile }] of watched) {
+                yield* walk(context);
+                if (dockerfile !== undefined && !dockerfile.startsWith(context)) {
+                    hashes.push(`${dockerfile}:${yield* fs.readFile(dockerfile).pipe(Effect.flatMap(sha256))}`);
+                }
+            }
+            return yield* sha256(hashes.join("\n"));
+        }).pipe(Effect.orElseSucceed(() => undefined));
+        const streams = [...watched.entries()].flatMap(([context, { dockerfile }]) => [
+            fs.watch(context, { recursive: true }),
+            ...(dockerfile !== undefined && !dockerfile.startsWith(context)
+                ? [fs.watch(path.dirname(dockerfile))]
+                : []),
+        ]);
+        const watchLoop = Effect.gen(function* () {
+            let last = yield* fingerprint;
+            yield* Stream.mergeAll(streams, {
+                concurrency: streams.length,
+            }).pipe(Stream.debounce("500 millis"), Stream.runForEach(() => Effect.gen(function* () {
+                const next = yield* fingerprint;
+                if (next === undefined || next === last)
+                    return;
+                last = next;
+                yield* Effect.logInfo(`[${worker.id}] Container build context changed, restarting instance`);
+                yield* restart;
+            })), Effect.catchCause((cause) => Effect.logWarning(`[${worker.id}] Container context watch failed`, Cause.squash(cause))));
+        });
+        const fiber = yield* watchLoop.pipe(Effect.ensuring(Effect.sync(() => {
+            const current = containerWatchers.get(worker.id);
+            if (current?.fiber === fiber) {
+                containerWatchers.delete(worker.id);
+            }
+        })), Effect.forkIn(rootScope));
+        containerWatchers.set(worker.id, { key, fiber });
+    });
     const serveWith = (worker, bundle, proxy) => Semaphore.withPermits(serveLock(worker.id), 1)(
     // The bookkeeping around `runtime.start` must not be torn in half
     // by an interrupt: once a replacement workerd is up, it must be
@@ -516,6 +645,10 @@ export const LocalWorkerProvider = () => LocalProvider.make(Worker, LOCAL_ENTRY_
             // landing after the re-check find the hook; changes before it
             // are caught by the re-check. Nothing falls in between.
             MutableHashMap.set(localRuntimeState.workerRestarts, worker.name, restartWorker(worker.id));
+            // Idempotent: the registry keeps ONE watcher per worker id
+            // across restarts (a new one only when the watched path set
+            // changed).
+            yield* ensureContainerWatcher(worker, Effect.suspend(() => restartWorker(worker.id)));
             const currentConsumers = yield* getQueueConsumers(worker.name);
             if (JSON.stringify(currentConsumers) !==
                 JSON.stringify(queueConsumers)) {
@@ -567,6 +700,7 @@ export const LocalWorkerProvider = () => LocalProvider.make(Worker, LOCAL_ENTRY_
     // instance replacement does NOT go through this: the previous workerd
     // keeps serving until the replacement's first serve closes it.
     const closeWorkerd = Effect.fn(function* (id) {
+        yield* stopContainerWatcher(id);
         const scope = workerdScopes.get(id);
         if (scope) {
             workerdScopes.delete(id);