alchemy 2.0.0-beta.44 → 2.0.0-beta.46

package/src/KeyPair.ts

@@ -0,0 +1,146 @@
+import * as NodeCrypto from "node:crypto";
+import * as Effect from "effect/Effect";
+import * as Redacted from "effect/Redacted";
+import * as Provider from "./Provider.ts";
+import { Resource } from "./Resource.ts";
+
+export type KeyPairAlgorithm = "ed25519" | "rsa" | "ec";
+
+export interface KeyPairProps {
+  /**
+   * Key algorithm used to generate the pair.
+   * @default "ed25519"
+   */
+  algorithm?: KeyPairAlgorithm;
+  /**
+   * Modulus length in bits. Only used when {@link algorithm} is `"rsa"`.
+   * @default 2048
+   */
+  modulusLength?: number;
+  /**
+   * Named curve. Only used when {@link algorithm} is `"ec"`.
+   * @default "P-256"
+   */
+  namedCurve?: string;
+}
+
+export type KeyPair = Resource<
+  "Alchemy.KeyPair",
+  KeyPairProps,
+  {
+    algorithm: KeyPairAlgorithm;
+    privateKey: Redacted.Redacted<string>;
+    publicKey: string;
+  }
+>;
+
+/**
+ * A deterministic-in-state public/private keypair generator.
+ *
+ * The keypair is generated once on first reconcile and then persisted in
+ * state so subsequent deploys keep the same keys unless the resource is
+ * replaced. `privateKey` is PEM-encoded `pkcs8` and `publicKey` is
+ * PEM-encoded `spki`.
+ *
+ * @resource
+ *
+ * @section Generating a Keypair
+ * @example Default ed25519 keypair
+ * ```typescript
+ * const keys = yield* KeyPair("signing-key");
+ * // keys.privateKey: Redacted<string>  (PEM pkcs8)
+ * // keys.publicKey:  string            (PEM spki)
+ * // keys.algorithm:  "ed25519"
+ * ```
+ *
+ * @example RSA keypair
+ * ```typescript
+ * const keys = yield* KeyPair("rsa-key", {
+ *   algorithm: "rsa",
+ *   modulusLength: 2048,
+ * });
+ * ```
+ *
+ * @example EC keypair on a named curve
+ * ```typescript
+ * const keys = yield* KeyPair("ec-key", {
+ *   algorithm: "ec",
+ *   namedCurve: "P-256",
+ * });
+ * ```
+ *
+ * @section Consuming the Keys
+ * @example Pass the private key to a Worker as a secret
+ * ```typescript
+ * const keys = yield* KeyPair("signing-key");
+ * export const Worker = Cloudflare.Worker("Worker", {
+ *   main: "./src/worker.ts",
+ *   bindings: {
+ *     SIGNING_KEY: keys.privateKey,
+ *     PUBLIC_KEY: keys.publicKey,
+ *   },
+ * });
+ * ```
+ */
+export const KeyPair = Resource<KeyPair>("Alchemy.KeyPair");
+
+const pemEncoding = {
+  privateKeyEncoding: { type: "pkcs8", format: "pem" },
+  publicKeyEncoding: { type: "spki", format: "pem" },
+} as const;
+
+const generate = (
+  props: KeyPairProps,
+): {
+  privateKey: string;
+  publicKey: string;
+  algorithm: KeyPairAlgorithm;
+} => {
+  const algorithm = props.algorithm ?? "ed25519";
+  if (algorithm === "rsa") {
+    const { privateKey, publicKey } = NodeCrypto.generateKeyPairSync("rsa", {
+      modulusLength: props.modulusLength ?? 2048,
+      ...pemEncoding,
+    });
+    return { algorithm, privateKey, publicKey };
+  }
+  if (algorithm === "ec") {
+    const { privateKey, publicKey } = NodeCrypto.generateKeyPairSync("ec", {
+      namedCurve: props.namedCurve ?? "P-256",
+      ...pemEncoding,
+    });
+    return { algorithm, privateKey, publicKey };
+  }
+  const { privateKey, publicKey } = NodeCrypto.generateKeyPairSync(
+    "ed25519",
+    pemEncoding,
+  );
+  return { algorithm, privateKey, publicKey };
+};
+
+export const KeyPairProvider = () =>
+  Provider.succeed(KeyPair, {
+    reconcile: Effect.fn(function* ({ news = {}, output }) {
+      // Observe — there is no remote state. The cached `output` is the
+      // authoritative current value; once minted the keypair is preserved
+      // across reconciles to keep it stable.
+      if (output?.privateKey && output?.publicKey) {
+        return output;
+      }
+
+      // Ensure — no observed value: mint a fresh keypair. The next
+      // reconcile will see this in `output` and short-circuit above.
+      const generated = yield* Effect.sync(() => generate(news));
+      return {
+        algorithm: generated.algorithm,
+        privateKey: Redacted.make(generated.privateKey),
+        publicKey: generated.publicKey,
+      };
+    }),
+    delete: Effect.fn(function* () {
+      return undefined;
+    }),
+    read: Effect.fn(function* ({ output }) {
+      return output;
+    }),
+  });

package/src/Local/RpcProvider.ts

@@ -1,9 +1,16 @@
+import type * as Context from "effect/Context";
 import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
+import * as Option from "effect/Option";
+import * as Predicate from "effect/Predicate";
 import type { Scope } from "effect/Scope";
+import * as Stream from "effect/Stream";
+import { InstanceId } from "../InstanceId.ts";
 import type { Platform } from "../Platform.ts";
 import * as Provider from "../Provider.ts";
 import type { ResourceClass, ResourceLike } from "../Resource.ts";
+import { Stack } from "../Stack.ts";
+import { Stage } from "../Stage.ts";
 import { RpcProviderProxy } from "./RpcProviderProxy.ts";
 
 /**
@@ -69,11 +76,48 @@ export const effect = <
     cls,
     Effect.gen(function* () {
       const client = yield* Effect.serviceOption(RpcProviderProxy);
-      if (client._tag === "None") return yield* eff;
+      const stack = yield* Stack;
+
+      if (client._tag === "None") {
+        const provider = yield* eff;
+        return new Proxy(provider, {
+          get: (target, prop) => {
+            const value = (target as any)[prop];
+            if (!Predicate.isFunction(value)) return value;
+            return (...args: any[]) => {
+              const result = value(...args);
+              const services = Layer.mergeAll(
+                layerFallback(Stack, stack),
+                layerFallback(Stage, stack.stage),
+                Predicate.hasProperty(args[0], "instanceId") &&
+                  Predicate.isString(args[0].instanceId)
+                  ? layerFallback(InstanceId, args[0].instanceId)
+                  : Layer.empty,
+              );
+              return result.pipe(
+                Stream.isStream(result)
+                  ? Stream.provide(services)
+                  : Effect.provide(services),
+              );
+            };
+          },
+        });
+      }
       return yield* client.value.get(serverEntryUrl, cls.Type);
     }),
   );
 
+const layerFallback = <I, S>(
+  service: Context.Key<I, S>,
+  defaultValue: NoInfer<S>,
+) =>
+  Layer.effect(
+    service,
+    Effect.serviceOption(service).pipe(
+      Effect.map(Option.getOrElse(() => defaultValue)),
+    ),
+  );
+
 /**
  * Conditionally constructs a layer for use by an RpcProvider.
  * If the {@link RpcProviderProxy} is present in context, the layer is empty because it will not be used in this process.

package/src/Local/RpcServerEnvironment.ts

@@ -29,7 +29,7 @@ export const layer = (environment: RpcServerEnvironment) =>
     CredentialsStoreLive,
     Layer.succeed(AuthProviders, {}),
     ConfigProvider.layer(
-      loadConfigProvider(Option.fromUndefinedOr(environment.envFile)).pipe(
+      loadConfigProvider(Option.fromNullishOr(environment.envFile)).pipe(
         Effect.map((base) => withProfileOverride(base, environment.profile)),
       ),
     ),

package/src/Neon/Project.ts

@@ -136,7 +136,7 @@ const findProjectByName = (name: string) =>
   Effect.gen(function* () {
     const matches: ListProjectsOutput["projects"][number][] = [];
     let cursor: string | undefined;
-    do {
+    while (true) {
       const page = yield* listProjects({
         search: name,
         ...(cursor !== undefined ? { cursor } : {}),
@@ -144,8 +144,21 @@ const findProjectByName = (name: string) =>
       for (const p of page.projects) {
         if (p.name === name) matches.push(p);
       }
-      cursor = page.pagination?.cursor;
-    } while (cursor);
+      const nextCursor = page.pagination?.cursor;
+      // Neon returns a `pagination.cursor` on every response — it's the
+      // `created_at` of the last row, not a "has next page" flag — so we
+      // can't loop on cursor presence alone or we spin forever re-fetching
+      // empty/identical pages. Stop once a page comes back empty or the
+      // cursor stops advancing.
+      if (
+        page.projects.length === 0 ||
+        nextCursor === undefined ||
+        nextCursor === cursor
+      ) {
+        break;
+      }
+      cursor = nextCursor;
+    }
     return matches;
   });
 

package/src/Output.ts

@@ -1,4 +1,5 @@
 import * as Data from "effect/Data";
+import * as Duration from "effect/Duration";
 import * as Effect from "effect/Effect";
 import { pipe } from "effect/Function";
 import type { Pipeable } from "effect/Pipeable";
@@ -6,7 +7,7 @@ import * as Redacted from "effect/Redacted";
 import { SingleShotGen } from "effect/Utils";
 import { getRefMetadata, isRef, type Ref } from "./Ref.ts";
 import { isResource, type Resource, type ResourceLike } from "./Resource.ts";
-import { RuntimeContext } from "./RuntimeContext.ts";
+import { RuntimeContext, sanitizeKey } from "./RuntimeContext.ts";
 import { Stack } from "./Stack.ts";
 import { Stage } from "./Stage.ts";
 import * as State from "./State/State.ts";
@@ -112,9 +113,11 @@ export abstract class BaseExpr<A = any, Req = any> implements Output<A, Req> {
   }
 
   public bind(id: string): any {
+    // `set`/`get` store keys verbatim, so canonicalize here (the caller's job).
+    const key = sanitizeKey(id);
     return RuntimeContext.pipe(
       Effect.flatMap((ctx) =>
-        Effect.map(ctx.set(id, this), (key) => ctx.get<A>(key)),
+        Effect.map(ctx.set(key, this), (k) => ctx.get<A>(k)),
       ),
     );
   }
@@ -590,6 +593,9 @@ export const evaluate: <A, Req = never>(
       return yield* Effect.all(expr.map((item) => evaluate(item, upstream)));
     } else if (Redacted.isRedacted(expr)) {
       return expr;
+    } else if (Duration.isDuration(expr)) {
+      // Opaque value — see resolveInput in Plan.ts for rationale.
+      return expr;
     } else if (typeof expr === "object" && expr !== null) {
       return Object.fromEntries(
         yield* Effect.all(

package/src/Phase.ts

@@ -1,7 +1,15 @@
 import * as Config from "effect/Config";
 import * as Effect from "effect/Effect";
 
+export type AlchemyPhase = "plan" | "runtime";
+
 export const ALCHEMY_PHASE = Config.string("ALCHEMY_PHASE").pipe(
   Config.withDefault("plan"),
+  Config.mapOrFail((value) => {
+    if (value !== "plan" && value !== "runtime") {
+      return Effect.die(new Error(`Invalid ALCHEMY_PHASE: ${value}`));
+    }
+    return Effect.succeed(value as AlchemyPhase);
+  }),
   Effect.orDie,
 );

package/src/Plan.ts

@@ -1,4 +1,5 @@
 import * as Data from "effect/Data";
+import * as Duration from "effect/Duration";
 import * as Effect from "effect/Effect";
 import * as Option from "effect/Option";
 import * as Redacted from "effect/Redacted";
@@ -18,6 +19,7 @@ import {
   makeScopedArtifacts,
 } from "./Artifacts.ts";
 import {
+  dedupeBindings,
   diffBindings,
   havePropsChanged,
   isResolved,
@@ -309,7 +311,11 @@ export const make = <A>(
                   : oldState.props;
 
               const oldBindings = oldState.bindings ?? [];
-              const newBindings = stack.bindings[resource.FQN] ?? [];
+              // Collapse duplicate bindings by sid so the binding set handed to
+              // `diff` matches what `reconcile` receives (see `dedupeBindings`).
+              const newBindings = dedupeBindings(
+                stack.bindings[resource.FQN] ?? [],
+              );
 
               const diff = yield* provider.diff
                 ? provider
@@ -375,6 +381,11 @@ export const make = <A>(
           return yield* resolveOutput(input);
         } else if (Redacted.isRedacted(input)) {
           return input;
+        } else if (Duration.isDuration(input)) {
+          // Duration is an opaque value; walking its internal `.value`
+          // would destroy the prototype and produce a plain `{ value: ... }`
+          // object that downstream consumers can't interpret.
+          return input;
         } else if (Array.isArray(input)) {
           return yield* Effect.all(input.map(resolveInput), {
             concurrency: "unbounded",
@@ -627,8 +638,10 @@ export const make = <A>(
             const news = yield* resolveInput(resource.Props);
             const downstream = newDownstreamDependencies[fqn] ?? [];
 
-            const newBindings: ResourceBinding[] = yield* resolveInput(
-              stack.bindings[fqn] ?? [],
+            // Collapse duplicate bindings by sid so the binding set handed to
+            // `diff` matches what `reconcile` receives (see `dedupeBindings`).
+            const newBindings: ResourceBinding[] = dedupeBindings(
+              yield* resolveInput(stack.bindings[fqn] ?? []),
             );
             const persisted = yield* state.get({
               stack: stackName,

package/src/Platform.ts

@@ -1,3 +1,5 @@
+import * as ConfigError from "effect/Config";
+import * as ConfigProvider from "effect/ConfigProvider";
 import * as Context from "effect/Context";
 import * as Effect from "effect/Effect";
 import { pipe } from "effect/Function";
@@ -7,14 +9,21 @@ import type { Scope } from "effect/Scope";
 import type { HttpClient } from "effect/unstable/http/HttpClient";
 import { SingleShotGen } from "effect/Utils";
 import type { PolicyLike } from "./Binding.ts";
+import type { Dependencies } from "./Dependencies.ts";
 import type { ExecutionContext } from "./ExecutionContext.ts";
 import type { HttpEffect } from "./Http.ts";
 import type { InputProps } from "./Input.ts";
+import * as Output from "./Output.ts";
 import { ALCHEMY_PHASE } from "./Phase.ts";
 import type { Provider, ProviderCollectionLike } from "./Provider.ts";
 import { Resource, type ResourceLike } from "./Resource.ts";
 import type { Rpc } from "./Rpc.ts";
-import { RuntimeContext, type BaseRuntimeContext } from "./RuntimeContext.ts";
+import {
+  CurrentRuntimeContext,
+  RuntimeContext,
+  sanitizeKey,
+  type BaseRuntimeContext,
+} from "./RuntimeContext.ts";
 import { Self } from "./Self.ts";
 import type { Stack, StackServices } from "./Stack.ts";
 import type { Stage } from "./Stage.ts";
@@ -65,19 +74,19 @@ export interface Platform<
   Type: Resource["Type"];
   Provider: Provider<Resource>;
 
-  <Self, Shape>(): {
+  <Self, Shape, Deps = never>(): {
     <PropsReq = never>(
       id: string,
       props:
         | InputProps<Resource["Props"]>
         | Effect.Effect<InputProps<Resource["Props"]>, never, PropsReq>,
     ): Effect.Effect<
-      Resource & Rpc<Self>,
+      Resource & Rpc<Self> & Dependencies<Deps>,
       never,
-      Self | Resource["Providers"] | PropsReq
+      Resource["Providers"] | PropsReq
     > & {
       make<InitReq = never>(
-        impl: Effect.Effect<Shape, never, InitReq>,
+        impl: Effect.Effect<Shape, ConfigError.ConfigError, InitReq>,
       ): Layer.Layer<
         Self,
         never,
@@ -98,7 +107,7 @@ export interface Platform<
       props:
         | InputProps<Resource["Props"]>
         | Effect.Effect<Resource["Props"], never, PropsReq>,
-      impl: Effect.Effect<Shape, never, InitReq>,
+      impl: Effect.Effect<Shape, ConfigError.ConfigError, InitReq>,
     ): Effect.Effect<
       Resource & Rpc<Self>,
       never,
@@ -119,7 +128,7 @@ export interface Platform<
       Resource["Providers"] | PropsReq
     > & {
       make<InitReq extends Services | PlatformServices = never>(
-        impl: Effect.Effect<Shape, never, InitReq>,
+        impl: Effect.Effect<Shape, ConfigError.ConfigError, InitReq>,
       ): Layer.Layer<
         Self,
         never,
@@ -158,7 +167,7 @@ export interface Platform<
     props:
       | InputProps<Resource["Props"]>
       | Effect.Effect<InputProps<Resource["Props"]>, never, PropsReq>,
-    impl: Effect.Effect<Shape, never, InitReq>,
+    impl: Effect.Effect<Shape, ConfigError.ConfigError, InitReq>,
   ): Effect.Effect<
     Resource & Rpc<Shape>,
     never,
@@ -343,28 +352,66 @@ export const Platform = <
                       }) ?? Effect.die("No serve handler"))
                     : Effect.void,
                 ),
+
                 Effect.provide(
-                  Layer.provideMerge(
-                    Layer.mergeAll(
-                      Layer.succeed(Platform.Platform, runtimeContext),
-                      Layer.succeed(PlatformContext, runtimeContext),
-                      Layer.succeed(RuntimeContext, runtimeContext),
-                      Layer.succeed(resource.Self, instance),
-                      Layer.succeed(Platform.Self, instance),
-                      Layer.succeed(Self, instance),
-                      runtimeContext.planServices
-                        ? Layer.unwrap(
-                            ALCHEMY_PHASE.pipe(
-                              Effect.map((phase) =>
-                                phase === "plan"
-                                  ? runtimeContext.planServices!
-                                  : Layer.empty,
+                  Layer.effect(
+                    ConfigProvider.ConfigProvider,
+                    Effect.gen(function* () {
+                      // a Config Provider that we use to intercept config lookups and bind them to the RuntimeContext
+                      const configProvider =
+                        yield* ConfigProvider.ConfigProvider;
+                      const phase = yield* ALCHEMY_PHASE;
+
+                      return ConfigProvider.make(
+                        Effect.fnUntraced(function* (path) {
+                          const ctx = yield* CurrentRuntimeContext;
+                          // `set`/`get` store keys verbatim, so canonicalize the
+                          // logical config path here (the caller's job) before
+                          // handing it to the RuntimeContext.
+                          const key = sanitizeKey(
+                            path.map((p) => p.toString()).join("_"),
+                          );
+                          const node = yield* configProvider.get(path);
+                          if (phase === "plan" && node) {
+                            // bind it to the RuntimeContext if running in plan phase
+                            const output = Output.literal(node.value);
+                            yield* ctx?.set(key, output) ?? Effect.void;
+                            return node;
+                          } else if (phase === "runtime" && ctx) {
+                            // retrieve from the RuntimeContext if running in runtime phase
+                            const value = yield* ctx.get<string>(key);
+                            if (value) {
+                              return ConfigProvider.makeValue(value as string);
+                            }
+                          }
+                          // fallback to the config provider otherwise
+                          return node;
+                        }),
+                      );
+                    }),
+                  ).pipe(
+                    Layer.provideMerge(
+                      Layer.mergeAll(
+                        Layer.succeed(Platform.Platform, runtimeContext),
+                        Layer.succeed(PlatformContext, runtimeContext),
+                        Layer.succeed(RuntimeContext, runtimeContext),
+                        Layer.succeed(resource.Self, instance),
+                        Layer.succeed(Platform.Self, instance),
+                        Layer.succeed(Self, instance),
+                        runtimeContext.planServices
+                          ? Layer.unwrap(
+                              ALCHEMY_PHASE.pipe(
+                                Effect.map((phase) =>
+                                  phase === "plan"
+                                    ? runtimeContext.planServices!
+                                    : Layer.empty,
+                                ),
                               ),
-                            ),
-                          )
-                        : Layer.empty,
+                            )
+                          : Layer.empty,
+                      ),
                     ),
-                    Layer.succeedContext(outerServices),
+                    Layer.provideMerge(Layer.succeedContext(outerServices)),
                   ),
                 ),
               );

package/src/Random.ts

@@ -32,34 +32,29 @@ export const Random = Resource<Random>("Alchemy.Random");
 
 export const RandomProvider = () =>
   Provider.succeed(Random, {
-    reconcile: Effect.fn(function* ({ news = {}, output }) {
-      // Observe — there is no remote state. The cached `output.text` is
-      // the authoritative current value; once minted it is preserved
-      // across reconciles to keep the secret stable.
-      if (output?.text) {
-        return output;
-      }
+    reconcile: ({ news = {}, output }) =>
+      Effect.sync(() => {
+        // Observe — there is no remote state. The cached `output.text` is
+        // the authoritative current value; once minted it is preserved
+        // across reconciles to keep the secret stable.
+        if (output?.text) {
+          return output;
+        }
 
-      // Ensure — no observed value: mint a fresh random secret and
-      // return it. The next reconcile will see this in `output` and
-      // short-circuit above.
-      const byteLength = news.bytes ?? 32;
-      const text = yield* Effect.sync(() => {
+        // Ensure — no observed value: mint a fresh random secret and
+        // return it. The next reconcile will see this in `output` and
+        // short-circuit above.
+        const byteLength = news.bytes ?? 32;
         const bytes = new Uint8Array(byteLength);
         crypto.getRandomValues(bytes);
-        return Redacted.make(
-          Array.from(bytes)
-            .map((b) => b.toString(16).padStart(2, "0"))
-            .join(""),
-        );
-      });
-
-      return { text };
-    }),
-    delete: Effect.fn(function* () {
-      return undefined;
-    }),
-    read: Effect.fn(function* ({ output }) {
-      return output;
-    }),
+        return {
+          text: Redacted.make(
+            Array.from(bytes)
+              .map((b) => b.toString(16).padStart(2, "0"))
+              .join(""),
+          ),
+        };
+      }),
+    delete: () => Effect.void,
+    read: ({ output }) => Effect.succeed(output),
   });

package/src/RuntimeContext.ts

@@ -9,7 +9,15 @@ export interface BaseRuntimeContext {
   Type: string;
   id: string;
   env: Record<string, any>;
-  get<T>(key: string): Effect.Effect<T>;
+  /**
+   * Read a value by its (already-canonical) key. The key is used verbatim;
+   * callers must {@link sanitizeKey} first. See {@link sanitizeKey}.
+   */
+  get<T>(key: string): Effect.Effect<T | undefined>;
+  /**
+   * Store an output under the given (already-canonical) key, returning the key.
+   * The key is used verbatim; callers must {@link sanitizeKey} first.
+   */
   set(id: string, output: Output): Effect.Effect<string>;
   exports?: Effect.Effect<Record<string, any>>;
   serve?<Req = never>(
@@ -21,6 +29,20 @@ export interface BaseRuntimeContext {
   planServices?: Layer.Layer<any>;
 }
 
+/**
+ * Canonicalize a logical key into a key that is safe to use as the name of an
+ * environment variable / binding (`[a-zA-Z][a-zA-Z0-9_]*`).
+ *
+ * `RuntimeContext.set`/`get` are dumb key/value stores: they read and write the
+ * key **verbatim**. It is the *caller's* responsibility to hand them a
+ * canonical key, since the caller is the one that knows the logical key may
+ * contain `.`/`-` (e.g. a dotted config name from `Platform`, or an
+ * `Output.toString()` like `"QueueSinkQueue.queueUrl"`). Callers run the key
+ * through this before calling `set`/`get` so both sides agree.
+ */
+export const sanitizeKey = (key: string): string =>
+  key.replaceAll(/[^a-zA-Z0-9]/g, "_");
+
 /**
  * Context of the runtime environment.
  *

package/src/Stack.ts

@@ -10,6 +10,7 @@ import * as Scope from "effect/Scope";
 import * as FetchHttpClient from "effect/unstable/http/FetchHttpClient";
 import type { HttpClient } from "effect/unstable/http/HttpClient";
 import type { ChildProcessSpawner } from "effect/unstable/process/ChildProcessSpawner";
+import type { ActionLike } from "./Action.ts";
 import { AlchemyContext, AlchemyContextLive } from "./AlchemyContext.ts";
 import { provideFreshArtifactStore } from "./Artifacts.ts";
 import { AuthProviders } from "./Auth/AuthProvider.ts";
@@ -20,7 +21,6 @@ import type { Input, InputProps } from "./Input.ts";
 import * as Output from "./Output.ts";
 import type { ResourceBinding, ResourceLike } from "./Resource.ts";
 import { Stage } from "./Stage.ts";
-import type { ActionLike } from "./Action.ts";
 import type { State } from "./State/State.ts";
 import { loadConfigProvider } from "./Util/ConfigProvider.ts";
 import { effectClass, taggedFunction } from "./Util/effect.ts";
@@ -291,8 +291,8 @@ const alchemy = (overrides?: { dev?: boolean }) =>
       : AlchemyContextLive,
   );
 
-export const evalStack = <A, B, Err, Req>(
-  effect: StackEffect<CompiledStack<A>, Stage | AlchemyContext>,
+export const evalStack = <A, B, StackErr, Err, Req>(
+  effect: StackEffect<CompiledStack<A>, StackErr, Stage | AlchemyContext>,
   fn: (stack: CompiledStack<A>) => Effect.Effect<B, Err, Req>,
   options: {
     stage: string;