alchemy 2.0.0-beta.39 → 2.0.0-beta.40

package/src/Cloudflare/Workers/HttpServer.ts

@@ -1,12 +1,9 @@
 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 Option from "effect/Option";
 import type { Scope } from "effect/Scope";
 import type { HttpBodyError } from "effect/unstable/http/HttpBody";
-import * as EffectHttp from "effect/unstable/http/HttpEffect";
-import { ClientAbort } from "effect/unstable/http/HttpServerError";
 import * as HttpServerError from "effect/unstable/http/HttpServerError";
 import * as HttpServerRequest from "effect/unstable/http/HttpServerRequest";
 import * as HttpServerResponse from "effect/unstable/http/HttpServerResponse";
@@ -51,10 +48,6 @@ export const serveWebRequest = <Req = never>(
   Exclude<Req, HttpServerRequest.HttpServerRequest | Scope>
 > =>
   Effect.gen(function* () {
-    const context =
-      yield* Effect.context<
-        Exclude<Req, HttpServerRequest.HttpServerRequest | Scope>
-      >();
     const request = HttpServerRequest.fromWeb(
       webRequest as any as globalThis.Request,
     ).modify({
@@ -68,7 +61,9 @@ export const serveWebRequest = <Req = never>(
         }),
     });
 
-    const safeHandler = handler.pipe(
+    const response = yield* handler.pipe(
+      Effect.provideService(HttpServerRequest.HttpServerRequest, request),
+      Effect.provideService(Request, webRequest as any),
       Effect.catchCause((cause) => {
         const message = Option.match(Cause.findErrorOption(cause), {
           onNone: () => "Internal Server Error",
@@ -86,34 +81,7 @@ export const serveWebRequest = <Req = never>(
       }),
     );
 
-    const resolveSymbol = Symbol.for("@effect/platform/HttpApp/resolve");
-    const httpApp = EffectHttp.toHandled(safeHandler, (request, response) => {
-      response = EffectHttp.scopeTransferToStream(response);
-      (request as any)[resolveSymbol](
-        HttpServerResponse.toWeb(response, {
-          withoutBody: request.method === "HEAD",
-          context,
-        }),
-      );
-      return Effect.void;
-    });
-
-    return yield* Effect.promise(() => {
-      return new Promise<Response>((resolve) => {
-        const contextMap = new Map<string, any>(context.mapUnsafe);
-        contextMap.set(HttpServerRequest.HttpServerRequest.key, request);
-        contextMap.set(Request.key, webRequest);
-        (request as any)[resolveSymbol] = resolve;
-        const fiber = Effect.runForkWith(Context.makeUnsafe(contextMap))(
-          httpApp as any,
-        );
-        webRequest.signal?.addEventListener(
-          "abort",
-          () => {
-            fiber.interruptUnsafe(undefined, ClientAbort.annotation);
-          },
-          { once: true },
-        );
-      });
+    return HttpServerResponse.toWeb(response, {
+      context: yield* Effect.context(),
     });
   }) as any;

package/src/Cloudflare/Workers/LocalWorkerProvider.ts

@@ -1,130 +1,37 @@
-import type { HyperdriveOrigin } from "@distilled.cloud/cloudflare-runtime/Worker";
 import * as Effect from "effect/Effect";
-import * as Redacted from "effect/Redacted";
 import * as Provider from "../../Provider.ts";
-import type { ResourceBinding } from "../../Resource.ts";
 import { Stack } from "../../Stack.ts";
-import { CloudflareEnvironment } from "../CloudflareEnvironment.ts";
 import { Sidecar } from "../Local/Sidecar.ts";
-import { getCompatibility } from "./Compatibility.ts";
-import {
-  getCronBindings,
-  Worker,
-  type WorkerBinding,
-  type WorkerProps,
-} from "./Worker.ts";
-import { createWorkerName } from "./WorkerName.ts";
+import { Worker } from "./Worker.ts";
 
 export const LocalWorkerProvider = () =>
   Provider.effect(
     Worker,
     Effect.gen(function* () {
-      const { accountId } = yield* CloudflareEnvironment;
       const stack = yield* Stack;
       const sidecar = yield* Sidecar;
-
-      const run = Effect.fn(function* (
-        id: string,
-        props: WorkerProps,
-        bindings: ResourceBinding<Worker["Binding"]>[],
-      ) {
-        const name = yield* createWorkerName(id, props.name);
-        const workerBindings: WorkerBinding[] = [];
-        const durableObjectNamespaces: Record<string, string> = {};
-        const hyperdrives: Record<string, Required<HyperdriveOrigin>> = {};
-        for (const { sid, data } of bindings) {
-          for (const binding of data.bindings ?? []) {
-            workerBindings.push(binding);
-            if (binding.type === "durable_object_namespace") {
-              durableObjectNamespaces[binding.name] = sid;
-            }
-          }
-          if (data.hyperdrives) {
-            for (const [id, origin] of Object.entries(data.hyperdrives)) {
-              hyperdrives[id] = {
-                scheme: origin.scheme,
-                host: origin.host,
-                port: origin.port,
-                user: origin.user,
-                database: origin.database,
-                password: Redacted.isRedacted(origin.password)
-                  ? Redacted.value(origin.password)
-                  : origin.password,
-                sslmode: origin.sslmode,
-              };
-            }
-          }
-        }
-        for (const [key, value] of Object.entries(props.env ?? {})) {
-          if (value === undefined) continue;
-          if (Redacted.isRedacted(value)) {
-            workerBindings.push({
-              type: "secret_text",
-              name: key,
-              text: Redacted.value(value),
-            });
-          } else if (typeof value === "string") {
-            workerBindings.push({
-              type: "plain_text",
-              name: key,
-              text: value,
-            });
-          } else {
-            workerBindings.push({
-              type: "json",
-              name: key,
-              json: value,
-            });
-          }
-        }
-        const result = yield* sidecar.serve({
-          id,
-          name,
-          main: props.main,
-          compatibility: getCompatibility(props),
-          entry: props.isExternal
-            ? {
-                kind: "external",
-              }
-            : {
-                kind: "effect",
-                exports: (props.exports ?? {}) as any,
-              },
-          stack: { name: stack.name, stage: stack.stage },
-          bindings: workerBindings,
-          hyperdrives,
-          durableObjectNamespaces: Object.entries(durableObjectNamespaces).map(
-            ([className, namespaceId]) => ({
-              className,
-              uniqueKey: namespaceId,
-              sql: true,
-            }),
-          ),
-          userOptions: props.build,
-        });
-        return {
-          workerId: name,
-          workerName: name,
-          logpush: undefined,
-          url: result.address,
-          tags: [],
-          durableObjectNamespaces,
-          domains: [],
-          crons: Array.from(
-            new Set([...getCronBindings(bindings), ...(props.crons ?? [])]),
-          ),
-          accountId,
-        } satisfies Worker["Attributes"];
-      });
-
       return {
-        diff: () => Effect.succeed({ action: "update" }),
+        diff: ({ id, news, newBindings, instanceId }) =>
+          sidecar.diff({
+            id,
+            props: news as any,
+            bindings: newBindings as any,
+            stack,
+            instanceId,
+          }),
         // The local sidecar `serve` operation is itself a true upsert:
         // it tears down any existing process for the worker name and
         // starts a fresh one with the latest bindings, so observe and
         // sync collapse into a single sidecar call.
-        reconcile: ({ id, news, bindings }) => run(id, news, bindings),
-        delete: ({ output }) => sidecar.stop(output.workerName),
+        reconcile: ({ id, news, bindings, instanceId }) =>
+          sidecar.reconcile({
+            id,
+            props: news,
+            bindings,
+            stack,
+            instanceId,
+          }),
+        delete: ({ id }) => sidecar.delete(id),
       };
     }),
   );

package/src/Cloudflare/Workers/Vite.ts

@@ -0,0 +1,114 @@
+import cloudflare, {
+  type CloudflareVitePluginOptions,
+} from "@distilled.cloud/cloudflare-vite-plugin";
+import * as Effect from "effect/Effect";
+import * as Redacted from "effect/Redacted";
+import { createRequire } from "node:module";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+import type * as vite from "vite";
+
+export const viteDev = (
+  rootDir: string = process.cwd(),
+  env: Record<string, unknown>,
+  pluginOptions: CloudflareVitePluginOptions,
+) =>
+  Effect.acquireRelease(
+    Effect.promise(async () => {
+      const vite = await loadVite(rootDir);
+      const devServer = await vite.createServer({
+        root: rootDir,
+        define: getDefine(env),
+        plugins: [cloudflare(pluginOptions)],
+      });
+      await devServer.listen();
+      return devServer;
+    }),
+    (devServer) =>
+      Effect.promise(async () => {
+        await devServer.close();
+      }),
+  );
+
+export const viteBuild = (
+  rootDir: string = process.cwd(),
+  env: Record<string, unknown>,
+  pluginOptions: CloudflareVitePluginOptions,
+) =>
+  Effect.promise(async () => {
+    let serverBundle: vite.Rolldown.OutputBundle | undefined;
+    let assetsDirectory: string | undefined;
+    const vite = await loadVite(rootDir);
+    const builder = await vite.createBuilder(
+      {
+        root: rootDir,
+        define: getDefine(env),
+        plugins: [
+          cloudflare(pluginOptions),
+          {
+            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();
+    return {
+      serverBundle,
+      assetsDirectory,
+    };
+  });
+
+// Emulate `vite build` env semantics for `props.env`: only
+// keys with Vite's default `VITE_` prefix are inlined into
+// the bundle as `import.meta.env.*`. `Redacted` values are
+// unwrapped — by prefixing with `VITE_` the user is opting
+// them into the public bundle.
+const getDefine = (env: Record<string, unknown>) =>
+  Object.fromEntries(
+    Object.entries(env).flatMap(([key, raw]) => {
+      if (!key.startsWith("VITE_")) return [];
+      const value = Redacted.isRedacted(raw) ? Redacted.value(raw) : raw;
+      return [[`import.meta.env.${key}`, JSON.stringify(value)] as const];
+    }),
+  );
+
+type ViteModule = typeof import("vite");
+
+/**
+ * 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(
+  projectRoot: string = process.cwd(),
+): Promise<ViteModule> {
+  try {
+    const require = createRequire(path.join(projectRoot, "package.json"));
+    const vitePath = require.resolve("vite");
+    // On Windows, absolute paths must be file:// URLs for ESM import().
+    const viteUrl = pathToFileURL(vitePath);
+    return await import(/* @vite-ignore */ viteUrl.href);
+  } catch {
+    // Fallback: try to import vite from the global node_modules (works for non-linked installs)
+    // The fallback is a bare specifier and works as-is.
+    return await import("vite");
+  }
+}

package/src/Cloudflare/Workers/Worker.ts

@@ -1,5 +1,4 @@
 import type * as cf from "@cloudflare/workers-types";
-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 Cause from "effect/Cause";
@@ -14,12 +13,9 @@ import * as Redacted from "effect/Redacted";
 import * as Schedule from "effect/Schedule";
 import * as Scope from "effect/Scope";
 import * as Stream from "effect/Stream";
-import { createRequire } from "node:module";
-import path from "node:path";
-import { pathToFileURL } from "node:url";
-import type * as vite from "vite";
 import { Unowned } from "../../AdoptPolicy.ts";
 import { AlchemyContext } from "../../AlchemyContext.ts";
+import * as Artifacts from "../../Artifacts.ts";
 import * as Binding from "../../Binding.ts";
 import { hashDirectory, type MemoOptions } from "../../Build/Memo.ts";
 import * as Bundle from "../../Bundle/Bundle.ts";
@@ -91,6 +87,7 @@ import {
   type RpcErrorEnvelope,
   type RpcStreamEnvelope,
 } from "./Rpc.ts";
+import * as Vite from "./Vite.ts";
 import { WorkerBundle } from "./WorkerBundle.ts";
 import { createWorkerName } from "./WorkerName.ts";
 
@@ -1592,92 +1589,35 @@ export const LiveWorkerProvider = () =>
       });
 
       const prepareBundle = (id: string, props: WorkerProps) =>
-        bundler.build({
-          id,
-          main: props.main,
-          compatibility: getCompatibility(props),
-          entry: props.isExternal
-            ? {
-                kind: "external",
-              }
-            : {
-                kind: "effect",
-                exports: (props.exports ?? {}) as any,
-              },
-          stack: { name: stack.name, stage: stack.stage },
-          userOptions: props.build,
-        });
+        bundler
+          .build({
+            id,
+            main: props.main,
+            compatibility: getCompatibility(props),
+            entry: props.isExternal
+              ? {
+                  kind: "external",
+                }
+              : {
+                  kind: "effect",
+                  exports: (props.exports ?? {}) as any,
+                },
+            stack: { name: stack.name, stage: stack.stage },
+            userOptions: props.build,
+          })
+          .pipe(Artifacts.cached("build"));
 
       const viteBuild = Effect.fnUntraced(function* (props: WorkerProps) {
-        let assetsDirectory: string | undefined;
-        let serverBundle: vite.Rolldown.OutputBundle | undefined;
         const compatibility = getCompatibility(props);
+        const { assetsDirectory, serverBundle } = yield* Vite.viteBuild(
+          props.vite?.rootDir,
+          props.env ?? {},
+          {
+            compatibilityDate: compatibility.date,
+            compatibilityFlags: compatibility.flags,
+          },
+        );
 
-        yield* Effect.promise(async () => {
-          const vite = await loadVite(props.vite?.rootDir);
-          const builder = await vite.createBuilder(
-            {
-              root: props.vite?.rootDir,
-              // Emulate `vite build` env semantics for `props.env`: only
-              // keys with Vite's default `VITE_` prefix are inlined into
-              // the bundle as `import.meta.env.*`. `Redacted` values are
-              // unwrapped — by prefixing with `VITE_` the user is opting
-              // them into the public bundle.
-              define: Object.fromEntries(
-                Object.entries(props.env ?? {}).flatMap(([key, raw]) => {
-                  if (!key.startsWith("VITE_")) return [];
-                  const value = Redacted.isRedacted(raw)
-                    ? Redacted.value(raw)
-                    : raw;
-                  return [
-                    [`import.meta.env.${key}`, JSON.stringify(value)] as const,
-                  ];
-                }),
-              ),
-              // 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,
-                  },
-                },
-              },
-              plugins: [
-                cloudflareVite({
-                  compatibilityDate: compatibility.date,
-                  compatibilityFlags: compatibility.flags,
-                }),
-                {
-                  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"),
@@ -2623,25 +2563,3 @@ const contentTypeFromExtension = (extension: string) => {
       return "application/octet-stream";
   }
 };
-
-type ViteModule = typeof import("vite");
-
-/**
- * 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(
-  projectRoot: string = process.cwd(),
-): Promise<ViteModule> {
-  try {
-    const require = createRequire(path.join(projectRoot, "package.json"));
-    const vitePath = require.resolve("vite");
-    // On Windows, absolute paths must be file:// URLs for ESM import().
-    const viteUrl = pathToFileURL(vitePath);
-    return await import(/* @vite-ignore */ viteUrl.href);
-  } catch {
-    // Fallback: try to import vite from the global node_modules (works for non-linked installs)
-    // The fallback is a bare specifier and works as-is.
-    return await import("vite");
-  }
-}

package/src/Cloudflare/Workers/WorkerBundle.ts

@@ -7,7 +7,6 @@ import * as Stream from "effect/Stream";
 import { fileURLToPath } from "node:url";
 import type * as rolldown from "rolldown";
 import Sonda from "sonda/rolldown";
-import * as Artifacts from "../../Artifacts.ts";
 import * as Bundle from "../../Bundle/Bundle.ts";
 import { findCwdForBundle } from "../../Bundle/TempRoot.ts";
 import { Self } from "../../Self.ts";
@@ -64,9 +63,11 @@ export const WorkerBundle = Effect.gen(function* () {
           compatibilityFlags: options.compatibility.flags,
         }),
         options.entry.kind === "effect"
-          ? virtualEntryPlugin(
-              makeEffectVirtualEntry(options.entry.exports, options.stack),
-            )
+          ? [
+              virtualEntryPlugin(
+                makeEffectVirtualEntry(options.entry.exports, options.stack),
+              ),
+            ]
           : undefined,
         ...(options.userOptions?.metafile ? [Sonda({ open: false })] : []),
       ],
@@ -116,7 +117,6 @@ export const WorkerBundle = Effect.gen(function* () {
           resolved.extraOptions,
         ),
       ),
-      Artifacts.cached("build"),
     ),
     watch: flow(
       makeOptions,
@@ -160,12 +160,12 @@ import * as Stream from "effect/Stream";
 
 import { env, DurableObject, WorkerEntrypoint${hasWfClasses ? ", WorkflowEntrypoint" : ""} } from "cloudflare:workers";
 import { MinimumLogLevel } from "effect/References";
-import { NodeServices } from "@effect/platform-node";
+import * as NodeServices from "@effect/platform-node/NodeServices";
 import { Stack } from "alchemy/Stack";
 import { WorkerEnvironment, makeDurableObjectBridge, makeWorkerBridge${hasWfClasses ? ", makeWorkflowBridge" : ""}, ExportedHandlerMethods } from "alchemy/Cloudflare";
 import { makeEntrypointLayer } from "alchemy/Runtime";
 
-import entrypoint from "${importPath}";
+import entrypoint from ${JSON.stringify(importPath)};
 
 const tag = Context.Service("${Self.key}")
 const layer = makeEntrypointLayer(tag, entrypoint);

package/src/Diff.ts

@@ -87,26 +87,47 @@ export const havePropsChanged = <Props extends object>(
   newProps: Props,
 ) =>
   Output.hasOutputs(newProps) ||
-  JSON.stringify(canonicalize(oldProps ?? {})) !==
-    JSON.stringify(canonicalize(newProps ?? {}));
+  JSON.stringify(canonicalize(oldProps ?? {}, false)) !==
+    JSON.stringify(canonicalize(newProps ?? {}, false));
+
+export type DeepEqualOptions = {
+  /**
+   * When true, treat `null` and `undefined` as equivalent at any depth.
+   * Useful when comparing cloud-API responses (which often return `null`
+   * for unconfigured optional fields) against desired-state shapes built
+   * from `props?.x` (which leave the same fields `undefined`).
+   *
+   * @default false
+   */
+  stripNullish?: boolean;
+};
 
 /**
  * Sort-keys deep equality for plain data (objects, arrays, primitives).
  * Use in provider `diff` handlers instead of ad-hoc `JSON.stringify` comparisons.
+ *
+ * By default, `null` and `undefined` are treated as distinct. Pass
+ * `{ stripNullish: true }` to opt into treating them as equivalent.
  */
-export const deepEqual = (a: unknown, b: unknown): boolean =>
-  JSON.stringify(canonicalize(a ?? undefined)) ===
-  JSON.stringify(canonicalize(b ?? undefined));
+export const deepEqual = (
+  a: unknown,
+  b: unknown,
+  options?: DeepEqualOptions,
+): boolean =>
+  JSON.stringify(canonicalize(a, options?.stripNullish ?? false)) ===
+  JSON.stringify(canonicalize(b, options?.stripNullish ?? false));
 
-const canonicalize = (value: unknown): unknown => {
+const canonicalize = (value: unknown, stripNullish: boolean): unknown => {
+  if (stripNullish && value == null) return undefined;
   if (Array.isArray(value)) {
-    return value.map(canonicalize);
+    return value.map((v) => canonicalize(v, stripNullish));
   }
   if (value && typeof value === "object") {
     return Object.fromEntries(
       Object.entries(value)
+        .filter(([, nested]) => !stripNullish || nested != null)
         .sort(([a], [b]) => a.localeCompare(b))
-        .map(([key, nested]) => [key, canonicalize(nested)]),
+        .map(([key, nested]) => [key, canonicalize(nested, stripNullish)]),
     );
   }
   return value;

package/src/Http.ts

@@ -61,18 +61,22 @@ export const safeHttpEffect = <Req = never>(
       ),
     ) as any as HttpEffect<Req>,
     (cause) => {
-      const message = Option.match(Cause.findErrorOption(cause), {
-        onNone: () => "Internal Server Error",
-        onSome: (error) => error.message ?? "Internal Server Error",
-      });
-
-      return Effect.map(
-        Effect.all([Effect.logError(message), Effect.logError(cause)]),
-        () =>
-          HttpServerResponse.text(message, {
+      // ClientAbort interrupts are not real failures — the client closed
+      // the connection. Skip logging and respond with 499 if applicable.
+      if (Cause.hasInterruptsOnly(cause)) {
+        return Effect.succeed(HttpServerResponse.empty({ status: 499 }));
+      }
+      // Log the full cause server-side so operators can debug, but return
+      // a generic 500 to the client. Causes can contain sensitive data
+      // (prompt contents, API keys baked into error messages, internal
+      // file paths) and should never be echoed back to the network.
+      return Effect.logError("HTTP handler failed", cause).pipe(
+        Effect.as(
+          HttpServerResponse.text("Internal Server Error", {
             status: 500,
-            statusText: message,
+            statusText: "Internal Server Error",
           }),
+        ),
       );
     },
   );