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

package/lib/Test/Core.d.ts

@@ -1,277 +0,0 @@
-/** @effect-diagnostics anyUnknownInErrorContext:off */
-import * as Config from "effect/Config";
-import * as Effect from "effect/Effect";
-import * as HttpClient from "effect/http/HttpClient";
-import * as Layer from "effect/Layer";
-import * as Option from "effect/Option";
-import * as Scope from "effect/Scope";
-import { AlchemyContext } from "../AlchemyContext.ts";
-import { ArtifactStore } from "../Artifacts.ts";
-import type { Input } from "../Input.ts";
-import * as Interaction from "../Interaction.ts";
-import * as RpcProviderProxy from "../Local/RpcProviderProxy.ts";
-import * as RpcSpawner from "../Local/RpcSpawner.ts";
-import * as Plan from "../Plan.ts";
-import type { ResourceSelection, SelectionOutput } from "../ResourceSelection.ts";
-import { type CompiledStack, Stack, type StackEffect, type StackServices } from "../Stack.ts";
-import { Stage } from "../Stage.ts";
-import * as State from "../State/index.ts";
-/**
- * Configuration shared by every test in a file. Pass to `Test.make(...)`.
- */
-export interface MakeOptions<ROut = any> {
-    /** Provider layer for the stack — e.g. `AWS.providers()`, `Cloudflare.providers()`. */
-    providers: Layer.Layer<ROut, never, StackServices>;
-    /** State store for top-level `deploy(Stack)` / `destroy(Stack)`; defaults to {@link State.localState}. */
-    state?: Layer.Layer<State.State, never, StackServices>;
-    /** Override the current profile; otherwise resolved from env or the built-in `default`. */
-    profile?: string;
-    /**
-     * Default stage for deploy/destroy. Defaults to `test_$USER` (or
-     * `test_$USERNAME` on Windows, `test_unknown` if neither is set) so two
-     * people running the same suite against one account don't collide.
-     * Does **not** read `$ALCHEMY_STAGE` — that is the CLI deploy/dev stage.
-     */
-    stage?: string;
-    /**
-     * Engine-level adoption policy for this test run. When `true`, resources
-     * without prior state will be adopted from the cloud via `provider.read`
-     * (matching the CLI's `--adopt` flag). Defaults to `false`.
-     */
-    adopt?: boolean;
-    /**
-     * Run providers in local-dev mode (matching the CLI's `alchemy dev` flag).
-     * When `true`, resources like Cloudflare Workers run locally via workerd
-     * instead of being deployed to the cloud. When omitted, falls back to the
-     * `ALCHEMY_DEV` environment variable (`"1"` / `"true"` enable it).
-     *
-     * {@link ALCHEMY_TEST_DEV} (`ALCHEMY_TEST_DEV=1`) overrides this — use it
-     * to force an entire existing live suite through local providers without
-     * editing each `Test.make({ dev: true })`.
-     */
-    dev?: boolean;
-    /**
-     * Run local providers behind the RPC sidecar proxy, matching the process
-     * topology of the real `alchemy dev` command: an {@link RpcProviderProxy}
-     * is installed, so `RpcProvider.providerServicesEffect` layers (e.g.
-     * Cloudflare's `localRuntimeServices()`) are EMPTY in the test process and
-     * RPC-backed providers run their lifecycle in a spawned sidecar process.
-     *
-     * Defaults to the resolved `dev` flag — dev tests run the real `alchemy
-     * dev` topology unless they opt out. In-process dev (`sidecar: false`)
-     * masks missing main-process lifecycle dependencies (the class of bug
-     * behind #1007, where D1's local migrations only failed under `alchemy
-     * dev`); it remains available because it IS still a real production path —
-     * a plain `alchemy deploy` deleting a `providerMode: "local"` state row
-     * runs the local provider in-process — and because in-process runs are
-     * easier to debug.
-     *
-     * Fully lazy: only the proxy facade is installed up front. The spawner
-     * HTTP server starts — and a sidecar child process is forked — on the
-     * first provider session request (a deploy/destroy building an RPC-backed
-     * local provider); a dev file that never does starts no processes at all.
-     * Once started, the sidecar lives for the whole test file (its own scope,
-     * closed by the adapter's final cleanup hook), so `beforeAll(deploy(Stack))`
-     * + per-test requests work the same way they do under a real `alchemy dev`
-     * session.
-     *
-     * Pass an object to run the sidecar with options: `omitEnv` lists prefixes
-     * of environment variables the sidecar must not inherit (e.g.
-     * `["CLOUDFLARE_"]` to exercise credential-free dev while the shell
-     * exports credentials).
-     */
-    sidecar?: boolean | SidecarOptions;
-}
-/** Options for the dev sidecar process — see {@link MakeOptions.sidecar}. */
-export interface SidecarOptions {
-    /** Prefixes of environment variables withheld from the sidecar. */
-    readonly omitEnv?: ReadonlyArray<string>;
-}
-/**
- * The RPC sidecar topology used by the real `alchemy dev` command, in one
- * process-local layer: an {@link RpcSpawner} HTTP server that forks sidecar
- * processes on demand, and an {@link RpcProviderProxy} pointed at it.
- */
-export declare const sidecarProxy: (options: {
-    profile?: string;
-    omitEnv?: ReadonlyArray<string>;
-}) => Layer.Layer<RpcProviderProxy.RpcProviderProxy | RpcSpawner.RpcSpawner, import("effect/http/HttpServerError").ServeError, import("effect/process/ChildProcessSpawner").ChildProcessSpawner | HttpClient.HttpClient>;
-/**
- * Force every `Test.make` into (or out of) local-dev mode, regardless of
- * the file's `dev` option. Unset leaves the option / `ALCHEMY_DEV` fallback
- * in place. Accepts the usual truthy/falsey strings (`true`/`1`/`yes`/`on`,
- * `false`/`0`/`no`/`off`).
- */
-export declare const ALCHEMY_TEST_DEV: Config.Config<Option.Option<boolean>>;
-/** The `ALCHEMY_TEST_DEV` override, if the env var is set. */
-export declare const alchemyTestDevOverride: () => Option.Option<boolean>;
-/** Resolve the effective `dev` flag: `ALCHEMY_TEST_DEV`, then options, then `ALCHEMY_DEV`. */
-export declare const resolveDev: (options: {
-    dev?: boolean;
-}) => boolean;
-/** Resolve the effective `sidecar` flag: defaults to the resolved `dev` flag. */
-export declare const resolveSidecar: (options: MakeOptions) => boolean;
-/**
- * Default test stage: `ALCHEMY_TEST_STAGE`, then `test_$USER` (or
- * `test_$USERNAME` / `test_unknown`). Set an explicit test stage to isolate
- * concurrent worktrees that share a cloud account.
- * Matches the CLI's `live_$USER` / `dev_$USER` per-developer isolation.
- */
-export declare const defaultStage: () => string;
-/** File-level stage: a string override, otherwise {@link defaultStage}. */
-export declare const resolveStage: (options: {
-    stage?: string;
-}) => string;
-/**
- * The sidecar runtime handed to each adapter's `make(...)`.
- *
- * `provide` installs a lazy {@link RpcProviderProxy} facade into an effect.
- * Installing the facade is free: the spawner HTTP server only starts (and,
- * downstream of it, a sidecar child process is only forked) when a provider
- * actually requests a session — i.e. when a deploy/destroy builds an
- * RPC-backed local provider. A dev file that never does starts nothing.
- *
- * The spawner (and the sidecar children it forks) is a PROCESS-WIDE
- * SINGLETON shared by every test file, refcounted per handle: all files run
- * in one bun process, and a per-file sidecar means a per-file bun child that
- * imports the entire alchemy + distilled module graph — dozens of concurrent
- * files at hundreds of MB each OOMs the machine. Stack isolation is
- * preserved because each RPC session carries its own stack environment (see
- * `SESSION_ENV_PARAM` in Local/RpcServerEnvironment.ts) and the child builds
- * a provider context per stack. The singleton's scope closes when the LAST
- * handle closes; `Test.make` runs at collection time (before any test), so
- * the refcount cannot dip to zero while later files still need it. Adapters
- * run `close` from the same final cleanup hook that closes the shared scope.
- */
-export interface SidecarHandle {
-    readonly provide: <A, E, R>(eff: Effect.Effect<A, E, R>) => Effect.Effect<A, any, any>;
-    readonly close: Effect.Effect<void>;
-}
-/** Payload-free counts; observing them never starts the singleton. */
-export declare const sidecarDiagnostics: Effect.Effect<{
-    sessions: number;
-    testSessions: number;
-    owners: number;
-    connections: number;
-    singletons: number;
-    reservations: number;
-    started: number;
-}, never, never>;
-export declare const makeSidecarHandle: <ROut = any>(options: MakeOptions<ROut>) => SidecarHandle | undefined;
-export type TestEffect<A, Req = never> = StackEffect<A, any, Req>;
-/**
- * Build the per-test runtime and return a self-contained Effect.
- *
- * Mirrors {@link "../bin/alchemy.js"} composition: ConfigProvider via
- * `loadConfigProvider` + `withProfileOverride`, an empty `AuthProviders`
- * registry that the user's `providers` layer populates, the platform layers,
- * and the configured state store. Adapters wrap this into runner-specific
- * thunks (`bun.test` -> `runPromise`, `it.live` -> as-is).
- *
- * When `scope` is provided, scoped resources (like the Cloudflare dev
- * sidecar) survive past this effect and are tied to the lifetime of the
- * provided scope instead. The runner is responsible for closing it.
- *
- * When `scope` is omitted, the effect runs with `Effect.scoped` and any
- * scoped resources are torn down as soon as it resolves.
- */
-export declare const toEffect: <A, ROut = any>(effect: TestEffect<A>, options: MakeOptions<ROut>, scope?: Scope.Scope, sidecar?: SidecarHandle) => Effect.Effect<A, any, never>;
-/** Promise wrapper around {@link toEffect} for `bun.test`-style runners. */
-export declare const run: <A, ROut = any>(effect: TestEffect<A>, options: MakeOptions<ROut>, scope?: Scope.Scope, sidecar?: SidecarHandle) => Promise<A>;
-/**
- * Wrap an effect so it runs with `options.providers` + a placeholder Stack +
- * Stage in scope. Used by `test.provider` so user code can call provider SDK
- * APIs (e.g. `DynamoDB.describeTable`) directly inside the test body.
- */
-export declare const withProviders: <A, E, R, ROut>(effect: Effect.Effect<A, E, R>, options: MakeOptions<ROut>, stackName: string) => Effect.Effect<A, E, Exclude<R, ROut | Stack | Stage>>;
-/**
- * Curried `deploy` for the test factory: bakes in the configured stage and
- * adds the telemetry layer the CLI uses, so `beforeAll(deploy(Stack))` works
- * the same way as `alchemy deploy`.
- *
- * `scope`, when supplied, is forwarded down so the dev sidecar (and other
- * scoped resources) lives until the caller closes it instead of dying as
- * soon as `deploy` resolves. The test harness uses this to keep workerd
- * alive across `beforeAll` → tests → `afterAll`.
- */
-export interface DeployCallOptions extends Plan.MakePlanOptions {
-    stage?: string;
-    scope?: Scope.Scope;
-}
-export type DeployResult<A> = Effect.Effect<Input.Resolve<A>, Effect.Error<ReturnType<typeof deployStack<A>>>, Effect.Services<ReturnType<typeof deployStack<A>>>>;
-export interface FilteredDeployCallOptions extends Omit<DeployCallOptions, keyof ResourceSelection>, ResourceSelection {
-}
-type FullDeployCall = [options?: DeployCallOptions];
-/**
- * Filtered deploys return void; the whole declaration still evaluates.
- * With an explicit output type, filtering also requires the Call tuple type.
- */
-export interface Deploy {
-    <A, Call extends [options?: FilteredDeployCallOptions] = FullDeployCall>(stack: TestEffect<CompiledStack<A>, Stage | AlchemyContext>, ...call: Call): DeployResult<SelectionOutput<A, Call[0]>>;
-}
-export declare function deploy<A, Call extends [options?: FilteredDeployCallOptions] = FullDeployCall>(options: MakeOptions, stack: TestEffect<CompiledStack<A>, Stage | AlchemyContext>, ...call: Call): DeployResult<SelectionOutput<A, Call[0]>>;
-declare const deployStack: <A>(options: MakeOptions, stack: TestEffect<CompiledStack<A>, Stage | AlchemyContext>, callOptions?: FilteredDeployCallOptions) => Effect.Effect<Input.Resolve<A> | undefined, import("../Auth/AuthProvider.ts").AuthError | Config.ConfigError | import("../Auth/Demand.ts").CredentialsRequired | import("../Apply.ts").DestroyError | import("../Output.ts").InvalidReferenceError | import("../Output.ts").MissingSourceError | import("../Auth/AuthProvider.ts").NeedsReauth | import("effect/PlatformError").PlatformError | State.StateStoreError, AlchemyContext | ArtifactStore | import("effect/FileSystem").FileSystem | Interaction.Interaction | import("effect/Path").Path | State.State>;
-/** Bind test-file options and the shared runtime scope without erasing output types. */
-export declare const makeDeploy: (options: MakeOptions, scope: Scope.Scope) => Deploy;
-export declare const destroy: (options: MakeOptions, stack: TestEffect<CompiledStack, Stage | AlchemyContext>, callOptions?: {
-    stage?: string;
-    scope?: Scope.Scope;
-    include?: never;
-    exclude?: never;
-}) => Effect.Effect<undefined, import("../Auth/AuthProvider.ts").AuthError | Config.ConfigError | import("../Auth/Demand.ts").CredentialsRequired | import("../Apply.ts").DestroyError | import("../Output.ts").InvalidReferenceError | import("../Output.ts").MissingSourceError | import("../Auth/AuthProvider.ts").NeedsReauth | import("effect/PlatformError").PlatformError | State.StateStoreError, AlchemyContext | ArtifactStore | import("effect/FileSystem").FileSystem | Interaction.Interaction | import("effect/Path").Path | State.State>;
-/**
- * In-test scratch stack handed to `test.provider(name, (stack) => ...)`.
- *
- * Each scratch stack owns a private state store that is shared between
- * successive `deploy`/`destroy` calls AND visible to the user's test body
- * (so `yield* State` / `state.get(...)` see the same store the deploys
- * mutated). This makes create / update / replace / delete paths exercisable
- * without polluting other tests in the same file.
- *
- * When the adapter can name the test file (the alchemy-test runner), the
- * store is DURABLE — rows live under `.alchemy/state/{file}-{test}/{stage}`
- * on disk. Durability is what makes an interrupted destroy recoverable: the
- * engine persists a `deleting` row before every `provider.delete` and only
- * drops it on success, so a run killed mid-delete (e.g. the runner's
- * teardown-abandonment after a test timeout) leaves resumable rows that the
- * NEXT run's leading `stack.destroy()` (or the `Effect.ensuring` teardown)
- * picks up and drains. An in-memory scratch dies with the process, silently
- * orphaning every cloud resource whose delete was still in flight.
- */
-export interface ScratchStack<ROut = any> {
-    readonly name: string;
-    /** Stage this scratch deploys to ({@link resolveStage} of the file options). */
-    readonly stage: string;
-    /** The shared in-memory state Layer for this scratch. @internal */
-    readonly state: Layer.Layer<State.State, never, never>;
-    /** Filters leave other rows and stack outputs untouched; declaration still runs. */
-    deploy<A, E, R, Call extends [options?: Plan.FilteredPlanOptions] = []>(effect: Effect.Effect<A, E, R>, ...call: Call): Effect.Effect<SelectionOutput<Input.Resolve<A>, Call[0]>, any, Exclude<R, ROut | StackServices>>;
-    /**
-     * Build a plan against the scratch's shared state WITHOUT applying it.
-     *
-     * Use this to assert on the planned action for a resource (e.g. that a
-     * downstream dependency stays `noop` when only an upstream resource
-     * changes) without mutating the cloud. Plans run against whatever state
-     * prior `deploy(...)` calls persisted.
-     */
-    plan<A, E, R, Call extends [options?: Plan.FilteredPlanOptions] = []>(effect: Effect.Effect<A, E, R>, ...call: Call): Effect.Effect<Plan.Plan<SelectionOutput<A, Call[0]>>, any, Exclude<R, ROut | StackServices>>;
-    destroy(options?: {
-        include?: never;
-        exclude?: never;
-    }): Effect.Effect<void, any, never>;
-}
-/**
- * Build a fresh `ScratchStack` for `test.provider`.
- *
- * With `file` (the registration-time test file, supplied by the
- * alchemy-test adapter): the store is the durable `.alchemy/state` local
- * store and the stack name is namespaced by file so interrupted destroys
- * leave resumable rows for the next run (see {@link ScratchStack}).
- *
- * Without `file` (bun/vitest adapters, which cannot name their file at
- * registration time): falls back to a private in-memory store — isolated,
- * but discarded with the process.
- */
-export declare const scratchStack: <ROut>(options: MakeOptions<ROut>, name: string, file?: string) => ScratchStack<ROut>;
-export {};
-//# sourceMappingURL=Core.d.ts.map

package/lib/Test/Core.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Core.d.ts","sourceRoot":"","sources":["../../src/Test/Core.ts"],"names":[],"mappings":"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"}

package/lib/Test/Core.js

@@ -1,362 +0,0 @@
-/** @effect-diagnostics anyUnknownInErrorContext:off */
-import * as Config from "effect/Config";
-import { ConfigProvider } from "effect/ConfigProvider";
-import * as Context from "effect/Context";
-import * as Effect from "effect/Effect";
-import * as Exit from "effect/Exit";
-import * as FetchHttpClient from "effect/http/FetchHttpClient";
-import * as HttpClient from "effect/http/HttpClient";
-import * as Layer from "effect/Layer";
-import * as Option from "effect/Option";
-import * as Scope from "effect/Scope";
-import { AdoptPolicy } from "../AdoptPolicy.js";
-import { AlchemyContext, AlchemyContextLive } from "../AlchemyContext.js";
-import { apply } from "../Apply.js";
-import { ArtifactStore, provideFreshArtifactStore } from "../Artifacts.js";
-import { AuthProviders } from "../Auth/AuthProvider.js";
-import { CredentialsStoreLive } from "../Auth/Credentials.js";
-import { ProfileStoreLive } from "../Auth/Profile.js";
-import { withProfileOverride } from "../Auth/Resolve.js";
-import { userStage } from "../Cli/commands/flags.js";
-import { LoggingCli } from "../Cli/LoggingCli.js";
-import * as Contributions from "../Contributions.js";
-import { deploy as _deploy } from "../Deploy.js";
-import { destroy as _destroy } from "../Destroy.js";
-import * as Interaction from "../Interaction.js";
-import * as RpcProviderProxy from "../Local/RpcProviderProxy.js";
-import * as RpcSpawner from "../Local/RpcSpawner.js";
-import { ALCHEMY_DEV } from "../Phase.js";
-import * as Plan from "../Plan.js";
-import { make as makeStack, Stack, } from "../Stack.js";
-import { Stage } from "../Stage.js";
-import * as State from "../State/index.js";
-import { TelemetryLive } from "../Telemetry/Layer.js";
-import { loadConfigProvider, StackConfigOverrides } from "../Util/ConfigProvider.js";
-import { PlatformServices } from "../Util/PlatformServices.js";
-/**
- * The RPC sidecar topology used by the real `alchemy dev` command, in one
- * process-local layer: an {@link RpcSpawner} HTTP server that forks sidecar
- * processes on demand, and an {@link RpcProviderProxy} pointed at it.
- */
-export const sidecarProxy = (options) => Layer.unwrap(Effect.map(RpcSpawner.RpcSpawner, (spawner) => RpcProviderProxy.layer(spawner.url))).pipe(Layer.provideMerge(RpcSpawner.layerServer({
-    profile: options.profile ?? process.env.ALCHEMY_PROFILE,
-    envFile: undefined,
-    omitEnv: options.omitEnv,
-})));
-/**
- * Force every `Test.make` into (or out of) local-dev mode, regardless of
- * the file's `dev` option. Unset leaves the option / `ALCHEMY_DEV` fallback
- * in place. Accepts the usual truthy/falsey strings (`true`/`1`/`yes`/`on`,
- * `false`/`0`/`no`/`off`).
- */
-export const ALCHEMY_TEST_DEV = Config.Boolean("ALCHEMY_TEST_DEV").pipe(Config.option);
-/** The `ALCHEMY_TEST_DEV` override, if the env var is set. */
-export const alchemyTestDevOverride = () => Effect.runSync(ALCHEMY_TEST_DEV);
-/** Resolve the effective `dev` flag: `ALCHEMY_TEST_DEV`, then options, then `ALCHEMY_DEV`. */
-export const resolveDev = (options) => {
-    const override = alchemyTestDevOverride();
-    if (Option.isSome(override))
-        return override.value;
-    if (options.dev !== undefined)
-        return options.dev;
-    return Effect.runSync(ALCHEMY_DEV);
-};
-/** Resolve the effective `sidecar` flag: defaults to the resolved `dev` flag. */
-export const resolveSidecar = (options) => options.sidecar === undefined ? resolveDev(options) : options.sidecar !== false;
-/** The sidecar's withheld env prefixes, sorted so equal sets share a key. */
-const sidecarOmitEnv = (options) => typeof options.sidecar === "object" ? [...(options.sidecar.omitEnv ?? [])].sort() : [];
-/**
- * Default test stage: `ALCHEMY_TEST_STAGE`, then `test_$USER` (or
- * `test_$USERNAME` / `test_unknown`). Set an explicit test stage to isolate
- * concurrent worktrees that share a cloud account.
- * Matches the CLI's `live_$USER` / `dev_$USER` per-developer isolation.
- */
-export const defaultStage = () => process.env.ALCHEMY_TEST_STAGE || Effect.runSync(userStage("test"));
-/** File-level stage: a string override, otherwise {@link defaultStage}. */
-export const resolveStage = (options) => 
-// Configured stacks carry a cross-stack reference proxy, not a stage override.
-typeof options.stage === "string" ? options.stage : defaultStage();
-const sidecarSingletons = new Map();
-/** Payload-free counts; observing them never starts the singleton. */
-export const sidecarDiagnostics = Effect.gen(function* () {
-    const instances = [...sidecarSingletons.values()];
-    const counts = { sessions: 0, testSessions: 0, owners: 0, connections: 0 };
-    for (const instance of instances) {
-        if (instance.proxy === undefined)
-            continue;
-        const current = yield* instance.proxy.diagnostics;
-        counts.sessions += current.sessions;
-        counts.testSessions += current.testSessions;
-        counts.owners += current.owners;
-        counts.connections += current.connections;
-    }
-    return {
-        singletons: instances.length,
-        reservations: instances.reduce((sum, instance) => sum + instance.refs, 0),
-        started: instances.filter((instance) => instance.proxy !== undefined).length,
-        ...counts,
-    };
-});
-export const makeSidecarHandle = (options) => {
-    if (!resolveSidecar(options))
-        return undefined;
-    const profile = options.profile ?? process.env.ALCHEMY_PROFILE ?? "";
-    const omitEnv = sidecarOmitEnv(options);
-    // Files only share a sidecar when it was started with the same environment.
-    const key = JSON.stringify([profile, omitEnv]);
-    let singleton = sidecarSingletons.get(key);
-    if (singleton === undefined) {
-        singleton = {
-            real: sidecarProxy({ profile: options.profile, omitEnv }),
-            memoMap: Layer.makeMemoMapUnsafe(),
-            scope: Scope.makeUnsafe("sequential"),
-            refs: 0,
-        };
-        sidecarSingletons.set(key, singleton);
-    }
-    singleton.refs += 1;
-    let runtime = {
-        instance: singleton,
-        owner: RpcProviderProxy.makeSessionOwner(),
-        contexts: new Set(),
-    };
-    const lazy = Layer.effect(RpcProviderProxy.RpcProviderProxy, Effect.gen(function* () {
-        if (runtime === undefined) {
-            return yield* Effect.die("Test sidecar handle is closed");
-        }
-        // Never pin the singleton to a file's scope, artifacts, or layer builds.
-        const context = {
-            ambient: Context.omit(Scope.Scope, ArtifactStore, Layer.CurrentMemoMap)(yield* Effect.context()),
-        };
-        if (runtime === undefined) {
-            return yield* Effect.die("Test sidecar handle is closed");
-        }
-        runtime.contexts.add(context);
-        return RpcProviderProxy.RpcProviderProxy.of({
-            diagnostics: Effect.suspend(() => runtime?.instance.proxy?.diagnostics ??
-                Effect.succeed({
-                    sessions: 0,
-                    testSessions: 0,
-                    owners: 0,
-                    connections: 0,
-                })),
-            serverDiagnostics: Effect.suspend(() => runtime?.instance.proxy?.serverDiagnostics ?? Effect.succeed(undefined)),
-            get: Effect.fn(function* (providersUrl, providerName) {
-                if (runtime === undefined) {
-                    return yield* Effect.die("Test sidecar handle is closed");
-                }
-                const { instance, owner } = runtime;
-                let proxy = instance.proxy;
-                if (proxy === undefined) {
-                    const built = yield* Layer.buildWithMemoMap(instance.real, instance.memoMap, instance.scope).pipe(Effect.provideContext(context.ambient), Scope.provide(instance.scope), Effect.orDie);
-                    proxy = Context.get(built, RpcProviderProxy.RpcProviderProxy);
-                    instance.proxy = proxy;
-                }
-                context.ambient = undefined;
-                runtime?.contexts.delete(context);
-                // A handle may have closed while the singleton was building.
-                return yield* proxy.get(providersUrl, providerName, owner);
-            }),
-        });
-    }));
-    return {
-        provide: (eff) => Effect.provide(eff, lazy),
-        close: Effect.suspend(() => {
-            if (runtime === undefined)
-                return Effect.void;
-            const { instance, owner, contexts } = runtime;
-            runtime = undefined;
-            for (const context of contexts)
-                context.ambient = undefined;
-            contexts.clear();
-            return RpcProviderProxy.closeSessionOwner(owner).pipe(Effect.ensuring(Effect.suspend(() => {
-                instance.refs -= 1;
-                if (instance.refs > 0)
-                    return Effect.void;
-                if (sidecarSingletons.get(key) === instance)
-                    sidecarSingletons.delete(key);
-                instance.proxy = undefined;
-                return Scope.close(instance.scope, Exit.void);
-            })));
-        }).pipe(Effect.uninterruptible, Effect.ignore),
-    };
-};
-const overrideAlchemyContext = (overrides) => Layer.effect(AlchemyContext, AlchemyContext.pipe(Effect.map((ctx) => ({ ...ctx, ...overrides }))));
-const testDev = Option.getOrElse(alchemyTestDevOverride(), () => false);
-/**
- * Every provider's test services (e.g. AWS's Floci emulator), applied under
- * {@link ALCHEMY_TEST_DEV} only.
- */
-const testServices = testDev
-    ? await Effect.runPromise(Contributions.load().pipe(Effect.flatMap((providers) => Effect.forEach(providers, (provider) => provider.testServices
-        ? Contributions.resolve(provider, "testServices", provider.testServices)
-        : Effect.succeed(undefined))), Effect.map((services) => services.filter((service) => service !== undefined)), Effect.provide(PlatformServices)))
-    : [];
-if (testDev) {
-    // Emulators rewrite WebSocket invoke URLs onto their self-signed gateway;
-    // Bun/Node would otherwise reject the upgrade. Scoped to ALCHEMY_TEST_DEV
-    // only.
-    process.env.NODE_TLS_REJECT_UNAUTHORIZED = "0";
-    // Set here — before the RPC spawner or any vite child forks — so the whole
-    // dev process tree inherits it.
-    for (const services of testServices) {
-        for (const [key, value] of Object.entries(services.env ?? {}))
-            process.env[key] ??= value;
-    }
-}
-/** The test services' layers, closest wins over the stack's own. */
-const testServicesLayer = testServices.length === 0
-    ? undefined
-    : testServices
-        .map((services) => services.layer)
-        .reduce((merged, layer) => Layer.merge(merged, layer));
-const provideTestServices = (effect) => 
-// Test services override services already present in R.
-testServicesLayer === undefined
-    ? effect
-    : // oxlint-disable-next-line effecttsgo/unsafe-effect-type-assertion -- the layer overrides services already present in R
-        Effect.provide(effect, testServicesLayer);
-const testHttp = Layer.effect(HttpClient.HttpClient, Effect.map(HttpClient.HttpClient, (client) => testServices.reduce((mapped, services) => services.mapRequest ? HttpClient.mapRequest(mapped, services.mapRequest) : mapped, client))).pipe(Layer.provide(FetchHttpClient.layer));
-const platformLayer = () => Layer.mergeAll(PlatformServices, testDev ? testHttp : FetchHttpClient.layer, Layer.provide(ProfileStoreLive, PlatformServices), Layer.provide(CredentialsStoreLive, PlatformServices));
-const alchemyLayer = Layer.mergeAll(LoggingCli, Interaction.layerNonInteractive(), AlchemyContextLive);
-/**
- * Build the per-test runtime and return a self-contained Effect.
- *
- * Mirrors {@link "../bin/alchemy.js"} composition: ConfigProvider via
- * `loadConfigProvider` + `withProfileOverride`, an empty `AuthProviders`
- * registry that the user's `providers` layer populates, the platform layers,
- * and the configured state store. Adapters wrap this into runner-specific
- * thunks (`bun.test` -> `runPromise`, `it.live` -> as-is).
- *
- * When `scope` is provided, scoped resources (like the Cloudflare dev
- * sidecar) survive past this effect and are tied to the lifetime of the
- * provided scope instead. The runner is responsible for closing it.
- *
- * When `scope` is omitted, the effect runs with `Effect.scoped` and any
- * scoped resources are torn down as soon as it resolves.
- */
-export const toEffect = (effect, options, scope, sidecar) => {
-    const base = Effect.gen(function* () {
-        const cfg = yield* loadConfigProvider(Option.none());
-        const configProvider = withProfileOverride(cfg, options.profile);
-        // `ALCHEMY_TEST_DEV=1` forces local providers AND points the test
-        // process's distilled AWS clients at the emulator. Otherwise
-        // out-of-band `describeTable` / `getFunction` calls still hit the
-        // live account and fail with ResourceNotFound. Existing
-        // `Test.make({ dev: true })` files are unchanged (mixed
-        // `Alchemy.remote()` suites keep their live SDK).
-        const body = sidecar ? sidecar.provide(effect) : effect;
-        const locally = testDev ? provideTestServices(body) : body;
-        return yield* locally.pipe(provideFreshArtifactStore, Effect.provideService(ConfigProvider, configProvider), Effect.provideService(StackConfigOverrides, { profile: options.profile }));
-    }).pipe(Effect.provideService(AdoptPolicy, options.adopt ?? false), Effect.provide(overrideAlchemyContext({ dev: resolveDev(options) })), 
-    // `options.state` (e.g. `Cloudflare.state()`) itself requires
-    // `AuthProviders` to read credentials, so AuthProviders must be provided
-    // AFTER the state layer or the state layer's requirement is never
-    // satisfied — which surfaces as `Service not found: AuthProviders`.
-    Effect.provide(options.state ?? State.localState()), Effect.provideService(AuthProviders, {}), Effect.provide(Layer.provideMerge(alchemyLayer, platformLayer())));
-    return (scope === undefined ? Effect.scoped(base) : Scope.provide(base, scope));
-};
-/** Promise wrapper around {@link toEffect} for `bun.test`-style runners. */
-export const run = (effect, options, scope, sidecar) => Effect.runPromise(toEffect(effect, options, scope, sidecar));
-/**
- * Wrap an effect so it runs with `options.providers` + a placeholder Stack +
- * Stage in scope. Used by `test.provider` so user code can call provider SDK
- * APIs (e.g. `DynamoDB.describeTable`) directly inside the test body.
- */
-export const withProviders = (effect, options, stackName) => {
-    // Closest wins: when `ALCHEMY_TEST_DEV=1`, pin the test body's
-    // distilled AWS clients to the emulator BEFORE `options.providers`
-    // (which still carries the live `AWSEnvironment`).
-    const body = testDev ? provideTestServices(effect) : effect;
-    const stage = resolveStage(options);
-    // oxlint-disable-next-line effecttsgo/unsafe-effect-type-assertion -- providers layer is typed `any`; requirements are satisfied by it
-    return body.pipe(Effect.provide(options.providers.pipe(Layer.provideMerge(Layer.succeed(Stack, {
-        name: stackName,
-        stage,
-        resources: {},
-        bindings: {},
-        actions: {},
-    })), Layer.provideMerge(Layer.succeed(Stage, stage)))));
-};
-export function deploy(options, stack, callOptions) {
-    return deployStack(options, stack, callOptions);
-}
-const deployStack = (options, stack, callOptions) => _deploy({
-    stack: stack,
-    stage: callOptions?.stage ?? resolveStage(options),
-    dev: resolveDev(options),
-    scope: callOptions?.scope,
-    force: callOptions?.force,
-    include: callOptions?.include,
-    exclude: callOptions?.exclude,
-}).pipe(Effect.provide(TelemetryLive));
-/** Bind test-file options and the shared runtime scope without erasing output types. */
-export const makeDeploy = (options, scope) => {
-    function run(stack, callOptions) {
-        return deployStack(options, stack, { ...callOptions, scope });
-    }
-    return run;
-};
-export const destroy = (options, stack, callOptions) => _destroy({
-    include: callOptions?.include,
-    exclude: callOptions?.exclude,
-    stack: stack,
-    stage: callOptions?.stage ?? resolveStage(options),
-    dev: resolveDev(options),
-    scope: callOptions?.scope,
-}).pipe(Effect.provide(TelemetryLive));
-const sanitizeStackName = (name) => name.replaceAll(/[^a-zA-Z0-9_]/g, "-").replace(/-+/g, "-");
-/**
- * Turn a test-file path (relative to the run root) into a stack-name
- * namespace: `test/AWS/Website/Router.test.ts` -> `AWS/Website/Router`.
- * Test names repeat across files (e.g. "create and delete bucket with
- * default props"), so the durable per-test store MUST be namespaced by file
- * or two concurrently-running same-named tests would read, write and — far
- * worse — destroy each other's rows.
- */
-const scratchNamespace = (file) => file.replace(/^test[/\\]/, "").replace(/\.test\.ts$/, "");
-/**
- * Build a fresh `ScratchStack` for `test.provider`.
- *
- * With `file` (the registration-time test file, supplied by the
- * alchemy-test adapter): the store is the durable `.alchemy/state` local
- * store and the stack name is namespaced by file so interrupted destroys
- * leave resumable rows for the next run (see {@link ScratchStack}).
- *
- * Without `file` (bun/vitest adapters, which cannot name their file at
- * registration time): falls back to a private in-memory store — isolated,
- * but discarded with the process.
- */
-export const scratchStack = (options, name, file) => {
-    const stage = resolveStage(options);
-    const stackName = sanitizeStackName(file === undefined ? name : `${scratchNamespace(file)}-${name}`);
-    const stateLayer = file === undefined
-        ? Layer.succeed(State.State, State.InMemoryService({}))
-        : Layer.provide(State.localState(), PlatformServices);
-    // `withProviders` already pins the test body to the test services, but the
-    // stack program and its later plan/apply phase run under the providers'
-    // live services. Pin both phases separately: Actions execute during apply,
-    // after the stack program has finished. This override must be inside
-    // `compiled.services` so Effect's closest-layer precedence selects the test
-    // services for Action data-plane calls.
-    const pinToTestServices = (effect) => testDev ? provideTestServices(effect) : effect;
-    const buildAndApply = (effect, planOptions) => pinToTestServices(effect).pipe(makeStack({ name: stackName, providers: options.providers, state: stateLayer }), Effect.flatMap((compiled) => Plan.make(compiled, planOptions ?? {}).pipe(Effect.flatMap(apply), pinToTestServices, Effect.provide(compiled.services))), Effect.provideService(Stage, stage), provideFreshArtifactStore);
-    const buildPlan = (effect, planOptions) => pinToTestServices(effect).pipe(makeStack({ name: stackName, providers: options.providers, state: stateLayer }), Effect.flatMap((compiled) => pinToTestServices(Plan.make(compiled, planOptions ?? {})).pipe(Effect.provide(compiled.services))), Effect.provideService(Stage, stage), provideFreshArtifactStore);
-    return {
-        name: stackName,
-        stage,
-        state: stateLayer,
-        deploy: ((effect, planOptions) => buildAndApply(effect, planOptions)),
-        plan: ((effect, planOptions) => buildPlan(effect, planOptions)),
-        destroy: (callOptions) => callOptions?.include !== undefined || callOptions?.exclude !== undefined
-            ? Effect.die(new Plan.InvalidResourceSelection({ message: "Filtered destroy is not supported." }))
-            : Plan.destroy({ name: stackName, stage }).pipe(Effect.flatMap(apply), Effect.asVoid, Effect.provide(stateLayer.pipe(Layer.provideMerge(options.providers), Layer.provideMerge(Layer.succeed(Stack, {
-                name: stackName,
-                stage,
-                resources: {},
-                bindings: {},
-                actions: {},
-            })), Layer.provideMerge(Layer.succeed(Stage, stage)))), provideFreshArtifactStore),
-    };
-};
-//# sourceMappingURL=Core.js.map