alchemy 2.0.0-beta.42 → 2.0.0-beta.44

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "alchemy",
-  "version": "2.0.0-beta.42",
+  "version": "2.0.0-beta.44",
   "homepage": "https://alchemy.run",
   "license": "Apache-2.0",
   "author": "Sam Goodwin <sam@alchemy.run>",
@@ -196,6 +196,18 @@
       "worker": "./src/Output.ts",
       "import": "./lib/Output.js"
     },
+    "./Planetscale": {
+      "types": "./lib/Planetscale/index.d.ts",
+      "bun": "./src/Planetscale/index.ts",
+      "worker": "./src/Planetscale/index.ts",
+      "import": "./lib/Planetscale/index.js"
+    },
+    "./Planetscale/*": {
+      "types": "./lib/Planetscale/*/index.d.ts",
+      "bun": "./src/Planetscale/*/index.ts",
+      "worker": "./src/Planetscale/*/index.ts",
+      "import": "./lib/Planetscale/*/index.js"
+    },
     "./Runtime": {
       "types": "./lib/Runtime.d.ts",
       "bun": "./src/Runtime.ts",
@@ -276,17 +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.0",
-    "@distilled.cloud/axiom": "^0.21.0",
-    "@distilled.cloud/cloudflare": "^0.21.0",
-    "@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.0",
-    "@distilled.cloud/neon": "^0.21.0",
+    "@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",
@@ -298,17 +311,16 @@
     "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",
     "magic-string": "^0.30.21",
+    "mysql2": "^3.15.3",
     "pathe": "^2.0.3",
     "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/Binding.ts

@@ -90,7 +90,7 @@ export interface Policy<
   in out Self,
   in out Identifier extends string,
   in out Shape extends (...args: any[]) => Effect.Effect<any, any, any>,
-> extends Effect.Effect<Shape, never, Self | RuntimeContext> {
+> extends Effect.Effect<Shape, never, Self> {
   readonly key: Identifier;
   new (_: never): PolicyShape<Identifier, Shape>;
   layer: {

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/Docker.ts

@@ -2,6 +2,7 @@ import * as Data from "effect/Data";
 import * as Effect from "effect/Effect";
 import * as FileSystem from "effect/FileSystem";
 import * as Path from "effect/Path";
+import * as Stream from "effect/Stream";
 import { ChildProcess } from "effect/unstable/process";
 import { exec } from "../Util/exec.ts";
 
@@ -66,8 +67,6 @@ export const writeContextFiles = Effect.fn(function* (
   }
 });
 
-const shellQuote = (value: string) => `'${value.replaceAll("'", `'\\''`)}'`;
-
 export const runDockerCommand = Effect.fn(function* (
   args: ReadonlyArray<string>,
   options?: {
@@ -77,24 +76,22 @@ export const runDockerCommand = Effect.fn(function* (
     stdin?: string;
   },
 ) {
-  const command = `docker ${args.map(shellQuote).join(" ")}`;
-  const shellCommand =
-    options?.stdin === undefined
-      ? command
-      : `printf '%s' "$ALCHEMY_DOCKER_STDIN" | ${command}`;
-  const env = {
-    ...process.env,
-    ...options?.env,
-    ...(options?.stdin === undefined
-      ? {}
-      : { ALCHEMY_DOCKER_STDIN: options.stdin }),
+  const command = `docker ${args.join(" ")}`;
+  const env = { ...process.env, ...options?.env };
+  const commandOptions: ChildProcess.CommandOptions = {
+    env,
+    ...(options?.stdin !== undefined
+      ? {
+          stdin: Stream.succeed(new TextEncoder().encode(options.stdin)),
+        }
+      : {}),
   };
   const child = options?.cwd
     ? ChildProcess.setCwd(
-        ChildProcess.make(shellCommand, [], { shell: true, env }),
+        ChildProcess.make("docker", args, commandOptions),
         options.cwd,
       )
-    : ChildProcess.make(shellCommand, [], { shell: true, env });
+    : ChildProcess.make("docker", args, commandOptions);
 
   const { stdout, stderr, exitCode } = yield* exec(child).pipe(
     Effect.catch((e) =>

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/deploy.ts

@@ -125,6 +125,7 @@ export const execStack = Effect.fn(function* ({
               // TODO(sam): probably better to have Plan.destroy and Plan.update
               resources: {},
               bindings: {},
+              actions: {},
               output: {},
             }
           : stack,

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/AiGateway/AiGatewayBinding.ts

@@ -3,9 +3,9 @@
 import * as Data from "effect/Data";
 import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
-import * as Option from "effect/Option";
 import * as Binding from "../../Binding.ts";
 import type { ResourceLike } from "../../Resource.ts";
+import type { RuntimeContext } from "../../RuntimeContext.ts";
 import { isWorker, WorkerEnvironment } from "../Workers/Worker.ts";
 import type { AiGateway as AiGatewayResource } from "./AiGateway.ts";
 
@@ -34,37 +34,37 @@ export interface AiGatewayClient {
   /**
    * Effect resolving to the raw Workers AI binding.
    */
-  raw: Effect.Effect<Ai, never, WorkerEnvironment>;
+  raw: Effect.Effect<Ai, never, RuntimeContext>;
   /**
    * Effect resolving to the raw AI Gateway runtime binding.
    */
-  gateway: Effect.Effect<AiGateway, never, WorkerEnvironment>;
+  gateway: Effect.Effect<AiGateway, never, RuntimeContext>;
   /**
    * Update metadata on an existing AI Gateway log entry.
    */
   patchLog(
     logId: string,
     data: Parameters<AiGateway["patchLog"]>[1],
-  ): Effect.Effect<void, AiGatewayError, WorkerEnvironment>;
+  ): Effect.Effect<void, AiGatewayError, RuntimeContext>;
   /**
    * Read an AI Gateway log entry by ID.
    */
   getLog(
     logId: string,
-  ): Effect.Effect<AiGatewayLog, AiGatewayError, WorkerEnvironment>;
+  ): Effect.Effect<AiGatewayLog, AiGatewayError, RuntimeContext>;
   /**
    * Build a provider URL routed through this gateway.
    */
   getUrl(
     provider?: Parameters<AiGateway["getUrl"]>[0],
-  ): Effect.Effect<string, AiGatewayError, WorkerEnvironment>;
+  ): Effect.Effect<string, AiGatewayError, RuntimeContext>;
   /**
    * Run an AI Gateway request through the Cloudflare runtime binding.
    */
   run(
     data: Parameters<AiGateway["run"]>[0],
     options?: Parameters<AiGateway["run"]>[1],
-  ): Effect.Effect<Response, AiGatewayError, WorkerEnvironment>;
+  ): Effect.Effect<Response, AiGatewayError, RuntimeContext>;
 }
 
 /**
@@ -106,18 +106,13 @@ export const AiGatewayBindingLive = Layer.effect(
   AiGatewayBinding,
   Effect.gen(function* () {
     const Policy = yield* AiGatewayBindingPolicy;
+    const env = yield* WorkerEnvironment;
 
     return Effect.fn(function* (gateway: AiGatewayResource) {
       yield* Policy(gateway);
-      // Capture the gatewayId accessor (which requires WorkerEnvironment) but
-      // don't resolve it here — that happens lazily at runtime when each
-      // method is invoked. Resolving eagerly would require WorkerEnvironment
-      // at deploy time, where it's intentionally not provided.
       const gatewayIdAccessor = yield* gateway.gatewayId;
-      const ai = yield* Effect.serviceOption(WorkerEnvironment).pipe(
-        Effect.map(Option.getOrUndefined),
-        Effect.map((env) => env?.[gateway.LogicalId]! as Ai),
-        Effect.cached,
+      const ai = Effect.sync(
+        () => (env as Record<string, Ai>)[gateway.LogicalId]!,
       );
       const runtimeGateway = yield* Effect.zip(ai, gatewayIdAccessor).pipe(
         Effect.map(([ai, gatewayId]) => ai.gateway(gatewayId)),
@@ -126,7 +121,7 @@ export const AiGatewayBindingLive = Layer.effect(
 
       const use = <T>(
         fn: (gateway: AiGateway) => Promise<T>,
-      ): Effect.Effect<T, AiGatewayError, WorkerEnvironment> =>
+      ): Effect.Effect<T, AiGatewayError> =>
         runtimeGateway.pipe(
           Effect.flatMap((gateway) => tryPromise(() => fn(gateway))),
         );

package/src/Cloudflare/AnalyticsEngine/AnalyticsEngineDatasetBinding.ts

@@ -3,6 +3,7 @@ import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
 import * as Binding from "../../Binding.ts";
 import type { ResourceLike } from "../../Resource.ts";
+import type { RuntimeContext } from "../../RuntimeContext.ts";
 import { isWorker, WorkerEnvironment } from "../Workers/Worker.ts";
 import type { AnalyticsEngineDataset as AnalyticsEngineDatasetLike } from "./AnalyticsEngineDataset.ts";
 
@@ -24,10 +25,10 @@ export class AnalyticsEngineDatasetError extends Data.TaggedError(
 }> {}
 
 export interface AnalyticsEngineDatasetClient {
-  raw: Effect.Effect<RuntimeAnalyticsEngineDataset, never, WorkerEnvironment>;
+  raw: Effect.Effect<RuntimeAnalyticsEngineDataset, never, RuntimeContext>;
   writeDataPoint(
     dataPoint: AnalyticsEngineDataPoint,
-  ): Effect.Effect<void, AnalyticsEngineDatasetError, WorkerEnvironment>;
+  ): Effect.Effect<void, AnalyticsEngineDatasetError, RuntimeContext>;
 }
 
 export class AnalyticsEngineDatasetBinding extends Binding.Service<
@@ -41,17 +42,14 @@ export const AnalyticsEngineDatasetBindingLive = Layer.effect(
   AnalyticsEngineDatasetBinding,
   Effect.gen(function* () {
     const bind = yield* AnalyticsEngineDatasetBindingPolicy;
+    const env = yield* WorkerEnvironment;
 
     return Effect.fnUntraced(function* (dataset: AnalyticsEngineDatasetLike) {
       yield* bind(dataset);
 
-      const raw = WorkerEnvironment.pipe(
-        Effect.map(
-          (env) =>
-            (env as Record<string, RuntimeAnalyticsEngineDataset>)[
-              dataset.name
-            ]!,
-        ),
+      const raw = Effect.sync(
+        () =>
+          (env as Record<string, RuntimeAnalyticsEngineDataset>)[dataset.name]!,
       );
 
       return {