alchemy 2.0.0-beta.62 → 2.0.0-beta.63

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "alchemy",
-  "version": "2.0.0-beta.62",
+  "version": "2.0.0-beta.63",
   "homepage": "https://alchemy.run",
   "license": "Apache-2.0",
   "author": "Sam Goodwin <sam@alchemy.run>",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/alchemy-run/alchemy-effect.git",
+    "url": "git+https://github.com/alchemy-run/alchemy.git",
     "directory": "packages/alchemy"
   },
   "bin": {
@@ -26,8 +26,7 @@
     "bundle": "tsdown",
     "bundle:watch": "tsdown --watch",
     "publish:npm": "cp ../README.md . && bun publish && rm README.md",
-    "test": "vitest run",
-    "test:fast": "FAST=1 vitest run",
+    "test": "alchemy-test",
     "test:benchmark": "tsx --tsconfig tsconfig.test.json test/types.benchmark.ts",
     "nuke": "cd ../../ && bun nuke"
   },
@@ -313,15 +312,15 @@
     "@alchemy.run/node-utils": "0.0.5",
     "@aws-sdk/credential-providers": "^3.0.0",
     "@clack/prompts": "^0.11.0",
-    "@distilled.cloud/aws": "0.29.0",
-    "@distilled.cloud/axiom": "0.29.0",
-    "@distilled.cloud/cloudflare": "0.29.0",
+    "@distilled.cloud/aws": "0.29.1",
+    "@distilled.cloud/axiom": "0.29.1",
+    "@distilled.cloud/cloudflare": "0.29.1",
     "@distilled.cloud/cloudflare-rolldown-plugin": "0.13.5",
     "@distilled.cloud/cloudflare-runtime": "0.13.5",
     "@distilled.cloud/cloudflare-vite-plugin": "0.13.5",
-    "@distilled.cloud/core": "0.29.0",
-    "@distilled.cloud/neon": "0.29.0",
-    "@distilled.cloud/planetscale": "0.29.0",
+    "@distilled.cloud/core": "0.29.1",
+    "@distilled.cloud/neon": "0.29.1",
+    "@distilled.cloud/planetscale": "0.29.1",
     "@effect/vitest": ">=4.0.0-beta.97|| >=4.0.0",
     "@libsql/client": "^0.17.0",
     "@octokit/rest": "^22.0.1",
@@ -348,6 +347,7 @@
     "yaml": "^2.0.0"
   },
   "devDependencies": {
+    "alchemy-test": "0.0.0",
     "@clack/prompts": "^0.11.0",
     "@cloudflare/containers": "^0.3.7",
     "@cloudflare/puppeteer": "^1.1.0",

package/src/AWS/AuthProvider.ts

@@ -272,7 +272,7 @@ export const AwsAuth = AuthProviderLayer<
                   ? Effect.fail(
                       new AuthError({
                         message:
-                          "AWS stored credentials not found. Run: alchemy-effect login --configure",
+                          "AWS stored credentials not found. Run: alchemy login --configure",
                       }),
                     )
                   : Effect.succeed({

package/src/AWS/EC2/hosted.ts

@@ -188,6 +188,7 @@ export const createEc2HostedSupport = ({
 import { BunServices } from "@effect/platform-bun";
 import { BunHttpServer } from "alchemy/Http";
 import { Stack } from "alchemy/Stack";
+import { reifyBoundConfigProvider } from "alchemy/Runtime";
 import * as Config from "effect/Config";
 import * as ConfigProvider from "effect/ConfigProvider";
 import * as Credentials from "@distilled.cloud/aws/Credentials";
@@ -233,7 +234,7 @@ const program = handler.pipe(
       Layer.provideMerge(
         Layer.succeed(
           ConfigProvider.ConfigProvider,
-          ConfigProvider.fromEnv()
+          reifyBoundConfigProvider(ConfigProvider.fromEnv(), process.env)
         )
       ),
     )

package/src/AWS/ECS/Task.ts

@@ -585,6 +585,7 @@ export const TaskProvider = () =>
 import { BunServices } from "@effect/platform-bun";
 import { BunHttpServer } from "alchemy/Http";
 import { Stack } from "alchemy/Stack";
+import { reifyBoundConfigProvider } from "alchemy/Runtime";
 import * as Config from "effect/Config";
 import * as ConfigProvider from "effect/ConfigProvider";
 import * as Credentials from "@distilled.cloud/aws/Credentials";
@@ -630,7 +631,7 @@ const program = handler.pipe(
       Layer.provideMerge(
         Layer.succeed(
           ConfigProvider.ConfigProvider,
-          ConfigProvider.fromEnv()
+          reifyBoundConfigProvider(ConfigProvider.fromEnv(), process.env)
         )
       ),
     )

package/src/AWS/Lambda/Function.ts

@@ -38,6 +38,7 @@ import { Platform, type Main, type PlatformProps } from "../../Platform.ts";
 import type { LogLine, LogsInput } from "../../Provider.ts";
 import * as Provider from "../../Provider.ts";
 import { Resource, type ResourceBinding } from "../../Resource.ts";
+import { packEnvValue, unpackEnvValue } from "../../RuntimeContext.ts";
 import { Self } from "../../Self.ts";
 import * as Serverless from "../../Serverless/index.ts";
 import { Stack } from "../../Stack.ts";
@@ -585,55 +586,17 @@ export const Function: Platform<
       set: (id: string, output: Output.Output) =>
         Effect.sync(() => {
           // Key is already canonical (see RuntimeContext.sanitizeKey); store it
-          // verbatim.
+          // verbatim. `packEnvValue` marker-packs Redacted values so they
+          // survive the Output → Lambda env var round-trip.
           const key = id;
-          // Preserve `Redacted`-ness across the Output → Lambda env var
-          // round-trip. `JSON.stringify(Redacted)` would emit the literal
-          // string `"<redacted>"` and lose the value, so secrets are
-          // serialized with a `{_tag: "Redacted", value: ...}` marker
-          // that the runtime `get` path detects and rebuilds.
-          env[key] = output.pipe(
-            Output.map((value) =>
-              Redacted.isRedacted(value)
-                ? JSON.stringify({
-                    _tag: "Redacted",
-                    value: Redacted.value(value),
-                  })
-                : JSON.stringify(value),
-            ),
-          );
+          env[key] = output.pipe(Output.map(packEnvValue));
           return key;
         }),
       get: <T>(key: string) =>
-        // Read the captured value straight from `process.env`. We must NOT
-        // resolve through `Config.string` here: at runtime the ambient
-        // `ConfigProvider` is the interceptor installed in `Platform.ts`,
-        // whose runtime branch calls back into `ctx.get(key)`. Going through
-        // `Config` would re-enter that interceptor for the same key and
-        // recurse forever, allocating until the Lambda init OOMs. The Worker
-        // runtime reads from `WorkerEnvironment` for the same reason.
-        Effect.sync(() => {
-          // Key is already canonical (see RuntimeContext.sanitizeKey).
-          const val = process.env[key];
-          if (val === undefined) {
-            return undefined;
-          }
-          try {
-            const value = JSON.parse(val);
-            if (
-              typeof value === "object" &&
-              value?._tag === "Redacted" &&
-              "value" in value
-            ) {
-              return Redacted.make(
-                (value as { value: unknown }).value,
-              ) as unknown as T;
-            }
-            return value as T;
-          } catch {
-            return val as unknown as T; // assume it's just a string
-          }
-        }),
+        // Key is already canonical (see RuntimeContext.sanitizeKey). Read
+        // straight from `process.env` — see `unpackEnvValue` for why this
+        // must never resolve through `Config.string`.
+        Effect.sync(() => unpackEnvValue<T>(process.env[key])),
       serve: (handler: HttpEffect) =>
         // @ts-ignore
         ctx.listen(makeFunctionHttpHandler(handler)),
@@ -940,7 +903,7 @@ export const FunctionProvider = () =>
                 (importPath) => `
 import { layer as nodeServicesLayer } from "@effect/platform-node/NodeServices";
 import { Stack } from "alchemy/Stack";
-import { makeEntrypointLayer } from "alchemy/Runtime";
+import { makeEntrypointLayer, reifyBoundConfigProvider } from "alchemy/Runtime";
 import { registerLambdaExtension } from "alchemy/AWS/Lambda/RuntimeExtension";
 import * as Config from "effect/Config";
 import * as ConfigProvider from "effect/ConfigProvider";
@@ -1001,7 +964,10 @@ const entryLayer = layer.pipe(
   Layer.provideMerge(
     Layer.succeed(
       ConfigProvider.ConfigProvider,
-      ConfigProvider.fromEnv()
+      // Auto-bound \`Config\` values arrive in the env as
+      // \`{"_tag":"Redacted","value":...}\` markers; reify them so a \`Config\`
+      // re-read inside a handler decodes the raw source value.
+      reifyBoundConfigProvider(ConfigProvider.fromEnv(), process.env)
     )
   ),
   Layer.provideMerge(

package/src/AWS/Lambda/MicrovmRuntimeContext.ts

@@ -1,10 +1,12 @@
-import * as Config from "effect/Config";
 import * as Effect from "effect/Effect";
 import * as Option from "effect/Option";
-import * as Redacted from "effect/Redacted";
 import { HttpServer, type HttpEffect } from "../../Http.ts";
 import * as Output from "../../Output.ts";
 import { serveRpc } from "../../Rpc.ts";
+import {
+  packEnvValueKeepRedacted,
+  unpackEnvValue,
+} from "../../RuntimeContext.ts";
 import * as Server from "../../Server/index.ts";
 
 export const MicrovmImageTypeId = "AWS.Lambda.MicrovmImage" as const;
@@ -49,45 +51,16 @@ export const makeMicrovmRuntimeContext = (
     set: (bindingId: string, output: Output.Output) =>
       Effect.sync(() => {
         const key = bindingId.replaceAll(/[^a-zA-Z0-9]/g, "_");
-        env[key] = output.pipe(
-          Output.map((value) =>
-            Redacted.isRedacted(value)
-              ? Redacted.make(
-                  JSON.stringify({
-                    _tag: "Redacted",
-                    value: Redacted.value(value),
-                  }),
-                )
-              : JSON.stringify(value),
-          ),
-        );
+        // `packEnvValueKeepRedacted` keeps the Redacted wrapper on the
+        // outside so deploy-time code can route secrets while the inner
+        // marker lets the runtime `get` accessor rebuild the wrapper.
+        env[key] = output.pipe(Output.map(packEnvValueKeepRedacted));
         return key;
       }),
     get: <T>(key: string) =>
-      Config.string(key).pipe(
-        Effect.flatMap((value) =>
-          Effect.try({
-            try: () => {
-              const parsed = JSON.parse(value) as T;
-              if (
-                typeof parsed === "object" &&
-                parsed !== null &&
-                (parsed as { _tag?: unknown })._tag === "Redacted" &&
-                "value" in parsed
-              ) {
-                return Redacted.make((parsed as { value: unknown }).value) as T;
-              }
-              return parsed;
-            },
-            catch: (error) => error as Error,
-          }),
-        ),
-        Effect.catch((cause) =>
-          Effect.die(
-            new Error(`Failed to get environment variable: ${key}`, { cause }),
-          ),
-        ),
-      ),
+      // Read straight from `process.env` — see `unpackEnvValue` for why
+      // this must never resolve through `Config.string`.
+      Effect.sync(() => unpackEnvValue<T>(process.env[key]) as T),
     run: ((effect: Effect.Effect<void, never, any>) =>
       Effect.sync(() => {
         runners.push(effect);

package/src/Action.ts

@@ -2,10 +2,12 @@ import * as Context from "effect/Context";
 import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
 import type { Pipeable } from "effect/Pipeable";
+import { makeCaptureContext } from "./ActionRuntimeContext.ts";
 import { toFqn } from "./FQN.ts";
 import type { Input } from "./Input.ts";
 import { CurrentNamespace, type NamespaceNode } from "./Namespace.ts";
 import * as Output from "./Output.ts";
+import { RuntimeContext } from "./RuntimeContext.ts";
 import { Stack } from "./Stack.ts";
 
 /**
@@ -35,6 +37,14 @@ export interface ActionLike<
   readonly Type: Type;
   readonly LogicalId: string;
   readonly Input: In;
+  /**
+   * Resource Outputs referenced via `yield* output` inside the init Effect,
+   * keyed by the Output's sanitized key. They become dependency edges (the
+   * Action waits for these upstreams) and are resolved against the tracker at
+   * apply time, then exposed to the body through the resolve
+   * {@link RuntimeContext}. Empty when the Action captures nothing.
+   */
+  readonly Captures: Record<string, Output.Output>;
   /** Resolved runner — populated by the init effect (if any). */
   readonly Run: (input: In) => Effect.Effect<Out, any, any>;
   /** @internal phantom */
@@ -83,9 +93,14 @@ export type ActionInit<In extends object | undefined, Out, Req> = Effect.Effect<
 //   const rows = yield* Sync({ table: bucket.name });
 //   // rows: Output<{ rows: number }, never>
 //
-// Tagged form for split contract/implementation:
+// Tagged form for split contract/implementation — declare the type with an
+// interface, build the value with the no-arg overload, then supply the runner
+// via `.make` (add the returned Layer to the stack's `providers`, or provide it
+// locally with `Effect.provide`). The init passed to `.make` runs under the
+// same capture context as the inline form, so `yield* output` accessors work:
 //
-//   class Sync extends Action<Sync, { table: string }, { rows: number }>()("Sync") {}
+//   interface Sync extends Action<"Sync", { table: string }, { rows: number }> {}
+//   const Sync = Action<Sync, { table: string }, { rows: number }>()("Sync");
 //   const SyncLive = Sync.make(Effect.gen(function* () { /* ... */ }));
 
 export function Action<
@@ -187,14 +202,23 @@ const makeActionClass = (
         `alchemy/Action<${type}>`,
       );
 
+  // Outputs referenced via `yield* output` inside the init Effect land here,
+  // recorded by the capture RuntimeContext. Shared per definition — the init
+  // runs at most once (Effect.cached), so captures are inherently
+  // per-definition, matching how the init's `Req` bubbles per definition.
+  const captures: Record<string, Output.Output> = {};
+  const captureContext = makeCaptureContext(captures);
+
   const constructor = (...args: [any] | [string, any]) => {
     const [id, input] =
       args.length === 1 ? [type, args[0]] : (args as [string, any]);
     return Effect.gen(function* () {
       const run = resolveRunner
-        ? yield* resolveRunner
+        ? yield* resolveRunner.pipe(
+            Effect.provideService(RuntimeContext, captureContext),
+          )
         : ((yield* SelfTag!) as ActionRunner<any, any, any>);
-      return yield* registerAction(type, id, input, run);
+      return yield* registerAction(type, id, input, run, captures);
     });
   };
 
@@ -203,12 +227,19 @@ const makeActionClass = (
     extra.Self = SelfTag;
     // `.make(initOrRun)` — accepts either a direct runner or an init Effect.
     // For init form we use `Layer.effect` so the init's Req surfaces on the
-    // Layer; for runners we use `Layer.succeed`.
+    // Layer, and run it under the capture RuntimeContext so `yield* output`
+    // accessors are recorded just like the inline form; for runners we use
+    // `Layer.succeed` (nothing to capture).
     extra.make = <R>(
       initOrRun: ActionRunner<any, any, R> | ActionInit<any, any, R>,
     ) =>
       isRunnerEffect(initOrRun)
-        ? Layer.effect(SelfTag, initOrRun as any)
+        ? Layer.effect(
+            SelfTag,
+            (initOrRun as ActionInit<any, any, R>).pipe(
+              Effect.provideService(RuntimeContext, captureContext),
+            ),
+          )
         : Layer.succeed(SelfTag, initOrRun as ActionRunner<any, any, any>);
   }
   return Object.assign(constructor, extra);
@@ -223,6 +254,7 @@ const registerAction = <
   id: string,
   input: any,
   run: ActionRunner<In, Out, any>,
+  captures: Record<string, Output.Output>,
 ): Effect.Effect<Output.ToOutput<Out, never>, never, Stack> =>
   Effect.gen(function* () {
     const stack = yield* Stack;
@@ -255,6 +287,7 @@ const registerAction = <
       FQN: fqn,
       LogicalId: id,
       Input: input,
+      Captures: captures,
       Run: run,
       Output: undefined as any,
     };

package/src/ActionRuntimeContext.ts

@@ -0,0 +1,68 @@
+import * as Effect from "effect/Effect";
+import type { Output } from "./Output.ts";
+import { type BaseRuntimeContext, RuntimeContext } from "./RuntimeContext.ts";
+
+/**
+ * Runtime context bridge that lets an {@link Action} read Resource Outputs.
+ *
+ * Actions are peculiar: their init Effect runs at plan/stack-eval time (before
+ * any resource exists) while their body runs at apply time (after upstreams are
+ * materialized). To make `yield* db.databaseId` work inside an Action we split
+ * the {@link RuntimeContext} into two cooperating halves that share nothing but
+ * a sanitized key:
+ *
+ *  - {@link makeCaptureContext} is provided while the init Effect runs. Its
+ *    `set(key, output)` records the referenced {@link Output} (so the engine can
+ *    add a dependency edge and later resolve it) and its `get(key)` hands back a
+ *    *deferred* accessor — an Effect that re-reads whatever `RuntimeContext` is
+ *    ambient when it actually runs.
+ *  - {@link makeResolveContext} is provided around the Action body at apply
+ *    time. Its `get(key)` returns the already-resolved value for that key.
+ *
+ * Because the accessor produced at init re-reads `RuntimeContext`, yielding it
+ * inside the body resolves against the apply-time context — no shared mutable
+ * state, no infinite recursion (the resolve context's `get` is terminal).
+ */
+
+const base = (id: string): Omit<BaseRuntimeContext, "get" | "set"> => ({
+  Type: "Action",
+  id,
+  env: {},
+});
+
+/**
+ * Capture context — provided while an Action's init Effect runs. Records every
+ * Output referenced via `yield* output` into `captures`, keyed by the Output's
+ * sanitized key, and returns deferred accessors.
+ */
+export const makeCaptureContext = (
+  captures: Record<string, Output>,
+): BaseRuntimeContext => ({
+  ...base("capture"),
+  set: (key, output) =>
+    Effect.sync(() => {
+      captures[key] = output as unknown as Output;
+      return key;
+    }),
+  // Deferred: re-read the ambient RuntimeContext at run time. At apply this is
+  // the resolve context below; its `get` returns the materialized value. The
+  // `RuntimeContext` requirement is erased at the Action boundary (`Run` is
+  // typed `Effect<Out, any, any>`) and satisfied by the resolve context, so
+  // the accessor presents as `Effect<T | undefined>`.
+  get: (<T>(key: string) =>
+    Effect.flatMap(RuntimeContext, (ctx) =>
+      ctx.get<T>(key),
+    )) as BaseRuntimeContext["get"],
+});
+
+/**
+ * Resolve context — provided around an Action body at apply time. `resolved`
+ * maps each captured key to its value (already evaluated against the tracker).
+ */
+export const makeResolveContext = (
+  resolved: Record<string, unknown>,
+): BaseRuntimeContext => ({
+  ...base("resolve"),
+  set: (key) => Effect.succeed(key),
+  get: <T>(key: string) => Effect.succeed(resolved[key] as T | undefined),
+});

package/src/Apply.ts

@@ -3,6 +3,9 @@ import * as Deferred from "effect/Deferred";
 import * as Effect from "effect/Effect";
 import * as Option from "effect/Option";
 import type { Simplify } from "effect/Types";
+import type { ActionLike } from "./Action.ts";
+import { makeResolveContext } from "./ActionRuntimeContext.ts";
+import { RuntimeContext } from "./RuntimeContext.ts";
 import {
   Artifacts,
   ArtifactStore,
@@ -16,7 +19,7 @@ import {
   Cli,
 } from "./Cli/Cli.ts";
 import type { ApplyStatus } from "./Cli/Event.ts";
-import { havePropsChanged } from "./Diff.ts";
+import { havePropsChanged, stripUnresolved } from "./Diff.ts";
 import type { Input } from "./Input.ts";
 import { generateInstanceId, InstanceId } from "./InstanceId.ts";
 import * as Output from "./Output.ts";
@@ -405,7 +408,14 @@ const executeNode = (
         stack: stackName,
         stage,
         fqn,
-        value: { ...value, namespace } as S,
+        // Early commits (`creating`/`replacing`) persist plan props that may
+        // still hold unresolved Output exprs; strip them so state stores only
+        // plain data (see stripUnresolved in Diff.ts).
+        value: {
+          ...value,
+          props: stripUnresolved(value.props),
+          namespace,
+        } as S,
       });
 
     const scopedSession = {
@@ -1117,6 +1127,25 @@ const executeNode = (
 // `--force` is set). The output value is written to `tracker[fqn].output`
 // so downstream Output evaluation works identically to resource attrs.
 
+/**
+ * Run an Action body, resolving any Outputs it captured via `yield* output`
+ * during init against the current tracker and exposing them to the body through
+ * the resolve {@link RuntimeContext}. See {@link makeCaptureContext}.
+ */
+const runAction = Effect.fn("apply.runAction")(function* (
+  task: ActionLike,
+  input: any,
+  outputs: Record<string, any>,
+) {
+  const resolved: Record<string, unknown> = {};
+  for (const [key, output] of Object.entries(task.Captures)) {
+    resolved[key] = yield* Output.evaluate(output, outputs);
+  }
+  return yield* task
+    .Run(input)
+    .pipe(Effect.provideService(RuntimeContext, makeResolveContext(resolved)));
+});
+
 const executeActionNode = (
   fqn: string,
   node: ActionApply,
@@ -1195,9 +1224,12 @@ const executeActionNode = (
     // until its run actually starts.
     yield* report("pending");
     yield* waitForDeps(
-      Object.keys(Output.resolveUpstream(node.input)).filter(
-        (f) => f in readyStable,
-      ),
+      [
+        ...new Set([
+          ...Object.keys(Output.resolveUpstream(node.input)),
+          ...Object.keys(Output.upstreamAny(task.Captures)),
+        ]),
+      ].filter((f) => f in readyStable),
     );
 
     const outputs = getOutputs();
@@ -1216,7 +1248,7 @@ const executeActionNode = (
     });
     yield* report("running");
 
-    const result = yield* task.Run(resolvedInput);
+    const result = yield* runAction(task, resolvedInput, outputs);
 
     yield* commit<RanActionState>({
       kind: "action",
@@ -1440,7 +1472,7 @@ const converge = Effect.fn(function* (
         } satisfies RunningActionState,
       });
 
-      const result = yield* node.def.Run(newInput);
+      const result = yield* runAction(node.def, newInput, outputs);
 
       yield* state.set({
         stack: stackName,
@@ -1577,7 +1609,13 @@ const collectGarbage = Effect.fn(function* (
             stack: stackName,
             stage,
             fqn,
-            value: { ...value, namespace } as S,
+            // Same rule as the lifecycle commit above: state only stores
+            // plain data, never unresolved Output exprs.
+            value: {
+              ...value,
+              props: stripUnresolved(value.props),
+              namespace,
+            } as S,
           });
 
         const report = (status: ApplyStatus) =>

package/src/Auth/AuthProvider.ts

@@ -12,7 +12,7 @@ import { withLock } from "./Lock.ts";
  * here so the redirect target lives in exactly one place across all
  * provider OAuth clients.
  */
-export const AUTH_LANDING_HOST = "https://v2.alchemy.run";
+export const AUTH_LANDING_HOST = "https://alchemy.run";
 export const AUTH_SUCCESS_URL = `${AUTH_LANDING_HOST}/auth/success`;
 export const AUTH_ERROR_URL = `${AUTH_LANDING_HOST}/auth/error`;
 

package/src/Auth/Lock.ts

@@ -50,7 +50,10 @@ export const withLock = <A, E, R>(
       try {
         await fs.mkdir(lockDir, { recursive: true });
         return await lock(lockPath, {
-          retries: { retries: 600, minTimeout: 50, maxTimeout: 50 },
+          // A full single-process test run can build hundreds of provider
+          // layers concurrently. Each credential read briefly takes this
+          // lock, so tail waiters need enough budget to drain that queue.
+          retries: { retries: 2_400, minTimeout: 50, maxTimeout: 50 },
           // The holder refreshes the lockfile mtime on a timer. Under heavy
           // load (e.g. a full test run saturating every core) that timer can
           // be starved for several seconds, so keep the stale threshold well
@@ -79,7 +82,7 @@ export const withLock = <A, E, R>(
         ) {
           throw new Error(
             `Timed out waiting for the alchemy auth lock '${lockPath}' — another alchemy ` +
-              `process has held it for over 30s. If no other alchemy process is running, ` +
+              `process has held it for over 120s. If no other alchemy process is running, ` +
               `delete the lock file and retry.`,
             { cause: err },
           );

package/src/Bundle/PurePlugin.ts

@@ -134,7 +134,7 @@ export const purePlugin = (
           markSideEffectFreeOpt &&
           !isEntry &&
           isSideEffectFree(info.sideEffects);
-        const annotated = annotateModule(code, id);
+        const annotated = annotateModuleCached(code, id);
         if (annotated === null) {
           return markSideEffectFree ? { code, moduleSideEffects: false } : null;
         }
@@ -433,6 +433,39 @@ interface AnnotatedModule {
   readonly map: ReturnType<MagicString["generateMap"]>;
 }
 
+/**
+ * Process-wide memo of {@link annotateModule} results keyed by module id.
+ *
+ * Parsing with oxc + generating the sourcemap dominates bundling CPU (it
+ * showed up as ~60% of the main-thread profile of a test run), and the same
+ * modules — effect/alchemy dist files — are re-transformed for EVERY bundle
+ * built in the process. The single-process test runner builds dozens of
+ * worker bundles per run, so this cache eliminates all repeat parses. The
+ * stored `code` is compared on lookup, so a changed file (e.g. dev watch
+ * mode) never serves a stale result.
+ */
+const annotateCache = new Map<
+  string,
+  { readonly code: string; readonly result: AnnotatedModule | null }
+>();
+const ANNOTATE_CACHE_MAX = 10_000;
+
+const annotateModuleCached = (
+  code: string,
+  filename: string,
+): AnnotatedModule | null => {
+  const cached = annotateCache.get(filename);
+  if (cached !== undefined && cached.code === code) {
+    return cached.result;
+  }
+  const result = annotateModule(code, filename);
+  if (annotateCache.size >= ANNOTATE_CACHE_MAX) {
+    annotateCache.clear();
+  }
+  annotateCache.set(filename, { code, result });
+  return result;
+};
+
 /**
  * Parses `code` and inserts `/*#__PURE__*\/` before every top-level
  * `CallExpression` / `NewExpression` callee. Returns `null` if the file