alchemy 2.0.0-beta.43 → 2.0.0-beta.44

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "alchemy",
-  "version": "2.0.0-beta.43",
+  "version": "2.0.0-beta.44",
   "homepage": "https://alchemy.run",
   "license": "Apache-2.0",
   "author": "Sam Goodwin <sam@alchemy.run>",
@@ -288,18 +288,18 @@
     "access": "public"
   },
   "dependencies": {
-    "@alchemy.run/node-utils": "0.0.2",
+    "@alchemy.run/node-utils": "0.0.4",
     "@aws-sdk/credential-providers": "^3.0.0",
     "@clack/prompts": "^0.11.0",
-    "@distilled.cloud/aws": "^0.21.3",
-    "@distilled.cloud/axiom": "^0.21.3",
-    "@distilled.cloud/cloudflare": "^0.21.3",
-    "@distilled.cloud/cloudflare-rolldown-plugin": "0.5.4",
-    "@distilled.cloud/cloudflare-runtime": "0.5.4",
-    "@distilled.cloud/cloudflare-vite-plugin": "0.5.4",
-    "@distilled.cloud/core": "^0.21.3",
-    "@distilled.cloud/planetscale": "^0.21.3",
-    "@distilled.cloud/neon": "^0.21.3",
+    "@distilled.cloud/aws": "^0.21.5",
+    "@distilled.cloud/axiom": "^0.21.5",
+    "@distilled.cloud/cloudflare": "^0.21.5",
+    "@distilled.cloud/cloudflare-rolldown-plugin": "0.6.3",
+    "@distilled.cloud/cloudflare-runtime": "0.6.3",
+    "@distilled.cloud/cloudflare-vite-plugin": "0.6.3",
+    "@distilled.cloud/core": "^0.21.5",
+    "@distilled.cloud/neon": "^0.21.5",
+    "@distilled.cloud/planetscale": "^0.21.5",
     "@effect/vitest": ">=4.0.0-beta.66 || >=4.0.0",
     "@libsql/client": "^0.17.0",
     "@octokit/rest": "^22.0.1",
@@ -311,7 +311,6 @@
     "capnweb": "^0.6.1",
     "fast-glob": "^3.3.2",
     "fast-xml-parser": "^5.3.4",
-    "foreground-child": "^4.0.3",
     "ink": "^6.3.1",
     "jszip": "^3.10.1",
     "libsodium-wrappers": "^0.8.3",
@@ -321,8 +320,7 @@
     "pg": "^8.13.0",
     "picomatch": "^4.0.4",
     "react": "^19.2.0",
-    "rolldown": "1.0.0-rc.17",
-    "sonda": "^0.11.1",
+    "rolldown": "1.0.1",
     "undici": "^7.16.0",
     "yaml": "^2.0.0"
   },

package/src/Auth/Lock.ts

@@ -1,4 +1,4 @@
-import * as lockfile from "@alchemy.run/node-utils";
+import { lock } from "@alchemy.run/node-utils/lockfile";
 import * as Effect from "effect/Effect";
 import * as fs from "node:fs/promises";
 import * as path from "pathe";
@@ -24,7 +24,7 @@ export const withLock = <A, E, R>(
   return Effect.acquireUseRelease(
     Effect.promise(async () => {
       await fs.mkdir(lockDir, { recursive: true });
-      return await lockfile.lock(lockPath, {
+      return await lock(lockPath, {
         retries: { retries: 600, minTimeout: 50, maxTimeout: 50 },
         stale: 5_000,
         realpath: false,

package/src/Bundle/Bundle.ts

@@ -6,7 +6,12 @@ import * as Stream from "effect/Stream";
 import assert from "node:assert";
 import * as rolldown from "rolldown";
 import { sha256, sha256Object } from "../Util/sha256.ts";
+import {
+  bundleAnalyzerPlugin,
+  type BundleAnalyzerPluginOptions,
+} from "./BundleAnalyzerPlugin.ts";
 import { purePlugin, type PurePluginOptions } from "./PurePlugin.ts";
+import { rawPlugin } from "./RawPlugin.ts";
 
 /**
  * Extra options accepted by {@link build} / {@link watch} on top of the
@@ -24,6 +29,16 @@ export interface BundleExtraOptions {
    * - `false`: plugin is disabled.
    */
   readonly pure?: PurePluginOptions | false;
+  /**
+   * Configures the {@link bundleAnalyzerPlugin} which emits a bundle analysis
+   * report alongside the bundle output, describing chunks, modules, and the
+   * import graph reachable from each entry point.
+   *
+   * - `undefined` / `false` (default): plugin is disabled.
+   * - `true`: plugin is enabled with default options.
+   * - `BundleAnalyzerPluginOptions`: plugin is enabled with the provided options.
+   */
+  readonly bundleAnalyzer?: BundleAnalyzerPluginOptions | boolean;
 }
 
 export interface BundleOutput {
@@ -86,7 +101,7 @@ export const build = (
     try: async () => {
       const bundle = await rolldown.rolldown({
         ...inputOptions,
-        plugins: withPurePlugin(inputOptions.plugins, extra?.pure),
+        plugins: [inputOptions.plugins, builtInPlugins(extra)],
         optimization: inputOptions.optimization ?? {
           inlineConst: {
             mode: "smart",
@@ -94,7 +109,7 @@ export const build = (
           },
         },
       });
-      const result = await bundle.generate(outputOptions);
+      const result = await bundle.write(outputOptions);
       await bundle.close();
       return result.output;
     },
@@ -128,7 +143,8 @@ export const watch = (
         const watcher = rolldown.watch({
           ...inputOptions,
           plugins: [
-            withPurePlugin(inputOptions.plugins, extra?.pure),
+            inputOptions.plugins,
+            builtInPlugins(extra),
             // The watcher event listener does not receive the bundle output, so we grab it using a plugin.
             {
               name: "alchemy:watch-bundle",
@@ -266,19 +282,25 @@ export function bundleOutputFromRolldownOutputBundle(
 }
 
 /**
- * Composes the user-provided plugin chain with the default
- * {@link purePlugin} according to the `pure` option.
+ * Returns the built-in plugins appended after the user-provided plugin chain,
+ * configured by {@link BundleExtraOptions}.
  *
- * The pure plugin is appended LAST so it sees module ids that have already
- * been resolved into `node_modules/<pkg>/...` by upstream resolver plugins
- * such as `@distilled.cloud/cloudflare-rolldown-plugin`.
+ * These run LAST so they see module ids that have already been resolved into
+ * `node_modules/<pkg>/...` by upstream resolver plugins such as
+ * `@distilled.cloud/cloudflare-rolldown-plugin`.
  */
-function withPurePlugin(
-  plugins: rolldown.RolldownPluginOption,
-  pure: PurePluginOptions | false | undefined,
+function builtInPlugins(
+  extra?: BundleExtraOptions,
 ): rolldown.RolldownPluginOption {
-  if (pure === false) return plugins;
-  return [plugins, purePlugin(pure ?? {})];
+  return [
+    extra?.bundleAnalyzer
+      ? bundleAnalyzerPlugin(
+          extra.bundleAnalyzer === true ? {} : extra.bundleAnalyzer,
+        )
+      : undefined,
+    extra?.pure !== false ? purePlugin(extra?.pure ?? {}) : undefined,
+    rawPlugin(),
+  ];
 }
 
 function bundleErrorFromUnknown(error: unknown): BundleError {

package/src/Bundle/BundleAnalyzerPlugin.ts

@@ -0,0 +1,33 @@
+import type { Plugin } from "rolldown";
+import { bundleAnalyzerPlugin as rolldownBundleAnalyzerPlugin } from "rolldown/experimental";
+
+export interface BundleAnalyzerPluginOptions {
+  /**
+   * The filename of the bundle analysis data.
+   * @default "analyze-data.md"
+   */
+  readonly fileName?: string;
+  /**
+   * The format of the bundle analysis data.
+   * @default "md"
+   */
+  readonly format?: "json" | "md";
+}
+
+/**
+ * Wraps rolldown's experimental bundle analyzer plugin, which emits a report
+ * describing the composition of the bundle.
+ *
+ * The report includes:
+ * - all chunks and their relationships
+ * - the modules bundled into each chunk
+ * - import dependencies between chunks
+ * - the modules reachable from each entry point
+ */
+export const bundleAnalyzerPlugin = (
+  options: BundleAnalyzerPluginOptions = {},
+): Plugin =>
+  rolldownBundleAnalyzerPlugin({
+    fileName: options.fileName,
+    format: options.format ?? "md",
+  });

package/src/Bundle/RawPlugin.ts

@@ -0,0 +1,82 @@
+import type * as rolldown from "rolldown";
+
+/**
+ * Matches `?raw` or `&raw` query suffixes, mirroring Vite's `rawRE`
+ * (see `vite/src/node/utils.ts`). Used to gate both `resolveId` and
+ * `load` so the plugin only inspects ids that opt in.
+ */
+export const RAW_RE: RegExp = /(\?|&)raw(?:&|$)/;
+
+/**
+ * Rolldown plugin that adds Vite-style `?raw` import support to the
+ * Alchemy bundler.
+ *
+ * Importing a file with the `?raw` suffix inlines its contents as the
+ * default export of a JS module:
+ *
+ * ```ts
+ * import sql from "./schema.sql?raw";
+ * //         ^ string — the file contents read as UTF-8
+ * ```
+ *
+ * This plugin only implements `?raw`. Vite's `?url` and `?inline`
+ * variants both rely on a browser asset pipeline (URL serving / `data:`
+ * fallback) that has no analogue in the server-side bundles produced
+ * here (Cloudflare Workers, AWS Lambda), so they are intentionally
+ * omitted.
+ */
+export const rawPlugin = (): rolldown.Plugin => ({
+  name: "alchemy:raw",
+  resolveId: {
+    filter: { id: RAW_RE },
+    async handler(source, importer) {
+      const [base, query] = splitFileAndPostfix(source);
+      const resolved = await this.resolve(base, importer, { skipSelf: true });
+      if (!resolved || resolved.external) return null;
+      return { id: resolved.id + query, moduleSideEffects: false };
+    },
+  },
+  load: {
+    filter: { id: RAW_RE },
+    async handler(id) {
+      const file = id.replace(/[?#].*$/, "");
+      const contents = await this.fs.readFile(file, { encoding: "utf8" });
+      return {
+        code: `export default ${JSON.stringify(contents)};`,
+        // Empty mappings = "this module has no meaningful source map".
+        // The generated code is a synthetic `export default "..."` that
+        // doesn't correspond line-for-line to any source file (the
+        // underlying file isn't JS), so there's nothing to map. Supplying
+        // `{ mappings: "" }` (rather than omitting `map`) opts the module
+        // out of source-map generation without making rolldown synthesize
+        // a default one from the loaded code.
+        map: { mappings: "" },
+        // NOTE: matches Vite — avoids a double `export default` if the
+        // file extension would otherwise be picked up by another loader
+        // (e.g. `?raw&.json`).
+        moduleType: "js",
+      };
+    },
+  },
+});
+
+/**
+ * Splits an id into its file portion and the query/hash postfix (kept
+ * with the leading `?` / `#`). Matches Vite's `splitFileAndPostfix`.
+ *
+ * @example
+ *   splitFileAndPostfix("./foo.txt?raw") // => ["./foo.txt", "?raw"]
+ *   splitFileAndPostfix("./foo.txt")     // => ["./foo.txt", ""]
+ */
+export function splitFileAndPostfix(id: string): [string, string] {
+  const queryIdx = id.indexOf("?");
+  const hashIdx = id.indexOf("#");
+  const idx =
+    queryIdx === -1
+      ? hashIdx
+      : hashIdx === -1
+        ? queryIdx
+        : Math.min(queryIdx, hashIdx);
+  if (idx === -1) return [id, ""];
+  return [id.slice(0, idx), id.slice(idx)];
+}

package/src/Bundle/index.ts

@@ -1,4 +1,6 @@
 export * from "./Bundle.ts";
+export * from "./BundleAnalyzerPlugin.ts";
 export * from "./Docker.ts";
 export * from "./PurePlugin.ts";
+export * from "./RawPlugin.ts";
 export * from "./TempRoot.ts";

package/src/Cli/commands/dev.ts

@@ -1,8 +1,11 @@
 import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
 import * as Schema from "effect/Schema";
 import * as Command from "effect/unstable/cli/Command";
 import * as ChildProcess from "effect/unstable/process/ChildProcess";
 import { fileURLToPath } from "node:url";
+import { SPAWNER_URL_ENV_KEY } from "../../Local/RpcProviderProxy.ts";
+import * as RpcSpawner from "../../Local/RpcSpawner.ts";
 import { envFile, force, profile, script, stage } from "./_shared.ts";
 import { ExecStackOptions } from "./deploy.ts";
 
@@ -15,41 +18,52 @@ export const devCommand = Command.make(
     stage,
     profile,
   },
-  Effect.fn(function* (args) {
-    const options = yield* Schema.encodeEffect(ExecStackOptions)({
-      ...args,
-      yes: true,
-      dev: true,
-    });
-    // We no longer force Bun in development because this prevents us from testing in Node.
-    const command =
-      typeof globalThis.Bun !== "undefined"
-        ? [
-            "bun",
-            "run",
-            ...process.execArgv,
-            "--watch",
-            "--no-clear-screen",
-            fileURLToPath(import.meta.resolve("alchemy/bin/exec.ts")),
-          ]
-        : [
-            "node",
-            ...process.execArgv,
-            "--experimental-transform-types",
-            "--watch",
-            "--watch-preserve-output",
-            fileURLToPath(import.meta.resolve("alchemy/bin/exec.js")),
-          ];
-    const child = yield* ChildProcess.make(command[0], command.slice(1), {
-      stdin: "inherit",
-      stdout: "inherit",
-      stderr: "inherit",
-      env: {
-        ALCHEMY_EXEC_OPTIONS: JSON.stringify(options),
-      },
-      extendEnv: true,
-      detached: false,
-    });
-    yield* child.exitCode;
-  }),
+  Effect.fn(
+    function* (args) {
+      const options = yield* Schema.encodeEffect(ExecStackOptions)({
+        ...args,
+        yes: true,
+        dev: true,
+      });
+      const spawner = yield* RpcSpawner.RpcSpawner;
+      // We no longer force Bun in development because this prevents us from testing in Node.
+      const command =
+        typeof globalThis.Bun !== "undefined"
+          ? [
+              "bun",
+              "run",
+              ...process.execArgv,
+              "--watch",
+              "--no-clear-screen",
+              fileURLToPath(import.meta.resolve("alchemy/bin/exec.ts")),
+            ]
+          : [
+              "node",
+              ...process.execArgv,
+              "--experimental-transform-types",
+              "--watch",
+              "--watch-preserve-output",
+              fileURLToPath(import.meta.resolve("alchemy/bin/exec.js")),
+            ];
+      const child = yield* ChildProcess.make(command[0], command.slice(1), {
+        stdin: "inherit",
+        stdout: "inherit",
+        stderr: "inherit",
+        env: {
+          ALCHEMY_EXEC_OPTIONS: JSON.stringify(options),
+          [SPAWNER_URL_ENV_KEY]: spawner.url,
+        },
+        extendEnv: true,
+        detached: false,
+      });
+      yield* child.exitCode;
+    },
+    (effect, args) =>
+      Effect.provide(
+        RpcSpawner.layerServer({
+          profile: args.profile,
+          envFile: Option.getOrUndefined(args.envFile),
+        }),
+      )(effect),
+  ),
 );

package/src/Cli/exec.ts

@@ -7,17 +7,22 @@ import * as FetchHttpClient from "effect/unstable/http/FetchHttpClient";
 import { AlchemyContextLive } from "../AlchemyContext.ts";
 import { CredentialsStoreLive } from "../Auth/Credentials.ts";
 import { ProfileLive } from "../Auth/Profile.ts";
+import * as RpcProviderProxy from "../Local/RpcProviderProxy.ts";
 import { PlatformServices } from "../Util/PlatformServices.ts";
 import { execStack, ExecStackOptions } from "./commands/deploy.ts";
 import { selectCli } from "./selectCli.ts";
 
-const services = Layer.mergeAll(
-  Layer.provideMerge(AlchemyContextLive, PlatformServices),
-  Layer.provide(ProfileLive, PlatformServices),
-  Layer.provide(CredentialsStoreLive, PlatformServices),
-  FetchHttpClient.layer,
-  ConfigProvider.layer(ConfigProvider.fromEnv()),
-  selectCli(),
+const services = Layer.merge(selectCli(), RpcProviderProxy.fromEnv()).pipe(
+  Layer.provideMerge(
+    Layer.mergeAll(AlchemyContextLive, ProfileLive, CredentialsStoreLive),
+  ),
+  Layer.provideMerge(
+    Layer.mergeAll(
+      PlatformServices,
+      FetchHttpClient.layer,
+      ConfigProvider.layer(ConfigProvider.fromEnv()),
+    ),
+  ),
 );
 
 export const exec = () =>

package/src/Cloudflare/Local.ts

@@ -0,0 +1,23 @@
+import * as Layer from "effect/Layer";
+import * as RpcServer from "../Local/RpcServer.ts";
+import { CloudflareAuth } from "./Auth/AuthProvider.ts";
+import * as CloudflareEnvironment from "./CloudflareEnvironment.ts";
+import * as Credentials from "./Credentials.ts";
+import {
+  LocalWorkerProvider,
+  localRuntimeServices,
+} from "./Workers/LocalWorkerProvider.ts";
+
+const cloudflareServices = Layer.provide(
+  Layer.merge(
+    Credentials.fromAuthProvider(),
+    CloudflareEnvironment.fromProfile(),
+  ),
+  CloudflareAuth,
+);
+
+LocalWorkerProvider().pipe(
+  Layer.provide(localRuntimeServices({ port: 1337 })),
+  Layer.provide(cloudflareServices),
+  RpcServer.launch,
+);

package/src/Cloudflare/Providers.ts

@@ -32,6 +32,7 @@ import * as Tunnel from "./Tunnel/index.ts";
 import * as VpcService from "./VpcService/index.ts";
 import * as Workers from "./Workers/index.ts";
 import * as Workflows from "./Workers/Workflow.ts";
+import * as Zaraz from "./Zaraz/index.ts";
 
 export { Credentials } from "@distilled.cloud/cloudflare/Credentials";
 
@@ -84,6 +85,7 @@ export const providers = () =>
       Workers.FetchPolicy,
       Workers.Worker,
       Workflows.WorkflowResource,
+      Zaraz.ZarazConfig,
     ]),
   ).pipe(
     Layer.provide(
@@ -122,6 +124,7 @@ export const providers = () =>
         Workers.FetchPolicyLive,
         Workers.WorkerProvider(),
         Workflows.WorkflowProvider(),
+        Zaraz.ZarazConfigProvider(),
       ),
     ),
     Layer.provideMerge(

package/src/Cloudflare/Workers/DurableObjectBridge.ts

@@ -81,7 +81,6 @@ export const makeDurableObjectBridge =
 
         return new Proxy(this, {
           get: (target, prop) => {
-            console.log(target, prop, prop in target);
             const bind = (f: any) =>
               typeof f === "function" ? f.bind(target) : f;
             if (typeof prop !== "string") return bind((target as any)[prop]);