@domainkit/react 0.8.0 → 0.9.1

package/dist/index.d.mts

@@ -1,998 +1,1337 @@
-import { Transport } from "domainkit";
+import { Approval, DnsRecord, DomainKit, Plan, Reason, Receipt, Storage } from "domainkit";
+import "effect/Effect";
+import { CSSProperties, ElementType, ReactElement, ReactNode, RefObject } from "react";
 import * as Data from "effect/Data";
-import * as Atom from "effect/unstable/reactivity/Atom";
-import { CSSProperties, ComponentPropsWithoutRef, ElementType, ReactElement, ReactNode, RefObject } from "react";
+import { Transport } from "domainkit/client";
 import { useRender } from "@base-ui/react/use-render";
-import { Dialog } from "@base-ui/react/dialog";
-import * as Layer from "effect/Layer";
-//#region src/atom.d.ts
-type Runtime = Atom.AtomRuntime<Transport.Service>;
-type Failure = Data.TaggedEnum<{
-  Failure: {
-    readonly message: string;
-    readonly operation: string;
-    readonly retry: Transport.Failure["retry"];
+import { Testing } from "domainkit/testing";
+//#region src/events.d.ts
+/** What a customer finished doing, for host notifications, analytics, and audit trails. */
+type Event = Data.TaggedEnum<{
+  Connected: {
+    readonly domain: string;
+    readonly connectionId: string;
+    readonly snapshot: Transport.Snapshot;
   };
-}>;
-declare const Failure: {
-  readonly $is: <Tag extends "Failure">(tag: Tag) => (u: unknown) => u is Extract<{
-    readonly _tag: "Failure";
-    readonly message: string;
-    readonly operation: string;
-    readonly retry: Transport.Failure["retry"];
-  }, {
-    readonly _tag: Tag;
-  }>;
-  readonly $match: {
-    <Cases extends { readonly [Tag in "Failure"]: (args: Extract<{
-      readonly _tag: "Failure";
-      readonly message: string;
-      readonly operation: string;
-      readonly retry: Transport.Failure["retry"];
-    }, {
-      readonly _tag: Tag;
-    }>) => any; }>(cases: Cases): (value: {
-      readonly _tag: "Failure";
-      readonly message: string;
-      readonly operation: string;
-      readonly retry: Transport.Failure["retry"];
-    }) => import("effect/Unify").Unify<ReturnType<Cases["Failure"]>>;
-    <Cases extends { readonly [Tag in "Failure"]: (args: Extract<{
-      readonly _tag: "Failure";
-      readonly message: string;
-      readonly operation: string;
-      readonly retry: Transport.Failure["retry"];
-    }, {
-      readonly _tag: Tag;
-    }>) => any; }>(value: {
-      readonly _tag: "Failure";
-      readonly message: string;
-      readonly operation: string;
-      readonly retry: Transport.Failure["retry"];
-    }, cases: Cases): import("effect/Unify").Unify<ReturnType<Cases["Failure"]>>;
+  Detached: {
+    readonly domain: string;
   };
-  readonly Failure: Data.TaggedEnum.ConstructorFrom<{
-    readonly _tag: "Failure";
-    readonly message: string;
-    readonly operation: string;
-    readonly retry: Transport.Failure["retry"];
-  }, "_tag">;
-};
-//#endregion
-//#region src/composition.d.ts
-type ClassName<State> = string | ((state: State) => string | undefined);
-type Style<State> = CSSProperties | ((state: State) => CSSProperties | undefined);
-type PartProps<Tag extends ElementType, State extends Record<string, unknown>> = Omit<useRender.ElementProps<Tag>, "className" | "style"> & {
-  readonly className?: ClassName<State>;
-  readonly render?: useRender.RenderProp<State>;
-  readonly style?: Style<State>;
-};
-declare namespace cleanup_d_exports {
-  export { Command$3 as Command, Completion, Controller$3 as Controller, Dialog$3 as Dialog, DialogProps$2 as DialogProps, Flow$3 as Flow, FlowProps$3 as FlowProps, Model$3 as Model, Outcome$2 as Outcome, Root$6 as Root, RootProps$6 as RootProps, State$3 as State, useController$3 as useController, useModel$3 as useModel };
-}
-type LocalState$3 = Data.TaggedEnum<{
-  Cleaned: {
-    readonly result: Extract<Transport.CleanupResult, {
-      readonly _tag: "Cleaned";
-    }>;
+  Disconnected: {
+    readonly domain: string;
+    readonly connectionId: string;
   };
-  Cleaning: {
-    readonly plan: Transport.CleanupPlan;
+  Applied: {
+    readonly domain: string;
+    readonly receipt: Receipt.Model;
   };
-  Idle: {};
-  Partial: {
-    readonly result: Extract<Transport.CleanupResult, {
-      readonly _tag: "Partial";
-    }>;
+  Cleaned: {
+    readonly domain: string;
+    readonly receipt: Receipt.Model;
   };
-  Planning: {};
-  Review: {
-    readonly plan: Transport.CleanupPlan;
+  Declined: {
+    readonly domain: string;
+    readonly attempt: Transport.Attempt;
+  };
+  Failed: {
+    readonly domain: string;
+    readonly error: DomainKit.Error;
   };
 }>;
-declare const State$3: {
-  readonly $is: <Tag extends "Cleaned" | "Cleaning" | "Idle" | "Partial" | "Planning" | "Review">(tag: Tag) => (u: unknown) => u is Extract<{
+declare const Event: {
+  readonly $is: <Tag extends "Applied" | "Cleaned" | "Connected" | "Declined" | "Detached" | "Disconnected" | "Failed">(tag: Tag) => (u: unknown) => u is Extract<{
+    readonly _tag: "Applied";
+    readonly domain: string;
+    readonly receipt: Receipt.Model;
+  }, {
+    readonly _tag: Tag;
+  }> | Extract<{
     readonly _tag: "Cleaned";
-    readonly result: Extract<Transport.CleanupResult, {
-      readonly _tag: "Cleaned";
-    }>;
+    readonly domain: string;
+    readonly receipt: Receipt.Model;
   }, {
     readonly _tag: Tag;
   }> | Extract<{
-    readonly _tag: "Cleaning";
-    readonly plan: Transport.CleanupPlan;
+    readonly _tag: "Connected";
+    readonly domain: string;
+    readonly connectionId: string;
+    readonly snapshot: Transport.Snapshot;
   }, {
     readonly _tag: Tag;
   }> | Extract<{
-    readonly _tag: "Idle";
+    readonly _tag: "Declined";
+    readonly domain: string;
+    readonly attempt: Transport.Attempt;
   }, {
     readonly _tag: Tag;
   }> | Extract<{
-    readonly _tag: "Partial";
-    readonly result: Extract<Transport.CleanupResult, {
-      readonly _tag: "Partial";
-    }>;
+    readonly _tag: "Detached";
+    readonly domain: string;
   }, {
     readonly _tag: Tag;
   }> | Extract<{
-    readonly _tag: "Planning";
+    readonly _tag: "Disconnected";
+    readonly domain: string;
+    readonly connectionId: string;
   }, {
     readonly _tag: Tag;
   }> | Extract<{
-    readonly _tag: "Review";
-    readonly plan: Transport.CleanupPlan;
+    readonly _tag: "Failed";
+    readonly domain: string;
+    readonly error: DomainKit.Error;
   }, {
     readonly _tag: Tag;
   }>;
   readonly $match: {
-    <Cases extends { readonly [Tag in "Cleaned" | "Cleaning" | "Idle" | "Partial" | "Planning" | "Review"]: (args: Extract<{
+    <Cases extends { readonly [Tag in "Applied" | "Cleaned" | "Connected" | "Declined" | "Detached" | "Disconnected" | "Failed"]: (args: Extract<{
+      readonly _tag: "Applied";
+      readonly domain: string;
+      readonly receipt: Receipt.Model;
+    } | {
       readonly _tag: "Cleaned";
-      readonly result: Extract<Transport.CleanupResult, {
-        readonly _tag: "Cleaned";
-      }>;
+      readonly domain: string;
+      readonly receipt: Receipt.Model;
     } | {
-      readonly _tag: "Cleaning";
-      readonly plan: Transport.CleanupPlan;
+      readonly _tag: "Connected";
+      readonly domain: string;
+      readonly connectionId: string;
+      readonly snapshot: Transport.Snapshot;
     } | {
-      readonly _tag: "Idle";
+      readonly _tag: "Declined";
+      readonly domain: string;
+      readonly attempt: Transport.Attempt;
     } | {
-      readonly _tag: "Partial";
-      readonly result: Extract<Transport.CleanupResult, {
-        readonly _tag: "Partial";
-      }>;
+      readonly _tag: "Detached";
+      readonly domain: string;
     } | {
-      readonly _tag: "Planning";
+      readonly _tag: "Disconnected";
+      readonly domain: string;
+      readonly connectionId: string;
     } | {
-      readonly _tag: "Review";
-      readonly plan: Transport.CleanupPlan;
+      readonly _tag: "Failed";
+      readonly domain: string;
+      readonly error: DomainKit.Error;
     }, {
       readonly _tag: Tag;
     }>) => any; }>(cases: Cases): (value: {
+      readonly _tag: "Applied";
+      readonly domain: string;
+      readonly receipt: Receipt.Model;
+    } | {
       readonly _tag: "Cleaned";
-      readonly result: Extract<Transport.CleanupResult, {
-        readonly _tag: "Cleaned";
-      }>;
+      readonly domain: string;
+      readonly receipt: Receipt.Model;
+    } | {
+      readonly _tag: "Connected";
+      readonly domain: string;
+      readonly connectionId: string;
+      readonly snapshot: Transport.Snapshot;
     } | {
-      readonly _tag: "Cleaning";
-      readonly plan: Transport.CleanupPlan;
+      readonly _tag: "Declined";
+      readonly domain: string;
+      readonly attempt: Transport.Attempt;
     } | {
-      readonly _tag: "Idle";
+      readonly _tag: "Detached";
+      readonly domain: string;
     } | {
-      readonly _tag: "Partial";
-      readonly result: Extract<Transport.CleanupResult, {
-        readonly _tag: "Partial";
-      }>;
+      readonly _tag: "Disconnected";
+      readonly domain: string;
+      readonly connectionId: string;
     } | {
-      readonly _tag: "Planning";
+      readonly _tag: "Failed";
+      readonly domain: string;
+      readonly error: DomainKit.Error;
+    }) => import("effect/Unify").Unify<ReturnType<Cases["Applied" | "Cleaned" | "Connected" | "Declined" | "Detached" | "Disconnected" | "Failed"]>>;
+    <Cases extends { readonly [Tag in "Applied" | "Cleaned" | "Connected" | "Declined" | "Detached" | "Disconnected" | "Failed"]: (args: Extract<{
+      readonly _tag: "Applied";
+      readonly domain: string;
+      readonly receipt: Receipt.Model;
     } | {
-      readonly _tag: "Review";
-      readonly plan: Transport.CleanupPlan;
-    }) => import("effect/Unify").Unify<ReturnType<Cases["Cleaned" | "Cleaning" | "Idle" | "Partial" | "Planning" | "Review"]>>;
-    <Cases extends { readonly [Tag in "Cleaned" | "Cleaning" | "Idle" | "Partial" | "Planning" | "Review"]: (args: Extract<{
       readonly _tag: "Cleaned";
-      readonly result: Extract<Transport.CleanupResult, {
-        readonly _tag: "Cleaned";
-      }>;
+      readonly domain: string;
+      readonly receipt: Receipt.Model;
     } | {
-      readonly _tag: "Cleaning";
-      readonly plan: Transport.CleanupPlan;
+      readonly _tag: "Connected";
+      readonly domain: string;
+      readonly connectionId: string;
+      readonly snapshot: Transport.Snapshot;
     } | {
-      readonly _tag: "Idle";
+      readonly _tag: "Declined";
+      readonly domain: string;
+      readonly attempt: Transport.Attempt;
     } | {
-      readonly _tag: "Partial";
-      readonly result: Extract<Transport.CleanupResult, {
-        readonly _tag: "Partial";
-      }>;
+      readonly _tag: "Detached";
+      readonly domain: string;
     } | {
-      readonly _tag: "Planning";
+      readonly _tag: "Disconnected";
+      readonly domain: string;
+      readonly connectionId: string;
     } | {
-      readonly _tag: "Review";
-      readonly plan: Transport.CleanupPlan;
+      readonly _tag: "Failed";
+      readonly domain: string;
+      readonly error: DomainKit.Error;
     }, {
       readonly _tag: Tag;
     }>) => any; }>(value: {
+      readonly _tag: "Applied";
+      readonly domain: string;
+      readonly receipt: Receipt.Model;
+    } | {
       readonly _tag: "Cleaned";
-      readonly result: Extract<Transport.CleanupResult, {
-        readonly _tag: "Cleaned";
-      }>;
+      readonly domain: string;
+      readonly receipt: Receipt.Model;
     } | {
-      readonly _tag: "Cleaning";
-      readonly plan: Transport.CleanupPlan;
+      readonly _tag: "Connected";
+      readonly domain: string;
+      readonly connectionId: string;
+      readonly snapshot: Transport.Snapshot;
     } | {
-      readonly _tag: "Idle";
+      readonly _tag: "Declined";
+      readonly domain: string;
+      readonly attempt: Transport.Attempt;
     } | {
-      readonly _tag: "Partial";
-      readonly result: Extract<Transport.CleanupResult, {
-        readonly _tag: "Partial";
-      }>;
+      readonly _tag: "Detached";
+      readonly domain: string;
     } | {
-      readonly _tag: "Planning";
+      readonly _tag: "Disconnected";
+      readonly domain: string;
+      readonly connectionId: string;
     } | {
-      readonly _tag: "Review";
-      readonly plan: Transport.CleanupPlan;
-    }, cases: Cases): import("effect/Unify").Unify<ReturnType<Cases["Cleaned" | "Cleaning" | "Idle" | "Partial" | "Planning" | "Review"]>>;
+      readonly _tag: "Failed";
+      readonly domain: string;
+      readonly error: DomainKit.Error;
+    }, cases: Cases): import("effect/Unify").Unify<ReturnType<Cases["Applied" | "Cleaned" | "Connected" | "Declined" | "Detached" | "Disconnected" | "Failed"]>>;
   };
+  readonly Applied: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "Applied";
+    readonly domain: string;
+    readonly receipt: Receipt.Model;
+  }, "_tag">;
   readonly Cleaned: Data.TaggedEnum.ConstructorFrom<{
     readonly _tag: "Cleaned";
-    readonly result: Extract<Transport.CleanupResult, {
-      readonly _tag: "Cleaned";
-    }>;
+    readonly domain: string;
+    readonly receipt: Receipt.Model;
   }, "_tag">;
-  readonly Cleaning: Data.TaggedEnum.ConstructorFrom<{
-    readonly _tag: "Cleaning";
-    readonly plan: Transport.CleanupPlan;
+  readonly Connected: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "Connected";
+    readonly domain: string;
+    readonly connectionId: string;
+    readonly snapshot: Transport.Snapshot;
   }, "_tag">;
-  readonly Idle: Data.TaggedEnum.ConstructorFrom<{
-    readonly _tag: "Idle";
+  readonly Declined: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "Declined";
+    readonly domain: string;
+    readonly attempt: Transport.Attempt;
   }, "_tag">;
-  readonly Partial: Data.TaggedEnum.ConstructorFrom<{
-    readonly _tag: "Partial";
-    readonly result: Extract<Transport.CleanupResult, {
-      readonly _tag: "Partial";
-    }>;
+  readonly Detached: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "Detached";
+    readonly domain: string;
   }, "_tag">;
-  readonly Planning: Data.TaggedEnum.ConstructorFrom<{
-    readonly _tag: "Planning";
+  readonly Disconnected: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "Disconnected";
+    readonly domain: string;
+    readonly connectionId: string;
   }, "_tag">;
-  readonly Review: Data.TaggedEnum.ConstructorFrom<{
-    readonly _tag: "Review";
-    readonly plan: Transport.CleanupPlan;
+  readonly Failed: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "Failed";
+    readonly domain: string;
+    readonly error: DomainKit.Error;
   }, "_tag">;
 };
-type State$3 = LocalState$3 | Extract<Transport.CleanupResult, {
-  readonly _tag: "Stale";
-}> | Failure;
-type Command$3 = Data.TaggedEnum<{
-  Apply: {};
-  Dismiss: {};
-  Plan: {};
+type Listener = (event: Event) => void;
+//#endregion
+//#region src/attempt.d.ts
+type State$2 = Data.TaggedEnum<{
+  Idle: {};
+  Planning: {};
+  Planned: {
+    readonly plan: Plan.Model;
+  };
+  Approving: {
+    readonly plan: Plan.Model;
+  };
+  Applying: {
+    readonly plan: Plan.Model;
+    readonly approval: Approval.Model;
+  };
+  Applied: {
+    readonly plan: Plan.Model | null;
+    readonly receipt: Receipt.Model;
+  };
+  Rejecting: {
+    readonly plan: Plan.Model;
+  };
+  Rejected: {
+    readonly plan: Plan.Model;
+    readonly attempt: Transport.Attempt;
+  };
+  Failure: {
+    readonly error: DomainKit.Error;
+  };
 }>;
-declare const Command$3: {
-  readonly $is: <Tag extends "Apply" | "Dismiss" | "Plan">(tag: Tag) => (u: unknown) => u is Extract<{
-    readonly _tag: "Apply";
+declare const State$2: {
+  readonly $is: <Tag extends "Applied" | "Applying" | "Approving" | "Failure" | "Idle" | "Planned" | "Planning" | "Rejected" | "Rejecting">(tag: Tag) => (u: unknown) => u is Extract<{
+    readonly _tag: "Applied";
+    readonly plan: Plan.Model | null;
+    readonly receipt: Receipt.Model;
+  }, {
+    readonly _tag: Tag;
+  }> | Extract<{
+    readonly _tag: "Applying";
+    readonly plan: Plan.Model;
+    readonly approval: Approval.Model;
+  }, {
+    readonly _tag: Tag;
+  }> | Extract<{
+    readonly _tag: "Approving";
+    readonly plan: Plan.Model;
+  }, {
+    readonly _tag: Tag;
+  }> | Extract<{
+    readonly _tag: "Failure";
+    readonly error: DomainKit.Error;
+  }, {
+    readonly _tag: Tag;
+  }> | Extract<{
+    readonly _tag: "Idle";
+  }, {
+    readonly _tag: Tag;
+  }> | Extract<{
+    readonly _tag: "Planned";
+    readonly plan: Plan.Model;
   }, {
     readonly _tag: Tag;
   }> | Extract<{
-    readonly _tag: "Dismiss";
+    readonly _tag: "Planning";
+  }, {
+    readonly _tag: Tag;
+  }> | Extract<{
+    readonly _tag: "Rejected";
+    readonly plan: Plan.Model;
+    readonly attempt: Transport.Attempt;
   }, {
     readonly _tag: Tag;
   }> | Extract<{
-    readonly _tag: "Plan";
+    readonly _tag: "Rejecting";
+    readonly plan: Plan.Model;
   }, {
     readonly _tag: Tag;
   }>;
   readonly $match: {
-    <Cases extends { readonly [Tag in "Apply" | "Dismiss" | "Plan"]: (args: Extract<{
-      readonly _tag: "Apply";
+    <Cases extends { readonly [Tag in "Applied" | "Applying" | "Approving" | "Failure" | "Idle" | "Planned" | "Planning" | "Rejected" | "Rejecting"]: (args: Extract<{
+      readonly _tag: "Applied";
+      readonly plan: Plan.Model | null;
+      readonly receipt: Receipt.Model;
+    } | {
+      readonly _tag: "Applying";
+      readonly plan: Plan.Model;
+      readonly approval: Approval.Model;
+    } | {
+      readonly _tag: "Approving";
+      readonly plan: Plan.Model;
     } | {
-      readonly _tag: "Dismiss";
+      readonly _tag: "Failure";
+      readonly error: DomainKit.Error;
+    } | {
+      readonly _tag: "Idle";
+    } | {
+      readonly _tag: "Planned";
+      readonly plan: Plan.Model;
     } | {
-      readonly _tag: "Plan";
+      readonly _tag: "Planning";
+    } | {
+      readonly _tag: "Rejected";
+      readonly plan: Plan.Model;
+      readonly attempt: Transport.Attempt;
+    } | {
+      readonly _tag: "Rejecting";
+      readonly plan: Plan.Model;
     }, {
       readonly _tag: Tag;
     }>) => any; }>(cases: Cases): (value: {
-      readonly _tag: "Apply";
+      readonly _tag: "Applied";
+      readonly plan: Plan.Model | null;
+      readonly receipt: Receipt.Model;
+    } | {
+      readonly _tag: "Applying";
+      readonly plan: Plan.Model;
+      readonly approval: Approval.Model;
+    } | {
+      readonly _tag: "Approving";
+      readonly plan: Plan.Model;
+    } | {
+      readonly _tag: "Failure";
+      readonly error: DomainKit.Error;
+    } | {
+      readonly _tag: "Idle";
+    } | {
+      readonly _tag: "Planned";
+      readonly plan: Plan.Model;
+    } | {
+      readonly _tag: "Planning";
+    } | {
+      readonly _tag: "Rejected";
+      readonly plan: Plan.Model;
+      readonly attempt: Transport.Attempt;
+    } | {
+      readonly _tag: "Rejecting";
+      readonly plan: Plan.Model;
+    }) => import("effect/Unify").Unify<ReturnType<Cases["Applied" | "Applying" | "Approving" | "Failure" | "Idle" | "Planned" | "Planning" | "Rejected" | "Rejecting"]>>;
+    <Cases extends { readonly [Tag in "Applied" | "Applying" | "Approving" | "Failure" | "Idle" | "Planned" | "Planning" | "Rejected" | "Rejecting"]: (args: Extract<{
+      readonly _tag: "Applied";
+      readonly plan: Plan.Model | null;
+      readonly receipt: Receipt.Model;
+    } | {
+      readonly _tag: "Applying";
+      readonly plan: Plan.Model;
+      readonly approval: Approval.Model;
+    } | {
+      readonly _tag: "Approving";
+      readonly plan: Plan.Model;
     } | {
-      readonly _tag: "Dismiss";
+      readonly _tag: "Failure";
+      readonly error: DomainKit.Error;
+    } | {
+      readonly _tag: "Idle";
+    } | {
+      readonly _tag: "Planned";
+      readonly plan: Plan.Model;
     } | {
-      readonly _tag: "Plan";
-    }) => import("effect/Unify").Unify<ReturnType<Cases["Apply" | "Dismiss" | "Plan"]>>;
-    <Cases extends { readonly [Tag in "Apply" | "Dismiss" | "Plan"]: (args: Extract<{
-      readonly _tag: "Apply";
+      readonly _tag: "Planning";
     } | {
-      readonly _tag: "Dismiss";
+      readonly _tag: "Rejected";
+      readonly plan: Plan.Model;
+      readonly attempt: Transport.Attempt;
     } | {
-      readonly _tag: "Plan";
+      readonly _tag: "Rejecting";
+      readonly plan: Plan.Model;
     }, {
       readonly _tag: Tag;
     }>) => any; }>(value: {
-      readonly _tag: "Apply";
+      readonly _tag: "Applied";
+      readonly plan: Plan.Model | null;
+      readonly receipt: Receipt.Model;
+    } | {
+      readonly _tag: "Applying";
+      readonly plan: Plan.Model;
+      readonly approval: Approval.Model;
+    } | {
+      readonly _tag: "Approving";
+      readonly plan: Plan.Model;
+    } | {
+      readonly _tag: "Failure";
+      readonly error: DomainKit.Error;
+    } | {
+      readonly _tag: "Idle";
+    } | {
+      readonly _tag: "Planned";
+      readonly plan: Plan.Model;
+    } | {
+      readonly _tag: "Planning";
     } | {
-      readonly _tag: "Dismiss";
+      readonly _tag: "Rejected";
+      readonly plan: Plan.Model;
+      readonly attempt: Transport.Attempt;
     } | {
-      readonly _tag: "Plan";
-    }, cases: Cases): import("effect/Unify").Unify<ReturnType<Cases["Apply" | "Dismiss" | "Plan"]>>;
+      readonly _tag: "Rejecting";
+      readonly plan: Plan.Model;
+    }, cases: Cases): import("effect/Unify").Unify<ReturnType<Cases["Applied" | "Applying" | "Approving" | "Failure" | "Idle" | "Planned" | "Planning" | "Rejected" | "Rejecting"]>>;
   };
-  readonly Apply: Data.TaggedEnum.ConstructorFrom<{
-    readonly _tag: "Apply";
+  readonly Applied: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "Applied";
+    readonly plan: Plan.Model | null;
+    readonly receipt: Receipt.Model;
   }, "_tag">;
-  readonly Dismiss: Data.TaggedEnum.ConstructorFrom<{
-    readonly _tag: "Dismiss";
+  readonly Applying: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "Applying";
+    readonly plan: Plan.Model;
+    readonly approval: Approval.Model;
+  }, "_tag">;
+  readonly Approving: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "Approving";
+    readonly plan: Plan.Model;
+  }, "_tag">;
+  readonly Failure: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "Failure";
+    readonly error: DomainKit.Error;
+  }, "_tag">;
+  readonly Idle: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "Idle";
+  }, "_tag">;
+  readonly Planned: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "Planned";
+    readonly plan: Plan.Model;
+  }, "_tag">;
+  readonly Planning: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "Planning";
+  }, "_tag">;
+  readonly Rejected: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "Rejected";
+    readonly plan: Plan.Model;
+    readonly attempt: Transport.Attempt;
   }, "_tag">;
-  readonly Plan: Data.TaggedEnum.ConstructorFrom<{
-    readonly _tag: "Plan";
+  readonly Rejecting: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "Rejecting";
+    readonly plan: Plan.Model;
   }, "_tag">;
 };
-interface Model$3 {
-  readonly command: Atom.AtomResultFn<Command$3, void>;
-  readonly state: Atom.Atom<State$3>;
-}
-interface Controller$3 {
-  readonly apply: () => void;
-  readonly dismiss: () => void;
+interface Controller$2 {
+  readonly state: State$2;
+  /** Build a plan. The plan itself rides on the state, from `Planned` through `Applied`. */
   readonly plan: () => void;
+  /** Authorize the digest and apply it. Pass `operationIds` to approve part of the plan. */
+  readonly approve: (operationIds?: ReadonlyArray<Plan.OperationId>) => void;
+  /** Decline the plan. Terminal: approving it afterwards fails `Stale`. */
+  readonly reject: (reason?: string) => void;
+  /** Apply the approval this controller already holds. */
+  readonly apply: () => void;
+  /** Re-plan when the zone moved under the plan, otherwise re-run the step that failed. */
   readonly retry: () => void;
-  readonly state: State$3;
+  readonly reset: () => void;
 }
-type Completion = Extract<Transport.CleanupResult, {
-  readonly _tag: "Cleaned" | "Partial";
-}>;
-declare function useModel$3(connection: Transport.Connected, receiptId: string, onCleaned?: (result: Completion) => void): Model$3;
-declare function useController$3(connection: Transport.Connected, receiptId: string, onCleaned?: (result: Completion) => void): Controller$3;
-interface RootProps$6 extends PartProps<"div", {
-  readonly status: State$3["_tag"];
-}> {
-  readonly status: State$3["_tag"];
-}
-declare function Root$6({ status, ...props }: RootProps$6): ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
-declare function Outcome$2({ state }: {
-  readonly state: State$3;
-}): import("react/jsx-runtime").JSX.Element | null;
-interface DialogProps$2 {
-  readonly controller: Controller$3;
+//#endregion
+//#region src/composition.d.ts
+type ClassName<State> = string | ((state: State) => string | undefined);
+type Style<State> = CSSProperties | ((state: State) => CSSProperties | undefined);
+/**
+ * What every rendered part accepts: the element's own props, a state-aware `className` and
+ * `style`, and Base UI's `render` for replacing the element outright.
+ */
+type PartProps<Tag extends ElementType = "div", State extends Record<string, unknown> = Record<string, unknown>> = Omit<useRender.ElementProps<Tag>, "className" | "style"> & {
+  readonly className?: ClassName<State>;
+  readonly render?: useRender.RenderProp<State>;
+  readonly style?: Style<State>;
+};
+//#endregion
+//#region src/review.d.ts
+interface ReviewState extends Record<string, unknown> {
+  readonly status: Controller$2["state"]["_tag"];
+}
+interface KindProps {
+  readonly controller: Controller$2;
+  readonly kind: Plan.Kind;
+}
+interface StatusProps$5 extends PartProps<"p", ReviewState>, KindProps {}
+interface OutcomeProps$4 extends PartProps<"p", ReviewState>, KindProps {}
+interface ActionsProps$2 extends PartProps<"div", ReviewState>, KindProps {}
+interface DialogProps$3 extends KindProps {
+  readonly children?: ReactNode;
   readonly onOpenChange?: (open: boolean) => void;
-  readonly onOpenChangeComplete?: (open: boolean) => void;
-  readonly trigger?: ReactElement | null;
+  readonly open?: boolean;
+  /** Replace the dialog surface entirely: a drawer, an inline panel, a host modal. */
+  readonly render?: (props: {
+    readonly open: boolean;
+    readonly children: ReactNode;
+  }) => ReactNode;
+  readonly trigger?: ReactNode;
+}
+declare namespace cleanup_d_exports {
+  export { Actions$1 as Actions, ActionsProps$1 as ActionsProps, Controller$2 as Controller, Dialog$2 as Dialog, DialogProps$2 as DialogProps, Flow$3 as Flow, FlowProps$3 as FlowProps, Options$3 as Options, Outcome$3 as Outcome, OutcomeProps$3 as OutcomeProps, Root$6 as Root, RootProps$6 as RootProps, RootState$4 as RootState, State$2 as State, Status$4 as Status, StatusProps$4 as StatusProps, useController$3 as useController };
+}
+interface Options$3 {
+  readonly domain: string;
+  /** Which apply to undo. Without it, the domain's latest provisioning receipt. */
+  readonly receiptId?: Receipt.ReceiptId;
+  readonly onCleaned?: (receipt: Receipt.Model) => void;
+}
+/**
+ * Cleanup is bound to a receipt: it removes only what an apply proved DomainKit created. When the
+ * host does not name one, the controller reads the domain's latest from the snapshot.
+ */
+declare function useController$3({ domain, onCleaned, receiptId }: Options$3): Controller$2;
+interface RootState$4 extends Record<string, unknown> {
+  readonly status: State$2["_tag"];
+}
+interface RootProps$6 extends PartProps<"div", RootState$4> {
+  readonly controller: Controller$2;
 }
-declare function Dialog$3({ controller, onOpenChange, onOpenChangeComplete, trigger }: DialogProps$2): import("react/jsx-runtime").JSX.Element;
-interface FlowProps$3 extends Omit<RootProps$6, "status"> {
-  readonly connection: Transport.Connected;
-  readonly onCleaned?: (result: Completion) => void;
-  readonly receiptId: string;
-  readonly trigger?: ReactElement;
+declare function Root$6({ controller, ...props }: RootProps$6): ReactElement;
+interface DialogProps$2 extends Omit<DialogProps$3, "kind"> {}
+declare function Dialog$2(props: DialogProps$2): ReactElement;
+interface ActionsProps$1 extends Omit<ActionsProps$2, "kind"> {}
+declare function Actions$1(props: ActionsProps$1): ReactElement | null;
+interface OutcomeProps$3 extends Omit<OutcomeProps$4, "kind"> {}
+declare function Outcome$3(props: OutcomeProps$3): ReactElement | null;
+interface StatusProps$4 extends Omit<StatusProps$5, "kind"> {}
+declare function Status$4(props: StatusProps$4): ReactElement;
+interface FlowProps$3 extends Omit<RootProps$6, "controller"> {
+  readonly domain: string;
+  readonly onCleaned?: (receipt: Receipt.Model) => void;
+  readonly receiptId?: Receipt.ReceiptId;
+  readonly trigger?: ReactNode;
 }
-declare function Flow$3({ connection, onCleaned, receiptId, trigger, ...props }: FlowProps$3): import("react/jsx-runtime").JSX.Element;
+/** Cleanup on its own: a trigger that plans the removal, then the same review dialog. */
+declare function Flow$3({ domain, onCleaned, receiptId, trigger, ...props }: FlowProps$3): import("react/jsx-runtime").JSX.Element;
 declare namespace provider_d_exports {
-  export { Mark, MarkElementProps, MarkProps, MarkState, Marks, ProviderDescriptor as Provider };
+  export { Descriptor$1 as Descriptor, Mark, MarkProps, MarkState, Marks };
 }
-type ProviderDescriptor = Transport.Provider;
-type Marks = Readonly<Record<string, ReactNode | ((provider: ProviderDescriptor) => ReactNode)>>;
+/** A provider as the snapshot describes it: an id, a display name, and its auth methods. */
+type Descriptor$1 = Transport.Snapshot["providers"][number];
+/** Host-supplied artwork per provider id. A function receives the descriptor it renders for. */
+type Marks = Readonly<Record<string, ReactNode | ((provider: Descriptor$1) => ReactNode)>>;
 interface MarkState extends Record<string, unknown> {
   readonly providerId: string;
 }
 interface MarkProps extends PartProps<"span", MarkState> {
-  readonly provider: ProviderDescriptor;
+  readonly provider: Descriptor$1;
 }
+/**
+ * A provider's artwork. `DomainKit.Root`'s `marks` decides what a provider looks like; without an
+ * entry the mark is the provider's initial. Nothing is fetched at render time.
+ */
 declare function Mark({ provider, ...props }: MarkProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
-type MarkElementProps = ComponentPropsWithoutRef<"span">;
-declare namespace connection_d_exports {
-  export { ActionState, AttachAction, AttachActionProps, Card$1 as Card, CardActions, CardActionsProps, CardIdentity, CardIdentityProps, CardProps$1 as CardProps, Command$2 as Command, ConnectTrigger, ConnectTriggerProps, Connected, Controller$2 as Controller, Dialog$2 as Dialog, DialogProps$1 as DialogProps, DisconnectDialog, DisconnectDialogProps, Flow$2 as Flow, FlowProps$2 as FlowProps, IntegrationAction, IntegrationActionProps, Model$2 as Model, OAuthAction, OAuthActionProps, RetryAction$1 as RetryAction, RetryActionProps, Root$5 as Root, RootProps$5 as RootProps, RootState$1 as RootState, State$2 as State, Status$2 as Status, StatusProps$2 as StatusProps, StatusState, TokenAction, TokenActionProps, Trigger, TriggerProps, targetLabel, useController$2 as useController, useModel$2 as useModel };
-}
-type LocalState$2 = Data.TaggedEnum<{
-  Detaching: {
-    readonly snapshot: Transport.Connected;
+declare namespace connect_d_exports {
+  export { Candidate, Card$1 as Card, CardProps$1 as CardProps, ConnectInput, Controller$1 as Controller, Descriptor, Dialog$1 as Dialog, DialogProps$1 as DialogProps, Discovery, Field, Flow$2 as Flow, FlowProps$2 as FlowProps, Form, FormProps, MethodDescriptor, Options$2 as Options, Outcome$2 as Outcome, OutcomeProps$2 as OutcomeProps, Root$5 as Root, RootProps$5 as RootProps, RootState$3 as RootState, Snapshot, State$1 as State, Status$3 as Status, StatusProps$3 as StatusProps, useController$2 as useController };
+}
+type Snapshot = Transport.Snapshot;
+type Discovery = Transport.Discovery;
+type Candidate = Transport.Candidate;
+type Descriptor = Descriptor$1;
+type MethodDescriptor = Descriptor["methods"][number];
+type Field = NonNullable<MethodDescriptor["fields"]>[number];
+/**
+ * Where a domain stands with its DNS provider. `Disconnected` carries whatever
+ * `connection.discover` found, so the UI can offer a connection the customer already has before
+ * asking for another one.
+ */
+type State$1 = Data.TaggedEnum<{
+  Loading: {
+    readonly snapshot: Snapshot | null;
   };
-  Loading: {};
-  Redirecting: {
-    readonly snapshot: Disconnected;
+  Disconnected: {
+    readonly snapshot: Snapshot;
+    readonly discovery: Discovery | null;
+  };
+  Connected: {
+    readonly snapshot: Snapshot;
+  };
+  Reconnect: {
+    readonly snapshot: Snapshot;
   };
   Submitting: {
-    readonly snapshot: Disconnected;
+    readonly snapshot: Snapshot | null;
+  };
+  Redirecting: {
+    readonly url: string;
+  };
+  SelectionRequired: {
+    readonly snapshot: Snapshot | null;
+    readonly connectionId: string;
+    readonly candidates: ReadonlyArray<Candidate>;
+  };
+  Failure: {
+    readonly error: DomainKit.Error;
   };
 }>;
-declare const State$2: {
-  readonly $is: <Tag extends "Detaching" | "Loading" | "Redirecting" | "Submitting">(tag: Tag) => (u: unknown) => u is Extract<{
-    readonly _tag: "Detaching";
-    readonly snapshot: Transport.Connected;
+declare const State$1: {
+  readonly $is: <Tag extends "Connected" | "Disconnected" | "Failure" | "Loading" | "Reconnect" | "Redirecting" | "SelectionRequired" | "Submitting">(tag: Tag) => (u: unknown) => u is Extract<{
+    readonly _tag: "Connected";
+    readonly snapshot: Snapshot;
+  }, {
+    readonly _tag: Tag;
+  }> | Extract<{
+    readonly _tag: "Disconnected";
+    readonly snapshot: Snapshot;
+    readonly discovery: Discovery | null;
+  }, {
+    readonly _tag: Tag;
+  }> | Extract<{
+    readonly _tag: "Failure";
+    readonly error: DomainKit.Error;
   }, {
     readonly _tag: Tag;
   }> | Extract<{
     readonly _tag: "Loading";
+    readonly snapshot: Snapshot | null;
+  }, {
+    readonly _tag: Tag;
+  }> | Extract<{
+    readonly _tag: "Reconnect";
+    readonly snapshot: Snapshot;
   }, {
     readonly _tag: Tag;
   }> | Extract<{
     readonly _tag: "Redirecting";
-    readonly snapshot: Disconnected;
+    readonly url: string;
+  }, {
+    readonly _tag: Tag;
+  }> | Extract<{
+    readonly _tag: "SelectionRequired";
+    readonly snapshot: Snapshot | null;
+    readonly connectionId: string;
+    readonly candidates: ReadonlyArray<Candidate>;
   }, {
     readonly _tag: Tag;
   }> | Extract<{
     readonly _tag: "Submitting";
-    readonly snapshot: Disconnected;
+    readonly snapshot: Snapshot | null;
   }, {
     readonly _tag: Tag;
   }>;
   readonly $match: {
-    <Cases extends { readonly [Tag in "Detaching" | "Loading" | "Redirecting" | "Submitting"]: (args: Extract<{
-      readonly _tag: "Detaching";
-      readonly snapshot: Transport.Connected;
+    <Cases extends { readonly [Tag in "Connected" | "Disconnected" | "Failure" | "Loading" | "Reconnect" | "Redirecting" | "SelectionRequired" | "Submitting"]: (args: Extract<{
+      readonly _tag: "Connected";
+      readonly snapshot: Snapshot;
+    } | {
+      readonly _tag: "Disconnected";
+      readonly snapshot: Snapshot;
+      readonly discovery: Discovery | null;
+    } | {
+      readonly _tag: "Failure";
+      readonly error: DomainKit.Error;
     } | {
       readonly _tag: "Loading";
+      readonly snapshot: Snapshot | null;
+    } | {
+      readonly _tag: "Reconnect";
+      readonly snapshot: Snapshot;
     } | {
       readonly _tag: "Redirecting";
-      readonly snapshot: Disconnected;
+      readonly url: string;
+    } | {
+      readonly _tag: "SelectionRequired";
+      readonly snapshot: Snapshot | null;
+      readonly connectionId: string;
+      readonly candidates: ReadonlyArray<Candidate>;
     } | {
       readonly _tag: "Submitting";
-      readonly snapshot: Disconnected;
+      readonly snapshot: Snapshot | null;
     }, {
       readonly _tag: Tag;
     }>) => any; }>(cases: Cases): (value: {
-      readonly _tag: "Detaching";
-      readonly snapshot: Transport.Connected;
+      readonly _tag: "Connected";
+      readonly snapshot: Snapshot;
+    } | {
+      readonly _tag: "Disconnected";
+      readonly snapshot: Snapshot;
+      readonly discovery: Discovery | null;
+    } | {
+      readonly _tag: "Failure";
+      readonly error: DomainKit.Error;
     } | {
       readonly _tag: "Loading";
+      readonly snapshot: Snapshot | null;
+    } | {
+      readonly _tag: "Reconnect";
+      readonly snapshot: Snapshot;
     } | {
       readonly _tag: "Redirecting";
-      readonly snapshot: Disconnected;
+      readonly url: string;
+    } | {
+      readonly _tag: "SelectionRequired";
+      readonly snapshot: Snapshot | null;
+      readonly connectionId: string;
+      readonly candidates: ReadonlyArray<Candidate>;
     } | {
       readonly _tag: "Submitting";
-      readonly snapshot: Disconnected;
-    }) => import("effect/Unify").Unify<ReturnType<Cases["Detaching" | "Loading" | "Redirecting" | "Submitting"]>>;
-    <Cases extends { readonly [Tag in "Detaching" | "Loading" | "Redirecting" | "Submitting"]: (args: Extract<{
-      readonly _tag: "Detaching";
-      readonly snapshot: Transport.Connected;
+      readonly snapshot: Snapshot | null;
+    }) => import("effect/Unify").Unify<ReturnType<Cases["Connected" | "Disconnected" | "Failure" | "Loading" | "Reconnect" | "Redirecting" | "SelectionRequired" | "Submitting"]>>;
+    <Cases extends { readonly [Tag in "Connected" | "Disconnected" | "Failure" | "Loading" | "Reconnect" | "Redirecting" | "SelectionRequired" | "Submitting"]: (args: Extract<{
+      readonly _tag: "Connected";
+      readonly snapshot: Snapshot;
+    } | {
+      readonly _tag: "Disconnected";
+      readonly snapshot: Snapshot;
+      readonly discovery: Discovery | null;
+    } | {
+      readonly _tag: "Failure";
+      readonly error: DomainKit.Error;
     } | {
       readonly _tag: "Loading";
+      readonly snapshot: Snapshot | null;
+    } | {
+      readonly _tag: "Reconnect";
+      readonly snapshot: Snapshot;
     } | {
       readonly _tag: "Redirecting";
-      readonly snapshot: Disconnected;
+      readonly url: string;
+    } | {
+      readonly _tag: "SelectionRequired";
+      readonly snapshot: Snapshot | null;
+      readonly connectionId: string;
+      readonly candidates: ReadonlyArray<Candidate>;
     } | {
       readonly _tag: "Submitting";
-      readonly snapshot: Disconnected;
+      readonly snapshot: Snapshot | null;
     }, {
       readonly _tag: Tag;
     }>) => any; }>(value: {
-      readonly _tag: "Detaching";
-      readonly snapshot: Transport.Connected;
+      readonly _tag: "Connected";
+      readonly snapshot: Snapshot;
+    } | {
+      readonly _tag: "Disconnected";
+      readonly snapshot: Snapshot;
+      readonly discovery: Discovery | null;
+    } | {
+      readonly _tag: "Failure";
+      readonly error: DomainKit.Error;
     } | {
       readonly _tag: "Loading";
+      readonly snapshot: Snapshot | null;
+    } | {
+      readonly _tag: "Reconnect";
+      readonly snapshot: Snapshot;
     } | {
       readonly _tag: "Redirecting";
-      readonly snapshot: Disconnected;
+      readonly url: string;
+    } | {
+      readonly _tag: "SelectionRequired";
+      readonly snapshot: Snapshot | null;
+      readonly connectionId: string;
+      readonly candidates: ReadonlyArray<Candidate>;
     } | {
       readonly _tag: "Submitting";
-      readonly snapshot: Disconnected;
-    }, cases: Cases): import("effect/Unify").Unify<ReturnType<Cases["Detaching" | "Loading" | "Redirecting" | "Submitting"]>>;
+      readonly snapshot: Snapshot | null;
+    }, cases: Cases): import("effect/Unify").Unify<ReturnType<Cases["Connected" | "Disconnected" | "Failure" | "Loading" | "Reconnect" | "Redirecting" | "SelectionRequired" | "Submitting"]>>;
   };
-  readonly Detaching: Data.TaggedEnum.ConstructorFrom<{
-    readonly _tag: "Detaching";
-    readonly snapshot: Transport.Connected;
+  readonly Connected: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "Connected";
+    readonly snapshot: Snapshot;
+  }, "_tag">;
+  readonly Disconnected: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "Disconnected";
+    readonly snapshot: Snapshot;
+    readonly discovery: Discovery | null;
+  }, "_tag">;
+  readonly Failure: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "Failure";
+    readonly error: DomainKit.Error;
   }, "_tag">;
   readonly Loading: Data.TaggedEnum.ConstructorFrom<{
     readonly _tag: "Loading";
+    readonly snapshot: Snapshot | null;
+  }, "_tag">;
+  readonly Reconnect: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "Reconnect";
+    readonly snapshot: Snapshot;
   }, "_tag">;
   readonly Redirecting: Data.TaggedEnum.ConstructorFrom<{
     readonly _tag: "Redirecting";
-    readonly snapshot: Disconnected;
+    readonly url: string;
+  }, "_tag">;
+  readonly SelectionRequired: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "SelectionRequired";
+    readonly snapshot: Snapshot | null;
+    readonly connectionId: string;
+    readonly candidates: ReadonlyArray<Candidate>;
   }, "_tag">;
   readonly Submitting: Data.TaggedEnum.ConstructorFrom<{
     readonly _tag: "Submitting";
-    readonly snapshot: Disconnected;
+    readonly snapshot: Snapshot | null;
   }, "_tag">;
 };
-type State$2 = LocalState$2 | Transport.ConnectionSnapshot | Failure;
-type Disconnected = Extract<Transport.ConnectionSnapshot, {
-  readonly _tag: "Disconnected";
-}>;
-interface Controller$2 {
-  readonly attach: (connection: Transport.ReusableConnection, target: Transport.ProviderTarget) => void;
-  readonly connect: (method: Transport.Method) => void;
+interface ConnectInput {
+  readonly provider: string;
+  readonly method: Storage.AuthMethod;
+  /** Keyed by the descriptor's field names. Ignored by the interactive methods. */
+  readonly values?: Readonly<Record<string, string>>;
+  /** Where an interactive method returns the customer. */
+  readonly returnTo?: string;
+}
+interface Controller$1 {
+  readonly state: State$1;
+  readonly snapshot: Snapshot | null;
+  readonly discovery: Discovery | null;
+  readonly providers: ReadonlyArray<Descriptor>;
+  readonly connect: (input: ConnectInput) => void;
+  /** Attach the domain to a connection this owner already has. */
+  readonly reuse: (input: {
+    readonly connectionId: string;
+    readonly zone?: string;
+  }) => void;
+  /** Answer `SelectionRequired` by naming the zone that serves the domain. */
+  readonly select: (zone: string) => void;
   readonly detach: () => void;
+  readonly disconnect: () => void;
+  /** Re-inspect the domain, discarding any failure. */
+  readonly refresh: () => void;
+  /** Re-run the step that failed; without one, re-inspect. */
   readonly retry: () => void;
-  readonly state: State$2;
 }
-type Command$2 = Data.TaggedEnum<{
-  Attach: {
-    readonly connectionId: string;
-    readonly target: Transport.ProviderTarget;
+interface Options$2 {
+  readonly domain: string;
+  /**
+   * Where an interactive method returns the customer. Defaults to the page they started from;
+   * pass `null` to send none and let the server's `defaultReturnTo` decide.
+   */
+  readonly returnTo?: string | null;
+}
+/**
+ * The domain's connection, and the four ways to change it. Discovery runs on mount whenever the
+ * transport declares it and the domain has no connection yet; a discovery failure is not the
+ * customer's problem, so the provider list still renders.
+ */
+declare function useController$2({ domain, returnTo }: Options$2): Controller$1;
+interface RootState$3 extends Record<string, unknown> {
+  readonly status: State$1["_tag"];
+}
+interface RootProps$5 extends PartProps<"div", RootState$3> {
+  readonly controller: Controller$1;
+}
+declare function Root$5({ controller, ...props }: RootProps$5): ReactElement;
+interface OutcomeProps$2 extends PartProps<"p", RootState$3> {
+  readonly controller: Controller$1;
+}
+/** The failure sentence, chosen by the error's reason, plus the retry that reason allows. */
+declare function Outcome$2({ controller, ...props }: OutcomeProps$2): ReactElement | null;
+interface StatusProps$3 extends PartProps<"p", RootState$3> {
+  readonly controller: Controller$1;
+}
+declare function Status$3({ controller, ...props }: StatusProps$3): ReactElement;
+interface FormProps extends PartProps<"div", RootState$3> {
+  readonly controller: Controller$1;
+}
+/**
+ * Everything a disconnected domain can do: a connection discovery already found, the connections
+ * this owner already has, then each provider's declared methods.
+ */
+declare function Form({ controller, ...props }: FormProps): ReactElement;
+interface DialogProps$1 {
+  readonly controller: Controller$1;
+  readonly children?: ReactNode;
+  /** Replace the dialog surface: a drawer, a panel, whatever the host already has. */
+  readonly render?: (props: {
+    readonly open: boolean;
+    readonly children: ReactNode;
+  }) => ReactNode;
+  readonly title?: ReactNode;
+  readonly trigger?: ReactNode;
+}
+/** The connect surface. Without `render` it is a Base UI dialog behind `trigger`. */
+declare function Dialog$1({ children, controller, render, title, trigger }: DialogProps$1): ReactElement;
+interface CardProps$1 extends PartProps<"div", RootState$3> {
+  readonly controller: Controller$1;
+}
+/** A connected domain: which provider holds it, and how to let it go. */
+declare function Card$1({ controller, ...props }: CardProps$1): ReactElement;
+interface FlowProps$2 extends Omit<RootProps$5, "controller"> {
+  readonly domain: string;
+  readonly returnTo?: string | null;
+}
+/** Connection on its own: the card once connected, the dialog until then. */
+declare function Flow$2({ domain, returnTo, ...props }: FlowProps$2): ReactElement;
+declare namespace provision_d_exports {
+  export { Actions, ActionsProps, Controller$2 as Controller, Dialog, DialogProps, Flow$1 as Flow, FlowProps$1 as FlowProps, Options$1 as Options, Outcome$1 as Outcome, OutcomeProps$1 as OutcomeProps, Root$4 as Root, RootProps$4 as RootProps, RootState$2 as RootState, State$2 as State, Status$2 as Status, StatusProps$2 as StatusProps, useController$1 as useController };
+}
+interface Options$1 {
+  readonly domain: string;
+  readonly requirements: ReadonlyArray<DnsRecord.Model>;
+  readonly onApplied?: (receipt: Receipt.Model) => void;
+}
+declare function useController$1({ domain, onApplied, requirements }: Options$1): Controller$2;
+interface RootState$2 extends Record<string, unknown> {
+  readonly status: State$2["_tag"];
+}
+interface RootProps$4 extends PartProps<"div", RootState$2> {
+  readonly controller: Controller$2;
+}
+declare function Root$4({ controller, ...props }: RootProps$4): ReactElement;
+interface DialogProps extends Omit<DialogProps$3, "kind"> {}
+declare function Dialog(props: DialogProps): ReactElement;
+interface ActionsProps extends Omit<ActionsProps$2, "kind"> {}
+/** Approve and Decline for a plan already under review. */
+declare function Actions(props: ActionsProps): ReactElement | null;
+interface OutcomeProps$1 extends Omit<OutcomeProps$4, "kind"> {}
+declare function Outcome$1(props: OutcomeProps$1): ReactElement | null;
+interface StatusProps$2 extends Omit<StatusProps$5, "kind"> {}
+declare function Status$2(props: StatusProps$2): ReactElement;
+interface FlowProps$1 extends Omit<RootProps$4, "controller"> {
+  readonly domain: string;
+  readonly onApplied?: (receipt: Receipt.Model) => void;
+  readonly requirements: ReadonlyArray<DnsRecord.Model>;
+  readonly trigger?: ReactNode;
+}
+/** Provisioning on its own: a trigger that plans, then the review dialog. */
+declare function Flow$1({ domain, onApplied, requirements, trigger, ...props }: FlowProps$1): import("react/jsx-runtime").JSX.Element;
+declare namespace verify_d_exports {
+  export { Controller, Evidence, EvidenceProps, HostEvidence, ObserveAction, ObserveActionProps, Options, Outcome, OutcomeProps, Readiness$1 as Readiness, Requirement, Root$3 as Root, RootProps$3 as RootProps, RootState$1 as RootState, State, Status$1 as Status, StatusProps$1 as StatusProps, useController };
+}
+type Readiness$1 = Transport.Readiness;
+type HostEvidence = Readiness$1["host"][number];
+type Requirement = Readiness$1["requirements"][number];
+type Evidence = Requirement["evidence"][number];
+/**
+ * Readiness rides on the state rather than a ref, so it can never outlive the render that
+ * produced it: a controller pointed at a new domain has no readiness in the very first frame.
+ */
+type State = Data.TaggedEnum<{
+  Idle: {};
+  Observing: {
+    readonly readiness: Readiness$1 | null;
+  };
+  Observed: {
+    readonly readiness: Readiness$1;
   };
-  Connect: {
-    readonly method: Transport.Method;
+  Failure: {
+    readonly error: DomainKit.Error;
+    readonly readiness: Readiness$1 | null;
   };
-  Detach: {};
-  Retry: {};
 }>;
-declare const Command$2: {
-  readonly $is: <Tag extends "Attach" | "Connect" | "Detach" | "Retry">(tag: Tag) => (u: unknown) => u is Extract<{
-    readonly _tag: "Attach";
-    readonly connectionId: string;
-    readonly target: Transport.ProviderTarget;
+declare const State: {
+  readonly $is: <Tag extends "Failure" | "Idle" | "Observed" | "Observing">(tag: Tag) => (u: unknown) => u is Extract<{
+    readonly _tag: "Failure";
+    readonly error: DomainKit.Error;
+    readonly readiness: Readiness$1 | null;
   }, {
     readonly _tag: Tag;
   }> | Extract<{
-    readonly _tag: "Connect";
-    readonly method: Transport.Method;
+    readonly _tag: "Idle";
   }, {
     readonly _tag: Tag;
   }> | Extract<{
-    readonly _tag: "Detach";
+    readonly _tag: "Observed";
+    readonly readiness: Readiness$1;
   }, {
     readonly _tag: Tag;
   }> | Extract<{
-    readonly _tag: "Retry";
+    readonly _tag: "Observing";
+    readonly readiness: Readiness$1 | null;
   }, {
     readonly _tag: Tag;
   }>;
   readonly $match: {
-    <Cases extends { readonly [Tag in "Attach" | "Connect" | "Detach" | "Retry"]: (args: Extract<{
-      readonly _tag: "Attach";
-      readonly connectionId: string;
-      readonly target: Transport.ProviderTarget;
+    <Cases extends { readonly [Tag in "Failure" | "Idle" | "Observed" | "Observing"]: (args: Extract<{
+      readonly _tag: "Failure";
+      readonly error: DomainKit.Error;
+      readonly readiness: Readiness$1 | null;
     } | {
-      readonly _tag: "Connect";
-      readonly method: Transport.Method;
+      readonly _tag: "Idle";
     } | {
-      readonly _tag: "Detach";
+      readonly _tag: "Observed";
+      readonly readiness: Readiness$1;
     } | {
-      readonly _tag: "Retry";
+      readonly _tag: "Observing";
+      readonly readiness: Readiness$1 | null;
     }, {
       readonly _tag: Tag;
     }>) => any; }>(cases: Cases): (value: {
-      readonly _tag: "Attach";
-      readonly connectionId: string;
-      readonly target: Transport.ProviderTarget;
+      readonly _tag: "Failure";
+      readonly error: DomainKit.Error;
+      readonly readiness: Readiness$1 | null;
     } | {
-      readonly _tag: "Connect";
-      readonly method: Transport.Method;
+      readonly _tag: "Idle";
     } | {
-      readonly _tag: "Detach";
+      readonly _tag: "Observed";
+      readonly readiness: Readiness$1;
     } | {
-      readonly _tag: "Retry";
-    }) => import("effect/Unify").Unify<ReturnType<Cases["Attach" | "Connect" | "Detach" | "Retry"]>>;
-    <Cases extends { readonly [Tag in "Attach" | "Connect" | "Detach" | "Retry"]: (args: Extract<{
-      readonly _tag: "Attach";
-      readonly connectionId: string;
-      readonly target: Transport.ProviderTarget;
+      readonly _tag: "Observing";
+      readonly readiness: Readiness$1 | null;
+    }) => import("effect/Unify").Unify<ReturnType<Cases["Failure" | "Idle" | "Observed" | "Observing"]>>;
+    <Cases extends { readonly [Tag in "Failure" | "Idle" | "Observed" | "Observing"]: (args: Extract<{
+      readonly _tag: "Failure";
+      readonly error: DomainKit.Error;
+      readonly readiness: Readiness$1 | null;
     } | {
-      readonly _tag: "Connect";
-      readonly method: Transport.Method;
+      readonly _tag: "Idle";
     } | {
-      readonly _tag: "Detach";
+      readonly _tag: "Observed";
+      readonly readiness: Readiness$1;
     } | {
-      readonly _tag: "Retry";
+      readonly _tag: "Observing";
+      readonly readiness: Readiness$1 | null;
     }, {
       readonly _tag: Tag;
     }>) => any; }>(value: {
-      readonly _tag: "Attach";
-      readonly connectionId: string;
-      readonly target: Transport.ProviderTarget;
+      readonly _tag: "Failure";
+      readonly error: DomainKit.Error;
+      readonly readiness: Readiness$1 | null;
     } | {
-      readonly _tag: "Connect";
-      readonly method: Transport.Method;
+      readonly _tag: "Idle";
     } | {
-      readonly _tag: "Detach";
+      readonly _tag: "Observed";
+      readonly readiness: Readiness$1;
     } | {
-      readonly _tag: "Retry";
-    }, cases: Cases): import("effect/Unify").Unify<ReturnType<Cases["Attach" | "Connect" | "Detach" | "Retry"]>>;
+      readonly _tag: "Observing";
+      readonly readiness: Readiness$1 | null;
+    }, cases: Cases): import("effect/Unify").Unify<ReturnType<Cases["Failure" | "Idle" | "Observed" | "Observing"]>>;
   };
-  readonly Attach: Data.TaggedEnum.ConstructorFrom<{
-    readonly _tag: "Attach";
-    readonly connectionId: string;
-    readonly target: Transport.ProviderTarget;
+  readonly Failure: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "Failure";
+    readonly error: DomainKit.Error;
+    readonly readiness: Readiness$1 | null;
   }, "_tag">;
-  readonly Connect: Data.TaggedEnum.ConstructorFrom<{
-    readonly _tag: "Connect";
-    readonly method: Transport.Method;
+  readonly Idle: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "Idle";
   }, "_tag">;
-  readonly Detach: Data.TaggedEnum.ConstructorFrom<{
-    readonly _tag: "Detach";
+  readonly Observed: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "Observed";
+    readonly readiness: Readiness$1;
   }, "_tag">;
-  readonly Retry: Data.TaggedEnum.ConstructorFrom<{
-    readonly _tag: "Retry";
+  readonly Observing: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "Observing";
+    readonly readiness: Readiness$1 | null;
   }, "_tag">;
 };
-interface Model$2 {
-  readonly command: Atom.AtomResultFn<Command$2, void>;
-  readonly state: Atom.Atom<State$2>;
+interface Controller {
+  readonly state: State;
+  /** The latest readiness, kept while a new observation runs. */
+  readonly readiness: Readiness$1 | null;
+  readonly observe: () => void;
+  /** Observe again after a failure. */
+  readonly retry: () => void;
+  /** Whether this controller re-observes at `nextCheckAt` while mounted. */
+  readonly polling: boolean;
 }
-declare function useModel$2(domain: string): Model$2;
-declare function useController$2(domain: string): Controller$2;
+interface Options {
+  readonly domain: string;
+  /**
+   * What to look for. Supplied requirements win over the attachment's latest provisioning receipt,
+   * which is what lets a domain with no attachment be verified at all.
+   */
+  readonly requirements?: ReadonlyArray<DnsRecord.Model>;
+  /** Re-observe at each `nextCheckAt` while mounted. Default true. */
+  readonly polling?: boolean;
+}
+/** Observe once on mount, then follow the readiness's own `nextCheckAt` while polling is on. */
+declare function useController({ domain, polling, requirements }: Options): Controller;
 interface RootState$1 extends Record<string, unknown> {
-  readonly status: State$2["_tag"];
-}
-interface RootProps$5 extends PartProps<"div", RootState$1> {
-  readonly status?: State$2["_tag"];
-}
-declare function Root$5({ children, status, ...props }: RootProps$5): ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
-interface StatusState extends Record<string, unknown> {
-  readonly status: State$2["_tag"];
-}
-interface StatusProps$2 extends PartProps<"div", StatusState> {
-  readonly state: State$2;
-}
-declare function Status$2({ children, state, ...props }: StatusProps$2): ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
-interface TriggerProps extends Omit<ComponentPropsWithoutRef<typeof Dialog.Trigger>, "children"> {
-  readonly children: ReactNode;
-}
-interface ConnectTriggerProps extends Omit<TriggerProps, "children"> {
-  readonly children?: ReactNode;
-  readonly provider: ProviderDescriptor;
+  readonly status: State["_tag"];
 }
-declare function Trigger({ children, ...props }: TriggerProps): import("react/jsx-runtime").JSX.Element;
-declare function ConnectTrigger({ children, provider, ...props }: ConnectTriggerProps): import("react/jsx-runtime").JSX.Element;
-interface ActionState extends Record<string, unknown> {
-  readonly authentication: "attach" | "integration" | "oauth" | "token";
+interface RootProps$3 extends PartProps<"div", RootState$1> {
+  readonly controller: Controller;
 }
-interface OAuthActionProps extends PartProps<"button", ActionState> {
-  readonly controller: Controller$2;
-  readonly label: string;
+declare function Root$3({ controller, ...props }: RootProps$3): ReactElement;
+interface ObserveActionProps extends PartProps<"button", RootState$1> {
+  readonly controller: Controller;
 }
-declare function OAuthAction({ controller, label, ...props }: OAuthActionProps): ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
-interface IntegrationActionProps extends PartProps<"button", ActionState> {
-  readonly controller: Controller$2;
-  readonly label: string;
+declare function ObserveAction({ controller, ...props }: ObserveActionProps): ReactElement;
+interface EvidenceProps {
+  readonly readiness: Readiness$1;
 }
-declare function IntegrationAction({ controller, label, ...props }: IntegrationActionProps): ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
-interface AttachActionProps extends PartProps<"button", ActionState> {
-  readonly connection: Transport.ReusableConnection;
-  readonly controller: Controller$2;
-  readonly label: string;
-  readonly target: Transport.ProviderTarget;
+/**
+ * Per-requirement readiness and, below it, the host's own evidence: an SES identity, a certificate,
+ * anything DomainKit cannot observe but the host feeds in.
+ */
+declare function Evidence({ readiness }: EvidenceProps): ReactElement;
+interface OutcomeProps extends PartProps<"p", RootState$1> {
+  readonly controller: Controller;
 }
-declare function AttachAction({ connection, controller, label, target, ...props }: AttachActionProps): ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
-interface TokenActionProps extends Omit<PartProps<"form", ActionState>, "method"> {
-  readonly controller: Controller$2;
-  readonly method: Extract<Transport.AuthenticationMethod, {
-    readonly _tag: "Token";
-  }>;
+declare function Outcome({ controller, ...props }: OutcomeProps): ReactElement | null;
+interface StatusProps$1 extends Omit<RootProps$3, "render"> {
+  /** Replace the popover surface with a panel of the host's own. */
+  readonly render?: (props: {
+    readonly open: boolean;
+    readonly children: ReactNode;
+  }) => ReactNode;
 }
-declare function TokenAction({ controller, method, ...props }: TokenActionProps): ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
-interface DialogProps$1 {
-  readonly controller: Controller$2;
-  readonly snapshot: Disconnected;
+/** The default verification slot: a button that observes, with the evidence behind it. */
+declare function Status$1({ controller, render, ...props }: StatusProps$1): ReactElement;
+declare namespace domain_d_exports {
+  export { ActionsSlotProps, ConnectionSlotProps, Flow, FlowProps, FlowState, RecordsSlotProps, Slots, VerificationSlotProps };
 }
-declare const targetLabel: (target: Transport.ProviderTarget) => string;
-declare function Dialog$2({ controller, snapshot }: DialogProps$1): import("react/jsx-runtime").JSX.Element;
-interface FlowProps$2 extends Omit<RootProps$5, "children"> {
+interface RecordsSlotProps {
+  readonly records: ReadonlyArray<DnsRecord.Model>;
+  readonly readiness: Readiness$1 | null;
+  readonly controller: Controller;
   readonly domain: string;
 }
-declare function Flow$2({ domain, ...props }: FlowProps$2): import("react/jsx-runtime").JSX.Element;
-interface RetryActionProps extends PartProps<"button", {
-  readonly status: "Failure";
-}> {
-  readonly controller: Controller$2;
-  readonly kind?: "after-user-action" | "retry";
-}
-declare function RetryAction$1({ controller, kind, ...props }: RetryActionProps): ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
-interface CardProps$1 extends PartProps<"div", {
-  readonly status: State$2["_tag"];
-}> {
-  readonly status: State$2["_tag"];
-}
-declare function Card$1({ status, ...props }: CardProps$1): ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
-interface CardIdentityProps extends PartProps<"div", {
-  readonly status: State$2["_tag"];
-}> {
-  readonly status: State$2["_tag"];
-}
-declare function CardIdentity({ status, ...props }: CardIdentityProps): ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
-interface CardActionsProps extends PartProps<"div", {
-  readonly status: State$2["_tag"];
-}> {
-  readonly status: State$2["_tag"];
-}
-declare function CardActions({ status, ...props }: CardActionsProps): ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
-interface DisconnectDialogProps {
-  readonly connection: Transport.Connected;
-  readonly controller: Controller$2;
-  readonly onOpenChange?: (open: boolean) => void;
-  readonly open?: boolean;
-  readonly trigger?: ReactElement | null;
+interface VerificationSlotProps {
+  readonly controller: Controller;
+  readonly domain: string;
 }
-declare function DisconnectDialog({ connection, controller, onOpenChange, open: openProp, trigger }: DisconnectDialogProps): import("react/jsx-runtime").JSX.Element;
-type Connected = Transport.Connected;
-declare namespace domain_d_exports {
-  export { Flow$1 as Flow, FlowProps$1 as FlowProps };
+interface ActionsSlotProps {
+  readonly connection: Controller$1;
+  readonly provisioning: Controller$2;
+  readonly cleanup: Controller$2;
+  readonly domain: string;
 }
-interface FlowProps$1 {
+interface ConnectionSlotProps {
+  readonly controller: Controller$1;
   readonly domain: string;
-  readonly receiptId?: string;
-  readonly records: ReadonlyArray<Transport.DnsRecord>;
 }
-declare function Flow$1({ domain, receiptId, records }: FlowProps$1): import("react/jsx-runtime").JSX.Element;
+/**
+ * Each slot replaces one part of the flow and keeps the rest. Every slot has a default, so
+ * `<Domain.Flow domain requirements />` is complete on its own.
+ */
+interface Slots {
+  /** The requirements table. Defaults to `Records.Table` with readiness when there is any. */
+  readonly records?: (props: RecordsSlotProps) => ReactNode;
+  /** Defaults to `Verify.Status`. Rendered only when the transport declares `verification`. */
+  readonly verification?: (props: VerificationSlotProps) => ReactNode;
+  /** Defaults to Approve and Decline, plus cleanup when the transport declares it. */
+  readonly actions?: (props: ActionsSlotProps) => ReactNode;
+  /** Defaults to `Connect.Card` once connected and `Connect.Dialog` until then. */
+  readonly connection?: (props: ConnectionSlotProps) => ReactNode;
+}
+interface FlowState extends Record<string, unknown> {
+  readonly connection: State$1["_tag"];
+  readonly provisioning: State$2["_tag"];
+}
+interface FlowProps extends Omit<PartProps<"div", FlowState>, "children"> {
+  readonly domain: string;
+  readonly requirements: ReadonlyArray<DnsRecord.Model>;
+  readonly slots?: Slots;
+  readonly onApplied?: (receipt: Receipt.Model) => void;
+  readonly onCleaned?: (receipt: Receipt.Model) => void;
+  /**
+   * Where an interactive provider flow returns the customer. Defaults to the page they started
+   * from; pass `null` to let the server's `defaultReturnTo` decide.
+   */
+  readonly returnTo?: string | null;
+  /** Render this domain's state without the controls that change it. Defaults to the root's. */
+  readonly readOnly?: boolean;
+}
+/**
+ * The whole lifecycle for one domain: connect, review, apply, observe, clean up. The flow renders
+ * only what the transport declares, and every part of it is a slot with a default. It adds no
+ * layout containers of its own, so a host's grid can place the slot output directly.
+ */
+declare function Flow({ domain, onApplied, onCleaned, readOnly, requirements, returnTo, slots, ...props }: FlowProps): ReactElement;
 //#endregion
 //#region src/icons.d.ts
-type Icons = {
+/**
+ * Every glyph the package draws, in one place. Parts read them from context; none of them takes
+ * an icon prop of its own, so a host swaps the whole set once on `DomainKit.Root`.
+ */
+interface Icons {
+  readonly close: ReactNode;
   readonly copied: ReactNode;
   readonly copy: ReactNode;
   readonly download: ReactNode;
+  readonly external: ReactNode;
+  readonly failure: ReactNode;
+  readonly pending: ReactNode;
+  readonly success: ReactNode;
+}
+declare const defaultIcons: {
+  readonly close: import("react/jsx-runtime").JSX.Element;
+  readonly copied: import("react/jsx-runtime").JSX.Element;
+  readonly copy: import("react/jsx-runtime").JSX.Element;
+  readonly download: import("react/jsx-runtime").JSX.Element;
+  readonly external: import("react/jsx-runtime").JSX.Element;
+  readonly failure: import("react/jsx-runtime").JSX.Element;
+  readonly pending: import("react/jsx-runtime").JSX.Element;
+  readonly success: import("react/jsx-runtime").JSX.Element;
 };
-declare namespace lifecycle_d_exports {
-  export { Event, Listener };
-}
-/** User-action lifecycle events suitable for host notifications and telemetry. */
-type Event = Data.TaggedEnum<{
-  ConnectionEstablished: {
-    readonly connection: Transport.Connected;
-    readonly source: "attach" | "connect";
-  };
-  DomainDetached: {
-    readonly connection: Transport.Connected;
-    readonly result: Transport.DetachResult;
-  };
-  RecordsApplied: {
-    readonly connection: Transport.Connected;
-    readonly result: Extract<Transport.ApplyResult, {
-      readonly _tag: "Applied";
-    }>;
-  };
-  RecordsCleaned: {
-    readonly connection: Transport.Connected;
-    readonly result: Extract<Transport.CleanupResult, {
-      readonly _tag: "Cleaned";
-    }>;
-  };
-  RecordsPartiallyApplied: {
-    readonly connection: Transport.Connected;
-    readonly result: Extract<Transport.ApplyResult, {
-      readonly _tag: "Partial";
-    }>;
-  };
-  RecordsPartiallyCleaned: {
-    readonly connection: Transport.Connected;
-    readonly result: Extract<Transport.CleanupResult, {
-      readonly _tag: "Partial";
-    }>;
-  };
-}>;
-declare const Event: {
-  readonly $is: <Tag extends "ConnectionEstablished" | "DomainDetached" | "RecordsApplied" | "RecordsCleaned" | "RecordsPartiallyApplied" | "RecordsPartiallyCleaned">(tag: Tag) => (u: unknown) => u is Extract<{
-    readonly _tag: "ConnectionEstablished";
-    readonly connection: Transport.Connected;
-    readonly source: "attach" | "connect";
-  }, {
-    readonly _tag: Tag;
-  }> | Extract<{
-    readonly _tag: "DomainDetached";
-    readonly connection: Transport.Connected;
-    readonly result: Transport.DetachResult;
-  }, {
-    readonly _tag: Tag;
-  }> | Extract<{
-    readonly _tag: "RecordsApplied";
-    readonly connection: Transport.Connected;
-    readonly result: Extract<Transport.ApplyResult, {
-      readonly _tag: "Applied";
-    }>;
-  }, {
-    readonly _tag: Tag;
-  }> | Extract<{
-    readonly _tag: "RecordsCleaned";
-    readonly connection: Transport.Connected;
-    readonly result: Extract<Transport.CleanupResult, {
-      readonly _tag: "Cleaned";
-    }>;
-  }, {
-    readonly _tag: Tag;
-  }> | Extract<{
-    readonly _tag: "RecordsPartiallyApplied";
-    readonly connection: Transport.Connected;
-    readonly result: Extract<Transport.ApplyResult, {
-      readonly _tag: "Partial";
-    }>;
-  }, {
-    readonly _tag: Tag;
-  }> | Extract<{
-    readonly _tag: "RecordsPartiallyCleaned";
-    readonly connection: Transport.Connected;
-    readonly result: Extract<Transport.CleanupResult, {
-      readonly _tag: "Partial";
-    }>;
-  }, {
-    readonly _tag: Tag;
-  }>;
-  readonly $match: {
-    <Cases extends { readonly [Tag in "ConnectionEstablished" | "DomainDetached" | "RecordsApplied" | "RecordsCleaned" | "RecordsPartiallyApplied" | "RecordsPartiallyCleaned"]: (args: Extract<{
-      readonly _tag: "ConnectionEstablished";
-      readonly connection: Transport.Connected;
-      readonly source: "attach" | "connect";
-    } | {
-      readonly _tag: "DomainDetached";
-      readonly connection: Transport.Connected;
-      readonly result: Transport.DetachResult;
-    } | {
-      readonly _tag: "RecordsApplied";
-      readonly connection: Transport.Connected;
-      readonly result: Extract<Transport.ApplyResult, {
-        readonly _tag: "Applied";
-      }>;
-    } | {
-      readonly _tag: "RecordsCleaned";
-      readonly connection: Transport.Connected;
-      readonly result: Extract<Transport.CleanupResult, {
-        readonly _tag: "Cleaned";
-      }>;
-    } | {
-      readonly _tag: "RecordsPartiallyApplied";
-      readonly connection: Transport.Connected;
-      readonly result: Extract<Transport.ApplyResult, {
-        readonly _tag: "Partial";
-      }>;
-    } | {
-      readonly _tag: "RecordsPartiallyCleaned";
-      readonly connection: Transport.Connected;
-      readonly result: Extract<Transport.CleanupResult, {
-        readonly _tag: "Partial";
-      }>;
-    }, {
-      readonly _tag: Tag;
-    }>) => any; }>(cases: Cases): (value: {
-      readonly _tag: "ConnectionEstablished";
-      readonly connection: Transport.Connected;
-      readonly source: "attach" | "connect";
-    } | {
-      readonly _tag: "DomainDetached";
-      readonly connection: Transport.Connected;
-      readonly result: Transport.DetachResult;
-    } | {
-      readonly _tag: "RecordsApplied";
-      readonly connection: Transport.Connected;
-      readonly result: Extract<Transport.ApplyResult, {
-        readonly _tag: "Applied";
-      }>;
-    } | {
-      readonly _tag: "RecordsCleaned";
-      readonly connection: Transport.Connected;
-      readonly result: Extract<Transport.CleanupResult, {
-        readonly _tag: "Cleaned";
-      }>;
-    } | {
-      readonly _tag: "RecordsPartiallyApplied";
-      readonly connection: Transport.Connected;
-      readonly result: Extract<Transport.ApplyResult, {
-        readonly _tag: "Partial";
-      }>;
-    } | {
-      readonly _tag: "RecordsPartiallyCleaned";
-      readonly connection: Transport.Connected;
-      readonly result: Extract<Transport.CleanupResult, {
-        readonly _tag: "Partial";
-      }>;
-    }) => import("effect/Unify").Unify<ReturnType<Cases["ConnectionEstablished" | "DomainDetached" | "RecordsApplied" | "RecordsCleaned" | "RecordsPartiallyApplied" | "RecordsPartiallyCleaned"]>>;
-    <Cases extends { readonly [Tag in "ConnectionEstablished" | "DomainDetached" | "RecordsApplied" | "RecordsCleaned" | "RecordsPartiallyApplied" | "RecordsPartiallyCleaned"]: (args: Extract<{
-      readonly _tag: "ConnectionEstablished";
-      readonly connection: Transport.Connected;
-      readonly source: "attach" | "connect";
-    } | {
-      readonly _tag: "DomainDetached";
-      readonly connection: Transport.Connected;
-      readonly result: Transport.DetachResult;
-    } | {
-      readonly _tag: "RecordsApplied";
-      readonly connection: Transport.Connected;
-      readonly result: Extract<Transport.ApplyResult, {
-        readonly _tag: "Applied";
-      }>;
-    } | {
-      readonly _tag: "RecordsCleaned";
-      readonly connection: Transport.Connected;
-      readonly result: Extract<Transport.CleanupResult, {
-        readonly _tag: "Cleaned";
-      }>;
-    } | {
-      readonly _tag: "RecordsPartiallyApplied";
-      readonly connection: Transport.Connected;
-      readonly result: Extract<Transport.ApplyResult, {
-        readonly _tag: "Partial";
-      }>;
-    } | {
-      readonly _tag: "RecordsPartiallyCleaned";
-      readonly connection: Transport.Connected;
-      readonly result: Extract<Transport.CleanupResult, {
-        readonly _tag: "Partial";
-      }>;
-    }, {
-      readonly _tag: Tag;
-    }>) => any; }>(value: {
-      readonly _tag: "ConnectionEstablished";
-      readonly connection: Transport.Connected;
-      readonly source: "attach" | "connect";
-    } | {
-      readonly _tag: "DomainDetached";
-      readonly connection: Transport.Connected;
-      readonly result: Transport.DetachResult;
-    } | {
-      readonly _tag: "RecordsApplied";
-      readonly connection: Transport.Connected;
-      readonly result: Extract<Transport.ApplyResult, {
-        readonly _tag: "Applied";
-      }>;
-    } | {
-      readonly _tag: "RecordsCleaned";
-      readonly connection: Transport.Connected;
-      readonly result: Extract<Transport.CleanupResult, {
-        readonly _tag: "Cleaned";
-      }>;
-    } | {
-      readonly _tag: "RecordsPartiallyApplied";
-      readonly connection: Transport.Connected;
-      readonly result: Extract<Transport.ApplyResult, {
-        readonly _tag: "Partial";
-      }>;
-    } | {
-      readonly _tag: "RecordsPartiallyCleaned";
-      readonly connection: Transport.Connected;
-      readonly result: Extract<Transport.CleanupResult, {
-        readonly _tag: "Partial";
-      }>;
-    }, cases: Cases): import("effect/Unify").Unify<ReturnType<Cases["ConnectionEstablished" | "DomainDetached" | "RecordsApplied" | "RecordsCleaned" | "RecordsPartiallyApplied" | "RecordsPartiallyCleaned"]>>;
-  };
-  readonly ConnectionEstablished: Data.TaggedEnum.ConstructorFrom<{
-    readonly _tag: "ConnectionEstablished";
-    readonly connection: Transport.Connected;
-    readonly source: "attach" | "connect";
-  }, "_tag">;
-  readonly DomainDetached: Data.TaggedEnum.ConstructorFrom<{
-    readonly _tag: "DomainDetached";
-    readonly connection: Transport.Connected;
-    readonly result: Transport.DetachResult;
-  }, "_tag">;
-  readonly RecordsApplied: Data.TaggedEnum.ConstructorFrom<{
-    readonly _tag: "RecordsApplied";
-    readonly connection: Transport.Connected;
-    readonly result: Extract<Transport.ApplyResult, {
-      readonly _tag: "Applied";
-    }>;
-  }, "_tag">;
-  readonly RecordsCleaned: Data.TaggedEnum.ConstructorFrom<{
-    readonly _tag: "RecordsCleaned";
-    readonly connection: Transport.Connected;
-    readonly result: Extract<Transport.CleanupResult, {
-      readonly _tag: "Cleaned";
-    }>;
-  }, "_tag">;
-  readonly RecordsPartiallyApplied: Data.TaggedEnum.ConstructorFrom<{
-    readonly _tag: "RecordsPartiallyApplied";
-    readonly connection: Transport.Connected;
-    readonly result: Extract<Transport.ApplyResult, {
-      readonly _tag: "Partial";
-    }>;
-  }, "_tag">;
-  readonly RecordsPartiallyCleaned: Data.TaggedEnum.ConstructorFrom<{
-    readonly _tag: "RecordsPartiallyCleaned";
-    readonly connection: Transport.Connected;
-    readonly result: Extract<Transport.CleanupResult, {
-      readonly _tag: "Partial";
-    }>;
-  }, "_tag">;
-};
-type Listener = (event: Event) => void;
+declare function useIcons(): Icons;
 declare namespace messages_d_exports {
-  export { Catalog, english, merge };
+  export { Catalog, EvidenceLike, english, failure, merge };
 }
 interface Catalog {
-  readonly applyCleanup: string;
-  readonly applyDns: string;
-  readonly applyingDns: string;
-  readonly authenticationAlternative: string;
-  readonly automaticUnavailable: string;
+  readonly connect: string;
+  readonly connectWith: (method: string) => string;
+  readonly disconnect: string;
+  readonly detach: string;
   readonly cancel: string;
-  readonly checkAgain: string;
-  readonly checkingDns: string;
+  readonly close: string;
+  readonly retry: string;
+  readonly approve: string;
+  readonly decline: string;
+  readonly reviewChanges: string;
+  readonly cleanUp: string;
   readonly checkDns: string;
-  readonly cleanupConsent: string;
-  readonly cleanupPartial: string;
-  readonly cleaningDns: string;
-  readonly connectProvider: (provider: string) => string;
-  readonly connected: (provider: string) => string;
-  readonly providerAvailable: (provider: string) => string;
+  readonly checkAgain: string;
+  readonly moreActions: string;
+  readonly copy: string;
+  readonly copied: string;
+  readonly copyZone: string;
+  readonly download: string;
+  readonly useConnection: (label: string) => string;
+  readonly chooseZone: string;
+  readonly getToken: string;
+  readonly loading: string;
   readonly connecting: string;
-  readonly close: string;
-  readonly detectingProvider: string;
-  readonly disconnectDomain: string;
-  readonly disconnectConsent: string;
-  readonly disconnecting: string;
+  readonly redirecting: string;
   readonly detaching: string;
+  readonly disconnecting: string;
+  readonly planning: string;
+  readonly approving: string;
+  readonly applying: string;
+  readonly rejecting: string;
+  readonly planningCleanup: string;
+  readonly cleaning: string;
+  readonly observing: string;
+  readonly connectTitle: (provider: string) => string;
+  /** The dialog heading before a provider is chosen. */
+  readonly connectAnyTitle: string;
+  readonly connectDescription: (domain: string) => string;
+  readonly connectedTo: (provider: string) => string;
+  /** Shown where a connect control would be when the customer may not connect. */
+  readonly notConnected: string;
+  readonly reconnectRequired: (provider: string) => string;
   readonly disconnectTitle: (provider: string) => string;
-  readonly domainDisconnected: string;
-  readonly dialogDescription: (domain: string) => string;
-  readonly dialogTitle: (provider: string) => string;
-  readonly openingAuthorization: string;
-  readonly moreActions: string;
-  readonly noChanges: string;
+  readonly disconnectConsent: string;
+  readonly detachConsent: string;
+  readonly detached: string;
+  readonly reusableConnections: string;
+  readonly authenticationAlternative: string;
+  readonly discoveredConnection: (label: string) => string;
+  readonly discoveryAmbiguous: string;
+  readonly discoveryNotFound: (nameservers: ReadonlyArray<string>) => string;
+  readonly noProviders: string;
+  readonly fieldLabel: (name: string) => string;
+  readonly optionalField: string;
+  readonly planTitle: string;
   readonly planConsent: string;
-  readonly planningCleanup: string;
-  readonly planningDns: string;
-  readonly recordsPartiallyApplied: string;
-  readonly reviewCleanup: string;
-  readonly reviewDns: string;
-  readonly retry: string;
-  readonly existingConnection: string;
-  readonly targetUnavailable: string;
-  readonly attachTarget: (target: string) => string;
-  readonly tokenLabel: string;
-}
+  readonly cleanupTitle: string;
+  readonly cleanupConsent: string;
+  readonly noChanges: string;
+  readonly planExpires: (at: string) => string;
+  readonly declinedBy: (actor: string) => string;
+  readonly declineReason: (reason: string) => string;
+  readonly operation: (operation: Plan.Operation) => string;
+  readonly conflictReason: (reason: Plan.Conflict["reason"]) => string;
+  readonly attemptStatus: (status: Storage.AttemptStatus) => string;
+  readonly recordsCaption: (domain: string) => string;
+  readonly headingType: string;
+  readonly headingName: string;
+  readonly headingValue: string;
+  readonly headingStatus: string;
+  readonly headingPurpose: string;
+  readonly priority: (priority: number) => string;
+  readonly ttl: (seconds: number) => string;
+  readonly recordType: (record: DnsRecord.Observed) => string;
+  readonly applied: (receipt: Receipt.Model) => string;
+  readonly cleaned: (receipt: Receipt.Model) => string;
+  readonly partiallyApplied: string;
+  readonly partiallyCleaned: string;
+  readonly outcome: (outcome: Receipt.Outcome) => string;
+  readonly skippedReason: (reason: Receipt.Skipped["reason"]) => string;
+  readonly requirementStatus: (status: Storage.RequirementStatus) => string;
+  readonly overall: (overall: Storage.Overall) => string;
+  readonly evidenceSource: (evidence: EvidenceLike) => string;
+  readonly hostEvidenceStatus: (status: "failed" | "ok" | "pending") => string;
+  /** What the requirement asks for, shown when an observation disagrees with it. */
+  readonly expectedValue: (value: string) => string;
+  /** What one observer actually read back for that name. */
+  readonly observedValues: (values: ReadonlyArray<string>) => string;
+  readonly observedNothing: string;
+  readonly checkedAt: (at: string) => string;
+  readonly nextCheckAt: (at: string) => string;
+  readonly hostEvidence: string;
+  readonly noEvidence: string;
+  readonly invalidInput: (reason: Reason.InvalidInput) => string;
+  readonly unauthenticated: (reason: Reason.Unauthenticated) => string;
+  readonly forbidden: (reason: Reason.Forbidden) => string;
+  readonly notFound: (reason: Reason.NotFound) => string;
+  readonly conflict: (reason: Reason.Conflict) => string;
+  readonly stale: (reason: Reason.Stale) => string;
+  readonly expired: (reason: Reason.Expired) => string;
+  readonly busy: (reason: Reason.Busy) => string;
+  readonly providerRejected: (reason: Reason.ProviderRejected) => string;
+  readonly providerUnavailable: (reason: Reason.ProviderUnavailable) => string;
+  readonly providerConflict: (reason: Reason.ProviderConflict) => string;
+  readonly unsupported: (reason: Reason.Unsupported) => string;
+  readonly reconnect: (reason: Reason.Reconnect) => string;
+  readonly storageFailed: (reason: Reason.StorageFailed) => string;
+  readonly cryptoFailed: (reason: Reason.CryptoFailed) => string;
+  readonly resolverFailed: (reason: Reason.ResolverFailed) => string;
+}
+/** The evidence shapes `Verify` produces, structurally, so the catalog needs no service import. */
+type EvidenceLike = {
+  readonly _tag: "Host";
+  readonly source: string;
+  readonly label: string;
+} | {
+  readonly _tag: "Provider";
+  readonly provider: string;
+} | {
+  readonly _tag: "PublicDns";
+  readonly resolver: string;
+};
 declare const english: Catalog;
 declare const merge: (overrides?: Partial<Catalog>) => Catalog;
+/** The user-facing sentence for a failure, chosen by the error's reason. */
+declare const failure: (error: DomainKit.Error, catalog: Catalog) => string;
 declare namespace theme_d_exports {
   export { Theme, toStyle };
 }
@@ -1014,351 +1353,98 @@ interface Theme {
 }
 declare function toStyle(theme?: Theme): CSSProperties;
 declare namespace domain_kit_d_exports {
-  export { Root$4 as Root, RootProps$4 as RootProps, RootState, useDomainKit };
+  export { ReadOnly, Root$2 as Root, RootProps$2 as RootProps, RootState, StableTransport, useCapabilities, useDomainKit, useReadOnly, useTransport };
 }
 interface RootState extends Record<string, unknown> {
   readonly colorScheme: "dark" | "inherit" | "light";
 }
-interface RootProps$4 extends Omit<PartProps<"div", RootState>, "children"> {
+interface RootProps$2 extends Omit<PartProps<"div", RootState>, "children"> {
   readonly children: ReactNode;
   readonly colorScheme?: RootState["colorScheme"];
   readonly icons?: Partial<Icons>;
-  readonly messages?: Partial<Catalog>;
   readonly marks?: Marks;
+  readonly messages?: Partial<Catalog>;
+  /** Where an interactive provider flow sends the customer. Defaults to `window.location`. */
   readonly navigate?: (url: string) => void;
   readonly onEvent?: Listener;
   readonly portalContainer?: HTMLElement | null;
+  /**
+   * Render the state without the controls that change it, for a customer who may read the domain
+   * but not write to it. Capability gating already hides a group the transport does not declare;
+   * this covers authorization the transport cannot express, such as a member of an organisation.
+   */
+  readonly readOnly?: boolean;
+  /** Bump to re-inspect every mounted domain after a change the UI did not make. */
+  readonly revision?: number;
   readonly theme?: Theme;
-  readonly transport: Layer.Layer<Transport.Service>;
+  /** The transport, by value. Rebuilding it inline on every render does not restart controllers. */
+  readonly transport: Transport.Interface;
 }
 interface ContextValue {
+  readonly capabilities: ReadonlyArray<Transport.Capability>;
   readonly colorScheme: RootState["colorScheme"];
-  readonly navigate: (url: string) => void;
+  readonly emit: Listener;
   readonly marks: Marks;
   readonly messages: Catalog;
-  readonly emit: Listener;
+  readonly navigate: (url: string) => void;
   readonly portalContainer: RefObject<HTMLElement | null>;
+  readonly readOnly: boolean;
+  readonly revision: number;
   readonly themeStyle: ReturnType<typeof toStyle>;
-  readonly runtime: Runtime;
+  readonly transport: Transport.Interface;
 }
-declare function Root$4({ children, colorScheme, icons, marks, messages, navigate, onEvent, portalContainer, theme, transport, ...props }: RootProps$4): import("react/jsx-runtime").JSX.Element;
+interface StableTransport {
+  readonly transport: Transport.Interface;
+  readonly capabilities: ReadonlyArray<Transport.Capability>;
+}
+declare function Root$2({ children, colorScheme, icons, marks, messages, navigate, onEvent, portalContainer, readOnly, revision, theme, transport, ...props }: RootProps$2): import("react/jsx-runtime").JSX.Element;
 declare function useDomainKit(): ContextValue;
+/** The transport `DomainKit.Root` holds, with the identity it keeps for the whole mount. */
+declare function useTransport(): Transport.Interface;
+/** Narrow one subtree to read-only without touching the rest of the page. */
+declare function ReadOnly({ children, value }: {
+  readonly children: ReactNode;
+  readonly value: boolean;
+}): import("react/jsx-runtime").JSX.Element;
+/** Whether this part may offer controls that change the domain. */
+declare function useReadOnly(): boolean;
+/** Which capability groups the host's transport declares, for gating a custom part. */
+declare function useCapabilities(): ReadonlyArray<Transport.Capability>;
 declare namespace operations_d_exports {
-  export { Item, ItemProps, Kind, Lifecycle, List, ListProps, Name, Operation, Priority$1 as Priority, Reason, Record$1 as Record, Root$3 as Root, RootProps$3 as RootProps, Type, Value$1 as Value };
-}
-type Operation = Transport.ProvisioningPlan["operations"][number] | Transport.CleanupPlan["operations"][number];
-type LeafState$1 = Record$1<string, unknown>;
-declare const Kind: (props: PartProps<"span", LeafState$1>) => ReactElement;
-declare const Type: (props: PartProps<"strong", LeafState$1>) => ReactElement;
-declare const Record$1: (props: PartProps<"span", LeafState$1>) => ReactElement;
-declare const Name: (props: PartProps<"span", LeafState$1>) => ReactElement;
-declare const Value$1: (props: PartProps<"code", LeafState$1>) => ReactElement;
-declare const Priority$1: (props: PartProps<"span", LeafState$1>) => ReactElement;
-declare const Reason: (props: PartProps<"span", LeafState$1>) => ReactElement;
+  export { Item, ItemProps, Kind, List, ListProps, Name, Reason$1 as Reason, Record$1 as Record, Root$1 as Root, RootProps$1 as RootProps, Type };
+}
+declare const Kind: (props: PartProps<"span", Record$1<string, unknown>>) => ReactElement;
+declare const Type: (props: PartProps<"strong", Record$1<string, unknown>>) => ReactElement;
+declare const Record$1: (props: PartProps<"span", Record$1<string, unknown>>) => ReactElement;
+declare const Name: (props: PartProps<"span", Record$1<string, unknown>>) => ReactElement;
+declare const Reason$1: (props: PartProps<"span", Record$1<string, unknown>>) => ReactElement;
 interface ItemProps extends PartProps<"li", {
-  readonly operation: Operation["_tag"];
+  readonly operation: Plan.Operation["_tag"];
 }> {
-  readonly operation: Operation;
+  readonly operation: Plan.Operation;
 }
-declare function Item({ operation, ...props }: ItemProps): ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
-interface RootProps$3 extends PartProps<"ul", {
+declare function Item({ operation, ...props }: ItemProps): ReactElement;
+interface RootProps$1 extends PartProps<"ul", {
   readonly count: number;
-  readonly lifecycle: Lifecycle;
+  readonly kind: Plan.Kind;
 }> {
   readonly count?: number;
-  readonly lifecycle: Lifecycle;
-}
-type Lifecycle = "cleanup" | "provisioning";
-declare function Root$3({ count, lifecycle, ...props }: RootProps$3): ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
-interface ListProps extends Omit<RootProps$3, "children" | "count"> {
-  readonly operations: ReadonlyArray<Operation>;
+  readonly kind: Plan.Kind;
 }
-declare function List({ lifecycle, operations, ...props }: ListProps): import("react/jsx-runtime").JSX.Element;
-declare namespace provisioning_d_exports {
-  export { Command$1 as Command, Controller$1 as Controller, Dialog$1 as Dialog, DialogProps, Flow, FlowProps, Model$1 as Model, Outcome$1 as Outcome, RetryAction, Root$2 as Root, RootProps$2 as RootProps, State$1 as State, useController$1 as useController, useModel$1 as useModel };
+declare function Root$1({ count, kind, ...props }: RootProps$1): ReactElement;
+interface ListProps extends Omit<RootProps$1, "children" | "count" | "kind"> {
+  readonly plan: Plan.Model;
 }
-type LocalState$1 = Data.TaggedEnum<{
-  Applying: {
-    readonly plan: Transport.ProvisioningPlan;
-  };
-  Complete: {
-    readonly result: Extract<Transport.ApplyResult, {
-      readonly _tag: "Applied";
-    }>;
-  };
-  Idle: {};
-  Partial: {
-    readonly result: Extract<Transport.ApplyResult, {
-      readonly _tag: "Partial";
-    }>;
-  };
-  Planning: {};
-  Review: {
-    readonly plan: Transport.ProvisioningPlan;
-  };
-}>;
-declare const State$1: {
-  readonly $is: <Tag extends "Applying" | "Complete" | "Idle" | "Partial" | "Planning" | "Review">(tag: Tag) => (u: unknown) => u is Extract<{
-    readonly _tag: "Applying";
-    readonly plan: Transport.ProvisioningPlan;
-  }, {
-    readonly _tag: Tag;
-  }> | Extract<{
-    readonly _tag: "Complete";
-    readonly result: Extract<Transport.ApplyResult, {
-      readonly _tag: "Applied";
-    }>;
-  }, {
-    readonly _tag: Tag;
-  }> | Extract<{
-    readonly _tag: "Idle";
-  }, {
-    readonly _tag: Tag;
-  }> | Extract<{
-    readonly _tag: "Partial";
-    readonly result: Extract<Transport.ApplyResult, {
-      readonly _tag: "Partial";
-    }>;
-  }, {
-    readonly _tag: Tag;
-  }> | Extract<{
-    readonly _tag: "Planning";
-  }, {
-    readonly _tag: Tag;
-  }> | Extract<{
-    readonly _tag: "Review";
-    readonly plan: Transport.ProvisioningPlan;
-  }, {
-    readonly _tag: Tag;
-  }>;
-  readonly $match: {
-    <Cases extends { readonly [Tag in "Applying" | "Complete" | "Idle" | "Partial" | "Planning" | "Review"]: (args: Extract<{
-      readonly _tag: "Applying";
-      readonly plan: Transport.ProvisioningPlan;
-    } | {
-      readonly _tag: "Complete";
-      readonly result: Extract<Transport.ApplyResult, {
-        readonly _tag: "Applied";
-      }>;
-    } | {
-      readonly _tag: "Idle";
-    } | {
-      readonly _tag: "Partial";
-      readonly result: Extract<Transport.ApplyResult, {
-        readonly _tag: "Partial";
-      }>;
-    } | {
-      readonly _tag: "Planning";
-    } | {
-      readonly _tag: "Review";
-      readonly plan: Transport.ProvisioningPlan;
-    }, {
-      readonly _tag: Tag;
-    }>) => any; }>(cases: Cases): (value: {
-      readonly _tag: "Applying";
-      readonly plan: Transport.ProvisioningPlan;
-    } | {
-      readonly _tag: "Complete";
-      readonly result: Extract<Transport.ApplyResult, {
-        readonly _tag: "Applied";
-      }>;
-    } | {
-      readonly _tag: "Idle";
-    } | {
-      readonly _tag: "Partial";
-      readonly result: Extract<Transport.ApplyResult, {
-        readonly _tag: "Partial";
-      }>;
-    } | {
-      readonly _tag: "Planning";
-    } | {
-      readonly _tag: "Review";
-      readonly plan: Transport.ProvisioningPlan;
-    }) => import("effect/Unify").Unify<ReturnType<Cases["Applying" | "Complete" | "Idle" | "Partial" | "Planning" | "Review"]>>;
-    <Cases extends { readonly [Tag in "Applying" | "Complete" | "Idle" | "Partial" | "Planning" | "Review"]: (args: Extract<{
-      readonly _tag: "Applying";
-      readonly plan: Transport.ProvisioningPlan;
-    } | {
-      readonly _tag: "Complete";
-      readonly result: Extract<Transport.ApplyResult, {
-        readonly _tag: "Applied";
-      }>;
-    } | {
-      readonly _tag: "Idle";
-    } | {
-      readonly _tag: "Partial";
-      readonly result: Extract<Transport.ApplyResult, {
-        readonly _tag: "Partial";
-      }>;
-    } | {
-      readonly _tag: "Planning";
-    } | {
-      readonly _tag: "Review";
-      readonly plan: Transport.ProvisioningPlan;
-    }, {
-      readonly _tag: Tag;
-    }>) => any; }>(value: {
-      readonly _tag: "Applying";
-      readonly plan: Transport.ProvisioningPlan;
-    } | {
-      readonly _tag: "Complete";
-      readonly result: Extract<Transport.ApplyResult, {
-        readonly _tag: "Applied";
-      }>;
-    } | {
-      readonly _tag: "Idle";
-    } | {
-      readonly _tag: "Partial";
-      readonly result: Extract<Transport.ApplyResult, {
-        readonly _tag: "Partial";
-      }>;
-    } | {
-      readonly _tag: "Planning";
-    } | {
-      readonly _tag: "Review";
-      readonly plan: Transport.ProvisioningPlan;
-    }, cases: Cases): import("effect/Unify").Unify<ReturnType<Cases["Applying" | "Complete" | "Idle" | "Partial" | "Planning" | "Review"]>>;
-  };
-  readonly Applying: Data.TaggedEnum.ConstructorFrom<{
-    readonly _tag: "Applying";
-    readonly plan: Transport.ProvisioningPlan;
-  }, "_tag">;
-  readonly Complete: Data.TaggedEnum.ConstructorFrom<{
-    readonly _tag: "Complete";
-    readonly result: Extract<Transport.ApplyResult, {
-      readonly _tag: "Applied";
-    }>;
-  }, "_tag">;
-  readonly Idle: Data.TaggedEnum.ConstructorFrom<{
-    readonly _tag: "Idle";
-  }, "_tag">;
-  readonly Partial: Data.TaggedEnum.ConstructorFrom<{
-    readonly _tag: "Partial";
-    readonly result: Extract<Transport.ApplyResult, {
-      readonly _tag: "Partial";
-    }>;
-  }, "_tag">;
-  readonly Planning: Data.TaggedEnum.ConstructorFrom<{
-    readonly _tag: "Planning";
-  }, "_tag">;
-  readonly Review: Data.TaggedEnum.ConstructorFrom<{
-    readonly _tag: "Review";
-    readonly plan: Transport.ProvisioningPlan;
-  }, "_tag">;
-};
-type State$1 = LocalState$1 | Extract<Transport.ApplyResult, {
-  readonly _tag: "Stale";
-}> | Failure;
-interface Controller$1 {
-  readonly apply: () => void;
-  readonly dismiss: () => void;
-  readonly plan: () => void;
-  readonly retry: () => void;
-  readonly state: State$1;
-}
-type Command$1 = Data.TaggedEnum<{
-  Apply: {};
-  Dismiss: {};
-  Plan: {};
-}>;
-declare const Command$1: {
-  readonly $is: <Tag extends "Apply" | "Dismiss" | "Plan">(tag: Tag) => (u: unknown) => u is Extract<{
-    readonly _tag: "Apply";
-  }, {
-    readonly _tag: Tag;
-  }> | Extract<{
-    readonly _tag: "Dismiss";
-  }, {
-    readonly _tag: Tag;
-  }> | Extract<{
-    readonly _tag: "Plan";
-  }, {
-    readonly _tag: Tag;
-  }>;
-  readonly $match: {
-    <Cases extends { readonly [Tag in "Apply" | "Dismiss" | "Plan"]: (args: Extract<{
-      readonly _tag: "Apply";
-    } | {
-      readonly _tag: "Dismiss";
-    } | {
-      readonly _tag: "Plan";
-    }, {
-      readonly _tag: Tag;
-    }>) => any; }>(cases: Cases): (value: {
-      readonly _tag: "Apply";
-    } | {
-      readonly _tag: "Dismiss";
-    } | {
-      readonly _tag: "Plan";
-    }) => import("effect/Unify").Unify<ReturnType<Cases["Apply" | "Dismiss" | "Plan"]>>;
-    <Cases extends { readonly [Tag in "Apply" | "Dismiss" | "Plan"]: (args: Extract<{
-      readonly _tag: "Apply";
-    } | {
-      readonly _tag: "Dismiss";
-    } | {
-      readonly _tag: "Plan";
-    }, {
-      readonly _tag: Tag;
-    }>) => any; }>(value: {
-      readonly _tag: "Apply";
-    } | {
-      readonly _tag: "Dismiss";
-    } | {
-      readonly _tag: "Plan";
-    }, cases: Cases): import("effect/Unify").Unify<ReturnType<Cases["Apply" | "Dismiss" | "Plan"]>>;
-  };
-  readonly Apply: Data.TaggedEnum.ConstructorFrom<{
-    readonly _tag: "Apply";
-  }, "_tag">;
-  readonly Dismiss: Data.TaggedEnum.ConstructorFrom<{
-    readonly _tag: "Dismiss";
-  }, "_tag">;
-  readonly Plan: Data.TaggedEnum.ConstructorFrom<{
-    readonly _tag: "Plan";
-  }, "_tag">;
-};
-interface Model$1 {
-  readonly command: Atom.AtomResultFn<Command$1, void>;
-  readonly state: Atom.Atom<State$1>;
-}
-declare function useModel$1(connection: Transport.Connected, records: ReadonlyArray<Transport.DnsRecord>, onApplied?: (result: Extract<Transport.ApplyResult, {
-  readonly _tag: "Applied" | "Partial";
-}>) => void): Model$1;
-declare function useController$1(connection: Transport.Connected, records: ReadonlyArray<Transport.DnsRecord>, onApplied?: (result: Extract<Transport.ApplyResult, {
-  readonly _tag: "Applied" | "Partial";
-}>) => void): Controller$1;
-interface RootProps$2 extends PartProps<"div", {
-  readonly status: State$1["_tag"];
-}> {
-  readonly status: State$1["_tag"];
-}
-declare function Root$2({ status, ...props }: RootProps$2): ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
-declare function Outcome$1({ state }: {
-  readonly state: State$1;
-}): import("react/jsx-runtime").JSX.Element | null;
-interface DialogProps {
-  readonly controller: Controller$1;
-  readonly trigger?: ReactElement;
-}
-declare function Dialog$1({ controller, trigger }: DialogProps): import("react/jsx-runtime").JSX.Element;
-declare function RetryAction({ controller }: {
-  readonly controller: Controller$1;
-}): import("react/jsx-runtime").JSX.Element | null;
-interface FlowProps extends Omit<RootProps$2, "status"> {
-  readonly connection: Transport.Connected;
-  readonly onApplied?: (result: Extract<Transport.ApplyResult, {
-    readonly _tag: "Applied" | "Partial";
-  }>) => void;
-  readonly records: ReadonlyArray<Transport.DnsRecord>;
-  readonly showRecords?: boolean;
-  readonly trigger?: ReactElement;
-}
-declare function Flow({ connection, onApplied, records, showRecords, trigger, ...props }: FlowProps): import("react/jsx-runtime").JSX.Element;
+/** Every operation the plan holds, in plan order, so a customer reviews exactly what will run. */
+declare function List({ plan, ...props }: ListProps): ReactElement;
 declare namespace records_d_exports {
-  export { Body, Caption, Card, CardContent, CardHeader, CardProps, CardTitle, Cell, CopyController, CopyValue, CopyValueProps, DnsRecord, Footer, Head, Header, ObservationEvidence, Priority, PriorityProps, Root$1 as Root, RootProps$1 as RootProps, Row, Status$1 as Status, StatusProps$1 as StatusProps, Table, TableProps, Value, ZoneFile, ZoneFileProps, copyText, downloadZoneFile, toZoneFile, useCopy };
+  export { Body, Caption, Card, CardContent, CardHeader, CardProps, CardTitle, Cell, CopyController, CopyValue, CopyValueProps, Footer, Head, Header, Purpose, Readiness, RequirementStatus, Root, RootProps, Row, Status, StatusProps, Table, TableProps, Value, ZoneFile, ZoneFileProps, copyText, downloadZoneFile, identity, requirementsKey, statusOf, toZoneFile, useCopy };
 }
+type Readiness = Transport.Readiness;
+type RequirementStatus = Readiness["requirements"][number]["status"];
+declare const toZoneFile: (records: ReadonlyArray<DnsRecord.Model>) => string;
+declare const downloadZoneFile: (domain: string, records: ReadonlyArray<DnsRecord.Model>) => void;
 declare const copyText: (value: string) => Promise<boolean>;
-type LeafState = Record<string, unknown>;
 interface CopyController {
   readonly copied: boolean;
   readonly copy: () => void;
@@ -1367,292 +1453,117 @@ declare function useCopy(value: string, resetAfter?: number): CopyController;
 interface CopyValueProps extends PartProps<"span", {
   readonly copied: boolean;
 }> {
-  readonly copiedIcon?: ReactNode;
-  readonly copiedLabel?: string;
-  readonly copyIcon?: ReactNode;
-  readonly copyLabel?: string;
   readonly value: string;
 }
-declare function CopyValue({ copiedIcon, copiedLabel, copyIcon, copyLabel, value, ...props }: CopyValueProps): ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
+declare function CopyValue({ value, ...props }: CopyValueProps): ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
 interface ZoneFileProps extends PartProps<"div", {
   readonly count: number;
 }> {
-  readonly copiedIcon?: ReactNode;
-  readonly copiedLabel?: string;
-  readonly copyIcon?: ReactNode;
-  readonly copyLabel?: string;
   readonly domain: string;
-  readonly downloadIcon?: ReactNode;
-  readonly downloadLabel?: string;
-  readonly records: ReadonlyArray<Transport.DnsRecord>;
-}
-declare function ZoneFile({ copiedIcon, copiedLabel, copyIcon, copyLabel, domain, downloadIcon, downloadLabel, records, ...props }: ZoneFileProps): ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
-interface StatusProps$1 extends PartProps<"span", {
-  readonly status: Transport.ObservationEvidence["_tag"];
-}> {
-  readonly evidence: Transport.ObservationEvidence;
+  readonly records: ReadonlyArray<DnsRecord.Model>;
 }
-declare function Status$1({ evidence, ...props }: StatusProps$1): ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
-interface PriorityProps extends PartProps<"span", {
-  readonly priority: number;
+declare function ZoneFile({ domain, records, ...props }: ZoneFileProps): ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
+/** The readiness this record reached, or `null` when nothing has observed it. */
+declare const statusOf: (record: DnsRecord.Model, readiness: Readiness | null | undefined) => RequirementStatus | null;
+interface StatusProps extends PartProps<"span", {
+  readonly status: RequirementStatus;
 }> {
-  readonly priority?: number;
-}
-declare function Priority({ children, priority, ...props }: PriorityProps): ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
-declare const Header: (props: PartProps<"thead", LeafState>) => ReactElement;
-declare const Body: (props: PartProps<"tbody", LeafState>) => ReactElement;
-declare const Footer: (props: PartProps<"tfoot", LeafState>) => ReactElement;
-declare const Row: (props: PartProps<"tr", LeafState>) => ReactElement;
-declare const Head: (props: PartProps<"th", LeafState>) => ReactElement;
-declare const Cell: (props: PartProps<"td", LeafState>) => ReactElement;
-declare const Caption: (props: PartProps<"caption", LeafState>) => ReactElement;
-declare const Value: (props: PartProps<"span", LeafState>) => ReactElement;
-declare const CardHeader: (props: PartProps<"div", LeafState>) => ReactElement;
-declare const CardTitle: (props: PartProps<"strong", LeafState>) => ReactElement;
-declare const CardContent: (props: PartProps<"dl", LeafState>) => ReactElement;
-interface RootProps$1 extends PartProps<"table", {
+  readonly status: RequirementStatus;
+}
+declare function Status({ status, ...props }: StatusProps): ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
+declare const Header: (props: PartProps<"thead", Record<string, unknown>>) => ReactElement;
+declare const Body: (props: PartProps<"tbody", Record<string, unknown>>) => ReactElement;
+declare const Footer: (props: PartProps<"tfoot", Record<string, unknown>>) => ReactElement;
+declare const Row: (props: PartProps<"tr", Record<string, unknown>>) => ReactElement;
+declare const Head: (props: PartProps<"th", Record<string, unknown>>) => ReactElement;
+declare const Cell: (props: PartProps<"td", Record<string, unknown>>) => ReactElement;
+declare const Caption: (props: PartProps<"caption", Record<string, unknown>>) => ReactElement;
+declare const Value: (props: PartProps<"span", Record<string, unknown>>) => ReactElement;
+declare const Purpose: (props: PartProps<"span", Record<string, unknown>>) => ReactElement;
+declare const CardHeader: (props: PartProps<"div", Record<string, unknown>>) => ReactElement;
+declare const CardTitle: (props: PartProps<"strong", Record<string, unknown>>) => ReactElement;
+declare const CardContent: (props: PartProps<"dl", Record<string, unknown>>) => ReactElement;
+interface RootProps extends PartProps<"table", {
   readonly count: number;
 }> {
   readonly count?: number;
 }
-declare function Root$1({ count, ...props }: RootProps$1): import("react/jsx-runtime").JSX.Element;
+declare function Root({ count, ...props }: RootProps): import("react/jsx-runtime").JSX.Element;
+/** A stable React key for a requirement: type, name, and data identify a record. */
+declare const identity: (record: DnsRecord.Model) => string;
+/**
+ * A requirement set keyed by everything it carries, for memos that decide whether to re-send it.
+ * `identity` is deliberately narrower: it answers "is this the same record" for a React key, while
+ * a plan and an observation are built from `ttl`, `policy`, and `purpose` as well. `policy` in
+ * particular decides whether a name may hold anything else, so readiness turns on it.
+ */
+declare const requirementsKey: (records: ReadonlyArray<DnsRecord.Model>) => string;
 interface CardProps extends PartProps<"section", {
-  readonly recordId: string;
+  readonly record: string;
 }> {
-  readonly copiedIcon?: ReactNode;
-  readonly copyIcon?: ReactNode;
-  readonly evidence?: ReadonlyArray<Transport.ObservationEvidence>;
-  readonly record: Transport.DnsRecord;
+  readonly readiness?: Readiness | null;
+  readonly record: DnsRecord.Model;
 }
-declare function Card({ copiedIcon, copyIcon, evidence, record, ...props }: CardProps): ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
+declare function Card({ readiness, record, ...props }: CardProps): ReactElement;
 interface TableProps extends PartProps<"table", {
   readonly count: number;
 }> {
-  readonly copiedIcon?: ReactNode;
-  readonly copyIcon?: ReactNode;
-  readonly evidence?: ReadonlyArray<Transport.ObservationEvidence>;
-  readonly records: ReadonlyArray<Transport.DnsRecord>;
-}
-declare function Table({ copiedIcon, copyIcon, evidence, records, ...props }: TableProps): import("react/jsx-runtime").JSX.Element;
-declare const toZoneFile: (records: ReadonlyArray<Transport.DnsRecord>) => string;
-declare const downloadZoneFile: (domain: string, records: ReadonlyArray<Transport.DnsRecord>) => void;
-type DnsRecord = Transport.DnsRecord;
-type ObservationEvidence = Transport.ObservationEvidence;
-declare namespace testing_d_exports {
-  export { FakeOptions, FakeTransport, attachment, connected, connection$1 as connection, makeFakeTransport, provider$1 as provider, target$1 as target };
-}
-interface FakeOptions {
-  readonly connect?: Transport.ConnectionResult;
-  readonly inspect: Transport.ConnectionSnapshot | FakeFailure | ReadonlyArray<Transport.ConnectionSnapshot | FakeFailure>;
-  readonly attach?: Transport.Connected;
-  readonly detach?: Transport.DetachResult;
-  readonly plan?: Transport.ProvisioningPlan;
-  readonly apply?: Transport.ApplyResult;
-  readonly observe?: Transport.Observation;
-  readonly cleanupPlan?: Transport.CleanupPlan;
-  readonly cleanupApply?: Transport.CleanupResult;
-}
-interface FakeFailure {
-  readonly _tag: "Failure";
-  readonly message: string;
-  readonly operation?: string;
-  readonly retry: Transport.Failure["retry"];
-}
-interface FakeTransport extends Transport.AsyncInterface, Layer.Layer<Transport.Service> {
-  readonly calls: {
-    readonly attach: Array<Transport.AttachInput>;
-    readonly connect: Array<Transport.ConnectInput>;
-    readonly detach: Array<Transport.DetachInput>;
-    readonly inspect: Array<Transport.InspectInput>;
-    readonly plan: Array<Transport.ProvisioningPlanInput>;
-    readonly apply: Array<Transport.ProvisioningApplyInput>;
-    readonly observe: Array<Transport.ObserveInput>;
-    readonly cleanupPlan: Array<Transport.CleanupPlanInput>;
-    readonly cleanupApply: Array<Transport.CleanupApplyInput>;
-  };
+  readonly caption?: string;
+  readonly readiness?: Readiness | null;
+  readonly records: ReadonlyArray<DnsRecord.Model>;
 }
-declare const provider$1: (overrides?: Partial<Transport.Provider>) => Transport.Provider;
-declare const target$1: (overrides?: Partial<Transport.ProviderTarget>) => Transport.ProviderTarget;
-declare const connection$1: (overrides?: Partial<Transport.ProviderConnection>) => Transport.ProviderConnection;
-declare const attachment: (overrides?: Partial<Transport.DomainAttachment>) => Transport.DomainAttachment;
-declare const connected: (overrides?: Partial<Transport.Connected>) => Transport.Connected;
-declare function makeFakeTransport(options: FakeOptions): FakeTransport;
-declare namespace verification_d_exports {
-  export { Command, Controller, Evidence, Model, Observation, ObserveAction, ObserveActionProps, ObserveConfig, Outcome, Root, RootProps, State, Status, StatusProps, useController, useModel };
+/** The default records presentation: one row per requirement, with readiness when there is any. */
+declare function Table({ caption, readiness, records, ...props }: TableProps): ReactElement;
+declare namespace testing_d_exports {
+  export { RecordedCall, RecordingTransport, TransportOptions, transport$1 as transport };
 }
-type LocalState = Data.TaggedEnum<{
-  Failed: {
-    readonly failure: Failure;
-    readonly previous?: Transport.Observation;
-  };
-  Idle: {};
-  Observing: {
-    readonly previous?: Transport.Observation;
-  };
-}>;
-declare const State: {
-  readonly $is: <Tag extends "Failed" | "Idle" | "Observing">(tag: Tag) => (u: unknown) => u is Extract<{
-    readonly _tag: "Failed";
-    readonly failure: Failure;
-    readonly previous?: Transport.Observation;
-  }, {
-    readonly _tag: Tag;
-  }> | Extract<{
-    readonly _tag: "Idle";
-  }, {
-    readonly _tag: Tag;
-  }> | Extract<{
-    readonly _tag: "Observing";
-    readonly previous?: Transport.Observation;
-  }, {
-    readonly _tag: Tag;
-  }>;
-  readonly $match: {
-    <Cases extends { readonly [Tag in "Failed" | "Idle" | "Observing"]: (args: Extract<{
-      readonly _tag: "Failed";
-      readonly failure: Failure;
-      readonly previous?: Transport.Observation;
-    } | {
-      readonly _tag: "Idle";
-    } | {
-      readonly _tag: "Observing";
-      readonly previous?: Transport.Observation;
-    }, {
-      readonly _tag: Tag;
-    }>) => any; }>(cases: Cases): (value: {
-      readonly _tag: "Failed";
-      readonly failure: Failure;
-      readonly previous?: Transport.Observation;
-    } | {
-      readonly _tag: "Idle";
-    } | {
-      readonly _tag: "Observing";
-      readonly previous?: Transport.Observation;
-    }) => import("effect/Unify").Unify<ReturnType<Cases["Failed" | "Idle" | "Observing"]>>;
-    <Cases extends { readonly [Tag in "Failed" | "Idle" | "Observing"]: (args: Extract<{
-      readonly _tag: "Failed";
-      readonly failure: Failure;
-      readonly previous?: Transport.Observation;
-    } | {
-      readonly _tag: "Idle";
-    } | {
-      readonly _tag: "Observing";
-      readonly previous?: Transport.Observation;
-    }, {
-      readonly _tag: Tag;
-    }>) => any; }>(value: {
-      readonly _tag: "Failed";
-      readonly failure: Failure;
-      readonly previous?: Transport.Observation;
-    } | {
-      readonly _tag: "Idle";
-    } | {
-      readonly _tag: "Observing";
-      readonly previous?: Transport.Observation;
-    }, cases: Cases): import("effect/Unify").Unify<ReturnType<Cases["Failed" | "Idle" | "Observing"]>>;
-  };
-  readonly Failed: Data.TaggedEnum.ConstructorFrom<{
-    readonly _tag: "Failed";
-    readonly failure: Failure;
-    readonly previous?: Transport.Observation;
-  }, "_tag">;
-  readonly Idle: Data.TaggedEnum.ConstructorFrom<{
-    readonly _tag: "Idle";
-  }, "_tag">;
-  readonly Observing: Data.TaggedEnum.ConstructorFrom<{
-    readonly _tag: "Observing";
-    readonly previous?: Transport.Observation;
-  }, "_tag">;
-};
-type State = LocalState | Transport.Observation;
-interface ObserveConfig {
-  readonly connection?: Transport.Connected;
-  readonly domain: string;
-  readonly records: ReadonlyArray<Transport.DnsRecord>;
-  readonly sources?: {
-    readonly provider?: boolean;
-    readonly publicDns?: boolean;
+declare const transport$1: (options?: Testing.TransportOptions) => Testing.RecordingTransport;
+type RecordedCall = Testing.RecordedCall;
+type RecordingTransport = Testing.RecordingTransport;
+type TransportOptions = Testing.TransportOptions;
+//#endregion
+//#region src/failure.d.ts
+/**
+ * The failed member every controller state shares. It carries the `DomainKit.Error` itself, so a
+ * host reads `error.reason`, `error.category`, and `error.isRetryable` instead of parsing text.
+ */
+type Failure = Data.TaggedEnum<{
+  Failure: {
+    readonly error: DomainKit.Error;
   };
-}
-type Command = Data.TaggedEnum<{
-  Observe: {};
-  Reset: {};
 }>;
-declare const Command: {
-  readonly $is: <Tag extends "Observe" | "Reset">(tag: Tag) => (u: unknown) => u is Extract<{
-    readonly _tag: "Observe";
-  }, {
-    readonly _tag: Tag;
-  }> | Extract<{
-    readonly _tag: "Reset";
+declare const Failure: {
+  readonly $is: <Tag extends "Failure">(tag: Tag) => (u: unknown) => u is Extract<{
+    readonly _tag: "Failure";
+    readonly error: DomainKit.Error;
   }, {
     readonly _tag: Tag;
   }>;
   readonly $match: {
-    <Cases extends { readonly [Tag in "Observe" | "Reset"]: (args: Extract<{
-      readonly _tag: "Observe";
-    } | {
-      readonly _tag: "Reset";
+    <Cases extends { readonly [Tag in "Failure"]: (args: Extract<{
+      readonly _tag: "Failure";
+      readonly error: DomainKit.Error;
     }, {
       readonly _tag: Tag;
     }>) => any; }>(cases: Cases): (value: {
-      readonly _tag: "Observe";
-    } | {
-      readonly _tag: "Reset";
-    }) => import("effect/Unify").Unify<ReturnType<Cases["Observe" | "Reset"]>>;
-    <Cases extends { readonly [Tag in "Observe" | "Reset"]: (args: Extract<{
-      readonly _tag: "Observe";
-    } | {
-      readonly _tag: "Reset";
+      readonly _tag: "Failure";
+      readonly error: DomainKit.Error;
+    }) => import("effect/Unify").Unify<ReturnType<Cases["Failure"]>>;
+    <Cases extends { readonly [Tag in "Failure"]: (args: Extract<{
+      readonly _tag: "Failure";
+      readonly error: DomainKit.Error;
     }, {
       readonly _tag: Tag;
     }>) => any; }>(value: {
-      readonly _tag: "Observe";
-    } | {
-      readonly _tag: "Reset";
-    }, cases: Cases): import("effect/Unify").Unify<ReturnType<Cases["Observe" | "Reset"]>>;
+      readonly _tag: "Failure";
+      readonly error: DomainKit.Error;
+    }, cases: Cases): import("effect/Unify").Unify<ReturnType<Cases["Failure"]>>;
   };
-  readonly Observe: Data.TaggedEnum.ConstructorFrom<{
-    readonly _tag: "Observe";
-  }, "_tag">;
-  readonly Reset: Data.TaggedEnum.ConstructorFrom<{
-    readonly _tag: "Reset";
+  readonly Failure: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "Failure";
+    readonly error: DomainKit.Error;
   }, "_tag">;
 };
-interface Model {
-  readonly command: Atom.AtomResultFn<Command, void>;
-  readonly state: Atom.Atom<State>;
-}
-interface Controller {
-  readonly observe: () => void;
-  readonly reset: () => void;
-  readonly state: State;
-}
-declare function useModel(config: ObserveConfig): Model;
-declare function useController(config: ObserveConfig): Controller;
-interface RootProps extends PartProps<"div", {
-  readonly status: State["_tag"];
-}> {
-  readonly status: State["_tag"];
-}
-declare function Root({ status, ...props }: RootProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
-declare function Evidence({ observation }: {
-  readonly observation: Transport.Observation;
-}): import("react/jsx-runtime").JSX.Element;
-declare function Outcome({ state }: {
-  readonly state: State;
-}): import("react/jsx-runtime").JSX.Element | null;
-interface ObserveActionProps extends PartProps<"button", {
-  readonly status: State["_tag"];
-}> {
-  readonly controller: Controller;
-}
-declare function ObserveAction({ controller, ...props }: ObserveActionProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
-interface StatusProps extends Omit<RootProps, "status"> {
-  readonly config: ObserveConfig;
-}
-declare function Status({ config, ...props }: StatusProps): import("react/jsx-runtime").JSX.Element;
-type Observation = Transport.Observation;
 //#endregion
-export { cleanup_d_exports as Cleanup, connection_d_exports as Connection, domain_d_exports as Domain, domain_kit_d_exports as DomainKit, lifecycle_d_exports as Lifecycle, messages_d_exports as Messages, operations_d_exports as Operations, provider_d_exports as Provider, provisioning_d_exports as Provisioning, records_d_exports as Records, testing_d_exports as Testing, theme_d_exports as Theme, verification_d_exports as Verification };
+export { type ClassName, cleanup_d_exports as Cleanup, connect_d_exports as Connect, domain_d_exports as Domain, domain_kit_d_exports as DomainKit, Event, Failure, type Icons, type Listener, messages_d_exports as Messages, operations_d_exports as Operations, type PartProps, provider_d_exports as Provider, provision_d_exports as Provision, records_d_exports as Records, type Style, testing_d_exports as Testing, theme_d_exports as Theme, verify_d_exports as Verify, defaultIcons, useIcons };
 //# sourceMappingURL=index.d.mts.map