@domainkit/react 0.1.1 → 0.3.0

package/dist/index.d.mts

@@ -1,6 +1,64 @@
 import { Dialog } from "@base-ui/react/dialog";
+import { Transport } from "domainkit";
+import * as Data from "effect/Data";
+import * as Atom from "effect/unstable/reactivity/Atom";
 import { CSSProperties, ComponentPropsWithoutRef, ElementType, ReactElement, ReactNode, RefObject } from "react";
 import { useRender } from "@base-ui/react/use-render";
+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"];
+  };
+}>;
+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"]>>;
+  };
+  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);
@@ -9,381 +67,572 @@ type PartProps<Tag extends ElementType, State extends Record<string, unknown>> =
   readonly render?: useRender.RenderProp<State>;
   readonly style?: Style<State>;
 };
-declare namespace transport_d_exports {
-  export { ApplyResult, AuthenticationMethod, AuthenticationParameter, CleanupOperation, CleanupPlan, CleanupResult, CleanupTransport, Connected, ConnectionResult, ConnectionSnapshot, ConnectionTransport, DnsRecord, DomainKitTransport, Failure, Observation, ObservationEvidence, OperationResult, PlanOperation, Provider, ProvisioningPlan, ProvisioningTransport, RemoveDomainResult, ReusableConnection, VerificationTransport };
-}
-interface Failure {
-  readonly _tag: "Failure";
-  readonly message: string;
-  readonly retry: "never" | "after-user-action" | "safe" | "unknown";
-}
-interface AuthenticationParameter {
-  readonly description?: string;
-  readonly key: string;
-  readonly label: string;
-  readonly placeholder?: string;
-  readonly required?: boolean;
-}
-type AuthenticationMethod = {
-  readonly _tag: "OAuth";
-  readonly label: string;
-} | {
-  readonly _tag: "Token";
-  readonly label: string;
-  readonly parameters?: ReadonlyArray<AuthenticationParameter>;
-  readonly placeholder?: string;
-};
-interface Provider {
-  readonly authentication: ReadonlyArray<AuthenticationMethod>;
-  readonly id: string;
-  readonly name: string;
-}
-interface Connected {
-  readonly _tag: "Connected";
-  readonly connectionId: string;
-  readonly domain: string;
-  readonly provider: Provider;
-}
-interface ReusableConnection {
-  readonly connectionId: string;
-  readonly label: string;
-}
-type ConnectionSnapshot = Connected | {
-  readonly _tag: "Disconnected";
-  readonly domain: string;
-  readonly provider: Provider;
-  readonly reusableConnection?: ReusableConnection;
-} | {
-  readonly _tag: "Unsupported";
-  readonly domain: string;
-} | Failure;
-type ConnectionResult = Connected | {
-  readonly _tag: "Redirect";
-  readonly authorizationUrl: string;
-} | Failure;
-interface ConnectionTransport {
-  readonly connect: (input: {
-    readonly domain: string;
-    readonly method: "oauth" | "token";
-    readonly parameters?: Readonly<Record<string, string>>;
-    readonly providerId: string;
-    readonly token?: string;
-  }) => Promise<ConnectionResult>;
-  readonly inspect: (input: {
-    readonly domain: string;
-  }) => Promise<ConnectionSnapshot>;
-  readonly reuse: (input: {
-    readonly connectionId: string;
-    readonly domain: string;
-  }) => Promise<Connected | Failure>;
-  readonly removeDomain: (input: {
-    readonly connectionId: string;
-    readonly domain: string;
-    readonly preserveDns: true;
-  }) => Promise<RemoveDomainResult | Failure>;
-}
-interface RemoveDomainResult {
-  readonly _tag: "Removed";
-  readonly connectionId: string;
-  readonly domain: string;
-  readonly remainingDomainCount: number;
-}
-interface DnsRecord {
-  readonly id: string;
-  readonly name: string;
-  readonly priority?: number;
-  readonly type: string;
-  readonly value: string;
-}
-type PlanOperation = {
-  readonly _tag: "Create";
-  readonly id: string;
-  readonly record: DnsRecord;
-} | {
-  readonly _tag: "Noop";
-  readonly id: string;
-  readonly record: DnsRecord;
-} | {
-  readonly _tag: "Conflict";
-  readonly id: string;
-  readonly record: DnsRecord;
-  readonly reason: string;
-};
-interface ProvisioningPlan {
-  readonly _tag: "Plan";
-  readonly digest: string;
-  readonly expiresAt: string;
-  readonly operations: ReadonlyArray<PlanOperation>;
-}
-type OperationResult = {
-  readonly _tag: "Applied";
-  readonly operationId: string;
-} | {
-  readonly _tag: "Unchanged";
-  readonly operationId: string;
-} | {
-  readonly _tag: "Failed";
-  readonly message: string;
-  readonly operationId: string;
-};
-type ApplyResult = {
-  readonly _tag: "Applied";
-  readonly operationId: string;
-  readonly receiptId: string;
-  readonly results: ReadonlyArray<OperationResult>;
-} | {
-  readonly _tag: "Partial";
-  readonly operationId: string;
-  readonly receiptId: string;
-  readonly results: ReadonlyArray<OperationResult>;
-} | {
-  readonly _tag: "Stale";
-  readonly message: string;
-} | Failure;
-interface ProvisioningTransport {
-  readonly plan: (input: {
-    readonly connectionId: string;
-    readonly domain: string;
-    readonly records: ReadonlyArray<DnsRecord>;
-  }) => Promise<ProvisioningPlan | Failure>;
-  readonly apply: (input: {
-    readonly connectionId: string;
-    readonly domain: string;
-    readonly planDigest: string;
-  }) => Promise<ApplyResult>;
-}
-type ObservationEvidence = {
-  readonly _tag: "Found";
-  readonly recordId: string;
-} | {
-  readonly _tag: "Missing";
-  readonly recordId: string;
-} | {
-  readonly _tag: "Mismatch";
-  readonly recordId: string;
-  readonly message: string;
-} | {
-  readonly _tag: "Unavailable";
-  readonly recordId: string;
-  readonly message: string;
-};
-interface Observation {
-  readonly _tag: "Observation";
-  readonly provider: ReadonlyArray<ObservationEvidence>;
-  readonly publicDns: ReadonlyArray<ObservationEvidence>;
-}
-interface VerificationTransport {
-  readonly observe: (input: {
-    readonly connectionId?: string;
-    readonly domain: string;
-    readonly records: ReadonlyArray<DnsRecord>;
-    readonly sources: {
-      readonly provider: boolean;
-      readonly publicDns: boolean;
-    };
-  }) => Promise<Observation | Failure>;
-}
-type CleanupOperation = {
-  readonly _tag: "Delete";
-  readonly id: string;
-  readonly record: DnsRecord;
-} | {
-  readonly _tag: "AlreadyAbsent";
-  readonly id: string;
-  readonly record: DnsRecord;
-} | {
-  readonly _tag: "Blocked";
-  readonly id: string;
-  readonly record: DnsRecord;
-  readonly reason: string;
-};
-interface CleanupPlan {
-  readonly _tag: "CleanupPlan";
-  readonly digest: string;
-  readonly expiresAt: string;
-  readonly operations: ReadonlyArray<CleanupOperation>;
-}
-type CleanupResult = {
-  readonly _tag: "Cleaned";
-  readonly operationId: string;
-  readonly results: ReadonlyArray<OperationResult>;
-} | {
-  readonly _tag: "Partial";
-  readonly operationId: string;
-  readonly results: ReadonlyArray<OperationResult>;
-} | {
-  readonly _tag: "Stale";
-  readonly message: string;
-} | Failure;
-interface CleanupTransport {
-  readonly plan: (input: {
-    readonly connectionId: string;
-    readonly domain: string;
-    readonly receiptId: string;
-  }) => Promise<CleanupPlan | Failure>;
-  readonly apply: (input: {
-    readonly connectionId: string;
-    readonly domain: string;
-    readonly planDigest: string;
-    readonly receiptId: string;
-  }) => Promise<CleanupResult>;
-}
-interface DomainKitTransport {
-  readonly cleanup: CleanupTransport;
-  readonly connection: ConnectionTransport;
-  readonly provisioning: ProvisioningTransport;
-  readonly verification: VerificationTransport;
-}
 declare namespace cleanup_d_exports {
-  export { Flow$3 as Flow, FlowProps$3 as FlowProps, State$3 as State, useController$3 as useController };
-}
-type State$3 = {
-  readonly _tag: "Idle";
-} | {
-  readonly _tag: "Planning";
-} | {
-  readonly _tag: "Review";
-  readonly plan: CleanupPlan;
-} | {
-  readonly _tag: "Cleaning";
-  readonly plan: CleanupPlan;
-} | {
-  readonly _tag: "Cleaned";
-  readonly result: Extract<CleanupResult, {
+  export { Command$3 as Command, Controller$3 as Controller, Dialog$3 as Dialog, 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";
+    }>;
+  };
+  Cleaning: {
+    readonly plan: Transport.CleanupPlan;
+  };
+  Idle: {};
+  Partial: {
+    readonly result: Extract<Transport.CleanupResult, {
+      readonly _tag: "Partial";
+    }>;
+  };
+  Planning: {};
+  Review: {
+    readonly plan: Transport.CleanupPlan;
+  };
+}>;
+declare const State$3: {
+  readonly $is: <Tag extends "Cleaned" | "Cleaning" | "Idle" | "Partial" | "Planning" | "Review">(tag: Tag) => (u: unknown) => u is Extract<{
     readonly _tag: "Cleaned";
-  }>;
-} | {
-  readonly _tag: "Partial";
-  readonly result: Extract<CleanupResult, {
+    readonly result: Extract<Transport.CleanupResult, {
+      readonly _tag: "Cleaned";
+    }>;
+  }, {
+    readonly _tag: Tag;
+  }> | Extract<{
+    readonly _tag: "Cleaning";
+    readonly plan: Transport.CleanupPlan;
+  }, {
+    readonly _tag: Tag;
+  }> | Extract<{
+    readonly _tag: "Idle";
+  }, {
+    readonly _tag: Tag;
+  }> | Extract<{
     readonly _tag: "Partial";
+    readonly result: Extract<Transport.CleanupResult, {
+      readonly _tag: "Partial";
+    }>;
+  }, {
+    readonly _tag: Tag;
+  }> | Extract<{
+    readonly _tag: "Planning";
+  }, {
+    readonly _tag: Tag;
+  }> | Extract<{
+    readonly _tag: "Review";
+    readonly plan: Transport.CleanupPlan;
+  }, {
+    readonly _tag: Tag;
   }>;
-} | {
+  readonly $match: {
+    <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 _tag: "Cleaning";
+      readonly plan: Transport.CleanupPlan;
+    } | {
+      readonly _tag: "Idle";
+    } | {
+      readonly _tag: "Partial";
+      readonly result: Extract<Transport.CleanupResult, {
+        readonly _tag: "Partial";
+      }>;
+    } | {
+      readonly _tag: "Planning";
+    } | {
+      readonly _tag: "Review";
+      readonly plan: Transport.CleanupPlan;
+    }, {
+      readonly _tag: Tag;
+    }>) => any; }>(cases: Cases): (value: {
+      readonly _tag: "Cleaned";
+      readonly result: Extract<Transport.CleanupResult, {
+        readonly _tag: "Cleaned";
+      }>;
+    } | {
+      readonly _tag: "Cleaning";
+      readonly plan: Transport.CleanupPlan;
+    } | {
+      readonly _tag: "Idle";
+    } | {
+      readonly _tag: "Partial";
+      readonly result: Extract<Transport.CleanupResult, {
+        readonly _tag: "Partial";
+      }>;
+    } | {
+      readonly _tag: "Planning";
+    } | {
+      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 _tag: "Cleaning";
+      readonly plan: Transport.CleanupPlan;
+    } | {
+      readonly _tag: "Idle";
+    } | {
+      readonly _tag: "Partial";
+      readonly result: Extract<Transport.CleanupResult, {
+        readonly _tag: "Partial";
+      }>;
+    } | {
+      readonly _tag: "Planning";
+    } | {
+      readonly _tag: "Review";
+      readonly plan: Transport.CleanupPlan;
+    }, {
+      readonly _tag: Tag;
+    }>) => any; }>(value: {
+      readonly _tag: "Cleaned";
+      readonly result: Extract<Transport.CleanupResult, {
+        readonly _tag: "Cleaned";
+      }>;
+    } | {
+      readonly _tag: "Cleaning";
+      readonly plan: Transport.CleanupPlan;
+    } | {
+      readonly _tag: "Idle";
+    } | {
+      readonly _tag: "Partial";
+      readonly result: Extract<Transport.CleanupResult, {
+        readonly _tag: "Partial";
+      }>;
+    } | {
+      readonly _tag: "Planning";
+    } | {
+      readonly _tag: "Review";
+      readonly plan: Transport.CleanupPlan;
+    }, cases: Cases): import("effect/Unify").Unify<ReturnType<Cases["Cleaned" | "Cleaning" | "Idle" | "Partial" | "Planning" | "Review"]>>;
+  };
+  readonly Cleaned: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "Cleaned";
+    readonly result: Extract<Transport.CleanupResult, {
+      readonly _tag: "Cleaned";
+    }>;
+  }, "_tag">;
+  readonly Cleaning: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "Cleaning";
+    readonly plan: Transport.CleanupPlan;
+  }, "_tag">;
+  readonly Idle: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "Idle";
+  }, "_tag">;
+  readonly Partial: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "Partial";
+    readonly result: Extract<Transport.CleanupResult, {
+      readonly _tag: "Partial";
+    }>;
+  }, "_tag">;
+  readonly Planning: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "Planning";
+  }, "_tag">;
+  readonly Review: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "Review";
+    readonly plan: Transport.CleanupPlan;
+  }, "_tag">;
+};
+type State$3 = LocalState$3 | Extract<Transport.CleanupResult, {
   readonly _tag: "Stale";
-  readonly message: string;
-} | Failure;
-declare function useController$3(connection: Connected, receiptId: string): {
-  readonly apply: () => Promise<void>;
+}> | Failure;
+type Command$3 = Data.TaggedEnum<{
+  Apply: {};
+  Dismiss: {};
+  Plan: {};
+}>;
+declare const Command$3: {
+  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$3 {
+  readonly command: Atom.AtomResultFn<Command$3, void>;
+  readonly state: Atom.Atom<State$3>;
+}
+interface Controller$3 {
+  readonly apply: () => void;
   readonly dismiss: () => void;
-  readonly plan: () => Promise<void>;
+  readonly plan: () => void;
   readonly state: State$3;
-};
-interface FlowProps$3 extends PartProps<"div", {
+}
+declare function useModel$3(connection: Transport.Connected, receiptId: string): Model$3;
+declare function useController$3(connection: Transport.Connected, receiptId: string): Controller$3;
+interface RootProps$6 extends PartProps<"div", {
   readonly status: State$3["_tag"];
 }> {
-  readonly connection: Connected;
+  readonly status: State$3["_tag"];
+}
+declare function Root$6({ status, ...props }: RootProps$6): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
+declare function Outcome$2({ state }: {
+  readonly state: State$3;
+}): import("react/jsx-runtime").JSX.Element | null;
+declare function Dialog$3({ controller }: {
+  readonly controller: Controller$3;
+}): import("react/jsx-runtime").JSX.Element;
+interface FlowProps$3 extends Omit<RootProps$6, "status"> {
+  readonly connection: Transport.Connected;
   readonly receiptId: string;
 }
-declare function Flow$3({ connection, receiptId, ...props }: FlowProps$3): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
+declare function Flow$3({ connection, receiptId, ...props }: FlowProps$3): import("react/jsx-runtime").JSX.Element;
 declare namespace provider_d_exports {
-  export { Mark, MarkElementProps, MarkProps, MarkState, Marks, Provider };
+  export { Mark, MarkElementProps, MarkProps, MarkState, Marks, ProviderDescriptor as Provider };
 }
-type Marks = Readonly<Record<string, ReactNode | ((provider: Provider) => ReactNode)>>;
+type ProviderDescriptor = Transport.Provider;
+type Marks = Readonly<Record<string, ReactNode | ((provider: ProviderDescriptor) => ReactNode)>>;
 interface MarkState extends Record<string, unknown> {
   readonly providerId: string;
 }
 interface MarkProps extends PartProps<"span", MarkState> {
-  readonly provider: Provider;
+  readonly provider: ProviderDescriptor;
 }
 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, Connected, Controller$1 as Controller, Dialog$1 as Dialog, DialogProps, DisconnectAction, DisconnectActionProps, DisconnectState, Flow$2 as Flow, FlowProps$2 as FlowProps, OAuthAction, OAuthActionProps, RetryAction, RetryActionProps, ReuseAction, ReuseActionProps, Root$2 as Root, RootProps$2 as RootProps, RootState$1 as RootState, State$2 as State, Status$2 as Status, StatusProps$2 as StatusProps, StatusState, TokenAction, TokenActionProps, Trigger, TriggerProps, useController$2 as useController, useDisconnect };
+  export { ActionState, Command$2 as Command, ConnectTrigger, ConnectTriggerProps, Connected, Controller$2 as Controller, Dialog$2 as Dialog, DialogProps, DisconnectAction, DisconnectActionProps, DisconnectState, Flow$2 as Flow, FlowProps$2 as FlowProps, Model$2 as Model, OAuthAction, OAuthActionProps, RetryAction$1 as RetryAction, RetryActionProps, ReuseAction, ReuseActionProps, 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, useController$2 as useController, useDisconnect, useModel$2 as useModel };
 }
-type State$2 = {
-  readonly _tag: "Loading";
-} | ConnectionSnapshot | {
-  readonly _tag: "Submitting";
-  readonly snapshot: Disconnected;
-} | {
-  readonly _tag: "Redirecting";
-  readonly snapshot: Disconnected;
+type LocalState$2 = Data.TaggedEnum<{
+  Loading: {};
+  Redirecting: {
+    readonly snapshot: Disconnected;
+  };
+  Submitting: {
+    readonly snapshot: Disconnected;
+  };
+}>;
+declare const State$2: {
+  readonly $is: <Tag extends "Loading" | "Redirecting" | "Submitting">(tag: Tag) => (u: unknown) => u is Extract<{
+    readonly _tag: "Loading";
+  }, {
+    readonly _tag: Tag;
+  }> | Extract<{
+    readonly _tag: "Redirecting";
+    readonly snapshot: Disconnected;
+  }, {
+    readonly _tag: Tag;
+  }> | Extract<{
+    readonly _tag: "Submitting";
+    readonly snapshot: Disconnected;
+  }, {
+    readonly _tag: Tag;
+  }>;
+  readonly $match: {
+    <Cases extends { readonly [Tag in "Loading" | "Redirecting" | "Submitting"]: (args: Extract<{
+      readonly _tag: "Loading";
+    } | {
+      readonly _tag: "Redirecting";
+      readonly snapshot: Disconnected;
+    } | {
+      readonly _tag: "Submitting";
+      readonly snapshot: Disconnected;
+    }, {
+      readonly _tag: Tag;
+    }>) => any; }>(cases: Cases): (value: {
+      readonly _tag: "Loading";
+    } | {
+      readonly _tag: "Redirecting";
+      readonly snapshot: Disconnected;
+    } | {
+      readonly _tag: "Submitting";
+      readonly snapshot: Disconnected;
+    }) => import("effect/Unify").Unify<ReturnType<Cases["Loading" | "Redirecting" | "Submitting"]>>;
+    <Cases extends { readonly [Tag in "Loading" | "Redirecting" | "Submitting"]: (args: Extract<{
+      readonly _tag: "Loading";
+    } | {
+      readonly _tag: "Redirecting";
+      readonly snapshot: Disconnected;
+    } | {
+      readonly _tag: "Submitting";
+      readonly snapshot: Disconnected;
+    }, {
+      readonly _tag: Tag;
+    }>) => any; }>(value: {
+      readonly _tag: "Loading";
+    } | {
+      readonly _tag: "Redirecting";
+      readonly snapshot: Disconnected;
+    } | {
+      readonly _tag: "Submitting";
+      readonly snapshot: Disconnected;
+    }, cases: Cases): import("effect/Unify").Unify<ReturnType<Cases["Loading" | "Redirecting" | "Submitting"]>>;
+  };
+  readonly Loading: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "Loading";
+  }, "_tag">;
+  readonly Redirecting: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "Redirecting";
+    readonly snapshot: Disconnected;
+  }, "_tag">;
+  readonly Submitting: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "Submitting";
+    readonly snapshot: Disconnected;
+  }, "_tag">;
 };
-type Disconnected = Extract<ConnectionSnapshot, {
+type State$2 = LocalState$2 | Transport.ConnectionSnapshot | Failure;
+type Disconnected = Extract<Transport.ConnectionSnapshot, {
   readonly _tag: "Disconnected";
 }>;
-interface Controller$1 {
-  readonly connect: (method: "oauth" | "token", token?: string, parameters?: Readonly<Record<string, string>>) => Promise<void>;
+interface Controller$2 {
+  readonly connect: (method: Transport.Method) => void;
   readonly retry: () => void;
-  readonly reuse: () => Promise<void>;
+  readonly reuse: () => void;
   readonly state: State$2;
 }
-declare function useController$2(domain: string): Controller$1;
+type Command$2 = Data.TaggedEnum<{
+  Connect: {
+    readonly method: Transport.Method;
+  };
+  Retry: {};
+  Reuse: {};
+}>;
+declare const Command$2: {
+  readonly $is: <Tag extends "Connect" | "Retry" | "Reuse">(tag: Tag) => (u: unknown) => u is Extract<{
+    readonly _tag: "Connect";
+    readonly method: Transport.Method;
+  }, {
+    readonly _tag: Tag;
+  }> | Extract<{
+    readonly _tag: "Retry";
+  }, {
+    readonly _tag: Tag;
+  }> | Extract<{
+    readonly _tag: "Reuse";
+  }, {
+    readonly _tag: Tag;
+  }>;
+  readonly $match: {
+    <Cases extends { readonly [Tag in "Connect" | "Retry" | "Reuse"]: (args: Extract<{
+      readonly _tag: "Connect";
+      readonly method: Transport.Method;
+    } | {
+      readonly _tag: "Retry";
+    } | {
+      readonly _tag: "Reuse";
+    }, {
+      readonly _tag: Tag;
+    }>) => any; }>(cases: Cases): (value: {
+      readonly _tag: "Connect";
+      readonly method: Transport.Method;
+    } | {
+      readonly _tag: "Retry";
+    } | {
+      readonly _tag: "Reuse";
+    }) => import("effect/Unify").Unify<ReturnType<Cases["Connect" | "Retry" | "Reuse"]>>;
+    <Cases extends { readonly [Tag in "Connect" | "Retry" | "Reuse"]: (args: Extract<{
+      readonly _tag: "Connect";
+      readonly method: Transport.Method;
+    } | {
+      readonly _tag: "Retry";
+    } | {
+      readonly _tag: "Reuse";
+    }, {
+      readonly _tag: Tag;
+    }>) => any; }>(value: {
+      readonly _tag: "Connect";
+      readonly method: Transport.Method;
+    } | {
+      readonly _tag: "Retry";
+    } | {
+      readonly _tag: "Reuse";
+    }, cases: Cases): import("effect/Unify").Unify<ReturnType<Cases["Connect" | "Retry" | "Reuse"]>>;
+  };
+  readonly Connect: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "Connect";
+    readonly method: Transport.Method;
+  }, "_tag">;
+  readonly Retry: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "Retry";
+  }, "_tag">;
+  readonly Reuse: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "Reuse";
+  }, "_tag">;
+};
+interface Model$2 {
+  readonly command: Atom.AtomResultFn<Command$2, void>;
+  readonly state: Atom.Atom<State$2>;
+}
+declare function useModel$2(domain: string): Model$2;
+declare function useController$2(domain: string): Controller$2;
 interface RootState$1 extends Record<string, unknown> {
   readonly status: State$2["_tag"];
 }
-interface RootProps$2 extends PartProps<"div", RootState$1> {
+interface RootProps$5 extends PartProps<"div", RootState$1> {
   readonly status?: State$2["_tag"];
 }
-declare function Root$2({ children, status, ...props }: RootProps$2): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
+declare function Root$5({ children, status, ...props }: RootProps$5): import("react").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({ state, ...props }: StatusProps$2): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
-interface TriggerProps extends ComponentPropsWithoutRef<typeof Dialog.Trigger> {
-  readonly provider: Provider;
+declare function Status$2({ children, state, ...props }: StatusProps$2): import("react").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;
 }
-declare function Trigger({ provider, ...props }: TriggerProps): import("react/jsx-runtime").JSX.Element;
+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: "oauth" | "reuse" | "token";
 }
 interface OAuthActionProps extends PartProps<"button", ActionState> {
-  readonly controller: Controller$1;
+  readonly controller: Controller$2;
   readonly label: string;
 }
 declare function OAuthAction({ controller, label, ...props }: OAuthActionProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
 interface ReuseActionProps extends PartProps<"button", ActionState> {
-  readonly controller: Controller$1;
+  readonly controller: Controller$2;
   readonly label: string;
 }
 declare function ReuseAction({ controller, label, ...props }: ReuseActionProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
 interface TokenActionProps extends Omit<PartProps<"form", ActionState>, "method"> {
-  readonly controller: Controller$1;
-  readonly method: Extract<AuthenticationMethod, {
+  readonly controller: Controller$2;
+  readonly method: Extract<Transport.AuthenticationMethod, {
     readonly _tag: "Token";
   }>;
 }
 declare function TokenAction({ controller, method, ...props }: TokenActionProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
 interface DialogProps {
-  readonly controller: Controller$1;
+  readonly controller: Controller$2;
   readonly snapshot: Disconnected;
 }
-declare function Dialog$1({ controller, snapshot }: DialogProps): import("react/jsx-runtime").JSX.Element;
-interface FlowProps$2 extends Omit<RootProps$2, "children"> {
+declare function Dialog$2({ controller, snapshot }: DialogProps): import("react/jsx-runtime").JSX.Element;
+interface FlowProps$2 extends Omit<RootProps$5, "children"> {
   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$1;
+  readonly controller: Controller$2;
   readonly kind?: "after-user-action" | "retry";
 }
-declare function RetryAction({ controller, kind, ...props }: RetryActionProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
-type DisconnectState = {
-  readonly _tag: "Idle";
-} | {
-  readonly _tag: "Disconnecting";
-} | RemoveDomainResult | Failure;
-declare function useDisconnect(connection: Connected): {
-  readonly disconnect: () => Promise<void>;
+declare function RetryAction$1({ controller, kind, ...props }: RetryActionProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
+type LocalDisconnectState = Data.TaggedEnum<{
+  Disconnecting: {};
+  Idle: {};
+}>;
+declare const DisconnectState: {
+  readonly $is: <Tag extends "Disconnecting" | "Idle">(tag: Tag) => (u: unknown) => u is Extract<{
+    readonly _tag: "Disconnecting";
+  }, {
+    readonly _tag: Tag;
+  }> | Extract<{
+    readonly _tag: "Idle";
+  }, {
+    readonly _tag: Tag;
+  }>;
+  readonly $match: {
+    <Cases extends { readonly [Tag in "Disconnecting" | "Idle"]: (args: Extract<{
+      readonly _tag: "Disconnecting";
+    } | {
+      readonly _tag: "Idle";
+    }, {
+      readonly _tag: Tag;
+    }>) => any; }>(cases: Cases): (value: {
+      readonly _tag: "Disconnecting";
+    } | {
+      readonly _tag: "Idle";
+    }) => import("effect/Unify").Unify<ReturnType<Cases["Disconnecting" | "Idle"]>>;
+    <Cases extends { readonly [Tag in "Disconnecting" | "Idle"]: (args: Extract<{
+      readonly _tag: "Disconnecting";
+    } | {
+      readonly _tag: "Idle";
+    }, {
+      readonly _tag: Tag;
+    }>) => any; }>(value: {
+      readonly _tag: "Disconnecting";
+    } | {
+      readonly _tag: "Idle";
+    }, cases: Cases): import("effect/Unify").Unify<ReturnType<Cases["Disconnecting" | "Idle"]>>;
+  };
+  readonly Disconnecting: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "Disconnecting";
+  }, "_tag">;
+  readonly Idle: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "Idle";
+  }, "_tag">;
+};
+type DisconnectState = LocalDisconnectState | Transport.RemoveDomainResult | Failure;
+declare function useDisconnect(connection: Transport.Connected): {
+  readonly disconnect: () => void;
   readonly state: DisconnectState;
 };
 interface DisconnectActionProps extends PartProps<"div", {
   readonly status: DisconnectState["_tag"];
 }> {
-  readonly connection: Connected;
+  readonly connection: Transport.Connected;
 }
 declare function DisconnectAction({ connection, ...props }: DisconnectActionProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
+type Connected = Transport.Connected;
 declare namespace domain_d_exports {
   export { Flow$1 as Flow, FlowProps$1 as FlowProps };
 }
 interface FlowProps$1 {
   readonly domain: string;
   readonly receiptId?: string;
-  readonly records: ReadonlyArray<DnsRecord>;
+  readonly records: ReadonlyArray<Transport.DnsRecord>;
 }
 declare function Flow$1({ domain, receiptId, records }: FlowProps$1): import("react/jsx-runtime").JSX.Element;
 //#endregion
@@ -411,6 +660,7 @@ interface Catalog {
   readonly cleaningDns: string;
   readonly connectProvider: (provider: string) => string;
   readonly connected: (provider: string) => string;
+  readonly providerAvailable: (provider: string) => string;
   readonly connecting: string;
   readonly close: string;
   readonly detectingProvider: string;
@@ -452,12 +702,12 @@ interface Theme {
 }
 declare function toStyle(theme?: Theme): CSSProperties;
 declare namespace domain_kit_d_exports {
-  export { Root$1 as Root, RootProps$1 as RootProps, RootState, useDomainKit };
+  export { Root$4 as Root, RootProps$4 as RootProps, RootState, useDomainKit };
 }
 interface RootState extends Record<string, unknown> {
   readonly colorScheme: "dark" | "inherit" | "light";
 }
-interface RootProps$1 extends Omit<PartProps<"div", RootState>, "children"> {
+interface RootProps$4 extends Omit<PartProps<"div", RootState>, "children"> {
   readonly children: ReactNode;
   readonly colorScheme?: RootState["colorScheme"];
   readonly icons?: Partial<Icons>;
@@ -466,7 +716,7 @@ interface RootProps$1 extends Omit<PartProps<"div", RootState>, "children"> {
   readonly navigate?: (url: string) => void;
   readonly portalContainer?: HTMLElement | null;
   readonly theme?: Theme;
-  readonly transport: DomainKitTransport;
+  readonly transport: Layer.Layer<Transport.Service>;
 }
 interface ContextValue {
   readonly colorScheme: RootState["colorScheme"];
@@ -475,65 +725,328 @@ interface ContextValue {
   readonly messages: Catalog;
   readonly portalContainer: RefObject<HTMLElement | null>;
   readonly themeStyle: ReturnType<typeof toStyle>;
-  readonly transport: DomainKitTransport;
+  readonly runtime: Runtime;
 }
-declare function Root$1({ children, colorScheme, icons, marks, messages, navigate, portalContainer, theme, transport, ...props }: RootProps$1): import("react/jsx-runtime").JSX.Element;
+declare function Root$4({ children, colorScheme, icons, marks, messages, navigate, portalContainer, theme, transport, ...props }: RootProps$4): import("react/jsx-runtime").JSX.Element;
 declare function useDomainKit(): ContextValue;
+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;
+interface ItemProps extends PartProps<"li", {
+  readonly operation: Operation["_tag"];
+}> {
+  readonly operation: Operation;
+}
+declare function Item({ operation, ...props }: ItemProps): ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
+interface RootProps$3 extends PartProps<"ul", {
+  readonly count: number;
+  readonly lifecycle: Lifecycle;
+}> {
+  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>;
+}
+declare function List({ lifecycle, operations, ...props }: ListProps): import("react/jsx-runtime").JSX.Element;
 declare namespace provisioning_d_exports {
-  export { Controller, Flow, FlowProps, OperationList, State$1 as State, useController$1 as useController };
-}
-type State$1 = {
-  readonly _tag: "Idle";
-} | {
-  readonly _tag: "Planning";
-} | {
-  readonly _tag: "Review";
-  readonly plan: ProvisioningPlan;
-} | {
-  readonly _tag: "Applying";
-  readonly plan: ProvisioningPlan;
-} | {
-  readonly _tag: "Complete";
-  readonly result: Extract<ApplyResult, {
-    readonly _tag: "Applied";
-  }>;
-} | {
-  readonly _tag: "Partial";
-  readonly result: Extract<ApplyResult, {
+  export { Command$1 as Command, Controller$1 as Controller, Dialog$1 as Dialog, 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 };
+}
+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";
-  readonly message: string;
-} | Failure;
-interface Controller {
-  readonly apply: () => Promise<void>;
+}> | Failure;
+interface Controller$1 {
+  readonly apply: () => void;
   readonly dismiss: () => void;
-  readonly plan: () => Promise<void>;
-  readonly retry: () => Promise<void>;
+  readonly plan: () => void;
+  readonly retry: () => void;
   readonly state: State$1;
 }
-declare function useController$1(connection: Connected, records: ReadonlyArray<DnsRecord>, onApplied?: (result: Extract<ApplyResult, {
+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;
-interface FlowProps extends PartProps<"div", {
+}>) => void): Controller$1;
+interface RootProps$2 extends PartProps<"div", {
   readonly status: State$1["_tag"];
 }> {
-  readonly connection: Connected;
-  readonly onApplied?: (result: Extract<ApplyResult, {
+  readonly status: State$1["_tag"];
+}
+declare function Root$2({ status, ...props }: RootProps$2): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
+declare function Outcome$1({ state }: {
+  readonly state: State$1;
+}): import("react/jsx-runtime").JSX.Element | null;
+declare function Dialog$1({ controller }: {
+  readonly controller: Controller$1;
+}): 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<DnsRecord>;
+  readonly records: ReadonlyArray<Transport.DnsRecord>;
   readonly showRecords?: boolean;
 }
-declare function Flow({ connection, onApplied, records, showRecords, ...props }: FlowProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
-declare function OperationList({ plan }: {
-  readonly plan: ProvisioningPlan;
-}): import("react/jsx-runtime").JSX.Element;
+declare function Flow({ connection, onApplied, records, showRecords, ...props }: FlowProps): import("react/jsx-runtime").JSX.Element;
 declare namespace records_d_exports {
-  export { Body, Caption, Card, CardContent, CardHeader, CardProps, CardTitle, Cell, CopyValue, CopyValueProps, DnsRecord, Footer, Head, Header, ObservationEvidence, Priority, PriorityProps, Root, RootProps, Row, Status$1 as Status, StatusProps$1 as StatusProps, Table, TableProps, Value, ZoneFile, ZoneFileProps, toZoneFile };
+  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 };
 }
+declare const copyText: (value: string) => Promise<boolean>;
 type LeafState = Record<string, unknown>;
+interface CopyController {
+  readonly copied: boolean;
+  readonly copy: () => void;
+}
+declare function useCopy(value: string, resetAfter?: number): CopyController;
 interface CopyValueProps extends PartProps<"span", {
   readonly copied: boolean;
 }> {
@@ -554,13 +1067,13 @@ interface ZoneFileProps extends PartProps<"div", {
   readonly domain: string;
   readonly downloadIcon?: ReactNode;
   readonly downloadLabel?: string;
-  readonly records: ReadonlyArray<DnsRecord>;
+  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: ObservationEvidence["_tag"];
+  readonly status: Transport.ObservationEvidence["_tag"];
 }> {
-  readonly evidence: ObservationEvidence;
+  readonly evidence: Transport.ObservationEvidence;
 }
 declare function Status$1({ evidence, ...props }: StatusProps$1): ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
 interface PriorityProps extends PartProps<"span", {
@@ -580,19 +1093,19 @@ 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 extends PartProps<"table", {
+interface RootProps$1 extends PartProps<"table", {
   readonly count: number;
 }> {
   readonly count?: number;
 }
-declare function Root({ count, ...props }: RootProps): import("react/jsx-runtime").JSX.Element;
+declare function Root$1({ count, ...props }: RootProps$1): import("react/jsx-runtime").JSX.Element;
 interface CardProps extends PartProps<"section", {
   readonly recordId: string;
 }> {
   readonly copiedIcon?: ReactNode;
   readonly copyIcon?: ReactNode;
-  readonly evidence?: ReadonlyArray<ObservationEvidence>;
-  readonly record: DnsRecord;
+  readonly evidence?: ReadonlyArray<Transport.ObservationEvidence>;
+  readonly record: Transport.DnsRecord;
 }
 declare function Card({ copiedIcon, copyIcon, evidence, record, ...props }: CardProps): ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
 interface TableProps extends PartProps<"table", {
@@ -600,67 +1113,183 @@ interface TableProps extends PartProps<"table", {
 }> {
   readonly copiedIcon?: ReactNode;
   readonly copyIcon?: ReactNode;
-  readonly evidence?: ReadonlyArray<ObservationEvidence>;
-  readonly records: ReadonlyArray<DnsRecord>;
+  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<DnsRecord>) => string;
+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, makeFakeTransport, provider$1 as provider };
 }
 interface FakeOptions {
-  readonly connect?: ConnectionResult;
-  readonly inspect: ConnectionSnapshot | ReadonlyArray<ConnectionSnapshot>;
-  readonly reuse?: Connected;
-  readonly removeDomain?: RemoveDomainResult;
-  readonly plan?: ProvisioningPlan;
-  readonly apply?: ApplyResult;
-  readonly observe?: Observation;
-  readonly cleanupPlan?: CleanupPlan;
-  readonly cleanupApply?: CleanupResult;
-}
-interface FakeTransport extends DomainKitTransport {
+  readonly connect?: Transport.ConnectionResult;
+  readonly inspect: Transport.ConnectionSnapshot | FakeFailure | ReadonlyArray<Transport.ConnectionSnapshot | FakeFailure>;
+  readonly reuse?: Transport.Connected;
+  readonly removeDomain?: Transport.RemoveDomainResult;
+  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 connect: Array<Parameters<DomainKitTransport["connection"]["connect"]>[0]>;
-    readonly inspect: Array<Parameters<DomainKitTransport["connection"]["inspect"]>[0]>;
-    readonly reuse: Array<Parameters<DomainKitTransport["connection"]["reuse"]>[0]>;
-    readonly removeDomain: Array<Parameters<DomainKitTransport["connection"]["removeDomain"]>[0]>;
-    readonly plan: Array<Parameters<DomainKitTransport["provisioning"]["plan"]>[0]>;
-    readonly apply: Array<Parameters<DomainKitTransport["provisioning"]["apply"]>[0]>;
-    readonly observe: Array<Parameters<DomainKitTransport["verification"]["observe"]>[0]>;
-    readonly cleanupPlan: Array<Parameters<DomainKitTransport["cleanup"]["plan"]>[0]>;
-    readonly cleanupApply: Array<Parameters<DomainKitTransport["cleanup"]["apply"]>[0]>;
+    readonly connect: Array<Transport.ConnectInput>;
+    readonly inspect: Array<Transport.InspectInput>;
+    readonly reuse: Array<Transport.ReuseInput>;
+    readonly removeDomain: Array<Transport.RemoveDomainInput>;
+    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>;
   };
 }
-declare const provider$1: (overrides?: Partial<Provider>) => Provider;
+declare const provider$1: (overrides?: Partial<Transport.Provider>) => Transport.Provider;
 declare function makeFakeTransport(options: FakeOptions): FakeTransport;
 declare namespace verification_d_exports {
-  export { Observation, ObserveConfig, State, Status, StatusProps, useController };
+  export { Command, Controller, Evidence, Model, Observation, ObserveAction, ObserveConfig, Outcome, Root, RootProps, State, Status, StatusProps, useController, useModel };
 }
-type State = {
-  readonly _tag: "Idle";
-} | {
-  readonly _tag: "Observing";
-} | Observation | Failure;
+type LocalState = Data.TaggedEnum<{
+  Idle: {};
+  Observing: {};
+}>;
+declare const State: {
+  readonly $is: <Tag extends "Idle" | "Observing">(tag: Tag) => (u: unknown) => u is Extract<{
+    readonly _tag: "Idle";
+  }, {
+    readonly _tag: Tag;
+  }> | Extract<{
+    readonly _tag: "Observing";
+  }, {
+    readonly _tag: Tag;
+  }>;
+  readonly $match: {
+    <Cases extends { readonly [Tag in "Idle" | "Observing"]: (args: Extract<{
+      readonly _tag: "Idle";
+    } | {
+      readonly _tag: "Observing";
+    }, {
+      readonly _tag: Tag;
+    }>) => any; }>(cases: Cases): (value: {
+      readonly _tag: "Idle";
+    } | {
+      readonly _tag: "Observing";
+    }) => import("effect/Unify").Unify<ReturnType<Cases["Idle" | "Observing"]>>;
+    <Cases extends { readonly [Tag in "Idle" | "Observing"]: (args: Extract<{
+      readonly _tag: "Idle";
+    } | {
+      readonly _tag: "Observing";
+    }, {
+      readonly _tag: Tag;
+    }>) => any; }>(value: {
+      readonly _tag: "Idle";
+    } | {
+      readonly _tag: "Observing";
+    }, cases: Cases): import("effect/Unify").Unify<ReturnType<Cases["Idle" | "Observing"]>>;
+  };
+  readonly Idle: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "Idle";
+  }, "_tag">;
+  readonly Observing: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "Observing";
+  }, "_tag">;
+};
+type State = LocalState | Transport.Observation | Failure;
 interface ObserveConfig {
-  readonly connection?: Connected;
+  readonly connection?: Transport.Connected;
   readonly domain: string;
-  readonly records: ReadonlyArray<DnsRecord>;
+  readonly records: ReadonlyArray<Transport.DnsRecord>;
   readonly sources?: {
     readonly provider?: boolean;
     readonly publicDns?: boolean;
   };
 }
-declare function useController(config: ObserveConfig): {
-  readonly observe: () => Promise<void>;
-  readonly state: State;
+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";
+  }, {
+    readonly _tag: Tag;
+  }>;
+  readonly $match: {
+    <Cases extends { readonly [Tag in "Observe" | "Reset"]: (args: Extract<{
+      readonly _tag: "Observe";
+    } | {
+      readonly _tag: "Reset";
+    }, {
+      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: Tag;
+    }>) => any; }>(value: {
+      readonly _tag: "Observe";
+    } | {
+      readonly _tag: "Reset";
+    }, cases: Cases): import("effect/Unify").Unify<ReturnType<Cases["Observe" | "Reset"]>>;
+  };
+  readonly Observe: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "Observe";
+  }, "_tag">;
+  readonly Reset: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "Reset";
+  }, "_tag">;
 };
-interface StatusProps extends PartProps<"div", {
+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;
+declare function ObserveAction({ controller }: {
+  readonly controller: Controller;
+}): import("react/jsx-runtime").JSX.Element;
+interface StatusProps extends Omit<RootProps, "status"> {
   readonly config: ObserveConfig;
 }
-declare function Status({ config, ...props }: StatusProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
+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, messages_d_exports as Messages, 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, transport_d_exports as Transport, verification_d_exports as Verification };
+export { cleanup_d_exports as Cleanup, connection_d_exports as Connection, domain_d_exports as Domain, domain_kit_d_exports as DomainKit, 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 };
 //# sourceMappingURL=index.d.mts.map