alchemy 2.0.0-beta.61 → 2.0.0-beta.63

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 = {
@@ -584,6 +594,7 @@ const executeNode = (
           attr = yield* node.provider
             .precreate({
               id: logicalId,
+              fqn,
               news: node.props,
               session: scopedSession,
               instanceId,
@@ -643,6 +654,7 @@ const executeNode = (
         attr = yield* node.provider
           .reconcile({
             id: logicalId,
+            fqn,
             news,
             instanceId,
             bindings: bindingOutputs,
@@ -765,6 +777,7 @@ const executeNode = (
         const attr = yield* node.provider
           .reconcile({
             id: logicalId,
+            fqn,
             news,
             instanceId,
             bindings: bindingOutputs,
@@ -887,6 +900,7 @@ const executeNode = (
               yield* node.provider
                 .delete({
                   id: logicalId,
+                  fqn,
                   instanceId: old.instanceId,
                   olds: old.props as never,
                   output: old.attr,
@@ -933,6 +947,7 @@ const executeNode = (
           attr = yield* node.provider
             .precreate({
               id: logicalId,
+              fqn,
               news: node.props,
               session: scopedSession,
               instanceId,
@@ -993,6 +1008,7 @@ const executeNode = (
         attr = yield* node.provider
           .reconcile({
             id: logicalId,
+            fqn,
             news,
             instanceId,
             bindings: bindingOutputs,
@@ -1111,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,
@@ -1189,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();
@@ -1210,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",
@@ -1346,6 +1384,7 @@ const converge = Effect.fn(function* (
       const attr = yield* node.provider
         .reconcile({
           id: logicalId,
+          fqn,
           news: newProps,
           instanceId,
           bindings: newBindings,
@@ -1433,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,
@@ -1570,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) =>
@@ -1648,6 +1693,7 @@ const collectGarbage = Effect.fn(function* (
               yield* provider
                 .delete({
                   id: logicalId,
+                  fqn,
                   instanceId,
                   olds: props as never,
                   output: attr,

package/src/Auth/AuthProvider.ts

@@ -5,6 +5,17 @@ import * as Schema from "effect/Schema";
 import * as Semaphore from "effect/Semaphore";
 import { withLock } from "./Lock.ts";
 
+/**
+ * Canonical web host for OAuth provider-agnostic landing pages
+ * (`/auth/success`, `/auth/error`). The CLI's loopback server 302s the
+ * browser to one of these after handling the OAuth callback. Centralized
+ * here so the redirect target lives in exactly one place across all
+ * provider OAuth clients.
+ */
+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`;
+
 /**
  * Methods on an {@link AuthProviderImpl} that mutate (or could trigger
  * mutation of) on-disk credentials. The factory wraps these in a

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/Axiom/AuthProvider.ts

@@ -328,9 +328,6 @@ export const AxiomAuth = AuthProviderLayer<
             Match.exhaustive,
           );
         }),
-        Effect.catch((e) =>
-          Console.error(`  Failed to retrieve credentials: ${e}`),
-        ),
       );
 
     return {

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

package/src/Bundle/Vite.ts

@@ -1,10 +1,11 @@
 import type { NonEmptyArray } from "effect/Array";
 import * as Cause from "effect/Cause";
-import * as Deferred from "effect/Deferred";
 import * as Effect from "effect/Effect";
 import * as FileSystem from "effect/FileSystem";
 import * as Path from "effect/Path";
+import type { PlatformError } from "effect/PlatformError";
 import type * as vite from "vite";
+import { cachedFunction } from "../Util/cached-function.ts";
 import { sha256 } from "../Util/index.ts";
 import {
   BundleError,
@@ -18,6 +19,7 @@ export interface ViteBuildOutput {
   readonly clientDirectory: string | undefined;
   // This is emitted as an Effect instead of a value so we can process it in parallel with reading the client assets.
   readonly serverBundle: Effect.Effect<BundleOutput | undefined, BundleError>;
+  readonly externalWorkspaces: Effect.Effect<Set<string>, PlatformError>;
 }
 
 // `@vitejs/plugin-rsc` writes these modules separately after build completes instead of emitting them as chunks.
@@ -45,15 +47,68 @@ export const viteBuildOutputPlugin = Effect.fn(function* ({
     string,
     Effect.Effect<BundleFile, BundleError>
   >();
-  const deferred = yield* Deferred.make<ViteBuildOutput, BundleError>();
+  const maybeExternalWorkspaces = new Set<string>();
 
+  const findUp = yield* cachedFunction(
+    (
+      dir: string,
+      filenames: Array<string>,
+    ): Effect.Effect<string | undefined, PlatformError> =>
+      Effect.filter(
+        filenames.map((filename) => path.join(dir, filename)),
+        fs.exists,
+        { concurrency: "unbounded" },
+      ).pipe(
+        Effect.flatMap(([match]) => {
+          if (match) {
+            return Effect.succeed(match);
+          }
+          const parent = path.dirname(dir);
+          if (parent === dir) {
+            return Effect.undefined;
+          }
+          return findUp(parent, filenames);
+        }),
+      ),
+  );
+  const collectExternalWorkspaces = (): Effect.Effect<
+    Set<string>,
+    PlatformError
+  > =>
+    Effect.forEach(maybeExternalWorkspaces, (directory) =>
+      findUp(directory, ["package.json"]),
+    ).pipe(
+      Effect.map(
+        (paths) =>
+          new Set(paths.filter((file) => file !== undefined).map(path.dirname)),
+      ),
+    );
   const plugin: vite.Plugin = {
     name: "alchemy:build-output",
     sharedDuringBuild: true,
+    // Collect the client output directory and server chunks as each
+    // environment writes its bundle. We deliberately do NOT resolve the build
+    // result from a `buildApp` hook: on Vite 8, when a project declares no
+    // `builder.buildApp` (e.g. a plain client-only SPA), `builder.buildApp()`
+    // runs post-order `buildApp` hooks *before* the default environment builds,
+    // so a hook fires while the output is still empty (issue #792). Instead,
+    // `viteBuild` reads `output` *after* `builder.buildApp()` resolves — by
+    // which point every environment that actually built has run `writeBundle`.
     async writeBundle(_, bundle) {
+      const root = path.resolve(this.environment.config.root);
+      for (const id of this.getModuleIds()) {
+        if (
+          !path.isAbsolute(id) ||
+          id.includes("node_modules") ||
+          id.startsWith(root)
+        ) {
+          continue;
+        }
+        maybeExternalWorkspaces.add(path.dirname(id));
+      }
       if (this.environment.name === "client") {
         clientDirectory = path.resolve(
-          this.environment.config.root,
+          root,
           this.environment.config.build.outDir,
         );
         return;
@@ -107,18 +162,6 @@ export const viteBuildOutputPlugin = Effect.fn(function* ({
         }),
       );
     },
-    buildApp: {
-      order: "post",
-      async handler() {
-        Deferred.doneUnsafe(
-          deferred,
-          Effect.succeed({
-            clientDirectory,
-            serverBundle: makeServerBundle(),
-          }),
-        );
-      },
-    },
   };
 
   // The server bundle may include chunks from more than one Vite environment, so we need to prefix them with the environment-specific output directory.
@@ -199,6 +242,14 @@ export const viteBuildOutputPlugin = Effect.fn(function* ({
 
   return {
     plugin,
-    output: Deferred.await(deferred),
+    // Read lazily so callers observe the state collected during the build.
+    // Only safe to await *after* `builder.buildApp()` has resolved.
+    output: Effect.sync(
+      (): ViteBuildOutput => ({
+        clientDirectory,
+        serverBundle: makeServerBundle(),
+        externalWorkspaces: collectExternalWorkspaces(),
+      }),
+    ),
   };
 });

package/src/Cli/LoggingCli.ts

@@ -113,22 +113,25 @@ export const LoggingCli = Layer.succeed(
 
         const counts = { ok: 0, fail: 0 };
         return {
+          // Write through the Effect Console SERVICE (not the global
+          // `console`) so environments that override it — e.g. the
+          // alchemy-test runner's per-test buffering console — capture
+          // apply progress instead of having it leak to stdout.
           emit: (event: ApplyEvent) =>
-            Effect.sync(() => {
+            Effect.suspend(() => {
               if (event.kind === "annotate") {
-                console.log(`${tag(event.id)} ${blue(event.message)}`);
-                return;
+                return Console.log(`${tag(event.id)} ${blue(event.message)}`);
               }
               const id = event.bindingId
                 ? `${event.id}/${event.bindingId}`
                 : event.id;
               const status = statusColor(event.status)(event.status);
               const msg = event.message ? ` ${dim("—")} ${event.message}` : "";
-              console.log(`${tag(id)} ${status}${msg}`);
               if (isTerminal(event.status)) {
                 if (event.status === "fail") counts.fail++;
                 else counts.ok++;
               }
+              return Console.log(`${tag(id)} ${status}${msg}`);
             }),
           done: () =>
             Console.log(