alchemy 2.0.0-beta.13 → 2.0.0-beta.14

package/src/State/State.ts

@@ -9,7 +9,7 @@ export class StateStoreError extends Data.TaggedError("StateStoreError")<{
 }> {}
 
 export class State extends Context.Service<State, StateService>()(
-  "AWS::Lambda::State",
+  "alchemy/State",
 ) {}
 
 /**
@@ -21,8 +21,10 @@ export class State extends Context.Service<State, StateService>()(
  * for provider operations.
  */
 export interface StateService {
-  listStacks(): Effect.Effect<string[], StateStoreError, never>;
-  listStages(stack: string): Effect.Effect<string[], StateStoreError, never>;
+  listStacks(): Effect.Effect<readonly string[], StateStoreError, never>;
+  listStages(
+    stack: string,
+  ): Effect.Effect<readonly string[], StateStoreError, never>;
   /**
    * Get a resource by its FQN (namespace-qualified key).
    */
@@ -62,11 +64,18 @@ export interface StateService {
     stage: string;
     fqn: string;
   }): Effect.Effect<void, StateStoreError, never>;
+  /**
+   * Delete an entire stack, or a single stage when `stage` is provided.
+   */
+  deleteStack(request: {
+    stack: string;
+    stage?: string;
+  }): Effect.Effect<void, StateStoreError, never>;
   /**
    * List all resource FQNs in a stack/stage.
    */
   list(request: {
     stack: string;
     stage: string;
-  }): Effect.Effect<string[], StateStoreError, never>;
+  }): Effect.Effect<readonly string[], StateStoreError, never>;
 }

package/src/State/StateEncoding.ts

@@ -0,0 +1,83 @@
+import * as Redacted from "effect/Redacted";
+import { isResource } from "../Resource.ts";
+
+/**
+ * JSON marker used to tag a `Redacted<T>` value when writing state.
+ * The reviver recognises objects with exactly this key and rebuilds
+ * the `Redacted` wrapper on read.
+ */
+export const REDACTED_MARKER = "__redacted__";
+
+/**
+ * Recursively encode a state value for JSON serialisation.
+ *
+ * - `Redacted<T>` values are wrapped as `{ [REDACTED_MARKER]: <inner> }`
+ *   so the actual string is persisted rather than the `<redacted>`
+ *   placeholder produced by the default `toJSON`.
+ * - `Resource` instances are flattened to `{ id, type, props, attr }`
+ *   so persisted state matches the schema used by the loader.
+ * - Plain objects and arrays are walked structurally.
+ */
+export const encodeState = (value: unknown): unknown => {
+  if (value === null || value === undefined) return value;
+  if (Redacted.isRedacted(value)) {
+    return {
+      [REDACTED_MARKER]: encodeState(Redacted.value(value)),
+    };
+  }
+  if (isResource(value)) {
+    return {
+      id: value.LogicalId,
+      type: value.Type,
+      props: encodeState(value.Props),
+      attr: encodeState(value.Attributes),
+    };
+  }
+  if (Array.isArray(value)) return value.map(encodeState);
+  if (typeof value === "object") {
+    const result: Record<string, unknown> = {};
+    for (const [k, v] of Object.entries(value)) {
+      result[k] = encodeState(v);
+    }
+    return result;
+  }
+  return value;
+};
+
+/**
+ * JSON reviver that rebuilds `Redacted<T>` values that were written
+ * through {@link encodeState}. Intended for use with `JSON.parse`.
+ */
+export const reviveState = (_key: string, value: unknown): unknown => {
+  if (
+    value !== null &&
+    typeof value === "object" &&
+    !Array.isArray(value) &&
+    REDACTED_MARKER in value
+  ) {
+    return Redacted.make((value as Record<string, unknown>)[REDACTED_MARKER]);
+  }
+  return value;
+};
+
+/**
+ * Recursively walk an already-decoded value and rebuild `Redacted<T>`
+ * instances from `{ [REDACTED_MARKER]: <inner> }` envelopes. Mirror
+ * image of {@link encodeState} for callers that hold a parsed JS
+ * value rather than a JSON string (e.g. the HTTP state-store client,
+ * which receives values pre-parsed by `HttpApiClient`).
+ */
+export const reviveStateRecursive = (value: unknown): unknown => {
+  if (value === null || typeof value !== "object") return value;
+  if (Array.isArray(value)) return value.map(reviveStateRecursive);
+  const obj = value as Record<string, unknown>;
+  const keys = Object.keys(obj);
+  if (keys.length === 1 && keys[0] === REDACTED_MARKER) {
+    return Redacted.make(reviveStateRecursive(obj[REDACTED_MARKER]));
+  }
+  const result: Record<string, unknown> = {};
+  for (const [k, v] of Object.entries(obj)) {
+    result[k] = reviveStateRecursive(v);
+  }
+  return result;
+};

package/src/State/Sync.ts

@@ -0,0 +1,89 @@
+import * as Effect from "effect/Effect";
+import { type StateService } from "./State.ts";
+
+/**
+ * Synchronize all state (every stack/stage/resource) from `source` into
+ * `destination` so that `destination` becomes a mirror of `source`.
+ *
+ * For each `{ stack, stage, fqn }` present in `source`, the resource is
+ * written into `destination`, overwriting any existing entry under the same
+ * key. Any keys present in `destination` but absent from `source` are
+ * deleted, ensuring the two stores end up structurally identical.
+ *
+ * Stacks are walked sequentially; stages within a stack and resources
+ * within a stage are processed concurrently for throughput.
+ */
+export const syncState = Effect.fnUntraced(function* (
+  source: StateService,
+  destination: StateService,
+  options?: {
+    stacks?: string[];
+    /**
+     * Maximum number of resources to copy in parallel within a single stage.
+     * @default "unbounded".
+     */
+    concurrency?: number | "unbounded";
+  },
+) {
+  const concurrency = options?.concurrency ?? "unbounded";
+  const [sourceStacks, destStacks] = yield* Effect.all([
+    source.listStacks(),
+    destination.listStacks(),
+  ]);
+  const sourceStackSet = new Set(
+    sourceStacks.filter((stack) => options?.stacks?.includes(stack) ?? true),
+  );
+
+  yield* Effect.forEach(
+    sourceStacks,
+    Effect.fnUntraced(function* (stack) {
+      const [sourceStages, destStages] = yield* Effect.all([
+        source.listStages(stack),
+        destination.listStages(stack),
+      ]);
+      const stages = union(sourceStages, destStages);
+
+      yield* Effect.forEach(
+        stages,
+        Effect.fnUntraced(function* (stage) {
+          const sourceFqns = yield* source.list({ stack, stage });
+          const destFqns = yield* destination.list({ stack, stage });
+
+          const sourceSet = new Set(sourceFqns);
+          const toDelete = destFqns.filter((fqn) => !sourceSet.has(fqn));
+
+          yield* Effect.all(
+            [
+              Effect.forEach(
+                sourceFqns,
+                Effect.fnUntraced(function* (fqn) {
+                  const value = yield* source.get({ stack, stage, fqn });
+                  if (value) {
+                    yield* destination.set({ stack, stage, fqn, value });
+                  }
+                }),
+                { concurrency },
+              ),
+              Effect.forEach(
+                toDelete,
+                (fqn) => destination.delete({ stack, stage, fqn }),
+                { concurrency },
+              ),
+            ],
+            { concurrency: "unbounded" },
+          );
+        }),
+        { concurrency: "unbounded" },
+      );
+    }),
+  );
+
+  yield* Effect.forEach(
+    destStacks.filter((stack) => !sourceStackSet.has(stack)),
+    (stack) => destination.deleteStack({ stack }),
+  );
+});
+
+const union = <T>(left: Iterable<T>, right: Iterable<T>) => [
+  ...new Set([...left, ...right]),
+];

package/src/State/index.ts

@@ -1,4 +1,8 @@
+export * from "./HttpStateApi.ts";
+export * from "./HttpStateStore.ts";
 export * from "./InMemoryState.ts";
 export * from "./LocalState.ts";
 export * from "./ResourceState.ts";
 export * from "./State.ts";
+export * from "./StateEncoding.ts";
+export * from "./Sync.ts";

package/src/Test/Bun.ts

@@ -1,44 +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 { AuthProviders } from "../Auth/AuthProvider.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 { 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
   Logger.layer([Logger.consolePretty()]),
-  dotAlchemy,
+  AlchemyContextLive,
 );
 
 const run = <A>(effect: TestEffect<A>) =>
@@ -51,6 +44,7 @@ const run = <A>(effect: TestEffect<A>) =>
     );
   }).pipe(
     Effect.provideService(AuthProviders, {}),
+    Effect.provide(State.localState()),
     Effect.provide(Layer.provideMerge(alchemy, platform)),
     Effect.scoped,
     Effect.runPromise,
@@ -106,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)),
@@ -120,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(
@@ -147,75 +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.provideService(AuthProviders, {}),
-    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,6 +22,7 @@ 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 { AuthProviders } from "../Auth/AuthProvider.ts";
@@ -30,12 +31,12 @@ 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";
@@ -47,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(
@@ -70,7 +70,7 @@ type Provided =
   | Stack.Stack
   | State.State
   | Stage.Stage
-  | DotAlchemy
+  | AlchemyContext
   | HttpClient.HttpClient
   | FileSystem.FileSystem
   | Path.Path
@@ -101,7 +101,7 @@ const platform = Layer.mergeAll(
 
 const awsEnvironment = Layer.unwrap(
   Effect.gen(function* () {
-    const profileName = yield* Config.string("AWS_PROFILE").pipe(
+    const _profileName = yield* Config.string("AWS_PROFILE").pipe(
       Config.withDefault("default"),
     );
     const LOCAL = yield* Config.boolean("LOCAL").pipe(
@@ -176,8 +176,8 @@ const runWithContext = <A, Err>(
   );
 
   const alchemy = Layer.provideMerge(
-    Layer.mergeAll(options.state ?? State.LocalState, TestCli),
-    Layer.mergeAll(stack, dotAlchemy),
+    Layer.mergeAll(options.state ?? State.localState(), LoggingCli),
+    Layer.mergeAll(stack, AlchemyContextLive),
   );
 
   const context = {
@@ -357,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;
@@ -528,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/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/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/lib/Config.d.ts

@@ -1,20 +0,0 @@
-import * as Context from "effect/Context";
-import * as FileSystem from "effect/FileSystem";
-import * as Layer from "effect/Layer";
-import * as Path from "effect/Path";
-export type cwd = typeof cwd;
-/**
- * Placeholder for referencing the current working directory in module-scoped code.
- *
- * Will be replaced lazily with the actual current working directory (as provided by Effect context).
- */
-export declare const cwd: {
-    readonly type: "cwd";
-};
-export declare const isCwd: (x: any) => x is cwd;
-declare const DotAlchemy_base: Context.ServiceClass<DotAlchemy, ".alchemy", string>;
-export declare class DotAlchemy extends DotAlchemy_base {
-}
-export declare const dotAlchemy: Layer.Layer<DotAlchemy, import("effect/PlatformError").PlatformError, FileSystem.FileSystem | Path.Path>;
-export {};
-//# sourceMappingURL=Config.d.ts.map

package/lib/Config.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Config.d.ts","sourceRoot":"","sources":["../src/Config.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,OAAO,MAAM,gBAAgB,CAAC;AAE1C,OAAO,KAAK,UAAU,MAAM,mBAAmB,CAAC;AAChD,OAAO,KAAK,KAAK,MAAM,cAAc,CAAC;AACtC,OAAO,KAAK,IAAI,MAAM,aAAa,CAAC;AAEpC,MAAM,MAAM,GAAG,GAAG,OAAO,GAAG,CAAC;AAE7B;;;;GAIG;AACH,eAAO,MAAM,GAAG;;CAA2B,CAAC;AAE5C,eAAO,MAAM,KAAK,GAAI,GAAG,GAAG,KAAG,CAAC,IAAI,GAAwB,CAAC;;AAE7D,qBAAa,UAAW,SAAQ,eAE/B;CAAG;AAEJ,eAAO,MAAM,UAAU,0GAStB,CAAC"}

package/lib/Config.js

@@ -1,22 +0,0 @@
-import * as Context from "effect/Context";
-import * as Effect from "effect/Effect";
-import * as FileSystem from "effect/FileSystem";
-import * as Layer from "effect/Layer";
-import * as Path from "effect/Path";
-/**
- * Placeholder for referencing the current working directory in module-scoped code.
- *
- * Will be replaced lazily with the actual current working directory (as provided by Effect context).
- */
-export const cwd = { type: "cwd" };
-export const isCwd = (x) => x?.type === "cwd";
-export class DotAlchemy extends Context.Service()(".alchemy") {
-}
-export const dotAlchemy = Layer.effect(DotAlchemy, Effect.gen(function* () {
-    const fs = yield* FileSystem.FileSystem;
-    const path = yield* Path.Path;
-    const dir = path.join(process.cwd(), ".alchemy");
-    yield* fs.makeDirectory(dir, { recursive: true });
-    return dir;
-}));
-//# sourceMappingURL=Config.js.map

package/lib/Config.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"Config.js","sourceRoot":"","sources":["../src/Config.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,OAAO,MAAM,gBAAgB,CAAC;AAC1C,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AACxC,OAAO,KAAK,UAAU,MAAM,mBAAmB,CAAC;AAChD,OAAO,KAAK,KAAK,MAAM,cAAc,CAAC;AACtC,OAAO,KAAK,IAAI,MAAM,aAAa,CAAC;AAIpC;;;;GAIG;AACH,MAAM,CAAC,MAAM,GAAG,GAAG,EAAE,IAAI,EAAE,KAAK,EAAW,CAAC;AAE5C,MAAM,CAAC,MAAM,KAAK,GAAG,CAAC,CAAM,EAAY,EAAE,CAAC,CAAC,EAAE,IAAI,KAAK,KAAK,CAAC;AAE7D,MAAM,OAAO,UAAW,SAAQ,OAAO,CAAC,OAAO,EAAsB,CACnE,UAAU,CACX;CAAG;AAEJ,MAAM,CAAC,MAAM,UAAU,GAAG,KAAK,CAAC,MAAM,CACpC,UAAU,EACV,MAAM,CAAC,GAAG,CAAC,QAAQ,CAAC;IAClB,MAAM,EAAE,GAAG,KAAK,CAAC,CAAC,UAAU,CAAC,UAAU,CAAC;IACxC,MAAM,IAAI,GAAG,KAAK,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC;IAC9B,MAAM,GAAG,GAAG,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,GAAG,EAAE,EAAE,UAAU,CAAC,CAAC;IACjD,KAAK,CAAC,CAAC,EAAE,CAAC,aAAa,CAAC,GAAG,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;IAClD,OAAO,GAAG,CAAC;AACb,CAAC,CAAC,CACH,CAAC"}

package/lib/Observability.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=Observability.d.ts.map

package/lib/Observability.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Observability.d.ts","sourceRoot":"","sources":["../src/Observability.ts"],"names":[],"mappings":""}

package/lib/Observability.js

@@ -1 +0,0 @@
-//# sourceMappingURL=Observability.js.map

package/lib/Observability.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"Observability.js","sourceRoot":"","sources":["../src/Observability.ts"],"names":[],"mappings":""}

package/lib/Test/TestCli.d.ts

@@ -1,4 +0,0 @@
-import * as Layer from "effect/Layer";
-import { Cli } from "../Cli/Cli.ts";
-export declare const TestCli: Layer.Layer<Cli, never, never>;
-//# sourceMappingURL=TestCli.d.ts.map

package/lib/Test/TestCli.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"TestCli.d.ts","sourceRoot":"","sources":["../../src/Test/TestCli.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,KAAK,MAAM,cAAc,CAAC;AACtC,OAAO,EAAE,GAAG,EAAE,MAAM,eAAe,CAAC;AAEpC,eAAO,MAAM,OAAO,gCAgBnB,CAAC"}