@domainkit/react 0.9.0 → 0.10.0

package/README.md

@@ -51,6 +51,19 @@ the UI did not make.
 An interactive provider returns the customer to the page they started from. Pass `returnTo` to name
 a different destination, or `null` to leave the server's `defaultReturnTo` in charge.
 
+## The disconnected offer
+
+Discovery names the provider whose nameservers serve the domain. `Connect.Prompt` states it beside a
+trigger, and the dialog behind that trigger is narrowed to that provider, with the rest behind a
+disclosure.
+
+When no registered provider serves the zone there is nothing DomainKit can connect, so the flow
+offers nothing. Pass `connect="always"` to offer the all-providers dialog anyway:
+
+```tsx
+<Domain.Flow domain="app.example.com" requirements={requirements} connect="always" />
+```
+
 ## Own one piece, keep the rest
 
 Every part of the flow is a slot with a default.
@@ -68,7 +81,7 @@ Every part of the flow is a slot with a default.
 
 | Slot           | Receives                                        | Default                                                    |
 | -------------- | ----------------------------------------------- | ---------------------------------------------------------- |
-| `connection`   | `{ controller, domain }`                        | `Connect.Card` once connected, `Connect.Dialog` until then |
+| `connection`   | `{ controller, domain, connect }`               | `Connect.Card` once connected, `Connect.Prompt` until then |
 | `records`      | `{ records, readiness, controller, domain }`    | `Records.Table`                                            |
 | `verification` | `{ controller, domain }`                        | `Verify.Status` with per-requirement evidence              |
 | `actions`      | `{ connection, provisioning, cleanup, domain }` | Review changes, Approve, Decline, Remove records           |
@@ -121,17 +134,45 @@ one is gone, and re-runs the failed step otherwise.
 ## Presentation
 
 `DomainKit.Root` takes `messages`, `marks`, `icons`, `theme`, `colorScheme`, and `portalContainer`,
-so branding stays in your app. `Messages.Catalog` holds every user-visible string, including one
-sentence per `DomainKit.Error` reason; nothing renders a tag. Provider artwork comes from `marks`,
+so branding stays in your app. `Messages.Catalog` holds every user-visible string, including a
+title and a description per `DomainKit.Error` reason; nothing renders a tag. Provider artwork comes from `marks`,
 with the provider's initial as the fallback and no request at render time. The stylesheet is
 opt-in and every color is a `--domainkit-*` custom property.
 
-Every rule ships inside `@layer domainkit`, so your own stylesheet wins without out-specifying a
-part selector and a Tailwind utility class lands where you put it. To let the package win instead,
-order a layer of your own below it:
+Every rule ships inside `@layer domainkit`. An unlayered rule of yours already beats every layer, so
+plain CSS needs nothing here.
+
+Once your app uses layers, name the order yourself: a layer's priority is its position in that list,
+and a layer you never declare lands wherever it first appears, so `domainkit` can sort under
+Tailwind's preflight and the package's buttons render as bare text.
+
+```css
+@layer theme, base, components, domainkit, utilities;
+```
+
+`domainkit` sits after `base` so preflight cannot strip it, and before `utilities` so a utility class
+still wins. Any layer you declare after it wins the same way:
 
 ```css
-@layer domainkit, app;
+@layer utilities {
+  [data-domainkit-part="records-panel"] {
+    border-radius: 0;
+  }
+}
+```
+
+A failed step renders as `Outcome`: media, the catalog's title and description, and the retry the
+flow allows, as a card or on one line. Pass your own parts as children and the words still come from
+the catalog.
+
+```tsx
+<Connect.Outcome controller={connection} layout="inline">
+  <Outcome.Media variant="default">
+    <MyIcon />
+  </Outcome.Media>
+  <Outcome.Title />
+  <Outcome.Content />
+</Connect.Outcome>
 ```
 
 Every dialog and popover takes a `render` prop that replaces the surface with your own.

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. */
+declare function Description(props: DescriptionProps): ReactElement;
+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, 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, hostProvider, useController$2 as useController };
 }
 type Snapshot = Transport.Snapshot;
 type Discovery = Transport.Discovery;
@@ -620,6 +682,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 +703,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<{
@@ -678,6 +747,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;
@@ -707,6 +779,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;
@@ -735,6 +810,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;
@@ -764,6 +842,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;
@@ -795,6 +876,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";
@@ -819,6 +903,11 @@ declare const State$1: {
     readonly snapshot: Snapshot | 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;
@@ -868,11 +957,24 @@ 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;
+/**
+ * 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;
 }
@@ -898,6 +1000,22 @@ 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 when discovery names no host. */
+type Invitation = "always" | "detected";
+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.
+   */
+  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 CardProps$1 extends PartProps<"div", RootState$3> {
   readonly controller: Controller$1;
 }
@@ -906,11 +1024,13 @@ declare function Card$1({ controller, ...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;
 }
-/** 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, 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 +1039,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 +1051,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 +1063,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 +1222,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: {
@@ -1137,6 +1261,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 +1275,12 @@ 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;
 }
 interface FlowState extends Record<string, unknown> {
   readonly connection: State$1["_tag"];
-  readonly provisioning: State$2["_tag"];
+  readonly provisioning: State$3["_tag"];
 }
 interface FlowProps extends Omit<PartProps<"div", FlowState>, "children"> {
   readonly domain: string;
@@ -1169,13 +1295,18 @@ 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. Defaults to `detected`.
+   */
+  readonly connect?: Invitation;
 }
 /**
  * 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, readOnly, requirements, returnTo, slots, ...props }: FlowProps): ReactElement;
 //#endregion
 //#region src/icons.d.ts
 /**
@@ -1191,6 +1322,7 @@ interface Icons {
   readonly failure: ReactNode;
   readonly pending: ReactNode;
   readonly success: ReactNode;
+  readonly warning: ReactNode;
 }
 declare const defaultIcons: {
   readonly close: import("react/jsx-runtime").JSX.Element;
@@ -1201,14 +1333,18 @@ 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;
@@ -1221,6 +1357,10 @@ interface Catalog {
   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;
   readonly copy: string;
   readonly copied: string;
   readonly copyZone: string;
@@ -1241,8 +1381,10 @@ 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. */
@@ -1282,9 +1424,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 +1443,36 @@ 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;
+  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 +1488,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 +1510,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 +1726,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