alchemy-effect 0.6.0 → 0.6.2

package/src/plan.ts

@@ -1,1129 +0,0 @@
-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 { omit } from "effect/Struct";
-import { App } from "./app.ts";
-import type {
-  AnyBinding,
-  BindingDiffProps,
-  BindingService,
-} from "./binding.ts";
-import type { Capability } from "./capability.ts";
-import type { Diff, NoopDiff, UpdateDiff } from "./diff.ts";
-import { InstanceId } from "./instance-id.ts";
-import * as Output from "./output.ts";
-import type { Instance } from "./policy.ts";
-import type { Provider } from "./provider.ts";
-import { getProviderByType, type ProviderService } from "./provider.ts";
-import type { AnyResource, Resource, ResourceTags } from "./resource.ts";
-import { isService, type IService, type Service } from "./service.ts";
-import {
-  State,
-  StateStoreError,
-  type CreatedResourceState,
-  type CreatingResourceState,
-  type ReplacedResourceState,
-  type ReplacingResourceState,
-  type ResourceState,
-  type UpdatedResourceState,
-  type UpdatingReourceState,
-} from "./state.ts";
-import { asEffect } from "./util.ts";
-
-export type PlanError = never;
-
-export const isBindNode = (node: any): node is BindNode => {
-  return (
-    node &&
-    typeof node === "object" &&
-    (node.action === "attach" ||
-      node.action === "detach" ||
-      node.action === "noop")
-  );
-};
-
-/**
- * A node in the plan that represents a binding operation acting on a resource.
- */
-export type BindNode<B extends AnyBinding = AnyBinding> =
-  | Attach<B>
-  | Reattach<B>
-  | Detach<B>
-  | NoopBind<B>;
-
-export type Attach<B extends AnyBinding = AnyBinding> = {
-  action: "attach";
-  binding: B;
-  olds: BindNode | undefined;
-  attr: B["attr"] | undefined;
-};
-
-export type Reattach<B extends AnyBinding = AnyBinding> = {
-  action: "reattach";
-  binding: B;
-  olds: BindNode;
-  attr: B["attr"];
-};
-
-export type Detach<B extends AnyBinding = AnyBinding> = {
-  action: "detach";
-  binding: B;
-  attr: B["attr"] | undefined;
-};
-
-export type NoopBind<B extends AnyBinding = AnyBinding> = {
-  action: "noop";
-  binding: B;
-  attr: B["attr"];
-};
-
-export const isCRUD = (node: any): node is CRUD => {
-  return (
-    node &&
-    typeof node === "object" &&
-    (node.action === "create" ||
-      node.action === "update" ||
-      node.action === "replace" ||
-      node.action === "noop")
-  );
-};
-
-/**
- * A node in the plan that represents a resource CRUD operation.
- */
-export type CRUD<R extends Resource = AnyResource> =
-  | Create<R>
-  | Update<R>
-  | Delete<R>
-  | Replace<R>
-  | NoopUpdate<R>;
-
-export type Apply<R extends Resource = AnyResource> =
-  | Create<R>
-  | Update<R>
-  | Replace<R>
-  | NoopUpdate<R>;
-
-export interface BaseNode<R extends Resource = AnyResource> {
-  resource: R;
-  provider: ProviderService<R>;
-  bindings: BindNode[];
-  downstream: string[];
-}
-
-export interface Create<R extends Resource = AnyResource> extends BaseNode<R> {
-  action: "create";
-  props: any;
-  state: CreatingResourceState | undefined;
-}
-
-export interface Update<R extends Resource = AnyResource> extends BaseNode<R> {
-  action: "update";
-  props: any;
-  state:
-    | CreatedResourceState
-    | UpdatedResourceState
-    | UpdatingReourceState
-    // the props can change after creating the replacement resource,
-    // so Apply needs to handle updates and then continue with cleaning up the replaced graph
-    | ReplacedResourceState;
-}
-
-export interface Delete<R extends Resource = AnyResource> extends BaseNode<R> {
-  action: "delete";
-  // a resource can be deleted no matter what state it's in
-  state: ResourceState;
-}
-
-export interface NoopUpdate<
-  R extends Resource = AnyResource,
-> extends BaseNode<R> {
-  action: "noop";
-  state: CreatedResourceState | UpdatedResourceState;
-}
-
-export interface Replace<R extends Resource = AnyResource> extends BaseNode<R> {
-  action: "replace";
-  props: any;
-  deleteFirst: boolean;
-  state:
-    | CreatingResourceState
-    | CreatedResourceState
-    | UpdatingReourceState
-    | UpdatedResourceState
-    | ReplacingResourceState
-    | ReplacedResourceState;
-}
-
-export type ResourceGraph<Resources extends Service | Resource> = ToGraph<
-  TraverseResources<Resources>
->;
-
-export type TraverseResources<Resources extends Service | Resource> =
-  | Resources
-  | BoundResources<Resources>
-  | TransitiveResources<Resources>;
-
-type ToGraph<Resources extends Service | Resource> = {
-  [ID in Resources["id"]]: Apply<Extract<Resources, { id: ID }>>;
-};
-
-export type BoundResources<Resources extends Service | Resource> = NeverUnknown<
-  Extract<
-    Resources,
-    IService
-  >["props"]["bindings"]["capabilities"][number]["resource"]
->;
-
-// finds transitive dependencies at most two levels deep
-// TODO(sam): figure out an efficient way to do arbitrary depth
-export type TransitiveResources<
-  Resources extends Service | Resource,
-  Found extends Service | Resource = never,
-> = Extract<
-  | Found
-  | {
-      [prop in keyof Resources["props"]]: IsAny<
-        Resources["props"][prop]
-      > extends true
-        ? Found
-        : Resources["props"][prop] extends { kind: "alchemy/Policy" }
-          ? Found
-          : Resources["props"][prop] extends Output.Output<any, infer Src, any>
-            ? Src extends Found
-              ? Found
-              : TransitiveResources<Src, Src | Found>
-            : {
-                [p in keyof Resources["props"][prop]]: IsAny<
-                  Resources["props"][prop][p]
-                > extends true
-                  ? Found
-                  : Resources["props"][prop][p] extends Output.Output<
-                        any,
-                        infer Src,
-                        any
-                      >
-                    ? Src extends Found
-                      ? Found
-                      : string extends Src["id"]
-                        ? Found
-                        : TransitiveResources<Src, Src | Found>
-                    : Found;
-              }[keyof Resources["props"][prop]];
-    }[keyof Resources["props"]],
-  Service | Resource
->;
-
-export type Providers<Resources extends Service | Resource> =
-  | ResourceProviders<Resources>
-  | BindingTags<Resources>;
-
-export type ResourceProviders<Res extends Service | Resource> = Res extends any
-  ? Provider<Extract<Res["base"], Service | Resource>>
-  : never;
-
-export type BindingTags<Resources extends Service | Resource> = NeverUnknown<
-  Extract<Resources, Service>["props"]["bindings"]["tags"][number]
->;
-
-type NeverUnknown<T> = unknown extends T ? never : T;
-
-type IsAny<T> = 0 extends 1 & T ? true : false;
-
-export type DerivePlan<Resources extends Service | Resource> = {
-  resources: {
-    [ID in keyof ResourceGraph<Resources>]: ResourceGraph<Resources>[ID];
-  };
-  deletions: {
-    [ID in string]: Delete<AnyResource>;
-  };
-};
-
-export type IPlan = {
-  resources: {
-    [id in string]: Apply<any>;
-  };
-  deletions: {
-    [id in string]?: Delete<Resource>;
-  };
-};
-
-export type Plan<Resources extends Service | Resource> = Effect.Effect<
-  DerivePlan<Resources>,
-  | CannotReplacePartiallyReplacedResource
-  | DeleteResourceHasDownstreamDependencies,
-  Providers<Resources> | State
->;
-
-export const plan = <const Resources extends (Service | Resource)[]>(
-  ..._resources: Resources
-): Plan<Instance<Resources[number]>> =>
-  Effect.gen(function* () {
-    const state = yield* State;
-
-    const findResources = (
-      resource: Service | Resource,
-      visited: Set<string>,
-    ): (Service | Resource)[] => {
-      if (visited.has(resource.id)) {
-        return [];
-      }
-      visited.add(resource.id);
-      const upstream = Object.values(Output.upstreamAny(resource.props)) as (
-        | Service
-        | Resource
-      )[];
-      return [
-        resource,
-        ...upstream,
-        ...upstream.flatMap((r) => findResources(r, visited)),
-      ];
-    };
-    const resources = _resources
-      .flatMap((r) => findResources(r, new Set()))
-      .filter((r, i, arr) => arr.findIndex((r2) => r2.id === r.id) === i);
-
-    // TODO(sam): rename terminology to Stack
-    const app = yield* App;
-
-    const resourceIds = yield* state.list({
-      stack: app.name,
-      stage: app.stage,
-    });
-    const oldResources = yield* Effect.all(
-      resourceIds.map((id) =>
-        state.get({ stack: app.name, stage: app.stage, resourceId: id }),
-      ),
-      { concurrency: "unbounded" },
-    );
-
-    type ResolveEffect<T> = Effect.Effect<T, ResolveErr, ResolveReq>;
-    type ResolveErr = StateStoreError;
-    type ResolveReq =
-      | Context.TagClass<
-          Provider<Resource<string, string, any, any>>,
-          string,
-          ProviderService<Resource<string, string, any, any>>
-        >
-      | State;
-
-    const resolvedResources: Record<
-      string,
-      ResolveEffect<
-        | {
-            [attr in string]: any;
-          }
-        | undefined
-      >
-    > = {};
-
-    const resolveResource = (
-      resourceExpr: Output.ResourceExpr<any, any, any>,
-    ) =>
-      Effect.gen(function* () {
-        return yield* (resolvedResources[resourceExpr.src.id] ??=
-          yield* Effect.cached(
-            Effect.gen(function* () {
-              const resource = resourceExpr.src as Resource & {
-                provider: ResourceTags<Resource<string, string, any, any>>;
-              };
-              const provider = yield* resource.provider.tag;
-              const props = yield* resolveInput(resource.props);
-              const oldState = yield* state.get({
-                stack: app.name,
-                stage: app.stage,
-                resourceId: resource.id,
-              });
-
-              if (!oldState || oldState.status === "creating") {
-                return resourceExpr;
-              }
-
-              const oldProps =
-                oldState.status === "created" ||
-                oldState.status === "updated" ||
-                oldState.status === "replaced"
-                  ? // if we're in a stable state, then just use the props
-                    oldState.props
-                  : // if we failed to update or replace, compare with the last known stable props
-                    oldState.status === "updating" ||
-                      oldState.status === "replacing"
-                    ? oldState.old.props
-                    : // TODO(sam): it kinda doesn't make sense to diff with a "deleting" state
-                      oldState.props;
-
-              const diff = yield* provider.diff
-                ? provider
-                    .diff({
-                      id: resource.id,
-                      olds: oldProps,
-                      instanceId: oldState.instanceId,
-                      news: props,
-                      output: oldState.attr,
-                    })
-                    .pipe(
-                      Effect.provide(
-                        Layer.succeed(InstanceId, oldState.instanceId),
-                      ),
-                    )
-                : Effect.succeed(undefined);
-
-              const stables: string[] = [
-                ...(provider.stables ?? []),
-                ...(diff?.stables ?? []),
-              ];
-
-              const withStables = (output: any) =>
-                stables.length > 0
-                  ? new Output.ResourceExpr(
-                      resourceExpr.src,
-                      Object.fromEntries(
-                        stables.map((stable) => [stable, output?.[stable]]),
-                      ),
-                    )
-                  : // if there are no stable properties, treat every property as changed
-                    resourceExpr;
-
-              if (diff == null) {
-                if (arePropsChanged(oldProps, props)) {
-                  // the props have changed but the provider did not provide any hints as to what is stable
-                  // so we must assume everything has changed
-                  return withStables(oldState?.attr);
-                }
-              } else if (diff.action === "update") {
-                return withStables(oldState?.attr);
-              } else if (diff.action === "replace") {
-                return resourceExpr;
-              }
-              if (
-                oldState.status === "created" ||
-                oldState.status === "updated" ||
-                oldState.status === "replaced"
-              ) {
-                // we can safely return the attributes if we know they have stabilized
-                return oldState?.attr;
-              } else {
-                // we must assume the resource doesn't exist if it hasn't stabilized
-                return resourceExpr;
-              }
-            }),
-          ));
-      });
-
-    const resolveInput = (input: any): ResolveEffect<any> =>
-      Effect.gen(function* () {
-        if (!input) {
-          return input;
-        } else if (Output.isExpr(input)) {
-          return yield* resolveOutput(input);
-        } else if (Array.isArray(input)) {
-          return yield* Effect.all(input.map(resolveInput), {
-            concurrency: "unbounded",
-          });
-        } else if (typeof input === "object") {
-          return Object.fromEntries(
-            yield* Effect.all(
-              Object.entries(input).map(([key, value]) =>
-                resolveInput(value).pipe(Effect.map((value) => [key, value])),
-              ),
-              { concurrency: "unbounded" },
-            ),
-          );
-        }
-        return input;
-      });
-
-    const resolveOutput = (expr: Output.Expr<any>): ResolveEffect<any> =>
-      Effect.gen(function* () {
-        if (Output.isResourceExpr(expr)) {
-          return yield* resolveResource(expr);
-        } else if (Output.isPropExpr(expr)) {
-          const upstream = yield* resolveOutput(expr.expr);
-          return upstream?.[expr.identifier];
-        } else if (Output.isApplyExpr(expr)) {
-          const upstream = yield* resolveOutput(expr.expr);
-          return Output.hasOutputs(upstream) ? expr : expr.f(upstream);
-        } else if (Output.isEffectExpr(expr)) {
-          const upstream = yield* resolveOutput(expr.expr);
-          return Output.hasOutputs(upstream) ? expr : yield* expr.f(upstream);
-        } else if (Output.isAllExpr(expr)) {
-          return yield* Effect.all(expr.outs.map(resolveOutput), {
-            concurrency: "unbounded",
-          });
-        }
-        return yield* Effect.die(new Error("Not implemented yet"));
-      });
-
-    // map of resource ID -> its downstream dependencies (resources that depend on it)
-    const oldDownstreamDependencies: {
-      [resourceId: string]: string[];
-    } = Object.fromEntries(
-      oldResources
-        .filter((resource) => !!resource)
-        .map((resource) => [resource.logicalId, resource.downstream]),
-    );
-
-    const newUpstreamDependencies: {
-      [resourceId: string]: string[];
-    } = Object.fromEntries(
-      resources.map((resource) => [
-        resource.id,
-        [
-          ...Object.values(Output.upstreamAny(resource.props)).map((r) => r.id),
-          ...(isService(resource)
-            ? resource.props.bindings.capabilities.map((cap) => cap.resource.id)
-            : []),
-        ],
-      ]),
-    );
-
-    const newDownstreamDependencies: {
-      [resourceId: string]: string[];
-    } = Object.fromEntries(
-      resources.map((resource) => [
-        resource.id,
-        Object.entries(newUpstreamDependencies)
-          .filter(([_, downstream]) => downstream.includes(resource.id))
-          .map(([id]) => id),
-      ]),
-    );
-
-    const resourceGraph = Object.fromEntries(
-      (yield* Effect.all(
-        resources
-          .flatMap((resource) => [
-            ...(isService(resource)
-              ? resource.props.bindings.capabilities.map(
-                  (cap: Capability) => cap.resource as Resource,
-                )
-              : []),
-            ...Object.values(Output.upstreamAny(resource.props)),
-            resource,
-          ])
-          .filter(
-            (node, i, arr) => arr.findIndex((n) => n.id === node.id) === i,
-          )
-          .map(
-            Effect.fn(function* (node) {
-              const id = node.id;
-              const resource = node as Resource & {
-                provider: ResourceTags<Resource<string, string, any, any>>;
-              };
-              const news = yield* resolveInput(resource.props);
-
-              const oldState = yield* state.get({
-                stack: app.name,
-                stage: app.stage,
-                resourceId: id,
-              });
-              const provider = yield* resource.provider.tag;
-
-              const downstream = newDownstreamDependencies[id] ?? [];
-
-              const bindings = isService(node)
-                ? yield* diffBindings({
-                    oldState,
-                    bindings: (
-                      node.props.bindings as unknown as {
-                        bindings: AnyBinding[];
-                      }
-                    ).bindings,
-                    target: {
-                      id: node.id,
-                      props: node.props,
-                      // TODO(sam): pick the right ones based on old status
-                      oldAttr: oldState?.attr,
-                      oldProps: oldState?.props,
-                    },
-                  })
-                : []; // TODO(sam): return undefined instead of empty array
-
-              const Node = <T extends Apply>(
-                node: Omit<
-                  T,
-                  "provider" | "resource" | "bindings" | "downstream"
-                >,
-              ) =>
-                ({
-                  ...node,
-                  provider,
-                  resource,
-                  bindings,
-                  downstream,
-                }) as any as T;
-
-              // handle empty and intermediate (non-final) states:
-              if (oldState === undefined) {
-                return Node<Create<Resource>>({
-                  action: "create",
-                  props: news,
-                  state: oldState,
-                });
-              } else if (
-                oldState.status === "creating" &&
-                oldState.attr === undefined
-              ) {
-                if (provider.read) {
-                  const attr = yield* provider.read({
-                    id,
-                    instanceId: oldState.instanceId,
-                    olds: oldState.props,
-                    output: oldState.attr,
-                    bindings,
-                  });
-                  if (attr) {
-                    return Node<Create<Resource>>({
-                      action: "create",
-                      props: news,
-                      state: { ...oldState, attr },
-                    });
-                  }
-                }
-              }
-
-              // TODO(sam): is this correct for all possible states a resource can be in?
-              const oldProps = oldState.props;
-
-              const diff = yield* asEffect(
-                provider.diff
-                  ? provider
-                      .diff({
-                        id,
-                        olds: oldProps,
-                        instanceId: oldState.instanceId,
-                        output: oldState.attr,
-                        news,
-                      })
-                      .pipe(
-                        Effect.provide(
-                          Layer.succeed(InstanceId, oldState.instanceId),
-                        ),
-                      )
-                  : undefined,
-              ).pipe(
-                Effect.map(
-                  (diff) =>
-                    diff ??
-                    ({
-                      action: arePropsChanged(oldProps, news)
-                        ? "update"
-                        : "noop",
-                    } as UpdateDiff | NoopDiff),
-                ),
-              );
-
-              if (oldState.status === "creating") {
-                if (diff.action === "noop") {
-                  // we're in the creating state and props are un-changed
-                  // let's just continue where we left off
-                  return Node<Create<Resource>>({
-                    action: "create",
-                    props: news,
-                    state: oldState,
-                  });
-                } else if (diff.action === "update") {
-                  // props have changed in a way that is updatable
-                  // again, just continue with the create
-                  // TODO(sam): should we maybe try an update instead?
-                  return Node<Create<Resource>>({
-                    action: "create",
-                    props: news,
-                    state: oldState,
-                  });
-                } else {
-                  // props have changed in an incompatible way
-                  // because it's possible that an un-updatable resource has already been created
-                  // we must use a replace step to create a new one and delete the potential old one
-                  return Node<Replace<Resource>>({
-                    action: "replace",
-                    props: news,
-                    deleteFirst: diff.deleteFirst ?? false,
-                    state: oldState,
-                  });
-                }
-              } else if (oldState.status === "updating") {
-                // we started to update a resource but did not complete
-                if (diff.action === "update" || diff.action === "noop") {
-                  return Node<Update<Resource>>({
-                    action: "update",
-                    props: news,
-                    state: oldState,
-                  });
-                } else {
-                  // we started to update a resource but now believe we should replace it
-                  return Node<Replace<Resource>>({
-                    action: "replace",
-                    deleteFirst: diff.deleteFirst ?? false,
-                    props: news,
-                    // TODO(sam): can Apply handle replacements when the oldState is UpdatingResourceState?
-                    // -> or is there we do a provider.read to try and reconcile back to UpdatedResourceState?
-                    state: oldState,
-                  });
-                }
-              } else if (oldState.status === "replacing") {
-                // resource replacement started, but the replacement may or may not have been created
-                if (diff.action === "noop") {
-                  // this is the stable case - noop means just continue with the replacement
-                  return Node<Replace<Resource>>({
-                    action: "replace",
-                    deleteFirst: oldState.deleteFirst,
-                    props: news,
-                    state: oldState,
-                  });
-                } else if (diff.action === "update") {
-                  // potential problem here - the props have changed since we tried to replace,
-                  // but not enough to trigger another replacement. the resource provider should
-                  // be designed as idempotent to converge to the right state when creating the new resource
-                  // the newly generated instanceId is intended to assist with this
-                  return Node<Replace<Resource>>({
-                    action: "replace",
-                    deleteFirst: oldState.deleteFirst,
-                    props: news,
-                    state: oldState,
-                  });
-                } else {
-                  // ah shit, so we tried to replace the resource and then crashed
-                  // now the props have changed again in such a way that the (maybe, maybe not)
-                  // created resource should also be replaced
-
-                  // TODO(sam): what should we do?
-                  // 1. trigger a deletion of the potentially created resource
-                  // 2. expect the resource provider to handle it idempotently?
-                  // -> i don't think this case is fair to put on the resource provider
-                  //    because if the resource was created, it's in a state that can't be updated
-                  return yield* Effect.fail(
-                    new CannotReplacePartiallyReplacedResource(id),
-                  );
-                }
-              } else if (oldState.status === "replaced") {
-                // replacement has been created but we're not done cleaning up the old state
-                if (diff.action === "noop") {
-                  // this is the stable case - noop means just continue cleaning up the replacement
-                  return Node<Replace<Resource>>({
-                    action: "replace",
-                    deleteFirst: oldState.deleteFirst,
-                    props: news,
-                    state: oldState,
-                  });
-                } else if (diff.action === "update") {
-                  // the replacement has been created but now also needs to be updated
-                  // the resource provider should:
-                  // 1. Update the newly created replacement resource
-                  // 2. Then proceed as normal to delete the replaced resources (after all downstream references are updated)
-                  return Node<Update<Resource>>({
-                    action: "update",
-                    props: news,
-                    state: oldState,
-                  });
-                } else {
-                  // the replacement has been created but now it needs to be replaced
-                  // this is the worst-case scenario because downstream resources
-                  // could have been been updated to point to the replaced resources
-                  return yield* Effect.fail(
-                    new CannotReplacePartiallyReplacedResource(id),
-                  );
-                }
-              } else if (oldState.status === "deleting") {
-                if (diff.action === "noop" || diff.action === "update") {
-                  // we're in a partially deleted state, it is unclear whether it was or was not deleted
-                  // it should be safe to re-create it with the same instanceId?
-                  return Node<Create<Resource>>({
-                    action: "create",
-                    props: news,
-                    state: {
-                      ...oldState,
-                      status: "creating",
-                      props: news,
-                    },
-                  });
-                } else {
-                  return yield* Effect.fail(
-                    new CannotReplacePartiallyReplacedResource(id),
-                  );
-                }
-              } else if (diff.action === "update") {
-                return Node<Update<Resource>>({
-                  action: "update",
-                  props: news,
-                  state: oldState,
-                });
-              } else if (diff.action === "replace") {
-                return Node<Replace<Resource>>({
-                  action: "replace",
-                  props: news,
-                  state: oldState,
-                  deleteFirst: diff?.deleteFirst ?? false,
-                });
-              } else {
-                return Node<NoopUpdate<Resource>>({
-                  action: "noop",
-                  state: oldState,
-                });
-              }
-            }),
-          ),
-        { concurrency: "unbounded" },
-      )).map((update) => [update.resource.id, update]),
-    ) as IPlan["resources"];
-
-    const deletions = Object.fromEntries(
-      (yield* Effect.all(
-        (yield* state.list({ stack: app.name, stage: app.stage })).map(
-          Effect.fn(function* (id) {
-            if (id in resourceGraph) {
-              return;
-            }
-            const oldState = yield* state.get({
-              stack: app.name,
-              stage: app.stage,
-              resourceId: id,
-            });
-            let attr: any = oldState?.attr;
-            if (oldState) {
-              const provider = yield* getProviderByType(oldState.resourceType);
-              if (oldState.attr === undefined) {
-                if (provider.read) {
-                  attr = yield* provider
-                    .read({
-                      id,
-                      instanceId: oldState.instanceId,
-                      olds: oldState.props as never,
-                      output: oldState.attr as never,
-                      bindings: oldState.bindings ?? [],
-                    })
-                    .pipe(
-                      Effect.provide(
-                        Layer.succeed(InstanceId, oldState.instanceId),
-                      ),
-                    );
-                }
-              }
-              return [
-                id,
-                {
-                  action: "delete",
-                  state: { ...oldState, attr },
-                  // // TODO(sam): Support Detach Bindings
-                  bindings: [],
-                  provider,
-                  resource: {
-                    id: id,
-                    type: oldState.resourceType,
-                    attr,
-                    props: oldState.props,
-                  } as Resource,
-                  // TODO(sam): is it enough to just pass through oldState?
-                  downstream: oldDownstreamDependencies[id] ?? [],
-                } satisfies Delete<Resource>,
-              ] as const;
-            }
-          }),
-        ),
-        { concurrency: "unbounded" },
-      )).filter((v) => !!v),
-    );
-
-    for (const [resourceId, deletion] of Object.entries(deletions)) {
-      const dependencies = deletion.state.downstream.filter(
-        (d) => d in resourceGraph,
-      );
-      if (dependencies.length > 0) {
-        return yield* Effect.fail(
-          new DeleteResourceHasDownstreamDependencies({
-            message: `Resource ${resourceId} has downstream dependencies`,
-            resourceId,
-            dependencies,
-          }),
-        );
-      }
-    }
-
-    return {
-      resources: resourceGraph,
-      deletions,
-    } satisfies IPlan as IPlan;
-  }) as any;
-
-export class CannotReplacePartiallyReplacedResource extends Data.TaggedError(
-  "CannotReplacePartiallyReplacedResource",
-)<{
-  message: string;
-  logicalId: string;
-}> {
-  constructor(logicalId: string) {
-    super({
-      message:
-        `Resource '${logicalId}' did not finish being replaced in a previous deployment ` +
-        `and is expected to be replaced again in this deployment. ` +
-        `You should revert its properties and try again after a successful deployment.`,
-      logicalId,
-    });
-  }
-}
-
-export class DeleteResourceHasDownstreamDependencies extends Data.TaggedError(
-  "DeleteResourceHasDownstreamDependencies",
-)<{
-  message: string;
-  resourceId: string;
-  dependencies: string[];
-}> {}
-
-const arePropsChanged = <R extends Resource>(
-  oldProps: R["props"] | undefined,
-  newProps: R["props"],
-) => {
-  return (
-    Output.hasOutputs(newProps) ||
-    JSON.stringify(omit((oldProps ?? {}) as any, "bindings")) !==
-      JSON.stringify(omit((newProps ?? {}) as any, "bindings"))
-  );
-};
-
-const diffBindings = Effect.fn(function* ({
-  oldState,
-  bindings,
-  target,
-}: {
-  oldState: ResourceState | undefined;
-  bindings: AnyBinding[];
-  target: BindingDiffProps["target"];
-}) {
-  // const actions: BindNode[] = [];
-  const oldBindings = oldState?.bindings;
-  // const oldSids = new Set(
-  //   oldBindings?.map(({ binding }) => binding.capability.sid),
-  // );
-
-  const diffBinding: (
-    binding: AnyBinding,
-  ) => Effect.Effect<BindNode, StateStoreError, State> = Effect.fn(
-    function* (binding) {
-      const cap = binding.capability;
-      const sid = cap.sid ?? `${cap.action}:${cap.resource.ID}`;
-      // Find potential oldBinding for this sid
-      const oldBinding = oldBindings?.find(
-        ({ binding }) => binding.capability.sid === sid,
-      );
-      if (!oldBinding) {
-        return {
-          action: "attach",
-          binding,
-          attr: undefined,
-          olds: undefined,
-        } satisfies Attach<AnyBinding>;
-      }
-
-      const diff = yield* isBindingDiff({
-        target,
-        oldBinding,
-        newBinding: binding,
-      });
-      // if (diff === false) {
-      // } else if (diff === true) {
-      //   return {
-      //     action: "attach",
-      //     binding,
-      //     olds: oldBinding,
-      //   } satisfies Attach<AnyBinding>;
-      // }
-      if (diff.action === "replace") {
-        return yield* Effect.die(
-          new Error("Replace binding not yet supported"),
-        );
-        // TODO(sam): implement support for replacing bindings
-        // return {
-        //   action: "replace",
-        //   binding,
-        //   olds: oldBinding,
-        // };
-      } else if (diff?.action === "update") {
-        return {
-          action: "reattach",
-          binding,
-          olds: oldBinding,
-          attr: oldBinding.attr,
-        } satisfies Reattach<AnyBinding>;
-      }
-      return {
-        action: "noop",
-        binding,
-        attr: oldBinding.attr,
-      } satisfies NoopBind<AnyBinding>;
-    },
-  );
-
-  return (yield* Effect.all(bindings.map(diffBinding), {
-    concurrency: "unbounded",
-  })).filter((action): action is BindNode => action !== null);
-});
-
-const isBindingDiff = Effect.fn(function* ({
-  target,
-  oldBinding: { binding: oldBinding },
-  newBinding,
-}: {
-  // TODO(sam): support binding to other Resources
-  target: BindingDiffProps["target"];
-  oldBinding: BindNode;
-  newBinding: AnyBinding;
-}) {
-  const oldCap = oldBinding.capability;
-  const newCap = newBinding.capability;
-  if (
-    // if the binding provider has changed
-    oldBinding.tag !== newBinding.tag ||
-    // if it points to a totally different resource, we should replace
-    oldCap?.resource?.id !== newCap?.resource?.id ||
-    // if it is a different action
-    oldCap.action !== newCap.action
-  ) {
-    // then we must replace (we need to detach and attach with different bindings or to different resources)
-    return {
-      action: "replace",
-    } satisfies Diff;
-  }
-
-  const binding = newBinding as AnyBinding & {
-    // smuggled property (because it interacts poorly with inference)
-    Tag: Context.Tag<never, BindingService>;
-  };
-  const provider = yield* binding.Tag;
-  if (provider.diff) {
-    const state = yield* State;
-    const oldState = yield* state.get(oldCap.resource.id);
-    if (oldState) {
-      const diff = yield* provider
-        .diff({
-          source: {
-            id: oldCap.resource.id,
-            props: newCap.resource.props,
-            oldProps: oldState?.props,
-            oldAttr: oldState?.attr,
-          },
-          props: newBinding.props,
-          attr: oldBinding.attr,
-          target,
-        })
-        .pipe(Effect.provide(Layer.succeed(InstanceId, oldState.instanceId)));
-
-      if (diff?.action === "update" || diff?.action === "replace") {
-        return diff;
-      }
-    }
-  }
-  return {
-    action:
-      oldBinding.capability.action !== newBinding.capability.action ||
-      oldBinding.capability?.resource?.id !==
-        newBinding.capability?.resource?.id
-        ? "update"
-        : "noop",
-  } as const;
-});
-// TODO(sam): compare props
-// oldBinding.props !== newBinding.props;
-
-/**
- * Print a plan in a human-readable format that shows the graph topology.
- */
-export const printPlan = (plan: IPlan): string => {
-  const lines: string[] = [];
-  const allNodes = { ...plan.resources, ...plan.deletions };
-
-  // Build reverse mapping: upstream -> downstream
-  const upstreamMap: Record<string, string[]> = {};
-  for (const [id] of Object.entries(allNodes)) {
-    upstreamMap[id] = [];
-  }
-  for (const [id, node] of Object.entries(allNodes)) {
-    if (!node) continue;
-    for (const downstreamId of node.state?.downstream ?? []) {
-      if (upstreamMap[downstreamId]) {
-        upstreamMap[downstreamId].push(id);
-      }
-    }
-  }
-
-  // Action symbols
-  const actionSymbol = (action: string) => {
-    switch (action) {
-      case "create":
-        return "+";
-      case "update":
-        return "~";
-      case "delete":
-        return "-";
-      case "replace":
-        return "±";
-      case "noop":
-        return "=";
-      default:
-        return "?";
-    }
-  };
-
-  // Print header
-  lines.push(
-    "╔════════════════════════════════════════════════════════════════╗",
-  );
-  lines.push(
-    "║                           PLAN                                 ║",
-  );
-  lines.push(
-    "╠════════════════════════════════════════════════════════════════╣",
-  );
-  lines.push(
-    "║ Legend: + create, ~ update, - delete, ± replace, = noop        ║",
-  );
-  lines.push(
-    "╚════════════════════════════════════════════════════════════════╝",
-  );
-  lines.push("");
-
-  // Print resources section
-  lines.push(
-    "┌─ Resources ────────────────────────────────────────────────────┐",
-  );
-  const resourceIds = Object.keys(plan.resources).sort();
-  for (const id of resourceIds) {
-    const node = plan.resources[id];
-    const symbol = actionSymbol(node.action);
-    const type = node.resource?.type ?? "unknown";
-    const downstream = node.state?.downstream?.length
-      ? ` → [${node.state?.downstream.join(", ")}]`
-      : "";
-    lines.push(`│ [${symbol}] ${id} (${type})${downstream}`);
-  }
-  if (resourceIds.length === 0) {
-    lines.push("│ (none)");
-  }
-  lines.push(
-    "└────────────────────────────────────────────────────────────────┘",
-  );
-  lines.push("");
-
-  // Print deletions section
-  lines.push(
-    "┌─ Deletions ────────────────────────────────────────────────────┐",
-  );
-  const deletionIds = Object.keys(plan.deletions).sort();
-  for (const id of deletionIds) {
-    const node = plan.deletions[id]!;
-    const type = node.resource?.type ?? "unknown";
-    const downstream = node.state.downstream?.length
-      ? ` → [${node.state.downstream.join(", ")}]`
-      : "";
-    lines.push(`│ [-] ${id} (${type})${downstream}`);
-  }
-  if (deletionIds.length === 0) {
-    lines.push("│ (none)");
-  }
-  lines.push(
-    "└────────────────────────────────────────────────────────────────┘",
-  );
-  lines.push("");
-
-  return lines.join("\n");
-};