alchemy 2.0.0-beta.74 → 2.0.0-beta.76

package/src/Runtime/Bootstrap/MicrovmBun.ts

@@ -0,0 +1,14 @@
+/** `AWS.Lambda.MicrovmImage` bootstrap on the bun runtime. */
+import { BunServices } from "@effect/platform-bun";
+import { BunHttpServer } from "../../Http.ts";
+import { bootstrapMicrovm, type MicrovmBootstrapOptions } from "./Microvm.ts";
+
+export const bootstrap = (
+  entrypoint: unknown,
+  options: MicrovmBootstrapOptions,
+): Promise<void> =>
+  bootstrapMicrovm(
+    { services: BunServices.layer, httpServer: BunHttpServer() },
+    entrypoint,
+    options,
+  );

package/src/Runtime/Bootstrap/MicrovmNode.ts

@@ -0,0 +1,14 @@
+/** `AWS.Lambda.MicrovmImage` bootstrap on the node runtime. */
+import { NodeServices } from "@effect/platform-node";
+import { NodeHttpServer } from "../../Http.ts";
+import { bootstrapMicrovm, type MicrovmBootstrapOptions } from "./Microvm.ts";
+
+export const bootstrap = (
+  entrypoint: unknown,
+  options: MicrovmBootstrapOptions,
+): Promise<void> =>
+  bootstrapMicrovm(
+    { services: NodeServices.layer, httpServer: NodeHttpServer() },
+    entrypoint,
+    options,
+  );

package/src/Runtime/Bootstrap/Prisma.ts

@@ -0,0 +1,71 @@
+/**
+ * Process bootstrap for `Prisma.Compute` apps. The generated entry imports
+ * this module and the user's `main`, nothing else — see
+ * {@link ./Process.ts} for why.
+ */
+import { BunServices } from "@effect/platform-bun";
+import * as ConfigProvider from "effect/ConfigProvider";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Logger from "effect/Logger";
+import { MinimumLogLevel } from "effect/References";
+import * as FetchHttpClient from "effect/unstable/http/FetchHttpClient";
+import { BunHttpServer } from "../../Http.ts";
+import { Stage } from "../../Stage.ts";
+import {
+  entrypointLayer,
+  resolveProgram,
+  runProcess,
+  stackConstant,
+} from "./Process.ts";
+
+export interface PrismaBootstrapOptions {
+  /** Port to serve on when the platform does not inject `PORT`. */
+  readonly port: number;
+  /** Stack identity baked in at deploy time. */
+  readonly stack: { readonly name: string; readonly stage: string };
+}
+
+/** Serve the bundled app with a Bun HTTP server on `PORT` (all interfaces). */
+export const bootstrap = (
+  entrypoint: unknown,
+  options: PrismaBootstrapOptions,
+): Promise<void> => {
+  process.env.PORT ??= String(options.port);
+
+  const platform = Layer.mergeAll(
+    BunServices.layer,
+    FetchHttpClient.layer,
+    Logger.layer([Logger.consolePretty()]),
+  );
+
+  const stack = Layer.mergeAll(
+    stackConstant(options.stack.name, options.stack.stage),
+    Layer.succeed(Stage, options.stack.stage),
+  );
+
+  const program = resolveProgram("default").pipe(
+    Effect.provide(
+      entrypointLayer(entrypoint).pipe(
+        Layer.provideMerge(stack),
+        Layer.provideMerge(BunHttpServer({ hostname: "0.0.0.0" })),
+        Layer.provideMerge(platform),
+        Layer.provideMerge(
+          Layer.succeed(
+            ConfigProvider.ConfigProvider,
+            ConfigProvider.orElse(
+              ConfigProvider.fromUnknown({ ALCHEMY_PHASE: "runtime" }),
+              ConfigProvider.fromEnv(),
+            ),
+          ),
+        ),
+        Layer.provideMerge(
+          Layer.succeed(MinimumLogLevel, process.env.DEBUG ? "Debug" : "Info"),
+        ),
+      ),
+    ),
+    Effect.scoped,
+  );
+
+  return runProcess("Prisma Compute", program);
+};

package/src/Runtime/Bootstrap/Process.ts

@@ -0,0 +1,131 @@
+/**
+ * Shared core of the generated process bootstraps (ECS, App Runner, Batch,
+ * EC2, Cloudflare Containers, MicroVM, Docker, Fly, Hetzner, Prisma).
+ *
+ * Each bundler used to emit its bootstrap as an inline TypeScript string —
+ * a virtual module with no location on disk, whose imports mixed alchemy's
+ * own dependencies (`@distilled.cloud/*`, `@effect/platform-*`) with the
+ * consumer's (`alchemy`, `effect`). No directory can resolve both under an
+ * isolated install (bun `--linker=isolated`, pnpm), so the imports were
+ * left external and the process died at boot with `Cannot find module`.
+ *
+ * Now the generated entry is a three-line shim that imports ONLY
+ * `alchemy/Runtime/Bootstrap/<Platform>` (resolvable from any consumer —
+ * `alchemy` is its direct dependency) plus the user's `main`. Everything
+ * alchemy needs lives in these real modules, whose imports resolve by the
+ * ordinary rule: from the file that wrote them.
+ *
+ * The helpers here are the pieces every platform module composes; the
+ * layer ORDER (which service is provided to which) is platform-specific and
+ * stays in each module.
+ */
+import * as Config from "effect/Config";
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import { makeEntrypointLayer } from "../../Runtime.ts";
+import { Self } from "../../Self.ts";
+import { Stack } from "../../Stack.ts";
+import { provideProcessTelemetry } from "../../Telemetry.ts";
+
+/**
+ * The tag every bundled platform program registers itself under
+ * (`Self`'s key). Typed loosely on purpose: the shape is the platform
+ * instance, which differs per platform and is only ever read dynamically.
+ */
+export const entrypointTag = Context.Service<any, any>(Self.key);
+
+/**
+ * Normalize the entrypoint export into the layer providing
+ * {@link entrypointTag}: an inline-effect class default export is an Effect
+ * resolving the platform instance, while the tagged form
+ * (`X.make(props, impl)`) exports a Layer providing the `Self` tag.
+ */
+export const entrypointLayer = (entrypoint: unknown): Layer.Layer<any> =>
+  makeEntrypointLayer(entrypointTag, entrypoint);
+
+/** `Stack` from the `ALCHEMY_STACK_NAME` / `ALCHEMY_STAGE` the host injects. */
+export const stackFromEnv: Layer.Layer<Stack, Config.ConfigError> =
+  Layer.effect(
+    Stack,
+    Effect.all([
+      Config.string("ALCHEMY_STACK_NAME"),
+      Config.string("ALCHEMY_STAGE"),
+    ]).pipe(
+      Effect.map(([name, stage]) => ({
+        name,
+        stage,
+        bindings: {},
+        resources: {},
+        actions: {},
+      })),
+    ),
+  );
+
+/** `Stack` from constants baked in at deploy time. */
+export const stackConstant = (
+  name: string,
+  stage: string,
+): Layer.Layer<Stack> =>
+  Layer.succeed(Stack, {
+    name,
+    stage,
+    bindings: {},
+    resources: {},
+    actions: {},
+  });
+
+/**
+ * Resolve the program the bundled platform registered under `exportKey`
+ * (`program` for the server/one-shot hosts, `default` for containers,
+ * `handler` for Lambda), optionally under process-lifetime telemetry: built
+ * once into the root scope; exporters batch on their intervals and flush
+ * when the scope closes on graceful shutdown.
+ */
+export const resolveProgram = (
+  exportKey: string,
+  options?: { readonly telemetry?: boolean },
+): Effect.Effect<any, any, any> =>
+  entrypointTag.pipe(
+    Effect.flatMap((self) => {
+      const program: Effect.Effect<any, any, any> =
+        self.RuntimeContext.exports.pipe(
+          Effect.flatMap((exports: any) => exports[exportKey]),
+        );
+      return options?.telemetry
+        ? program.pipe(provideProcessTelemetry(self.RuntimeContext))
+        : program;
+    }),
+  );
+
+/**
+ * Run `program` as the process entry: log the start, exit 1 on failure.
+ * With `exitOnComplete`, exit 0 explicitly once it completes (one-shot jobs
+ * whose host waits on the process, e.g. Batch).
+ */
+export const runProcess = (
+  label: string,
+  program: Effect.Effect<unknown, unknown>,
+  options?: { readonly exitOnComplete?: boolean },
+): Promise<void> => {
+  console.log(`${label} bootstrap starting...`);
+  // Node 26 exits 13 (unsettled TLA) when the event loop is empty while
+  // `await bootstrap(...)` is still pending. `host.run(Effect.never)` has
+  // no native handle; an HTTP `listen` does. Hold a timer so run-only
+  // Services stay up the same way Bun does.
+  const keepAlive = setInterval(() => undefined, 1 << 30);
+  return Effect.runPromise(program).then(
+    () => {
+      clearInterval(keepAlive);
+      if (options?.exitOnComplete) {
+        console.log(`${label} completed.`);
+        process.exit(0);
+      }
+    },
+    (err) => {
+      clearInterval(keepAlive);
+      console.error(`${label} bootstrap failed:`, err);
+      process.exit(1);
+    },
+  );
+};

package/src/Runtime/Bootstrap/Railway.ts

@@ -0,0 +1,55 @@
+/**
+ * Process bootstrap for `Railway.Service` (a Node process serving the
+ * bundled program). The generated entry imports this module and the user's
+ * `main`, nothing else — see {@link ./Process.ts} for why.
+ *
+ * Railway canvas Functions stay on bun (`functionRuntime(bun)` + the
+ * inline canvas wrapper). This module is the Docker/Service path only.
+ */
+import { NodeServices } from "@effect/platform-node";
+import * as ConfigProvider from "effect/ConfigProvider";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Logger from "effect/Logger";
+import * as FetchHttpClient from "effect/unstable/http/FetchHttpClient";
+import { NodeHttpServer } from "../../Http.ts";
+import { reifyBoundConfigProvider } from "../../Runtime.ts";
+import {
+  entrypointLayer,
+  resolveProgram,
+  runProcess,
+  stackFromEnv,
+} from "./Process.ts";
+
+/**
+ * Resolve the bundled program (the runners registered via `host.run` /
+ * serve) and run it with a Node HTTP server bound to `PORT`, so the
+ * returned `{ fetch }` handler is actually served and `host.run` loops
+ * stay alive.
+ */
+export const bootstrap = (entrypoint: unknown): Promise<void> => {
+  const platform = Layer.mergeAll(
+    NodeServices.layer,
+    FetchHttpClient.layer,
+    Logger.layer([Logger.consolePretty()]),
+  );
+
+  const program = resolveProgram("program").pipe(
+    Effect.provide(
+      entrypointLayer(entrypoint).pipe(
+        Layer.provideMerge(stackFromEnv),
+        Layer.provideMerge(NodeHttpServer({ hostname: "0.0.0.0" })),
+        Layer.provideMerge(platform),
+        Layer.provideMerge(
+          Layer.succeed(
+            ConfigProvider.ConfigProvider,
+            reifyBoundConfigProvider(ConfigProvider.fromEnv(), process.env),
+          ),
+        ),
+      ),
+    ),
+    Effect.scoped,
+  );
+
+  return runProcess("Railway service", program);
+};

package/src/Telemetry/Metrics.ts

@@ -144,10 +144,16 @@ export const recordStateStoreOp =
 export const recordStateStoreInit = <A extends { readonly id: string }, E, R>(
   self: Effect.Effect<A, E, R>,
 ): Effect.Effect<A, E, R> =>
-  self.pipe(
+  // The debug lines bracket the first phase of a deploy that can block on
+  // credential resolution (see `Auth/Lock.ts`). Without them a stalled
+  // deploy produces no output at all, at any log level, and there is
+  // nothing to tell "hung" apart from "slow".
+  Effect.logDebug("state store: initializing").pipe(
+    Effect.andThen(self),
     Effect.tap((service) =>
       Effect.all(
         [
+          Effect.logDebug(`state store: ready (${service.id})`),
           Metric.update(
             Metric.withAttributes(stateStoreInitCounter, { id: service.id }),
             1,

package/src/Test/Alchemy.ts

@@ -237,6 +237,7 @@ export const make = <ROut = any>(options: MakeOptions<ROut>): TestApi => {
           }),
         ),
       timeout: timeoutOf(hookOptions) ?? DEFAULT_TIMEOUT,
+      exclusive: exclusiveOf(hookOptions),
     });
     return Effect.sync(() => result);
   };
@@ -252,6 +253,7 @@ export const make = <ROut = any>(options: MakeOptions<ROut>): TestApi => {
     registerHook("afterAll", {
       body: () => wrap(eff),
       timeout: timeoutOf(hookOptions) ?? DEFAULT_TIMEOUT,
+      exclusive: exclusiveOf(hookOptions),
     });
   }) as AfterAllFn;
   afterAll.skipIf = (predicate) => (eff, hookOptions) => {
@@ -259,6 +261,7 @@ export const make = <ROut = any>(options: MakeOptions<ROut>): TestApi => {
     registerHook("afterAll", {
       body: () => wrap(eff),
       timeout: timeoutOf(hookOptions) ?? DEFAULT_TIMEOUT,
+      exclusive: exclusiveOf(hookOptions),
     });
   };
 

package/src/Test/Bun.ts

@@ -194,12 +194,25 @@ export const make = <ROut = any>(options: MakeOptions<ROut>): TestApi => {
     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(() => runEff(eff), hookOptions ?? DEFAULT_HOOK_TIMEOUT);
+    bun.afterAll(guardTeardown(eff), hookOptions ?? DEFAULT_HOOK_TIMEOUT);
   }) as AfterAllFn;
   afterAll.skipIf = (predicate) => (eff, hookOptions) => {
     if (predicate) return;
-    bun.afterAll(() => runEff(eff), hookOptions ?? DEFAULT_HOOK_TIMEOUT);
+    bun.afterAll(guardTeardown(eff), hookOptions ?? DEFAULT_HOOK_TIMEOUT);
   };
 
   const afterEach: AfterEachFn = (eff, hookOptions) => {

package/src/Test/Core.ts

@@ -1,5 +1,6 @@
 /** @effect-diagnostics anyUnknownInErrorContext:off */
 
+import * as Floci from "@alchemy.run/floci";
 import * as Config from "effect/Config";
 import { ConfigProvider } from "effect/ConfigProvider";
 import * as Context from "effect/Context";
@@ -11,7 +12,6 @@ import * as Scope from "effect/Scope";
 import * as FetchHttpClient from "effect/unstable/http/FetchHttpClient";
 import * as HttpClient from "effect/unstable/http/HttpClient";
 import * as HttpClientRequest from "effect/unstable/http/HttpClientRequest";
-import * as Floci from "@alchemy.run/floci";
 
 import { DEFAULT_LOCAL_ENDPOINT } from "../AWS/AuthProvider.ts";
 import { flociServices } from "../AWS/Local/FlociServices.ts";
@@ -28,6 +28,7 @@ import { destroy as _destroy } from "../Destroy.ts";
 import type { Input } from "../Input.ts";
 import * as RpcProviderProxy from "../Local/RpcProviderProxy.ts";
 import * as RpcSpawner from "../Local/RpcSpawner.ts";
+import { ALCHEMY_DEV } from "../Phase.ts";
 import * as Plan from "../Plan.ts";
 import {
   type CompiledStack,
@@ -39,7 +40,6 @@ import {
 import { Stage } from "../Stage.ts";
 import * as State from "../State/index.ts";
 import { TelemetryLive } from "../Telemetry/Layer.ts";
-import { ALCHEMY_DEV } from "../Phase.ts";
 import { loadConfigProvider } from "../Util/ConfigProvider.ts";
 import { PlatformServices } from "../Util/PlatformServices.ts";
 
@@ -181,8 +181,8 @@ interface SidecarSingleton {
 
 const sidecarSingletons = new Map<string, SidecarSingleton>();
 
-export const makeSidecarHandle = (
-  options: MakeOptions,
+export const makeSidecarHandle = <ROut = any>(
+  options: MakeOptions<ROut>,
 ): SidecarHandle | undefined => {
   if (!resolveSidecar(options)) return undefined;
   const key = options.profile ?? process.env.ALCHEMY_PROFILE ?? "";
@@ -197,14 +197,19 @@ export const makeSidecarHandle = (
         // Capture the ambient platform context (provided by `toEffect`) so
         // the deferred spawner build can run inside a provider's `get`
         // without leaking platform requirements onto the RpcProviderProxy
-        // interface. The shared MemoMap dedupes concurrent first calls, so
-        // the PROCESS gets exactly one spawner no matter how many files race.
-        const context = yield* Effect.context<never>();
+        // interface. Omit Scope: that key is the calling file's sharedScope
+        // (closed in afterAll). Merging it in would pin the process-wide
+        // spawner HTTP server to a file that exits while others still need
+        // it. Provide the sidecar singleton scope instead.
+        const ambient = Context.omit(Scope.Scope)(
+          yield* Effect.context<never>(),
+        );
         const realProxy = Layer.buildWithMemoMap(real, memoMap, scope).pipe(
           Effect.map((built) =>
             Context.get(built, RpcProviderProxy.RpcProviderProxy),
           ),
-          Effect.provideContext(context as Context.Context<any>),
+          Effect.provideContext(ambient as Context.Context<any>),
+          Scope.provide(scope),
           Effect.orDie,
         );
         return RpcProviderProxy.RpcProviderProxy.of({
@@ -332,9 +337,9 @@ const alchemyLayer = Layer.mergeAll(LoggingCli, AlchemyContextLive);
  * 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 = <A>(
+export const toEffect = <A, ROut = any>(
   effect: TestEffect<A>,
-  options: MakeOptions,
+  options: MakeOptions<ROut>,
   scope?: Scope.Scope,
   sidecar?: SidecarHandle,
 ): Effect.Effect<A, any, never> => {
@@ -374,9 +379,9 @@ export const toEffect = <A>(
 };
 
 /** Promise wrapper around {@link toEffect} for `bun.test`-style runners. */
-export const run = <A>(
+export const run = <A, ROut = any>(
   effect: TestEffect<A>,
-  options: MakeOptions,
+  options: MakeOptions<ROut>,
   scope?: Scope.Scope,
   sidecar?: SidecarHandle,
 ): Promise<A> => Effect.runPromise(toEffect(effect, options, scope, sidecar));
@@ -530,11 +535,12 @@ export const scratchStack = <ROut>(
       ? Layer.succeed(State.State, State.InMemoryService({}))
       : Layer.provide(State.localState(), PlatformServices);
 
-  // `withProviders` already pins test-body distilled to Floci, but the stack
-  // *program* is composed under `AWS.providers()`'s live Endpoint. Dual
-  // providers still hit Floci in lifecycle ops; user-program distilled
-  // (e.g. ECS Service `findHostedZoneId`) would otherwise query real AWS.
-  const pinProgramToFloci = <A, E, R>(
+  // `withProviders` already pins the test body to Floci, but the stack program
+  // and its later plan/apply phase run under `AWS.providers()`'s 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 Floci for Action data-plane calls.
+  const pinToFloci = <A, E, R>(
     effect: Effect.Effect<A, E, R>,
   ): Effect.Effect<A, E, R> =>
     Option.getOrElse(alchemyTestDevOverride(), () => false)
@@ -542,7 +548,7 @@ export const scratchStack = <ROut>(
       : effect;
 
   const buildAndApply = (effect: Effect.Effect<any, any, any>) =>
-    (pinProgramToFloci(effect) as Effect.Effect<any, any, never>).pipe(
+    (pinToFloci(effect) as Effect.Effect<any, any, never>).pipe(
       makeStack({
         name: stackName,
         providers: options.providers,
@@ -551,6 +557,7 @@ export const scratchStack = <ROut>(
       Effect.flatMap((compiled: any) =>
         Plan.make(compiled).pipe(
           Effect.flatMap(apply),
+          pinToFloci,
           Effect.provide(compiled.services),
         ),
       ),
@@ -559,14 +566,14 @@ export const scratchStack = <ROut>(
     );
 
   const buildPlan = (effect: Effect.Effect<any, any, any>) =>
-    (pinProgramToFloci(effect) as Effect.Effect<any, any, never>).pipe(
+    (pinToFloci(effect) as Effect.Effect<any, any, never>).pipe(
       makeStack({
         name: stackName,
         providers: options.providers,
         state: stateLayer,
       } as any) as any,
       Effect.flatMap((compiled: any) =>
-        Plan.make(compiled).pipe(Effect.provide(compiled.services)),
+        pinToFloci(Plan.make(compiled)).pipe(Effect.provide(compiled.services)),
       ),
       Effect.provide(Layer.succeed(Stage, stage)),
       provideFreshArtifactStore,

package/src/Util/ConfigProvider.ts

@@ -18,8 +18,8 @@ export const loadConfigProvider = (envFile: Option.Option<string>) => {
       return ConfigProvider.fromEnv();
     }
     return ConfigProvider.orElse(
-      yield* ConfigProvider.fromDotEnv({ path: ".env" }),
       ConfigProvider.fromEnv(),
+      yield* ConfigProvider.fromDotEnv({ path: ".env" }),
     );
   });
 };