alchemy 2.0.0-beta.61 → 2.0.0-beta.62

package/src/Cloudflare/Workflows/Workflow.ts

@@ -2,9 +2,9 @@ import * as workflows from "@distilled.cloud/cloudflare/workflows";
 import type { ConfigError } from "effect/Config";
 import * as Context from "effect/Context";
 import * as Effect from "effect/Effect";
+import type { Scope } from "effect/Scope";
 import * as Stream from "effect/Stream";
 import { AlchemyContext } from "../../AlchemyContext.ts";
-import { ExecutionContext } from "../../ExecutionContext.ts";
 import type { Input } from "../../Input.ts";
 import { ALCHEMY_PHASE } from "../../Phase.ts";
 import type { PlatformServices } from "../../Platform.ts";
@@ -18,6 +18,7 @@ import {
   WorkerEnvironment,
   type WorkerServices,
 } from "../Workers/Worker.ts";
+import { makeWorkflowName } from "./WorkflowName.ts";
 
 type TypeId = "Cloudflare.Workflow";
 const TypeId = "Cloudflare.Workflow" as const;
@@ -243,17 +244,17 @@ export const waitForEvent = <T = unknown>(
  * reflect that or `yield* WorkerEnvironment` fails to type-check inside a
  * body even though it succeeds at runtime.
  *
- * `ExecutionContext` (scope + cache) is provided per run-invocation by
- * `WorkflowBridge.run` and threaded into every `task` via the surrounding
- * body context, so `@binding` helpers that need it (e.g. `Drizzle.postgres`)
- * resolve their per-run resources inside workflow steps just as they do in a
- * Worker `fetch`/`queue` handler.
+ * A fresh `Scope` is provided per run-invocation by `WorkflowBridge.run` and
+ * threaded into every `task` via the surrounding body context, so `@binding`
+ * helpers that acquire per-run resources against the ambient scope (e.g.
+ * `Drizzle.postgres`) resolve them inside workflow steps just as they do in
+ * a Worker `fetch`/`queue` handler.
  */
 export type WorkflowRunServices =
   | WorkflowEvent
   | WorkflowStep
   | WorkerServices
-  | ExecutionContext;
+  | Scope;
 
 export type WorkflowServices =
   | WorkflowRunServices
@@ -759,7 +760,6 @@ export const Workflow: WorkflowClass = taggedFunction(WorkflowScope, ((
     return {
       kind: TypeId,
       name,
-      workflowName: name,
       className: props?.className ?? name,
       scriptName: props?.scriptName,
     } satisfies WorkflowLike;
@@ -769,25 +769,27 @@ export const Workflow: WorkflowClass = taggedFunction(WorkflowScope, ((
     Effect.gen(function* () {
       const worker = yield* Worker;
 
+      // Workflow names are account-global, so derive the physical name from
+      // the already-unique host Worker name and exported class name.
+      const workflowName = makeWorkflowName(worker.workerName, name);
+      const workflow = yield* WorkflowResource(name, {
+        workflowName,
+        className: name,
+        scriptName: worker.workerName,
+      });
+
       // Add the workflow binding to the Worker metadata
       yield* worker.bind`${name}`({
         bindings: [
           {
             type: "workflow",
             name,
-            workflowName: name,
+            workflowName: workflow.workflowName,
             className: name,
           },
         ],
       });
 
-      // Create the Workflow API resource (putWorkflow / deleteWorkflow)
-      yield* WorkflowResource(name, {
-        workflowName: name,
-        className: name,
-        scriptName: worker.workerName,
-      });
-
       const services = yield* Effect.context<Effect.Services<typeof impl>>();
 
       const binding = yield* Effect.all([
@@ -854,6 +856,9 @@ export const Workflow: WorkflowClass = taggedFunction(WorkflowScope, ((
 // ---------------------------------------------------------------------------
 
 export interface WorkflowResourceProps {
+  /**
+   * Account-global Workflow name.
+   */
   workflowName: string;
   className: string;
   scriptName: string;
@@ -887,7 +892,7 @@ export const WorkflowProvider = () =>
 
       return WorkflowResource.Provider.of({
         // The `workflowId` is no longer marked as stable because if you start in dev mode, the ID will change on first deploy.
-        stables: ["accountId"],
+        stables: ["accountId", "workflowName"],
         // Workflows are account-scoped. Enumerate every workflow in the account
         // via the paginated list API and hydrate each into the same Attributes
         // shape `reconcile` returns (id/name/className/scriptName are all on the
@@ -918,17 +923,46 @@ export const WorkflowProvider = () =>
             return { action: "update" };
           }
         }),
+        read: Effect.fn(function* ({ output, olds }) {
+          // Dev workflows only exist in local state; there is no account-level
+          // Workflow API resource to observe until the first real deploy.
+          if (ctx.dev) return output;
+
+          const { accountId } = yield* yield* CloudflareEnvironment;
+          const workflowName = output?.workflowName ?? olds?.workflowName;
+          if (workflowName === undefined) return undefined;
+
+          const acct = output?.accountId ?? accountId;
+          return yield* workflows
+            .getWorkflow({
+              accountId: acct,
+              workflowName,
+            })
+            .pipe(
+              Effect.map((workflow) => ({
+                workflowId: workflow.id,
+                workflowName: workflow.name,
+                className: workflow.className,
+                scriptName: workflow.scriptName,
+                accountId: acct,
+              })),
+              Effect.catchTag("WorkflowNotFound", () =>
+                Effect.succeed(undefined),
+              ),
+            );
+        }),
         reconcile: Effect.fn(function* ({ news, output }) {
           const { accountId } = yield* yield* CloudflareEnvironment;
           const acct = output?.accountId ?? accountId;
+          const workflowName = news.workflowName;
           yield* Effect.logInfo(
-            `Cloudflare Workflow reconcile: ${news.workflowName}`,
+            `Cloudflare Workflow reconcile: ${workflowName}`,
           );
           if (ctx.dev) {
             return {
               workflowId: output?.workflowId ?? `dev:${crypto.randomUUID()}`,
               accountId,
-              workflowName: news.workflowName,
+              workflowName,
               className: news.className,
               scriptName: news.scriptName,
             };
@@ -939,7 +973,7 @@ export const WorkflowProvider = () =>
           // — the API is naturally reconciler-shaped.
           const result = yield* workflows.putWorkflow({
             accountId: acct,
-            workflowName: news.workflowName,
+            workflowName,
             className: news.className,
             scriptName: news.scriptName,
           });

package/src/Cloudflare/Workflows/WorkflowBridge.ts

@@ -3,7 +3,6 @@ import * as Effect from "effect/Effect";
 import * as Exit from "effect/Exit";
 import * as Layer from "effect/Layer";
 import * as Scope from "effect/Scope";
-import { ExecutionContext } from "../../ExecutionContext.ts";
 import { isScopeEjected } from "../Workers/HttpServer.ts";
 import { getWorkerExport } from "../Workers/WorkerBridge.ts";
 import {
@@ -40,35 +39,34 @@ export const makeWorkflowBridge =
       stack: { name: string; stage: string };
     },
   ) =>
-  (className: string) =>
-    class WorkflowBridge extends WorkflowEntrypoint {
+  (className: string) => {
+    // One isolate-lifetime layer build shared by every instantiation of this
+    // workflow class — `build` memoizes the built context.
+    const { build } = getWorkerExport<WorkflowExport>({
+      entrypoint,
+      stack,
+      exportName: className,
+    });
+
+    return class WorkflowBridge extends WorkflowEntrypoint {
       readonly fn: Promise<WorkflowImpl<unknown, unknown>>;
 
       constructor(ctx: unknown, env: unknown) {
         super(ctx, env);
 
-        const { globalContext, exported } = getWorkerExport<WorkflowExport>({
-          entrypoint,
-          stack,
-          exportName: className,
-        });
-
-        this.fn = exported.pipe(
-          Effect.flatMap((wf) => wf.make(env)),
-          Effect.provide(globalContext),
-          Effect.runPromise,
+        this.fn = build(() => {}).then(({ context, export: wf }) =>
+          wf.make(env).pipe(Effect.provideContext(context), Effect.runPromise),
         ) as Promise<WorkflowImpl<unknown, unknown>>;
       }
 
       async run(event: any, step: any): Promise<unknown> {
         const fn = await this.fn;
-        // Each run-invocation gets a fresh ExecutionContext (scope + cache),
-        // following the same per-invocation-scope pattern as
-        // `WorkerBridge.processEvent`. `task` threads this into every step via
-        // the surrounding body context, so `@binding` helpers that need it
-        // (e.g. `Drizzle.postgres`) resolve their per-run resources inside
-        // workflow steps. The same scope is also provided as the ambient
-        // `Scope` service, matching the Worker and Durable Object bridges.
+        // Each run-invocation gets a fresh `Scope`, following the same
+        // per-invocation-scope pattern as `WorkerBridge.processEvent`. `task`
+        // threads it into every step via the surrounding body context, so
+        // `@binding` helpers that acquire per-run resources against the
+        // ambient scope (e.g. `Drizzle.postgres`) resolve them inside
+        // workflow steps, matching the Worker and Durable Object bridges.
         const scope = Scope.makeUnsafe();
         const exit = await Effect.runPromiseExit(
           fn(event.payload).pipe(
@@ -80,9 +78,6 @@ export const makeWorkflowBridge =
                 Layer.provideMerge(
                   Layer.succeed(WorkflowStep, wrapWorkflowStep(step)),
                 ),
-                Layer.provideMerge(
-                  Layer.succeed(ExecutionContext, { scope, cache: {} }),
-                ),
                 Layer.provideMerge(Layer.succeed(Scope.Scope, scope)),
               ),
             ),
@@ -108,6 +103,7 @@ export const makeWorkflowBridge =
         throw Cause.squash(exit.cause);
       }
     };
+  };
 
 const wrapWorkflowEvent = (event: any): WorkflowEventService["Service"] => ({
   payload: event.payload,

package/src/Cloudflare/Workflows/WorkflowName.ts

@@ -0,0 +1,41 @@
+import * as Effect from "effect/Effect";
+import type { Input } from "../../Input.ts";
+import * as Output from "../../Output.ts";
+import { sha256 } from "../../Util/sha256.ts";
+
+/**
+ * Derive an account-global Workflow name from its unique host Worker name and
+ * exported class. The hash preserves uniqueness when the readable prefix must
+ * be truncated to Cloudflare's 64-character limit.
+ *
+ * @internal
+ */
+export const makeWorkflowName = (
+  scriptName: Input<string>,
+  className: string,
+): Output.Output<string> => {
+  const resolvedScriptName = Effect.isEffect(scriptName)
+    ? scriptName.pipe(Effect.orDie)
+    : scriptName;
+  return Output.asOutput(
+    resolvedScriptName as
+      | string
+      | Output.Output<string>
+      | Effect.Effect<string>,
+  ).pipe(
+    Output.mapEffect((scriptName) => {
+      const base = `${scriptName}-${className}`
+        .toLowerCase()
+        .replaceAll(/[^a-z0-9-]/g, "-");
+      return sha256(base).pipe(
+        Effect.map((hash) => {
+          const suffix = `-${hash.slice(0, 8)}`;
+          // Trim trailing dashes left by mid-name truncation so the result
+          // never contains a `--` seam.
+          const head = base.slice(0, 64 - suffix.length).replace(/-+$/, "");
+          return `${head}${suffix}`;
+        }),
+      );
+    }),
+  );
+};

package/src/Cloudflare/Zone/Hold.ts

@@ -109,10 +109,13 @@ export const isHold = (value: unknown): value is Hold =>
 // Cloudflare can transiently fail to authenticate a valid token, surfacing as
 // `Forbidden`. Retry with exponential backoff capped at 5s, bounded to ~8
 // attempts so a persistently-unauthorized call still fails fast.
-const forbiddenRetrySchedule = Schedule.exponential("500 millis").pipe(
-  Schedule.either(Schedule.spaced("5 seconds")),
-  Schedule.both(Schedule.recurs(8)),
-);
+const forbiddenRetrySchedule = Schedule.max([
+  Schedule.min([
+    Schedule.exponential("500 millis"),
+    Schedule.spaced("5 seconds"),
+  ]),
+  Schedule.recurs(8),
+]);
 
 export const HoldProvider = () =>
   Provider.succeed(Hold, {

package/src/Command/Dev.ts

@@ -22,8 +22,10 @@ export interface Dev extends Resource<
   DevProps,
   {
     /**
-     * URL extracted from the first matching stdout/stderr line. Best-effort:
-     * `undefined` if no URL appears within 5 seconds.
+     * URL extracted from stdout/stderr. A `localhost`/IP URL (the dev
+     * server's own address) is preferred over any other URL the command
+     * prints; a non-local URL is only used as a fallback if no local one
+     * appears. Best-effort: `undefined` if no URL appears within 5 seconds.
      */
     url: string | undefined;
   }
@@ -37,10 +39,11 @@ export interface Dev extends Resource<
  * The child process runs inside the dev sidecar (see `Command/Local.ts`) so it
  * survives user-code HMR — Alchemy's user process can restart without killing
  * your `npm run dev` server. Its stdout/stderr are mirrored to the terminal
- * (preserving colored output) and each line is scanned for the first
- * `http(s)://…` URL, which is exposed as the `url` output attribute — useful
- * for surfacing a dev server's local URL back out to whatever resource
- * declared this `Dev`.
+ * (preserving colored output) and scanned for an `http(s)://…` URL, favoring
+ * a `localhost`/IP URL (the dev server's own address) over any unrelated URL
+ * the command prints first. The result is exposed as the `url` output
+ * attribute — useful for surfacing a dev server's local URL back out to
+ * whatever resource declared this `Dev`.
  *
  * @resource
  *
@@ -119,6 +122,11 @@ export const DevProviderLocal = () =>
         const child = yield* spawn(props);
 
         let buffer = "";
+        // A non-local URL seen so far (docs link, error page, update notice,
+        // …). Held as a fallback so that if the dev server never prints a
+        // localhost/IP URL we still surface something, but a localhost URL
+        // always wins if one shows up. See issue #695.
+        let fallbackUrl: string | undefined;
         const deferred = yield* Deferred.make<string>();
 
         const mirror = (sink: "stdout" | "stderr") =>
@@ -132,8 +140,13 @@ export const DevProviderLocal = () =>
                 if (Deferred.isDoneUnsafe(deferred)) return;
                 buffer += text;
                 const url = extractUrl(buffer);
-                if (url) {
+                if (!url) return;
+                if (isLocalUrl(url)) {
+                  // The dev server's own address — resolve immediately.
                   Deferred.doneUnsafe(deferred, Effect.succeed(url));
+                } else {
+                  // Keep scanning: a localhost/IP URL may still appear.
+                  fallbackUrl = url;
                 }
               }),
             ),
@@ -147,7 +160,9 @@ export const DevProviderLocal = () =>
           Deferred.await(deferred).pipe(
             Effect.timeoutOrElse({
               duration: "5 seconds",
-              orElse: () => Effect.undefined,
+              // No localhost/IP URL appeared in time — fall back to any other
+              // URL we saw (or `undefined` if the process stayed silent).
+              orElse: () => Effect.succeed(fallbackUrl),
             }),
           ),
           child.exitCode.pipe(
@@ -206,6 +221,13 @@ export const DevProviderLocal = () =>
     }),
   );
 
+// Matches an http(s) URL whose host is `localhost`, an IPv4 address, or a
+// bracketed IPv6 address — i.e. the shape a dev server prints for its own
+// local address. Preferred over any other URL a command might print first
+// (docs links, error pages, update notices). See issue #695.
+const LOCAL_URL_REGEX =
+  /https?:\/\/(?:localhost|\[[0-9a-fA-F:]+\]|(?:\d{1,3}\.){3}\d{1,3})(?::\d+)?[^\s)\],"'`]*/;
+
 // Matches the first plain http(s) URL. Stops at whitespace and at a small
 // set of punctuation typically used to wrap URLs in log output.
 const URL_REGEX = /https?:\/\/[^\s)\],"'`]+/;
@@ -215,5 +237,15 @@ const URL_REGEX = /https?:\/\/[^\s)\],"'`]+/;
 // eslint-disable-next-line no-control-regex
 const ANSI_REGEX = /\x1b\[[0-9;]*m/g;
 
-const extractUrl = (text: string) =>
-  text.replaceAll(ANSI_REGEX, "").match(URL_REGEX)?.[0];
+/**
+ * Extract a URL from `text`, favoring a localhost/IP URL (the dev server's
+ * own address) over any other URL. Returns the first localhost/IP URL if one
+ * is present, otherwise the first plain http(s) URL, otherwise `undefined`.
+ * @internal
+ */
+export const extractUrl = (text: string) => {
+  const clean = text.replaceAll(ANSI_REGEX, "");
+  return clean.match(LOCAL_URL_REGEX)?.[0] ?? clean.match(URL_REGEX)?.[0];
+};
+
+const isLocalUrl = (url: string) => LOCAL_URL_REGEX.test(url);

package/src/Docker/Container.ts

@@ -418,5 +418,8 @@ const normalizeDuration = (
 ): string | undefined => {
   if (!input) return undefined;
   const duration = Duration.fromInputUnsafe(input);
-  return Duration.toNanosUnsafe(duration).toString();
+  // Docker parses `--health-*` durations with Go's `time.ParseDuration`, which
+  // requires a unit suffix — a bare nanosecond count is rejected with "missing
+  // unit in duration". `ns` is the lossless Go-duration rendering of the nanos.
+  return `${Duration.toNanosUnsafe(duration).toString()}ns`;
 };

package/src/Drizzle/Postgres.ts

@@ -4,10 +4,21 @@ import type { EffectPgDatabase } from "drizzle-orm/effect-postgres";
 import * as PgDrizzle from "drizzle-orm/effect-postgres";
 import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
-import * as Redacted from "effect/Redacted";
-import { ExecutionContext } from "../ExecutionContext.ts";
+import type * as Redacted from "effect/Redacted";
+import type * as Scope from "effect/Scope";
 import { proxyChain } from "../Util/proxy-chain.ts";
 
+/**
+ * Per-execution pool memos, keyed on the execution's `Scope` object. Every
+ * bridge (Worker event, Durable Object call, Workflow run, Lambda invoke)
+ * provides a fresh `Scope` per execution, so an entry lives exactly as long
+ * as its execution and is garbage-collected with the scope object.
+ */
+const caches = new WeakMap<
+  Scope.Scope,
+  Map<symbol, Effect.Effect<any, any, any>>
+>();
+
 /**
  * Open a Drizzle/Postgres database from a connection URL using the
  * `drizzle-orm/effect-postgres` integration.
@@ -26,19 +37,20 @@ import { proxyChain } from "../Util/proxy-chain.ts";
  * ```
  *
  * The connect work is deferred until the first query and memoized on the
- * current `ExecutionContext` (`ctx.cache`), so the pool is built at most
- * once per execution — a Worker `fetch`/`queue`/`scheduled` event or a
- * Workflow run — and reused across every query and `task` step in that
- * execution. Yielding the connection string is likewise deferred, so
- * deploy / plan-time invocations (where `WorkerEnvironment` isn't
- * provided) never trigger a real connection attempt.
+ * current execution's `Scope` (`yield* Effect.scope`), so the pool is built
+ * at most once per execution — a Worker `fetch`/`queue`/`scheduled` event, a
+ * Durable Object call, a Workflow run, or a Lambda invocation — and reused
+ * across every query and `task` step in that execution. Yielding the
+ * connection string is likewise deferred, so deploy / plan-time invocations
+ * (where `WorkerEnvironment` isn't provided) never trigger a real connection
+ * attempt.
  *
- * The pool is built against the execution's `Scope` (`ctx.scope`), so its
- * `end` finalizer fires when that scope closes — when the request / run
- * settles, not when the `Cloudflare.Worker` init scope closes. Init runs
- * inside `Effect.scoped` and closes after returning the exports object;
- * building lazily against `ctx.scope` (rather than that init scope) is
- * what keeps later requests from seeing "Cannot use a pool after end".
+ * The pool is built against that same execution scope, so its `end`
+ * finalizer fires when the scope closes — when the request / run settles,
+ * not when the Worker's isolate-lifetime init completes. Wrapping queries in
+ * a nested `Effect.scoped` narrows both the memo and the pool's lifetime to
+ * that block: memo key and finalizer target are always the same scope
+ * object, so they cannot disagree.
  *
  * @binding
  */
@@ -60,16 +72,32 @@ export const postgres = <
       }
     >(
       Effect.gen(function* () {
-        const ctx = yield* ExecutionContext;
-        return yield* (ctx.cache[symbol] ??= yield* Effect.gen(function* () {
-          const pgCtx = yield* Layer.buildWithScope(
-            PgClient.layer({ url: yield* connectionString }),
-            ctx.scope,
-          );
-          return yield* PgDrizzle.makeWithDefaults(config).pipe(
-            Effect.provideContext(pgCtx),
+        const scope = yield* Effect.scope;
+        let cache = caches.get(scope);
+        if (cache === undefined) {
+          caches.set(scope, (cache = new Map()));
+        }
+        let memo = cache.get(symbol);
+        if (memo === undefined) {
+          // `Effect.cached` only allocates the memo cell — the build runs
+          // on first evaluation — so this yield is synchronous and the
+          // fiber cannot be interleaved between the miss check and the
+          // set: a concurrent first query joins this memo (evaluating the
+          // same cached effect) instead of building a second pool.
+          memo = yield* Effect.cached(
+            Effect.gen(function* () {
+              const pgCtx = yield* Layer.buildWithScope(
+                PgClient.layer({ url: yield* connectionString }),
+                scope,
+              );
+              return yield* PgDrizzle.makeWithDefaults(config).pipe(
+                Effect.provideContext(pgCtx),
+              );
+            }),
           );
-        }).pipe(Effect.cached));
+          cache.set(symbol, memo);
+        }
+        return yield* memo;
       }) as Effect.Effect<
         EffectPgDatabase<TRelations> & {
           $client: PgClient.PgClient;

package/src/GitHub/AuthProvider.ts

@@ -297,9 +297,6 @@ export const GitHubAuth = AuthProviderLayer<
             Console.log(`  source: ${sourceStr}`),
           ]);
         }),
-        Effect.catch((e) =>
-          Console.error(`  Failed to retrieve credentials: ${e}`),
-        ),
       );
 
     return {

package/src/GitHub/Env.ts

@@ -0,0 +1,57 @@
+import * as Array from "effect/Array";
+import * as Config from "effect/Config";
+import * as Effect from "effect/Effect";
+import { flow } from "effect/Function";
+import * as Option from "effect/Option";
+import * as String from "effect/String";
+
+export interface GitHubEnv {
+  /** The commit SHA that triggered the workflow run. */
+  readonly sha: string;
+  /** The repository owner from `GITHUB_REPOSITORY_OWNER`. */
+  readonly owner: string;
+  /** The repository name parsed from `GITHUB_REPOSITORY`. */
+  readonly repository: string;
+  /** The pull request number exported by the Alchemy GitHub Action. */
+  readonly pr: number | undefined;
+}
+
+/**
+ * GitHub Actions metadata for conditional resources in `alchemy.run.ts`.
+ *
+ * Resolves to `undefined` outside GitHub Actions. In GitHub Actions, it reads
+ * `GITHUB_SHA`, `GITHUB_REPOSITORY_OWNER`, `GITHUB_REPOSITORY`, and the optional
+ * `PULL_REQUEST` variable exported by the Alchemy GitHub Action.
+ */
+export const GitHubEnv: Config.Config<GitHubEnv | undefined> = Config.boolean(
+  "GITHUB_ACTIONS",
+).pipe(
+  Config.withDefault(false),
+  // Config has no flatMap in Effect 4; a Config is itself an Effect, so the
+  // enabled branch returns the inner config for mapOrFail to evaluate.
+  Config.mapOrFail(
+    (enabled): Effect.Effect<GitHubEnv | undefined, Config.ConfigError> =>
+      enabled
+        ? Config.all({
+            sha: Config.string("GITHUB_SHA"),
+            owner: Config.string("GITHUB_REPOSITORY_OWNER"),
+            repository: Config.string("GITHUB_REPOSITORY").pipe(
+              Config.mapOrFail(
+                flow(
+                  String.split("/"),
+                  Array.get(1),
+                  Effect.fromOption,
+                  Effect.catchTags({
+                    NoSuchElementError: Effect.die,
+                  }),
+                ),
+              ),
+            ),
+            pr: Config.number("PULL_REQUEST").pipe(
+              Config.option,
+              Config.map(Option.getOrUndefined),
+            ),
+          })
+        : Effect.succeed(undefined),
+  ),
+);

package/src/GitHub/index.ts

@@ -1,6 +1,7 @@
 export * as Auth from "./AuthProvider.ts";
 export * from "./Comment.ts";
 export { GitHubCredentials, fromEnv, fromToken } from "./Credentials.ts";
+export * from "./Env.ts";
 export * from "./Providers.ts";
 export * from "./Repository.ts";
 export * from "./RepositoryEventSource.ts";

package/src/Http.ts

@@ -16,6 +16,17 @@ export type HttpEffect<Req = never> = Effect.Effect<
   HttpServerRequest | Scope | Req
 >;
 
+/**
+ * `effect`'s HttpEffect brands a request scope as "ejected" when ownership
+ * is transferred to a consumer that outlives the handler's return — a
+ * streaming response body, a WebSocket upgrade, an RPC stream. Bridges check
+ * this before their close-on-return path: an ejected scope is closed by its
+ * new owner when it finishes, not by the bridge.
+ */
+const scopeEjected = Symbol.for("effect/http/HttpEffect/scopeEjected");
+
+export const isScopeEjected = (scope: Scope) => scopeEjected in scope;
+
 export const serve = <Req = never>(
   handler: Effect.Effect<
     HttpServerResponse.HttpServerResponse,

package/src/Local/RpcProviderProxy.ts

@@ -65,7 +65,7 @@ const make = Effect.fn(function* (spawnerUrl: string) {
 
   return RpcProviderProxy.of({
     get: Effect.fn(function* (mainUrl, providerName) {
-      const session = yield* cache.lookup(mainUrl);
+      const session = yield* Cache.get(cache, mainUrl);
       const provider = yield* Effect.promise(
         () =>
           session.getProvider(providerName) as ReturnType<

package/src/Neon/AuthProvider.ts

@@ -207,9 +207,6 @@ export const NeonAuth = AuthProviderLayer<
             Console.log(`  source: ${sourceStr}`),
           ]);
         }),
-        Effect.catch((e) =>
-          Console.error(`  Failed to retrieve credentials: ${e}`),
-        ),
       );
 
     return {

package/src/Neon/Project.ts

@@ -565,10 +565,10 @@ export const waitForOperations = (
               tag === "GatewayTimeout"
             );
           },
-          schedule: Schedule.both(
+          schedule: Schedule.max([
             Schedule.exponential(Duration.millis(500), 1.5),
             Schedule.recurs(60),
-          ),
+          ]),
         }),
         Effect.catchTag("OperationPending", () => Effect.void),
       );