alchemy 2.0.0-beta.77 → 2.0.0-beta.78

package/src/Cloudflare/SecretsStore/Secret.ts

@@ -17,7 +17,7 @@ import { isResourceOfType, Resource } from "../../Resource.ts";
 import { CloudflareEnvironment } from "../CloudflareEnvironment.ts";
 import {
   generateLocalId,
-  LOCAL_ENTRY_URL,
+  LOCAL_PROVIDERS_URL,
   localRuntimeServices,
 } from "../LocalRuntime.ts";
 import type { Providers } from "../Providers.ts";
@@ -391,7 +391,7 @@ export const SecretProviderLive = () =>
 export const SecretProviderLocal = () =>
   RpcProvider.effect(
     Secret,
-    LOCAL_ENTRY_URL,
+    LOCAL_PROVIDERS_URL,
     Effect.gen(function* () {
       // The local runtime services (workerd `Runtime`, binding plugins) and
       // the HTTP client are resolved once at layer build and closed over —
@@ -466,7 +466,7 @@ export const StoreSecretProvider = () =>
     // The local provider's reconcile/delete boot an ephemeral workerd
     // gateway to seed the simulator, so it needs the shared local runtime
     // layer. Under `alchemy dev` the provider is an RPC stub (this gated
-    // layer is empty and unused) and the sidecar entry (`../Local.ts`)
+    // layer is empty and unused) and the provider group (`../Local.ts`)
     // supplies the real runtime; without the proxy the provider builds
     // in-process and this layer is real.
     local: () =>

package/src/Cloudflare/Snippets/SnippetRules.ts

@@ -203,11 +203,17 @@ export const SnippetRulesProvider = () =>
     }),
 
     delete: Effect.fn(function* ({ output }) {
-      // `deleteRule` removes the zone's entire rule list; deleting an
-      // already-empty list succeeds, making this naturally idempotent.
+      // An empty zone's DELETE can return "requested zone not found" even
+      // though the zone exists. Observe first so repeated deletes converge.
+      if ((yield* listObservedRules(output.zoneId)).length === 0) return;
       yield* snippets
         .deleteRule({ zoneId: output.zoneId })
-        .pipe(Effect.catchTag("SnippetRulesNotFound", () => Effect.void));
+        .pipe(
+          Effect.catchTag(
+            ["SnippetRulesNotFound", "SnippetZoneNotFound"],
+            () => Effect.void,
+          ),
+        );
     }),
   });
 

package/src/Cloudflare/StateStore/State.ts

@@ -12,7 +12,6 @@ import crypto from "node:crypto";
 
 import * as Config from "effect/Config";
 import * as Option from "effect/Option";
-import { isHttpClientError } from "effect/unstable/http/HttpClientError";
 import { adopt } from "../../AdoptPolicy.ts";
 import { AlchemyContext } from "../../AlchemyContext.ts";
 import { AuthError } from "../../Auth/AuthProvider.ts";
@@ -31,7 +30,11 @@ import {
   type HttpStateStoreCredentials,
 } from "../../State/HttpStateStore.ts";
 import { makeLocalState } from "../../State/LocalState.ts";
-import { State, type StateService } from "../../State/State.ts";
+import {
+  State,
+  type StateService,
+  type StateStoreError,
+} from "../../State/State.ts";
 import {
   recordStateStoreInit,
   recordStateStoreOp,
@@ -53,7 +56,7 @@ import {
   TokenValue,
 } from "./Token.ts";
 
-const CI = Config.boolean("CI").pipe(Config.withDefault(false));
+const CI = Config.Boolean("CI").pipe(Config.withDefault(false));
 
 export const state = () =>
   Layer.effect(
@@ -657,18 +660,14 @@ const deployWithLocalState = ({
  *
  * @internal exported for unit testing.
  */
-export const isTransientBootstrapWriteError = (error: {
-  cause?: unknown;
-}): boolean => {
-  const cause = error.cause;
-  if (cause == null) return false;
-  const tag = (cause as { _tag?: unknown })._tag;
-  if (typeof tag === "string" && tag.startsWith("Unauthorized")) return true;
-  if (isHttpClientError(cause)) {
-    const status = cause.response?.status;
-    return status === undefined || status === 404 || status >= 500;
-  }
-  return false;
+export const isTransientBootstrapWriteError = (
+  error: Pick<StateStoreError, "http">,
+): boolean => {
+  if (error.http === undefined) return false;
+  const { status } = error.http;
+  return (
+    status === undefined || status === 401 || status === 404 || status >= 500
+  );
 };
 
 // check if there's a local stack that wasn't properly hoisted
@@ -1185,7 +1184,7 @@ const annotateAccountHash = (noTrack?: boolean) =>
   Effect.gen(function* () {
     if (noTrack === true) return;
     if (noTrack === undefined) {
-      const fromEnv = yield* Config.boolean("NO_TRACK").pipe(
+      const fromEnv = yield* Config.Boolean("NO_TRACK").pipe(
         Config.withDefault(false),
       );
       if (fromEnv) return;

package/src/Cloudflare/Website/Nuxt.ts

@@ -134,7 +134,7 @@ export interface NuxtProps<
  * ```typescript
  * const site = yield* Cloudflare.Website.Nuxt("Website", {
  *   env: {
- *     API_KEY: Config.redacted("API_KEY"),
+ *     API_KEY: Config.Redacted("API_KEY"),
  *   },
  * });
  *

package/src/Cloudflare/Website/Octane.ts

@@ -132,7 +132,7 @@ export interface OctaneProps<
  *
  * const site = yield* Cloudflare.Website.Octane("Website", {
  *   env: {
- *     API_KEY: Config.redacted("API_KEY"),
+ *     API_KEY: Config.Redacted("API_KEY"),
  *   },
  * });
  * ```

package/src/Cloudflare/Website/SvelteKit.ts

@@ -94,7 +94,7 @@ export interface SvelteKitProps<
  * ```typescript
  * const site = yield* Cloudflare.Website.SvelteKit("Website", {
  *   env: {
- *     API_KEY: Config.redacted("API_KEY"),
+ *     API_KEY: Config.Redacted("API_KEY"),
  *   },
  * });
  *

package/src/Cloudflare/Workers/Assets.ts

@@ -1,6 +1,6 @@
 import * as workers from "@distilled.cloud/cloudflare/workers";
 import * as wfp from "@distilled.cloud/cloudflare/workers-for-platforms";
-import { Retry } from "@distilled.cloud/cloudflare";
+import * as Retry from "@distilled.cloud/cloudflare/Retry";
 import * as Data from "effect/Data";
 import * as Effect from "effect/Effect";
 import * as FileSystem from "effect/FileSystem";

package/src/Cloudflare/Workers/CloudflareTracer.ts

@@ -104,7 +104,7 @@ export const layer: Layer.Layer<never> = Layer.effect(
         );
       },
       context(primitive, fiber) {
-        return contextFor(fiber.currentSpan)(() =>
+        return contextFor(fiber.cache.span)(() =>
           primitive["~effect/Effect/evaluate"](fiber),
         );
       },

package/src/Cloudflare/Workers/DurableObject.ts

@@ -20,7 +20,7 @@ import {
   DurableObjectState,
   fromDurableObjectState,
 } from "./DurableObjectState.ts";
-import { makeRpcStub } from "./Rpc.ts";
+import { makeRpcStub, type RpcErrorClass } from "./Rpc.ts";
 import { type WebSocket } from "./WebSocket.ts";
 import {
   isWorker,
@@ -125,6 +125,7 @@ export interface DurableObjectShape {
 export type DurableObjectServices =
   | DurableObject
   | DurableObjectState
+  | DurableObjectScope
   | WorkerServices
   | WorkerEnvironment
   | PlatformServices;
@@ -258,6 +259,24 @@ export interface DurableObjectProps {
     | DurableObjectTransferSource
     | DurableObjectTransferSource[]
     | undefined;
+  /**
+   * Tagged-error classes this Durable Object's RPC methods can fail with.
+   *
+   * Effect failures crossing the Worker↔DO RPC boundary are serialized to
+   * plain `{ _tag, ...fields }` objects; declaring the classes here lets
+   * the calling side reconstruct real instances (both sides import this
+   * same class declaration, so the schema is shared by construction) —
+   * `Effect.catchTag`, `instanceof`, and schema encoders (e.g. HttpApi
+   * error responses) then all see the class the DO actually failed with.
+   *
+   * ```typescript
+   * export class Repo extends Cloudflare.DurableObject<Repo, RepoShape>()(
+   *   "Repo",
+   *   { errors: [RepoNotFound, StoreError] },
+   * ) {}
+   * ```
+   */
+  errors?: ReadonlyArray<RpcErrorClass> | undefined;
   // environment?: string | undefined;
   // sqlite?: boolean | undefined;
   // namespaceId?: string | undefined;
@@ -271,7 +290,7 @@ export interface DurableObjectClass extends Effect.Effect<
   <Self, Shape>(): {
     <Name extends string>(
       name: Name,
-      props?: Pick<DurableObjectProps, "transferredFrom">,
+      props?: Pick<DurableObjectProps, "transferredFrom" | "errors">,
     ): Effect.Effect<DurableObject<Self>, never, Worker | Self> & {
       new (_: never): Shape & {
         /** @internal */
@@ -293,9 +312,13 @@ export interface DurableObjectClass extends Effect.Effect<
             RuntimeContext | DurableObjectState | Scope
           >,
           never,
-          DurableObjectServices | Req
+          Req
         >,
-      ): Layer.Layer<Self, never, Worker | Req>;
+        // `Exclude` (rather than `DurableObjectServices | Req` inference)
+        // so ambient DO services resolved in the outer init effect never
+        // leak into the host Worker's requirements — mirrors Worker.make's
+        // `Exclude<InitReq, Self | WorkerServices>`.
+      ): Layer.Layer<Self, never, Worker | Exclude<Req, DurableObjectServices>>;
     };
   };
   <Self>(): {
@@ -1187,6 +1210,7 @@ export const DurableObject: DurableObjectClass = taggedFunction(
       transferredFrom?:
         | DurableObjectTransferSource
         | DurableObjectTransferSource[],
+      errors?: ReadonlyArray<RpcErrorClass>,
     ) =>
       Effect.gen(function* () {
         const worker = yield* Worker;
@@ -1241,7 +1265,7 @@ export const DurableObject: DurableObjectClass = taggedFunction(
           getByName: (
             name: string,
             options?: DurableObjectGetDurableObjectOptions,
-          ) => makeRpcStub(binding.getByName(name, options)),
+          ) => makeRpcStub(binding.getByName(name, options), { errors }),
           // newUniqueId: () => use((ns) => ns.newUniqueId()),
           // idFromName: (name: string) => use((ns) => ns.idFromName(name)),
           // idFromString: (id: string) => use((ns) => ns.idFromString(id)),
@@ -1260,7 +1284,7 @@ export const DurableObject: DurableObjectClass = taggedFunction(
     const classProps =
       isClassForm && !Effect.isEffect(propsOrImpl)
         ? (propsOrImpl as
-            | Pick<DurableObjectProps, "transferredFrom">
+            | Pick<DurableObjectProps, "transferredFrom" | "errors">
             | undefined)
         : undefined;
 
@@ -1276,7 +1300,11 @@ export const DurableObject: DurableObjectClass = taggedFunction(
       // `DurableObjectScope` to the user's constructor effect
       // and also return it so a `Layer.effect(tag, make(impl))` Layer
       // resolves the tag to a concrete namespace value.
-      const self = yield* binding(undefined, classProps?.transferredFrom);
+      const self = yield* binding(
+        undefined,
+        classProps?.transferredFrom,
+        classProps?.errors,
+      );
       const phase = yield* ALCHEMY_PHASE;
       const constructor = impl.pipe(
         Effect.provide(Layer.succeed(DurableObjectScope, self as any)),
@@ -1368,7 +1396,11 @@ export const DurableObject: DurableObjectClass = taggedFunction(
 
           return resolved.pipe(
             Effect.flatMap((w) =>
-              binding(typeof w === "string" ? w : w.workerName),
+              binding(
+                typeof w === "string" ? w : w.workerName,
+                undefined,
+                classProps?.errors,
+              ),
             ),
           );
         };

package/src/Cloudflare/Workers/DurableObjectBridge.ts

@@ -9,7 +9,7 @@ import * as Scope from "effect/Scope";
 import * as Stream from "effect/Stream";
 
 import { HttpServerResponse } from "effect/unstable/http";
-import { buildEventTelemetry } from "../../Telemetry.ts";
+import { buildEventTelemetry } from "../../TelemetryRuntime.ts";
 import type {
   DurableObjectExport,
   DurableObjectShape,

package/src/Cloudflare/Workers/DurableObjectState.ts

@@ -113,7 +113,7 @@ export const fromDurableObjectState = (
       const context = yield* Effect.context<R>();
       // The failure is typed away as before: a rejected gate is the
       // platform resetting the object, not a value a caller handles.
-      return yield* Effect.tryPromise<T, never>(() =>
+      return yield* Effect.promise(() =>
         state.blockConcurrencyWhile(() =>
           Effect.runPromise(callback().pipe(Effect.provide(context))),
         ),

package/src/Cloudflare/Workers/DurableObjectStorage.ts

@@ -191,19 +191,19 @@ export const fromDurableObjectTransaction = (
   txn: cf.DurableObjectTransaction,
 ): DurableObjectTransaction => ({
   get: ((keyOrKeys: string | string[], options?: cf.DurableObjectGetOptions) =>
-    Effect.tryPromise(() => txn.get(keyOrKeys as any, options))) as any,
+    Effect.promise(() => txn.get(keyOrKeys as any, options))) as any,
   list: (options?: cf.DurableObjectListOptions) =>
-    Effect.tryPromise(() => txn.list(options)),
+    Effect.promise(() => txn.list(options)),
   put: ((
     keyOrEntries: string | Record<string, unknown>,
     valueOrOptions?: unknown,
     maybeOptions?: cf.DurableObjectPutOptions,
   ) =>
     typeof keyOrEntries === "string"
-      ? Effect.tryPromise(() =>
+      ? Effect.promise(() =>
           txn.put(keyOrEntries, valueOrOptions, maybeOptions),
         )
-      : Effect.tryPromise(() =>
+      : Effect.promise(() =>
           txn.put(
             keyOrEntries,
             valueOrOptions as cf.DurableObjectPutOptions | undefined,
@@ -212,35 +212,35 @@ export const fromDurableObjectTransaction = (
   delete: ((
     keyOrKeys: string | string[],
     options?: cf.DurableObjectPutOptions,
-  ) => Effect.tryPromise(() => txn.delete(keyOrKeys as any, options))) as any,
+  ) => Effect.promise(() => txn.delete(keyOrKeys as any, options))) as any,
   rollback: () => Effect.sync(() => txn.rollback()),
   getAlarm: (options?: cf.DurableObjectGetAlarmOptions) =>
-    Effect.tryPromise(() => txn.getAlarm(options)),
+    Effect.promise(() => txn.getAlarm(options)),
   setAlarm: (
     scheduledTime: number | Date,
     options?: cf.DurableObjectSetAlarmOptions,
-  ) => Effect.tryPromise(() => txn.setAlarm(scheduledTime, options)),
+  ) => Effect.promise(() => txn.setAlarm(scheduledTime, options)),
   deleteAlarm: (options?: cf.DurableObjectSetAlarmOptions) =>
-    Effect.tryPromise(() => txn.deleteAlarm(options)),
+    Effect.promise(() => txn.deleteAlarm(options)),
 });
 
 export const fromDurableObjectStorage = (
   storage: cf.DurableObjectStorage,
 ): DurableObjectStorage => ({
   get: ((keyOrKeys: string | string[], options?: cf.DurableObjectGetOptions) =>
-    Effect.tryPromise(() => storage.get(keyOrKeys as any, options))) as any,
+    Effect.promise(() => storage.get(keyOrKeys as any, options))) as any,
   list: (options?: cf.DurableObjectListOptions) =>
-    Effect.tryPromise(() => storage.list(options)),
+    Effect.promise(() => storage.list(options)),
   put: ((
     keyOrEntries: string | Record<string, unknown>,
     valueOrOptions?: unknown,
     maybeOptions?: cf.DurableObjectPutOptions,
   ) =>
     typeof keyOrEntries === "string"
-      ? Effect.tryPromise(() =>
+      ? Effect.promise(() =>
           storage.put(keyOrEntries, valueOrOptions, maybeOptions),
         )
-      : Effect.tryPromise(() =>
+      : Effect.promise(() =>
           storage.put(
             keyOrEntries,
             valueOrOptions as cf.DurableObjectPutOptions | undefined,
@@ -249,10 +249,9 @@ export const fromDurableObjectStorage = (
   delete: ((
     keyOrKeys: string | string[],
     options?: cf.DurableObjectPutOptions,
-  ) =>
-    Effect.tryPromise(() => storage.delete(keyOrKeys as any, options))) as any,
+  ) => Effect.promise(() => storage.delete(keyOrKeys as any, options))) as any,
   deleteAll: (options?: cf.DurableObjectPutOptions) =>
-    Effect.tryPromise(() => storage.deleteAll(options)),
+    Effect.promise(() => storage.deleteAll(options)),
   transaction: <T, R = never>(
     closure: (txn: DurableObjectTransaction) => Effect.Effect<T, never, R>,
   ) =>
@@ -260,7 +259,7 @@ export const fromDurableObjectStorage = (
       const context = yield* Effect.context<R>();
       // The failure is typed away as before: a rejected transaction has
       // rolled back, and the rejection reaches the caller as a defect.
-      return yield* Effect.tryPromise<T, never>(() =>
+      return yield* Effect.promise(() =>
         storage.transaction((txn) =>
           Effect.runPromise(
             closure(fromDurableObjectTransaction(txn)).pipe(
@@ -271,20 +270,19 @@ export const fromDurableObjectStorage = (
       );
     }),
   getAlarm: (options?: cf.DurableObjectGetAlarmOptions) =>
-    Effect.tryPromise(() => storage.getAlarm(options)),
+    Effect.promise(() => storage.getAlarm(options)),
   setAlarm: (
     scheduledTime: number | Date,
     options?: cf.DurableObjectSetAlarmOptions,
-  ) => Effect.tryPromise(() => storage.setAlarm(scheduledTime, options)),
+  ) => Effect.promise(() => storage.setAlarm(scheduledTime, options)),
   deleteAlarm: (options?: cf.DurableObjectSetAlarmOptions) =>
-    Effect.tryPromise(() => storage.deleteAlarm(options)),
-  sync: () => Effect.tryPromise(() => storage.sync()),
+    Effect.promise(() => storage.deleteAlarm(options)),
+  sync: () => Effect.promise(() => storage.sync()),
   sql: fromSqlStorage(storage.sql),
   kv: storage.kv,
-  getCurrentBookmark: () =>
-    Effect.tryPromise(() => storage.getCurrentBookmark()),
+  getCurrentBookmark: () => Effect.promise(() => storage.getCurrentBookmark()),
   getBookmarkForTime: (timestamp: number | Date) =>
-    Effect.tryPromise(() => storage.getBookmarkForTime(timestamp)),
+    Effect.promise(() => storage.getBookmarkForTime(timestamp)),
   onNextSessionRestoreBookmark: (bookmark: string) =>
-    Effect.tryPromise(() => storage.onNextSessionRestoreBookmark(bookmark)),
+    Effect.promise(() => storage.onNextSessionRestoreBookmark(bookmark)),
 });

package/src/Cloudflare/Workers/HttpServer.ts

@@ -8,7 +8,8 @@ import * as HttpServerRequest from "effect/unstable/http/HttpServerRequest";
 import * as HttpServerResponse from "effect/unstable/http/HttpServerResponse";
 import * as Http from "../../Http.ts";
 import { Request } from "./Request.ts";
-import { isWorkerEvent, type WorkerServices } from "./Worker.ts";
+import type { WorkerServices } from "./Worker.ts";
+import { isWorkerEvent } from "./WorkerRuntime.ts";
 
 export type HttpEffect = Http.HttpEffect<WorkerServices>;
 

package/src/Cloudflare/Workers/InferEnv.ts

@@ -58,8 +58,8 @@ export type GetBindingType<T> =
   // A named-entrypoint service binding (`Cloudflare.WorkerEntrypoint`).
   // Tested first: the marker *contains* a Worker, so the later Worker
   // branches must never see it.
-  T extends WorkerEntrypointBinding
-    ? Fetcher
+  T extends WorkerEntrypointBinding<infer Entrypoint>
+    ? Service<Entrypoint>
     : // A Container bound in `env` is a container-backed Durable Object class —
       // the runtime binding is the class's namespace. Must be tested BEFORE the
       // generic Effect unwrap: a Container declaration is itself an Effect.

package/src/Cloudflare/Workers/LocalWorkerProvider.ts

@@ -45,7 +45,7 @@ import { sha256 } from "../../Util/sha256.ts";
 import { CloudflareEnvironment } from "../CloudflareEnvironment.ts";
 import {
   isLiveId,
-  LOCAL_ENTRY_URL,
+  LOCAL_PROVIDERS_URL,
   LocalRuntimeState,
   localStorageDirectory,
 } from "../LocalRuntime.ts";
@@ -135,7 +135,7 @@ const resolveLocalUrls = (serverUrl: URL): Effect.Effect<string[]> =>
 export const LocalWorkerProvider = () =>
   LocalProvider.make(
     Worker,
-    LOCAL_ENTRY_URL,
+    LOCAL_PROVIDERS_URL,
     Effect.gen(function* () {
       const bundler = yield* WorkerBundle;
       const runtime = yield* Runtime;
@@ -379,7 +379,9 @@ export const LocalWorkerProvider = () =>
         // change (a Dockerfile edit, a rebuilt bundle) would never change
         // the config and the running container would serve stale code.
         const containerHashes: Record<string, string> = {};
+        const boundEnv: Record<string, any> = { ...props.env };
         for (const { data } of bindings) {
+          if (data.env) Object.assign(boundEnv, data.env);
           for (const binding of data.bindings ?? []) {
             if (
               binding.type === "durable_object_namespace" &&
@@ -476,7 +478,7 @@ export const LocalWorkerProvider = () =>
           name,
           compatibility,
           /** User env (Redacted preserved — the canonical hasher unwraps). */
-          env: props.env,
+          env: Object.keys(boundEnv).length > 0 ? boundEnv : props.env,
           /**
            * Raw inline module source (mutually exclusive with `main`).
            * Serves as-is without the bundler; part of the hashed config so
@@ -1047,14 +1049,17 @@ export const LocalWorkerProvider = () =>
                   Effect.log(`[${worker.fqn}] Rebuilding`),
                   // Tells the proxy to queue requests until the updated
                   // worker is ready.
-                  Effect.forkChild(proxy.unset()),
+                  proxy.unset(),
                 ]);
               }
             } else if (event._tag === "Error") {
-              return Effect.logError(
-                `[${worker.fqn}] Bundle error`,
-                event.error,
-              );
+              return Effect.all([
+                Effect.logError(`[${worker.fqn}] Bundle error`, event.error),
+                // No updated worker is coming from this build: answer
+                // parked requests with the error now instead of after the
+                // pending timeout.
+                proxy.fail(event.error.message),
+              ]);
             }
             return Effect.void;
           }),
@@ -1083,10 +1088,13 @@ export const LocalWorkerProvider = () =>
                   status = "update";
                   return message;
                 } else {
-                  return Effect.logError(
-                    `[${worker.fqn}] Error`,
-                    Cause.squash(exit.cause),
-                  );
+                  return Effect.all([
+                    Effect.logError(
+                      `[${worker.fqn}] Error`,
+                      Cause.squash(exit.cause),
+                    ),
+                    proxy.fail(Cause.pretty(exit.cause)),
+                  ]);
                 }
               }),
             ),
@@ -1238,7 +1246,7 @@ export const LocalWorkerProvider = () =>
                 }
               }
               // Queue requests while the child is (re)starting.
-              yield* proxy.unset().pipe(Effect.forkChild);
+              yield* proxy.unset();
               // The dev server and its workerd run in a child process rooted
               // at the app.
               const root = path.resolve(rootDir ?? process.cwd());
@@ -1286,6 +1294,7 @@ export const LocalWorkerProvider = () =>
                         workflows: worker.workflows,
                         hyperdrives: worker.hyperdrives,
                         queueConsumers,
+                        crons: worker.crons,
                         assets: yield* toRuntimeAssets(worker.assets),
                       },
                     },
@@ -1308,17 +1317,19 @@ export const LocalWorkerProvider = () =>
                 );
                 workerdScopes.set(worker.fqn, scope);
                 latestViteServes.set(worker.fqn, args);
-                // Unexpected child death: log, park the proxy, and mark the
-                // instance for update on the next plan. Forked into the
-                // child's scope so a deliberate restart or teardown
-                // interrupts the watcher before the process is killed.
+                // Unexpected child death: log, fail the proxy so requests
+                // see why instead of parking, and mark the instance for
+                // update on the next plan. Forked into the child's scope so
+                // a deliberate restart or teardown interrupts the watcher
+                // before the process is killed.
                 yield* child.exitCode.pipe(
-                  Effect.flatMap((exitCode) =>
-                    Effect.logWarning(
-                      `[${worker.fqn}] Dev server child exited unexpectedly with code ${exitCode}`,
-                    ),
-                  ),
-                  Effect.andThen(proxy.unset().pipe(Effect.ignore)),
+                  Effect.flatMap((exitCode) => {
+                    const message = `[${worker.fqn}] Dev server child exited unexpectedly with code ${exitCode}`;
+                    return Effect.all([
+                      Effect.logWarning(message),
+                      proxy.fail(message),
+                    ]);
+                  }),
                   Effect.andThen(invalidate),
                   Effect.forkIn(scope),
                 );
@@ -1386,7 +1397,7 @@ export const LocalWorkerProvider = () =>
         // Queue requests until the source's first output is served —
         // whether that's the first workerd serve (bundle mode) or the dev
         // server URL (server mode).
-        yield* proxy.unset().pipe(Effect.forkChild);
+        yield* proxy.unset();
         // `loadSource` is typed against the full `SourceServices` union
         // (which includes the per-run Artifacts cache the live provider
         // supplies); local dev has no run-scoped cache, so hand the

package/src/Cloudflare/Workers/Rpc.ts

@@ -10,7 +10,13 @@ import {
   type RpcGroup,
 } from "effect/unstable/rpc";
 import type * as RpcClientError from "effect/unstable/rpc/RpcClientError";
-import { asEffectOrStream, decodeRpcResult, RpcCallError } from "../../Rpc.ts";
+import {
+  asEffectOrStream,
+  decodeRpcResult,
+  makeRpcErrorReviver,
+  RpcCallError,
+  type RpcErrorClass,
+} from "../../Rpc.ts";
 import { isYieldableEffect } from "../../Util/effect.ts";
 import { fromCloudflareFetcher } from "../Fetcher.ts";
 
@@ -34,12 +40,21 @@ export * from "../../Rpc.ts";
  */
 export const makeRpcStub = <Shape>(
   stubSource: unknown | Effect.Effect<unknown, never, never>,
+  options?: {
+    /**
+     * Declared error classes (see {@link RpcErrorClass}): failed method
+     * results whose `_tag` matches one are reconstructed as real class
+     * instances instead of the plain objects RPC serialization produces.
+     */
+    readonly errors?: ReadonlyArray<RpcErrorClass> | undefined;
+  },
 ): Shape => {
   const isLazy = isYieldableEffect(stubSource);
   const eagerFetcher = isLazy
     ? undefined
     : fromCloudflareFetcher(stubSource as cf.Fetcher);
   const proxyTarget: object = eagerFetcher ?? {};
+  const revive = makeRpcErrorReviver(options?.errors);
 
   return new Proxy(proxyTarget, {
     get: (target: any, prop) => {
@@ -57,7 +72,7 @@ export const makeRpcStub = <Shape>(
               try: () => (stub as any)[prop](...args),
               catch: (cause) =>
                 new RpcCallError({ method: String(prop), cause }),
-            }).pipe(Effect.flatMap(decodeRpcResult));
+            }).pipe(Effect.flatMap((value) => decodeRpcResult(value, revive)));
           }),
         );
     },

package/src/Cloudflare/Workers/RpcAsync.ts

@@ -1,7 +1,7 @@
 import type * as Effect from "effect/Effect";
 import type * as Stream from "effect/Stream";
 import type { Rpc } from "../../Rpc.ts";
-import { isRpcErrorEnvelope, isRpcStreamEnvelope } from "../Bridge.ts";
+import { isRpcErrorEnvelope, isRpcStreamEnvelope } from "./Rpc.ts";
 
 export type RpcAsync<Shape> = {
   [K in keyof Shape as K extends "fetch" ? never : K]: Shape[K] extends (

package/src/Cloudflare/Workers/Sources/Prebuilt.ts

@@ -1,6 +1,6 @@
 import * as Effect from "effect/Effect";
 import * as FileSystem from "effect/FileSystem";
-import fg from "fast-glob";
+import { glob } from "tinyglobby";
 import path from "pathe";
 import * as Artifacts from "../../../Artifacts.ts";
 import * as Bundle from "../../../Bundle/Bundle.ts";
@@ -90,11 +90,12 @@ export const readPrebuiltWorkerBundle = Effect.fn(function* (
     Effect.zipWith(
       Effect.tryPromise({
         try: () =>
-          fg.glob(
+          glob(
             (options.rules ?? defaultModuleRules).flatMap((rule) => rule.globs),
             {
               cwd: root,
               onlyFiles: true,
+              expandDirectories: false,
               dot: true,
             },
           ),