alchemy-effect 0.5.0 → 0.6.2

package/lib/cli/index.d.ts

@@ -1,39 +1,100 @@
 #!/usr/bin/env node
 import * as Effect$1 from "effect/Effect";
-import { Effect } from "effect/Effect";
-import * as Context from "effect/Context";
+import { Effect, Yieldable } from "effect/Effect";
+import * as ServiceMap from "effect/ServiceMap";
 import * as Layer from "effect/Layer";
+import * as Stream from "effect/Stream";
 import * as S from "effect/Schema";
-import { Types } from "effect";
-import "@effect/platform/FileSystem";
-import "@effect/platform/Path";
+import { Pipeable } from "effect/Pipeable";
+import { Scope } from "effect/Scope";
+import { HttpBodyError } from "effect/unstable/http/HttpBody";
+import { HttpServerError } from "effect/unstable/http/HttpServerError";
+import { HttpServerRequest } from "effect/unstable/http/HttpServerRequest";
+import * as HttpServerResponse from "effect/unstable/http/HttpServerResponse";
+import "effect/FileSystem";
+import "effect/Path";
 
-//#region src/diff.d.ts
-type Diff = NoopDiff | UpdateDiff | ReplaceDiff;
-interface NoopDiff {
-  action: "noop";
-  stables?: undefined;
+//#region src/Util/data.d.ts
+type Primitive = never | undefined | null | boolean | number | string | bigint | symbol;
+//#endregion
+//#region src/Http.d.ts
+type HttpEffect<Req$1 = never> = Effect$1.Effect<HttpServerResponse.HttpServerResponse, HttpServerError | HttpBodyError, HttpServerRequest | Scope | Req$1>;
+//#endregion
+//#region src/ExecutionContext.d.ts
+interface BaseExecutionContext {
+  Type: string;
+  id: string;
+  env: Record<string, any>;
+  get<T>(key: string): Effect$1.Effect<T>;
+  set(id: string, output: Output): Effect$1.Effect<string>;
+  exports?: Effect$1.Effect<Record<string, any>>;
+  serve?<Req$1 = never>(handler: HttpEffect<Req$1>): Effect$1.Effect<void, never, Req$1>;
+}
+interface ExecutionContext<Ctx extends BaseExecutionContext = BaseExecutionContext> extends ServiceMap.Service<`ExecutionContext<${Ctx["Type"]}>`, Ctx> {}
+declare const ExecutionContext: ExecutionContext<BaseExecutionContext> & (<Ctx extends BaseExecutionContext>(type: Ctx["Type"]) => ExecutionContext<Ctx>);
+//#endregion
+//#region src/Namespace.d.ts
+interface NamespaceNode {
+  Id: string;
+  Parent?: NamespaceNode;
 }
-interface UpdateDiff {
-  action: "update";
-  /** properties that won't change as part of this update */
-  stables?: string[];
+//#endregion
+//#region src/RemovalPolicy.d.ts
+declare const RemovalPolicy_base: ServiceMap.ServiceClass<RemovalPolicy, "RemovalPolicy", "retain" | "destroy">;
+declare class RemovalPolicy extends RemovalPolicy_base {}
+//#endregion
+//#region src/Resource.d.ts
+type LogicalId = string;
+interface ResourceBinding<Data = any> {
+  sid: string;
+  data: Data;
 }
-interface ReplaceDiff {
-  action: "replace";
-  deleteFirst?: boolean;
-  stables?: undefined;
+interface ResourceLike<Type extends string = string, Props$2 extends object | undefined = any, Attributes$1 extends object = object, Binding = any> {
+  /**
+   * Namespace containing this Resource.
+   */
+  Namespace: NamespaceNode | undefined;
+  /**
+   * Fully Qualified Name (namespace path + logical ID).
+   * Used as the unique key for state storage.
+   */
+  FQN: string;
+  /**
+   * Type of the Resource (e.g. AWS.Lambda.Function)
+   */
+  Type: Type;
+  /**
+   * Logical ID of the Resource (e.g. MyFunction)
+   */
+  LogicalId: LogicalId;
+  /**
+   * Properties of the Resource.
+   */
+  Props: Props$2;
+  /**
+   * Removal Policy of the Resource.
+   */
+  RemovalPolicy: RemovalPolicy["Service"];
+  /** @internal phantom */
+  Attributes: Attributes$1;
+  /** @internal phantom */
+  Binding: Binding;
 }
 //#endregion
-//#region src/data.d.ts
-type Primitive = never | undefined | null | boolean | number | string | bigint | symbol;
-//#endregion
-//#region src/state.d.ts
+//#region src/State/ResourceState.d.ts
+type ResourceState = CreatingResourceState | CreatedResourceState | UpdatingReourceState | UpdatedResourceState | DeletingResourceState | ReplacingResourceState | ReplacedResourceState;
 type Props$1 = Record<string, any>;
 type Attr = Record<string, any>;
 type ResourceStatus = ResourceState["status"];
+type ReplacementResourceState = ReplacingResourceState | ReplacedResourceState;
+type ReplacementOldResourceState = CreatingResourceState | CreatedResourceState | UpdatingReourceState | UpdatedResourceState | DeletingResourceState | ReplacementResourceState;
 interface BaseResourceState {
+  /** Type of the Resource (e.g. AWS.Lambda.Function) */
   resourceType: string;
+  /** Namespace of the Resource */
+  namespace: NamespaceNode | undefined;
+  /** Fully Qualified Name (namespace path + logical ID) */
+  fqn: 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) */
@@ -42,14 +103,16 @@ interface BaseResourceState {
   providerVersion: number;
   /** Current status of the logical Resource */
   status: ResourceStatus;
-  /** List of logical IDs of resources that depend on this resource */
+  /** List of FQNs of resources that depend on this resource */
   downstream: string[];
   /** List of Bindings attached to this Resource */
-  bindings?: BindNode[];
+  bindings: ResourceBinding[];
   /** Desired state (input props) of this Resource */
   props?: Props$1;
   /** The output attributes of this Resource (if it has been created) */
   attr?: Attr;
+  /** The removal policy of the resource */
+  removalPolicy?: RemovalPolicy["Service"];
 }
 interface CreatingResourceState extends BaseResourceState {
   status: "creating";
@@ -70,6 +133,8 @@ interface UpdatingReourceState extends BaseResourceState {
   old: {
     /** The old resource properties that have been successfully applied. */
     props: Props$1;
+    /** List of Bindings attached to this Resource */
+    bindings: any[];
     /** The old output properties that have been successfully applied. */
     attr: Attr;
   };
@@ -91,7 +156,7 @@ interface ReplacingResourceState extends BaseResourceState {
   /** 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;
+  old: ReplacementOldResourceState;
   /** Whether the resource should be deleted before or after replacements */
   deleteFirst: boolean;
 }
@@ -102,439 +167,203 @@ interface ReplacedResourceState extends BaseResourceState {
   /** 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;
+  old: ReplacementOldResourceState;
   /** 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> {
+//#region src/Output.d.ts
+interface Output<A = any, Req$1 = any> extends Pipeable {
+  /** @internal phantom */
   readonly kind: string;
-  readonly src: Src$1;
+  /** @internal phantom */
+  readonly A: A;
+  /** @internal phantom */
   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>;
+  /** @internal phantom */
+  [Symbol.iterator](): Iterator<Yieldable<any, void, never, Req$1>, Accessor<A>, void>;
+  bind(id: string): Effect$1.Effect<Effect$1.Effect<A>, never, ExecutionContext>;
+  asEffect(): Effect$1.Effect<Accessor<A>, never, 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> };
+interface Accessor<A> extends Effect$1.Effect<A> {}
 //#endregion
-//#region src/input.d.ts
+//#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));
+type Input<T> = T | Output<T> | Effect<T, any, any> | (T extends S.Schema<any> ? never : Output<T, 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 Resolve<T> = T extends {
+    Type: string;
+    Attributes: infer Attributes;
+  } ? { [K in keyof Attributes]: Resolve<Attributes[K]> } : 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 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 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;
-  runtime: F;
-  /**
-   * The raw handler function as passed in to the Runtime.
-   *
-   * @internal phantom type
-   */
-  impl: Handler;
-  /**
-   * 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$2;
-  /** @internal phantom type of this resource's output attributes */
-  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 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> {}
+//#region src/Diff.d.ts
+type Diff = NoopDiff | UpdateDiff | ReplaceDiff;
+interface NoopDiff {
+  action: "noop";
+  stables?: undefined;
+}
+interface UpdateDiff {
+  action: "update";
+  /** properties that won't change as part of this update */
+  stables?: string[];
+}
+interface ReplaceDiff {
+  action: "replace";
+  deleteFirst?: boolean;
+  stables?: undefined;
+}
 //#endregion
-//#region src/provider.d.ts
-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[];
-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> {
+//#region src/Provider.d.ts
+type BindingData<Res extends ResourceLike> = [Res] extends [{
+  Binding: infer B;
+}] ? ResourceBinding<B>[] : any[];
+type Props<Res extends ResourceLike> = keyof Res["Props"] extends never ? Res["Props"] | undefined : Res["Props"];
+interface LogLine {
+  timestamp: Date;
+  message: string;
+}
+interface LogsInput {
+  since?: Date;
+  limit?: number;
+}
+interface ProviderService<Res extends ResourceLike = ResourceLike, ReadReq = never, DiffReq = never, PrecreateReq = never, CreateReq = never, UpdateReq = never, DeleteReq = never, TailReq = never, LogsReq = never> {
   /**
    * The version of the provider.
    *
    * @default 0
    */
   version?: number;
+  /**
+   * Returns a stream of log lines for a deployed resource.
+   * Used by `alchemy tail` to stream real-time logs.
+   */
+  tail?(input: {
+    id: string;
+    instanceId: string;
+    props: Props<Res>;
+    output: Res["Attributes"];
+  }): Stream.Stream<LogLine, any, TailReq>;
+  /**
+   * Queries historical logs for a deployed resource.
+   * Used by `alchemy logs` to fetch past log entries.
+   */
+  logs?(input: {
+    id: string;
+    instanceId: string;
+    props: Props<Res>;
+    output: Res["Attributes"];
+    options: LogsInput;
+  }): Effect$1.Effect<LogLine[], any, LogsReq>;
   read?(input: {
     id: string;
     instanceId: string;
-    olds: Props<Res> | undefined;
-    output: Res["attr"] | undefined;
-    bindings: BindingData<Res>;
-  }): Effect$1.Effect<Res["attr"] | undefined, any, ReadReq>;
+    olds: Props<Res>;
+    output: Res["Attributes"] | undefined;
+  }): Effect$1.Effect<Res["Attributes"] | undefined, any, ReadReq>;
   /**
    * Properties that are always stable across any update.
    */
-  stables?: Extract<keyof Res["attr"], string>[];
+  stables?: Extract<keyof Res["Attributes"], string>[];
   diff?(input: {
     id: string;
-    olds: Props<Res>;
     instanceId: string;
-    news: Res["props"];
-    output: Res["attr"];
-  }): Effect$1.Effect<Diff | void, never, DiffReq>;
+    olds: Props<Res>;
+    news: Input<Props<Res>>;
+    oldBindings: BindingData<Res>;
+    newBindings: Input<BindingData<Res>>;
+    output: Res["Attributes"] | undefined;
+  }): Effect$1.Effect<Diff | void, any, DiffReq>;
   precreate?(input: {
     id: string;
     news: Props<Res>;
     instanceId: string;
     session: ScopedPlanStatusSession;
-  }): Effect$1.Effect<Res["attr"], any, PrecreateReq>;
+  }): Effect$1.Effect<Res["Attributes"], any, PrecreateReq>;
   create(input: {
     id: string;
     instanceId: string;
     news: Props<Res>;
     session: ScopedPlanStatusSession;
     bindings: BindingData<Res>;
-  }): Effect$1.Effect<Res["attr"], any, CreateReq>;
+    output?: Res["Attributes"];
+  }): Effect$1.Effect<Res["Attributes"], any, CreateReq>;
   update(input: {
     id: string;
     instanceId: string;
     news: Props<Res>;
     olds: Props<Res>;
-    output: Res["attr"];
+    output: Res["Attributes"];
     session: ScopedPlanStatusSession;
     bindings: BindingData<Res>;
-  }): Effect$1.Effect<Res["attr"], any, UpdateReq>;
+  }): Effect$1.Effect<Res["Attributes"], any, UpdateReq>;
   delete(input: {
     id: string;
     instanceId: string;
     olds: Props<Res>;
-    output: Res["attr"];
+    output: Res["Attributes"];
     session: ScopedPlanStatusSession;
     bindings: BindingData<Res>;
   }): Effect$1.Effect<void, any, DeleteReq>;
 }
 //#endregion
-//#region src/instance-id.d.ts
-declare const InstanceId_base: Context.TagClass<InstanceId, "instance-id", string>;
-/** A 16-byte (128-bit) random hex-encoded string representing an physical instance of a logical resource */
-declare class InstanceId extends InstanceId_base {}
-//#endregion
-//#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 */
-  attr: Attrs;
-}
-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 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, Exclude<Req$1 | ReadReq | DiffReq | PrecreateReq | CreateReq | UpdateReq | DeleteReq, InstanceId>>;
-  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, Exclude<ReadReq | DiffReq | PrecreateReq | CreateReq | UpdateReq | DeleteReq, InstanceId>>;
-}
-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>;
-}
-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 RuntimeProps<Run extends IRuntime, Req$1> {
-  bindings: Policy<Run, Extract<Req$1, Capability>, unknown>;
-}
-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
-/**
- * A Policy binds a set of Capbilities (e.g SQS.SendMessage, SQS.Consume, etc.) to a
- * specific Runtime (e.g. AWS Lambda Function, Cloudflare Worker, etc.).
- *
- * It brings with it a set of upstream Tags containing the required Provider services
- * to deploy the infrastructure, e.g. (BindingTag<AWS.Lambda.Function, SendMessage<Queue>>)
- *
- * A Policy is invariant over the set of Capabilities to ensure least-privilege.
- */
-interface Policy<F extends IRuntime, in out Capabilities, Tags = unknown> {
-  readonly kind: "alchemy/Policy";
-  readonly runtime: F;
-  readonly tags: Tags[];
-  readonly capabilities: Capabilities[];
-  /** Add more Capabilities to a Policy */
-  and<B extends AnyBinding[]>(...bindings: B): Policy<F, B[number]["capability"] | Capabilities, BindingTags<B[number]> | Exclude<Tags, unknown>>;
-}
-type BindingTags<B extends AnyBinding> = B extends any ? Bind<B["runtime"], B["capability"], Extract<B["tag"], string>> : never;
-declare function Policy<F extends Runtime>(): Policy<F, never, never>;
-declare function Policy<B extends AnyBinding[]>(...capabilities: B): Policy<B[number]["runtime"], B[number]["capability"], BindingTags<B[number]>>;
-declare namespace Policy {
-  export interface AnyOf<in out T> {
-    readonly anyOf: T[];
-  }
-  type Generalize<T> = T extends S.Schema<infer U> ? U : T;
-  export const anyOf: <const T>(...anyOf: T[]) => AnyOf<Generalize<T>>;
-  export const join: <const Strings extends readonly string[], const Delimiter extends string>(strings: Strings, delimiter: Delimiter) => Join<Strings, Delimiter>;
-  type Join<T extends readonly string[], Delimiter extends string> = T extends readonly [infer First extends string] ? First : T extends readonly [infer First extends string, ...infer Rest extends readonly string[]] ? `${First}${Delimiter}${Join<Rest, Delimiter>}` : T extends string[] ? string : "";
-  export type Constraint<T> = Pick<T, { [k in keyof T]: T[k] extends never ? never : T[k] extends AnyOf<never> ? never : k }[keyof T]>;
-  export const infer: <T>() => T;
-  export {};
-}
-//#endregion
-//#region src/capability.d.ts
-interface ICapability<Type extends string = string, Resource$1 = unknown, Constraint = unknown> {
-  type: Type;
-  resource: Resource$1;
-  constraint: Constraint;
-  sid: string;
-  label: string;
-}
-interface Capability<Type extends string = string, Resource$1 = unknown, Constraint = unknown> extends ICapability<Type, Resource$1, Constraint> {
-  new (): {};
-}
-declare namespace Capability {
-  type Simplify<C> = [C] extends [{
-    Constructor: {
-      Reduce: any;
-    };
-  }] ? _Simplify<C> : C;
-  type _Simplify<C> = [C] extends [infer c extends {
-    Constructor: any;
-    resource: any;
-    constraint: any;
-  }] ? (c["Constructor"] & {
-    resource: c["resource"];
-    constraint: Constraint.Simplify<c["constraint"]>;
-  })["Reduce"] : never;
-  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$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)[];
-  }] ? Policy.AnyOf<U> : never;
-  namespace Constraint {
-    type Simplify<Constraint> = { [k in Keys<DropIrrelevant<Constraint>>]: BoxPolicy<Get<Constraint, k>> };
-  }
-}
-//#endregion
-//#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;
-}
-/** 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 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 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"];
-  };
-}
-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/plan.d.ts
-/**
- * A node in the plan that represents a binding operation acting on a resource.
- */
-type BindNode<B extends AnyBinding = AnyBinding> = Attach<B> | Reattach<B> | Detach<B> | NoopBind<B>;
-type Attach<B extends AnyBinding = AnyBinding> = {
-  action: "attach";
-  binding: B;
-  olds: BindNode | undefined;
-  attr: B["attr"] | undefined;
-};
-type Reattach<B extends AnyBinding = AnyBinding> = {
-  action: "reattach";
-  binding: B;
-  olds: BindNode;
-  attr: B["attr"];
-};
-type Detach<B extends AnyBinding = AnyBinding> = {
-  action: "detach";
-  binding: B;
-  attr: B["attr"] | undefined;
-};
-type NoopBind<B extends AnyBinding = AnyBinding> = {
-  action: "noop";
-  binding: B;
-  attr: B["attr"];
-};
-type Apply<R extends Resource = AnyResource> = Create<R> | Update<R> | Replace<R> | NoopUpdate<R>;
-interface BaseNode<R extends Resource = AnyResource> {
+//#region src/Plan.d.ts
+type Apply<R extends ResourceLike = ResourceLike> = Create<R> | Update<R> | Replace<R> | NoopUpdate<R>;
+type BindingAction = "create" | "update" | "delete" | "noop";
+interface BindingNode<Data = any> extends ResourceBinding {
+  action: BindingAction;
+  data: Data;
+}
+interface BaseNode<R extends ResourceLike<string> = ResourceLike<string>> {
   resource: R;
   provider: ProviderService<R>;
-  bindings: BindNode[];
   downstream: string[];
+  bindings: BindingNode<R["Binding"]>[];
 }
-interface Create<R extends Resource = AnyResource> extends BaseNode<R> {
+interface Create<R extends ResourceLike = ResourceLike> extends BaseNode<R> {
   action: "create";
-  props: any;
+  props: R["Props"];
   state: CreatingResourceState | undefined;
 }
-interface Update<R extends Resource = AnyResource> extends BaseNode<R> {
+interface Update<R extends ResourceLike = ResourceLike> extends BaseNode<R> {
   action: "update";
-  props: any;
+  props: R["Props"];
   state: CreatedResourceState | UpdatedResourceState | UpdatingReourceState | ReplacedResourceState;
 }
-interface Delete<R extends Resource = AnyResource> extends BaseNode<R> {
+interface Delete<R extends ResourceLike = ResourceLike> extends BaseNode<R> {
   action: "delete";
   state: ResourceState;
 }
-interface NoopUpdate<R extends Resource = AnyResource> extends BaseNode<R> {
+interface NoopUpdate<R extends ResourceLike = ResourceLike> extends BaseNode<R> {
   action: "noop";
   state: CreatedResourceState | UpdatedResourceState;
 }
-interface Replace<R extends Resource = AnyResource> extends BaseNode<R> {
+interface Replace<R extends ResourceLike = ResourceLike> extends BaseNode<R> {
   action: "replace";
   props: any;
   deleteFirst: boolean;
+  restart?: boolean;
   state: CreatingResourceState | CreatedResourceState | UpdatingReourceState | UpdatedResourceState | ReplacingResourceState | ReplacedResourceState;
 }
-type IPlan = {
+type Plan<Output$1 = any> = {
   resources: { [id in string]: Apply<any> };
-  deletions: { [id in string]?: Delete<Resource> };
+  deletions: { [id in string]?: Delete<ResourceLike> };
+  output: Output$1;
 };
 //#endregion
-//#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";
+//#region src/Cli/Event.d.ts
+type ApplyStatus = "attaching" | "post-attach" | "pending" | "pre-creating" | "creating" | "creating replacement" | "created" | "updating" | "updated" | "deleting" | "deleted" | "replacing" | "replaced" | "fail";
 type ApplyEvent = AnnotateEvent | StatusChangeEvent;
 interface AnnotateEvent {
   kind: "annotate";
@@ -550,7 +379,7 @@ interface StatusChangeEvent {
   bindingId?: string;
 }
 //#endregion
-//#region src/cli/service.d.ts
+//#region src/Cli/Cli.d.ts
 interface PlanStatusSession {
   emit: (event: ApplyEvent) => Effect$1.Effect<void>;
   done: () => Effect$1.Effect<void>;
@@ -559,15 +388,15 @@ 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>;
+  approvePlan: <P$1 extends Plan>(plan: P$1) => Effect$1.Effect<boolean>;
+  displayPlan: <P$1 extends Plan>(plan: P$1) => Effect$1.Effect<void>;
+  startApplySession: <P$1 extends Plan>(plan: P$1) => Effect$1.Effect<PlanStatusSession>;
 }
-declare const CLI_base: Context.TagClass<CLI, "CLIService", CLIService>;
-declare class CLI extends CLI_base {}
+declare const Cli_base: ServiceMap.ServiceClass<Cli, "CLI", CLIService>;
+declare class Cli extends Cli_base {}
 //#endregion
-//#region src/cli/ink-service.d.ts
-declare const inkCLI: () => Layer.Layer<CLI, never, never>;
+//#region src/Cli/InkCLI.d.ts
+declare const inkCLI: () => Layer.Layer<Cli, never, never>;
 //#endregion
-export { CLI, CLIService, PlanStatusSession, ScopedPlanStatusSession, inkCLI };
+export { CLIService, Cli, PlanStatusSession, ScopedPlanStatusSession, inkCLI };
 //# sourceMappingURL=index.d.ts.map