@stridge/kit 0.1.0-alpha.5 → 0.1.0-alpha.51

package/dist/flows/withdraw/orchestrator/types.d.ts

@@ -1,6 +1,7 @@
 import { TxRef } from "../../../shared/driver/types.js";
 import { FailureInfo } from "../../../shared/orchestrator/types.js";
-
+import { WithdrawalQuotePayload } from "../driver/payloads.js";
+import { WithdrawPreparation } from "../driver/types.js";
 //#region src/flows/withdraw/orchestrator/types.d.ts
 /**
  * Form values captured at submit time. The orchestrator carries this snapshot through every
@@ -20,24 +21,45 @@ interface WithdrawalFormSnapshot {
   receiveTokenSymbol: string;
   /** Receive-side chain id (EIP-155 numeric). */
   receiveChainId: number;
+  /**
+   * Pre-formatted USD figure the form displayed under the amount input at submit time. Carried
+   * through the FSM so the in-progress / success heroes can render the same dollar value the
+   * user just saw on the form, before the indexer prices the settlement legs. Optional because
+   * the form's USD computation already returns `undefined` for invalid amounts; the snapshot
+   * mirrors that. Pre-formatted (locale-aware) — the orchestrator does not re-format.
+   */
+  amountUsd?: string;
+}
+/**
+ * Where `BACK` lands when the user exits the activity surface. Encoded once at `OPEN_HISTORY`
+ * time so the back chevron can restore the source state lossless. The withdraw flow's only
+ * pre-submit step is `form`, so the discriminated union is single-variant today — keeping the
+ * `kind` slot lets the shape grow if the form ever splits into multiple steps (mirrors deposit
+ * for cross-flow symmetry).
+ */
+interface HistoryBackTarget {
+  kind: "form";
+  notice?: string;
 }
 /**
- * State machine state for the orchestrated withdraw dialog. Per-state discriminated `ctx` narrows
- * what data is available — illegal states (e.g. `inProgress` without a tx ref) are
- * unrepresentable.
+ * State machine state for the orchestrated withdraw dialog. Per-state discriminated `ctx`
+ * narrows what data is available.
  *
- * The reducer carries navigation intent only — entity-derived data (quote payload, settlement
- * payload, balances) lives on the driver and is read directly by widgets.
+ * **Host-paced lifecycle** (different from the old wagmi-signed model): the kit stays in
+ * `submitting` until the host's `onSubmit` callback calls one of the controller's actions
+ * (`beginProcessing`, `fail`, `succeed`). `inProgress` accepts an optional `tx` — the host may
+ * move the user into processing before a broadcast tx hash exists; the kit polls
+ * `gateway/{owner}` and best-matches the relevant settlement (destination tuple + amount +
+ * submit-time window) until the host supplies a tx hash via `setTxHash`. `success` / `error`
+ * similarly accept optional `tx` since the host may declare a terminal verdict directly.
  */
 type WithdrawState = {
   name: "closed";
 } | {
   name: "form";
   /**
-   * Optional notice rendered inline near the submit footer. Currently set when the user
-   * declines the wallet signature: the FSM lands the user back on the form (preserving
-   * recipient + amount + receive selection) with `notice = "Signature declined…"` so they
-   * can retry without losing context. Cleared on the next SUBMIT or CLOSE.
+   * Optional notice rendered inline near the submit footer. Cleared on the next SUBMIT
+   * or CLOSE.
    */
   ctx?: {
     notice?: string;
@@ -50,27 +72,52 @@ type WithdrawState = {
 } | {
   name: "inProgress";
   ctx: {
-    input: WithdrawalFormSnapshot;
-    tx: TxRef;
+    input: WithdrawalFormSnapshot; /** Unix-ms timestamp the host moved the FSM into processing (drives best-match windowing). */
+    submittedAt: number;
+    /**
+     * Source-chain broadcast hash, when the host has surfaced one via
+     * `actions.setTxHash`. Absent while the kit relies on the best-match heuristic.
+     */
+    tx?: TxRef;
   };
 } | {
   name: "success";
   ctx: {
     input: WithdrawalFormSnapshot;
-    tx: TxRef;
+    tx?: TxRef;
   };
 } | {
   name: "error";
   ctx: {
     /**
      * Form snapshot captured at submit time. Set when error follows a submit attempt;
-     * absent when the error path was reached without a known prior submit (currently
-     * unreachable in V2 — kept optional so resume-style entries can re-use the slot).
+     * absent when the error path was reached without a known prior submit.
      */
-    input?: WithdrawalFormSnapshot; /** Optional non-settlement failure (quote / submission rejection). */
+    input?: WithdrawalFormSnapshot; /** Optional non-settlement failure (quote / submission rejection, host-supplied failure). */
     failure?: FailureInfo; /** Source-chain broadcast tx hash when the error followed a successful broadcast. */
     tx?: TxRef;
   };
+} | {
+  /**
+   * Activity history list — reachable from `form` via the header icon. `backTarget`
+   * snapshots the source state (including any inline notice) at `OPEN_HISTORY` time so
+   * the back chevron can restore it lossless.
+   */
+  name: "historyList";
+  ctx: {
+    backTarget: HistoryBackTarget;
+  };
+} | {
+  /**
+   * Activity history per-settlement detail — reached from `historyList` via
+   * `SELECT_SETTLEMENT`. Carries the selected row's id and the same `backTarget` so
+   * `BACK` collapses to `historyList` first, then to the original source step.
+   */
+  name: "historyDetail";
+  ctx: {
+    settlementId: string;
+    backTarget: HistoryBackTarget;
+  };
 };
 /**
  * Public state-name discriminator — useful for analytics and React-side gating without unwrapping
@@ -79,6 +126,16 @@ type WithdrawState = {
 type WithdrawStateName = WithdrawState["name"];
 /**
  * Reducer event union. Strict discriminated; no stringly-typed transitions.
+ *
+ * The host-paced lifecycle splits the old `SUBMIT_CONFIRMED { tx }` event into three pieces so
+ * the host can move the user forward at whichever step their backend actually completes:
+ *
+ * - `BEGIN_PROCESSING { tx?, submittedAt }` — host accepted the request; move to inProgress with
+ *   or without a tx hash.
+ * - `SET_TX_HASH { tx }` — host surfaced a broadcast hash later; upgrade best-match polling to
+ *   tx-anchored.
+ * - `MARK_SUCCEEDED` / `MARK_FAILED { failure? }` — host short-circuits to a terminal verdict
+ *   (e.g. their own settlement verification ran independently of Stridge's poll).
  */
 type WithdrawEvent = {
   type: "OPEN";
@@ -88,12 +145,22 @@ type WithdrawEvent = {
   type: "SUBMIT";
   input: WithdrawalFormSnapshot;
 } | {
-  type: "SUBMIT_CONFIRMED";
+  type: "BEGIN_PROCESSING";
+  submittedAt: number;
+  tx?: TxRef;
+} | {
+  type: "SET_TX_HASH";
   tx: TxRef;
+  submittedAt: number;
 } | {
   type: "SUBMIT_FAILED";
   failure: FailureInfo;
   input: WithdrawalFormSnapshot;
+} | {
+  type: "MARK_SUCCEEDED";
+} | {
+  type: "MARK_FAILED";
+  failure?: FailureInfo;
 } | {
   type: "SETTLEMENT_SUCCEEDED";
 } | {
@@ -101,16 +168,29 @@ type WithdrawEvent = {
   failure?: FailureInfo;
 } | {
   type: "RESET";
-}
-/**
- * Drops the inline notice on the `form` state. Dispatched by the form widget when the user
- * starts editing again after a wallet-rejection landed them back on `form{notice}`. Mirror of
- * deposit's `regenerating → ready` transition (where the notice clears as a side-effect of
- * the next quote resolving) — withdraw's form has no FSM-driven phase to ride on, so the
- * widget signals it explicitly.
- */
-| {
+} | {
   type: "CLEAR_NOTICE";
+} | {
+  /**
+   * User tapped the back chevron. Legal only from `historyList` / `historyDetail` today —
+   * the form step has no source to return to (closing the dialog is `CLOSE`). Two-step
+   * collapse: `historyDetail → historyList → source`.
+   */
+  type: "BACK";
+} | {
+  /**
+   * User tapped the header history icon. Legal from `form`; ignored elsewhere. Snapshots
+   * the source state into a {@link HistoryBackTarget} so the back chevron can restore it
+   * lossless (including any inline notice surfaced after a recent submit failure).
+   */
+  type: "OPEN_HISTORY";
+} | {
+  /**
+   * User tapped a row in the activity list. Legal only from `historyList`; transitions
+   * to `historyDetail` carrying the selected `settlementId`.
+   */
+  type: "SELECT_SETTLEMENT";
+  settlementId: string;
 };
 /**
  * Imperative controller returned by `useWithdraw()`. Mirrors {@link import("#/flows/deposit/orchestrator").DepositController}'s
@@ -134,9 +214,11 @@ interface WithdrawController {
  */
 interface WithdrawActions {
   /**
-   * Submits the withdrawal through the driver. Dispatches `SUBMIT` synchronously (so the form
-   * flips to the loading-button state) and then `SUBMIT_CONFIRMED` / `SUBMIT_FAILED` based on
-   * the driver's `submitWithdrawal` resolution.
+   * Submits the withdrawal. Dispatches `SUBMIT` synchronously (so the form flips to the
+   * loading-button state) and then fires the host's `<WithdrawDialog onSubmit>` callback with
+   * the prepared UDA target + a `WithdrawSubmitActions` handle. The kit stays in `submitting`
+   * until the host calls one of those actions (`beginProcessing`, `setTxHash`, `decline`,
+   * `fail`, `succeed`).
    */
   submit(input: WithdrawalFormSnapshot): void;
   /** Close the dialog. Idempotent. */
@@ -147,10 +229,97 @@ interface WithdrawActions {
    */
   reset(): void;
   /**
-   * Clear the form's inline notice (typically the post-rejection "Signature declined." hint).
-   * No-op when there's no notice or the FSM isn't on `form`.
+   * Clear the form's inline notice. No-op when there's no notice or the FSM isn't on `form`.
    */
   clearNotice(): void;
+  /**
+   * Back-chevron action. Today the chevron is only rendered on the activity history step
+   * (detail → list → source); other steps either render no chevron or close directly via
+   * {@link close}.
+   */
+  back(): void;
+  /**
+   * Header-icon entry into the activity surface. Legal from `form`; ignored elsewhere.
+   * Snapshots the current state into a {@link HistoryBackTarget} so `back()` can restore it
+   * lossless.
+   */
+  openHistory(): void;
+  /**
+   * Open the detail view for a settlement listed on the activity surface. Legal only from
+   * `historyList`; transitions the FSM to `historyDetail`.
+   */
+  selectSettlement(settlementId: string): void;
+}
+/**
+ * Payload the kit hands to the host's `<WithdrawDialog onSubmit>` callback. Carries everything
+ * the host needs to broadcast the source-chain transfer to the UDA (or to validate the request
+ * server-side before broadcasting / queueing).
+ */
+interface WithdrawSubmitInput {
+  /** What the user picked on the form (recipient, amount, receive token + chain). */
+  form: WithdrawalFormSnapshot;
+  /** Where the host should send brand-currency funds to trigger the bridge. */
+  depositTarget: WithdrawPreparation["depositTarget"];
+  /** Stridge correlation slot — useful for backend logs / cross-system traces. */
+  correlation: WithdrawPreparation["correlation"];
+  /** Active quote payload at submit time, when one is available. */
+  quote?: WithdrawalQuotePayload;
 }
+/**
+ * Imperative handles the host's `onSubmit` callback receives. Each action advances the kit's
+ * FSM at the point the host's backend reaches the matching state. All actions are optional —
+ * the host calls only what fits their flow (e.g. backend pre-validates and accepts ⇒
+ * `beginProcessing()`; later the broadcast lands ⇒ `setTxHash({ hash })`; settlement watching
+ * via Stridge takes over from there). The kit also exposes a `signal` for cancellation when
+ * the user closes the dialog mid-submit.
+ */
+interface WithdrawSubmitActions {
+  /**
+   * Move the FSM into `inProgress`. Pass `tx` if a broadcast hash already exists at this point;
+   * otherwise omit — the kit polls `gateway/{owner}` with a best-match heuristic until you
+   * call {@link setTxHash}. Idempotent — calling more than once is a no-op.
+   */
+  beginProcessing(tx?: TxRef): void;
+  /**
+   * Surface a broadcast hash mid-processing. Upgrades the watcher from best-match to
+   * tx-anchored. Legal from `inProgress` or `submitting` (auto-promotes to `inProgress`).
+   */
+  setTxHash(tx: TxRef): void;
+  /**
+   * Mark the withdraw failed. Legal from `submitting` (pre-broadcast rejection) and
+   * `inProgress` (post-broadcast failure). The optional `failure` carries a localized
+   * reason + machine code for analytics; omit when the host has nothing meaningful to
+   * report and just needs to terminate the flow.
+   *
+   * For user-rejection (the user said no in their wallet), prefer {@link decline} so the
+   * kit can emit `withdraw.submission.declined` instead of `withdraw.submission.failed`.
+   */
+  fail(failure?: FailureInfo): void;
+  /**
+   * Mark the withdraw as user-declined. Use when the user explicitly refused a wallet
+   * prompt or backed out of a host-side confirmation step. The kit routes the FSM back to
+   * `form{notice}` (same as the wallet-rejection heuristic) and emits
+   * `withdraw.submission.declined` on the unified bus — distinct from `*.failed` because
+   * declining is a user choice, not an error. Analytics that count `.failed` events stay
+   * accurate.
+   *
+   * Legal from `submitting`. When the host doesn't call this explicitly, the kit's
+   * built-in rejection heuristic still classifies wallet-rejection-shaped errors as
+   * declines automatically.
+   */
+  decline(): void;
+  /**
+   * Mark the withdraw succeeded directly. Useful when the host runs their own settlement
+   * verification independently of Stridge's poll. Legal from `submitting` and `inProgress`.
+   */
+  succeed(): void;
+}
+/**
+ * Host-supplied callback fired when the user submits the withdrawal form. The kit hands the
+ * callback the resolved {@link WithdrawSubmitInput} plus a {@link WithdrawSubmitActions} handle
+ * the host calls to advance the FSM. The kit does NOT await the callback's promise — the host
+ * is in control of pacing via the actions. The `signal` aborts when the user closes the dialog.
+ */
+type WithdrawSubmitCallback = (input: WithdrawSubmitInput, actions: WithdrawSubmitActions, signal: AbortSignal) => void | Promise<void>;
 //#endregion
-export { WithdrawActions, WithdrawController, WithdrawEvent, WithdrawState, WithdrawStateName, WithdrawalFormSnapshot };
+export { WithdrawActions, WithdrawController, WithdrawEvent, WithdrawState, WithdrawStateName, WithdrawSubmitActions, WithdrawSubmitCallback, WithdrawSubmitInput, WithdrawalFormSnapshot };

package/dist/flows/withdraw/orchestrator/useWithdraw.d.ts

@@ -19,5 +19,40 @@ import { WithdrawController } from "./types.js";
  * ```
  */
 declare function useWithdraw(): WithdrawController;
+/**
+ * Non-throwing variant of {@link useWithdraw} — returns `null` when called outside a
+ * `<KitProvider withdraw={…} />`. Lets hosts mount `<StridgeProvider />` conditionally
+ * (e.g. only after a wallet is connected) without descendants crashing the moment they render
+ * before the provider exists.
+ *
+ * @example
+ * ```tsx
+ * const withdraw = useOptionalWithdraw();
+ * return (
+ *     <button onClick={() => withdraw?.open()} disabled={!withdraw}>
+ *         Withdraw
+ *     </button>
+ * );
+ * ```
+ */
+declare function useOptionalWithdraw(): WithdrawController | null;
+/**
+ * Headless prefetch handle for the withdraw driver. Returns a stable function that arms the
+ * driver — kicks off the deferred `supportedAssets` + initial `balance/onchain` bootstrap.
+ * Calling it before the user opens the dialog warms the cache so the subsequent
+ * `useWithdraw().open()` lands on populated data without a perceptible loading window.
+ *
+ * Fire-and-forget: returns `void`. Observe bootstrap state via
+ * `useWithdrawSnapshot().receiveOptions.status` if needed.
+ *
+ * ```tsx
+ * const withdraw = useWithdraw();
+ * const prefetchWithdraw = usePrefetchWithdraw();
+ * <button onMouseEnter={prefetchWithdraw} onClick={() => withdraw.open()}>Withdraw</button>;
+ * ```
+ *
+ * Idempotent — subsequent calls are no-ops while the driver is already armed.
+ */
+declare function usePrefetchWithdraw(): () => void;
 //#endregion
-export { useWithdraw };
+export { useOptionalWithdraw, usePrefetchWithdraw, useWithdraw };

package/dist/flows/withdraw/orchestrator/useWithdraw.js

@@ -1 +1 @@
-"use client";import{useControllerContext as e}from"./controller.js";function t(){return e().controller}export{t as useWithdraw};
+"use client";import{useWithdrawDriverInstance as e}from"../driver/context.js";import{useControllerContext as t,useOptionalControllerContext as n}from"./controller.js";import{useCallback as r}from"react";function i(){return t().controller}function a(){return n()?.controller??null}function o(){let t=e();return r(()=>{t.arm()},[t])}export{a as useOptionalWithdraw,o as usePrefetchWithdraw,i as useWithdraw};

package/dist/flows/withdraw/widgets/activity-history/WithdrawHistoryDetail.d.ts

@@ -0,0 +1,39 @@
+import { ReactNode } from "react";
+import * as _$react_jsx_runtime0 from "react/jsx-runtime";
+
+//#region src/flows/withdraw/widgets/activity-history/WithdrawHistoryDetail.d.ts
+interface WithdrawHistoryDetailOwnProps {
+  /**
+   * Optional custom composition forwarded to the underlying `<ActivityHistoryDetail>`
+   * compound. Defaults to mounting all three per-kind parts.
+   */
+  children?: ReactNode;
+}
+/**
+ * Orchestrated activity-history detail wrapper for the withdraw dialog. Mirrors
+ * {@link import("#/flows/deposit/widgets/activity-history").DepositHistoryDetail}. Renders
+ * `null` while the FSM is not on `historyDetail`.
+ */
+declare function WithdrawHistoryDetail({
+  children
+}: WithdrawHistoryDetailOwnProps): _$react_jsx_runtime0.JSX.Element | null;
+declare namespace WithdrawHistoryDetail {
+  type Props = WithdrawHistoryDetailOwnProps;
+  const Processing: ({
+    children
+  }: {
+    children?: ReactNode;
+  }) => _$react_jsx_runtime0.JSX.Element | null;
+  const Succeeded: ({
+    children
+  }: {
+    children?: ReactNode;
+  }) => _$react_jsx_runtime0.JSX.Element | null;
+  const Failed: ({
+    children
+  }: {
+    children?: ReactNode;
+  }) => _$react_jsx_runtime0.JSX.Element | null;
+}
+//#endregion
+export { WithdrawHistoryDetail };

package/dist/flows/withdraw/widgets/activity-history/WithdrawHistoryDetail.js

@@ -0,0 +1 @@
+"use client";import{ActivityHistorySourceProvider as e}from"../../../../shared/widgets/activity-history/compound/context.js";import{ActivityHistoryDetail as t}from"../../../../shared/widgets/activity-history/compound/ActivityHistoryDetail.js";import"../../../../activity-history/compound/index.js";import{useWithdrawActivityHistorySource as n}from"./useWithdrawActivityHistorySource.js";import{jsx as r}from"react/jsx-runtime";function i({children:i}){let{sourceValue:a,step:o}=n();return o!==`historyDetail`||!a?null:r(e,{value:a,children:r(t,{children:i})})}(function(e){e.Processing=t.Processing,e.Succeeded=t.Succeeded,e.Failed=t.Failed})(i||={});export{i as WithdrawHistoryDetail};

package/dist/flows/withdraw/widgets/activity-history/WithdrawHistoryList.d.ts

@@ -0,0 +1,36 @@
+import { ActivityHistoryEmpty } from "../../../../shared/widgets/activity-history/compound/components/Empty.js";
+import { ActivityHistoryErrorView } from "../../../../shared/widgets/activity-history/compound/components/ErrorView.js";
+import { ActivityHistoryHeader, ActivityHistoryListHeader } from "../../../../shared/widgets/activity-history/compound/components/HistoryHeader.js";
+import { ActivityHistoryList } from "../../../../shared/widgets/activity-history/compound/components/List.js";
+import { ActivityHistoryRow } from "../../../../shared/widgets/activity-history/compound/components/Row.js";
+import { ComponentProps, ReactNode } from "react";
+import * as _$react_jsx_runtime0 from "react/jsx-runtime";
+
+//#region src/flows/withdraw/widgets/activity-history/WithdrawHistoryList.d.ts
+interface WithdrawHistoryListOwnProps {
+  /**
+   * Optional custom composition forwarded to the underlying `<ActivityHistory>` compound.
+   * Defaults to the compound's `<Header /> + <List />` shape.
+   */
+  children?: ReactNode;
+}
+/**
+ * Orchestrated activity-history list wrapper for the withdraw dialog. Mirrors
+ * {@link import("#/flows/deposit/widgets/activity-history").DepositHistoryList}. Renders
+ * `null` while the FSM is not on `historyList`.
+ */
+declare function WithdrawHistoryList({
+  children,
+  ...props
+}: ComponentProps<"div"> & WithdrawHistoryListOwnProps): _$react_jsx_runtime0.JSX.Element | null;
+declare namespace WithdrawHistoryList {
+  type Props = ComponentProps<"div"> & WithdrawHistoryListOwnProps;
+  const Header: typeof ActivityHistoryHeader;
+  const ListHeader: typeof ActivityHistoryListHeader;
+  const List: typeof ActivityHistoryList;
+  const Row: typeof ActivityHistoryRow;
+  const Empty: typeof ActivityHistoryEmpty;
+  const ErrorView: typeof ActivityHistoryErrorView;
+}
+//#endregion
+export { WithdrawHistoryList };

package/dist/flows/withdraw/widgets/activity-history/WithdrawHistoryList.js

@@ -0,0 +1 @@
+"use client";import{ActivityHistorySourceProvider as e}from"../../../../shared/widgets/activity-history/compound/context.js";import{ActivityHistory as t}from"../../../../shared/widgets/activity-history/compound/ActivityHistory.js";import"../../../../activity-history/compound/index.js";import{useWithdrawActivityHistorySource as n}from"./useWithdrawActivityHistorySource.js";import{jsx as r}from"react/jsx-runtime";function i({children:i,...a}){let{sourceValue:o,step:s}=n();return s!==`historyList`||!o?null:r(e,{value:o,children:r(t,{...a,children:i})})}(function(e){e.Header=t.Header,e.ListHeader=t.ListHeader,e.List=t.List,e.Row=t.Row,e.Empty=t.Empty,e.ErrorView=t.ErrorView})(i||={});export{i as WithdrawHistoryList};

package/dist/flows/withdraw/widgets/activity-history/index.d.ts

@@ -0,0 +1,2 @@
+import { WithdrawHistoryDetail } from "./WithdrawHistoryDetail.js";
+import { WithdrawHistoryList } from "./WithdrawHistoryList.js";

package/dist/flows/withdraw/widgets/activity-history/index.js

@@ -0,0 +1 @@
+import"./WithdrawHistoryDetail.js";import"./WithdrawHistoryList.js";

package/dist/flows/withdraw/widgets/activity-history/useWithdrawActivityHistorySource.js

@@ -0,0 +1 @@
+"use client";import{useLingui as e}from"../../../../shared/i18n/useLingui.js";import"../../../../i18n/index.js";import{useWithdrawDriverInstance as t,useWithdrawSnapshot as n}from"../../driver/context.js";import{useWithdrawActions as r,useWithdrawEffectiveState as i}from"../../orchestrator/controller.js";import"../../orchestrator/index.js";import{defaultBlockExplorers as a}from"../../../../shared/utils/explorers.js";import{useCallback as o,useMemo as s}from"react";function c(){let c=n(),l=r(),u=t(),d=i(),{i18n:f}=e(),p=o(e=>{u.refreshHistory?.(e)},[u]),m=d.name===`historyList`||d.name===`historyDetail`,h=d.name===`historyDetail`?d.ctx.settlementId:void 0;return{sourceValue:s(()=>{if(!m)return null;let e={i18n:f,sourceWallet:{name:`Wallet`,address:`0x0000000000000000000000000000000000000000`},explorers:a()};return{entity:c.history,refresh:p,selectSettlement:l.selectSettlement,back:l.back,...h===void 0?{}:{settlementId:h},settlementContext:e}},[c,l,m,h,f,p]),settlementId:h,step:d.name===`historyList`?`historyList`:d.name===`historyDetail`?`historyDetail`:`other`}}export{c as useWithdrawActivityHistorySource};

package/dist/flows/withdraw/widgets/withdraw/compound/Withdraw.d.ts

@@ -0,0 +1,60 @@
+import { WithdrawStateName } from "../../../orchestrator/types.js";
+import { Props, WithdrawBoundary } from "./components/Boundary.js";
+import { Props as Props$1, WithdrawGuards } from "./components/Guards.js";
+import { WithdrawSteps, WithdrawStepsProps } from "./components/Steps.js";
+import { ReactNode } from "react";
+
+//#region src/flows/withdraw/widgets/withdraw/compound/Withdraw.d.ts
+interface WithdrawStepProps {
+  /**
+   * Matches against the withdraw FSM's effective state name (with `submitting` collapsed
+   * to `form`). Declaring `name="submitting"` never matches — use `name="form"` and the
+   * widget stays mounted across both states.
+   */
+  name: WithdrawStateName;
+  children: ReactNode;
+}
+/**
+ * Top-level `Withdraw` compound namespace. Today exposes the slot-routing primitives that
+ * let hosts compose multi-screen withdraw flows; the namespace exists at this position so
+ * future `Withdraw.*` parts (Header, Body, …) can extend it without churning the import path.
+ *
+ * Hosts wire it like the deposit equivalent:
+ *
+ * ```tsx
+ * <Withdraw.Steps>
+ *   <Withdraw.Step name="form"><WithdrawForm /></Withdraw.Step>
+ *   <Withdraw.Step name="inProgress"><WithdrawInProgress /></Withdraw.Step>
+ *   <Withdraw.Step name="success"><WithdrawSuccess /></Withdraw.Step>
+ *   <Withdraw.Step name="error"><WithdrawError /></Withdraw.Step>
+ * </Withdraw.Steps>
+ * ```
+ *
+ * Rendered directly (`<Withdraw />`) the component is a no-op — reach into the sub-parts.
+ */
+declare function Withdraw(): null;
+declare namespace Withdraw {
+  type StepsProps = WithdrawStepsProps;
+  type StepProps = WithdrawStepProps;
+  type GuardsProps = Props$1;
+  type BoundaryProps = Props;
+  const Steps: typeof WithdrawSteps;
+  /**
+   * Slot consumed by {@link Withdraw.Steps}. `name` is the FSM state to match; the matched
+   * step's `children` are rendered, every other branch is dropped.
+   */
+  const Step: (props: WithdrawStepProps) => null;
+  /**
+   * Bootstrap-loading guard. While `gateway/start` is in flight on the form / submitting
+   * step pair, renders a centered spinner instead of empty form chrome. Falls through to
+   * children for every other state.
+   */
+  const Guards: typeof WithdrawGuards;
+  /**
+   * Error-boundary part. Wires the kit's `GatewayKitBoundary` with withdraw-flow recovery —
+   * `onReset` calls `useWithdraw().close()` internally; `onError` is host-supplied.
+   */
+  const Boundary: typeof WithdrawBoundary;
+}
+//#endregion
+export { Withdraw };

package/dist/flows/withdraw/widgets/withdraw/compound/Withdraw.js

@@ -0,0 +1 @@
+"use client";import{Step as e}from"../../../../../shared/ui/Steps/Steps.js";import"../../../../../shared/ui/Steps/index.js";import{WithdrawBoundary as t}from"./components/Boundary.js";import{WithdrawGuards as n}from"./components/Guards.js";import{WithdrawSteps as r}from"./components/Steps.js";function i(){return null}(function(i){i.Steps=r,i.Step=e,i.Guards=n,i.Boundary=t})(i||={});export{i as Withdraw};

package/dist/flows/withdraw/widgets/withdraw/compound/Withdraw.slots.d.ts

@@ -0,0 +1,13 @@
+//#region src/flows/withdraw/widgets/withdraw/compound/Withdraw.slots.d.ts
+/**
+ * `<Withdraw.*>` slot vocabulary. Today the namespace only houses `Withdraw.Steps` /
+ * `Withdraw.Step`, both of which route their slot attribute through the shared `Steps`
+ * primitive. The constant exists so future `Withdraw.*` parts (Header, Body, …) have a
+ * canonical slot map ready when they land.
+ */
+declare const WITHDRAW_SLOTS: {
+  readonly root: "withdraw-root";
+};
+type WithdrawSlot = (typeof WITHDRAW_SLOTS)[keyof typeof WITHDRAW_SLOTS];
+//#endregion
+export { WITHDRAW_SLOTS, WithdrawSlot };

package/dist/flows/withdraw/widgets/withdraw/compound/Withdraw.slots.js

@@ -0,0 +1 @@
+const e={root:`withdraw-root`};export{e as WITHDRAW_SLOTS};

package/dist/flows/withdraw/widgets/withdraw/compound/components/Boundary.d.ts

@@ -0,0 +1,29 @@
+import { ErrorInfo, ReactNode } from "react";
+import * as _$react_jsx_runtime0 from "react/jsx-runtime";
+
+//#region src/flows/withdraw/widgets/withdraw/compound/components/Boundary.d.ts
+interface Props {
+  children: ReactNode;
+  /**
+   * Replaces the kit's default crash fallback. Compose `GatewayKitErrorCard` parts to keep
+   * kit styling, or render your own JSX for a fully custom recovery surface.
+   */
+  fallback?: ReactNode;
+  /**
+   * Fires once per caught render error. Pipe to your analytics or error-reporting pipeline.
+   */
+  onError?: (error: Error, errorInfo: ErrorInfo) => void;
+}
+/**
+ * Error-boundary part for the withdraw flow. Wraps children with the kit's
+ * `GatewayKitBoundary` and pipes the recovery action through `useWithdraw().close()` so a
+ * crash returns the user to a clean state. `onError` is host-supplied; `onReset` is wired
+ * internally.
+ */
+declare function WithdrawBoundary({
+  children,
+  fallback,
+  onError
+}: Props): _$react_jsx_runtime0.JSX.Element;
+//#endregion
+export { Props, WithdrawBoundary };

package/dist/flows/withdraw/widgets/withdraw/compound/components/Boundary.js

@@ -0,0 +1 @@
+"use client";import{useWithdrawActions as e}from"../../../../orchestrator/controller.js";import{GatewayKitBoundary as t}from"../../../../../../shared/error-handling/components/GatewayKitBoundary.js";import"../../../../../../shared/error-handling/index.js";import{jsx as n}from"react/jsx-runtime";function r({children:r,fallback:i,onError:a}){let{close:o}=e();return n(t,{...a?{onError:a}:{},...i===void 0?{}:{fallback:i},onReset:o,children:r})}export{r as WithdrawBoundary};

package/dist/flows/withdraw/widgets/withdraw/compound/components/Guards.d.ts

@@ -0,0 +1,25 @@
+import { ReactNode } from "react";
+import * as _$react_jsx_runtime0 from "react/jsx-runtime";
+
+//#region src/flows/withdraw/widgets/withdraw/compound/components/Guards.d.ts
+interface Props {
+  children: ReactNode;
+}
+/**
+ * Bootstrap-loading guard for the withdraw flow. While the lazy `arm()` is in flight,
+ * `receiveOptions` is `idle` / `loading` — the form widget would render against an empty
+ * catalog, so we surface a centered spinner inside the same frame instead of empty form
+ * chrome. Cache hits never trip this branch because the entity stays `ready` for the rest
+ * of the provider lifetime once it transitions there.
+ *
+ * Only applies to the `form` / `submitting` step pair — terminal steps (`inProgress` /
+ * `success` / `error`) read from `settlement`, which populates independently of bootstrap.
+ * The withdraw flow does NOT have a wallet-required gate; the host always supplies a
+ * `flows.withdraw.owner` via `<StridgeProvider>` (the business broadcasts the source-chain
+ * tx, not the end-user).
+ */
+declare function WithdrawGuards({
+  children
+}: Props): _$react_jsx_runtime0.JSX.Element;
+//#endregion
+export { Props, WithdrawGuards };

package/dist/flows/withdraw/widgets/withdraw/compound/components/Guards.js

@@ -0,0 +1 @@
+"use client";import{useWithdrawSnapshot as e}from"../../../../driver/context.js";import{useWithdrawEffectiveState as t}from"../../../../orchestrator/controller.js";import"../../../../orchestrator/index.js";import{LoadingState as n}from"../../../../../../shared/dialog/LoadingState.js";import{Fragment as r,jsx as i}from"react/jsx-runtime";function a({children:a}){let o=t(),s=e();return(o.name===`form`||o.name===`submitting`)&&(s.receiveOptions.status===`loading`||s.receiveOptions.status===`idle`)?i(n,{slot:`withdraw`}):i(r,{children:a})}export{a as WithdrawGuards};

package/dist/flows/withdraw/widgets/withdraw/compound/components/Steps.d.ts

@@ -0,0 +1,27 @@
+import { ReactNode } from "react";
+import * as _$react_jsx_runtime0 from "react/jsx-runtime";
+
+//#region src/flows/withdraw/widgets/withdraw/compound/components/Steps.d.ts
+interface WithdrawStepsProps {
+  /**
+   * When true, the matched step renders without the kit's animated `StepTransition` wrapper.
+   * Forwarded to the underlying `Steps` primitive.
+   */
+  plain?: boolean;
+  children: ReactNode;
+}
+/**
+ * Withdraw-bound slot-routing parent. Reads the withdraw FSM's *effective* state name and
+ * renders only the matching `<Withdraw.Step name="…" />` child.
+ *
+ * Collapses `submitting → form` so the form widget stays mounted (and its slide animation
+ * does not re-trigger) while the host's `onSubmit` is in flight. Hosts therefore declare a
+ * single `<Withdraw.Step name="form">` to cover both the idle form and the post-submit
+ * pending state — declaring `name="submitting"` separately never matches.
+ */
+declare function WithdrawSteps({
+  plain,
+  children
+}: WithdrawStepsProps): _$react_jsx_runtime0.JSX.Element;
+//#endregion
+export { WithdrawSteps, type WithdrawStepsProps };

package/dist/flows/withdraw/widgets/withdraw/compound/components/Steps.js

@@ -0,0 +1 @@
+"use client";import{useWithdrawEffectiveState as e}from"../../../../orchestrator/controller.js";import"../../../../orchestrator/index.js";import{Steps as t}from"../../../../../../shared/ui/Steps/Steps.js";import"../../../../../../shared/ui/Steps/index.js";import{jsx as n}from"react/jsx-runtime";function r({plain:r,children:i}){let a=e();return n(t,{activeStep:a.name===`submitting`?`form`:a.name,...r===void 0?{}:{plain:r},children:i})}export{r as WithdrawSteps};

package/dist/flows/withdraw/widgets/withdraw/compound/index.d.ts

@@ -0,0 +1,3 @@
+import { WithdrawStepsProps } from "./components/Steps.js";
+import { Withdraw } from "./Withdraw.js";
+import { WITHDRAW_SLOTS, WithdrawSlot } from "./Withdraw.slots.js";

package/dist/flows/withdraw/widgets/withdraw/compound/index.js

@@ -0,0 +1 @@
+import"./Withdraw.js";import"./Withdraw.slots.js";