alchemy 2.0.0-beta.53 → 2.0.0-beta.55

package/src/Cloudflare/Queue/Queue.ts

@@ -1,12 +1,21 @@
 import * as queues from "@distilled.cloud/cloudflare/queues";
 import * as Effect from "effect/Effect";
+import * as MutableHashMap from "effect/MutableHashMap";
 import * as Option from "effect/Option";
 import * as Stream from "effect/Stream";
 import { isResolved } from "../../Diff.ts";
+import * as ProviderLayer from "../../Local/ProviderLayer.ts";
+import * as RpcProvider from "../../Local/RpcProvider.ts";
 import { createPhysicalName } from "../../PhysicalName.ts";
 import * as Provider from "../../Provider.ts";
 import { Resource } from "../../Resource.ts";
 import { CloudflareEnvironment } from "../CloudflareEnvironment.ts";
+import {
+  generateLocalId,
+  isLiveId,
+  LOCAL_ENTRY_URL,
+  LocalRuntimeState,
+} from "../LocalRuntime.ts";
 import type { Providers } from "../Providers.ts";
 import { QueueBinding } from "./QueueBinding.ts";
 
@@ -96,12 +105,18 @@ export const Queue = Resource<Queue>("Cloudflare.Queue")({
   bind: QueueBinding.bind,
 });
 
-export const QueueProvider = () =>
+export const QueueProviderLive = () =>
   Provider.succeed(Queue, {
-    stables: ["queueId", "accountId"],
+    // The `queueId` is not marked as stable because if you start in dev mode, the ID will change on first deploy.
+    stables: ["accountId"],
     diff: Effect.fn(function* ({ id, olds = {}, news = {}, output }) {
       const { accountId } = yield* yield* CloudflareEnvironment;
       if (!isResolved(news)) return undefined;
+      // If the queueId is a `dev:` ID, we need to update to a live one.
+      // The live resource doesn't exist yet, so there's no need to replace even if the name or accountId changed.
+      if (!isLiveId(output?.queueId)) {
+        return { action: "update" };
+      }
       if ((output?.accountId ?? accountId) !== accountId) {
         return { action: "replace" } as const;
       }
@@ -171,6 +186,8 @@ export const QueueProvider = () =>
       };
     }),
     delete: Effect.fn(function* ({ output }) {
+      // If the queueId is a `dev:` ID, the resource only exists locally, so we don't need to delete it from Cloudflare.
+      if (!isLiveId(output.queueId)) return;
       yield* queues
         .deleteQueue({
           accountId: output.accountId,
@@ -228,3 +245,57 @@ const findQueueByName = Effect.fnUntraced(function* (queueName: string) {
     Effect.map(Option.getOrUndefined),
   );
 });
+
+export const QueueProviderLocal = () =>
+  RpcProvider.effect(
+    Queue,
+    LOCAL_ENTRY_URL,
+    Effect.gen(function* () {
+      const localRuntimeState = yield* LocalRuntimeState;
+      return {
+        stables: ["accountId"],
+        diff: Effect.fn(function* ({ id, olds = {}, news = {}, output }) {
+          const { accountId } = yield* yield* CloudflareEnvironment;
+          if (!output?.queueId) return { action: "update" };
+          if (!isResolved(news)) return undefined;
+          const name = yield* createQueueName(id, news.name);
+          const oldName = output?.queueName
+            ? yield* createQueueName(id, olds.name)
+            : yield* createQueueName(id, olds.name);
+          if (name !== oldName || output.accountId !== accountId) {
+            return { action: "replace" };
+          }
+          // If the resource is a noop, add it to the local runtime state so it's available downstream.
+          // We do it here instead of in the reconcile function so it doesn't appear as an update.
+          MutableHashMap.set(localRuntimeState.queues, output.queueId, output);
+          return { action: "noop" };
+        }),
+        read: Effect.fn(function* ({ output }) {
+          if (!output?.queueId) return undefined;
+          return MutableHashMap.get(
+            localRuntimeState.queues,
+            output.queueId,
+          ).pipe(Option.getOrUndefined);
+        }),
+        reconcile: Effect.fn(function* ({ id, news = {}, output }) {
+          const { accountId } = yield* yield* CloudflareEnvironment;
+          const queue: Queue["Attributes"] = {
+            queueId: output?.queueId ?? generateLocalId(),
+            queueName: yield* createQueueName(id, news.name),
+            accountId: output?.accountId ?? accountId,
+          };
+          MutableHashMap.set(localRuntimeState.queues, queue.queueId, queue);
+          return queue;
+        }),
+        delete: Effect.fn(function* ({ output }) {
+          MutableHashMap.remove(localRuntimeState.queues, output.queueId);
+        }),
+      };
+    }),
+  );
+
+export const QueueProvider = () =>
+  ProviderLayer.select({
+    local: () => QueueProviderLocal(),
+    live: () => QueueProviderLive(),
+  });

package/src/Cloudflare/Queue/QueueConsumer.ts

@@ -1,12 +1,20 @@
 import * as queues from "@distilled.cloud/cloudflare/queues";
 import * as Effect from "effect/Effect";
+import * as MutableHashMap from "effect/MutableHashMap";
 import * as Option from "effect/Option";
 import * as Schedule from "effect/Schedule";
 import * as Stream from "effect/Stream";
 import { isResolved } from "../../Diff.ts";
+import * as ProviderLayer from "../../Local/ProviderLayer.ts";
+import * as RpcProvider from "../../Local/RpcProvider.ts";
 import * as Provider from "../../Provider.ts";
 import { Resource } from "../../Resource.ts";
 import { CloudflareEnvironment } from "../CloudflareEnvironment.ts";
+import {
+  isLiveId,
+  LOCAL_ENTRY_URL,
+  LocalRuntimeState,
+} from "../LocalRuntime.ts";
 import type { Providers } from "../Providers.ts";
 
 export type QueueConsumerProps = {
@@ -25,33 +33,35 @@ export type QueueConsumerProps = {
   /**
    * Consumer settings.
    */
-  settings?: {
-    /**
-     * The maximum number of messages per batch.
-     * @default 10
-     */
-    batchSize?: number;
-    /**
-     * The maximum number of concurrent consumer invocations.
-     */
-    maxConcurrency?: number;
-    /**
-     * The maximum number of retries for a message.
-     * @default 3
-     */
-    maxRetries?: number;
-    /**
-     * The maximum time to wait for a batch to fill, in milliseconds.
-     * @default 5000
-     */
-    maxWaitTimeMs?: number;
-    /**
-     * The number of seconds to wait before retrying a message.
-     */
-    retryDelay?: number;
-  };
+  settings?: QueueConsumerSettings;
 };
 
+export interface QueueConsumerSettings {
+  /**
+   * The maximum number of messages per batch.
+   * @default 10
+   */
+  batchSize?: number;
+  /**
+   * The maximum number of concurrent consumer invocations.
+   */
+  maxConcurrency?: number;
+  /**
+   * The maximum number of retries for a message.
+   * @default 3
+   */
+  maxRetries?: number;
+  /**
+   * The maximum time to wait for a batch to fill, in milliseconds.
+   * @default 5000
+   */
+  maxWaitTimeMs?: number;
+  /**
+   * The number of seconds to wait before retrying a message.
+   */
+  retryDelay?: number;
+}
+
 export type QueueConsumer = Resource<
   "Cloudflare.QueueConsumer",
   QueueConsumerProps,
@@ -60,6 +70,8 @@ export type QueueConsumer = Resource<
     queueId: string;
     scriptName: string;
     accountId: string;
+    deadLetterQueue?: string;
+    settings?: QueueConsumerSettings;
   },
   never,
   Providers
@@ -116,12 +128,19 @@ const findWorkerConsumer = (acct: string, queueId: string) =>
     Stream.runHead,
     Effect.map(Option.getOrUndefined),
   );
-export const QueueConsumerProvider = () =>
+
+export const QueueConsumerProviderLive = () =>
   Provider.succeed(QueueConsumer, {
-    stables: ["consumerId", "accountId"],
+    // The `consumerId` is not marked as stable because if you start in dev mode, the ID will change on first deploy.
+    stables: ["accountId"],
     diff: Effect.fn(function* ({ olds, news, output }) {
       const { accountId } = yield* yield* CloudflareEnvironment;
       if (!isResolved(news)) return undefined;
+      // If either contain `dev:` IDs, we need to update to live ones.
+      // The live resource doesn't exist yet, so there's no need to replace even when we otherwise would.
+      if (!isLiveId(output?.queueId) || !isLiveId(output?.consumerId)) {
+        return { action: "update" };
+      }
       if ((output?.accountId ?? accountId) !== accountId) {
         return { action: "replace" } as const;
       }
@@ -167,7 +186,7 @@ export const QueueConsumerProvider = () =>
       // updating it could clobber another team's wiring.
       let observed: ObservedConsumer | undefined;
       let owned = false;
-      if (output?.consumerId) {
+      if (isLiveId(output?.consumerId)) {
         const fetched = yield* queues
           .getConsumer({
             accountId: acct,
@@ -365,9 +384,14 @@ export const QueueConsumerProvider = () =>
         queueId,
         scriptName: news.scriptName!,
         accountId: acct,
+        deadLetterQueue: news.deadLetterQueue,
+        settings: news.settings,
       };
     }),
     delete: Effect.fn(function* ({ output }) {
+      // If the consumerId is a `dev:` ID, the resource only exists locally, so we don't need to delete it from Cloudflare.
+      if (!isLiveId(output.consumerId)) return;
+
       yield* queues
         .deleteConsumer({
           accountId: output.accountId,
@@ -421,6 +445,8 @@ export const QueueConsumerProvider = () =>
                 ? fetched.scriptName
                 : output.scriptName) ?? output.scriptName,
             accountId: output.accountId,
+            deadLetterQueue: output.deadLetterQueue,
+            settings: output.settings,
           };
         }
       }
@@ -439,6 +465,8 @@ export const QueueConsumerProvider = () =>
             queueId: output.queueId,
             scriptName: match.script ?? output.scriptName,
             accountId: output.accountId,
+            deadLetterQueue: output.deadLetterQueue,
+            settings: output.settings,
           };
         }
       }
@@ -465,3 +493,77 @@ const toObserved = (c: {
 const queueHandlerReadinessSchedule = Schedule.spaced("2 seconds").pipe(
   Schedule.both(Schedule.recurs(30)),
 );
+
+export const QueueConsumerProviderLocal = () =>
+  RpcProvider.effect(
+    QueueConsumer,
+    LOCAL_ENTRY_URL,
+    Effect.gen(function* () {
+      const localRuntimeState = yield* LocalRuntimeState;
+      return {
+        diff: Effect.fn(function* ({ news, output }) {
+          const { accountId } = yield* yield* CloudflareEnvironment;
+          if (!output) return { action: "update" };
+          if (!isResolved(news)) return undefined;
+          if (
+            output.queueId !== news.queueId ||
+            output.accountId !== accountId
+          ) {
+            return { action: "replace" };
+          }
+          if (
+            JSON.stringify(output.settings ?? {}) !==
+              JSON.stringify(news.settings ?? {}) ||
+            output.scriptName !== news.scriptName ||
+            output.deadLetterQueue !== news.deadLetterQueue
+          ) {
+            return { action: "update" };
+          }
+          // If the resource is a noop, add it to the local runtime state so it's available downstream.
+          // We do it here instead of in the reconcile function so it doesn't appear as an update.
+          MutableHashMap.set(
+            localRuntimeState.queueConsumers,
+            output.consumerId,
+            output,
+          );
+          return { action: "noop" };
+        }),
+        read: Effect.fn(function* ({ output }) {
+          if (!output?.consumerId) return undefined;
+          return MutableHashMap.get(
+            localRuntimeState.queueConsumers,
+            output.consumerId,
+          ).pipe(Option.getOrUndefined);
+        }),
+        reconcile: Effect.fn(function* ({ news, output }) {
+          const { accountId } = yield* yield* CloudflareEnvironment;
+          const consumer: QueueConsumer["Attributes"] = {
+            consumerId: output?.consumerId ?? `dev:${crypto.randomUUID()}`,
+            queueId: news.queueId,
+            scriptName: news.scriptName,
+            deadLetterQueue: news.deadLetterQueue,
+            accountId,
+            settings: news.settings,
+          };
+          MutableHashMap.set(
+            localRuntimeState.queueConsumers,
+            consumer.consumerId,
+            consumer,
+          );
+          return consumer;
+        }),
+        delete: Effect.fn(function* ({ output }) {
+          MutableHashMap.remove(
+            localRuntimeState.queueConsumers,
+            output.consumerId,
+          );
+        }),
+      };
+    }),
+  );
+
+export const QueueConsumerProvider = () =>
+  ProviderLayer.select({
+    local: () => QueueConsumerProviderLocal(),
+    live: () => QueueConsumerProviderLive(),
+  });

package/src/Cloudflare/Workers/Assets.ts

@@ -1,4 +1,4 @@
-import { Ignore } from "@alchemy.run/node-utils/ignore";
+import createIgnore from "@alchemy.run/node-utils/ignore";
 import * as workers from "@distilled.cloud/cloudflare/workers";
 import * as Data from "effect/Data";
 import * as Effect from "effect/Effect";
@@ -98,7 +98,7 @@ const maybeReadString = Effect.fnUntraced(function* (file: string) {
 });
 
 const createIgnoreMatcher = (patterns: string[]) => {
-  const matcher = new Ignore().add(patterns);
+  const matcher = createIgnore().add(patterns);
   return (file: string) => matcher.ignores(file);
 };
 

package/src/Cloudflare/Workers/LocalWorkerProvider.ts

@@ -1,5 +1,4 @@
 import {
-  layerRuntime,
   Runtime,
   RuntimeError,
   type BindingHook,
@@ -8,6 +7,7 @@ import {
   type Module,
   type Assets as RuntimeAssets,
   type DurableObjectNamespace as RuntimeDurableObjectNamespace,
+  type QueueConsumer as RuntimeQueueConsumer,
   type RuntimeServices,
 } from "@distilled.cloud/cloudflare-runtime";
 import {
@@ -26,6 +26,7 @@ import {
   KvNamespace,
   MtlsCertificate,
   Pipelines,
+  Queue,
   R2Bucket,
   RateLimit,
   SendEmail,
@@ -44,19 +45,21 @@ import * as Equal from "effect/Equal";
 import * as Exit from "effect/Exit";
 import * as Fiber from "effect/Fiber";
 import * as Hash from "effect/Hash";
+import * as MutableHashMap from "effect/MutableHashMap";
+import * as Option from "effect/Option";
 import * as Path from "effect/Path";
 import * as Redacted from "effect/Redacted";
 import * as Result from "effect/Result";
 import * as Schema from "effect/Schema";
 import * as Scope from "effect/Scope";
 import * as Stream from "effect/Stream";
-import { AlchemyContext } from "../../AlchemyContext.ts";
 import type * as Bundle from "../../Bundle/Bundle.ts";
 import { isResolved } from "../../Diff.ts";
 import * as RpcProvider from "../../Local/RpcProvider.ts";
 import type { ResourceBinding } from "../../Resource.ts";
 import { Stack } from "../../Stack.ts";
 import { CloudflareEnvironment } from "../CloudflareEnvironment.ts";
+import { LOCAL_ENTRY_URL, LocalRuntimeState } from "../LocalRuntime.ts";
 import type { WorkerAssetsConfig, WorkerProps } from "../Workers/Worker.ts";
 import { getCompatibility } from "./Compatibility.ts";
 import * as Vite from "./Vite.ts";
@@ -79,41 +82,16 @@ export class WorkerValidationError extends Schema.TaggedErrorClass<WorkerValidat
   },
 ) {}
 
-export const localRuntimeServices = () =>
-  RpcProvider.providerServicesEffect(
-    Effect.gen(function* () {
-      const { accountId } = yield* yield* CloudflareEnvironment;
-      const { dotAlchemy } = yield* AlchemyContext;
-      const path = yield* Path.Path;
-      return layerRuntime({
-        api: {
-          accountId,
-        },
-        storage: {
-          directory: path.join(dotAlchemy, "local"),
-        },
-      });
-    }),
-  );
-
 export const LocalWorkerProvider = () =>
   RpcProvider.effect(
     Worker,
-    import.meta.resolve(
-      // `import.meta.resolve(<string>)` is a runtime API — TypeScript's
-      // `rewriteRelativeImportExtensions` does NOT touch the string literal, so
-      // we have to pick the right extension ourselves. `import.meta.url` reflects
-      // the actual on-disk extension of *this* file (`.ts` when loaded from
-      // `src/` under Bun or vitest, `.js` when loaded from the compiled `lib/`
-      // under Node), which is exactly the signal we need.
-      import.meta.url.endsWith(".ts") ? "../Local.ts" : "../Local.js",
-      import.meta.url,
-    ),
+    LOCAL_ENTRY_URL,
     Effect.gen(function* () {
       const bundler = yield* WorkerBundle;
       const runtime = yield* Runtime;
       const stack = yield* Stack;
       const path = yield* Path.Path;
+      const localRuntimeState = yield* LocalRuntimeState;
       const workerProxy = yield* WorkerProxy.WorkerProxy;
       const proxyInstances = new Map<
         string,
@@ -124,6 +102,32 @@ export const LocalWorkerProvider = () =>
         }
       >();
 
+      const getQueueConsumers = Effect.fnUntraced(function* (
+        scriptName: string,
+      ) {
+        const consumers: RuntimeQueueConsumer[] = [];
+        for (const consumer of MutableHashMap.values(
+          localRuntimeState.queueConsumers,
+        )) {
+          if (consumer.scriptName === scriptName) {
+            const queue = MutableHashMap.get(
+              localRuntimeState.queues,
+              consumer.queueId,
+            ).pipe(Option.getOrUndefined);
+            if (queue) {
+              consumers.push({
+                queueName: queue.queueName,
+                deadLetterQueue: consumer.deadLetterQueue,
+                ...consumer.settings,
+              });
+            } else {
+              return yield* Effect.die(`Queue ${consumer.queueId} not found`);
+            }
+          }
+        }
+        return consumers;
+      });
+
       const startProxy = Effect.fn(function* (
         id: string,
         serverOptions: WorkerConfig["dev"],
@@ -211,6 +215,7 @@ export const LocalWorkerProvider = () =>
             durableObjectNamespaces: toRuntimeDurableObjectNamespaces(
               worker.durableObjectNamespaces,
             ),
+            queueConsumers: yield* getQueueConsumers(worker.name),
             modules: yield* toRuntimeModules(bundle),
             assets: toRuntimeAssets(worker.assets),
           })
@@ -392,6 +397,7 @@ export const LocalWorkerProvider = () =>
                 worker.durableObjectNamespaces,
               ),
               hyperdrives: worker.hyperdrives,
+              queueConsumers: yield* getQueueConsumers(worker.name),
               assets: toRuntimeAssets(worker.assets),
             },
             context,
@@ -586,7 +592,10 @@ const toRuntimeBinding = Effect.fnUntraced(function* (b: WorkerBinding) {
     case "plain_text":
       return Text.local(b.name, b.text);
     case "queue":
-      return yield* unsupported();
+      return Queue.local({
+        binding: b.name,
+        queueName: b.queueName,
+      });
     case "r2_bucket":
       return R2Bucket.remote(b.name, b.bucketName, b.jurisdiction);
     case "ratelimit":

package/src/Cloudflare/Workers/Worker.ts

@@ -6,20 +6,19 @@ import type { ConfigError } from "effect/Config";
 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 Path from "effect/Path";
 import * as Predicate from "effect/Predicate";
 import * as Redacted from "effect/Redacted";
 import * as Schedule from "effect/Schedule";
 import * as crypto from "node:crypto";
 import { Unowned } from "../../AdoptPolicy.ts";
-import { AlchemyContext } from "../../AlchemyContext.ts";
 import * as Artifacts from "../../Artifacts.ts";
 import { hashDirectory, type MemoOptions } from "../../Build/Memo.ts";
 import * as Bundle from "../../Bundle/Bundle.ts";
 import type { ScopedPlanStatusSession } from "../../Cli/Cli.ts";
 import { isResolved } from "../../Diff.ts";
 import type { InputProps } from "../../Input.ts";
+import * as ProviderLayer from "../../Local/ProviderLayer.ts";
 import { Platform, type Main, type PlatformProps } from "../../Platform.ts";
 import * as Provider from "../../Provider.ts";
 import { Resource, type ResourceBinding } from "../../Resource.ts";
@@ -36,10 +35,7 @@ import {
 } from "./Assets.ts";
 import { getCompatibility } from "./Compatibility.ts";
 import { isDurableObjectExport } from "./DurableObjectNamespace.ts";
-import {
-  LocalWorkerProvider,
-  localRuntimeServices,
-} from "./LocalWorkerProvider.ts";
+import { LocalWorkerProvider } from "./LocalWorkerProvider.ts";
 import { Request } from "./Request.ts";
 import * as Vite from "./Vite.ts";
 import {
@@ -743,27 +739,10 @@ class MissingDurableObjectNamespaces extends Data.TaggedError(
   expected: string[];
 }> {}
 
-const selectLayer = <
-  LayerLive extends Layer.Layer<any, any, any>,
-  LayerDev extends Layer.Layer<any, any, any>,
->(input: {
-  live: () => LayerLive;
-  dev: () => LayerDev;
-}): Layer.Layer<
-  Layer.Success<LayerLive | LayerDev>,
-  Layer.Error<LayerLive | LayerDev>,
-  Layer.Services<LayerLive | LayerDev> | AlchemyContext
-> =>
-  Layer.unwrap(
-    AlchemyContext.useSync((context) =>
-      context.dev ? input.dev() : input.live(),
-    ),
-  );
-
 export const WorkerProvider = () =>
-  selectLayer({
-    live: LiveWorkerProvider,
-    dev: () => Layer.provide(LocalWorkerProvider(), localRuntimeServices()),
+  ProviderLayer.select({
+    live: () => LiveWorkerProvider(),
+    local: () => LocalWorkerProvider(),
   });
 
 export const LiveWorkerProvider = () =>

package/src/Local/ProviderLayer.ts

@@ -0,0 +1,22 @@
+import * as Layer from "effect/Layer";
+import { AlchemyContext } from "../AlchemyContext.ts";
+
+/**
+ * Returns a layer that selects the live or local provider based on the `AlchemyContext.dev` flag.
+ */
+export const select = <
+  LayerLive extends Layer.Layer<any, any, any>,
+  LayerLocal extends Layer.Layer<any, any, any>,
+>(input: {
+  live: () => LayerLive;
+  local: () => LayerLocal;
+}): Layer.Layer<
+  Layer.Success<LayerLive | LayerLocal>,
+  Layer.Error<LayerLive | LayerLocal>,
+  Layer.Services<LayerLive | LayerLocal> | AlchemyContext
+> =>
+  Layer.unwrap(
+    AlchemyContext.useSync((context) =>
+      context.dev ? input.local() : input.live(),
+    ),
+  );

package/src/Local/RpcProvider.ts

@@ -5,6 +5,7 @@ import * as Option from "effect/Option";
 import * as Predicate from "effect/Predicate";
 import type { Scope } from "effect/Scope";
 import * as Stream from "effect/Stream";
+import { AlchemyContext } from "../AlchemyContext.ts";
 import { InstanceId } from "../InstanceId.ts";
 import type { Platform } from "../Platform.ts";
 import * as Provider from "../Provider.ts";
@@ -76,6 +77,7 @@ export const effect = <
     cls,
     Effect.gen(function* () {
       const client = yield* Effect.serviceOption(RpcProviderProxy);
+      const context = yield* Effect.context();
       const stack = yield* Stack;
 
       if (client._tag === "None") {
@@ -87,6 +89,7 @@ export const effect = <
             return (...args: any[]) => {
               const result = value(...args);
               const services = Layer.mergeAll(
+                Layer.succeedContext(context),
                 layerFallback(Stack, stack),
                 layerFallback(Stage, stack.stage),
                 Predicate.hasProperty(args[0], "instanceId") &&
@@ -127,7 +130,8 @@ const layerFallback = <I, S>(
  */
 export const providerServices = <ROut, E, RIn>(
   self: Layer.Layer<ROut, E, RIn>,
-): Layer.Layer<ROut, E, RIn> => providerServicesEffect(Effect.succeed(self));
+): Layer.Layer<ROut, E, RIn | AlchemyContext> =>
+  providerServicesEffect(Effect.succeed(self));
 
 /**
  * Conditionally constructs a layer for use by an RpcProvider.
@@ -137,10 +141,12 @@ export const providerServices = <ROut, E, RIn>(
  */
 export const providerServicesEffect = <A, E1, R1, E, R>(
   self: Effect.Effect<Layer.Layer<A, E1, R1>, E, R>,
-): Layer.Layer<A, E | E1, R1 | Exclude<R, Scope>> =>
-  Effect.serviceOption(RpcProviderProxy).pipe(
-    Effect.flatMap((client) =>
-      client._tag === "None" ? self : (Effect.succeed(Layer.empty) as never),
+): Layer.Layer<A, E | E1, R1 | Exclude<R, Scope> | AlchemyContext> =>
+  Effect.zip(AlchemyContext, Effect.serviceOption(RpcProviderProxy)).pipe(
+    Effect.flatMap(([context, client]) =>
+      context.dev && client._tag === "None"
+        ? self
+        : (Effect.succeed(Layer.empty) as never),
     ),
     Layer.unwrap,
   );

package/src/Local/RpcProviderProxy.ts

@@ -1,4 +1,4 @@
-import { newWebSocketRpcSession, type RpcStub } from "capnweb";
+import { newWebSocketRpcSession } from "capnweb";
 import * as Cache from "effect/Cache";
 import * as Config from "effect/Config";
 import * as Context from "effect/Context";
@@ -42,7 +42,7 @@ const make = Effect.fnUntraced(function* (spawnerUrl: string) {
         body: yield* HttpBody.json(payload),
       });
       const websocketUrl = yield* response.text;
-      return newWebSocketRpcSession(websocketUrl) as RpcStub<RpcProxyApi>;
+      return newWebSocketRpcSession<RpcProxyApi>(websocketUrl);
     },
     (effect, serverEntryUrl) =>
       Effect.catch(effect, (error) =>

package/src/Local/RpcSerialization.ts

@@ -64,7 +64,7 @@ export const wrapRpcHandlers = <T extends Record<string, any>>(
         ? streamKeys?.includes(key)
           ? wrapRpcStreamHandler(value)
           : wrapRpcEffectHandler(value)
-        : typeof value === "object" && value !== null
+        : typeof value === "object" && value !== null && !Array.isArray(value)
           ? wrapRpcHandlers(value)
           : value,
     ]),
@@ -82,7 +82,7 @@ export const unwrapRpcHandlers = <T extends Record<string, any>>(
         ? streamKeys?.includes(key)
           ? unwrapRpcStreamHandler(value)
           : unwrapRpcEffectHandler(value)
-        : typeof value === "object" && value !== null
+        : typeof value === "object" && value !== null && !Array.isArray(value)
           ? unwrapRpcHandlers(value)
           : value,
     ]),