alchemy 2.0.0-beta.41 → 2.0.0-beta.43

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "alchemy",
-  "version": "2.0.0-beta.41",
+  "version": "2.0.0-beta.43",
   "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",
@@ -279,14 +291,15 @@
     "@alchemy.run/node-utils": "0.0.2",
     "@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/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.0",
-    "@distilled.cloud/neon": "^0.21.0",
+    "@distilled.cloud/core": "^0.21.3",
+    "@distilled.cloud/planetscale": "^0.21.3",
+    "@distilled.cloud/neon": "^0.21.3",
     "@effect/vitest": ">=4.0.0-beta.66 || >=4.0.0",
     "@libsql/client": "^0.17.0",
     "@octokit/rest": "^22.0.1",
@@ -303,6 +316,7 @@
     "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",

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/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/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/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 {

package/src/Cloudflare/Artifacts/ArtifactsBinding.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 Artifacts as ArtifactsLike } from "./Artifacts.ts";
 
@@ -66,32 +67,22 @@ export interface ArtifactsRepoClient {
  */
 export interface ArtifactsClient {
   /** Effect resolving to the raw Cloudflare runtime binding. */
-  raw: Effect.Effect<Artifacts, never, WorkerEnvironment>;
+  raw: Effect.Effect<Artifacts, never, RuntimeContext>;
   create(
     name: string,
     opts?: ArtifactsCreateOptions,
-  ): Effect.Effect<
-    ArtifactsCreateRepoResult,
-    ArtifactsError,
-    WorkerEnvironment
-  >;
+  ): Effect.Effect<ArtifactsCreateRepoResult, ArtifactsError, RuntimeContext>;
   /** Look up an existing repo by name. Fails with `ArtifactsError` if missing. */
   get(
     name: string,
-  ): Effect.Effect<ArtifactsRepoClient, ArtifactsError, WorkerEnvironment>;
+  ): Effect.Effect<ArtifactsRepoClient, ArtifactsError, RuntimeContext>;
   list(
     opts?: ArtifactsListOptions,
-  ): Effect.Effect<ArtifactsRepoListResult, ArtifactsError, WorkerEnvironment>;
-  delete(
-    name: string,
-  ): Effect.Effect<boolean, ArtifactsError, WorkerEnvironment>;
+  ): Effect.Effect<ArtifactsRepoListResult, ArtifactsError, RuntimeContext>;
+  delete(name: string): Effect.Effect<boolean, ArtifactsError, RuntimeContext>;
   import(
     opts: ArtifactsImportOptions,
-  ): Effect.Effect<
-    ArtifactsCreateRepoResult,
-    ArtifactsError,
-    WorkerEnvironment
-  >;
+  ): Effect.Effect<ArtifactsCreateRepoResult, ArtifactsError, RuntimeContext>;
 }
 
 export class ArtifactsBinding extends Binding.Service<
@@ -103,19 +94,17 @@ export const ArtifactsBindingLive = Layer.effect(
   ArtifactsBinding,
   Effect.gen(function* () {
     const Policy = yield* ArtifactsBindingPolicy;
+    const env = yield* WorkerEnvironment;
 
     return Effect.fn(function* (artifacts: ArtifactsLike) {
       yield* Policy(artifacts);
-      const env = WorkerEnvironment;
-      const raw = env.pipe(
-        Effect.map(
-          (env) => (env as Record<string, Artifacts>)[artifacts.name]!,
-        ),
+      const raw = Effect.sync(
+        () => (env as Record<string, Artifacts>)[artifacts.name]!,
       );
 
       const use = <T>(
         fn: (raw: Artifacts) => Promise<T>,
-      ): Effect.Effect<T, ArtifactsError, WorkerEnvironment> =>
+      ): Effect.Effect<T, ArtifactsError> =>
         raw.pipe(Effect.flatMap((raw) => tryPromise(() => fn(raw))));
 
       return {

package/src/Cloudflare/D1/D1Connection.ts

@@ -1,8 +1,8 @@
 import type * as runtime from "@cloudflare/workers-types";
 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 { RuntimeContext } from "../../RuntimeContext.ts";
 import { WorkerEnvironment } from "../Workers/Worker.ts";
 import type { D1Database } from "./D1Database.ts";
 import { DatabaseBinding } from "./D1DatabaseBinding.ts";
@@ -33,32 +33,44 @@ export class D1PreparedStatement {
   }
 
   /** Run the query and return all matching rows. */
-  all<T = unknown>(): Effect.Effect<runtime.D1Result<T>> {
+  all<T = unknown>(): Effect.Effect<
+    runtime.D1Result<T>,
+    never,
+    RuntimeContext
+  > {
     return this.withRuntime((stmt) => stmt.all<T>());
   }
 
   /** Run the query and return the first row, or `null` if no rows. */
-  first<T = unknown>(): Effect.Effect<T | null>;
-  first<T = unknown>(column: string): Effect.Effect<T | null>;
-  first<T = unknown>(column?: string): Effect.Effect<T | null> {
+  first<T = unknown>(): Effect.Effect<T | null, never, RuntimeContext>;
+  first<T = unknown>(
+    column: string,
+  ): Effect.Effect<T | null, never, RuntimeContext>;
+  first<T = unknown>(
+    column?: string,
+  ): Effect.Effect<T | null, never, RuntimeContext> {
     return this.withRuntime((stmt) =>
       column !== undefined ? stmt.first<T>(column) : stmt.first<T>(),
     );
   }
 
   /** Run the query as a mutation; returns row metadata. */
-  run<T = unknown>(): Effect.Effect<runtime.D1Result<T>> {
+  run<T = unknown>(): Effect.Effect<
+    runtime.D1Result<T>,
+    never,
+    RuntimeContext
+  > {
     return this.withRuntime((stmt) => stmt.run<T>());
   }
 
   /** Run the query and return rows as flat arrays. */
-  raw<T = unknown[]>(): Effect.Effect<T[]>;
+  raw<T = unknown[]>(): Effect.Effect<T[], never, RuntimeContext>;
   raw<T = unknown[]>(options: {
     columnNames: true;
-  }): Effect.Effect<[string[], ...T[]]>;
+  }): Effect.Effect<[string[], ...T[]], never, RuntimeContext>;
   raw<T = unknown[]>(options?: {
     columnNames: true;
-  }): Effect.Effect<T[] | [string[], ...T[]]> {
+  }): Effect.Effect<T[] | [string[], ...T[]], never, RuntimeContext> {
     return this.withRuntime((stmt) =>
       options
         ? stmt.raw<T>(options)
@@ -80,10 +92,10 @@ export class D1PreparedStatement {
 
   private withRuntime<A>(
     fn: (stmt: runtime.D1PreparedStatement) => Promise<A>,
-  ): Effect.Effect<A> {
+  ): Effect.Effect<A, never, RuntimeContext> {
     return Effect.flatMap(this.rawEff, (raw) =>
       Effect.promise(() => fn(this._build(raw))),
-    );
+    ) as Effect.Effect<A, never, RuntimeContext>;
   }
 }
 
@@ -92,7 +104,7 @@ export interface D1ConnectionClient {
    * An Effect that resolves to the raw underlying Cloudflare D1Database binding.
    * Use this when you need direct access for libraries like Better Auth.
    */
-  raw: Effect.Effect<runtime.D1Database>;
+  raw: Effect.Effect<runtime.D1Database, never, RuntimeContext>;
   /**
    * Prepare a SQL statement. Returns synchronously — the network
    * round-trip happens when you yield one of the statement's
@@ -102,14 +114,16 @@ export interface D1ConnectionClient {
   /**
    * Execute raw SQL without prepared statements.
    */
-  exec: (query: string) => Effect.Effect<runtime.D1ExecResult>;
+  exec: (
+    query: string,
+  ) => Effect.Effect<runtime.D1ExecResult, never, RuntimeContext>;
   /**
    * Send multiple prepared statements in a single call.
    * Statements execute sequentially and are rolled back on failure.
    */
   batch: <T = unknown>(
     statements: D1PreparedStatement[],
-  ) => Effect.Effect<runtime.D1Result<T>[]>;
+  ) => Effect.Effect<runtime.D1Result<T>[], never, RuntimeContext>;
 }
 
 export class D1Connection extends Binding.Service<
@@ -121,13 +135,12 @@ export const D1ConnectionLive = Layer.effect(
   D1Connection,
   Effect.gen(function* () {
     const Policy = yield* D1ConnectionPolicy;
+    const env = yield* WorkerEnvironment;
 
     return Effect.fn(function* (database: D1Database) {
       yield* Policy(database);
-      const rawEff = yield* Effect.serviceOption(WorkerEnvironment).pipe(
-        Effect.map(Option.getOrUndefined),
-        Effect.map((env) => env?.[database.LogicalId]! as runtime.D1Database),
-        Effect.cached,
+      const rawEff = Effect.sync(
+        () => (env as Record<string, runtime.D1Database>)[database.LogicalId]!,
       );
 
       return {

package/src/Cloudflare/D1/D1Database.ts

@@ -10,7 +10,7 @@ import type { Providers } from "../Providers.ts";
 import { cloneD1Database } from "./D1Clone.ts";
 import { importD1Database } from "./D1Import.ts";
 import { applyMigrations } from "./D1Migrations.ts";
-import { listSqlFiles, readSqlFile } from "./D1SqlFile.ts";
+import { listSqlFiles, readSqlFile } from "../../Sql/SqlFile.ts";
 
 export type Jurisdiction = "default" | "eu" | "fedramp";
 export type PrimaryLocationHint =

package/src/Cloudflare/D1/D1Migrations.ts

@@ -2,13 +2,13 @@ import * as d1 from "@distilled.cloud/cloudflare/d1";
 import * as Effect from "effect/Effect";
 import type * as HttpClient from "effect/unstable/http/HttpClient";
 import type { Credentials } from "@distilled.cloud/cloudflare/Credentials";
-import type { D1SqlFile } from "./D1SqlFile.ts";
+import type { SqlFile } from "../../Sql/SqlFile.ts";
 
 export interface ApplyMigrationsOptions {
   accountId: string;
   databaseId: string;
   migrationsTable: string;
-  migrationsFiles: ReadonlyArray<D1SqlFile>;
+  migrationsFiles: ReadonlyArray<SqlFile>;
 }
 
 interface TableColumn {

package/src/Cloudflare/Email/SendEmailBinding.ts

@@ -4,6 +4,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 { SendEmail } from "./SendEmail.ts";
 
@@ -35,20 +36,20 @@ export interface SendEmailClient {
    * access to the Cloudflare object (e.g. to send a pre-built
    * `EmailMessage` from `cloudflare:email`).
    */
-  raw: Effect.Effect<runtime.SendEmail, never, WorkerEnvironment>;
+  raw: Effect.Effect<runtime.SendEmail, never, RuntimeContext>;
   /**
    * Send an email using the builder form. Equivalent to calling
    * `env.<name>.send({ from, to, subject, text, html, ... })`.
    */
   send(
     message: SendEmailMessage,
-  ): Effect.Effect<runtime.EmailSendResult, SendEmailError, WorkerEnvironment>;
+  ): Effect.Effect<runtime.EmailSendResult, SendEmailError, RuntimeContext>;
   /**
    * Send a raw `EmailMessage` (constructed via `cloudflare:email`).
    */
   sendRaw(
     message: runtime.EmailMessage,
-  ): Effect.Effect<runtime.EmailSendResult, SendEmailError, WorkerEnvironment>;
+  ): Effect.Effect<runtime.EmailSendResult, SendEmailError, RuntimeContext>;
 }
 
 /**
@@ -65,12 +66,13 @@ export const SendEmailBindingLive = Layer.effect(
   SendEmailBinding,
   Effect.gen(function* () {
     const bind = yield* SendEmailBindingPolicy;
+    const env = yield* WorkerEnvironment;
 
     return Effect.fnUntraced(function* (sender: SendEmail) {
       yield* bind(sender);
 
-      const raw = WorkerEnvironment.useSync(
-        (env) => (env as Record<string, runtime.SendEmail>)[sender.name]!,
+      const raw = Effect.sync(
+        () => (env as Record<string, runtime.SendEmail>)[sender.name]!,
       );
 
       const tryPromise = <T>(

package/src/Cloudflare/Hyperdrive/HyperdriveBinding.ts

@@ -1,12 +1,12 @@
 import type * as runtime from "@cloudflare/workers-types";
 import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
-import * as Option from "effect/Option";
 import * as Redacted from "effect/Redacted";
 import { AlchemyContext } from "../../AlchemyContext.ts";
 import * as Binding from "../../Binding.ts";
 import * as Output from "../../Output.ts";
 import type { ResourceLike } from "../../Resource.ts";
+import type { RuntimeContext } from "../../RuntimeContext.ts";
 import { isWorker, WorkerEnvironment } from "../Workers/Worker.ts";
 import type { Hyperdrive } from "./Hyperdrive.ts";
 import { defaultPort, type HyperdriveDevOrigin } from "./Hyperdrive.ts";
@@ -16,32 +16,36 @@ export interface HyperdriveBindingClient {
    * The raw runtime `Hyperdrive` binding. Use this when integrating with a
    * driver that wants direct access to the Cloudflare object.
    */
-  raw: Effect.Effect<runtime.Hyperdrive>;
+  raw: Effect.Effect<runtime.Hyperdrive, never, RuntimeContext>;
   /**
    * A valid DB connection string for use with a driver/ORM.
    */
-  connectionString: Effect.Effect<Redacted.Redacted<string>>;
+  connectionString: Effect.Effect<
+    Redacted.Redacted<string>,
+    never,
+    RuntimeContext
+  >;
   /**
    * Hostname valid only within the current Worker invocation.
    */
-  host: Effect.Effect<string>;
+  host: Effect.Effect<string, never, RuntimeContext>;
   /**
    * Port to pair with `host`.
    */
-  port: Effect.Effect<number>;
+  port: Effect.Effect<number, never, RuntimeContext>;
   /**
    * Database user.
    */
-  user: Effect.Effect<string>;
+  user: Effect.Effect<string, never, RuntimeContext>;
   /**
    * Randomly generated password valid only within the current Worker
    * invocation.
    */
-  password: Effect.Effect<Redacted.Redacted<string>>;
+  password: Effect.Effect<Redacted.Redacted<string>, never, RuntimeContext>;
   /**
    * Database name.
    */
-  database: Effect.Effect<string>;
+  database: Effect.Effect<string, never, RuntimeContext>;
 }
 
 /**
@@ -67,13 +71,13 @@ export const HyperdriveBindingLive = Layer.effect(
   HyperdriveBinding,
   Effect.gen(function* () {
     const Policy = yield* HyperdriveBindingPolicy;
+    const env = yield* WorkerEnvironment;
 
     return Effect.fn(function* (hyperdrive: Hyperdrive) {
       yield* Policy(hyperdrive);
-      const hd = yield* Effect.serviceOption(WorkerEnvironment).pipe(
-        Effect.map(Option.getOrUndefined),
-        Effect.map((env) => env?.[hyperdrive.LogicalId]! as runtime.Hyperdrive),
-        Effect.cached,
+      const hd = Effect.sync(
+        () =>
+          (env as Record<string, runtime.Hyperdrive>)[hyperdrive.LogicalId]!,
       );
 
       return {

package/src/Cloudflare/Images/ImagesBinding.ts

@@ -5,6 +5,7 @@ import * as Layer from "effect/Layer";
 import * as Stream from "effect/Stream";
 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 Images as ImagesLike } from "./Images.ts";
 
@@ -55,7 +56,7 @@ export interface ImageTransformerClient {
  */
 export interface ImagesClient {
   /** Effect resolving to the raw Cloudflare runtime binding. */
-  raw: Effect.Effect<cf.ImagesBinding, never, WorkerEnvironment>;
+  raw: Effect.Effect<cf.ImagesBinding, never, RuntimeContext>;
   /**
    * Read image format and dimensions from a stream of bytes.
    * Fails with {@link ImagesError} (code 9412) if the input is not
@@ -64,7 +65,7 @@ export interface ImagesClient {
   info<E = never, R = never>(
     stream: Stream.Stream<Uint8Array, E, R>,
     options?: cf.ImageInputOptions,
-  ): Effect.Effect<cf.ImageInfoResponse, ImagesError, WorkerEnvironment | R>;
+  ): Effect.Effect<cf.ImageInfoResponse, ImagesError, RuntimeContext | R>;
   /**
    * Begin a transformation pipeline. Subsequent `.transform()` /
    * `.draw()` calls are pure; `.output(opts)` runs the pipeline.
@@ -72,7 +73,7 @@ export interface ImagesClient {
   input<E = never, R = never>(
     stream: Stream.Stream<Uint8Array, E, R>,
     options?: cf.ImageInputOptions,
-  ): Effect.Effect<ImageTransformerClient, never, WorkerEnvironment | R>;
+  ): Effect.Effect<ImageTransformerClient, never, RuntimeContext | R>;
 }
 
 export class ImagesBinding extends Binding.Service<
@@ -84,14 +85,13 @@ export const ImagesBindingLive = Layer.effect(
   ImagesBinding,
   Effect.gen(function* () {
     const Policy = yield* ImagesBindingPolicy;
+    const env = yield* WorkerEnvironment;
 
     return Effect.fn(function* (images: ImagesLike) {
       yield* Policy(images);
-      const env = WorkerEnvironment;
-      const raw = env.pipe(
-        Effect.map(
-          (env) => (env as Record<string, cf.ImagesBinding>)[images.name]!,
-        ),
+      const raw = Effect.sync(
+        // this must be lazy because the WorkerEnvironment is not available yet
+        () => (env as Record<string, cf.ImagesBinding>)[images.name]!,
       );
 
       return {