alchemy-effect 0.2.0 → 0.3.0

package/src/state.ts

@@ -5,7 +5,6 @@ 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 { App } from "./app.ts";
 import type { BindNode } from "./plan.ts";
 import { isResource } from "./resource.ts";
 
@@ -75,18 +74,29 @@ export class StateStoreError extends Data.TaggedError("StateStoreError")<{
 }> {}
 
 export interface StateService {
-  listApps(): Effect.Effect<string[], StateStoreError, never>;
-  listStages(appName?: string): Effect.Effect<string[], StateStoreError, never>;
+  listStacks(): Effect.Effect<string[], StateStoreError, never>;
+  listStages(stack: string): Effect.Effect<string[], StateStoreError, never>;
   // stub
-  get(
-    id: string,
-  ): Effect.Effect<ResourceState | undefined, StateStoreError, never>;
-  set<V extends ResourceState>(
-    id: string,
-    value: V,
-  ): Effect.Effect<V, StateStoreError, never>;
-  delete(id: string): Effect.Effect<void, StateStoreError, never>;
-  list(): Effect.Effect<string[], StateStoreError, never>;
+  get(request: {
+    stack: string;
+    stage: string;
+    resourceId: string;
+  }): Effect.Effect<ResourceState | undefined, StateStoreError, never>;
+  set<V extends ResourceState>(request: {
+    stack: string;
+    stage: string;
+    resourceId: string;
+    value: V;
+  }): Effect.Effect<V, StateStoreError, never>;
+  delete(request: {
+    stack: string;
+    stage: string;
+    resourceId: string;
+  }): Effect.Effect<void, StateStoreError, never>;
+  list(request: {
+    stack: string;
+    stage: string;
+  }): Effect.Effect<string[], StateStoreError, never>;
 }
 
 export class State extends Context.Tag("AWS::Lambda::State")<
@@ -97,14 +107,12 @@ export class State extends Context.Tag("AWS::Lambda::State")<
 // TODO(sam): implement with SQLite3
 export const localFs = Layer.effect(
   State,
+  // @ts-expect-error -
   Effect.gen(function* () {
-    const app = yield* App;
     const fs = yield* FileSystem.FileSystem;
     const path = yield* Path.Path;
     const dotAlchemy = path.join(process.cwd(), ".alchemy");
     const stateDir = path.join(dotAlchemy, "state");
-    const appDir = path.join(stateDir, app.name);
-    const stageDir = path.join(appDir, app.stage);
 
     const fail = (err: PlatformError) =>
       Effect.fail(
@@ -121,9 +129,22 @@ export const localFs = Layer.effect(
         Effect.catchTag("BadArgument", (e) => fail(e)),
       );
 
-    const resourceFile = (id: string) => path.join(stageDir, `${id}.json`);
+    const stage = ({ stack, stage }: { stack: string; stage: string }) =>
+      path.join(stateDir, stack, stage);
 
-    yield* fs.makeDirectory(stageDir, { recursive: true });
+    const resource = ({
+      stack,
+      stage,
+      resourceId,
+    }: {
+      stack: string;
+      stage: string;
+      resourceId: string;
+    }) => path.join(stateDir, stack, stage, `${resourceId}.json`);
+
+    const ensure = yield* Effect.cachedFunction((dir: string) =>
+      fs.makeDirectory(dir, { recursive: true }),
+    );
 
     return {
       listApps: () =>
@@ -131,43 +152,44 @@ export const localFs = Layer.effect(
           recover,
           Effect.map((files) => files ?? []),
         ),
-      listStages: (appName: string = app.name) =>
-        fs.readDirectory(path.join(stateDir, appName)).pipe(
+      listStages: (stack: string) =>
+        fs.readDirectory(path.join(stateDir, stack)).pipe(
           recover,
           Effect.map((files) => files ?? []),
         ),
-      get: (id) =>
-        fs.readFile(resourceFile(id)).pipe(
+      get: (request) =>
+        fs.readFile(resource(request)).pipe(
           Effect.map((file) => JSON.parse(file.toString())),
           recover,
         ),
-      set: <V extends ResourceState>(id: string, value: V) =>
-        fs
-          .writeFileString(
-            resourceFile(id),
-            JSON.stringify(
-              value,
-              (k, v) => {
-                if (isResource(v)) {
-                  return {
-                    id: v.id,
-                    type: v.type,
-                    props: v.props,
-                    attr: v.attr,
-                  };
-                }
-                return v;
-              },
-              2,
+      set: (request) =>
+        ensure(stage(request)).pipe(
+          Effect.flatMap(() =>
+            fs.writeFileString(
+              resource(request),
+              JSON.stringify(
+                request.value,
+                (k, v) => {
+                  if (isResource(v)) {
+                    return {
+                      id: v.id,
+                      type: v.type,
+                      props: v.props,
+                      attr: v.attr,
+                    };
+                  }
+                  return v;
+                },
+                2,
+              ),
             ),
-          )
-          .pipe(
-            recover,
-            Effect.map(() => value),
           ),
-      delete: (id) => fs.remove(resourceFile(id)).pipe(recover),
-      list: () =>
-        fs.readDirectory(stageDir).pipe(
+          recover,
+          Effect.map(() => request.value),
+        ),
+      delete: (request) => fs.remove(resource(request)).pipe(recover),
+      list: (request) =>
+        fs.readDirectory(stage(request)).pipe(
           recover,
           Effect.map(
             (files) => files?.map((file) => file.replace(/\.json$/, "")) ?? [],
@@ -177,21 +199,77 @@ export const localFs = Layer.effect(
   }),
 );
 
-export const inMemory = () => {
-  const state = new Map<string, any>();
-  return Layer.succeed(State, {
-    listApps: () => Effect.succeed([]),
+type StackId = string;
+type StageId = string;
+type ResourceId = string;
+
+export const inMemory = (
+  initialState: Record<
+    StackId,
+    Record<StageId, Record<ResourceId, ResourceState>>
+  > = {},
+) =>
+  Layer.succeed(State, inMemoryService(initialState)) as Layer.Layer<
+    State,
+    never,
+    never
+  >;
+
+export const inMemoryService = (
+  initialState: Record<
+    StackId,
+    Record<StageId, Record<ResourceId, ResourceState>>
+  > = {},
+) => {
+  const state = new Map<StackId, Map<StageId, Map<ResourceId, ResourceState>>>(
+    Object.entries(initialState).map(([stack, stages]) => [
+      stack,
+      new Map(
+        Object.entries(stages).map(([stage, resources]) => [
+          stage,
+          new Map(Object.entries(resources)),
+        ]),
+      ),
+    ]),
+  );
+  return {
+    listStacks: () => Effect.succeed(Array.from(state.keys())),
     // oxlint-disable-next-line require-yield
-    listStages: (_appName?: string) => Effect.succeed([]),
-    get: (id: string) => Effect.succeed(state.get(id)),
-    set: <V>(id: string, value: V) => {
-      state.set(id, value);
+    listStages: (stack: string) =>
+      Effect.succeed(Array.from(state.get(stack)?.keys() ?? [])),
+    get: ({
+      stack,
+      stage,
+      resourceId,
+    }: {
+      stack: string;
+      stage: string;
+      resourceId: string;
+    }) => Effect.succeed(state.get(stack)?.get(stage)?.get(resourceId)),
+    set: <V extends ResourceState>({
+      stack,
+      stage,
+      resourceId,
+      value,
+    }: {
+      stack: string;
+      stage: string;
+      resourceId: string;
+      value: V;
+    }) => {
+      state.get(stack)?.get(stage)?.set(resourceId, value);
       return Effect.succeed(value);
     },
-    delete: (id: string) => {
-      state.delete(id);
-      return Effect.succeed(undefined);
-    },
-    list: () => Effect.succeed(Array.from(state.keys())),
-  });
+    delete: ({
+      stack,
+      stage,
+      resourceId,
+    }: {
+      stack: string;
+      stage: string;
+      resourceId: string;
+    }) => Effect.succeed(state.get(stack)?.get(stage)?.delete(resourceId)),
+    list: ({ stack, stage }: { stack: string; stage: string }) =>
+      Effect.succeed(Array.from(state.get(stack)?.get(stage)?.keys() ?? [])),
+  };
 };

package/src/test.ts

@@ -1,16 +1,41 @@
 import { FetchHttpClient, FileSystem, HttpClient } from "@effect/platform";
+import * as PlatformConfigProvider from "@effect/platform/PlatformConfigProvider";
 import { NodeContext } from "@effect/platform-node";
-import type * as Path from "@effect/platform/Path";
-import { it } from "@effect/vitest";
-import { LogLevel } from "effect";
+import * as Path from "@effect/platform/Path";
+import { it, expect } from "@effect/vitest";
+import { ConfigProvider, LogLevel } from "effect";
 import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
 import * as Logger from "effect/Logger";
 import * as Scope from "effect/Scope";
 import * as App from "./app.ts";
-import { PlanStatusReporter } from "./apply.ts";
 import { DotAlchemy, dotAlchemy } from "./dot-alchemy.ts";
 import * as State from "./state.ts";
+import type { Resource } from "./resource.ts";
+import { CLI } from "./cli/service.ts";
+
+declare module "@effect/vitest" {
+  interface ExpectStatic {
+    emptyObject(): any;
+    propExpr(identifier: string, src: Resource): any;
+  }
+}
+
+expect.emptyObject = () =>
+  expect.toSatisfy(
+    (deletions) => Object.keys(deletions).length === 0,
+    "empty object",
+  );
+
+expect.propExpr = (identifier: string, src: Resource) =>
+  expect.objectContaining({
+    kind: "PropExpr",
+    identifier,
+    expr: expect.objectContaining({
+      kind: "ResourceExpr",
+      src,
+    }),
+  });
 
 type Provided =
   | Scope.Scope
@@ -21,11 +46,34 @@ type Provided =
   | FileSystem.FileSystem
   | Path.Path;
 
+export function test(
+  name: string,
+  options: {
+    timeout?: number;
+    state?: Layer.Layer<State.State, never, App.App>;
+  },
+  testCase: Effect.Effect<void, any, Provided>,
+): void;
+
 export function test(
   name: string,
   testCase: Effect.Effect<void, any, Provided>,
-  timeout: number = 120_000,
+): void;
+
+export function test(
+  name: string,
+  ...args:
+    | [
+        {
+          timeout?: number;
+          state?: Layer.Layer<State.State, never, App.App>;
+        },
+        Effect.Effect<void, any, Provided>,
+      ]
+    | [Effect.Effect<void, any, Provided>]
 ) {
+  const [options = {}, testCase] =
+    args.length === 1 ? [undefined, args[0]] : args;
   const platform = Layer.mergeAll(
     NodeContext.layer,
     FetchHttpClient.layer,
@@ -33,9 +81,18 @@ export function test(
   );
 
   const alchemy = Layer.provideMerge(
-    Layer.mergeAll(State.localFs, report),
+    Layer.mergeAll(options.state ?? State.localFs, testCLI),
     Layer.mergeAll(
-      App.make({ name: name.replaceAll(/[^a-zA-Z0-9_]/g, "-"), stage: "test" }),
+      App.make({
+        name: name.replaceAll(/[^a-zA-Z0-9_]/g, "-"),
+        stage: "test",
+        config: {
+          adopt: true,
+          aws: {
+            profile: "default",
+          },
+        },
+      }),
       dotAlchemy,
     ),
   );
@@ -43,21 +100,66 @@ export function test(
   return it.scopedLive(
     name,
     () =>
-      testCase.pipe(
+      Effect.gen(function* () {
+        const configProvider = ConfigProvider.orElse(
+          yield* PlatformConfigProvider.fromDotEnv(".env"),
+          ConfigProvider.fromEnv,
+        );
+        return yield* testCase.pipe(Effect.withConfigProvider(configProvider));
+      }).pipe(
         Effect.provide(Layer.provideMerge(alchemy, platform)),
         Logger.withMinimumLogLevel(
           process.env.DEBUG ? LogLevel.Debug : LogLevel.Info,
         ),
+        Effect.provide(NodeContext.layer),
+        Effect.provide(NodeContext.layer),
       ),
-    timeout,
+    options.timeout,
   );
 }
 
-export const report = Layer.succeed(
-  PlanStatusReporter,
-  PlanStatusReporter.of({
-    start: Effect.fn(function* (plan) {
-      return {
+export namespace test {
+  export const state = (resources: Record<string, State.ResourceState> = {}) =>
+    Layer.effect(
+      State.State,
+      Effect.gen(function* () {
+        const app = yield* App.App;
+        return State.inMemoryService({
+          [app.name]: {
+            [app.stage]: resources,
+          },
+        });
+      }),
+    );
+
+  export const defaultState = (
+    resources: Record<string, State.ResourceState> = {},
+    other?: {
+      [stack: string]: {
+        [stage: string]: {
+          [resourceId: string]: State.ResourceState;
+        };
+      };
+    },
+  ) =>
+    Layer.succeed(
+      State.State,
+      State.inMemoryService({
+        ["test-app"]: {
+          ["test-stage"]: resources,
+        },
+        ...other,
+      }),
+    );
+}
+
+export const testCLI = Layer.succeed(
+  CLI,
+  CLI.of({
+    approvePlan: () => Effect.succeed(true),
+    displayPlan: () => Effect.void,
+    startApplySession: () =>
+      Effect.succeed({
         done: () => Effect.void,
         emit: (event) =>
           Effect.log(
@@ -65,7 +167,6 @@ export const report = Layer.succeed(
               ? `${event.status} ${event.id}(${event.type})`
               : event.message,
           ),
-      };
-    }),
+      }),
   }),
 );

package/src/type.ts

@@ -1,2 +1,6 @@
 export type type<T> = new () => T;
 export const type = class {} as new <T>() => T;
+
+export declare namespace type {
+  export type of<T extends type<any>> = InstanceType<T>;
+}

package/src/unknown.ts

@@ -0,0 +1,6 @@
+import { type Output, isOutput } from "./output.ts";
+import type { Input } from "./input.ts";
+
+// @ts-expect-error - we want to allow any value to be checked for unknown
+export const isUnknown = <V>(value: V): value is Output<Input.Resolve<V>> =>
+  isOutput(value);

package/src/user.ts

@@ -0,0 +1,4 @@
+import { env } from "./env.ts";
+
+export type USER = typeof USER;
+export const USER = env.USER ?? env.USERNAME ?? "unknown";

package/src/util.ts

@@ -0,0 +1,21 @@
+import * as Effect from "effect/Effect";
+
+export type IsAny<T> = 0 extends 1 & T ? true : false;
+
+export type UnionToIntersection<U> = (
+  U extends any ? (k: U) => void : never
+) extends (k: infer I) => void
+  ? I
+  : never;
+
+export const assertDefined = <T>(value: T | undefined, message: string): T => {
+  if (!value) {
+    throw new Error(message);
+  }
+  return value;
+};
+
+export const asEffect = <T, Err = never, Req = never>(
+  effect: T | Effect.Effect<T, Err, Req>,
+): Effect.Effect<T, Err, Req> =>
+  Effect.isEffect(effect) ? effect : Effect.succeed(effect);

package/lib/approve.d.ts

@@ -1,15 +0,0 @@
-import * as Context from "effect/Context";
-import type * as Effect from "effect/Effect";
-import type { Plan } from "./plan.ts";
-declare const PlanRejected_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => import("effect/Cause").YieldableError & {
-    readonly _tag: "PlanRejected";
-} & Readonly<A>;
-export declare class PlanRejected extends PlanRejected_base<{}> {
-}
-declare const PlanReviewer_base: Context.TagClass<PlanReviewer, "PlanReviewer", {
-    approve: <P extends Plan>(plan: P) => Effect.Effect<void, PlanRejected>;
-}>;
-export declare class PlanReviewer extends PlanReviewer_base {
-}
-export {};
-//# sourceMappingURL=approve.d.ts.map

package/lib/approve.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"approve.d.ts","sourceRoot":"","sources":["../src/approve.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,OAAO,MAAM,gBAAgB,CAAC;AAE1C,OAAO,KAAK,KAAK,MAAM,MAAM,eAAe,CAAC;AAC7C,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;;;;AAEtC,qBAAa,YAAa,SAAQ,kBAAiC,EAAE,CAAC;CAAG;;aAK5D,CAAC,CAAC,SAAS,IAAI,EAAE,IAAI,EAAE,CAAC,KAAK,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,YAAY,CAAC;;AAH3E,qBAAa,YAAa,SAAQ,iBAK/B;CAAG"}

package/lib/approve.js

@@ -1,7 +0,0 @@
-import * as Context from "effect/Context";
-import * as Data from "effect/Data";
-export class PlanRejected extends Data.TaggedError("PlanRejected") {
-}
-export class PlanReviewer extends Context.Tag("PlanReviewer")() {
-}
-//# sourceMappingURL=approve.js.map

package/lib/approve.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"approve.js","sourceRoot":"","sources":["../src/approve.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,OAAO,MAAM,gBAAgB,CAAC;AAC1C,OAAO,KAAK,IAAI,MAAM,aAAa,CAAC;AAIpC,MAAM,OAAO,YAAa,SAAQ,IAAI,CAAC,WAAW,CAAC,cAAc,CAAK;CAAG;AAEzE,MAAM,OAAO,YAAa,SAAQ,OAAO,CAAC,GAAG,CAAC,cAAc,CAAC,EAK1D;CAAG"}

package/lib/cli/approve.d.ts

@@ -1,4 +0,0 @@
-import * as Layer from "effect/Layer";
-import * as Alchemy from "alchemy-effect";
-export declare const requireApproval: Layer.Layer<Alchemy.PlanReviewer, never, never>;
-//# sourceMappingURL=approve.d.ts.map

package/lib/cli/approve.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"approve.d.ts","sourceRoot":"","sources":["../../src/cli/approve.tsx"],"names":[],"mappings":"AAIA,OAAO,KAAK,KAAK,MAAM,cAAc,CAAC;AAEtC,OAAO,KAAK,OAAO,MAAM,gBAAgB,CAAC;AAK1C,eAAO,MAAM,eAAe,iDAkB3B,CAAC"}

package/lib/cli/approve.js

@@ -1,18 +0,0 @@
-// biome-ignore lint/correctness/noUnusedImports: UMD global
-import React from "react";
-import * as Effect from "effect/Effect";
-import * as Layer from "effect/Layer";
-import * as Alchemy from "alchemy-effect";
-import { render } from "ink";
-import { ApprovePlan } from "./components/ApprovePlan.js";
-export const requireApproval = Layer.succeed(Alchemy.PlanReviewer, Alchemy.PlanReviewer.of({
-    approve: (plan) => Effect.gen(function* () {
-        let approved = false;
-        const { waitUntilExit } = render(React.createElement(ApprovePlan, { plan: plan, approve: (a) => (approved = a) }));
-        yield* Effect.promise(() => waitUntilExit());
-        if (!approved) {
-            yield* Effect.fail(new Alchemy.PlanRejected());
-        }
-    }),
-}));
-//# sourceMappingURL=approve.js.map

package/lib/cli/approve.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"approve.js","sourceRoot":"","sources":["../../src/cli/approve.tsx"],"names":[],"mappings":"AAAA,4DAA4D;AAC5D,OAAO,KAAK,MAAM,OAAO,CAAC;AAE1B,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AACxC,OAAO,KAAK,KAAK,MAAM,cAAc,CAAC;AAEtC,OAAO,KAAK,OAAO,MAAM,gBAAgB,CAAC;AAC1C,OAAO,EAAE,MAAM,EAAE,MAAM,KAAK,CAAC;AAE7B,OAAO,EAAE,WAAW,EAAE,MAAM,6BAA8B,CAAC;AAE3D,MAAM,CAAC,MAAM,eAAe,GAAG,KAAK,CAAC,OAAO,CAC1C,OAAO,CAAC,YAAY,EACpB,OAAO,CAAC,YAAY,CAAC,EAAE,CAAC;IACtB,OAAO,EAAE,CAAyB,IAAO,EAAE,EAAE,CAC3C,MAAM,CAAC,GAAG,CAAC,QAAQ,CAAC;QAClB,IAAI,QAAQ,GAAG,KAAK,CAAC;QAErB,MAAM,EAAE,aAAa,EAAE,GAAG,MAAM,CAC9B,oBAAC,WAAW,IAAC,IAAI,EAAE,IAAI,EAAE,OAAO,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,QAAQ,GAAG,CAAC,CAAC,GAAI,CAC5D,CAAC;QAEF,KAAK,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,GAAG,EAAE,CAAC,aAAa,EAAE,CAAC,CAAC;QAE7C,IAAI,CAAC,QAAQ,EAAE,CAAC;YACd,KAAK,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,OAAO,CAAC,YAAY,EAAE,CAAC,CAAC;QACjD,CAAC;IACH,CAAC,CAAC;CACL,CAAC,CACH,CAAC"}

package/lib/cli/clack.d.ts

@@ -1,14 +0,0 @@
-import * as Clack from "@clack/prompts";
-import * as Effect from "effect/Effect";
-export declare const confirm: (opts: Clack.ConfirmOptions) => Effect.Effect<boolean | symbol, never, never>;
-export declare const tasks: (tasks: Clack.Task[]) => Effect.Effect<void, never, never>;
-export declare const intro: (title?: string | undefined) => Effect.Effect<void, never, never>;
-export declare const outro: (message?: string | undefined) => Effect.Effect<void, never, never>;
-export declare const note: (message?: string | undefined, title?: string | undefined) => Effect.Effect<void, never, never>;
-export declare const spinner: (p_0?: Clack.SpinnerOptions | undefined) => Effect.Effect<{
-    start: (msg?: string) => void;
-    stop: (msg?: string, code?: number) => void;
-    message: (msg?: string) => void;
-}, never, never>;
-export declare const isCancel: typeof Clack.isCancel;
-//# sourceMappingURL=clack.d.ts.map

package/lib/cli/clack.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"clack.d.ts","sourceRoot":"","sources":["../../src/cli/clack.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,gBAAgB,CAAC;AACxC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AAYxC,eAAO,MAAM,OAAO,+EAAyB,CAAC;AAC9C,eAAO,MAAM,KAAK,4DAAuB,CAAC;AAE1C,eAAO,MAAM,KAAK,mEAAsB,CAAC;AACzC,eAAO,MAAM,KAAK,qEAAsB,CAAC;AACzC,eAAO,MAAM,IAAI,iGAAqB,CAAC;AACvC,eAAO,MAAM,OAAO;eAG2qG,CAAC;cAAiC,CAAC,cAAc,CAAC;iBAAoC,CAAC;gBAH1uG,CAAC;AAE7C,eAAO,MAAM,QAAQ,uBAAiB,CAAC"}

package/lib/cli/clack.js

@@ -1,12 +0,0 @@
-import * as Clack from "@clack/prompts";
-import * as Effect from "effect/Effect";
-const syncFn = (f) => (...p) => Effect.sync(() => f(...p));
-const asyncFn = (f) => (...p) => Effect.promise(() => f(...p));
-export const confirm = asyncFn(Clack.confirm);
-export const tasks = asyncFn(Clack.tasks);
-export const intro = syncFn(Clack.intro);
-export const outro = syncFn(Clack.outro);
-export const note = syncFn(Clack.note);
-export const spinner = syncFn(Clack.spinner);
-export const isCancel = Clack.isCancel;
-//# sourceMappingURL=clack.js.map

package/lib/cli/clack.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"clack.js","sourceRoot":"","sources":["../../src/cli/clack.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,gBAAgB,CAAC;AACxC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AAExC,MAAM,MAAM,GACV,CAAiC,CAAI,EAAE,EAAE,CACzC,CAAC,GAAG,CAAgB,EAAgC,EAAE,CACpD,MAAM,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;AAE/B,MAAM,OAAO,GACX,CAAiC,CAAI,EAAE,EAAE,CACzC,CAAC,GAAG,CAAgB,EAAyC,EAAE,CAC7D,MAAM,CAAC,OAAO,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;AAElC,MAAM,CAAC,MAAM,OAAO,GAAG,OAAO,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;AAC9C,MAAM,CAAC,MAAM,KAAK,GAAG,OAAO,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;AAE1C,MAAM,CAAC,MAAM,KAAK,GAAG,MAAM,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;AACzC,MAAM,CAAC,MAAM,KAAK,GAAG,MAAM,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;AACzC,MAAM,CAAC,MAAM,IAAI,GAAG,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;AACvC,MAAM,CAAC,MAAM,OAAO,GAAG,MAAM,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;AAE7C,MAAM,CAAC,MAAM,QAAQ,GAAG,KAAK,CAAC,QAAQ,CAAC"}

package/lib/cli/main.d.ts

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

package/lib/cli/main.d.ts.map

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

package/lib/cli/main.js

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

package/lib/cli/main.js.map

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

package/lib/cli/plan.d.ts

@@ -1,13 +0,0 @@
-export type PlanAction = "create" | "update" | "delete" | "noop";
-export interface PlanBinding {
-    id: string;
-    action: PlanAction;
-}
-export interface PlanItem {
-    id: string;
-    type: string;
-    action: PlanAction;
-    bindings?: PlanBinding[];
-}
-export type PlanSummary = Map<string, PlanItem>;
-//# sourceMappingURL=plan.d.ts.map

package/lib/cli/plan.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"plan.d.ts","sourceRoot":"","sources":["../../src/cli/plan.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,UAAU,GAAG,QAAQ,GAAG,QAAQ,GAAG,QAAQ,GAAG,MAAM,CAAC;AAEjE,MAAM,WAAW,WAAW;IAE1B,EAAE,EAAE,MAAM,CAAC;IACX,MAAM,EAAE,UAAU,CAAC;CACpB;AAED,MAAM,WAAW,QAAQ;IACvB,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,UAAU,CAAC;IACnB,QAAQ,CAAC,EAAE,WAAW,EAAE,CAAC;CAC1B;AAED,MAAM,MAAM,WAAW,GAAG,GAAG,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC"}

package/lib/cli/plan.js

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

package/lib/cli/plan.js.map

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

package/lib/cli/progress.d.ts

@@ -1,7 +0,0 @@
-import * as Alchemy from "alchemy-effect";
-import * as Layer from "effect/Layer";
-export interface ProgressEventSource {
-    subscribe(listener: (event: Alchemy.ApplyEvent) => void): () => void;
-}
-export declare const reportProgress: Layer.Layer<Alchemy.PlanStatusReporter, never, never>;
-//# sourceMappingURL=progress.d.ts.map

package/lib/cli/progress.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"progress.d.ts","sourceRoot":"","sources":["../../src/cli/progress.tsx"],"names":[],"mappings":"AAKA,OAAO,KAAK,OAAO,MAAM,gBAAgB,CAAC;AAE1C,OAAO,KAAK,KAAK,MAAM,cAAc,CAAC;AAItC,MAAM,WAAW,mBAAmB;IAClC,SAAS,CAAC,QAAQ,EAAE,CAAC,KAAK,EAAE,OAAO,CAAC,UAAU,KAAK,IAAI,GAAG,MAAM,IAAI,CAAC;CACtE;AAED,eAAO,MAAM,cAAc,uDA8B1B,CAAC"}