alchemy 2.0.0-beta.51 → 2.0.0-beta.53

package/src/Planetscale/Postgres/PostgresRole.ts

@@ -1,8 +1,9 @@
 import { Credentials } from "@distilled.cloud/planetscale/Credentials";
-import * as ops from "@distilled.cloud/planetscale/Operations";
+import * as planetscale from "@distilled.cloud/planetscale/Operations";
 import * as Effect from "effect/Effect";
 import * as Redacted from "effect/Redacted";
 import { deepEqual, isResolved } from "../../Diff.ts";
+import { createPhysicalName } from "../../PhysicalName.ts";
 import * as Provider from "../../Provider.ts";
 import { Resource } from "../../Resource.ts";
 import type { Providers } from "../Providers.ts";
@@ -14,7 +15,6 @@ import {
 import type { PostgresBranch } from "./PostgresBranch.ts";
 import type { PostgresDatabase } from "./PostgresDatabase.ts";
 import type { PostgresOrigin } from "./PostgresOrigin.ts";
-import { createPhysicalName } from "../../PhysicalName.ts";
 
 /**
  * Built-in PostgreSQL roles that can be inherited from. Custom role names
@@ -171,6 +171,192 @@ export type PostgresRole = Resource<
 
 export const PostgresRole = Resource<PostgresRole>("Planetscale.PostgresRole");
 
+export const PostgresRoleProvider = () =>
+  Provider.succeed(PostgresRole, {
+    stables: ["id"],
+
+    diff: Effect.fn(function* ({ id, news, olds, output }) {
+      if (!isResolved(news)) return undefined;
+
+      // Successor is the only updatable property — everything else
+      // requires replacement.
+      if (news.ttl !== olds.ttl) {
+        return { action: "replace" } as const;
+      }
+      const newDb = resolveDatabaseName(news.database);
+      const oldDb = olds.database
+        ? resolveDatabaseName(olds.database)
+        : undefined;
+      if (oldDb && newDb !== oldDb) {
+        return { action: "replace" } as const;
+      }
+      const newBranch = resolveBranchName(news.branch);
+      const oldBranch = resolveBranchName(olds.branch);
+      if (newBranch !== oldBranch) {
+        return { action: "replace" } as const;
+      }
+      const newRoles = resolveInheritedRoles(news.inheritedRoles);
+      const oldRoles = output?.inheritedRoles ?? [];
+      if (!deepEqual(newRoles, oldRoles)) {
+        return { action: "replace" } as const;
+      }
+      const oldName = output?.name ?? (yield* resolveName(id, olds?.name));
+      const newName = yield* resolveName(id, news.name);
+
+      if (newName !== oldName) {
+        return { action: "update" } as const;
+      }
+
+      return undefined;
+    }),
+
+    read: Effect.fn(function* ({ output }) {
+      if (!output?.id) return undefined;
+
+      return yield* planetscale
+        .getRole({
+          branch: output.branch,
+          database: output.database,
+          organization: output.organization,
+          id: output.id,
+        })
+        .pipe(
+          Effect.map((token) =>
+            buildAttributes(token, output.password, {
+              inheritedRoles: token.inherited_roles as InheritedRole[],
+              successor: output.successor,
+              organization: output.organization,
+              database: output.database,
+              branch: token.branch.name,
+            }),
+          ),
+          Effect.catchTag("Forbidden", () => Effect.succeed(undefined)),
+          Effect.catchTag("NotFound", () => Effect.succeed(undefined)),
+        );
+    }),
+
+    reconcile: Effect.fn(function* ({ id, news, output }) {
+      const { organization: envOrg } = yield* yield* Credentials;
+      const organization = resolveDatabaseOrg(news.database) ?? envOrg;
+      const databaseName = resolveDatabaseName(news.database);
+      const branchName = resolveBranchName(news.branch);
+      const inheritedRoles = resolveInheritedRoles(news.inheritedRoles);
+      const successor = resolveSuccessorName(news.successor);
+      const desiredName = yield* resolveName(id, news.name);
+
+      // 1. Observe — fetch live state if we know the role id. Roles
+      //    can only be looked up by id; without a cached id there is
+      //    no way to find the live role, so we fall through to ensure.
+      const observed = output?.id
+        ? yield* planetscale
+            .getRole({
+              id: output.id,
+              branch: branchName,
+              organization,
+              database: databaseName,
+            })
+            .pipe(Effect.catchTag("NotFound", () => Effect.succeed(undefined)))
+        : undefined;
+
+      // 2. Ensure — create if missing. Single branch covers both
+      //    greenfield (no output) and out-of-band-deletion (output
+      //    cached but cloud lost it). The latter is structurally a
+      //    rotation: the new role has fresh id/host/username/plaintext
+      //    that propagate downstream through the dependency graph.
+      //    There is no path to recover the original plaintext, so
+      //    recreating is the only way to converge.
+      //
+      //    Planetscale returns the plaintext password value exactly
+      //    once on create; on an observe-hit we re-use the cached
+      //    plaintext from output (which is why adoption requires
+      //    pre-existing state — see `read`).
+      let live: planetscale.GetRoleOutput | planetscale.CreateRoleOutput;
+      let plaintext: Redacted.Redacted<string>;
+      if (observed) {
+        live = observed;
+        plaintext = output!.password;
+      } else {
+        const branchInfo = yield* planetscale.getBranch({
+          organization,
+          database: databaseName,
+          branch: branchName,
+        });
+        if (branchInfo.kind !== "postgresql") {
+          return yield* Effect.fail(
+            new PlanetscaleConflict({
+              message: `Cannot create a Role on MySQL database "${databaseName}". Roles are only supported on PostgreSQL. Use Password for MySQL.`,
+            }),
+          );
+        }
+        if (!branchInfo.ready) {
+          yield* waitForBranchReady(organization, databaseName, branchName);
+        }
+        const created = yield* planetscale.createRole({
+          name: desiredName,
+          branch: branchName,
+          organization,
+          database: databaseName,
+          ttl: news.ttl,
+          inherited_roles: inheritedRoles as SDKInheritedRole[],
+        });
+        if (!created.password) {
+          return yield* Effect.die(
+            `Planetscale did not return a password for Role "${desiredName}".`,
+          );
+        }
+        plaintext = created.password;
+        live = created;
+      }
+
+      // 3. Sync — only `name` is mutable in place; diff observed
+      //    against desired and skip the API call when nothing
+      //    changed. Everything else triggers a replace via diff().
+      if (live.name !== desiredName) {
+        live = yield* planetscale.updateRole({
+          id: live.id,
+          branch: branchName,
+          organization,
+          database: databaseName,
+          name: desiredName,
+        });
+      }
+
+      // 4. Return — fresh attrs sourced from observed cloud state,
+      //    with cached or freshly-issued plaintext.
+      return buildAttributes(live, plaintext, {
+        inheritedRoles: live.inherited_roles as InheritedRole[],
+        successor,
+        organization,
+        database: databaseName,
+        branch: branchName,
+      });
+    }),
+
+    delete: Effect.fn(function* ({ output }) {
+      yield* planetscale
+        .deleteRole({
+          organization: output.organization,
+          database: output.database,
+          branch: output.branch,
+          id: output.id,
+          successor: output.successor,
+        })
+        .pipe(
+          Effect.catchTag("NotFound", () => Effect.void),
+          // 422 (UnprocessableEntity): role is still referenced. Log a
+          // warning rather than failing — the role will be cleaned up
+          // when the database/branch is deleted.
+          Effect.catchIf(
+            isKnownError(
+              "UnprocessableEntity",
+              "Role is still referenced and cannot be dropped.",
+            ),
+            () => Effect.void,
+          ),
+        );
+    }),
+  });
+
 // Structural shapes for runtime-resolved Resource references — see notes
 // in Password.ts.
 type DatabaseRef = string | { name: string; organization?: string };
@@ -274,196 +460,3 @@ const buildAttributes = (
     ttl: role.ttl,
   };
 };
-
-export const PostgresRoleProvider = () =>
-  Provider.effect(
-    PostgresRole,
-    Effect.gen(function* () {
-      const createRole = yield* ops.createRole;
-      const deleteRole = yield* ops.deleteRole;
-      const updateRole = yield* ops.updateRole;
-      const getRole = yield* ops.getRole;
-      const getBranch = yield* ops.getBranch;
-
-      return {
-        stables: ["id"],
-
-        diff: Effect.fn(function* ({ id, news, olds, output }) {
-          if (!isResolved(news)) return undefined;
-
-          // Successor is the only updatable property — everything else
-          // requires replacement.
-          if (news.ttl !== olds.ttl) {
-            return { action: "replace" } as const;
-          }
-          const newDb = resolveDatabaseName(news.database);
-          const oldDb = olds.database
-            ? resolveDatabaseName(olds.database)
-            : undefined;
-          if (oldDb && newDb !== oldDb) {
-            return { action: "replace" } as const;
-          }
-          const newBranch = resolveBranchName(news.branch);
-          const oldBranch = resolveBranchName(olds.branch);
-          if (newBranch !== oldBranch) {
-            return { action: "replace" } as const;
-          }
-          const newRoles = resolveInheritedRoles(news.inheritedRoles);
-          const oldRoles = output?.inheritedRoles ?? [];
-          if (!deepEqual(newRoles, oldRoles)) {
-            return { action: "replace" } as const;
-          }
-          const oldName = output?.name ?? (yield* resolveName(id, olds?.name));
-          const newName = yield* resolveName(id, news.name);
-
-          if (newName !== oldName) {
-            return { action: "update" } as const;
-          }
-
-          return undefined;
-        }),
-
-        read: Effect.fn(function* ({ output }) {
-          if (!output?.id) return undefined;
-
-          return yield* getRole({
-            branch: output.branch,
-            database: output.database,
-            organization: output.organization,
-            id: output.id,
-          }).pipe(
-            Effect.map((token) =>
-              buildAttributes(token, output.password, {
-                inheritedRoles: token.inherited_roles as InheritedRole[],
-                successor: output.successor,
-                organization: output.organization,
-                database: output.database,
-                branch: token.branch.name,
-              }),
-            ),
-            Effect.catchTag("Forbidden", () => Effect.succeed(undefined)),
-            Effect.catchTag("NotFound", () => Effect.succeed(undefined)),
-          );
-        }),
-
-        reconcile: Effect.fn(function* ({ id, news, output }) {
-          const { organization: envOrg } = yield* Credentials;
-          const organization = resolveDatabaseOrg(news.database) ?? envOrg;
-          const databaseName = resolveDatabaseName(news.database);
-          const branchName = resolveBranchName(news.branch);
-          const inheritedRoles = resolveInheritedRoles(news.inheritedRoles);
-          const successor = resolveSuccessorName(news.successor);
-          const desiredName = yield* resolveName(id, news.name);
-
-          // 1. Observe — fetch live state if we know the role id. Roles
-          //    can only be looked up by id; without a cached id there is
-          //    no way to find the live role, so we fall through to ensure.
-          const observed = output?.id
-            ? yield* getRole({
-                id: output.id,
-                branch: branchName,
-                organization,
-                database: databaseName,
-              }).pipe(
-                Effect.catchTag("NotFound", () => Effect.succeed(undefined)),
-              )
-            : undefined;
-
-          // 2. Ensure — create if missing. Single branch covers both
-          //    greenfield (no output) and out-of-band-deletion (output
-          //    cached but cloud lost it). The latter is structurally a
-          //    rotation: the new role has fresh id/host/username/plaintext
-          //    that propagate downstream through the dependency graph.
-          //    There is no path to recover the original plaintext, so
-          //    recreating is the only way to converge.
-          //
-          //    Planetscale returns the plaintext password value exactly
-          //    once on create; on an observe-hit we re-use the cached
-          //    plaintext from output (which is why adoption requires
-          //    pre-existing state — see `read`).
-          let live: ops.GetRoleOutput | ops.CreateRoleOutput;
-          let plaintext: Redacted.Redacted<string>;
-          if (observed) {
-            live = observed;
-            plaintext = output!.password;
-          } else {
-            const branchInfo = yield* getBranch({
-              organization,
-              database: databaseName,
-              branch: branchName,
-            });
-            if (branchInfo.kind !== "postgresql") {
-              return yield* Effect.fail(
-                new PlanetscaleConflict({
-                  message: `Cannot create a Role on MySQL database "${databaseName}". Roles are only supported on PostgreSQL. Use Password for MySQL.`,
-                }),
-              );
-            }
-            if (!branchInfo.ready) {
-              yield* waitForBranchReady(organization, databaseName, branchName);
-            }
-            const created = yield* createRole({
-              name: desiredName,
-              branch: branchName,
-              organization,
-              database: databaseName,
-              ttl: news.ttl,
-              inherited_roles: inheritedRoles as SDKInheritedRole[],
-            });
-            if (!created.password) {
-              return yield* Effect.die(
-                `Planetscale did not return a password for Role "${desiredName}".`,
-              );
-            }
-            plaintext = created.password;
-            live = created;
-          }
-
-          // 3. Sync — only `name` is mutable in place; diff observed
-          //    against desired and skip the API call when nothing
-          //    changed. Everything else triggers a replace via diff().
-          if (live.name !== desiredName) {
-            live = yield* updateRole({
-              id: live.id,
-              branch: branchName,
-              organization,
-              database: databaseName,
-              name: desiredName,
-            });
-          }
-
-          // 4. Return — fresh attrs sourced from observed cloud state,
-          //    with cached or freshly-issued plaintext.
-          return buildAttributes(live, plaintext, {
-            inheritedRoles: live.inherited_roles as InheritedRole[],
-            successor,
-            organization,
-            database: databaseName,
-            branch: branchName,
-          });
-        }),
-
-        delete: Effect.fn(function* ({ output }) {
-          yield* deleteRole({
-            organization: output.organization,
-            database: output.database,
-            branch: output.branch,
-            id: output.id,
-            successor: output.successor,
-          }).pipe(
-            Effect.catchTag("NotFound", () => Effect.void),
-            // 422 (UnprocessableEntity): role is still referenced. Log a
-            // warning rather than failing — the role will be cleaned up
-            // when the database/branch is deleted.
-            Effect.catchIf(
-              isKnownError(
-                "UnprocessableEntity",
-                "Role is still referenced and cannot be dropped.",
-              ),
-              () => Effect.void,
-            ),
-          );
-        }),
-      };
-    }),
-  );

package/src/Planetscale/Providers.ts

@@ -3,7 +3,6 @@ import * as FetchHttpClient from "effect/unstable/http/FetchHttpClient";
 import { CredentialsStoreLive } from "../Auth/Credentials.ts";
 import { ProfileLive } from "../Auth/Profile.ts";
 import * as Provider from "../Provider.ts";
-import type { StackServices } from "../Stack.ts";
 import { PlanetscaleAuth } from "./AuthProvider.ts";
 import * as Credentials from "./Credentials.ts";
 import { MySQLBranch, MySQLBranchProvider } from "./MySQL/MySQLBranch.ts";
@@ -43,11 +42,7 @@ export type ProviderRequirements = Layer.Services<ReturnType<typeof providers>>;
  * Effect.provide(Planetscale.providers())
  * ```
  */
-export const providers = (): Layer.Layer<
-  Providers | Credentials.Credentials,
-  never,
-  StackServices
-> =>
+export const providers = () =>
   Layer.effect(
     Providers,
     Provider.collection([
@@ -77,4 +72,4 @@ export const providers = (): Layer.Layer<
     Layer.provideMerge(ProfileLive),
     Layer.provideMerge(CredentialsStoreLive),
     Layer.orDie,
-  ) as Layer.Layer<Providers | Credentials.Credentials, never, StackServices>;
+  );

package/src/Platform.ts

@@ -2,13 +2,12 @@ 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";
+import * as Effectable from "effect/Effectable";
 import * as Layer from "effect/Layer";
 import * as Option from "effect/Option";
 import * as Redacted from "effect/Redacted";
 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";
@@ -225,7 +224,7 @@ export const Platform = <
         constructor(id, props, impl, true);
     } else if (!impl) {
       const cls = makeClass(id, props);
-      const asEffect = () =>
+      const evaluate = () =>
         (!isTag
           ? // this is a non-tagged resource yielded without providing an implementation
             // e.g.
@@ -272,7 +271,7 @@ export const Platform = <
         );
       return Object.assign(
         function (impl: Impl) {
-          return cls.asEffect().pipe(Effect.provide(cls.make(impl)));
+          return cls.Self.pipe(Effect.provide(cls.make(impl)));
         },
         // we splice in the Effect so this can be yielded to indicate a non-Effect native instance
         // e.g. here, we yield it - in this case we don't want to provide an implementation
@@ -280,42 +279,29 @@ export const Platform = <
         //  main: "./src/worker.ts"
         // });
         cls,
-        {
-          asEffect,
-          // @ts-expect-error
-          pipe: (...args: any[]) => asEffect().pipe(...args),
-          [Symbol.iterator]: () => new SingleShotGen(asEffect()),
-        },
+        // Spread the Effect prototype LAST so it overrides the evaluate copied
+        // from `cls`: yielding this no-impl form bridges to the (possibly
+        // non-Effect-native) resource rather than resolving the Self tag.
+        Effectable.Prototype({
+          label: `${type}<${id}>`,
+          evaluate,
+        }),
       );
     } else {
       // impl was provided inline, this is a non-tagged eager instance
       // e.g.
       // export default Cloudflare.Worker("id", { main: "./src/worker.ts" }, Effect.gen(function* () { .. })
       const cls = makeClass(id, props);
-      return cls.asEffect().pipe(Effect.provide(cls.make(impl)), effectClass);
+      return cls.Self.pipe(Effect.provide(cls.make(impl)), effectClass);
     }
   };
 
   const makeClass = (id: string, props: Props) => {
-    return class Platform {
+    class Platform {
       static readonly Self = Self(`${type}<${id}>`);
       static readonly Platform = Context.Service<Platform, Platform>(
         `Platform<${type}<${id}>>`,
       );
-      static [Symbol.iterator](): Iterator<
-        Effect.Effect<void, never, Self>,
-        Resource,
-        void
-      > {
-        return new SingleShotGen(this.asEffect()) as any;
-      }
-      static asEffect() {
-        return this.Self;
-      }
-      static pipe(...args: any[]) {
-        // @ts-expect-error
-        return pipe(this, ...args);
-      }
       static of = (shape: any) => shape;
       static make = (impl: Impl) => {
         // build the Layer once for the root Self
@@ -460,13 +446,31 @@ export const Platform = <
           SelfLayer,
         );
       };
-    };
+    }
+    // Make the platform class itself a real Effect: `yield* MyWorker` resolves
+    // the Self tag. Replaces the hand-rolled asEffect/pipe/[Symbol.iterator].
+    return Object.assign(
+      Platform,
+      Effectable.Prototype({
+        label: `${type}<${id}>`,
+        evaluate: () => Platform.Self,
+      }),
+    );
   };
 
-  const instance = Object.assign(constructor, resource, {
-    Platform: Platform,
-    asEffect: () => resource.Self,
-    ...methods,
-  }) as any;
+  const instance = Object.assign(
+    constructor,
+    resource,
+    // Spread the Effect prototype LAST so it overrides any evaluate inherited
+    // from `resource`; `yield* Cloudflare.Worker` resolves the resource Self.
+    Effectable.Prototype({
+      label: `${type}`,
+      evaluate: () => resource.Self,
+    }),
+    {
+      Platform: Platform,
+      ...methods,
+    },
+  ) as any;
   return instance;
 };

package/src/Resource.ts

@@ -1,7 +1,7 @@
 import * as Effect from "effect/Effect";
+import * as Effectable from "effect/Effectable";
 import * as Option from "effect/Option";
-import { pipeArguments, type Pipeable } from "effect/Pipeable";
-import { SingleShotGen } from "effect/Utils";
+import type { Pipeable } from "effect/Pipeable";
 import { AdoptPolicy } from "./AdoptPolicy.ts";
 import { toFqn } from "./FQN.ts";
 import type { Input, InputProps } from "./Input.ts";
@@ -287,17 +287,6 @@ export function Resource<R extends ResourceLike>(
   const ProviderTag = Provider(type);
 
   const Service = {
-    [Symbol.iterator]() {
-      return new SingleShotGen(this.asEffect());
-    },
-    pipe() {
-      return pipeArguments(this, arguments);
-    },
-    asEffect() {
-      return Effect.succeed((id: string, props: R["Props"]) =>
-        constructor(id, props),
-      );
-    },
     /**
      * Build a typed reference to a deployed instance of this resource
      * — in the current stack/stage by default, or in another via
@@ -323,6 +312,16 @@ export function Resource<R extends ResourceLike>(
         ? Object.assign(ResourceClass, args[0])
         : constructor(...(args as [string, R["Props"]])),
     Service,
+    // Make the constructor itself a real Effect: `yield* MyResource` resolves
+    // to the constructor function (same as the old `asEffect()`), and
+    // `Effect.isEffect(MyResource)` is now true so `Effect.all`/`forEach` work.
+    Effectable.Prototype({
+      label: `Resource<${type}>`,
+      evaluate: () =>
+        Effect.succeed((id: string, props: R["Props"]) =>
+          constructor(id, props),
+        ),
+    }),
   ) as any;
 
   return ResourceClass;

package/src/Runtime.ts

@@ -7,6 +7,7 @@
  */
 
 import * as Layer from "effect/Layer";
+import { asEffect } from "./Util/types.ts";
 
 /**
  * Resolve the user's default-export entrypoint into a `Layer` for the
@@ -14,7 +15,7 @@ import * as Layer from "effect/Layer";
  *
  * `entrypoint` may be any of:
  *   - a `Layer` factory (`{ build: (...) => ... }`) — used as-is
- *   - an effect-class with `asEffect()` (Alchemy `Platform`/`Worker` shape)
+ *   - an Alchemy `Platform`/`Worker` construct (now a real `Effect`)
  *   - a plain `Effect`
  *
  * Centralized so the inline ternary doesn't have to be re-emitted into
@@ -29,10 +30,5 @@ export const makeEntrypointLayer = (
   if (typeof entrypoint?.build === "function") {
     return entrypoint;
   }
-  return Layer.effect(
-    tag,
-    typeof entrypoint?.asEffect === "function"
-      ? entrypoint.asEffect()
-      : entrypoint,
-  );
+  return Layer.effect(tag, asEffect(entrypoint));
 };

package/src/Server/SQSQueueEventSource.ts

@@ -2,7 +2,7 @@ import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
 import * as Stream from "effect/Stream";
 
-import { Region } from "@distilled.cloud/aws/Region";
+import { AWSEnvironment } from "../AWS/Environment.ts";
 import * as SQS from "../AWS/SQS/index.ts";
 import { ServerHost } from "./Process.ts";
 
@@ -10,7 +10,7 @@ export const SQSQueueEventSource = Layer.effect(
   SQS.QueueEventSource,
   Effect.gen(function* () {
     const { run } = yield* ServerHost;
-    const region = yield* Region;
+    const env = yield* AWSEnvironment;
 
     const ReceiveMessage = yield* SQS.ReceiveMessage;
     const DeleteMessageBatch = yield* SQS.DeleteMessageBatch;
@@ -23,6 +23,7 @@ export const SQSQueueEventSource = Layer.effect(
       ) => Effect.Effect<void, never, Req | StreamReq>,
     ) {
       const QueueArn = yield* queue.queueArn;
+      const { region } = yield* env;
 
       const receiveMessage = yield* ReceiveMessage(queue);
       const deleteMessageBatch = yield* DeleteMessageBatch(queue);

package/src/Stack.ts

@@ -16,7 +16,7 @@ import { AlchemyContext, AlchemyContextLive } from "./AlchemyContext.ts";
 import { provideFreshArtifactStore } from "./Artifacts.ts";
 import { AuthProviders } from "./Auth/AuthProvider.ts";
 import { CredentialsStore, CredentialsStoreLive } from "./Auth/Credentials.ts";
-import { Profile, ProfileLive } from "./Auth/Profile.ts";
+import { AlchemyProfile, ProfileLive } from "./Auth/Profile.ts";
 import { Cli } from "./Cli/Cli.ts";
 import type { Input, InputProps } from "./Input.ts";
 import * as Output from "./Output.ts";
@@ -38,7 +38,7 @@ export type StackServices =
   | HttpClient
   | ChildProcessSpawner
   | AuthProviders
-  | Profile
+  | AlchemyProfile
   | CredentialsStore
   | Cli;
 
@@ -51,7 +51,7 @@ export type StackEffect<A, Err = never, Req = never> = Effect.Effect<
   | AuthProviders
   | AlchemyContext
   | Cli
-  | Profile
+  | AlchemyProfile
   | CredentialsStore
   | State
   | Req