@domainkit/react 0.9.1 → 0.11.0

package/dist/index.d.mts

@@ -240,7 +240,7 @@ declare const Event: {
 type Listener = (event: Event) => void;
 //#endregion
 //#region src/attempt.d.ts
-type State$2 = Data.TaggedEnum<{
+type State$3 = Data.TaggedEnum<{
   Idle: {};
   Planning: {};
   Planned: {
@@ -268,7 +268,7 @@ type State$2 = Data.TaggedEnum<{
     readonly error: DomainKit.Error;
   };
 }>;
-declare const State$2: {
+declare const State$3: {
   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 +475,7 @@ declare const State$2: {
   }, "_tag">;
 };
 interface Controller$2 {
-  readonly state: State$2;
+  readonly state: State$3;
   /** 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. */
@@ -501,6 +501,68 @@ type PartProps<Tag extends ElementType = "div", State extends Record<string, unk
   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 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.
+ */
+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> {
@@ -511,7 +573,7 @@ interface KindProps {
   readonly kind: Plan.Kind;
 }
 interface StatusProps$5 extends PartProps<"p", ReviewState>, KindProps {}
-interface OutcomeProps$4 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;
@@ -525,7 +587,7 @@ interface DialogProps$3 extends KindProps {
   readonly trigger?: ReactNode;
 }
 declare namespace cleanup_d_exports {
-  export { Actions$1 as Actions, ActionsProps$1 as ActionsProps, Controller$2 as Controller, Dialog$2 as Dialog, DialogProps$2 as DialogProps, Flow$3 as Flow, FlowProps$3 as FlowProps, Options$3 as Options, Outcome$3 as Outcome, OutcomeProps$3 as OutcomeProps, Root$6 as Root, RootProps$6 as RootProps, RootState$4 as RootState, State$2 as State, Status$4 as Status, StatusProps$4 as StatusProps, useController$3 as useController };
+  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 };
 }
 interface Options$3 {
   readonly domain: string;
@@ -539,7 +601,7 @@ interface Options$3 {
  */
 declare function useController$3({ domain, onCleaned, receiptId }: Options$3): Controller$2;
 interface RootState$4 extends Record<string, unknown> {
-  readonly status: State$2["_tag"];
+  readonly status: State$3["_tag"];
 }
 interface RootProps$6 extends PartProps<"div", RootState$4> {
   readonly controller: Controller$2;
@@ -550,7 +612,7 @@ declare function Dialog$2(props: DialogProps$2): ReactElement;
 interface ActionsProps$1 extends Omit<ActionsProps$2, "kind"> {}
 declare function Actions$1(props: ActionsProps$1): ReactElement | null;
 interface OutcomeProps$3 extends Omit<OutcomeProps$4, "kind"> {}
-declare function Outcome$3(props: OutcomeProps$3): ReactElement | null;
+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"> {
@@ -580,7 +642,7 @@ interface MarkProps extends PartProps<"span", MarkState> {
  */
 declare function Mark({ provider, ...props }: MarkProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
 declare namespace connect_d_exports {
-  export { Candidate, Card$1 as Card, CardProps$1 as CardProps, ConnectInput, Controller$1 as Controller, Descriptor, Dialog$1 as Dialog, DialogProps$1 as DialogProps, Discovery, Field, Flow$2 as Flow, FlowProps$2 as FlowProps, Form, FormProps, MethodDescriptor, Options$2 as Options, Outcome$2 as Outcome, OutcomeProps$2 as OutcomeProps, Root$5 as Root, RootProps$5 as RootProps, RootState$3 as RootState, Snapshot, State$1 as State, Status$3 as Status, StatusProps$3 as StatusProps, useController$2 as useController };
+  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 };
 }
 type Snapshot = Transport.Snapshot;
 type Discovery = Transport.Discovery;
@@ -609,6 +671,7 @@ type State$1 = Data.TaggedEnum<{
   };
   Submitting: {
     readonly snapshot: Snapshot | null;
+    readonly discovery: Discovery | null;
   };
   Redirecting: {
     readonly url: string;
@@ -620,6 +683,10 @@ type State$1 = Data.TaggedEnum<{
   };
   Failure: {
     readonly error: DomainKit.Error;
+    readonly snapshot: Snapshot | null;
+    readonly discovery: Discovery | null;
+    /** The provider and method the customer was using, when a command failed rather than a read. */
+    readonly attempt: Attempt | null;
   };
 }>;
 declare const State$1: {
@@ -637,6 +704,9 @@ declare const State$1: {
   }> | Extract<{
     readonly _tag: "Failure";
     readonly error: DomainKit.Error;
+    readonly snapshot: Snapshot | null;
+    readonly discovery: Discovery | null;
+    readonly attempt: Attempt | null;
   }, {
     readonly _tag: Tag;
   }> | Extract<{
@@ -664,6 +734,7 @@ declare const State$1: {
   }> | Extract<{
     readonly _tag: "Submitting";
     readonly snapshot: Snapshot | null;
+    readonly discovery: Discovery | null;
   }, {
     readonly _tag: Tag;
   }>;
@@ -678,6 +749,9 @@ declare const State$1: {
     } | {
       readonly _tag: "Failure";
       readonly error: DomainKit.Error;
+      readonly snapshot: Snapshot | null;
+      readonly discovery: Discovery | null;
+      readonly attempt: Attempt | null;
     } | {
       readonly _tag: "Loading";
       readonly snapshot: Snapshot | null;
@@ -695,6 +769,7 @@ declare const State$1: {
     } | {
       readonly _tag: "Submitting";
       readonly snapshot: Snapshot | null;
+      readonly discovery: Discovery | null;
     }, {
       readonly _tag: Tag;
     }>) => any; }>(cases: Cases): (value: {
@@ -707,6 +782,9 @@ declare const State$1: {
     } | {
       readonly _tag: "Failure";
       readonly error: DomainKit.Error;
+      readonly snapshot: Snapshot | null;
+      readonly discovery: Discovery | null;
+      readonly attempt: Attempt | null;
     } | {
       readonly _tag: "Loading";
       readonly snapshot: Snapshot | null;
@@ -724,6 +802,7 @@ declare const State$1: {
     } | {
       readonly _tag: "Submitting";
       readonly snapshot: Snapshot | null;
+      readonly discovery: Discovery | null;
     }) => import("effect/Unify").Unify<ReturnType<Cases["Connected" | "Disconnected" | "Failure" | "Loading" | "Reconnect" | "Redirecting" | "SelectionRequired" | "Submitting"]>>;
     <Cases extends { readonly [Tag in "Connected" | "Disconnected" | "Failure" | "Loading" | "Reconnect" | "Redirecting" | "SelectionRequired" | "Submitting"]: (args: Extract<{
       readonly _tag: "Connected";
@@ -735,6 +814,9 @@ declare const State$1: {
     } | {
       readonly _tag: "Failure";
       readonly error: DomainKit.Error;
+      readonly snapshot: Snapshot | null;
+      readonly discovery: Discovery | null;
+      readonly attempt: Attempt | null;
     } | {
       readonly _tag: "Loading";
       readonly snapshot: Snapshot | null;
@@ -752,6 +834,7 @@ declare const State$1: {
     } | {
       readonly _tag: "Submitting";
       readonly snapshot: Snapshot | null;
+      readonly discovery: Discovery | null;
     }, {
       readonly _tag: Tag;
     }>) => any; }>(value: {
@@ -764,6 +847,9 @@ declare const State$1: {
     } | {
       readonly _tag: "Failure";
       readonly error: DomainKit.Error;
+      readonly snapshot: Snapshot | null;
+      readonly discovery: Discovery | null;
+      readonly attempt: Attempt | null;
     } | {
       readonly _tag: "Loading";
       readonly snapshot: Snapshot | null;
@@ -781,6 +867,7 @@ declare const State$1: {
     } | {
       readonly _tag: "Submitting";
       readonly snapshot: Snapshot | null;
+      readonly discovery: Discovery | null;
     }, cases: Cases): import("effect/Unify").Unify<ReturnType<Cases["Connected" | "Disconnected" | "Failure" | "Loading" | "Reconnect" | "Redirecting" | "SelectionRequired" | "Submitting"]>>;
   };
   readonly Connected: Data.TaggedEnum.ConstructorFrom<{
@@ -795,6 +882,9 @@ declare const State$1: {
   readonly Failure: Data.TaggedEnum.ConstructorFrom<{
     readonly _tag: "Failure";
     readonly error: DomainKit.Error;
+    readonly snapshot: Snapshot | null;
+    readonly discovery: Discovery | null;
+    readonly attempt: Attempt | null;
   }, "_tag">;
   readonly Loading: Data.TaggedEnum.ConstructorFrom<{
     readonly _tag: "Loading";
@@ -817,8 +907,14 @@ declare const State$1: {
   readonly Submitting: Data.TaggedEnum.ConstructorFrom<{
     readonly _tag: "Submitting";
     readonly snapshot: Snapshot | null;
+    readonly discovery: Discovery | null;
   }, "_tag">;
 };
+/** Which provider and method the failed command was for, so the form can answer beside it. */
+interface Attempt {
+  readonly provider: string;
+  readonly method: Storage.AuthMethod;
+}
 interface ConnectInput {
   readonly provider: string;
   readonly method: Storage.AuthMethod;
@@ -828,6 +924,13 @@ interface ConnectInput {
   readonly returnTo?: string;
 }
 interface Controller$1 {
+  readonly domain: string;
+  /**
+   * 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
+   * grows, so a flow acts on a change rather than on a state that would fire again every render.
+   */
+  readonly established: number;
   readonly state: State$1;
   readonly snapshot: Snapshot | null;
   readonly discovery: Discovery | null;
@@ -868,23 +971,47 @@ interface RootProps$5 extends PartProps<"div", RootState$3> {
   readonly controller: Controller$1;
 }
 declare function Root$5({ controller, ...props }: RootProps$5): ReactElement;
-interface OutcomeProps$2 extends PartProps<"p", RootState$3> {
+/**
+ * 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.
+ */
+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.
+ */
+declare const holdsConnection: (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 failure sentence, chosen by the error's reason, plus the retry that reason allows. */
-declare function Outcome$2({ controller, ...props }: OutcomeProps$2): ReactElement | null;
+/**
+ * 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, ...props }: FormProps): ReactElement;
+declare function Form({ controller, provider: narrowed, ...props }: FormProps): ReactElement;
 interface DialogProps$1 {
   readonly controller: Controller$1;
   readonly children?: ReactNode;
@@ -898,19 +1025,72 @@ interface DialogProps$1 {
 }
 /** 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;
+/**
+ * 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
+ * connected domain keeps its status and its disconnect either way.
+ */
+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.
+ */
+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;
+}
+/**
+ * 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.
+ */
+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;
 }
-/** A connected domain: which provider holds it, and how to let it go. */
-declare function Card$1({ controller, ...props }: CardProps$1): ReactElement;
+/**
+ * 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.
+ */
+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 dialog until then. */
-declare function Flow$2({ domain, returnTo, ...props }: FlowProps$2): ReactElement;
+/** 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 namespace provision_d_exports {
-  export { Actions, ActionsProps, Controller$2 as Controller, Dialog, DialogProps, Flow$1 as Flow, FlowProps$1 as FlowProps, Options$1 as Options, Outcome$1 as Outcome, OutcomeProps$1 as OutcomeProps, Root$4 as Root, RootProps$4 as RootProps, RootState$2 as RootState, State$2 as State, Status$2 as Status, StatusProps$2 as StatusProps, useController$1 as useController };
+  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 };
 }
 interface Options$1 {
   readonly domain: string;
@@ -919,7 +1099,7 @@ interface Options$1 {
 }
 declare function useController$1({ domain, onApplied, requirements }: Options$1): Controller$2;
 interface RootState$2 extends Record<string, unknown> {
-  readonly status: State$2["_tag"];
+  readonly status: State$3["_tag"];
 }
 interface RootProps$4 extends PartProps<"div", RootState$2> {
   readonly controller: Controller$2;
@@ -931,7 +1111,7 @@ interface ActionsProps extends Omit<ActionsProps$2, "kind"> {}
 /** Approve and Decline for a plan already under review. */
 declare function Actions(props: ActionsProps): ReactElement | null;
 interface OutcomeProps$1 extends Omit<OutcomeProps$4, "kind"> {}
-declare function Outcome$1(props: OutcomeProps$1): ReactElement | null;
+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"> {
@@ -943,7 +1123,7 @@ interface FlowProps$1 extends Omit<RootProps$4, "controller"> {
 /** Provisioning on its own: a trigger that plans, then the review dialog. */
 declare function Flow$1({ domain, onApplied, requirements, trigger, ...props }: FlowProps$1): import("react/jsx-runtime").JSX.Element;
 declare namespace verify_d_exports {
-  export { Controller, Evidence, EvidenceProps, HostEvidence, ObserveAction, ObserveActionProps, Options, Outcome, OutcomeProps, Readiness$1 as Readiness, Requirement, Root$3 as Root, RootProps$3 as RootProps, RootState$1 as RootState, State, Status$1 as Status, StatusProps$1 as StatusProps, useController };
+  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 };
 }
 type Readiness$1 = Transport.Readiness;
 type HostEvidence = Readiness$1["host"][number];
@@ -1102,10 +1282,14 @@ interface EvidenceProps {
  * anything DomainKit cannot observe but the host feeds in.
  */
 declare function Evidence({ readiness }: EvidenceProps): ReactElement;
-interface OutcomeProps extends PartProps<"p", RootState$1> {
+interface OutcomeProps extends RootProps$7 {
   readonly controller: Controller;
 }
-declare function Outcome({ controller, ...props }: OutcomeProps): ReactElement | null;
+/**
+ * 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: {
@@ -1116,7 +1300,7 @@ interface StatusProps$1 extends Omit<RootProps$3, "render"> {
 /** The default verification slot: a button that observes, with the evidence behind it. */
 declare function Status$1({ controller, render, ...props }: StatusProps$1): ReactElement;
 declare namespace domain_d_exports {
-  export { ActionsSlotProps, ConnectionSlotProps, Flow, FlowProps, FlowState, RecordsSlotProps, Slots, VerificationSlotProps };
+  export { ActionsSlotProps, ConnectionSlotProps, Flow, FlowProps, FlowState, RecordsSlotProps, Review, Slots, VerificationSlotProps };
 }
 interface RecordsSlotProps {
   readonly records: ReadonlyArray<DnsRecord.Model>;
@@ -1137,6 +1321,8 @@ interface ActionsSlotProps {
 interface ConnectionSlotProps {
   readonly controller: Controller$1;
   readonly domain: string;
+  /** What the flow was told to offer when discovery names no host. */
+  readonly connect: Invitation;
 }
 /**
  * Each slot replaces one part of the flow and keeps the rest. Every slot has a default, so
@@ -1149,12 +1335,34 @@ interface Slots {
   readonly verification?: (props: VerificationSlotProps) => ReactNode;
   /** Defaults to Approve and Decline, plus cleanup when the transport declares it. */
   readonly actions?: (props: ActionsSlotProps) => ReactNode;
-  /** Defaults to `Connect.Card` once connected and `Connect.Dialog` until then. */
+  /** 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
+ * domain DomainKit holds needs none.
+ */
 interface FlowState extends Record<string, unknown> {
   readonly connection: State$1["_tag"];
-  readonly provisioning: State$2["_tag"];
+  readonly provisioning: State$3["_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.
+   */
+  readonly connected: boolean;
+  /** The connect surface has something to offer, so a host's own offer would compete with it. */
+  readonly offering: boolean;
+  /** Who holds the connection, or whose nameservers serve the zone. */
+  readonly provider: 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.
+   */
+  readonly receiptId: Receipt.ReceiptId | null;
+  /** `receiptId !== null`: DomainKit applied records here and can prove which. */
+  readonly applied: boolean;
 }
 interface FlowProps extends Omit<PartProps<"div", FlowState>, "children"> {
   readonly domain: string;
@@ -1169,13 +1377,28 @@ interface FlowProps extends Omit<PartProps<"div", FlowState>, "children"> {
   readonly returnTo?: string | null;
   /** Render 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({ domain, onApplied, onCleaned, readOnly, requirements, returnTo, slots, ...props }: FlowProps): ReactElement;
+declare function Flow({ connect, domain, onApplied, onCleaned, onState, readOnly, requirements, returnTo, review, slots, ...props }: FlowProps): ReactElement;
 //#endregion
 //#region src/icons.d.ts
 /**
@@ -1183,6 +1406,8 @@ declare function Flow({ domain, onApplied, onCleaned, readOnly, requirements, re
  * 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;
@@ -1191,8 +1416,10 @@ interface Icons {
   readonly failure: ReactNode;
   readonly pending: ReactNode;
   readonly success: ReactNode;
+  readonly warning: ReactNode;
 }
 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;
@@ -1201,26 +1428,49 @@ declare const defaultIcons: {
   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 namespace messages_d_exports {
-  export { Catalog, EvidenceLike, english, failure, merge };
+  export { Catalog, EvidenceLike, Outcome, OutcomeContext, english, failure, merge, outcome };
 }
 interface Catalog {
   readonly connect: string;
-  readonly connectWith: (method: string) => string;
+  /** The token method's button, which carries the verb rather than the method's own label. */
+  readonly methodToken: string;
+  readonly methodOAuth: (provider: string) => string;
+  readonly methodIntegration: (provider: string) => string;
   readonly disconnect: string;
   readonly detach: string;
   readonly cancel: string;
   readonly close: string;
   readonly retry: string;
   readonly approve: string;
+  /** The provisioning dialog's primary action: what it adds, and how many. */
+  readonly addRecords: (count: number) => string;
   readonly decline: string;
+  /** Why the primary action is unavailable: every operation the plan holds is blocked. */
+  readonly everyRecordConflicts: string;
   readonly reviewChanges: string;
   readonly cleanUp: string;
   readonly checkDns: string;
   readonly checkAgain: string;
   readonly moreActions: string;
+  /** Reveals the fields a provider does not need, such as an account id. */
+  readonly moreOptions: string;
+  /** Reveals the providers the dialog narrowed away. */
+  readonly useAnotherProvider: string;
+  /** Opens the token form where a provider also offers a method the customer clicks through. */
+  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;
+  readonly needsReconnect: string;
+  /** The disconnect dialog's scope question, when the connection serves other domains too. */
+  readonly disconnectScope: string;
+  readonly disconnectThisDomain: string;
+  readonly disconnectEveryDomain: (count: number) => string;
   readonly copy: string;
   readonly copied: string;
   readonly copyZone: string;
@@ -1241,15 +1491,28 @@ interface Catalog {
   readonly cleaning: string;
   readonly observing: string;
   readonly connectTitle: (provider: string) => string;
-  /** The dialog heading before a provider is chosen. */
+  /** 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 connectDescription: (domain: string) => string;
   readonly connectedTo: (provider: string) => string;
   /** Shown where a connect control would be when the customer may not connect. */
   readonly notConnected: string;
   readonly reconnectRequired: (provider: string) => string;
   readonly disconnectTitle: (provider: string) => string;
-  readonly disconnectConsent: string;
+  /**
+   * What disconnecting means, in the present. The default names DomainKit as what stops managing
+   * the records; a host application overrides the key to name itself.
+   */
+  readonly disconnectConsent: (domain: string, provider: string) => string;
+  /**
+   * The option inside the disconnect dialog, over the records it would remove. Only this domain's
+   * apply receipt proves what DomainKit created, so the words say which records go.
+   */
+  readonly disconnectWithCleanup: (count: number) => string;
+  /** What the listed records do when that option is off. */
+  readonly disconnectKeepsRecords: (provider: string) => string;
   readonly detachConsent: string;
   readonly detached: string;
   readonly reusableConnections: string;
@@ -1282,9 +1545,11 @@ interface Catalog {
   readonly recordType: (record: DnsRecord.Observed) => string;
   readonly applied: (receipt: Receipt.Model) => string;
   readonly cleaned: (receipt: Receipt.Model) => string;
+  readonly partiallyAppliedTitle: string;
   readonly partiallyApplied: string;
+  readonly partiallyCleanedTitle: string;
   readonly partiallyCleaned: string;
-  readonly outcome: (outcome: Receipt.Outcome) => string;
+  readonly receiptOutcome: (outcome: Receipt.Outcome) => string;
   readonly skippedReason: (reason: Receipt.Skipped["reason"]) => string;
   readonly requirementStatus: (status: Storage.RequirementStatus) => string;
   readonly overall: (overall: Storage.Overall) => string;
@@ -1299,22 +1564,37 @@ interface Catalog {
   readonly nextCheckAt: (at: string) => string;
   readonly hostEvidence: string;
   readonly noEvidence: string;
-  readonly invalidInput: (reason: Reason.InvalidInput) => string;
-  readonly unauthenticated: (reason: Reason.Unauthenticated) => string;
-  readonly forbidden: (reason: Reason.Forbidden) => string;
-  readonly notFound: (reason: Reason.NotFound) => string;
-  readonly conflict: (reason: Reason.Conflict) => string;
-  readonly stale: (reason: Reason.Stale) => string;
-  readonly expired: (reason: Reason.Expired) => string;
-  readonly busy: (reason: Reason.Busy) => string;
-  readonly providerRejected: (reason: Reason.ProviderRejected) => string;
-  readonly providerUnavailable: (reason: Reason.ProviderUnavailable) => string;
-  readonly providerConflict: (reason: Reason.ProviderConflict) => string;
-  readonly unsupported: (reason: Reason.Unsupported) => string;
-  readonly reconnect: (reason: Reason.Reconnect) => string;
-  readonly storageFailed: (reason: Reason.StorageFailed) => string;
-  readonly cryptoFailed: (reason: Reason.CryptoFailed) => string;
-  readonly resolverFailed: (reason: Reason.ResolverFailed) => string;
+  readonly invalidInput: (reason: Reason.InvalidInput, context: OutcomeContext) => Outcome;
+  readonly unauthenticated: (reason: Reason.Unauthenticated, context: OutcomeContext) => Outcome;
+  readonly forbidden: (reason: Reason.Forbidden, context: OutcomeContext) => Outcome;
+  readonly notFound: (reason: Reason.NotFound, context: OutcomeContext) => Outcome;
+  readonly conflict: (reason: Reason.Conflict, context: OutcomeContext) => Outcome;
+  readonly stale: (reason: Reason.Stale, context: OutcomeContext) => Outcome;
+  readonly expired: (reason: Reason.Expired, context: OutcomeContext) => Outcome;
+  readonly busy: (reason: Reason.Busy, context: OutcomeContext) => Outcome;
+  readonly providerRejected: (reason: Reason.ProviderRejected, context: OutcomeContext) => Outcome;
+  readonly providerUnavailable: (reason: Reason.ProviderUnavailable, context: OutcomeContext) => Outcome;
+  readonly providerConflict: (reason: Reason.ProviderConflict, context: OutcomeContext) => Outcome;
+  readonly unsupported: (reason: Reason.Unsupported, context: OutcomeContext) => Outcome;
+  readonly reconnect: (reason: Reason.Reconnect, context: OutcomeContext) => Outcome;
+  readonly storageFailed: (reason: Reason.StorageFailed, context: OutcomeContext) => Outcome;
+  readonly cryptoFailed: (reason: Reason.CryptoFailed, context: OutcomeContext) => Outcome;
+  readonly resolverFailed: (reason: Reason.ResolverFailed, context: OutcomeContext) => Outcome;
+}
+/** What an outcome says: a heading the customer reads first, then what to do about it. */
+interface Outcome {
+  readonly title: string;
+  /** What to do about it. Absent where the title has already said the whole of it. */
+  readonly description?: string;
+}
+/**
+ * What the flow was doing when it failed. The reason alone cannot name the provider a customer
+ * typed a token for, so the part that renders the outcome supplies it.
+ */
+interface OutcomeContext {
+  /** The provider's display name, when the flow knows which one the customer acted on. */
+  readonly provider?: string;
+  readonly domain?: string;
 }
 /** The evidence shapes `Verify` produces, structurally, so the catalog needs no service import. */
 type EvidenceLike = {
@@ -1330,8 +1610,10 @@ type EvidenceLike = {
 };
 declare const english: Catalog;
 declare const merge: (overrides?: Partial<Catalog>) => Catalog;
-/** The user-facing sentence for a failure, chosen by the error's reason. */
-declare const failure: (error: DomainKit.Error, catalog: Catalog) => string;
+/** The title and description for a failure, chosen by the error's reason. */
+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 };
 }
@@ -1350,6 +1632,7 @@ interface Theme {
   readonly shadow?: string;
   readonly success?: string;
   readonly text?: string;
+  readonly warning?: string;
 }
 declare function toStyle(theme?: Theme): CSSProperties;
 declare namespace domain_kit_d_exports {
@@ -1565,5 +1848,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, 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 { 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 };
 //# sourceMappingURL=index.d.mts.map