alchemy 2.0.0-beta.84 → 2.0.0-beta.85

package/src/Local/DevLog.ts

@@ -1,122 +0,0 @@
-import { stripVTControlCharacters } from "node:util";
-/**
- * Per-resource dev log files.
- *
- * Layout under `{dotAlchemy}/log`:
- *
- *   log/{stage}/{fqn…}/{timestamp}.log        — one file per instance start
- *                                               (a restart opens a new file;
- *                                               the FQN nests as directories,
- *                                               e.g. log/dev/Site/Worker/)
- *   log/{stage}/{timestamp}.log               — the dev child's mixed tail
- *
- * Retention: opening a new log prunes its sibling `*.log` files first — the
- * newest `LOG_RETENTION_GENERATIONS` survive, and anything older than
- * `LOG_RETENTION_MS` (7 days, judged by stat mtime — file names are never
- * trusted) is deleted regardless. Pruning is best-effort: any failure is
- * swallowed so it can never break dev startup.
- */
-import * as Clock from "effect/Clock";
-import * as Duration from "effect/Duration";
-import * as Effect from "effect/Effect";
-import * as FileSystem from "effect/FileSystem";
-import * as Option from "effect/Option";
-import * as Path from "effect/Path";
-import * as Queue from "effect/Queue";
-import * as Stream from "effect/Stream";
-import { AlchemyContext } from "../AlchemyContext.ts";
-
-const LOG_RETENTION = Duration.days(7);
-const LOG_RETENTION_GENERATIONS = 10;
-
-/**
- * Delete a resource's stale sibling logs before a new one is opened: keep
- * the newest `LOG_RETENTION_GENERATIONS - 1` (the file about to be created
- * fills the last slot) and drop anything older than `LOG_RETENTION_MS`.
- * Ages come from stat mtime — file names are never trusted. Best-effort:
- * every step (including a missing directory) is swallowed.
- */
-const pruneDevLogs = (
-  fs: FileSystem.FileSystem,
-  path: Path.Path,
-  dir: string,
-): Effect.Effect<void> =>
-  Effect.gen(function* () {
-    const entries = yield* fs
-      .readDirectory(dir)
-      .pipe(Effect.orElseSucceed(() => [] as Array<string>));
-    const logs: Array<{ file: string; mtime: number }> = [];
-    for (const entry of entries) {
-      if (!entry.endsWith(".log")) continue;
-      const file = path.join(dir, entry);
-      const info = yield* fs.stat(file).pipe(Effect.orElseSucceed(() => undefined));
-      const mtime = info === undefined ? undefined : Option.getOrUndefined(info.mtime);
-      if (mtime !== undefined) logs.push({ file, mtime: mtime.getTime() });
-    }
-    const cutoff = (yield* Clock.currentTimeMillis) - Duration.toMillis(LOG_RETENTION);
-    logs.sort((a, b) => b.mtime - a.mtime);
-    for (const [index, log] of logs.entries()) {
-      if (index >= LOG_RETENTION_GENERATIONS - 1 || log.mtime < cutoff) {
-        yield* fs.remove(log.file).pipe(Effect.ignore);
-      }
-    }
-  }).pipe(Effect.ignore);
-
-/**
- * Resolves the directory a resource's dev logs land in, for surfacing in
- * startup messages ("Started … → url (logs: …)") without opening a file.
- * Must join the same segments the opener is later called with.
- */
-export const makeDevLogDirectory = Effect.gen(function* () {
-  const path = yield* Path.Path;
-  const { dotAlchemy } = yield* AlchemyContext;
-  return (...segments: ReadonlyArray<string>) => path.join(dotAlchemy, "log", ...segments);
-});
-
-/**
- * Resolves the file-system services once (at provider/process init) and
- * returns an opener whose only requirement is the ambient `Scope` — local
- * provider `start` signatures are Scope-only, so the opener composes into
- * them without widening their requirements.
- *
- * The opener creates `{dotAlchemy}/log/{...segments}/{timestamp}.log`
- * (pruning stale siblings per the module retention policy first) and
- * returns the file's `path` plus synchronous `write`/`writeLine` sinks —
- * chunks queue through a drain fiber, so they're safe to call from
- * non-Effect callbacks (workerd output pumps, stream mirrors). The file and
- * drain close with the scope, which ties one log file to one
- * process/serve generation.
- */
-export const makeDevLogOpener = Effect.gen(function* () {
-  const fs = yield* FileSystem.FileSystem;
-  const path = yield* Path.Path;
-  const devLogDirectory = yield* makeDevLogDirectory;
-  const encoder = new TextEncoder();
-
-  return Effect.fn(function* (...segments: ReadonlyArray<string>) {
-    const dir = devLogDirectory(...segments);
-    yield* fs.makeDirectory(dir, { recursive: true });
-    yield* pruneDevLogs(fs, path, dir);
-    const name = yield* Effect.sync(() => `${new Date().toISOString().replaceAll(":", "-")}.log`);
-    const filePath = path.join(dir, name);
-    const file = yield* fs.open(filePath, { flag: "a" });
-    const queue = yield* Queue.make<Uint8Array>();
-    yield* Stream.fromQueue(queue).pipe(
-      Stream.runForEach((chunk) => file.write(chunk).pipe(Effect.ignore)),
-      Effect.forkScoped,
-    );
-    // ANSI is stripped: colors belong to the terminal path (FORCE_COLOR
-    // rides the sidecar pipes); the files stay plain-text grep-able.
-    return {
-      /** Absolute path of this generation's log file. */
-      path: filePath,
-      write: (chunk: string): void => {
-        Queue.offerUnsafe(queue, encoder.encode(stripVTControlCharacters(chunk)));
-      },
-      /** `write` + a trailing newline — for line-based sources. */
-      writeLine: (line: string): void => {
-        Queue.offerUnsafe(queue, encoder.encode(`${stripVTControlCharacters(line)}\n`));
-      },
-    };
-  });
-});

package/src/Test/Alchemy.ts

@@ -1,334 +0,0 @@
-/** @effect-diagnostics anyUnknownInErrorContext:off */
-
-/**
- * Test adapter for the `alchemy-test` runner (see `packages/alchemy-test`).
- *
- * Same shape as {@link "./Vitest.ts"} / {@link "./Bun.ts"}, but registers
- * tests as raw Effects with the alchemy-test harness so the single-process
- * runner can inject a buffering Logger/Console per test and manage
- * concurrency + timeouts itself.
- */
-import {
-  currentFile,
-  exclusiveOf,
-  registerFileCleanup,
-  registerHook,
-  registerTest,
-  retryOf,
-  tagsOf,
-  optInTagsOf,
-  timeoutOf,
-  type TestOptions,
-} from "alchemy-test";
-import * as Effect from "effect/Effect";
-import * as Exit from "effect/Exit";
-import * as Scope from "effect/Scope";
-import * as Semaphore from "effect/Semaphore";
-import type { AlchemyContext } from "../AlchemyContext.ts";
-import type { CompiledStack } from "../Stack.ts";
-import type { Stage } from "../Stage.ts";
-import * as Core from "./Core.ts";
-
-export {
-  executeWhenReady,
-  getWhenReady,
-  guardContentType,
-  guardedFetchLayer,
-  rpcClientLayer,
-  WorkerNotReady,
-  type EdgeGuardOptions,
-  type WhenReadyOptions,
-} from "./Http.ts";
-
-export type MakeOptions<ROut = any> = Core.MakeOptions<ROut>;
-export type ScratchStack = Core.ScratchStack;
-export type TestEffect<A, R = never> = Core.TestEffect<A, R>;
-export const ALCHEMY_TEST_DEV = Core.ALCHEMY_TEST_DEV;
-export const resolveDev = Core.resolveDev;
-export const defaultStage = Core.defaultStage;
-export const resolveStage = Core.resolveStage;
-
-interface TestFn {
-  (name: string, eff: TestEffect<void>, options?: TestOptions): void;
-  skip: (name: string, eff: TestEffect<void>, options?: TestOptions) => void;
-  skipIf: (
-    condition: boolean,
-  ) => (name: string, eff: TestEffect<void>, options?: TestOptions) => void;
-  only: (name: string, eff: TestEffect<void>, options?: TestOptions) => void;
-  todo: (name: string, eff: TestEffect<void>, options?: TestOptions) => void;
-  provider: ProviderFn;
-}
-
-interface ProviderFn {
-  (
-    name: string,
-    fn: (stack: ScratchStack) => Effect.Effect<void, any, any>,
-    options?: TestOptions,
-  ): void;
-  skip: (
-    name: string,
-    fn: (stack: ScratchStack) => Effect.Effect<void, any, any>,
-    options?: TestOptions,
-  ) => void;
-  skipIf: (
-    condition: boolean,
-  ) => (
-    name: string,
-    fn: (stack: ScratchStack) => Effect.Effect<void, any, any>,
-    options?: TestOptions,
-  ) => void;
-  todo: (
-    name: string,
-    fn: (stack: ScratchStack) => Effect.Effect<void, any, any>,
-    options?: TestOptions,
-  ) => void;
-}
-
-interface BeforeAllFn {
-  <A>(eff: TestEffect<A>, options?: TestOptions): Effect.Effect<A>;
-}
-
-interface BeforeEachFn {
-  (eff: TestEffect<void>, options?: TestOptions): void;
-}
-
-interface AfterAllFn {
-  (eff: TestEffect<any>, options?: TestOptions): void;
-  skipIf: (predicate: boolean) => (eff: TestEffect<any>, options?: TestOptions) => void;
-}
-
-interface AfterEachFn {
-  (eff: TestEffect<void>, options?: TestOptions): void;
-}
-
-export interface TestApi {
-  test: TestFn;
-  beforeAll: BeforeAllFn;
-  beforeEach: BeforeEachFn;
-  afterAll: AfterAllFn;
-  afterEach: AfterEachFn;
-  deploy: Core.Deploy;
-  destroy: (
-    stack: TestEffect<CompiledStack, Stage | AlchemyContext>,
-    options?: { stage?: string; include?: never; exclude?: never },
-  ) => ReturnType<typeof Core.destroy>;
-}
-
-const DEFAULT_TIMEOUT = 120_000;
-
-/**
- * Build the per-file test API. Configure providers / state once at the top of
- * the test file:
- *
- * ```ts
- * import * as Test from "@/Test/Alchemy";
- * import * as Cloudflare from "@alchemy.run/cloudflare";
- *
- * const { test, deploy, destroy, beforeAll, afterAll } = Test.make({
- *   providers: Cloudflare.providers(),
- *   state: Cloudflare.state(),
- * });
- * ```
- */
-export const make = <ROut = any>(options: MakeOptions<ROut>): TestApi => {
-  // Single scope shared across `beforeAll`, every `test`, and `afterAll`.
-  // Scoped resources in dev mode (the Cloudflare dev proxy and its workerd
-  // children) must outlive a single test boundary, otherwise the proxy is
-  // killed the moment `beforeAll(deploy(Stack))` resolves and every later
-  // `HttpClient.get(workerUrl)` hits a dead port. The scope is closed by
-  // `destroy(...)` (or by file cleanup below).
-  let sharedScope: Scope.Closeable | undefined = Scope.makeUnsafe("sequential");
-  // Session ownership outlives a mid-file destroy, but not file cleanup.
-  let sidecar = Core.makeSidecarHandle(options);
-  const clearResults = new Set<() => void>();
-  const wrap = <A>(eff: TestEffect<A>) =>
-    sharedScope === undefined
-      ? Effect.die("Test runtime is closed")
-      : Core.toEffect(eff, options, sharedScope, sidecar);
-
-  const addTest = (
-    name: string,
-    eff: TestEffect<void>,
-    opts: TestOptions | undefined,
-    mode: "run" | "skip" | "only" | "todo",
-  ) =>
-    registerTest({
-      name,
-      mode,
-      exclusive: exclusiveOf(opts),
-      retry: retryOf(opts),
-      timeout: timeoutOf(opts),
-      tags: tagsOf(opts),
-      optInTags: optInTagsOf(opts),
-      body: mode === "skip" || mode === "todo" ? undefined : () => wrap(eff),
-    });
-
-  const test = ((name, eff, opts) => {
-    addTest(name, eff, opts, "run");
-  }) as TestFn;
-
-  test.skip = (name, eff, opts) => addTest(name, eff, opts, "skip");
-  test.skipIf = (condition) => (name, eff, opts) =>
-    addTest(name, eff, opts, condition ? "skip" : "run");
-  test.only = (name, eff, opts) => addTest(name, eff, opts, "only");
-  test.todo = (name, eff, opts) => addTest(name, eff, opts, "todo");
-
-  // One lock per scratch stack. When an attempt times out, the runner fires
-  // an interrupt and ABANDONS the attempt's fiber after a short grace — but
-  // the fiber keeps running its teardown (`scratch.destroy()` below) in the
-  // background, e.g. a CloudFront disable-wait. Without this lock the retry
-  // starts concurrently on the SAME scratch state: the stale teardown then
-  // deletes the state rows the retry just wrote for the same logical ids,
-  // orphaning the retry's cloud resources (observed: two leaked CloudFront
-  // distributions + buckets + OACs from one retried test). Holding the lock
-  // across body + teardown makes a retry wait (on its own timeout clock)
-  // until the previous attempt's teardown has fully settled.
-  const scratchLocks = new Map<string, Semaphore.Semaphore>();
-  const scratchLock = (name: string) => {
-    let lock = scratchLocks.get(name);
-    if (lock === undefined) {
-      lock = Semaphore.makeUnsafe(1);
-      scratchLocks.set(name, lock);
-    }
-    return lock;
-  };
-
-  const wrapProvider = (
-    name: string,
-    fn: (stack: ScratchStack) => Effect.Effect<void, any, any>,
-    file: string | undefined,
-  ) => {
-    if (sharedScope === undefined) return Effect.die("Test runtime is closed");
-    // Durable, file-namespaced scratch state (`.alchemy/state`). A run that
-    // dies mid-delete — e.g. the runner abandons teardown 10s after a test
-    // timeout while a CloudFront disable-wait is still in flight — leaves
-    // its `deleting` rows on disk, so the NEXT run's leading
-    // `stack.destroy()` (or the ensuring teardown below) resumes and drains
-    // them instead of planning "no changes" and silently orphaning the
-    // cloud resource.
-    const scratch = Core.scratchStack(options, name, file);
-    // Guarantee teardown. `test.provider` has no built-in cleanup, so a body
-    // that fails (assertion, API error like a 409/Unauthorized) or is
-    // interrupted (timeout) BEFORE its trailing `stack.destroy()` would
-    // otherwise leak every cloud resource it deployed.
-    // `scratch.destroy()` is idempotent — a no-op when the body already
-    // destroyed, and it reclaims the orphans otherwise. `Effect.ensuring`
-    // runs the finalizer on success, failure, AND interruption.
-    const body = Core.withProviders(fn(scratch), options, scratch.name).pipe(
-      Effect.ensuring(scratch.destroy().pipe(Effect.ignore)),
-      scratchLock(scratch.name).withPermits(1),
-    );
-    return Core.toEffect(body, { ...options, state: scratch.state }, sharedScope, sidecar);
-  };
-
-  const addProvider = (
-    name: string,
-    fn: (stack: ScratchStack) => Effect.Effect<void, any, any>,
-    opts: TestOptions | undefined,
-    mode: "run" | "skip" | "todo",
-  ) => {
-    // Captured at registration (module evaluation during collection) — the
-    // collection context is gone by the time the body runs.
-    const file = currentFile();
-    registerTest({
-      name,
-      mode,
-      exclusive: exclusiveOf(opts),
-      retry: retryOf(opts),
-      timeout: timeoutOf(opts),
-      tags: tagsOf(opts),
-      optInTags: optInTagsOf(opts),
-      body: mode === "run" ? () => wrapProvider(name, fn, file) : undefined,
-    });
-  };
-
-  const provider = ((name, fn, opts) => {
-    addProvider(name, fn, opts, "run");
-  }) as ProviderFn;
-  provider.skip = (name, fn, opts) => addProvider(name, fn, opts, "skip");
-  provider.skipIf = (condition) => (name, fn, opts) =>
-    addProvider(name, fn, opts, condition ? "skip" : "run");
-  provider.todo = (name, fn, opts) => addProvider(name, fn, opts, "todo");
-  test.provider = provider;
-
-  const beforeAll: BeforeAllFn = <A>(eff: TestEffect<A>, hookOptions?: TestOptions) => {
-    let result: A | undefined;
-    clearResults.add(() => {
-      result = undefined;
-    });
-    registerHook("beforeAll", {
-      body: () =>
-        wrap(eff).pipe(
-          Effect.map((value) => {
-            if (sharedScope !== undefined) result = value;
-          }),
-        ),
-      timeout: timeoutOf(hookOptions) ?? DEFAULT_TIMEOUT,
-      exclusive: exclusiveOf(hookOptions),
-    });
-    return Effect.sync(() => result as A);
-  };
-
-  const beforeEach: BeforeEachFn = (eff, hookOptions) => {
-    registerHook("beforeEach", { body: () => wrap(eff), timeout: timeoutOf(hookOptions) });
-  };
-
-  const afterAll = ((eff, hookOptions) => {
-    registerHook("afterAll", {
-      body: () => wrap(eff),
-      timeout: timeoutOf(hookOptions) ?? DEFAULT_TIMEOUT,
-      exclusive: exclusiveOf(hookOptions),
-    });
-  }) as AfterAllFn;
-  afterAll.skipIf = (predicate) => (eff, hookOptions) => {
-    if (predicate) return;
-    registerHook("afterAll", {
-      body: () => wrap(eff),
-      timeout: timeoutOf(hookOptions) ?? DEFAULT_TIMEOUT,
-      exclusive: exclusiveOf(hookOptions),
-    });
-  };
-
-  const afterEach: AfterEachFn = (eff, hookOptions) => {
-    registerHook("afterEach", { body: () => wrap(eff), timeout: timeoutOf(hookOptions) });
-  };
-
-  // `destroy(Stack)` needs the dev sidecar alive so it can call `sidecar.stop`
-  // for each worker. We close the shared scope only AFTER destroy completes.
-  // `Scope.close` on an already-closed scope is a no-op, so it's safe for both
-  // the destroy wrapper AND the fallback cleanup hook below to call it.
-  const closeScope = Effect.suspend(() =>
-    sharedScope === undefined ? Effect.void : Scope.close(sharedScope, Exit.void),
-  ).pipe(Effect.ignore);
-
-  // File cleanup runs after user afterAll, including skipped/failed imports.
-  // Interactive retries retain the runtime until the runner releases the file.
-  registerFileCleanup({
-    body: () =>
-      closeScope.pipe(
-        Effect.ensuring(Effect.suspend(() => sidecar?.close ?? Effect.void)),
-        Effect.ensuring(
-          Effect.sync(() => {
-            sharedScope = undefined;
-            sidecar = undefined;
-            for (const clear of clearResults) clear();
-            clearResults.clear();
-          }),
-        ),
-      ),
-    timeout: DEFAULT_TIMEOUT,
-  });
-
-  return {
-    test,
-    beforeAll,
-    beforeEach,
-    afterAll,
-    afterEach,
-    deploy: Core.makeDeploy(options, sharedScope),
-    destroy: (stack, callOpts) =>
-      Core.destroy(options, stack, { ...callOpts, scope: sharedScope }).pipe(
-        Effect.ensuring(closeScope),
-      ),
-  };
-};

package/src/Test/Bun.ts

@@ -1,230 +0,0 @@
-/** @effect-diagnostics anyUnknownInErrorContext:off */
-
-import bun from "bun:test";
-import type { HookOptions } from "node:test";
-import * as Effect from "effect/Effect";
-import * as Exit from "effect/Exit";
-import * as Scope from "effect/Scope";
-import type { AlchemyContext } from "../AlchemyContext.ts";
-import type { CompiledStack } from "../Stack.ts";
-import type { Stage } from "../Stage.ts";
-import * as Core from "./Core.ts";
-
-export {
-  executeWhenReady,
-  getWhenReady,
-  guardContentType,
-  guardedFetchLayer,
-  rpcClientLayer,
-  WorkerNotReady,
-  type EdgeGuardOptions,
-  type WhenReadyOptions,
-} from "./Http.ts";
-
-export type MakeOptions<ROut = any> = Core.MakeOptions<ROut>;
-export type ScratchStack = Core.ScratchStack;
-export type TestEffect<A, R = never> = Core.TestEffect<A, R>;
-export const defaultStage = Core.defaultStage;
-export const resolveStage = Core.resolveStage;
-
-export interface TestApi {
-  test: TestFn;
-  beforeAll: BeforeAllFn;
-  beforeEach: BeforeEachFn;
-  afterAll: AfterAllFn;
-  afterEach: AfterEachFn;
-  deploy: Core.Deploy;
-  destroy: (
-    stack: TestEffect<CompiledStack, Stage | AlchemyContext>,
-    options?: { stage?: string; include?: never; exclude?: never },
-  ) => ReturnType<typeof Core.destroy>;
-}
-
-interface TestFn {
-  (name: string, eff: TestEffect<void>, options?: bun.TestOptions): void;
-  skip: (name: string, eff: TestEffect<void>, options?: bun.TestOptions) => void;
-  skipIf: (
-    condition: boolean,
-  ) => (name: string, eff: TestEffect<void>, options?: bun.TestOptions) => void;
-  only: (name: string, eff: TestEffect<void>, options?: bun.TestOptions) => void;
-  todo: (name: string, eff: TestEffect<void>, options?: bun.TestOptions) => void;
-  provider: ProviderFn;
-}
-
-interface ProviderFn {
-  (
-    name: string,
-    fn: (stack: ScratchStack) => Effect.Effect<void, any, any>,
-    options?: bun.TestOptions,
-  ): void;
-  skip: (
-    name: string,
-    fn: (stack: ScratchStack) => Effect.Effect<void, any, any>,
-    options?: bun.TestOptions,
-  ) => void;
-  skipIf: (
-    condition: boolean,
-  ) => (
-    name: string,
-    fn: (stack: ScratchStack) => Effect.Effect<void, any, any>,
-    options?: bun.TestOptions,
-  ) => void;
-}
-
-interface BeforeAllFn {
-  <A>(eff: TestEffect<A>, options?: HookOptions): Effect.Effect<A>;
-}
-
-interface BeforeEachFn {
-  (eff: TestEffect<void>, options?: HookOptions): void;
-}
-
-interface AfterAllFn {
-  (eff: TestEffect<any>, options?: HookOptions): void;
-  skipIf: (predicate: boolean) => (eff: TestEffect<any>, options?: HookOptions) => void;
-}
-
-interface AfterEachFn {
-  (eff: TestEffect<void>, options?: HookOptions): void;
-}
-
-const DEFAULT_HOOK_TIMEOUT: HookOptions = { timeout: 120_000 };
-
-/**
- * Build the per-file test API. Configure providers / state once at the top of
- * the test file:
- *
- * ```ts
- * import * as Test from "alchemy/Test/Bun";
- * import * as Cloudflare from "@alchemy.run/cloudflare";
- *
- * const { test, deploy, destroy, beforeAll, afterAll } = Test.make({
- *   providers: Cloudflare.providers(),
- *   state: Cloudflare.state(),
- * });
- * ```
- */
-export const make = <ROut = any>(options: MakeOptions<ROut>): TestApi => {
-  // Single scope shared across `beforeAll`, every `test`, and `afterAll`.
-  // Scoped resources in dev mode (the Cloudflare sidecar process and its
-  // workerd children) must outlive a single `Effect.runPromise` boundary,
-  // otherwise the proxy is killed the moment `beforeAll(deploy(Stack))`
-  // resolves and every later `HttpClient.get(workerUrl)` hits a dead port.
-  // The scope is closed by `destroy(...)` (or never — the next test run
-  // reclaims any leaked sidecar via the lock file).
-  const sharedScope = Scope.makeUnsafe("sequential");
-  // In dev mode, run local providers behind one file-scoped RPC sidecar
-  // (the `alchemy dev` topology). Lives in its own scope — NOT sharedScope,
-  // which `destroy(Stack)` closes mid-file in self-contained tests — and is
-  // closed by the fallback afterAll below.
-  const sidecar = Core.makeSidecarHandle(options);
-  const runEff = <A>(eff: TestEffect<A>) => Core.run(eff, options, sharedScope, sidecar);
-
-  const test = ((name, eff, opts) => {
-    bun.test(name, () => runEff(eff), opts);
-  }) as TestFn;
-
-  test.skip = (name, eff, opts) => {
-    bun.test.skip(name, () => runEff(eff), opts);
-  };
-  test.skipIf = (condition) => (name, eff, opts) => {
-    bun.test.skipIf(condition)(name, () => runEff(eff), opts);
-  };
-  test.only = (name, eff, opts) => {
-    bun.test.only(name, () => runEff(eff), opts);
-  };
-  test.todo = (name, eff, opts) => {
-    bun.test.todo(name, () => runEff(eff), opts);
-  };
-
-  const runProvider = (
-    name: string,
-    fn: (stack: ScratchStack) => Effect.Effect<void, any, any>,
-  ) => {
-    const scratch = Core.scratchStack(options, name);
-    return Core.run(
-      Core.withProviders(fn(scratch), options, scratch.name),
-      { ...options, state: scratch.state },
-      sharedScope,
-      sidecar,
-    );
-  };
-
-  const provider = ((name, fn, opts) => {
-    bun.test(name, () => runProvider(name, fn), opts);
-  }) as ProviderFn;
-  provider.skip = (name, fn, opts) => {
-    bun.test.skip(name, () => runProvider(name, fn), opts);
-  };
-  provider.skipIf = (condition) => (name, fn, opts) => {
-    bun.test.skipIf(condition)(name, () => runProvider(name, fn), opts);
-  };
-  test.provider = provider;
-
-  const beforeAll: BeforeAllFn = <A>(eff: TestEffect<A>, hookOptions?: HookOptions) => {
-    let result: A;
-    bun.beforeAll(() => runEff(eff).then((v) => (result = v)), hookOptions ?? DEFAULT_HOOK_TIMEOUT);
-    return Effect.sync(() => result);
-  };
-
-  const beforeEach: BeforeEachFn = (eff, hookOptions) => {
-    bun.beforeEach(() => runEff(eff), hookOptions);
-  };
-
-  // bun:test stops running later `afterAll` hooks once one throws, which
-  // would skip the fallback cleanup hook below — leaking the shared scope
-  // and the sidecar for the rest of the process whenever a teardown
-  // assertion fails. Guard every user teardown: on failure, run the
-  // (idempotent) cleanup before rethrowing so the failure still fails the
-  // suite. (`closeAll` is initialized below; hooks only run after `make`
-  // returns.)
-  const guardTeardown = (eff: TestEffect<any>) => () =>
-    runEff(eff).catch(async (error) => {
-      await Effect.runPromise(closeAll);
-      throw error;
-    });
-
-  const afterAll = ((eff, hookOptions) => {
-    bun.afterAll(guardTeardown(eff), hookOptions ?? DEFAULT_HOOK_TIMEOUT);
-  }) as AfterAllFn;
-  afterAll.skipIf = (predicate) => (eff, hookOptions) => {
-    if (predicate) return;
-    bun.afterAll(guardTeardown(eff), hookOptions ?? DEFAULT_HOOK_TIMEOUT);
-  };
-
-  const afterEach: AfterEachFn = (eff, hookOptions) => {
-    bun.afterEach(() => runEff(eff), hookOptions);
-  };
-
-  // `destroy(Stack)` needs the dev sidecar alive so it can call `sidecar.stop`
-  // for each worker. We close the shared scope only AFTER destroy completes.
-  // `Scope.close` on an already-closed scope is a no-op, so it's safe for both
-  // the destroy wrapper AND the fallback cleanup hook below to call it.
-  const closeScope = Effect.suspend(() => Scope.close(sharedScope, Exit.void)).pipe(Effect.ignore);
-
-  // Fallback cleanup: if the user never calls `destroy(Stack)` (e.g.
-  // `NO_DESTROY=1`), nothing else closes the shared scope and the sidecar
-  // child process leaks past the test process. Register an `afterAll` that
-  // closes it (and the RPC sidecar, which lives in its own scope so that
-  // mid-file `destroy(Stack)` calls can't kill it for later tests). We defer
-  // registration to a microtask so it runs AFTER any user-registered
-  // `afterAll` (including `destroy(Stack)`); bun runs afterAll hooks in
-  // registration order.
-  const closeAll = sidecar ? Effect.andThen(closeScope, sidecar.close) : closeScope;
-  queueMicrotask(() => {
-    bun.afterAll(() => Effect.runPromise(closeAll), DEFAULT_HOOK_TIMEOUT);
-  });
-
-  return {
-    test,
-    beforeAll,
-    beforeEach,
-    afterAll,
-    afterEach,
-    deploy: Core.makeDeploy(options, sharedScope),
-    destroy: (stack, callOpts) =>
-      Core.destroy(options, stack, { ...callOpts, scope: sharedScope }).pipe(
-        Effect.ensuring(closeScope),
-      ),
-  };
-};