alchemy 2.0.0-beta.test-export-fix-4 → 2.0.0-cli-bundle-fix.1

package/src/Test/Bun.ts

@@ -1,43 +1,37 @@
-import { BunServices } from "@effect/platform-bun";
 import bun from "bun:test";
 import { ConfigProvider } from "effect/ConfigProvider";
 import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
 import * as Logger from "effect/Logger";
 import * as Option from "effect/Option";
-import type { Scope } from "effect/Scope";
 import * as FetchHttpClient from "effect/unstable/http/FetchHttpClient";
-import type { HttpClient } from "effect/unstable/http/HttpClient";
 import type { HookOptions } from "node:test";
-import * as Apply from "../Apply.ts";
+import { AlchemyContext, AlchemyContextLive } from "../AlchemyContext.ts";
 import { provideFreshArtifactStore } from "../Artifacts.ts";
-import { DotAlchemy, dotAlchemy } from "../Config.ts";
-import type { Input } from "../Input.ts";
-import * as Plan from "../Plan.ts";
-import { type CompiledStack, type StackServices } from "../Stack.ts";
-import { Stage } from "../Stage.ts";
+import { AuthProviders } from "../Auth/AuthProvider.ts";
+import { inkCLI } from "../Cli/InkCLI.tsx";
+import { deploy as _deploy } from "../Deploy.ts";
+import { destroy as _destroy } from "../Destroy.ts";
+import {
+  type CompiledStack,
+  type StackEffect,
+  type StackServices,
+} from "../Stack.ts";
 import * as State from "../State/index.ts";
 import { loadConfigProvider } from "../Util/ConfigProvider.ts";
-import { TestCli } from "./TestCli.ts";
+import { PlatformServices } from "../Util/PlatformServices.ts";
 
 export type ProvidedServices = StackServices;
 
-type TestEffect<A, Req = never> = Effect.Effect<
-  A,
-  any,
-  BunServices.BunServices | HttpClient | Scope | Req
->;
+type TestEffect<A, Req = never> = StackEffect<A, any, Req>;
 
-const platform = Layer.mergeAll(BunServices.layer, FetchHttpClient.layer);
+const platform = Layer.mergeAll(PlatformServices, FetchHttpClient.layer);
 
-// override alchemy state store, CLI/reporting and dotAlchemy
+// override alchemy state store, CLI/reporting, state, and dotAlchemy
 const alchemy = Layer.mergeAll(
-  // TODO(sam): support overriding these
-  State.LocalState,
-  // CLI.inkCLI(),
-  // optional
+  inkCLI(),
   Logger.layer([Logger.consolePretty()]),
-  dotAlchemy,
+  AlchemyContextLive,
 );
 
 const run = <A>(effect: TestEffect<A>) =>
@@ -49,6 +43,8 @@ const run = <A>(effect: TestEffect<A>) =>
       Effect.provide(Layer.succeed(ConfigProvider, configProvider)),
     );
   }).pipe(
+    Effect.provideService(AuthProviders, {}),
+    Effect.provide(State.localState()),
     Effect.provide(Layer.provideMerge(alchemy, platform)),
     Effect.scoped,
     Effect.runPromise,
@@ -104,10 +100,7 @@ export namespace test {
 
 export const describe = bun.describe;
 
-export function beforeAll<A>(
-  eff: Effect.Effect<A, any>,
-  options?: HookOptions,
-) {
+export function beforeAll<A>(eff: TestEffect<A>, options?: HookOptions) {
   let a: A;
   bun.beforeAll(
     () => run(eff).then((v) => (a = v)),
@@ -118,21 +111,17 @@ export function beforeAll<A>(
   return Effect.sync(() => a);
 }
 
-export function beforeEach(
-  eff: Effect.Effect<void, any>,
-  options?: HookOptions,
-) {
+export function beforeEach(eff: TestEffect<void>, options?: HookOptions) {
   bun.beforeEach(() => run(eff), options);
 }
 
-export function afterAll(eff: Effect.Effect<any, any>, options?: HookOptions) {
+export function afterAll(eff: TestEffect<any>, options?: HookOptions) {
   bun.afterAll(() => run(eff), options);
 }
 
 export namespace afterAll {
   export const skipIf =
-    (predicate: boolean) =>
-    (test: Effect.Effect<void, any>, options?: HookOptions) => {
+    (predicate: boolean) => (test: TestEffect<void>, options?: HookOptions) => {
       if (predicate) {
       } else {
         bun.afterAll(
@@ -145,74 +134,30 @@ export namespace afterAll {
     };
 }
 
-export function afterEach(
-  eff: Effect.Effect<void, any>,
-  options?: HookOptions,
-) {
+export function afterEach(eff: TestEffect<void>, options?: HookOptions) {
   bun.afterEach(() => run(eff), options);
 }
 
 export const deploy = <A>(
-  effect: TestEffect<CompiledStack<A>, Stage | DotAlchemy>,
+  stack: TestEffect<CompiledStack<A>, AlchemyContext>,
   options?: {
     /** @default test */
     stage?: string;
   },
 ) =>
-  exec(
-    effect,
-    (stack) =>
-      Effect.gen(function* () {
-        const plan = yield* Plan.make(stack);
-        const output = yield* Apply.apply(plan);
-        return output as Input.Resolve<A>;
-      }),
-    options,
-  );
+  _deploy({
+    stack: stack,
+    stage: options?.stage ?? "test",
+  });
 
 export const destroy = (
-  effect: TestEffect<CompiledStack, Stage | DotAlchemy>,
+  stack: TestEffect<CompiledStack, AlchemyContext>,
   options?: {
     /** @default test */
     stage?: string;
   },
 ) =>
-  exec(
-    effect,
-    (stack) =>
-      Effect.gen(function* () {
-        const plan = yield* Plan.make({
-          ...stack,
-          // zero these out (destroy will treat all as orphans)
-          // TODO(sam): probably better to have Plan.destroy and Plan.update
-          resources: {},
-          bindings: {},
-          output: {},
-        });
-        yield* Apply.apply(plan);
-      }),
-    options,
-  );
-
-const exec = <A, B>(
-  effect: TestEffect<CompiledStack<A>, Stage | DotAlchemy>,
-  fn: (stack: CompiledStack<A>) => Effect.Effect<B, any, any>,
-  options?: {
-    stage?: string;
-  },
-) =>
-  Effect.gen(function* () {
-    const stack = yield* effect;
-    const configProvider = yield* loadConfigProvider(Option.none());
-
-    return yield* fn(stack).pipe(
-      provideFreshArtifactStore,
-      Effect.provide(stack.services),
-      Effect.provide(Layer.succeed(ConfigProvider, configProvider)),
-    );
-  }).pipe(
-    Effect.provide(Layer.succeed(Stage, options?.stage ?? "test")),
-    Effect.provide(TestCli),
-    Effect.provide(Layer.provideMerge(alchemy, platform)),
-    Effect.scoped,
-  );
+  _destroy({
+    stack,
+    stage: options?.stage ?? "test",
+  });

package/src/Test/TestState.ts

@@ -1,19 +1,17 @@
-import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
 import { Stack } from "../Stack.ts";
-import { Stage } from "../Stage.ts";
 import * as State from "../State/index.ts";
 
 export const state = (resources: Record<string, State.ResourceState> = {}) =>
   Layer.effect(
     State.State,
-    Effect.gen(function* () {
-      return State.InMemoryService({
-        [(yield* Stack).name]: {
-          [yield* Stage]: resources,
+    Stack.useSync((stack) =>
+      State.InMemoryService({
+        [stack.name]: {
+          [stack.stage]: resources,
         },
-      });
-    }),
+      }),
+    ),
   );
 
 export const defaultState = (

package/src/Test/Vitest.ts

@@ -22,18 +22,21 @@ import * as AWS from "../AWS/index.ts";
 import * as Cloudflare from "../Cloudflare/index.ts";
 
 import type { ChildProcessSpawner } from "effect/unstable/process/ChildProcessSpawner";
+import { AlchemyContext, AlchemyContextLive } from "../AlchemyContext.ts";
 import { apply } from "../Apply.ts";
 import { Artifacts, provideFreshArtifactStore } from "../Artifacts.ts";
-import * as Credentials from "../AWS/Credentials.ts";
-import * as Region from "../AWS/Region.ts";
+import { AuthProviders } from "../Auth/AuthProvider.ts";
+import * as AWSCredentials from "../AWS/Credentials.ts";
+import * as AWSEnvironment from "../AWS/Environment.ts";
+import * as AWSRegion from "../AWS/Region.ts";
 import type { Command } from "../Build/Command.ts";
 import type { Cli } from "../Cli/index.ts";
+import { LoggingCli } from "../Cli/LoggingCli.ts";
 import {
   buildNamespaceTree,
   flattenTree,
   type DerivedAction,
 } from "../Cli/NamespaceTree.ts";
-import { DotAlchemy, dotAlchemy } from "../Config.ts";
 import { ExecutionContext } from "../ExecutionContext.ts";
 import type { Input } from "../Input.ts";
 import type { Output } from "../Output.ts";
@@ -45,7 +48,6 @@ import * as Stack from "../Stack.ts";
 import * as Stage from "../Stage.ts";
 import * as State from "../State/index.ts";
 import { PlatformServices } from "../Util/PlatformServices.ts";
-import { TestCli } from "./TestCli.ts";
 
 export const expectEmptyObject = () =>
   expect.toSatisfy(
@@ -68,7 +70,7 @@ type Provided =
   | Stack.Stack
   | State.State
   | Stage.Stage
-  | DotAlchemy
+  | AlchemyContext
   | HttpClient.HttpClient
   | FileSystem.FileSystem
   | Path.Path
@@ -79,12 +81,13 @@ type Provided =
   | Server.ProcessContext
   | Server.ServerHost
   | Serverless.FunctionContext
-  | AWS.StageConfig
+  | AWSEnvironment.AWSEnvironment
   | Artifacts
   | Provider<Command>
   | AWS.Providers
   | Cloudflare.Providers
-  | ChildProcessSpawner;
+  | ChildProcessSpawner
+  | AuthProviders;
 
 const quietLogger = Logger.make(() => {
   // console.log(options.message);
@@ -96,39 +99,43 @@ const platform = Layer.mergeAll(
   Logger.layer([process.env.VERBOSE ? Logger.consolePretty() : quietLogger]),
 );
 
-const awsStageConfig = Layer.effect(
-  AWS.StageConfig,
+const awsEnvironment = Layer.unwrap(
   Effect.gen(function* () {
-    const AWS_PROFILE = yield* Config.string("AWS_PROFILE").pipe(
+    const _profileName = yield* Config.string("AWS_PROFILE").pipe(
       Config.withDefault("default"),
     );
-
     const LOCAL = yield* Config.boolean("LOCAL").pipe(
       Config.withDefault(false),
     );
-
     const LOCALSTACK_ENDPOINT = yield* Config.string(
       "LOCALSTACK_ENDPOINT",
     ).pipe(Config.withDefault("http://localhost.localstack.cloud:4566"));
 
-    return AWS.StageConfig.of({
-      profile: LOCAL ? undefined : AWS_PROFILE,
-      region: LOCAL ? "us-east-1" : undefined,
-      credentials: LOCAL
-        ? {
-            accessKeyId: "test",
-            secretAccessKey: "test",
-            sessionToken: "test",
-          }
-        : undefined,
-      endpoint: LOCAL ? LOCALSTACK_ENDPOINT : undefined,
-    });
+    if (LOCAL) {
+      return AWSEnvironment.makeEnvironment({
+        accountId: "000000000000",
+        region: "us-east-1",
+        credentials: {
+          accessKeyId: "test",
+          secretAccessKey: "test",
+          sessionToken: "test",
+        },
+        endpoint: LOCALSTACK_ENDPOINT,
+      });
+    }
+    return Layer.effect(
+      AWSEnvironment.AWSEnvironment,
+      AWSEnvironment.loadDefault(),
+    ).pipe(Layer.orDie);
   }),
 );
 
 const awsProviders = Layer.provideMerge(
   AWS.providers(),
-  Layer.mergeAll(Credentials.fromStageConfig(), Region.fromStageConfig()),
+  Layer.provideMerge(
+    Layer.mergeAll(AWSRegion.fromEnvironment, AWSCredentials.fromEnvironment),
+    awsEnvironment,
+  ),
 );
 
 const cfProviders = Layer.provideMerge(
@@ -169,8 +176,8 @@ const runWithContext = <A, Err>(
   );
 
   const alchemy = Layer.provideMerge(
-    Layer.mergeAll(options.state ?? State.LocalState, TestCli),
-    Layer.mergeAll(awsStageConfig, stack, dotAlchemy),
+    Layer.mergeAll(options.state ?? State.localState(), LoggingCli),
+    Layer.mergeAll(stack, AlchemyContextLive),
   );
 
   const context = {
@@ -205,6 +212,7 @@ const runWithContext = <A, Err>(
       ),
     ),
     Effect.provideService(Stage.Stage, "test"),
+    Effect.provideService(AuthProviders, {}),
     Effect.provideService(ExecutionContext, context as any),
     Effect.provideService(Server.ServerHost, {
       run: (_effect) => Effect.void,
@@ -349,23 +357,22 @@ export namespace test {
   export const deploy = <A, Err = never, Req = any>(
     effect: Effect.Effect<A, Err, Req>,
   ): Effect.Effect<Input.Resolve<A>, Err, Req | Stack.Stack> =>
-    Stack.Stack.use((stack) => {
-      return provideFreshArtifactStore(
-        effect.pipe(
-          // Effect.tap(Effect.logInfo),
-          // @ts-expect-error
-          Stack.make(stack.name, Layer.effectContext(Effect.context<never>()), {
-            ...stack,
-            resources: {},
-            bindings: {},
-            output: {},
-          }),
-          Effect.flatMap(Plan.make),
-          Effect.tap((plan) => Effect.logInfo(formatPlan(plan))),
-          Effect.flatMap(apply),
-        ),
-      );
-    });
+    Stack.Stack.use((stack) =>
+      effect.pipe(
+        // Effect.tap(Effect.logInfo),
+        // @ts-expect-error
+        Stack.make(stack.name, Layer.effectContext(Effect.context<never>()), {
+          ...stack,
+          resources: {},
+          bindings: {},
+          output: {},
+        }),
+        Effect.flatMap(Plan.make),
+        Effect.tap((plan) => Effect.logInfo(formatPlan(plan))),
+        Effect.flatMap(apply),
+        provideFreshArtifactStore,
+      ),
+    );
 }
 
 type AnyAction = Plan.CRUD["action"] | Plan.BindingAction | DerivedAction;
@@ -520,3 +527,13 @@ export function afterAll<A, E, R extends Provided = never>(
     options?.timeout,
   );
 }
+export const destroy = () =>
+  Stack.Stack.use((stack) =>
+    Plan.make({
+      name: stack.name,
+      stage: stack.stage,
+      resources: {},
+      bindings: {},
+      output: {},
+    }).pipe(Effect.flatMap(apply), provideFreshArtifactStore),
+  );

package/src/Test/index.ts

@@ -1,3 +1,2 @@
-export * from "./TestCli.ts";
 export * from "./TestState.ts";
 export * from "./Vitest.ts";

package/src/Util/Clank.ts

@@ -0,0 +1,77 @@
+import * as p from "@clack/prompts";
+import * as Data from "effect/Data";
+import * as Effect from "effect/Effect";
+import { ChildProcess } from "effect/unstable/process";
+
+export class PromptCancelled extends Data.TaggedError("PromptCancelled") {}
+export const retryIfCancelled = Effect.retry({
+  while: (e: unknown) => e instanceof PromptCancelled,
+});
+
+/**
+ * Wraps a clack prompt (which returns a `Promise<T | symbol>` where the
+ * symbol indicates user cancellation) in an Effect.
+ *
+ * Returns `undefined` if the user cancels (Ctrl+C / Escape).
+ *
+ * Uses `Effect.callback` so fiber interruption propagates via the abort
+ * signal to any async resources we own; the clack prompt itself is left
+ * to resolve — its result is ignored after interruption.
+ */
+export const prompt = <T>(
+  fn: () => Promise<T | symbol>,
+): Effect.Effect<T, PromptCancelled> =>
+  Effect.callback<T, PromptCancelled>((resume, signal) => {
+    let settled = false;
+    fn().then(
+      (result) => {
+        if (settled || signal.aborted) return;
+        settled = true;
+        if (p.isCancel(result)) {
+          resume(Effect.fail(new PromptCancelled()));
+        } else {
+          resume(Effect.succeed(result as T));
+        }
+      },
+      (err) => {
+        if (settled || signal.aborted) return;
+        settled = true;
+        resume(Effect.die(err));
+      },
+    );
+  });
+
+export const success = (str: string) => Effect.sync(() => p.log.success(str));
+export const warn = (str: string) => Effect.sync(() => p.log.warn(str));
+export const error = (str: string) => Effect.sync(() => p.log.error(str));
+export const info = (str: string) => Effect.sync(() => p.log.info(str));
+export const text = (opts: p.TextOptions) => prompt(() => p.text(opts));
+export const password = (opts: p.PasswordOptions) =>
+  prompt(() => p.password(opts));
+export const select = <Value>(opts: p.SelectOptions<Value>) =>
+  prompt(() => p.select<Value>(opts));
+export const confirm = (opts: p.ConfirmOptions) =>
+  prompt(() => p.confirm(opts));
+export const multiselect = <Value>(opts: p.MultiSelectOptions<Value>) =>
+  prompt(() => p.multiselect<Value>(opts));
+
+/**
+ * Open a URL in the user's default browser.
+ *
+ * On Windows, uses rundll32's FileProtocolHandler — a built-in shim that
+ * opens URLs in the default browser. It accepts the URL as a direct
+ * argument (no shell, no quoting of `&`). cmd.exe `start` would treat
+ * `&` in OAuth URLs as a command separator, and `explorer.exe` treats
+ * its arg as a path.
+ */
+export const openUrl = (url: string) =>
+  Effect.gen(function* () {
+    const [cmd, args] =
+      process.platform === "win32"
+        ? (["rundll32.exe", ["url.dll,FileProtocolHandler", url]] as const)
+        : process.platform === "darwin"
+          ? (["open", [url]] as const)
+          : (["xdg-open", [url]] as const);
+    const handle = yield* ChildProcess.make(cmd, [...args], { shell: false });
+    yield* handle.exitCode;
+  }).pipe(Effect.scoped);

package/src/Util/FileLogger.ts

@@ -2,12 +2,12 @@ import * as Effect from "effect/Effect";
 import * as FileSystem from "effect/FileSystem";
 import * as Logger from "effect/Logger";
 import { Path } from "effect/Path";
-import { DotAlchemy } from "../Config.ts";
+import { AlchemyContext } from "../AlchemyContext.ts";
 
 export const fileLogger = Effect.fnUntraced(function* (
   ...segments: ReadonlyArray<string>
 ) {
-  const dotAlchemy = yield* DotAlchemy;
+  const { dotAlchemy } = yield* AlchemyContext;
   const fs = yield* FileSystem.FileSystem;
   const path = yield* Path;
   const logFile = path.join(dotAlchemy, "log", ...segments);

package/src/Util/PlatformServices.ts

@@ -1,21 +1,62 @@
-import type { BunServices } from "@effect/platform-bun/BunServices";
-import type { NodeServices } from "@effect/platform-node/NodeServices";
 import * as Effect from "effect/Effect";
+import type { FileSystem } from "effect/FileSystem";
 import * as Layer from "effect/Layer";
+import type { Path } from "effect/Path";
+import type { Teardown } from "effect/Runtime";
+import type { Stdio } from "effect/Stdio";
+import type { Terminal } from "effect/Terminal";
+import type { ChildProcessSpawner } from "effect/unstable/process/ChildProcessSpawner";
+import type { WebSocketConstructor } from "effect/unstable/socket/Socket";
 
 const isBun = typeof Bun !== "undefined";
 
-export const PlatformServices: Layer.Layer<
-  NodeServices | BunServices,
-  never,
-  never
-> = Effect.promise(() => {
+export type PlatformServices =
+  | ChildProcessSpawner
+  | FileSystem
+  | Path
+  | Stdio
+  | Terminal
+  // WebSocketConstructor is not included in NodeServices/BunServices, but required for Workers tail
+  | WebSocketConstructor;
+
+export const PlatformServices: Layer.Layer<PlatformServices> = Effect.promise(
+  async () => {
+    if (isBun) {
+      const [BunServices, BunSocket] = await Promise.all([
+        import("@effect/platform-bun/BunServices"),
+        import("@effect/platform-bun/BunSocket"),
+      ]);
+      return Layer.merge(
+        BunServices.layer,
+        BunSocket.layerWebSocketConstructor,
+      );
+    } else {
+      const [NodeServices, NodeSocket] = await Promise.all([
+        import("@effect/platform-node/NodeServices"),
+        import("@effect/platform-node/NodeSocket"),
+      ]);
+      return Layer.merge(
+        NodeServices.layer,
+        NodeSocket.layerWebSocketConstructor,
+      );
+    }
+  },
+).pipe(Layer.unwrap);
+
+export const runMain = <E, A>(
+  effect: Effect.Effect<A, E>,
+  options?: {
+    readonly disableErrorReporting?: boolean | undefined;
+    readonly teardown?: Teardown | undefined;
+  },
+): void => {
   if (isBun) {
-    return import("@effect/platform-bun").then(
-      (platform) => platform.BunServices.layer,
+    void import("@effect/platform-bun/BunRuntime").then((BunRuntime) =>
+      BunRuntime.runMain(effect, options),
+    );
+  } else {
+    void import("@effect/platform-node/NodeRuntime").then((NodeRuntime) =>
+      NodeRuntime.runMain(effect, options),
     );
   }
-  return import("@effect/platform-node").then(
-    (platform) => platform.NodeServices.layer,
-  );
-}).pipe(Layer.unwrap);
+};

package/src/index.ts

@@ -1,4 +1,5 @@
 export * as AdoptPolicy from "./AdoptPolicy.ts";
+export * from "./AlchemyContext.ts";
 export * from "./Apply.ts";
 export {
   Service as BindingService,
@@ -8,7 +9,6 @@ export {
   type PolicyLike,
   type PolicyShape,
 } from "./Binding.ts";
-export * from "./Config.ts";
 export * from "./Destroy.ts";
 export * from "./Diff.ts";
 export * from "./Input.ts";
@@ -27,6 +27,7 @@ export * as Server from "./Server/index.ts";
 export * as Serverless from "./Serverless/index.ts";
 export { Stack } from "./Stack.ts";
 export * from "./Stage.ts";
+export { inMemoryState, localState } from "./State/index.ts";
 export * from "./Trait.ts";
 
 export * as Construct from "./Construct.ts";

package/bin/process-manager.ts

@@ -1,10 +0,0 @@
-import * as NodeRuntime from "@effect/platform-node/NodeRuntime";
-import * as Effect from "effect/Effect";
-import { BunSQLite, main, NodeServices } from "../src/Daemon/RpcServer.ts";
-
-main.pipe(
-  Effect.provide(NodeServices.layer),
-  Effect.provide(BunSQLite),
-  Effect.catchTag("DaemonAlreadyRunning", (err) => Effect.logInfo(err.message)),
-  NodeRuntime.runMain,
-);

package/src/AWS/Account.ts

@@ -1,56 +0,0 @@
-import * as Auth from "@distilled.cloud/aws/Auth";
-import * as STS from "@distilled.cloud/aws/sts";
-import * as Context from "effect/Context";
-import * as Data from "effect/Data";
-import * as Effect from "effect/Effect";
-import * as Layer from "effect/Layer";
-import { StageConfig } from "./StageConfig.ts";
-
-export class FailedToGetAccount extends Data.TaggedError(
-  "AWS::Account::FailedToGetAccount",
-)<{
-  message: string;
-  cause: Error;
-}> {}
-
-export type AccountID = string;
-
-export class Account extends Context.Service<Account, AccountID>()(
-  "AWS::AccountID",
-) {}
-
-export class AWSStageConfigAccountMissing extends Data.TaggedError(
-  "AWSStageConfigAccountMissing",
-)<{
-  message: string;
-  stage: string;
-}> {}
-
-export const fromStageConfig = () =>
-  Layer.effect(
-    Account,
-    Effect.gen(function* () {
-      const config = yield* StageConfig;
-      if (config.account) {
-        return config.account;
-      }
-      const profileName = config.profile;
-      if (profileName) {
-        const profile = yield* Auth.loadProfile(profileName);
-        if (profile.sso_account_id) {
-          return profile.sso_account_id;
-        }
-      }
-      const identity = yield* STS.getCallerIdentity({}).pipe(
-        Effect.catch((err) =>
-          Effect.fail(
-            new FailedToGetAccount({
-              message: "Failed to look up account ID",
-              cause: err,
-            }),
-          ),
-        ),
-      );
-      return identity.Account!;
-    }),
-  );

package/src/AWS/Profile.ts

@@ -1,5 +0,0 @@
-import * as Context from "effect/Context";
-
-export class Profile extends Context.Service<Profile, string>()(
-  "AWS::Profile",
-) {}