alchemy-effect 0.2.0 → 0.4.0

package/lib/cli/index.d.ts

@@ -1,45 +1,149 @@
 #!/usr/bin/env node
-import * as Layer from "effect/Layer";
 import * as Effect$1 from "effect/Effect";
 import { Effect } from "effect/Effect";
 import * as Context from "effect/Context";
-import "@effect/platform/FileSystem";
-import "@effect/platform/Path";
+import * as Layer from "effect/Layer";
 import * as S from "effect/Schema";
-import * as effect_Types0 from "effect/Types";
-import * as effect_Cause0 from "effect/Cause";
 import { Types } from "effect";
+import "@effect/platform/FileSystem";
+import "@effect/platform/Path";
 
-//#region src/resource.d.ts
-interface Resource<Type extends string = string, ID$1 extends string = string, Props = unknown, Attrs = unknown> {
-  id: ID$1;
-  type: Type;
-  props: Props;
-  attr: Attrs;
-  parent: unknown;
-  new (): Resource<Type, ID$1, Props, Attrs>;
+//#region src/diff.d.ts
+type Diff = NoopDiff | UpdateDiff | ReplaceDiff;
+interface NoopDiff {
+  action: "noop";
+  stables?: undefined;
 }
-interface ResourceTags<R extends Resource> {
-  of<S$1 extends ProviderService<R>>(service: S$1): S$1;
-  tag: Context.TagClass<Provider<R>, R["type"], ProviderService<R>>;
-  effect<Err, Req>(eff: Effect<ProviderService<R>, Err, Req>): Layer.Layer<Provider<R>, Err, Req>;
-  succeed(service: ProviderService<R>): Layer.Layer<Provider<R>>;
+interface UpdateDiff {
+  action: "update";
+  /** properties that won't change as part of this update */
+  stables?: string[];
 }
-declare const Resource: <Ctor extends (id: string, props: any) => Resource>(type: ReturnType<Ctor>["type"]) => Ctor & {
-  new (): ReturnType<Ctor> & {
-    parent: ReturnType<Ctor>;
+interface ReplaceDiff {
+  action: "replace";
+  deleteFirst?: boolean;
+  stables?: undefined;
+}
+//#endregion
+//#region src/data.d.ts
+type Primitive = never | undefined | null | boolean | number | string | bigint | symbol;
+//#endregion
+//#region src/state.d.ts
+type Props$1 = Record<string, any>;
+type Attr = Record<string, any>;
+type ResourceStatus = ResourceState["status"];
+interface BaseResourceState {
+  resourceType: string;
+  /** Logical ID of the Resource (stable across creates, updates, deletes and replaces) */
+  logicalId: string;
+  /** A unique randomly generated token used to seed ID generation (only changes when replaced) */
+  instanceId: string;
+  /** The version of the provider that was used to create/update the resource. */
+  providerVersion: number;
+  /** Current status of the logical Resource */
+  status: ResourceStatus;
+  /** List of logical IDs of resources that depend on this resource */
+  downstream: string[];
+  /** List of Bindings attached to this Resource */
+  bindings?: BindNode[];
+  /** Desired state (input props) of this Resource */
+  props?: Props$1;
+  /** The output attributes of this Resource (if it has been created) */
+  attr?: Attr;
+}
+interface CreatingResourceState extends BaseResourceState {
+  status: "creating";
+  /** The new resource properties that are being (or have been) applied. */
+  props: Props$1;
+}
+interface CreatedResourceState extends BaseResourceState {
+  status: "created";
+  /** The new resource properties that have been applied. */
+  props: Props$1;
+  /** The output attributes of the created resource */
+  attr: Attr;
+}
+interface UpdatingReourceState extends BaseResourceState {
+  status: "updating";
+  /** The new resource properties that are being (or have been) applied. */
+  props: Props$1;
+  old: {
+    /** The old resource properties that have been successfully applied. */
+    props: Props$1;
+    /** The old output properties that have been successfully applied. */
+    attr: Attr;
   };
-  type: ReturnType<Ctor>["type"];
-  provider: ResourceTags<ReturnType<Ctor>>;
-} & {
-  type: ReturnType<Ctor>["type"];
-  provider: ResourceTags<ReturnType<Ctor>>;
+}
+interface UpdatedResourceState extends BaseResourceState {
+  status: "updated";
+  /** The new resource properties that are being (or have been) applied. */
+  props: Props$1;
+  /** The output attributes of the created resource */
+  attr: Attr;
+}
+interface DeletingResourceState extends BaseResourceState {
+  status: "deleting";
+  /** Attributes of the resource being deleted */
+  attr: Attr | undefined;
+}
+interface ReplacingResourceState extends BaseResourceState {
+  status: "replacing";
+  /** Desired properties of the new resource (the replacement) */
+  props: Props$1;
+  /** Reference to the state of the old resource (the one being replaced) */
+  old: CreatedResourceState | UpdatedResourceState | CreatingResourceState | UpdatingReourceState | DeletingResourceState;
+  /** Whether the resource should be deleted before or after replacements */
+  deleteFirst: boolean;
+}
+interface ReplacedResourceState extends BaseResourceState {
+  status: "replaced";
+  /** Desired properties of the new resource (the replacement) */
+  props: Props$1;
+  /** Output attributes of the new resource (the replacement) */
+  attr: Attr;
+  /** Reference to the state of the old resource (the one being replaced) */
+  old: CreatingResourceState | CreatedResourceState | UpdatingReourceState | UpdatedResourceState | DeletingResourceState;
+  /** Whether the resource should be deleted before or after replacements */
+  deleteFirst: boolean;
+}
+type ResourceState = CreatingResourceState | CreatedResourceState | UpdatingReourceState | UpdatedResourceState | DeletingResourceState | ReplacingResourceState | ReplacedResourceState;
+//#endregion
+//#region src/output.d.ts
+interface Output<A = any, Src$1 extends Resource = any, Req$1 = any> {
+  readonly kind: string;
+  readonly src: Src$1;
+  readonly req: Req$1;
+  apply<B>(fn: (value: A) => B): Output.Of<B, Src$1, Req$1>;
+  effect<B, Req2$1>(fn: (value: A) => Effect$1.Effect<B, never, Req2$1>): Output.Of<B, Src$1, Req$1 | Req2$1>;
+}
+declare namespace Output {
+  type Of<A, Src$1 extends Resource = any, Req$1 = never> = [Extract<A, object>] extends [never] ? Output<A, Src$1, Req$1> : [Extract<A, any[]>] extends [never] ? Object$1<{ [attr in keyof A]: A[attr] }, Src$1, Req$1> : Array<Extract<A, any[]>, Src$1, Req$1>;
+}
+type Object$1<A, Src$1 extends Resource, Req$1 = any> = Output<A, Src$1, Req$1> & { [Prop in keyof Exclude<A, undefined>]-?: Output.Of<Exclude<A, undefined>[Prop] | Extract<A, undefined>, Src$1, Req$1> };
+type Array<A extends any[], Src$1 extends Resource, Req$1 = any> = Output<A, Src$1, Req$1> & { [i in Extract<keyof A, number>]: Output.Of<A[i], Src$1, Req$1> };
+//#endregion
+//#region src/input.d.ts
+type Function = (...args: any[]) => any;
+type Constructor = new (...args: any[]) => any;
+type PolicyLike = {
+  kind: "alchemy/Policy";
 };
+type Input<T> = T | (T extends S.Schema<any> ? never : Output<T, any, any> | (T extends Primitive ? never : T extends any[] ? number extends T["length"] ? Input<T[number]>[] : Inputs<T> : T extends object ? { [K in keyof T]: Input<T[K]> } : never));
+declare namespace Input {
+  type Resolve<T> = T extends Output<infer U> ? U : T extends Primitive | Constructor | Function | S.Schema<any> | PolicyLike ? T : T extends any[] ? ResolveArray<T> : T extends Record<string, any> ? { [k in keyof T]: Input.Resolve<T[k]> } : never;
+  type ResolveArray<T extends any[]> = number extends T["length"] ? Resolve<T[number]>[] : ResolveTuple<T>;
+  type ResolveTuple<T extends any[], Accum extends any[] = []> = T extends [infer H, ...infer Tail] ? ResolveTuple<Tail, [...Accum, Input.Resolve<H>]> : Accum;
+  type ResolveProps<Props$2 extends Record<string, any>> = { [k in keyof Props$2]: Input.Resolve<Props$2[k]> };
+  type ResolveOpaque<T> = true extends IsOut<T> ? ResolveOut<T> : Resolve<T>;
+  type IsOut<T> = T extends Output<infer U> ? true : never;
+  type ResolveOut<T> = T extends Output<infer U> ? U : never;
+}
+type Inputs<T extends any[], Out extends any[] = []> = T extends [infer H, ...infer T] ? Inputs<T, [...Out, Input<H>]> : Out;
 //#endregion
 //#region src/service.d.ts
-interface IService<ID$1 extends string = string, F extends Runtime = Runtime, Handler extends RuntimeHandler = RuntimeHandler, Props extends RuntimeProps<F, any> = RuntimeProps<F, any>, Attr = (F & {
-  props: Props;
-})["attr"]> extends Resource<F["type"], ID$1, Props, Attr> {
+interface IService<ID$1 extends string = string, F extends IRuntime = IRuntime, Handler extends RuntimeHandler = RuntimeHandler, Props$2 extends RuntimeProps<F, any> = RuntimeProps<F, any>, Attr$1 = (F & {
+  props: Props$2;
+})["attr"], Base = unknown> extends IResource<F["type"], ID$1, Props$2, Attr$1, F> {
   kind: "Service";
   type: F["type"];
   id: ID$1;
@@ -54,193 +158,146 @@ interface IService<ID$1 extends string = string, F extends Runtime = Runtime, Ha
    * An Effect that produces a handler stripped of its Infrastructure-time-only Capabilities.
    */
   handler: Effect<(...inputs: Parameters<Handler>) => Effect<Effect.Success<ReturnType<Handler>>, Effect.Error<ReturnType<Handler>>, never>, never, Exclude<Effect.Context<ReturnType<Handler>>, Capability>>;
-  props: Props;
+  props: Props$2;
   /** @internal phantom type of this resource's output attributes */
-  attr: Attr;
+  attr: Attr$1;
   /** @internal phantom type of this resource's parent */
   parent: unknown;
+  new (): Service<ID$1, F, Handler, Props$2, Attr$1, Base>;
 }
-interface Service<ID$1 extends string = string, F extends Runtime = Runtime, Handler extends RuntimeHandler = RuntimeHandler, Props extends RuntimeProps<F, any> = RuntimeProps<F, any>, Attr = (F & {
-  props: Props;
-})["attr"]> extends IService<ID$1, F, Handler, Props, Attr>, Resource<F["type"], ID$1, Props, Attr> {}
-//#endregion
-//#region src/event.d.ts
-type ApplyStatus = "pending" | "creating" | "created" | "updating" | "updated" | "deleting" | "deleted" | "success" | "fail";
-type ApplyEvent = AnnotateEvent | StatusChangeEvent;
-interface AnnotateEvent {
-  kind: "annotate";
-  id: string;
-  message: string;
-}
-interface StatusChangeEvent {
-  kind: "status-change";
-  id: string;
-  type: string;
-  status: ApplyStatus;
-  message?: string;
-  bindingId?: string;
-}
-//#endregion
-//#region src/apply.d.ts
-interface PlanStatusSession {
-  emit: (event: ApplyEvent) => Effect$1.Effect<void>;
-  done: () => Effect$1.Effect<void>;
-}
-interface ScopedPlanStatusSession extends PlanStatusSession {
-  note: (note: string) => Effect$1.Effect<void>;
-}
-declare const PlanStatusReporter_base: Context.TagClass<PlanStatusReporter, "PlanStatusReporter", {
-  start(plan: Plan): Effect$1.Effect<PlanStatusSession, never>;
-}>;
-declare class PlanStatusReporter extends PlanStatusReporter_base {}
+interface Service<ID$1 extends string = string, F extends IRuntime = IRuntime, Handler extends RuntimeHandler = RuntimeHandler, Props$2 extends RuntimeProps<F, any> = RuntimeProps<F, any>, Attr$1 = (F & {
+  props: Props$2;
+})["attr"], Base = unknown> extends IService<ID$1, F, Handler, Props$2, Attr$1, Base> {}
 //#endregion
 //#region src/provider.d.ts
-type Provider<R extends Resource> = Context.TagClass<Provider<R>, R["type"], ProviderService<R>>;
-type Diff = {
-  action: "update" | "noop";
-  deleteFirst?: undefined;
-} | {
-  action: "replace";
-  deleteFirst?: boolean;
-};
+interface Provider<R extends Resource | Service> extends Context.TagClass<Provider<R>, R["type"], ProviderService<any>> {}
 type BindingData<Res extends Resource> = [Res] extends [Runtime] ? Res["binding"][] : any[];
-interface ProviderService<Res extends Resource = Resource> {
+type Props<Res extends Resource> = Input.ResolveOpaque<Res["props"]>;
+interface ProviderService<Res extends Resource = Resource, ReadReq = never, DiffReq = never, PrecreateReq = never, CreateReq = never, UpdateReq = never, DeleteReq = never> {
+  /**
+   * The version of the provider.
+   *
+   * @default 0
+   */
+  version?: number;
   read?(input: {
     id: string;
-    olds: Res["props"] | undefined;
+    instanceId: string;
+    olds: Props<Res> | undefined;
     output: Res["attr"] | undefined;
     session: ScopedPlanStatusSession;
     bindings: BindingData<Res>;
-  }): Effect$1.Effect<Res["attr"] | undefined, any, never>;
+  }): Effect$1.Effect<Res["attr"] | undefined, any, ReadReq>;
+  /**
+   * Properties that are always stable across any update.
+   */
+  stables?: Extract<keyof Res["attr"], string>[];
   diff?(input: {
     id: string;
-    olds: Res["props"];
+    olds: Props<Res>;
+    instanceId: string;
     news: Res["props"];
     output: Res["attr"];
-  }): Effect$1.Effect<Diff | void, never, never>;
+  }): Effect$1.Effect<Diff | void, never, DiffReq>;
   precreate?(input: {
     id: string;
-    news: Res["props"];
+    news: Props<Res>;
+    instanceId: string;
     session: ScopedPlanStatusSession;
-  }): Effect$1.Effect<Res["attr"], any, never>;
+  }): Effect$1.Effect<Res["attr"], any, PrecreateReq>;
   create(input: {
     id: string;
-    news: Res["props"];
+    instanceId: string;
+    news: Props<Res>;
     session: ScopedPlanStatusSession;
     bindings: BindingData<Res>;
-  }): Effect$1.Effect<Res["attr"], any, never>;
+  }): Effect$1.Effect<Res["attr"], any, CreateReq>;
   update(input: {
     id: string;
-    news: Res["props"];
-    olds: Res["props"];
+    instanceId: string;
+    news: Props<Res>;
+    olds: Props<Res>;
     output: Res["attr"];
     session: ScopedPlanStatusSession;
     bindings: BindingData<Res>;
-  }): Effect$1.Effect<Res["attr"], any, never>;
+  }): Effect$1.Effect<Res["attr"], any, UpdateReq>;
   delete(input: {
     id: string;
-    olds: Res["props"];
+    instanceId: string;
+    olds: Props<Res>;
     output: Res["attr"];
     session: ScopedPlanStatusSession;
     bindings: BindingData<Res>;
-  }): Effect$1.Effect<void, any, never>;
+  }): Effect$1.Effect<void, any, DeleteReq>;
 }
 //#endregion
-//#region src/binding.d.ts
-type AnyBinding<F extends Runtime = any> = Binding<F, any, any, any, string, boolean>;
-interface Binding<Run extends Runtime<any, any, any>, Cap extends Capability = Capability, Props = any, Attr extends Run["binding"] = any, Tag extends string = Cap["type"], IsCustom extends boolean = (Cap["type"] extends Tag ? false : true)> {
-  runtime: Run;
-  capability: Cap;
-  tag: Tag;
-  props: Props;
-  attr: Attr;
-  isCustom: IsCustom;
-}
-/** Tag for a Service that can bind a Capability to a Runtime */
-interface Bind<F extends Runtime, Cap extends Capability, Tag extends string> extends Context.Tag<`${F["type"]}(${Cap["type"]}, ${Tag})`, BindingService<F, Extract<Extract<Cap["resource"], Resource>["parent"], Resource>, F["props"]>> {
+//#region src/resource.d.ts
+type AnyResource = Resource<string, string, any, any>;
+interface IResource<Type extends string = string, ID$1 extends string = string, Props$2 = unknown, Attrs = unknown, Base = unknown> {
+  id: ID$1;
+  type: Type;
+  Props: unknown;
+  props: Props$2;
+  base: Base;
   /** @internal phantom */
-  name: Tag;
+  attr: Attrs;
 }
-declare const Binding: {
-  <F extends (resource: any, props?: any) => AnyBinding & {
-    isCustom: true;
-  }>(runtime: ReturnType<F>["runtime"], type: ReturnType<F>["capability"]["type"], tag: ReturnType<F>["tag"]): F & BindingDeclaration<ReturnType<F>["runtime"], F>;
-  <F extends (resource: any, props?: any) => AnyBinding & {
-    isCustom: false;
-  }>(runtime: ReturnType<F>["runtime"], type: ReturnType<F>["capability"]["type"]): F & BindingDeclaration<ReturnType<F>["runtime"], F>;
-};
-interface BindingDeclaration<Run extends Runtime, F extends (target: any, props?: any) => AnyBinding<Run>, Tag extends string = ReturnType<F>["tag"], Cap extends Capability = ReturnType<F>["capability"]> {
-  provider: {
-    effect<Err, Req>(eff: Effect<BindingService<Run, Parameters<F>[0], Parameters<F>[1], ReturnType<F>["attr"]>, Err, Req>): Layer.Layer<Bind<Run, Cap, Tag>, Err, Req>;
-    succeed(service: BindingService<Run, Parameters<F>[0], Parameters<F>[1], ReturnType<F>["attr"]>): Layer.Layer<Bind<Run, Cap, Tag>>;
-  };
+interface Resource<Type extends string = string, ID$1 extends string = string, Props$2 = unknown, Attrs = unknown, Base = unknown> extends IResource<Type, ID$1, Props$2, Attrs, Base> {
+  new (): Resource<Type, ID$1, Props$2, Attrs, Base>;
 }
-interface BindingDiffProps<Source extends Resource = Resource, Target extends Resource = Resource, Props = any, Attr = any> {
-  source: {
-    id: string;
-    props: Source["props"];
-    oldProps?: Source["props"];
-    oldAttr?: Source["attr"];
-  };
-  props: Props;
-  attr: Attr | undefined;
-  target: {
-    id: string;
-    props: Target["props"];
-    oldProps?: Target["props"];
-    oldAttr?: Target["attr"];
-  };
+interface ResourceTags<R extends Resource<string, string, any, any>> {
+  of<S$1 extends ProviderService<R>>(service: S$1): S$1;
+  tag: Provider<R>;
+  effect<Err, Req$1, ReadReq = never, DiffReq = never, PrecreateReq = never, CreateReq = never, UpdateReq = never, DeleteReq = never>(eff: Effect<ProviderService<R, ReadReq, DiffReq, PrecreateReq, CreateReq, UpdateReq, DeleteReq>, Err, Req$1>): Layer.Layer<Provider<R>, Err, Req$1 | ReadReq | DiffReq | PrecreateReq | CreateReq | UpdateReq | DeleteReq>;
+  succeed<ReadReq = never, DiffReq = never, PrecreateReq = never, CreateReq = never, UpdateReq = never, DeleteReq = never>(service: ProviderService<R, ReadReq, DiffReq, PrecreateReq, CreateReq, UpdateReq, DeleteReq>): Layer.Layer<Provider<R>, never, ReadReq | DiffReq | PrecreateReq | CreateReq | UpdateReq | DeleteReq>;
 }
-interface BindingAttachProps<Source extends Resource, Target extends Resource, Props, Attr> {
-  source: {
-    id: string;
-    attr: Source["attr"];
-    props: Source["props"];
-  };
-  props: Props;
-  attr: Attr | undefined;
-  target: {
-    id: string;
-    props: Target["props"];
-    attr: Target["attr"];
+declare const Resource: <Ctor extends (id: string, props: any) => Resource>(type: ReturnType<Ctor>["type"]) => Ctor & {
+  new (): ReturnType<Ctor> & {
+    parent: ReturnType<Ctor>;
   };
+  type: ReturnType<Ctor>["type"];
+  parent: ReturnType<Ctor>;
+  provider: ResourceTags<ReturnType<Ctor>>;
+} & {
+  type: ReturnType<Ctor>["type"];
+  provider: ResourceTags<ReturnType<Ctor>>;
+};
+//#endregion
+//#region src/runtime.d.ts
+type RuntimeHandler<Inputs$1 extends any[] = any[], Output$1 = any, Err = any, Req$1 = any> = (...inputs: Inputs$1) => Effect$1.Effect<Output$1, Err, Req$1>;
+declare namespace RuntimeHandler {
+  type Caps<H$1 extends RuntimeHandler | unknown> = Extract<Effect$1.Effect.Context<ReturnType<Extract<H$1, RuntimeHandler>>>, Capability>;
 }
-interface BindingReattachProps<Source extends Resource, Target extends Resource, Props, Attr> {
-  source: {
-    id: string;
-    attr: Source["attr"];
-    props: Source["props"];
-  };
-  props: Props;
-  attr: Attr;
-  target: {
-    id: string;
-    props: Target["props"];
-    attr: Target["attr"];
+declare namespace Runtime {
+  type Binding<F, Cap> = F extends {
+    readonly Binding: unknown;
+  } ? (F & {
+    readonly cap: Cap;
+  })["Binding"] : {
+    readonly F: F;
+    readonly cap: Types.Contravariant<Cap>;
   };
 }
-interface BindingDetachProps<Source extends Resource, Target extends Resource, Props, Attr> {
-  source: {
-    id: string;
-    attr: Source["attr"];
-    props: Source["props"];
-  };
-  props: Props;
-  attr: Attr | undefined;
-  target: {
-    id: string;
-    props: Target["props"];
-    attr: Target["attr"];
-  };
+interface RuntimeProps<Run extends IRuntime, Req$1> {
+  bindings: Policy<Run, Extract<Req$1, Capability>, unknown>;
 }
-type BindingService<Target extends Runtime = any, Source extends Resource = Resource, Props = any, Attr extends Target["binding"] = any, DiffReq = never, PreReattachReq = never, AttachReq = never, ReattachReq = never, DetachReq = never, PostAttachReq = never> = {
-  diff?: (props: BindingDiffProps<Source, Target, Props>) => Effect<Diff, never, DiffReq>;
-  preattach?: (props: BindingAttachProps<Source, Target, Props, Attr>) => Effect<Partial<Target["attr"]>, never, PreReattachReq>;
-  attach: (props: BindingAttachProps<Source, Target, Props, Attr>) => Effect<Attr, never, AttachReq> | Attr;
-  postattach?: (props: BindingAttachProps<Source, Target, Props, Attr>) => Effect<Omit<Attr, keyof Target["binding"]>, never, PostAttachReq>;
-  reattach?: (props: BindingReattachProps<Source, Target, Props, Attr>) => Effect<Attr, never, ReattachReq> | Attr;
-  detach?: (props: BindingDetachProps<Source, Target, Props, Attr>) => Effect<void, never, DetachReq> | void;
-};
+interface IRuntime<Type extends string = string, Handler = unknown, Props$2 = unknown> extends IResource<Type, string, Props$2> {
+  type: Type;
+  props: Props$2;
+  handler: Handler;
+  binding: unknown;
+  /** @internal phantom */
+  capability: unknown;
+}
+interface Runtime<Type extends string = string, Handler = unknown, Props$2 = unknown> extends IRuntime<Type, Handler, Props$2>, Resource<Type, string, Props$2> {
+  provider: ResourceTags<this>;
+  <const ID$1 extends string, Inputs$1 extends any[], Output$1, Err, Req$1, Handler extends RuntimeHandler<Inputs$1, Output$1, Err, Req$1>>(id: ID$1, {
+    handle
+  }: {
+    handle: Handler;
+  }): <const Props$2 extends this["props"]>(props: Props$2) => Service<ID$1, this, Handler, Props$2>;
+}
+declare const Runtime: <const Type extends string>(type: Type) => <Self extends Runtime>() => Self;
 //#endregion
 //#region src/policy.d.ts
 /**
@@ -252,7 +309,8 @@ type BindingService<Target extends Runtime = any, Source extends Resource = Reso
  *
  * A Policy is invariant over the set of Capabilities to ensure least-privilege.
  */
-interface Policy<F extends Runtime, in out Capabilities, Tags = unknown> {
+interface Policy<F extends IRuntime, in out Capabilities, Tags = unknown> {
+  readonly kind: "alchemy/Policy";
   readonly runtime: F;
   readonly tags: Tags[];
   readonly capabilities: Capabilities[];
@@ -300,9 +358,9 @@ declare namespace Capability {
     resource: c["resource"];
     constraint: Constraint.Simplify<c["constraint"]>;
   })["Reduce"] : never;
-  type KeysWithNever<T> = { [K in keyof T]: T[K] extends never | Policy.AnyOf<never> ? K : never }[keyof T];
+  type KeysWithNever<T> = { [K in keyof T]: T[K$1] extends never | Policy.AnyOf<never> ? K$1 : never }[keyof T];
   type DropIrrelevant<T> = T extends any ? { [k in keyof Omit<T, KeysWithNever<T>>]: Omit<T, KeysWithNever<T>>[k] } : never;
-  type Get<T, K extends string | number | symbol> = T extends { [k in K]: infer V } ? V : never;
+  type Get<T, K$1 extends string | number | symbol> = T extends { [k in K$1]: infer V } ? V : never;
   type Keys<T> = T extends any ? keyof T : never;
   type BoxPolicy<T> = [T] extends [{
     anyOf: (infer U)[];
@@ -312,44 +370,102 @@ declare namespace Capability {
   }
 }
 //#endregion
-//#region src/runtime.d.ts
-type RuntimeHandler<Inputs extends any[] = any[], Output = any, Err = any, Req = any> = (...inputs: Inputs) => Effect$1.Effect<Output, Err, Req>;
-declare namespace RuntimeHandler {
-  type Caps<H extends RuntimeHandler | unknown> = Extract<Effect$1.Effect.Context<ReturnType<Extract<H, RuntimeHandler>>>, Capability>;
+//#region src/binding.d.ts
+type AnyBinding<F extends IRuntime = any> = Binding<F, any, any, any, string, boolean>;
+interface Binding<Run extends IRuntime<any, any, any>, Cap extends Capability = Capability, Props$2 = any, Attr$1 extends Run["binding"] = any, Tag extends string = Cap["type"], IsCustom extends boolean = (Cap["type"] extends Tag ? false : true)> {
+  runtime: Run;
+  capability: Cap;
+  tag: Tag;
+  props: Props$2;
+  attr: Attr$1;
+  isCustom: IsCustom;
 }
-declare namespace Runtime {
-  type Binding<F, Cap> = F extends {
-    readonly Binding: unknown;
-  } ? (F & {
-    readonly cap: Cap;
-  })["Binding"] : {
-    readonly F: F;
-    readonly cap: Types.Contravariant<Cap>;
+/** Tag for a Service that can bind a Capability to a Runtime */
+interface Bind<F extends IRuntime, Cap extends Capability, Tag extends string> extends Context.Tag<`${F["type"]}(${Cap["type"]}, ${Tag})`, BindingService<F, Extract<Extract<Cap["resource"], Resource>["base"], Resource>, F["props"]>> {
+  /** @internal phantom */
+  name: Tag;
+}
+declare const Binding: {
+  <F extends (resource: any, props?: any) => AnyBinding & {
+    isCustom: true;
+  }>(runtime: ReturnType<F>["runtime"], type: ReturnType<F>["capability"]["type"], tag: ReturnType<F>["tag"]): F & BindingDeclaration<ReturnType<F>["runtime"], F>;
+  <F extends (resource: any, props?: any) => AnyBinding & {
+    isCustom: false;
+  }>(runtime: ReturnType<F>["runtime"], type: ReturnType<F>["capability"]["type"]): F & BindingDeclaration<ReturnType<F>["runtime"], F>;
+};
+interface BindingDeclaration<Run extends IRuntime, F extends (target: any, props?: any) => AnyBinding<Run>, Tag extends string = ReturnType<F>["tag"], Cap extends Capability = ReturnType<F>["capability"]> {
+  provider: {
+    effect<Err, Req$1>(eff: Effect<BindingService<Run, Parameters<F>[0], Parameters<F>[1], ReturnType<F>["attr"]>, Err, Req$1>): Layer.Layer<Bind<Run, Cap, Tag>, Err, Req$1>;
+    succeed(service: BindingService<Run, Parameters<F>[0], Parameters<F>[1], ReturnType<F>["attr"]>): Layer.Layer<Bind<Run, Cap, Tag>>;
   };
 }
-interface RuntimeProps<Run extends Runtime, Req> {
-  bindings: Policy<Run, Extract<Req, Capability>, unknown>;
+interface BindingDiffProps<Source extends IResource = IResource, Target extends IResource = IResource, Props$2 = any, Attr$1 = any> {
+  source: {
+    id: string;
+    props: Source["props"];
+    oldProps?: Source["props"];
+    oldAttr?: Source["attr"];
+  };
+  props: Props$2;
+  attr: Attr$1 | undefined;
+  target: {
+    id: string;
+    props: Target["props"];
+    oldProps?: Target["props"];
+    oldAttr?: Target["attr"];
+  };
 }
-interface Runtime<Type extends string = string, Handler = unknown, Props = unknown> extends Resource<Type, string, Props, unknown> {
-  type: Type;
-  props: Props;
-  handler: Handler;
-  binding: unknown;
-  /** @internal phantom */
-  capability: unknown;
-  <const ID$1 extends string, Inputs extends any[], Output, Err, Req, Handler extends RuntimeHandler<Inputs, Output, Err, Req>>(id: ID$1, {
-    handle
-  }: {
-    handle: Handler;
-  }): <const Props extends this["props"]>(props: Props) => Service<ID$1, this, Handler, Props>;
+interface BindingAttachProps<Source extends IResource, Target extends IResource, Props$2, Attr$1> {
+  source: {
+    id: string;
+    attr: Source["attr"];
+    props: Source["props"];
+  };
+  props: Props$2;
+  attr: Attr$1 | undefined;
+  target: {
+    id: string;
+    props: Target["props"];
+    attr: Target["attr"];
+  };
+}
+interface BindingReattachProps<Source extends IResource, Target extends IResource, Props$2, Attr$1> {
+  source: {
+    id: string;
+    attr: Source["attr"];
+    props: Source["props"];
+  };
+  props: Props$2;
+  attr: Attr$1;
+  target: {
+    id: string;
+    props: Target["props"];
+    attr: Target["attr"];
+  };
 }
-declare const Runtime: <const Type extends string>(type: Type) => <Self extends Runtime>() => Self & {
-  provider: ResourceTags<Self>;
+interface BindingDetachProps<Source extends IResource, Target extends IResource, Props$2, Attr$1> {
+  source: {
+    id: string;
+    attr: Source["attr"];
+    props: Source["props"];
+  };
+  props: Props$2;
+  attr: Attr$1 | undefined;
+  target: {
+    id: string;
+    props: Target["props"];
+    attr: Target["attr"];
+  };
+}
+type BindingService<Target extends IRuntime = any, Source extends IResource = IResource, Props$2 = any, Attr$1 extends Target["binding"] = any, DiffReq = never, PreReattachReq = never, AttachReq = never, ReattachReq = never, DetachReq = never, PostAttachReq = never> = {
+  diff?: (props: BindingDiffProps<Source, Target, Props$2>) => Effect<Diff, never, DiffReq>;
+  preattach?: (props: BindingAttachProps<Source, Target, Props$2, Attr$1>) => Effect<Partial<Target["attr"]>, never, PreReattachReq>;
+  attach: (props: BindingAttachProps<Source, Target, Props$2, Attr$1>) => Effect<Attr$1, never, AttachReq> | Attr$1;
+  postattach?: (props: BindingAttachProps<Source, Target, Props$2, Attr$1>) => Effect<Omit<Attr$1, keyof Target["binding"]>, never, PostAttachReq>;
+  reattach?: (props: BindingReattachProps<Source, Target, Props$2, Attr$1>) => Effect<Attr$1, never, ReattachReq> | Attr$1;
+  detach?: (props: BindingDetachProps<Source, Target, Props$2, Attr$1>) => Effect<void, never, DetachReq> | void;
 };
 //#endregion
-//#region src/phase.d.ts
-type Phase = "update" | "destroy";
-//#endregion
 //#region src/plan.d.ts
 /**
  * A node in the plan that represents a binding operation acting on a resource.
@@ -377,73 +493,77 @@ type NoopBind<B extends AnyBinding = AnyBinding> = {
   binding: B;
   attr: B["attr"];
 };
-/**
- * A node in the plan that represents a resource CRUD operation.
- */
-type CRUD<R extends Resource = Resource> = Create<R> | Update<R> | Delete<R> | Replace<R> | NoopUpdate<R>;
-type Create<R extends Resource> = {
-  action: "create";
+type Apply<R extends Resource = AnyResource> = Create<R> | Update<R> | Replace<R> | NoopUpdate<R>;
+interface BaseNode<R extends Resource = AnyResource> {
   resource: R;
-  news: any;
-  provider: ProviderService;
-  attributes: R["attr"];
+  provider: ProviderService<R>;
   bindings: BindNode[];
-};
-type Update<R extends Resource> = {
+  downstream: string[];
+}
+interface Create<R extends Resource = AnyResource> extends BaseNode<R> {
+  action: "create";
+  props: any;
+  state: CreatingResourceState | undefined;
+}
+interface Update<R extends Resource = AnyResource> extends BaseNode<R> {
   action: "update";
-  resource: R;
-  olds: any;
-  news: any;
-  output: any;
-  provider: ProviderService;
-  attributes: R["attr"];
-  bindings: BindNode[];
-};
-type Delete<R extends Resource> = {
+  props: any;
+  state: CreatedResourceState | UpdatedResourceState | UpdatingReourceState | ReplacedResourceState;
+}
+interface Delete<R extends Resource = AnyResource> extends BaseNode<R> {
   action: "delete";
-  resource: R;
-  olds: any;
-  output: any;
-  provider: ProviderService;
-  bindings: BindNode[];
-  attributes: R["attr"];
-  downstream: string[];
-};
-type NoopUpdate<R extends Resource> = {
+  state: ResourceState;
+}
+interface NoopUpdate<R extends Resource = AnyResource> extends BaseNode<R> {
   action: "noop";
-  resource: R;
-  attributes: R["attr"];
-  bindings: BindNode[];
-};
-type Replace<R extends Resource> = {
+  state: CreatedResourceState | UpdatedResourceState;
+}
+interface Replace<R extends Resource = AnyResource> extends BaseNode<R> {
   action: "replace";
-  resource: R;
-  olds: any;
-  news: any;
-  output: any;
-  provider: ProviderService;
-  bindings: BindNode[];
-  attributes: R["attr"];
-  deleteFirst?: boolean;
-};
-type Plan = {
-  phase: Phase;
-  resources: { [id in string]: CRUD };
+  props: any;
+  deleteFirst: boolean;
+  state: CreatingResourceState | CreatedResourceState | UpdatingReourceState | UpdatedResourceState | ReplacingResourceState | ReplacedResourceState;
+}
+type IPlan = {
+  resources: { [id in string]: Apply<any> };
   deletions: { [id in string]?: Delete<Resource> };
 };
 //#endregion
-//#region src/approve.d.ts
-declare const PlanRejected_base: new <A extends Record<string, any> = {}>(args: effect_Types0.Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }) => effect_Cause0.YieldableError & {
-  readonly _tag: "PlanRejected";
-} & Readonly<A>;
-declare class PlanRejected extends PlanRejected_base<{}> {}
-declare const PlanReviewer_base: Context.TagClass<PlanReviewer, "PlanReviewer", {
-  approve: <P$1 extends Plan>(plan: P$1) => Effect$1.Effect<void, PlanRejected>;
-}>;
-declare class PlanReviewer extends PlanReviewer_base {}
+//#region src/event.d.ts
+type ApplyStatus = "attaching" | "post-attach" | "pending" | "pre-creating" | "creating" | "creating replacement" | "created" | "updating" | "updated" | "deleting" | "deleted" | "replacing" | "replaced" | "success" | "fail";
+type ApplyEvent = AnnotateEvent | StatusChangeEvent;
+interface AnnotateEvent {
+  kind: "annotate";
+  id: string;
+  message: string;
+}
+interface StatusChangeEvent {
+  kind: "status-change";
+  id: string;
+  type: string;
+  status: ApplyStatus;
+  message?: string;
+  bindingId?: string;
+}
+//#endregion
+//#region src/cli/service.d.ts
+interface PlanStatusSession {
+  emit: (event: ApplyEvent) => Effect$1.Effect<void>;
+  done: () => Effect$1.Effect<void>;
+}
+interface ScopedPlanStatusSession extends PlanStatusSession {
+  note: (note: string) => Effect$1.Effect<void>;
+}
+interface CLIService {
+  approvePlan: <P$1 extends IPlan>(plan: P$1) => Effect$1.Effect<boolean>;
+  displayPlan: <P$1 extends IPlan>(plan: P$1) => Effect$1.Effect<void>;
+  startApplySession: <P$1 extends IPlan>(plan: P$1) => Effect$1.Effect<PlanStatusSession>;
+}
+declare const CLI_base: Context.TagClass<CLI, "CLIService", CLIService>;
+declare class CLI extends CLI_base {}
 //#endregion
-//#region src/cli/index.d.ts
-declare const layer: Layer.Layer<PlanReviewer | PlanStatusReporter, never, never>;
+//#region src/cli/ink-service.d.ts
+declare const inkCLI: () => Layer.Layer<CLI, never, never>;
 //#endregion
-export { layer };
+export { CLI, CLIService, PlanStatusSession, ScopedPlanStatusSession, inkCLI };
 //# sourceMappingURL=index.d.ts.map