@stridge/kit 0.1.0-alpha.6 → 0.1.0-alpha.60

package/dist/flows/activity/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/activity/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
+   * (Sentry, Datadog, etc.) — the boundary itself only logs to `console.error` in development.
+   */
+  onError?: (error: Error, errorInfo: ErrorInfo) => void;
+}
+/**
+ * Error-boundary part for the standalone activity flow. Wraps children with the kit's
+ * `GatewayKitBoundary` and pipes the recovery action through `useActivity().close()` so a crash
+ * returns the user to a clean state. Mirrors `<Deposit.Boundary>` / `<Withdraw.Boundary>`.
+ */
+declare function ActivityBoundary({
+  children,
+  fallback,
+  onError
+}: Props): _$react_jsx_runtime0.JSX.Element;
+//#endregion
+export { ActivityBoundary, Props };

package/dist/flows/activity/compound/components/Boundary.js

@@ -0,0 +1 @@
+"use client";import{useActivityActions as e}from"../../orchestrator/controller.js";import"../../orchestrator/index.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 ActivityBoundary};

package/dist/flows/activity/compound/components/Steps.d.ts

@@ -0,0 +1,24 @@
+import { ReactNode } from "react";
+import * as _$react_jsx_runtime0 from "react/jsx-runtime";
+
+//#region src/flows/activity/compound/components/Steps.d.ts
+interface ActivityStepsProps {
+  /**
+   * When true, the matched step renders without the kit's animated `StepTransition` wrapper.
+   * Forwarded to the underlying `Steps` primitive.
+   */
+  plain?: boolean;
+  children: ReactNode;
+}
+/**
+ * Activity-bound slot-routing parent. Reads the standalone activity FSM's *effective* state
+ * name and renders only the `<ActivityFlow.Step name="…" />` child whose name matches. Reading
+ * effective (rather than logical) state keeps the matched step mounted while the enclosing
+ * dialog plays its exit animation — see `StepTransition.tsx` for the rationale.
+ */
+declare function ActivitySteps({
+  plain,
+  children
+}: ActivityStepsProps): _$react_jsx_runtime0.JSX.Element;
+//#endregion
+export { ActivitySteps, type ActivityStepsProps };

package/dist/flows/activity/compound/components/Steps.js

@@ -0,0 +1 @@
+"use client";import{useActivityEffectiveState 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}){return n(t,{activeStep:e().name,...r===void 0?{}:{plain:r},children:i})}export{r as ActivitySteps};

package/dist/flows/activity/dialog/ActivityDialog.d.ts

@@ -0,0 +1,55 @@
+import { Presentation } from "../../../shared/presentation/types.js";
+import { ErrorInfo } from "react";
+import * as _$react_jsx_runtime0 from "react/jsx-runtime";
+
+//#region src/flows/activity/dialog/ActivityDialog.d.ts
+/**
+ * Standalone activity dialog. Mount inside `<KitProvider activity={…}>` (or `<StridgeProvider>`
+ * with any flow enabled) wherever the integrator wants the dialog to live in the React tree
+ * (typically once at the layout root). Open state is bound to the controller's
+ * `state.name !== "closed"`, so the dialog appears / disappears automatically as descendants
+ * call `useActivity().open()` / `.close()`.
+ *
+ * The dialog is a pure composition of the shared dialog primitive + the standalone activity
+ * widgets. Each `<Step>` body is the per-FSM-state orchestrated widget; `useStandaloneActivitySource()`
+ * fires once per matched step (via `<Steps>`, which only mounts the active child) and the
+ * shared `<ActivitySourceProvider>` scope is owned by the matched widget itself.
+ */
+declare function ActivityDialog({
+  container,
+  onError,
+  presentation,
+  metadata
+}?: ActivityDialog.Props): _$react_jsx_runtime0.JSX.Element;
+declare namespace ActivityDialog {
+  interface Props {
+    /**
+     * Element the dialog portals into. Defaults to `document.body` (full-page overlay).
+     * Pass a transformed ancestor with `overflow: clip` — e.g. a mobile mockup frame — to
+     * scope the dialog's width, height, and backdrop to that rect.
+     */
+    container?: HTMLElement | null;
+    /**
+     * Fires once per caught render error inside the dialog. Pipe to your analytics or
+     * error-reporting pipeline. The dialog's internal `<ActivityFlow.Boundary>` recovers via
+     * `useActivity().close()`.
+     */
+    onError?: (error: Error, errorInfo: ErrorInfo) => void;
+    /**
+     * Consumer-attached metadata that rides along on every bus event emitted from this
+     * dialog's session. Snapshotted at `activity.opened` and frozen for the session — mid-flow
+     * prop changes are ignored to keep correlation consistent. The kit does not validate or
+     * normalise the shape. See `@stridge/kit/events`.
+     */
+    metadata?: Record<string, unknown>;
+    /**
+     * Per-dialog surface override. `"auto"` (default) renders a centred dialog on wide
+     * containers and a bottom-sheet drawer below the breakpoint; `"dialog"` / `"drawer"`
+     * force one surface. Pass `{ mode, breakpoint }` to tune the px threshold (default 600).
+     * Wins over the provider's `appearance.presentation`; omit to inherit it.
+     */
+    presentation?: Presentation;
+  }
+}
+//#endregion
+export { ActivityDialog };

package/dist/flows/activity/dialog/ActivityDialog.js

@@ -0,0 +1 @@
+"use client";import{useActivityControllerContext as e}from"../orchestrator/controller.js";import"../orchestrator/index.js";import{useActivityEmissions as t}from"../../../events/emit/useActivityEmissions.js";import"../../../events/emit/index.js";import{useIntercomShutdownOnUnmount as n}from"../../../shared/support/useIntercomShutdownOnUnmount.js";import"../../../shared/support/index.js";import{AdaptiveSurface as r}from"../../../shared/ui/AdaptiveSurface/AdaptiveSurface.js";import"../../../shared/ui/AdaptiveSurface/index.js";import{ActivityFlow as i}from"../compound/ActivityFlow.js";import"../../../activity/compound/index.js";import{ActivityDetail as a}from"../widgets/ActivityDetail.js";import{ActivityList as o}from"../widgets/ActivityList.js";import"../../../activity/widgets/index.js";import{jsx as s,jsxs as c}from"react/jsx-runtime";function l({container:l,onError:u,presentation:d,metadata:f}={}){let{state:p,controller:m}=e(),h=p.name!==`closed`;return t({state:p,metadata:f}),n(),s(r,{open:h,onOpenChange:e=>{e||m.close()},container:l,...d?{presentation:d}:{},children:s(i.Boundary,{...u?{onError:u}:{},children:c(i.Steps,{children:[s(i.Step,{name:`activityList`,children:s(o,{})}),s(i.Step,{name:`activityDetail`,children:s(a,{})})]})})})}export{l as ActivityDialog};

package/dist/flows/activity/dialog/ActivityFlowBoundary.d.ts

@@ -0,0 +1 @@
+import { ActivityBoundary, Props } from "../compound/components/Boundary.js";

package/dist/flows/activity/dialog/ActivityFlowBoundary.js

@@ -0,0 +1 @@
+import"../compound/components/Boundary.js";

package/dist/flows/activity/driver/context.d.ts

@@ -0,0 +1,38 @@
+import { ActivityDriver, ActivitySnapshot } from "./types.js";
+import * as _$react from "react";
+import { ReactNode } from "react";
+import * as _$react_jsx_runtime0 from "react/jsx-runtime";
+
+//#region src/flows/activity/driver/context.d.ts
+declare const ActivityDriverContext: _$react.Context<ActivityDriver | null>;
+interface ActivityDriverProviderProps {
+  driver: ActivityDriver;
+  children: ReactNode;
+}
+/**
+ * Publishes a {@link ActivityDriver} into kit context. Mounted internally by `<KitProvider />`
+ * when `activity` is supplied; tests can mount it directly to drive the standalone activity flow
+ * or the per-flow adapter hooks against a mock driver.
+ */
+declare function ActivityDriverProvider({
+  driver,
+  children
+}: ActivityDriverProviderProps): _$react_jsx_runtime0.JSX.Element;
+/**
+ * Reads the active {@link ActivityDriver}. Throws when called outside `<ActivityDriverProvider>` /
+ * `<KitProvider activity={…}>` — mirrors the per-flow `useDepositDriverInstance` contract.
+ */
+declare function useActivityDriverInstance(): ActivityDriver;
+/**
+ * Optional-read variant. Returns `null` when no driver is mounted — used by the per-flow header
+ * activity icons to hide gracefully when the host opted out of activity.
+ */
+declare function useOptionalActivityDriverInstance(): ActivityDriver | null;
+/**
+ * Subscribes the calling component to driver transitions and returns the live
+ * {@link ActivitySnapshot}. Mirrors `useDepositSnapshot` — class-based BYO drivers keep their
+ * `this` binding because the call resolves through the driver instance.
+ */
+declare function useActivitySnapshot(): ActivitySnapshot;
+//#endregion
+export { ActivityDriverContext, ActivityDriverProvider, useActivityDriverInstance, useActivitySnapshot, useOptionalActivityDriverInstance };

package/dist/flows/activity/driver/context.js

@@ -0,0 +1 @@
+"use client";import{createContext as e,use as t,useCallback as n,useSyncExternalStore as r}from"react";import{jsx as i}from"react/jsx-runtime";const a=e(null);a.displayName=`ActivityDriverContext`;function o({driver:e,children:t}){return i(a,{value:e,children:t})}function s(){let e=t(a);if(!e)throw Error("useActivity / useActivityDriverInstance must be used inside a `<KitProvider activity={…}>` (or a `<StridgeProvider>` with a flow enabled).");return e}function c(){return t(a)}function l(){let e=s();return r(t=>e.subscribe(t),()=>e.getSnapshot(),()=>e.getSnapshot())}function u(){let e=c(),t=n(t=>e?.subscribe(t)??(()=>void 0),[e]),i=n(()=>e?.getSnapshot()??null,[e]);return r(t,i,i)}export{a as ActivityDriverContext,o as ActivityDriverProvider,s as useActivityDriverInstance,l as useActivitySnapshot,c as useOptionalActivityDriverInstance,u as useOptionalActivitySnapshot};

package/dist/flows/activity/driver/types.d.ts

@@ -0,0 +1,58 @@
+import { Entity } from "../../../shared/driver/types.js";
+import { ActivityPayload } from "../../../shared/widgets/activity/payloads.js";
+import { GatewayPollResponse, GatewayUdaDto } from "@stridge/sdk";
+
+//#region src/flows/activity/driver/types.d.ts
+/**
+ * Slim snapshot exposed by the standalone activity driver. Mirrors the `activity` slot per-flow
+ * drivers used to carry on their own snapshot before the consolidation — keeping the shape
+ * identical lets the per-flow adapter hooks read from this driver without restructuring their
+ * `ActivitySourceValue` build.
+ */
+interface ActivitySnapshot {
+  activity: Entity<ActivityPayload, ReadonlyArray<GatewayUdaDto>, GatewayPollResponse>;
+}
+/**
+ * Standalone activity driver contract. The data slice is intentionally slimmer than
+ * {@link import("#/flows/deposit/driver").DepositDriver} / {@link import("#/flows/withdraw/driver").WithdrawDriver}
+ * — the driver only owns owner-scoped recent-settlements polling, no submission paths.
+ *
+ * Required methods (`arm`, `watchActivity`, `refreshActivity`) are mandatory because they are the
+ * driver's entire purpose — the kit's in-flow activity widgets and the standalone dialog both
+ * depend on a polling source being live. {@link invalidateActivity} is optional, mirroring the
+ * pattern on per-flow `invalidateBalances?` — drivers that want to opt out of cross-driver
+ * invalidation (e.g. tests, custom integrations) can skip implementing it.
+ */
+interface ActivityDriver {
+  /**
+   * Idempotent priming hook. Live driver kicks off the shared `Gateway.assets()` catalog fetch
+   * on first call; the mock no-ops because fixtures are immutable. `<KitProvider>` arms the
+   * driver lazily from the controller's `open()` path and from the in-flow watcher mount.
+   */
+  arm(): void;
+  /**
+   * Recurring `gateway/{owner}` poll. Honors the abort signal — the controller's `inActivity`
+   * effect tears down the watcher when the dialog closes. Cadence is adaptive on the live
+   * driver (fast while pending rows exist, slow once every row is terminal) and constant on
+   * the mock.
+   */
+  watchActivity(signal: AbortSignal): void;
+  /**
+   * One-shot owner-scoped activity fetch. The standalone source adapter calls this from
+   * pull-to-refresh; the per-flow adapters call it on settlement-completion signals.
+   */
+  refreshActivity(signal: AbortSignal): void;
+  /**
+   * Optional revalidation hook fired by per-flow drivers when they observe a relevant
+   * transition (settlement succeeded, withdraw submitted). Implementations should bump the
+   * `activity` entity into `loading` or `stale` and trigger an immediate refetch. Mirrors the
+   * `invalidateBalances?` lifecycle slot on the per-flow drivers.
+   */
+  invalidateActivity?(): void;
+  /** Returns the current snapshot. Cheap (no copy) when no mutation has occurred since the last call. */
+  getSnapshot(): ActivitySnapshot;
+  /** Registers a listener fired on every mutation. Returns the unsubscribe function. */
+  subscribe(listener: () => void): () => void;
+}
+//#endregion
+export { ActivityDriver, ActivitySnapshot };

package/dist/flows/activity/orchestrator/controller.d.ts

@@ -0,0 +1,11 @@
+import { ActivityState } from "./types.js";
+import { ReactNode } from "react";
+//#region src/flows/activity/orchestrator/controller.d.ts
+/**
+ * Read the **logical** activity state — what the reducer says. Transitions to `closed` are
+ * surfaced synchronously, so this is the right hook for "is the dialog open?" gating, analytics,
+ * and any headless UI that drives off live machine state.
+ */
+declare function useActivityState(): ActivityState;
+//#endregion
+export { useActivityState };

package/dist/flows/activity/orchestrator/controller.js

@@ -0,0 +1 @@
+"use client";import{useActivityDriverInstance as e}from"../driver/context.js";import{resolveActivityEntry as t}from"../../../shared/orchestrator/resolveActivityEntry.js";import{useEffectiveState as n}from"../../../shared/orchestrator/useEffectiveState.js";import"../../../shared/orchestrator/index.js";import{initialState as r,reducer as i}from"./reducer.js";import{createContext as a,use as o,useCallback as s,useEffect as c,useMemo as l,useReducer as u,useRef as d}from"react";import{jsx as f}from"react/jsx-runtime";const p=a(null);p.displayName=`ActivityControllerContext`;function m(){let e=o(p);if(!e)throw Error("useActivity must be used inside `<KitProvider activity={…}>` (or `<StridgeProvider>` with a flow enabled). Mount the provider once at the host's app root.");return e}function h(){return o(p)}function g(){return m().state}function _(){return m().effectiveState}function v(){return m().actions}function y({children:t}){let a=e(),[o,s]=u(i,r),c=x(s);S(o,a);let d=n(o),m=b(s,a,c);return f(p,{value:l(()=>({state:o,effectiveState:d,dispatch:s,controller:m,actions:c}),[o,d,m,c]),children:t})}function b(e,n,r){let i=d(n);i.current=n;let a=s(n=>(i.current.arm(),n?(e({type:`OPEN`,input:t(i.current.getSnapshot().activity,n)}),!0):(e({type:`OPEN`}),!0)),[e]),o=s(()=>{e({type:`CLOSE`})},[e]);return l(()=>({open:a,close:o,actions:r}),[a,o,r])}function x(e){let t=d(e);t.current=e;let n=s(e=>{t.current({type:`SELECT_SETTLEMENT`,settlementId:e})},[]),r=s(()=>{t.current({type:`BACK`})},[]),i=s(()=>{t.current({type:`CLOSE`})},[]);return l(()=>({selectSettlement:n,back:r,close:i}),[n,r,i])}function S(e,t){let n=e.name!==`closed`;c(()=>{if(!n)return;let e=new AbortController;return t.watchActivity(e.signal),()=>e.abort()},[n,t])}export{y as ActivityControllerProvider,v as useActivityActions,m as useActivityControllerContext,_ as useActivityEffectiveState,g as useActivityState,h as useOptionalActivityControllerContext};

package/dist/flows/activity/orchestrator/index.d.ts

@@ -0,0 +1,4 @@
+import { ActivityOpenInput } from "../../../shared/orchestrator/activityOpenInput.js";
+import { ActivityActions, ActivityController, ActivityState, ActivityStateName } from "./types.js";
+import { useActivityState } from "./controller.js";
+import { useActivity, useOptionalActivity, useOptionalPrefetchActivity, usePrefetchActivity } from "./useActivity.js";

package/dist/flows/activity/orchestrator/index.js

@@ -0,0 +1 @@
+import"./reducer.js";import"./controller.js";import"./useActivity.js";

package/dist/flows/activity/orchestrator/reducer.d.ts

@@ -0,0 +1 @@
+export { };

package/dist/flows/activity/orchestrator/reducer.js

@@ -0,0 +1 @@
+import{createActivityReducers as e}from"../../../shared/orchestrator/createActivityReducers.js";import"../../../shared/orchestrator/index.js";const t={name:`closed`},{reduceFromActivityList:n,reduceFromActivityDetail:r}=e({activityList:()=>({name:`activityList`,ctx:{backTarget:void 0}}),activityDetail:(e,t,n)=>({name:`activityDetail`,ctx:{settlementId:e,viaList:n,backTarget:void 0}}),closed:()=>({name:`closed`}),restoreFromBackTarget:()=>({name:`closed`})});function i(e,t){if(t.type===`OPEN`&&e.name!==`closed`)return o(e,t);switch(e.name){case`closed`:return a(t);case`activityList`:return n(e,t);case`activityDetail`:return r(e,t);default:return s(e)}}function a(e){if(e.type!==`OPEN`)return{name:`closed`};let t=e.input;return!t||t.kind===`list`?{name:`activityList`,ctx:{backTarget:void 0}}:{name:`activityDetail`,ctx:{settlementId:t.settlementId,viaList:!1,backTarget:void 0}}}function o(e,t){if(t.type!==`OPEN`)return e;let n=t.input;return!n||n.kind===`list`?e.name===`activityList`?e:{name:`activityList`,ctx:{backTarget:void 0}}:{name:`activityDetail`,ctx:{settlementId:n.settlementId,viaList:!1,backTarget:void 0}}}function s(e){throw Error(`Unhandled activity state: ${JSON.stringify(e)}`)}export{t as initialState,i as reducer};

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

@@ -0,0 +1,71 @@
+import { ActivityOpenInput } from "../../../shared/orchestrator/activityOpenInput.js";
+//#region src/flows/activity/orchestrator/types.d.ts
+/**
+ * Standalone activity FSM state. Minimal — `closed | activityList | activityDetail`. No
+ * `backTarget` carrying because the flow has no source step to restore; `viaList` mirrors the
+ * per-flow invariant so BACK from a tap-through detail returns to the list and BACK from a
+ * direct-entry detail collapses to `closed`.
+ *
+ * The vestigial `backTarget: void` slot is required (not optional) so the factory's
+ * `TState & { ctx: { backTarget: TBackTarget } }` intersection narrows cleanly when
+ * `TBackTarget = void`. At runtime the field is omitted; TypeScript treats `void` ≡ `undefined`
+ * for property types.
+ */
+type ActivityState = {
+  name: "closed";
+} | {
+  name: "activityList";
+  ctx: {
+    backTarget: void;
+  };
+} | {
+  name: "activityDetail";
+  ctx: {
+    settlementId: string;
+    viaList: boolean;
+    backTarget: void;
+  };
+};
+/** Public state-name discriminator. Mirrors `DepositStateName` / `WithdrawStateName`. */
+type ActivityStateName = ActivityState["name"];
+/**
+ * Imperative controller returned by `useActivity()`. Stable across re-renders.
+ */
+interface ActivityController {
+  /**
+   * Open the activity dialog.
+   *
+   * - `open()` → `activityList`; `BACK` closes the dialog.
+   * - `open({ settlementId })` → `activityDetail` when the id resolves against the driver's
+   *   `activity` entity, otherwise falls through to `activityList`. `BACK` closes the dialog.
+   * - `open({ txHash })` → same fall-through semantics, but matched against
+   *   `from.tx_id` in the raw UDA envelope.
+   *
+   * Returns `true` — the activity surface is always reachable (read-only, method-agnostic);
+   * the boolean is preserved for symmetry with `useDeposit().open()` / `useWithdraw().open()`.
+   */
+  open(input?: ActivityOpenInput): boolean;
+  /** Close the activity dialog. Idempotent. */
+  close(): void;
+  /**
+   * Action dispatchers — fire the same FSM transitions the kit's compound widgets fire. Use
+   * these when building fully-custom headless UI; the dialog and compound layers wire them up
+   * automatically.
+   */
+  actions: ActivityActions;
+}
+/**
+ * Imperative actions consumed by widgets. Read with `useActivityActions()` and dispatch into
+ * the standalone activity FSM directly — there's no host-supplied transitions handler in
+ * between.
+ */
+interface ActivityActions {
+  /** Open the detail view for a settlement listed on the activity surface. Legal only from `activityList`. */
+  selectSettlement(settlementId: string): void;
+  /** BACK chevron — collapses one navigation level (list-from-detail-via-list, or closed otherwise). */
+  back(): void;
+  /** Dialog close (X / overlay click). */
+  close(): void;
+}
+//#endregion
+export { ActivityActions, ActivityController, ActivityState, ActivityStateName };

package/dist/flows/activity/orchestrator/useActivity.d.ts

@@ -0,0 +1,94 @@
+import { ActivityController } from "./types.js";
+
+//#region src/flows/activity/orchestrator/useActivity.d.ts
+/**
+ * Imperative handle to the orchestrated activity flow. Use to open / close the activity dialog from
+ * anywhere in the host app, with optional direct-entry into a settlement detail by `settlementId`
+ * or `txHash`.
+ *
+ * Mount `<KitProvider activity={…} />` once at the host's app root first (or use `<StridgeProvider>`
+ * with any flow enabled, which auto-derives the activity driver) — the hook throws when called
+ * outside.
+ *
+ * @example
+ * ```tsx
+ * import { useActivity } from "@stridge/kit";
+ *
+ * function ActivityButton() {
+ *     const { open } = useActivity();
+ *     return <button onClick={() => open()}>Activity</button>;
+ * }
+ * ```
+ *
+ * @example
+ * ```tsx
+ * // Direct-entry into a settlement detail. Resolution misses fall through to `activityList` —
+ * // the click never silently no-ops.
+ * open({ settlementId });
+ * open({ txHash });
+ * ```
+ */
+declare function useActivity(): ActivityController;
+/**
+ * Non-throwing variant of {@link useActivity} — returns `null` when called outside a
+ * `<KitProvider activity={…} />`. 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 activity = useOptionalActivity();
+ * return (
+ *     <button onClick={() => activity?.open()} disabled={!activity}>
+ *         Activity
+ *     </button>
+ * );
+ * ```
+ */
+declare function useOptionalActivity(): ActivityController | null;
+/**
+ * Headless prefetch handle for the activity driver. Returns a stable function that arms the
+ * driver — kicks off the deferred `Gateway.assets()` catalog fetch alongside the initial
+ * `gateway/{owner}` envelope GET. Calling it before the user opens the dialog warms the cache so
+ * the subsequent `useActivity().open()` lands on a populated payload without a perceptible
+ * loading window.
+ *
+ * Fire-and-forget: returns `void`. Observe the live snapshot via `useActivitySnapshot()` if
+ * needed.
+ *
+ * ```tsx
+ * const activity = useActivity();
+ * const prefetchActivity = usePrefetchActivity();
+ * <button onMouseEnter={prefetchActivity} onClick={() => activity.open()}>Activity</button>;
+ * ```
+ *
+ * Idempotent — subsequent calls are no-ops while the driver is already armed.
+ */
+declare function usePrefetchActivity(): () => void;
+/**
+ * Non-throwing variant of {@link usePrefetchActivity} — returns a stable function that no-ops when
+ * called outside a `<KitProvider activity={…}>`. Lets hosts mount `<StridgeProvider />`
+ * conditionally (e.g. only after a wallet is connected) without descendants crashing the moment
+ * they render before the provider exists.
+ *
+ * Symmetric with {@link useOptionalActivity}; pair them when wiring conditional-mount hosts:
+ *
+ * @example
+ * ```tsx
+ * const activity = useOptionalActivity();
+ * const prefetchActivity = useOptionalPrefetchActivity();
+ * return (
+ *     <button
+ *         onMouseEnter={prefetchActivity}
+ *         onFocus={prefetchActivity}
+ *         onClick={() => activity?.open({ settlementId })}
+ *         disabled={!activity}
+ *     >
+ *         View receipt
+ *     </button>
+ * );
+ * ```
+ */
+declare function useOptionalPrefetchActivity(): () => void;
+//#endregion
+export { useActivity, useOptionalActivity, useOptionalPrefetchActivity, usePrefetchActivity };

package/dist/flows/activity/orchestrator/useActivity.js

@@ -0,0 +1 @@
+"use client";import{useActivityDriverInstance as e,useOptionalActivityDriverInstance as t}from"../driver/context.js";import{useActivityControllerContext as n,useOptionalActivityControllerContext as r}from"./controller.js";import{useCallback as i}from"react";function a(){return n().controller}function o(){return r()?.controller??null}function s(){let t=e();return i(()=>{t.arm()},[t])}function c(){let e=t();return i(()=>{e?.arm()},[e])}export{a as useActivity,o as useOptionalActivity,c as useOptionalPrefetchActivity,s as usePrefetchActivity};

package/dist/flows/activity/widgets/ActivityDetail.d.ts

@@ -0,0 +1,41 @@
+import { ReactNode } from "react";
+import * as _$react_jsx_runtime0 from "react/jsx-runtime";
+
+//#region src/flows/activity/widgets/ActivityDetail.d.ts
+interface ActivityDetailOwnProps {
+  /**
+   * Optional custom composition forwarded to the underlying `<ActivityDetail>`
+   * compound. Defaults to mounting all three per-kind parts; each gates internally on the
+   * resolved payload's `kind`.
+   */
+  children?: ReactNode;
+}
+/**
+ * Orchestrated activity detail wrapper for the standalone activity dialog. Mounts the
+ * cross-flow `<ActivityDetail>` compound and exposes per-kind parts (`Processing`,
+ * `Succeeded`, `Failed`) as namespace members. Renders `null` while the FSM is not on
+ * `activityDetail`.
+ */
+declare function ActivityDetail({
+  children
+}: ActivityDetailOwnProps): _$react_jsx_runtime0.JSX.Element | null;
+declare namespace ActivityDetail {
+  type Props = ActivityDetailOwnProps;
+  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 { ActivityDetail };

package/dist/flows/activity/widgets/ActivityDetail.js

@@ -0,0 +1 @@
+"use client";import{ActivitySourceProvider as e}from"../../../shared/widgets/activity/compound/context.js";import{ActivityDetail as t}from"../../../shared/widgets/activity/compound/ActivityDetail.js";import"../../../shared/widgets/activity/compound/index.js";import{useStandaloneActivitySource as n}from"./useStandaloneActivitySource.js";import{jsx as r}from"react/jsx-runtime";function i({children:i}){let{sourceValue:a,step:o}=n();return o!==`activityDetail`||!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 ActivityDetail};

package/dist/flows/activity/widgets/ActivityList.d.ts

@@ -0,0 +1,38 @@
+import { ActivityHeader, ActivityListHeader } from "../../../shared/widgets/activity/compound/components/ActivityHeader.js";
+import { ActivityEmpty } from "../../../shared/widgets/activity/compound/components/Empty.js";
+import { ActivityErrorView } from "../../../shared/widgets/activity/compound/components/ErrorView.js";
+import { ActivityList as ActivityList$1 } from "../../../shared/widgets/activity/compound/components/List.js";
+import { ActivityRow } from "../../../shared/widgets/activity/compound/components/Row.js";
+import { ComponentProps, ReactNode } from "react";
+import * as _$react_jsx_runtime0 from "react/jsx-runtime";
+
+//#region src/flows/activity/widgets/ActivityList.d.ts
+interface ActivityListOwnProps {
+  /**
+   * Optional custom composition forwarded to the underlying `<Activity>` compound.
+   * Defaults to the compound's `<Header /> + <List />` shape.
+   */
+  children?: ReactNode;
+}
+/**
+ * Orchestrated activity list wrapper for the standalone activity dialog. Bridges the activity
+ * flow's snapshot + actions + FSM state into the cross-flow `<Activity>` compound's source
+ * value. Renders `null` while the FSM is not on `activityList` — the dialog's step router only
+ * matches the active step, but the no-op guard keeps the component safe to mount in custom
+ * dialog compositions that skip the step router.
+ */
+declare function ActivityList({
+  children,
+  ...props
+}: ComponentProps<"div"> & ActivityListOwnProps): _$react_jsx_runtime0.JSX.Element | null;
+declare namespace ActivityList {
+  type Props = ComponentProps<"div"> & ActivityListOwnProps;
+  const Header: typeof ActivityHeader;
+  const ListHeader: typeof ActivityListHeader;
+  const List: typeof ActivityList$1;
+  const Row: typeof ActivityRow;
+  const Empty: typeof ActivityEmpty;
+  const ErrorView: typeof ActivityErrorView;
+}
+//#endregion
+export { ActivityList };

package/dist/flows/activity/widgets/ActivityList.js

@@ -0,0 +1 @@
+"use client";import{ActivitySourceProvider as e}from"../../../shared/widgets/activity/compound/context.js";import{Activity as t}from"../../../shared/widgets/activity/compound/Activity.js";import"../../../shared/widgets/activity/compound/index.js";import{useStandaloneActivitySource as n}from"./useStandaloneActivitySource.js";import{jsx as r}from"react/jsx-runtime";function i({children:i,...a}){let{sourceValue:o,step:s}=n();return s!==`activityList`||!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 ActivityList};

package/dist/flows/activity/widgets/useStandaloneActivitySource.js

@@ -0,0 +1 @@
+"use client";import{useActivityDriverInstance as e,useActivitySnapshot as t}from"../driver/context.js";import{useLingui as n}from"../../../shared/i18n/useLingui.js";import"../../../i18n/index.js";import{useActivityActions as r,useActivityEffectiveState as i}from"../orchestrator/controller.js";import{useActivity as a}from"../orchestrator/useActivity.js";import"../orchestrator/index.js";import{defaultBlockExplorers as o}from"../../../shared/utils/explorers.js";import{useCallback as s,useMemo as c}from"react";function l(){let l=t(),u=e(),d=r(),f=a(),p=i(),{i18n:m}=n(),h=s(e=>{u.refreshActivity(e)},[u]),g=s(()=>{f.open()},[f]),_=p.name===`activityList`||p.name===`activityDetail`,v=p.name===`activityDetail`?p.ctx.settlementId:void 0,y=p.name===`activityDetail`&&p.ctx.viaList;return{sourceValue:c(()=>{if(!_)return null;let e=l.activity.status===`ready`||l.activity.status===`stale`?l.activity.response.owner:`0x0000000000000000000000000000000000000000`,t=l.activity.status===`ready`||l.activity.status===`stale`?l.activity.payload.brandName:void 0,n={i18n:m,sourceWallet:{name:`Wallet`,address:e},explorers:o(),...t?{brandName:t}:{}};return{entity:l.activity,refresh:h,selectSettlement:d.selectSettlement,...y?{back:d.back}:{},onLookupMiss:g,...v===void 0?{}:{settlementId:v},settlementContext:n}},[l,d,_,v,m,h,y,g]),settlementId:v,step:p.name===`activityList`?`activityList`:p.name===`activityDetail`?`activityDetail`:`other`}}export{l as useStandaloneActivitySource};

package/dist/flows/deposit/bindings/DepositBindings.d.ts

@@ -0,0 +1,87 @@
+import { ReactNode } from "react";
+//#region src/flows/deposit/bindings/DepositBindings.d.ts
+/**
+ * Detected card-brand union. Matches the IIN-range coverage of the cash deposit's
+ * `CardInputRow`: Visa / Mastercard / Amex / Discover, plus `"unknown"` for any prefix outside
+ * those ranges. Exposed here (rather than alongside the widget-local masking helpers) so the
+ * public `tokenizeCard` binding can talk about it without a deep widget import.
+ */
+type CardBrand = "visa" | "mastercard" | "amex" | "discover" | "unknown";
+/**
+ * Raw card data the kit hands to the host's tokenize binding when the user submits the cash
+ * deposit's card form. PAN / CVC are raw digit strings (no masking); `exp` is the formatted
+ * `MM/YY` value the user typed; `brand` is the IIN-range detection from `CardInputRow`.
+ *
+ * This struct is the host's only direct contact with cardholder data — once `tokenizeCard`
+ * resolves, the host exchanges it for an opaque token (Stripe.js / Adyen / Spreedly / similar)
+ * and the kit no longer holds the raw PAN.
+ */
+interface CardData {
+  /** Raw digits with no separators (16 for Visa/MC/Discover, 15 for Amex). */
+  pan: string;
+  /** Formatted `MM/YY` value. Validated upstream by `isValidExp` before submit. */
+  exp: string;
+  /** Raw digits (3 for Visa/MC/Discover, 4 for Amex). */
+  cvc: string;
+  /** Detected brand at submit time. */
+  brand: CardBrand;
+}
+/**
+ * Discriminated result of a tokenize attempt. Success carries the opaque token the host's PSP
+ * returned; failure carries a host-supplied reason string the form surfaces inline.
+ */
+type TokenizationResult = {
+  ok: true;
+  token: string;
+} | {
+  ok: false;
+  reason: string;
+};
+/**
+ * Render-time inputs the host supplies to the deposit flow. Today this is just the optional
+ * `tokenizeCard` callback — when undefined, callers compose with {@link DEFAULT_TOKENIZE_CARD}
+ * so the editable form stays observable end-to-end without any host wiring. Future per-method
+ * slots (`applePayMerchantSession`, `googlePayPaymentData`) will land on the same context.
+ */
+interface DepositBindings {
+  /**
+   * Optional host-supplied tokenize handler. Fired when the user submits a valid card form.
+   * Host wires this to its PSP's tokenization JS — `stripe.createPaymentMethod`,
+   * `adyenWebComponents.createToken`, `spreedlyExpress.createToken`, etc. Resolves to a
+   * discriminated result the form surfaces inline.
+   *
+   * When undefined, callers fall through to {@link DEFAULT_TOKENIZE_CARD} — keeps the demo
+   * path interactive without forcing every host to ship a tokenizer just to render the form.
+   */
+  tokenizeCard?: (data: CardData) => Promise<TokenizationResult>;
+}
+/**
+ * Publish the host's render-time deposit inputs (just `tokenizeCard` today) into the kit's
+ * deposit scope. Call it once from whatever component renders the deposit UI:
+ *
+ * - The kit's `<DepositDialog>` calls it internally when the host passes its bindings prop.
+ * - A **headless** host that renders fully custom deposit UI calls it directly — it's the
+ *   supported way to wire `tokenizeCard` without mounting the dialog.
+ *
+ * Publishes via `useLayoutEffect` so the bridge ref and reactive state are committed before the
+ * next browser paint — the form's submit handler reads `ctx.ref.current.tokenizeCard` at fire
+ * time and always sees the latest value. Cleanup blanks both on unmount.
+ *
+ * React 19 StrictMode runs the layout effect mount → cleanup → mount sequence, so the cleanup
+ * blanking the ref is fine: the immediate re-mount restores the bound `tokenizeCard` before any
+ * paint, so no user interaction can observe the empty window.
+ *
+ * @example Headless usage
+ * ```tsx
+ * useDepositBindings({
+ *     tokenizeCard: async (card) => {
+ *         const result = await stripe.createPaymentMethod({ type: "card", card });
+ *         if (result.error) return { ok: false, reason: result.error.message ?? "Tokenization failed" };
+ *         return { ok: true, token: result.paymentMethod.id };
+ *     },
+ * });
+ * ```
+ */
+declare function useDepositBindings(bindings: DepositBindings): void;
+//#endregion
+export { CardBrand, CardData, DepositBindings, TokenizationResult, useDepositBindings };

package/dist/flows/deposit/bindings/DepositBindings.js

@@ -0,0 +1 @@
+"use client";import{createContext as e,use as t,useLayoutEffect as n,useMemo as r,useRef as i,useState as a}from"react";import{jsx as o}from"react/jsx-runtime";async function s(e){return await new Promise(e=>setTimeout(e,800)),{ok:!0,token:`kit-mock-token`}}const c=e(null);c.displayName=`DepositBindingsControlContext`;const l=e(null);l.displayName=`DepositBindingsValueContext`;function u({children:e}){let[t,n]=a({}),s=i({});return o(c,{value:r(()=>({setBindings:n,ref:s}),[]),children:o(l,{value:t,children:e})})}function d(){let e=t(c),n=i({});return e?.ref??n}function f(e){let r=t(c),a=e.tokenizeCard,o=i(r?.setBindings);o.current=r?.setBindings;let s=i(r?.ref);s.current=r?.ref,n(()=>{let e=o.current,t=s.current;if(!e||!t)return;let n={...a?{tokenizeCard:a}:{}};return t.current=n,e(n),()=>{let e=o.current,t=s.current;t&&(t.current={}),e&&e({})}},[a])}export{s as DEFAULT_TOKENIZE_CARD,u as DepositBindingsProvider,f as useDepositBindings,d as useDepositBindingsRef};

package/dist/flows/deposit/bindings/index.d.ts

@@ -0,0 +1 @@
+import { CardBrand, CardData, DepositBindings, TokenizationResult, useDepositBindings } from "./DepositBindings.js";

package/dist/flows/deposit/bindings/index.js

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