@domainkit/react 0.11.0 → 0.12.0

package/dist/index.d.mts

@@ -1,9 +1,8 @@
 import { Approval, DnsRecord, DomainKit, Plan, Reason, Receipt, Storage } from "domainkit";
 import "effect/Effect";
-import { CSSProperties, ElementType, ReactElement, ReactNode, RefObject } from "react";
+import { AriaAttributes, FocusEventHandler, FormEventHandler, KeyboardEventHandler, MouseEventHandler, ReactElement, ReactNode } from "react";
 import * as Data from "effect/Data";
 import { Transport } from "domainkit/client";
-import { useRender } from "@base-ui/react/use-render";
 import { Testing } from "domainkit/testing";
 //#region src/events.d.ts
 /** What a customer finished doing, for host notifications, analytics, and audit trails. */
@@ -240,7 +239,7 @@ declare const Event: {
 type Listener = (event: Event) => void;
 //#endregion
 //#region src/attempt.d.ts
-type State$3 = Data.TaggedEnum<{
+type State$2 = Data.TaggedEnum<{
   Idle: {};
   Planning: {};
   Planned: {
@@ -268,7 +267,7 @@ type State$3 = Data.TaggedEnum<{
     readonly error: DomainKit.Error;
   };
 }>;
-declare const State$3: {
+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;
@@ -475,7 +474,7 @@ declare const State$3: {
   }, "_tag">;
 };
 interface Controller$2 {
-  readonly state: State$3;
+  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. */
@@ -488,166 +487,386 @@ interface Controller$2 {
   readonly retry: () => void;
   readonly reset: () => void;
 }
-//#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>;
-};
-declare namespace outcome_d_exports {
-  export { Composition, Content, ContentProps, Description, DescriptionProps, Header$1 as Header, HeaderProps, Layout, Media, MediaProps, Provider, Root$7 as Root, RootProps$7 as RootProps, State$2 as State, Title, TitleProps, Tone, Value$1 as Value, useOutcome };
-}
-/** How the outcome reads: a problem, a caution, or a step that went through. */
-type Tone = "danger" | "success" | "warning";
-/** `card` is the panel a flow shows on its own; `inline` sits under a field or in a busy row. */
-type Layout = "card" | "inline";
-/** What a flow resolved for the outcome its parts render. */
-interface Value$1 {
-  readonly tone: Tone;
-  readonly layout: Layout;
-  readonly title: string;
-  readonly description: string;
-  /** The retry the flow allows, or `null` when it allows none. */
-  readonly retry: (() => void) | null;
-  /** The part name the flow's retry carries, so a host's selectors keep working. */
-  readonly retryPart: string;
-}
-/** What the surrounding flow resolved, for a part of your own inside `X.Outcome`. */
-declare function useOutcome(): Value$1;
-/** Binds a resolved outcome to the parts below it. Flows render this; hosts rarely do. */
-declare function Provider({ children, value }: {
-  readonly children: ReactNode;
-  readonly value: Value$1;
-}): ReactElement;
-interface State$2 extends Record<string, unknown> {
-  readonly tone: Tone;
-  readonly layout: Layout;
-}
-interface RootProps$7 extends PartProps<"div", State$2> {
-  readonly tone?: Tone;
-  readonly layout?: Layout;
-}
+/** The plan an attempt holds, whatever step it is on; `null` before there is one. */
+declare const planOf: (state: State$2) => Plan.Model | null;
 /**
- * The outcome itself. It announces, so a customer reading with assistive tech hears it. A `tone`
- * or `layout` of its own reaches every part below it, so the glyph and the words agree with the
- * root's own attributes.
+ * The plan still awaiting its apply, which is what a row of records reports; `null` once one has
+ * landed, because from then on an observation answers instead.
  */
-declare function Root$7({ layout, tone, ...props }: RootProps$7): ReactElement;
-interface HeaderProps extends PartProps<"div", State$2> {}
-/** Media, title, and description together, so the action below them can move on its own. */
-declare function Header$1(props: HeaderProps): ReactElement;
-interface MediaProps extends PartProps<"div", State$2> {
-  /** `icon` frames the glyph the way shadcn's `EmptyMedia` does; `default` draws it bare. */
-  readonly variant?: "default" | "icon";
-}
-/** The glyph for the tone. Children replace it; `icons` on `DomainKit.Root` replaces the set. */
-declare function Media({ variant, ...props }: MediaProps): ReactElement;
-interface TitleProps extends PartProps<"div", State$2> {}
-/** The heading from the catalog. Children win, for a host that words it itself. */
-declare function Title(props: TitleProps): ReactElement;
-interface DescriptionProps extends PartProps<"p", State$2> {}
-/** What to do about it, from the catalog. An outcome whose title says everything renders none. */
-declare function Description(props: DescriptionProps): ReactElement | null;
-interface ContentProps extends PartProps<"div", State$2> {}
-/**
- * The actions under the header. Without children it is the flow's retry, and a flow that allows
- * none renders nothing: read-only hides every control that would start a write again.
- */
-declare function Content(props: ContentProps): ReactElement | null;
-/** Media, title, and description in a header, then the action. What `X.Outcome` renders alone. */
-declare function Composition(): ReactElement;
-//#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 RootProps$7, KindProps {}
-interface ActionsProps$2 extends PartProps<"div", ReviewState>, KindProps {}
-interface DialogProps$3 extends KindProps {
-  readonly children?: ReactNode;
-  readonly onOpenChange?: (open: boolean) => void;
-  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 const pendingPlan: (state: State$2) => Plan.Model | null;
 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$4 as Outcome, OutcomeProps$3 as OutcomeProps, Root$6 as Root, RootProps$6 as RootProps, RootState$4 as RootState, State$3 as State, Status$4 as Status, StatusProps$4 as StatusProps, useController$3 as useController };
+  export { Controller$2 as Controller, Options$3 as Options, State$2 as State, pendingPlan, planOf, 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;
+  /** Refuse every step. Defaults to the surrounding `readOnly`. */
+  readonly readOnly?: boolean;
 }
 /**
  * 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$3["_tag"];
+declare function useController$3({ domain, onCleaned, readOnly, receiptId }: Options$3): Controller$2;
+//#endregion
+//#region src/domain-field.d.ts
+type Zone = Transport.Zone;
+type Account = Transport.Zones["connections"][number];
+type AuthMethod = Descriptor["methods"][number];
+/** Where a domain's records would go: the connection that serves it, and in which zone. */
+interface Placement {
+  readonly connectionId: string;
+  readonly zone: string;
+}
+type ZonesState = Data.TaggedEnum<{
+  Loading: {};
+  Ready: {
+    readonly zones: ReadonlyArray<Zone>;
+    readonly connections: ReadonlyArray<Account>;
+    readonly providers: ReadonlyArray<Descriptor>;
+  };
+  Failure: {
+    readonly error: DomainKit.Error;
+  };
+}>;
+declare const ZonesState: {
+  readonly $is: <Tag extends "Failure" | "Loading" | "Ready">(tag: Tag) => (u: unknown) => u is Extract<{
+    readonly _tag: "Failure";
+    readonly error: DomainKit.Error;
+  }, {
+    readonly _tag: Tag;
+  }> | Extract<{
+    readonly _tag: "Loading";
+  }, {
+    readonly _tag: Tag;
+  }> | Extract<{
+    readonly _tag: "Ready";
+    readonly zones: ReadonlyArray<Zone>;
+    readonly connections: ReadonlyArray<Account>;
+    readonly providers: ReadonlyArray<Descriptor>;
+  }, {
+    readonly _tag: Tag;
+  }>;
+  readonly $match: {
+    <Cases extends { readonly [Tag in "Failure" | "Loading" | "Ready"]: (args: Extract<{
+      readonly _tag: "Failure";
+      readonly error: DomainKit.Error;
+    } | {
+      readonly _tag: "Loading";
+    } | {
+      readonly _tag: "Ready";
+      readonly zones: ReadonlyArray<Zone>;
+      readonly connections: ReadonlyArray<Account>;
+      readonly providers: ReadonlyArray<Descriptor>;
+    }, {
+      readonly _tag: Tag;
+    }>) => any; }>(cases: Cases): (value: {
+      readonly _tag: "Failure";
+      readonly error: DomainKit.Error;
+    } | {
+      readonly _tag: "Loading";
+    } | {
+      readonly _tag: "Ready";
+      readonly zones: ReadonlyArray<Zone>;
+      readonly connections: ReadonlyArray<Account>;
+      readonly providers: ReadonlyArray<Descriptor>;
+    }) => import("effect/Unify").Unify<ReturnType<Cases["Failure" | "Loading" | "Ready"]>>;
+    <Cases extends { readonly [Tag in "Failure" | "Loading" | "Ready"]: (args: Extract<{
+      readonly _tag: "Failure";
+      readonly error: DomainKit.Error;
+    } | {
+      readonly _tag: "Loading";
+    } | {
+      readonly _tag: "Ready";
+      readonly zones: ReadonlyArray<Zone>;
+      readonly connections: ReadonlyArray<Account>;
+      readonly providers: ReadonlyArray<Descriptor>;
+    }, {
+      readonly _tag: Tag;
+    }>) => any; }>(value: {
+      readonly _tag: "Failure";
+      readonly error: DomainKit.Error;
+    } | {
+      readonly _tag: "Loading";
+    } | {
+      readonly _tag: "Ready";
+      readonly zones: ReadonlyArray<Zone>;
+      readonly connections: ReadonlyArray<Account>;
+      readonly providers: ReadonlyArray<Descriptor>;
+    }, cases: Cases): import("effect/Unify").Unify<ReturnType<Cases["Failure" | "Loading" | "Ready"]>>;
+  };
+  readonly Failure: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "Failure";
+    readonly error: DomainKit.Error;
+  }, "_tag">;
+  readonly Loading: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "Loading";
+  }, "_tag">;
+  readonly Ready: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "Ready";
+    readonly zones: ReadonlyArray<Zone>;
+    readonly connections: ReadonlyArray<Account>;
+    readonly providers: ReadonlyArray<Descriptor>;
+  }, "_tag">;
+};
+interface ZonesController {
+  readonly state: ZonesState;
+  readonly zones: ReadonlyArray<Zone>;
+  readonly connections: ReadonlyArray<Account>;
+  readonly providers: ReadonlyArray<Descriptor>;
+  readonly refresh: () => void;
 }
-interface RootProps$6 extends PartProps<"div", RootState$4> {
-  readonly controller: Controller$2;
+interface ZonesOptions {
+  /** Only this provider's connections. Omit for every connection this owner holds. */
+  readonly provider?: string;
 }
-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$4(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;
+/**
+ * Every zone this owner's connections reach. A connection whose credential the provider turned
+ * down is listed in `connections` as `reconnect` and contributes no zones, so one dead account
+ * never costs the customer the others.
+ */
+declare function useZones({ provider }?: ZonesOptions): ZonesController;
+interface ConnectAccountInput {
+  readonly provider: string;
+  readonly method: AuthMethod["kind"];
+  /** Keyed by the descriptor's field names. Ignored by the interactive methods. */
+  readonly values?: Readonly<Record<string, string>>;
 }
-/** 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 { Descriptor$1 as Descriptor, Mark, MarkProps, MarkState, Marks };
+type AccountsState = Data.TaggedEnum<{
+  Loading: {};
+  Ready: {};
+  Submitting: {
+    readonly provider: string;
+  };
+  Redirecting: {
+    readonly url: string;
+  };
+  Failure: {
+    readonly error: DomainKit.Error;
+  };
+}>;
+declare const AccountsState: {
+  readonly $is: <Tag extends "Failure" | "Loading" | "Ready" | "Redirecting" | "Submitting">(tag: Tag) => (u: unknown) => u is Extract<{
+    readonly _tag: "Failure";
+    readonly error: DomainKit.Error;
+  }, {
+    readonly _tag: Tag;
+  }> | Extract<{
+    readonly _tag: "Loading";
+  }, {
+    readonly _tag: Tag;
+  }> | Extract<{
+    readonly _tag: "Ready";
+  }, {
+    readonly _tag: Tag;
+  }> | Extract<{
+    readonly _tag: "Redirecting";
+    readonly url: string;
+  }, {
+    readonly _tag: Tag;
+  }> | Extract<{
+    readonly _tag: "Submitting";
+    readonly provider: string;
+  }, {
+    readonly _tag: Tag;
+  }>;
+  readonly $match: {
+    <Cases extends { readonly [Tag in "Failure" | "Loading" | "Ready" | "Redirecting" | "Submitting"]: (args: Extract<{
+      readonly _tag: "Failure";
+      readonly error: DomainKit.Error;
+    } | {
+      readonly _tag: "Loading";
+    } | {
+      readonly _tag: "Ready";
+    } | {
+      readonly _tag: "Redirecting";
+      readonly url: string;
+    } | {
+      readonly _tag: "Submitting";
+      readonly provider: string;
+    }, {
+      readonly _tag: Tag;
+    }>) => any; }>(cases: Cases): (value: {
+      readonly _tag: "Failure";
+      readonly error: DomainKit.Error;
+    } | {
+      readonly _tag: "Loading";
+    } | {
+      readonly _tag: "Ready";
+    } | {
+      readonly _tag: "Redirecting";
+      readonly url: string;
+    } | {
+      readonly _tag: "Submitting";
+      readonly provider: string;
+    }) => import("effect/Unify").Unify<ReturnType<Cases["Failure" | "Loading" | "Ready" | "Redirecting" | "Submitting"]>>;
+    <Cases extends { readonly [Tag in "Failure" | "Loading" | "Ready" | "Redirecting" | "Submitting"]: (args: Extract<{
+      readonly _tag: "Failure";
+      readonly error: DomainKit.Error;
+    } | {
+      readonly _tag: "Loading";
+    } | {
+      readonly _tag: "Ready";
+    } | {
+      readonly _tag: "Redirecting";
+      readonly url: string;
+    } | {
+      readonly _tag: "Submitting";
+      readonly provider: string;
+    }, {
+      readonly _tag: Tag;
+    }>) => any; }>(value: {
+      readonly _tag: "Failure";
+      readonly error: DomainKit.Error;
+    } | {
+      readonly _tag: "Loading";
+    } | {
+      readonly _tag: "Ready";
+    } | {
+      readonly _tag: "Redirecting";
+      readonly url: string;
+    } | {
+      readonly _tag: "Submitting";
+      readonly provider: string;
+    }, cases: Cases): import("effect/Unify").Unify<ReturnType<Cases["Failure" | "Loading" | "Ready" | "Redirecting" | "Submitting"]>>;
+  };
+  readonly Failure: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "Failure";
+    readonly error: DomainKit.Error;
+  }, "_tag">;
+  readonly Loading: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "Loading";
+  }, "_tag">;
+  readonly Ready: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "Ready";
+  }, "_tag">;
+  readonly Redirecting: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "Redirecting";
+    readonly url: string;
+  }, "_tag">;
+  readonly Submitting: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "Submitting";
+    readonly provider: string;
+  }, "_tag">;
+};
+interface AccountsController {
+  readonly state: AccountsState;
+  readonly zones: ReadonlyArray<Zone>;
+  readonly connections: ReadonlyArray<Account>;
+  readonly providers: ReadonlyArray<Descriptor>;
+  /** Connect a provider with no domain attached. The account is what the customer is granting. */
+  readonly connect: (input: ConnectAccountInput) => void;
+  /**
+   * Prove an account again for a connection the owner already holds. The connection and its
+   * domains stay; only the credential behind it is replaced.
+   */
+  readonly reconnect: (input: ConnectAccountInput & {
+    readonly connectionId: string;
+  }) => void;
+  readonly refresh: () => void;
 }
-/** 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 AccountsOptions {
+  /** Where an interactive method returns the customer. Defaults to the page they started from. */
+  readonly returnTo?: string | null;
+  /** Refuse the commands that grant an account. Defaults to the surrounding `readOnly`. */
+  readonly readOnly?: boolean;
 }
-interface MarkProps extends PartProps<"span", MarkState> {
-  readonly provider: Descriptor$1;
+/**
+ * The accounts this owner holds, and the one way to add another: connect a provider without naming
+ * a domain. A token method finishes in place; an interactive one redirects and comes back through
+ * the library's own callback, which lands on `returnTo`.
+ */
+declare function useAccounts({ readOnly: refused, returnTo }?: AccountsOptions): AccountsController;
+/**
+ * The zone a value already sits in: the longest listed zone the value is at or under. Two accounts
+ * can serve the same zone, so `preferred` names the one the customer picked and wins among equals;
+ * without it the first listed account answers.
+ */
+declare const placementOf: (value: string, zones: ReadonlyArray<Zone>, preferred?: Placement | null) => {
+  readonly zone: Zone;
+  readonly placement: Placement;
+} | null;
+/** Zones the typed value is reaching for: a prefix of the zone, or a subdomain of one. */
+declare const suggestionsFor: (value: string, zones: ReadonlyArray<Zone>) => ReadonlyArray<Zone>;
+/** The value a suggestion completes to: whatever subdomain was typed, then the zone. */
+declare const completionOf: (value: string, zone: Zone) => string;
+interface DomainFieldOptions {
+  /** Every zone the surface offers, which `useZones` or `useAccounts` already holds. */
+  readonly zones: ReadonlyArray<Zone>;
+  readonly value: string;
+  readonly onChange: (value: string) => void;
+  /**
+   * Fires when the value or the account it resolves to changes, so a host holds the two together
+   * and submits them together. It reports the value as typed, not only the placement, because a
+   * form needs the name the customer is on as well as where its records would go.
+   */
+  readonly onResolve?: (input: {
+    readonly domain: string;
+    readonly connection: Placement | null;
+  }) => void;
+  /** The input's id. The listbox and its options are named from it; one is generated otherwise. */
+  readonly id?: string;
+}
+/** The props one suggestion carries, so the option is a listbox option to a screen reader. */
+interface OptionProps {
+  readonly "aria-selected": boolean;
+  readonly id: string;
+  readonly onMouseDown: MouseEventHandler<Element>;
+  readonly role: "option";
+}
+interface DomainFieldController {
+  /** Whether the listbox is showing: the customer opened it and there is something in it. */
+  readonly open: boolean;
+  /** The zones the typed value is reaching for, in the order they were listed. */
+  readonly suggestions: ReadonlyArray<Zone>;
+  /** The suggestion Tab and Enter would complete, or `null` when the list is empty. */
+  readonly highlighted: Zone | null;
+  /** The zone the value already sits in, with the account its records would go to. */
+  readonly found: {
+    readonly zone: Zone;
+    readonly placement: Placement;
+  } | null;
+  /** Finish the name from one suggestion, keeping whatever subdomain was typed in front of it. */
+  readonly complete: (zone: Zone) => void;
+  readonly close: () => void;
+  readonly inputProps: {
+    readonly "aria-activedescendant": AriaAttributes["aria-activedescendant"];
+    readonly "aria-autocomplete": "list";
+    readonly "aria-controls": string;
+    readonly "aria-expanded": boolean;
+    readonly autoComplete: "off";
+    readonly id: string;
+    readonly onChange: FormEventHandler<HTMLInputElement>;
+    readonly onFocus: FocusEventHandler<HTMLInputElement>;
+    readonly onKeyDown: KeyboardEventHandler<HTMLInputElement>;
+    readonly role: "combobox";
+    readonly type: "text";
+    readonly value: string;
+  };
+  readonly listboxProps: {
+    readonly "aria-label": string;
+    readonly hidden: boolean;
+    readonly id: string;
+    readonly role: "listbox";
+  };
+  readonly optionProps: (zone: Zone) => OptionProps;
 }
 /**
- * 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.
+ * One input over every zone the workspace's accounts reach, as props rather than markup. Arrow
+ * keys move the highlight, Tab or Enter completes it, Escape closes the list, and `found` says
+ * where the records will go.
  */
-declare function Mark({ provider, ...props }: MarkProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
+declare function useDomainField({ id, onChange, onResolve, value, zones }: DomainFieldOptions): DomainFieldController;
 declare namespace connect_d_exports {
-  export { Attempt, Candidate, Card$1 as Card, CardProps$1 as CardProps, ConnectInput, Controller$1 as Controller, Descriptor, Dialog$1 as Dialog, DialogProps$1 as DialogProps, DisconnectDialog, DisconnectDialogProps, Discovery, Field, Flow$2 as Flow, FlowProps$2 as FlowProps, Form, FormProps, Invitation, MethodDescriptor, Options$2 as Options, Outcome$3 as Outcome, OutcomeProps$2 as OutcomeProps, Prompt, PromptProps, 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, answeredInPlace, holdsConnection, hostProvider, offering, useController$2 as useController };
+  export { Account, AccountsController, AccountsOptions, AccountsState, Attempt, Candidate, ConnectAccountInput, ConnectInput, Controller$1 as Controller, DescribedMethod, DescribedMethods, Descriptor, Discovery, DomainFieldController, DomainFieldOptions, Field, Invitation, MethodDescriptor, MethodFields, Options$2 as Options, Placement, Reusable, Snapshot, State$1 as State, Zone, ZonesController, ZonesOptions, ZonesState, answeredInPlace, attempted, completionOf, describeMethods, displayName, holdsConnection, hostProvider, offering, placementOf, providerOf, reconnect, rejectedField, reusableConnections, suggestionsFor, useAccounts, useController$2 as useController, useDomainField, useZones };
 }
 type Snapshot = Transport.Snapshot;
 type Discovery = Transport.Discovery;
 type Candidate = Transport.Candidate;
-type Descriptor = Descriptor$1;
+/** A provider as the snapshot describes it: an id, a display name, and its auth methods. */
+type Descriptor = Transport.Snapshot["providers"][number];
 type MethodDescriptor = Descriptor["methods"][number];
 type Field = NonNullable<MethodDescriptor["fields"]>[number];
 /**
@@ -925,6 +1144,11 @@ interface ConnectInput {
 }
 interface Controller$1 {
   readonly domain: string;
+  /**
+   * What this domain's last apply landed, read once per receipt id and held here. `null` until
+   * the snapshot names a receipt, or when the transport carries no provisioning group.
+   */
+  readonly receipt: Receipt.Model | null;
   /**
    * How many times a connection has been established for this domain on this surface: a token
    * connect that landed, or a load that followed this library's own redirect back. It only ever
@@ -957,74 +1181,44 @@ interface Options$2 {
    * pass `null` to send none and let the server's `defaultReturnTo` decide.
    */
   readonly returnTo?: string | null;
+  /**
+   * Refuse every command that changes the connection. Defaults to the surrounding `readOnly`,
+   * which is `DomainKit.Root`'s unless a `DomainKit.ReadOnly` narrows it.
+   */
+  readonly readOnly?: boolean;
 }
 /**
  * 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;
+declare function useController$2({ domain, readOnly: refused, returnTo }: Options$2): Controller$1;
 /**
  * Whether a failure is already answered where it was raised: beside the method the customer used.
- * A flow rendering its own `Outcome` beside the dialog skips it, so the failure announces once.
+ * A surface rendering one outcome for the whole flow skips it, so the failure announces once.
  */
 declare const answeredInPlace: (controller: Controller$1) => boolean;
 /**
  * Whether the surface should read as connected: it is, or a command it started is in flight over a
- * connection that was. The card and the dialog it opened stay on screen for the length of the
- * command rather than vanishing under the customer half way through it.
+ * connection that was. The provider row and the dialog it opened stay on screen for the length of
+ * the command rather than vanishing under the customer half way through it.
  */
 declare const holdsConnection: (controller: Controller$1) => boolean;
+/**
+ * Whether the provider turned the credential down, so the customer must prove the account again.
+ * Proving it re-credits the connection the workspace already holds and leaves its domains where
+ * they are, which is why the surface offers a reconnect rather than a second account.
+ */
+declare const reconnect: (controller: Controller$1) => boolean;
 /**
  * The provider whose nameservers serve this domain, as the snapshot describes it. Discovery names
  * it by id; without a descriptor there is nothing to draw, so there is no host.
  */
 declare const hostProvider: (controller: Controller$1) => Descriptor | null;
-interface OutcomeProps$2 extends RootProps$7 {
-  readonly controller: Controller$1;
-}
-/**
- * The last failure as a card: media, the catalog's title and description, and the retry the flow
- * allows. Children replace the composition and keep the binding.
- */
-declare function Outcome$3({ children, 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;
-  /**
-   * Narrow to this provider whatever discovery found. The dialog's header menu sets it, so a
-   * customer who picks another provider gets the same one-decision surface for it.
-   */
-  readonly provider?: string;
-}
-/**
- * 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, provider: narrowed, ...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;
+/** The descriptor for one provider id, or `null` when the snapshot describes no such provider. */
+declare const providerOf: (controller: Controller$1, providerId: string | null | undefined) => Descriptor | null;
+/** The provider as the customer knows it, falling back to the id when the snapshot has no name. */
+declare const displayName: (controller: Controller$1, providerId: string) => string;
 /**
  * Whether the flow offers a connect surface: only when discovery names a host, always, or never.
  * `never` is a host that decides for itself, such as a domain already ready without DomainKit; a
@@ -1034,101 +1228,83 @@ type Invitation = "always" | "detected" | "never";
 /**
  * Whether the connect surface has anything to offer for this domain: a provider that serves the
  * zone, a connection discovery already found, one the owner already holds, or a command already
- * running. Never while a connection is held, which is what `holdsConnection` answers. `Prompt`
- * renders on this, and `Domain.Flow` reports it so a host can order its own offers beside
- * DomainKit's rather than competing with them.
+ * running. Never while a connection is held, which is what `holdsConnection` answers. A host reads
+ * it to order its own offers beside DomainKit's rather than competing with them.
  */
 declare const offering: (controller: Controller$1, connect?: Invitation) => boolean;
-interface PromptProps extends PartProps<"div", RootState$3> {
-  readonly controller: Controller$1;
-  /**
-   * `detected` offers nothing when discovery names no host, which is the honest answer for a
-   * domain DomainKit cannot write to. `always` offers the all-providers dialog anyway, and
-   * `never` offers none.
-   */
-  readonly connect?: Invitation;
-}
-/**
- * The disconnected offer: the provider whose nameservers serve the domain, what that means, and
- * the trigger that connects it. With no host detected there is nothing to offer, so nothing
- * renders unless the host application asks for the dialog anyway.
- */
-declare function Prompt({ connect, controller, ...props }: PromptProps): ReactElement | null;
-interface DisconnectDialogProps {
-  readonly controller: Controller$1;
-  /** The receipt the cleanup this dialog ran produced, for a host that tracks its own state. */
-  readonly onCleaned?: (receipt: Receipt.Model) => void;
-  readonly trigger?: ReactNode;
+/** A connection this owner already holds that would serve the domain, as one list to offer. */
+interface Reusable {
+  readonly connectionId: string;
+  /** The zone the connection would attach, when discovery named one. */
+  readonly zone: string | undefined;
+  readonly label: string;
 }
 /**
- * Letting a provider go, with the records DomainKit added as one decision rather than two.
- * Confirming removes what the domain's apply receipt proves DomainKit created, then releases the
- * connection; a plan with nothing in it is not a failure, so it goes straight to the release.
- *
- * The cleanup is this dialog's own, so nothing re-reads the snapshot in between: the disconnect
- * needs the connection the cleanup just used.
+ * Every connection the customer can attach without proving anything: the one discovery resolved,
+ * the candidates a zone choice is between, and the connections the snapshot lists as reusable.
  */
-declare function DisconnectDialog({ controller, onCleaned, trigger }: DisconnectDialogProps): ReactElement;
-interface CardProps$1 extends PartProps<"div", RootState$3> {
-  readonly controller: Controller$1;
-  /** The receipt a cleanup run from the disconnect dialog produced. */
-  readonly onCleaned?: (receipt: Receipt.Model) => void;
+declare const reusableConnections: (controller: Controller$1) => ReadonlyArray<Reusable>;
+/** The fields one token method declares, split into what the surface asks for and what it hides. */
+interface MethodFields {
+  readonly required: ReadonlyArray<Field>;
+  /** The fields a provider does not need, which the surface keeps behind a disclosure. */
+  readonly optional: ReadonlyArray<Field>;
+  /** The field the provider's documentation link explains: the first secret, else the first field. */
+  readonly explains: string | null;
+}
+/** One declared auth method, with the fields it asks for already arranged. */
+interface DescribedMethod {
+  readonly kind: Storage.AuthMethod;
+  readonly descriptor: MethodDescriptor;
+  /** `null` for a method the customer clicks through, which asks for nothing on the page. */
+  readonly fields: MethodFields | null;
+}
+/** What one provider offers, in the order the descriptor declares it. */
+interface DescribedMethods {
+  /** The methods the customer clicks through: OAuth and the provider's own integration. */
+  readonly interactive: ReadonlyArray<DescribedMethod>;
+  /** The methods that ask for credentials on the page. */
+  readonly typed: ReadonlyArray<DescribedMethod>;
+  /**
+   * Both kinds are on offer, so the surface shows the interactive one and a control that opens the
+   * token form in its place: one decision at a time rather than a wall of alternatives.
+   */
+  readonly alternate: boolean;
 }
+/** One provider's auth methods, arranged for a surface that asks for one decision at a time. */
+declare const describeMethods: (provider: Descriptor) => DescribedMethods;
 /**
- * A connected domain, with the prompt card's anatomy: the provider's mark, the name the customer
- * knows it by, where the connection stands, and the one action that ends it.
+ * The one field a rejected command was about, if any. A provider that turns down credentials is
+ * answering the secret it was given, and it names no field, so the first secret carries the
+ * answer; anything else is about the request rather than one input.
  */
-declare function Card$1({ controller, onCleaned, ...props }: CardProps$1): ReactElement;
-interface FlowProps$2 extends Omit<RootProps$5, "controller"> {
-  readonly domain: string;
-  readonly returnTo?: string | null;
-  /** Offer the connect dialog even when discovery names no host. Defaults to `detected`. */
-  readonly connect?: Invitation;
-  /** The receipt a cleanup run from the disconnect dialog produced. */
-  readonly onCleaned?: (receipt: Receipt.Model) => void;
-}
-/** Connection on its own: the card once connected, the prompt until then. */
-declare function Flow$2({ connect, domain, onCleaned, returnTo, ...props }: FlowProps$2): ReactElement;
+declare const rejectedField: (error: DomainKit.Error | null, fields: ReadonlyArray<Field>) => string | null;
+/** Whether a failure was raised by this provider's method, so the form answers beside it. */
+declare const attempted: (controller: Controller$1, provider: string, method: Storage.AuthMethod) => DomainKit.Error | null;
 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$2 as Outcome, OutcomeProps$1 as OutcomeProps, Root$4 as Root, RootProps$4 as RootProps, RootState$2 as RootState, State$3 as State, Status$2 as Status, StatusProps$2 as StatusProps, useController$1 as useController };
+  export { Controller$2 as Controller, Options$1 as Options, State$2 as State, pendingPlan, planOf, useController$1 as useController };
 }
 interface Options$1 {
   readonly domain: string;
   readonly requirements: ReadonlyArray<DnsRecord.Model>;
   readonly onApplied?: (receipt: Receipt.Model) => void;
+  /** Refuse every step. Defaults to the surrounding `readOnly`. */
+  readonly readOnly?: boolean;
 }
-declare function useController$1({ domain, onApplied, requirements }: Options$1): Controller$2;
-interface RootState$2 extends Record<string, unknown> {
-  readonly status: State$3["_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$2(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 function useController$1({ domain, onApplied, readOnly, requirements }: Options$1): Controller$2;
 declare namespace verify_d_exports {
-  export { Controller, Evidence, EvidenceProps, HostEvidence, ObserveAction, ObserveActionProps, Options, Outcome$1 as 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 };
+  export { Controller, Evidence, HostEvidence, Options, Readiness$1 as Readiness, Requirement, State, useController, valuesOf };
 }
 type Readiness$1 = Transport.Readiness;
 type HostEvidence = Readiness$1["host"][number];
 type Requirement = Readiness$1["requirements"][number];
 type Evidence = Requirement["evidence"][number];
+/**
+ * What the observer read back for the requirement's name, or `null` when it read nothing back at
+ * all. Host evidence reports a status the host reached rather than values read off a name, and an
+ * `unknown` observation is a lookup that never answered, which is not the same as finding nothing.
+ */
+declare const valuesOf: (evidence: Evidence) => ReadonlyArray<string> | null;
 /**
  * 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.
@@ -1263,90 +1439,17 @@ interface Options {
 }
 /** 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["_tag"];
-}
-interface RootProps$3 extends PartProps<"div", RootState$1> {
-  readonly controller: Controller;
-}
-declare function Root$3({ controller, ...props }: RootProps$3): ReactElement;
-interface ObserveActionProps extends PartProps<"button", RootState$1> {
-  readonly controller: Controller;
-}
-declare function ObserveAction({ controller, ...props }: ObserveActionProps): ReactElement;
-interface EvidenceProps {
-  readonly readiness: Readiness$1;
-}
-/**
- * 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 RootProps$7 {
-  readonly controller: Controller;
-}
-/**
- * The last observation that failed. Observing reads the world rather than changing the domain, so
- * the retry stays even in read-only.
- */
-declare function Outcome$1({ children, 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;
-}
-/** 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, Review, Slots, VerificationSlotProps };
-}
-interface RecordsSlotProps {
-  readonly records: ReadonlyArray<DnsRecord.Model>;
-  readonly readiness: Readiness$1 | null;
-  readonly controller: Controller;
-  readonly domain: string;
-}
-interface VerificationSlotProps {
-  readonly controller: Controller;
-  readonly domain: string;
-}
-interface ActionsSlotProps {
-  readonly connection: Controller$1;
-  readonly provisioning: Controller$2;
-  readonly cleanup: Controller$2;
-  readonly domain: string;
-}
-interface ConnectionSlotProps {
-  readonly controller: Controller$1;
-  readonly domain: string;
-  /** What the flow was told to offer when discovery names no host. */
-  readonly connect: Invitation;
+  export { Flow, FlowOptions, FlowState, useFlow };
 }
 /**
- * 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.Prompt` until then. */
-  readonly connection?: (props: ConnectionSlotProps) => ReactNode;
-}
-/**
- * What DomainKit has to say about this domain, on the part's data attributes, in `className` and
- * `style` callbacks, and through `onState`. A host reads `connected` and `offering` to order its
- * own offers beside DomainKit's: an offer of its own competes while `offering` is true, and a
+ * What DomainKit has to say about this domain. A host reads `connected` and `offering` to order
+ * its own offers beside DomainKit's: an offer of its own competes while `offering` is true, and a
  * domain DomainKit holds needs none.
  */
-interface FlowState extends Record<string, unknown> {
+interface FlowState {
   readonly connection: State$1["_tag"];
-  readonly provisioning: State$3["_tag"];
+  readonly provisioning: State$2["_tag"];
   /**
    * DomainKit holds a connection for this domain, including while a command it started over that
    * connection is still running. `offering` is never true at the same time.
@@ -1356,6 +1459,11 @@ interface FlowState extends Record<string, unknown> {
   readonly offering: boolean;
   /** Who holds the connection, or whose nameservers serve the zone. */
   readonly provider: string | null;
+  /**
+   * The account the records go to, as the provider labelled the zone when the domain was attached.
+   * `null` until there is an attachment.
+   */
+  readonly label: string | null;
   /**
    * The apply receipt this domain's latest provisioning attempt produced, which is what cleanup
    * plans from. A host's own "remove this domain" surface offers cleanup only when there is one.
@@ -1363,11 +1471,21 @@ interface FlowState extends Record<string, unknown> {
   readonly receiptId: Receipt.ReceiptId | null;
   /** `receiptId !== null`: DomainKit applied records here and can prove which. */
   readonly applied: boolean;
+  /**
+   * The surface may read this domain but not write to it, so a host can say why rather than
+   * leaving a customer in front of a page with nothing on it.
+   */
+  readonly readOnly: boolean;
 }
-interface FlowProps extends Omit<PartProps<"div", FlowState>, "children"> {
+interface FlowOptions {
   readonly domain: string;
   readonly requirements: ReadonlyArray<DnsRecord.Model>;
-  readonly slots?: Slots;
+  /**
+   * Offer the connect surface even when discovery names no host, for a host application that lets
+   * a customer connect a provider the domain's nameservers do not point at, or `never` for a
+   * domain the host has already settled another way. Defaults to `detected`.
+   */
+  readonly connect?: Invitation;
   readonly onApplied?: (receipt: Receipt.Model) => void;
   readonly onCleaned?: (receipt: Receipt.Model) => void;
   /**
@@ -1375,62 +1493,28 @@ interface FlowProps extends Omit<PartProps<"div", FlowState>, "children"> {
    * 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. */
+  /** Report this domain's state without the controls that change it. Defaults to the root's. */
   readonly readOnly?: boolean;
-  /**
-   * Offer the connect dialog even when discovery names no host, for a host application that lets
-   * a customer connect a provider the domain's nameservers do not point at, or `never` for a
-   * domain the host has already settled another way. Defaults to `detected`.
-   */
-  readonly connect?: Invitation;
-  /** Fires whenever what DomainKit has to say about this domain changes, and once on mount. */
-  readonly onState?: (state: FlowState) => void;
-  /**
-   * `auto` plans and opens the review the moment a connection lands, so connecting and adding the
-   * records is one pass rather than three. `manual` waits for the trigger.
-   */
-  readonly review?: Review;
 }
-/** Whether the flow opens the plan itself once a connection lands, or waits to be asked. */
-type Review = "auto" | "manual";
-/**
- * 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({ connect, domain, onApplied, onCleaned, onState, readOnly, requirements, returnTo, review, slots, ...props }: FlowProps): ReactElement;
-//#endregion
-//#region src/icons.d.ts
-/**
- * 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 {
-  /** Points at what a control opens: the provider menu's own marker. */
-  readonly chevron: ReactNode;
-  readonly close: ReactNode;
-  readonly copied: ReactNode;
-  readonly copy: ReactNode;
-  readonly download: ReactNode;
-  readonly external: ReactNode;
-  readonly failure: ReactNode;
-  readonly pending: ReactNode;
-  readonly success: ReactNode;
-  readonly warning: ReactNode;
+interface Flow {
+  readonly domain: string;
+  /** What the host asked for, as the surface renders it row by row. */
+  readonly requirements: ReadonlyArray<DnsRecord.Model>;
+  readonly state: FlowState;
+  readonly connection: Controller$1;
+  readonly provisioning: Controller$2;
+  /** Bound to the domain's latest apply receipt, which is the only thing cleanup may undo. */
+  readonly cleanup: Controller$2;
+  readonly verification: Controller;
+  /** The plan the rows report, which is one still awaiting its apply. */
+  readonly plan: Plan.Model | null;
+  readonly readiness: Readiness$1 | null;
+  /** Which capability groups the transport declares, so a surface renders only what it can run. */
+  readonly capabilities: ReadonlyArray<Transport.Capability>;
+  /** What the flow was told to offer when discovery names no host. */
+  readonly invitation: Invitation;
 }
-declare const defaultIcons: {
-  readonly chevron: import("react/jsx-runtime").JSX.Element;
-  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;
-  readonly warning: import("react/jsx-runtime").JSX.Element;
-};
-declare function useIcons(): Icons;
+declare function useFlow({ connect, domain, onApplied, onCleaned, readOnly, requirements, returnTo }: FlowOptions): Flow;
 declare namespace messages_d_exports {
   export { Catalog, EvidenceLike, Outcome, OutcomeContext, english, failure, merge, outcome };
 }
@@ -1464,8 +1548,10 @@ interface Catalog {
   readonly useTokenInstead: string;
   /** Returns from one method's form to the provider's methods. */
   readonly back: string;
-  /** The connected card's own line, beside the provider's name. */
-  readonly connected: string;
+  /** The connected card's identity: who holds the connection and which account it reaches. */
+  readonly connectedAccount: (provider: string, account: string) => string;
+  /** How many records this domain's apply receipt proves DomainKit added. */
+  readonly recordsAdded: (count: number) => string;
   readonly needsReconnect: string;
   /** The disconnect dialog's scope question, when the connection serves other domains too. */
   readonly disconnectScope: string;
@@ -1477,6 +1563,14 @@ interface Catalog {
   readonly download: string;
   readonly useConnection: (label: string) => string;
   readonly chooseZone: string;
+  /** The domain field's listbox, named for a customer reading it with assistive technology. */
+  readonly zoneSuggestions: string;
+  /** Which account a typed domain's records will go to. */
+  readonly recordsGoTo: (provider: string, account: string) => string;
+  /** A typed domain no connected account reaches; the customer adds the records by hand. */
+  readonly notInConnectedAccount: string;
+  /** A held connection whose credential the provider turned down. */
+  readonly reconnectAccount: (account: string) => string;
   readonly getToken: string;
   readonly loading: string;
   readonly connecting: string;
@@ -1494,11 +1588,16 @@ interface Catalog {
   /** The dialog heading, and the trigger, when no provider is named yet. */
   readonly connectAnyTitle: string;
   /** What the disconnected prompt says about the provider whose nameservers serve the domain. */
-  readonly hostOwnsZone: string;
+  readonly hostDetected: (provider: string) => 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;
+  /**
+   * What a customer who may read the domain but not write to it is told in place of the connect
+   * control, so the surface explains the gap rather than leaving an empty row.
+   */
+  readonly administratorConnects: (provider: string) => string;
   readonly reconnectRequired: (provider: string) => string;
   readonly disconnectTitle: (provider: string) => string;
   /**
@@ -1533,6 +1632,10 @@ interface Catalog {
   readonly declineReason: (reason: string) => string;
   readonly operation: (operation: Plan.Operation) => string;
   readonly conflictReason: (reason: Plan.Conflict["reason"]) => string;
+  /** What to do about a conflict, in the row that reports it. */
+  readonly conflictAdvice: (reason: Plan.Conflict["reason"]) => string;
+  /** What a pending plan holds for one row: a write, a record already there, or a blocker. */
+  readonly planStatus: (operation: Plan.Operation) => string;
   readonly attemptStatus: (status: Storage.AttemptStatus) => string;
   readonly recordsCaption: (domain: string) => string;
   readonly headingType: string;
@@ -1614,74 +1717,49 @@ declare const merge: (overrides?: Partial<Catalog>) => Catalog;
 declare const outcome: (error: DomainKit.Error, catalog: Catalog, context?: OutcomeContext) => Outcome;
 /** The same failure as one sentence, for a host that renders text rather than a card. */
 declare const failure: (error: DomainKit.Error, catalog: Catalog, context?: OutcomeContext) => string;
-declare namespace theme_d_exports {
-  export { Theme, toStyle };
-}
-interface Theme {
-  readonly accent?: string;
-  readonly accentContrast?: string;
-  readonly backdrop?: string;
-  readonly background?: string;
-  readonly border?: string;
-  readonly danger?: string;
-  readonly dangerContrast?: string;
-  readonly fill?: string;
-  readonly fontFamily?: string;
-  readonly muted?: string;
-  readonly radius?: string;
-  readonly shadow?: string;
-  readonly success?: string;
-  readonly text?: string;
-  readonly warning?: string;
-}
-declare function toStyle(theme?: Theme): CSSProperties;
 declare namespace domain_kit_d_exports {
-  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";
+  export { ReadOnly, Root, RootProps, StableTransport, useCapabilities, useDomainKit, useMessages, useReadOnly, useTransport };
 }
-interface RootProps$2 extends Omit<PartProps<"div", RootState>, "children"> {
+interface RootProps {
   readonly children: ReactNode;
-  readonly colorScheme?: RootState["colorScheme"];
-  readonly icons?: Partial<Icons>;
-  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.
+   * Report the domain's 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. Every flow carries it on `FlowState.readOnly`, so a surface can explain it.
    */
   readonly readOnly?: boolean;
   /** Bump to re-inspect every mounted domain after a change the UI did not make. */
   readonly revision?: number;
-  readonly theme?: Theme;
   /** 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 emit: Listener;
-  readonly marks: Marks;
   readonly messages: Catalog;
   readonly navigate: (url: string) => void;
-  readonly portalContainer: RefObject<HTMLElement | null>;
   readonly readOnly: boolean;
   readonly revision: number;
-  readonly themeStyle: ReturnType<typeof toStyle>;
   readonly transport: Transport.Interface;
 }
 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;
+/**
+ * The transport, the catalog, and the two host callbacks every hook below reads. It renders no
+ * element of its own: `@domainkit/react` supplies behaviour, state, copy, and accessibility, and
+ * the host application supplies the markup.
+ */
+declare function Root({ children, messages, navigate, onEvent, readOnly, revision, transport }: RootProps): ReactElement;
 declare function useDomainKit(): ContextValue;
+/** The catalog `DomainKit.Root` holds, with the host's overrides already merged in. */
+declare function useMessages(): Catalog;
 /** 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. */
@@ -1689,39 +1767,22 @@ 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. */
+/** Whether this surface may offer controls that change the domain. */
 declare function useReadOnly(): boolean;
-/** Which capability groups the host's transport declares, for gating a custom part. */
+/** Which capability groups the host's transport declares, for gating a surface of your own. */
 declare function useCapabilities(): ReadonlyArray<Transport.Capability>;
-declare namespace operations_d_exports {
-  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: Plan.Operation["_tag"];
-}> {
-  readonly operation: Plan.Operation;
-}
-declare function Item({ operation, ...props }: ItemProps): ReactElement;
-interface RootProps$1 extends PartProps<"ul", {
-  readonly count: number;
-  readonly kind: Plan.Kind;
-}> {
-  readonly count?: number;
-  readonly kind: Plan.Kind;
-}
-declare function Root$1({ count, kind, ...props }: RootProps$1): ReactElement;
-interface ListProps extends Omit<RootProps$1, "children" | "count" | "kind"> {
-  readonly plan: Plan.Model;
+declare namespace outcome_d_exports {
+  export { Outcome, OutcomeContext, describe, useDescribe };
 }
-/** Every operation the plan holds, in plan order, so a customer reviews exactly what will run. */
-declare function List({ plan, ...props }: ListProps): ReactElement;
+/** The catalog's title and description for one failure. */
+declare const describe: (error: DomainKit.Error, catalog: Catalog, context?: OutcomeContext) => Outcome;
+/**
+ * `describe` bound to the catalog `DomainKit.Root` holds. The reason alone cannot name the
+ * provider a customer typed a token for, so the surface supplies it in the context.
+ */
+declare function useDescribe(): (error: DomainKit.Error, context?: OutcomeContext) => Outcome;
 declare namespace records_d_exports {
-  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 };
+  export { CopyController, Readiness, RequirementStatus, Sources, Standing, copyText, downloadZoneFile, identity, requirementsKey, statusOf, toZoneFile, useCopy };
 }
 type Readiness = Transport.Readiness;
 type RequirementStatus = Readiness["requirements"][number]["status"];
@@ -1733,45 +1794,24 @@ interface CopyController {
   readonly copy: () => void;
 }
 declare function useCopy(value: string, resetAfter?: number): CopyController;
-interface CopyValueProps extends PartProps<"span", {
-  readonly copied: boolean;
-}> {
-  readonly value: string;
-}
-declare function CopyValue({ value, ...props }: CopyValueProps): ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
-interface ZoneFileProps extends PartProps<"div", {
-  readonly count: number;
-}> {
-  readonly domain: string;
-  readonly records: ReadonlyArray<DnsRecord.Model>;
-}
-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;
-}> {
+/**
+ * What a row has to say about one record: while a plan is pending it is what the plan will do to
+ * it, and otherwise what the last observation read back.
+ */
+type Standing = {
+  readonly _tag: "Operation";
+  readonly operation: Plan.Operation;
+} | {
+  readonly _tag: "Readiness";
   readonly status: RequirementStatus;
+};
+interface Sources {
+  /** A plan still awaiting its apply. Pass `null` once one has landed; readiness answers then. */
+  readonly plan?: Plan.Model | null | undefined;
+  readonly readiness?: Readiness | null | undefined;
 }
-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({ count, ...props }: RootProps): import("react/jsx-runtime").JSX.Element;
+/** The row's standing, or `null` when neither a plan nor an observation covers the record. */
+declare const statusOf: (record: DnsRecord.Model, sources: Sources) => Standing | null;
 /** A stable React key for a requirement: type, name, and data identify a record. */
 declare const identity: (record: DnsRecord.Model) => string;
 /**
@@ -1781,22 +1821,6 @@ declare const identity: (record: DnsRecord.Model) => string;
  * 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 record: string;
-}> {
-  readonly readiness?: Readiness | null;
-  readonly record: DnsRecord.Model;
-}
-declare function Card({ readiness, record, ...props }: CardProps): ReactElement;
-interface TableProps extends PartProps<"table", {
-  readonly count: number;
-}> {
-  readonly caption?: string;
-  readonly readiness?: Readiness | null;
-  readonly records: ReadonlyArray<DnsRecord.Model>;
-}
-/** 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 };
 }
@@ -1848,5 +1872,5 @@ declare const Failure: {
   }, "_tag">;
 };
 //#endregion
-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, outcome_d_exports as Outcome, 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 };
+export { cleanup_d_exports as Cleanup, connect_d_exports as Connect, domain_d_exports as Domain, domain_kit_d_exports as DomainKit, Event, Failure, type Listener, messages_d_exports as Messages, outcome_d_exports as Outcome, provision_d_exports as Provision, records_d_exports as Records, testing_d_exports as Testing, verify_d_exports as Verify };
 //# sourceMappingURL=index.d.mts.map