@xyo-network/xl1-react-client-sdk 1.28.0

package/LICENSE

@@ -0,0 +1,165 @@
+                   GNU LESSER GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+
+  This version of the GNU Lesser General Public License incorporates
+the terms and conditions of version 3 of the GNU General Public
+License, supplemented by the additional permissions listed below.
+
+  0. Additional Definitions.
+
+  As used herein, "this License" refers to version 3 of the GNU Lesser
+General Public License, and the "GNU GPL" refers to version 3 of the GNU
+General Public License.
+
+  "The Library" refers to a covered work governed by this License,
+other than an Application or a Combined Work as defined below.
+
+  An "Application" is any work that makes use of an interface provided
+by the Library, but which is not otherwise based on the Library.
+Defining a subclass of a class defined by the Library is deemed a mode
+of using an interface provided by the Library.
+
+  A "Combined Work" is a work produced by combining or linking an
+Application with the Library.  The particular version of the Library
+with which the Combined Work was made is also called the "Linked
+Version".
+
+  The "Minimal Corresponding Source" for a Combined Work means the
+Corresponding Source for the Combined Work, excluding any source code
+for portions of the Combined Work that, considered in isolation, are
+based on the Application, and not on the Linked Version.
+
+  The "Corresponding Application Code" for a Combined Work means the
+object code and/or source code for the Application, including any data
+and utility programs needed for reproducing the Combined Work from the
+Application, but excluding the System Libraries of the Combined Work.
+
+  1. Exception to Section 3 of the GNU GPL.
+
+  You may convey a covered work under sections 3 and 4 of this License
+without being bound by section 3 of the GNU GPL.
+
+  2. Conveying Modified Versions.
+
+  If you modify a copy of the Library, and, in your modifications, a
+facility refers to a function or data to be supplied by an Application
+that uses the facility (other than as an argument passed when the
+facility is invoked), then you may convey a copy of the modified
+version:
+
+   a) under this License, provided that you make a good faith effort to
+   ensure that, in the event an Application does not supply the
+   function or data, the facility still operates, and performs
+   whatever part of its purpose remains meaningful, or
+
+   b) under the GNU GPL, with none of the additional permissions of
+   this License applicable to that copy.
+
+  3. Object Code Incorporating Material from Library Header Files.
+
+  The object code form of an Application may incorporate material from
+a header file that is part of the Library.  You may convey such object
+code under terms of your choice, provided that, if the incorporated
+material is not limited to numerical parameters, data structure
+layouts and accessors, or small macros, inline functions and templates
+(ten or fewer lines in length), you do both of the following:
+
+   a) Give prominent notice with each copy of the object code that the
+   Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the object code with a copy of the GNU GPL and this license
+   document.
+
+  4. Combined Works.
+
+  You may convey a Combined Work under terms of your choice that,
+taken together, effectively do not restrict modification of the
+portions of the Library contained in the Combined Work and reverse
+engineering for debugging such modifications, if you also do each of
+the following:
+
+   a) Give prominent notice with each copy of the Combined Work that
+   the Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the Combined Work with a copy of the GNU GPL and this license
+   document.
+
+   c) For a Combined Work that displays copyright notices during
+   execution, include the copyright notice for the Library among
+   these notices, as well as a reference directing the user to the
+   copies of the GNU GPL and this license document.
+
+   d) Do one of the following:
+
+       0) Convey the Minimal Corresponding Source under the terms of this
+       License, and the Corresponding Application Code in a form
+       suitable for, and under terms that permit, the user to
+       recombine or relink the Application with a modified version of
+       the Linked Version to produce a modified Combined Work, in the
+       manner specified by section 6 of the GNU GPL for conveying
+       Corresponding Source.
+
+       1) Use a suitable shared library mechanism for linking with the
+       Library.  A suitable mechanism is one that (a) uses at run time
+       a copy of the Library already present on the user's computer
+       system, and (b) will operate properly with a modified version
+       of the Library that is interface-compatible with the Linked
+       Version.
+
+   e) Provide Installation Information, but only if you would otherwise
+   be required to provide such information under section 6 of the
+   GNU GPL, and only to the extent that such information is
+   necessary to install and execute a modified version of the
+   Combined Work produced by recombining or relinking the
+   Application with a modified version of the Linked Version. (If
+   you use option 4d0, the Installation Information must accompany
+   the Minimal Corresponding Source and Corresponding Application
+   Code. If you use option 4d1, you must provide the Installation
+   Information in the manner specified by section 6 of the GNU GPL
+   for conveying Corresponding Source.)
+
+  5. Combined Libraries.
+
+  You may place library facilities that are a work based on the
+Library side by side in a single library together with other library
+facilities that are not Applications and are not covered by this
+License, and convey such a combined library under terms of your
+choice, if you do both of the following:
+
+   a) Accompany the combined library with a copy of the same work based
+   on the Library, uncombined with any other library facilities,
+   conveyed under the terms of this License.
+
+   b) Give prominent notice with the combined library that part of it
+   is a work based on the Library, and explaining where to find the
+   accompanying uncombined form of the same work.
+
+  6. Revised Versions of the GNU Lesser General Public License.
+
+  The Free Software Foundation may publish revised and/or new versions
+of the GNU Lesser General Public License from time to time. Such new
+versions will be similar in spirit to the present version, but may
+differ in detail to address new problems or concerns.
+
+  Each version is given a distinguishing version number. If the
+Library as you received it specifies that a certain numbered version
+of the GNU Lesser General Public License "or any later version"
+applies to it, you have the option of following the terms and
+conditions either of that published version or of any later version
+published by the Free Software Foundation. If the Library as you
+received it does not specify a version number of the GNU Lesser
+General Public License, you may choose any version of the GNU Lesser
+General Public License ever published by the Free Software Foundation.
+
+  If the Library as you received it specifies that a proxy can decide
+whether future versions of the GNU Lesser General Public License shall
+apply, that proxy's public statement of acceptance of any version is
+permanent authorization for you to choose that version for the
+Library.

package/README.md

@@ -0,0 +1,30 @@
+# @xyo-network/xl1-react-client-sdk
+
+[![npm][npm-badge]][npm-link]
+[![license][license-badge]][license-link]
+
+> XL1 React Client/Wallet SDK
+
+Combines client/wallet hooks, the XL1 React data model, and shared UI helpers into a single package. Subpath exports are available:
+
+- `@xyo-network/xl1-react-client-sdk` — flat barrel of everything below
+- `@xyo-network/xl1-react-client-sdk/client` — providers, hooks, components for client/wallet integration
+- `@xyo-network/xl1-react-client-sdk/model` — `XyoGlobal` type and guards
+- `@xyo-network/xl1-react-client-sdk/shared` — shared MUI components and Storybook decorators
+
+## Install
+
+```sh
+{{pm}} add {{name}}
+```
+
+## License
+
+See the [LICENSE](LICENSE) file for license rights and limitations (LGPL-3.0-only).
+
+
+
+[npm-badge]: https://img.shields.io/npm/v/@xyo-network/xl1-react-client-sdk.svg
+[npm-link]: https://www.npmjs.com/package/@xyo-network/xl1-react-client-sdk
+[license-badge]: https://img.shields.io/npm/l/@xyo-network/xl1-react-client-sdk.svg
+[license-link]: https://github.com/xylabs/xl1-protocol/blob/main/LICENSE

package/dist/browser/client/components/connected/ConnectAccountsStack.d.ts

@@ -0,0 +1,51 @@
+import type { StackProps } from '@mui/material';
+import type { Address } from '@xylabs/sdk-js';
+import type { ComponentType, MouseEventHandler } from 'react';
+import React from 'react';
+export interface ConnectClientAccountsStackProps extends StackProps {
+    AccountComponent?: ComponentType<{
+        account?: string;
+    }>;
+    ConnectComponent?: ComponentType<{
+        onClick?: MouseEventHandler<HTMLElement>;
+    }>;
+    NoWalletInstalledComponent?: ComponentType;
+    onAccountConnected?: (account: Address) => void;
+    onCancel?: () => void;
+    timeout?: number;
+}
+/**
+ * Renders a horizontal stack that surfaces the current state of the user's
+ * connection to an XL1 wallet (e.g. the XL1 Chrome extension) and lets them
+ * kick off a connection.
+ *
+ * Connection state is derived from `useConnectAccount`, which wraps
+ * `useGatewayFromWallet` (wallet/gateway discovery with a configurable
+ * `timeout`) and `useAccountPermissions` (already-authorized addresses).
+ * The hook returns: `address` (resolved once the wallet exposes one),
+ * `connectSigner` (prompts the wallet for an address), `timedout` (the
+ * gateway never appeared within `timeout`), and `error` (the first of
+ * gateway, permissions, or signer-connect failures).
+ *
+ * The component renders exactly one of the following wallet states, plus
+ * an always-present error slot:
+ *
+ * - **Connected** — `address` is defined: renders `AccountComponent` for
+ *   that address. Also fires `onAccountConnected(address)` once via effect.
+ * - **Disconnected, wallet available** — no `address` and not `timedout`:
+ *   renders `ConnectComponent` as a "Connect" button that invokes
+ *   `connectSigner()`. This covers both "wallet installed but no account
+ *   authorized yet" and "gateway still resolving".
+ * - **Wallet missing / unreachable** — no `address` and `timedout` is true:
+ *   renders `NoWalletInstalledComponent` (defaults to an Alert linking to
+ *   the XL1 Wallet Chrome Web Store listing).
+ * - **Error** — any error from the hook is rendered via `ErrorRender`
+ *   alongside the state above, and `onCancel()` is fired once via effect
+ *   so the host UI can close/abort its connect flow.
+ *
+ * All three slot components (`AccountComponent`, `ConnectComponent`,
+ * `NoWalletInstalledComponent`) are injectable so consumers can restyle
+ * any state without forking this component.
+ */
+export declare const ConnectAccountsStack: React.FC<ConnectClientAccountsStackProps>;
+//# sourceMappingURL=ConnectAccountsStack.d.ts.map

package/dist/browser/client/components/connected/ConnectAccountsStack.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ConnectAccountsStack.d.ts","sourceRoot":"","sources":["../../../../../src/client/components/connected/ConnectAccountsStack.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAA;AAQ/C,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,gBAAgB,CAAA;AAE7C,OAAO,KAAK,EAAE,aAAa,EAAE,iBAAiB,EAAE,MAAM,OAAO,CAAA;AAC7D,OAAO,KAAoB,MAAM,OAAO,CAAA;AA4BxC,MAAM,WAAW,+BAAgC,SAAQ,UAAU;IACjE,gBAAgB,CAAC,EAAE,aAAa,CAAC;QAAE,OAAO,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC,CAAA;IACtD,gBAAgB,CAAC,EAAE,aAAa,CAAC;QAAE,OAAO,CAAC,EAAE,iBAAiB,CAAC,WAAW,CAAC,CAAA;KAAE,CAAC,CAAA;IAC9E,0BAA0B,CAAC,EAAE,aAAa,CAAA;IAC1C,kBAAkB,CAAC,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,IAAI,CAAA;IAC/C,QAAQ,CAAC,EAAE,MAAM,IAAI,CAAA;IACrB,OAAO,CAAC,EAAE,MAAM,CAAA;CACjB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,eAAO,MAAM,oBAAoB,EAAE,KAAK,CAAC,EAAE,CAAC,+BAA+B,CA2C1E,CAAA"}

package/dist/browser/client/components/connected/account/Connected.d.ts

@@ -0,0 +1,5 @@
+import React from 'react';
+export declare const ConnectedAccount: React.FC<{
+    address: string;
+}>;
+//# sourceMappingURL=Connected.d.ts.map

package/dist/browser/client/components/connected/account/Connected.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Connected.d.ts","sourceRoot":"","sources":["../../../../../../src/client/components/connected/account/Connected.tsx"],"names":[],"mappings":"AAKA,OAAO,KAAK,MAAM,OAAO,CAAA;AAEzB,eAAO,MAAM,gBAAgB,EAAE,KAAK,CAAC,EAAE,CAAC;IAAE,OAAO,EAAE,MAAM,CAAA;CAAE,CAW1D,CAAA"}

package/dist/browser/client/components/connected/account/index.d.ts

@@ -0,0 +1,2 @@
+export * from './Connected.tsx';
+//# sourceMappingURL=index.d.ts.map

package/dist/browser/client/components/connected/account/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/client/components/connected/account/index.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAA"}

package/dist/browser/client/components/connected/hooks/index.d.ts

@@ -0,0 +1,2 @@
+export * from './useConnectAccount.ts';
+//# sourceMappingURL=index.d.ts.map

package/dist/browser/client/components/connected/hooks/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/client/components/connected/hooks/index.ts"],"names":[],"mappings":"AAAA,cAAc,wBAAwB,CAAA"}

package/dist/browser/client/components/connected/hooks/useConnectAccount.d.ts

@@ -0,0 +1,17 @@
+import type { GatewayName } from '@xyo-network/xl1-sdk';
+export declare const useConnectAccount: (gatewayName?: GatewayName, timeout?: number) => {
+    address: (Lowercase<string> & {
+        readonly __hex: true;
+    } & {
+        readonly __address: true;
+    }) | undefined;
+    connectSigner: () => Promise<(Lowercase<string> & {
+        readonly __hex: true;
+    } & {
+        readonly __address: true;
+    }) | undefined>;
+    error: Error | undefined;
+    gateway: import("@xyo-network/xl1-sdk").XyoGatewayRunner | null | undefined;
+    timedout: boolean;
+};
+//# sourceMappingURL=useConnectAccount.d.ts.map

package/dist/browser/client/components/connected/hooks/useConnectAccount.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useConnectAccount.d.ts","sourceRoot":"","sources":["../../../../../../src/client/components/connected/hooks/useConnectAccount.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAA;AAMvD,eAAO,MAAM,iBAAiB,GAAI,cAAa,WAA4B,EAAE,UAAU,MAAM;;;;;;;;;;;;;;CA2B5F,CAAA"}

package/dist/browser/client/components/connected/index.d.ts

@@ -0,0 +1,3 @@
+export * from './account/index.ts';
+export * from './ConnectAccountsStack.tsx';
+//# sourceMappingURL=index.d.ts.map

package/dist/browser/client/components/connected/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/client/components/connected/index.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAA;AAClC,cAAc,4BAA4B,CAAA"}

package/dist/browser/client/components/index.d.ts

@@ -0,0 +1,2 @@
+export * from './connected/index.ts';
+//# sourceMappingURL=index.d.ts.map

package/dist/browser/client/components/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/client/components/index.ts"],"names":[],"mappings":"AAAA,cAAc,sBAAsB,CAAA"}

package/dist/browser/client/context/GatewayContext.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Shared React context that decouples gateway *sources* from gateway
+ * *consumers*. Any provider that can resolve an `XyoGateway` publishes to
+ * this context; any hook or component that needs a gateway reads from it
+ * via `useProvidedGateway`. Consumers never import a specific provider —
+ * they just require that *some* provider is mounted above them in the
+ * tree.
+ *
+ * Current publishers:
+ * - `WalletGatewayProvider` (this package) — sources gateways from the
+ *   injected XL1 wallet extension.
+ * - `GatewayProvider` in `@xyo-network/react-chain-provider` — sources
+ *   gateways built in-page against RPC endpoints, falling back to the
+ *   wallet when available.
+ *
+ * To add a new source (e.g. a mock provider for tests, an iframe-bridged
+ * provider, a server-rendered provider), publish a `GatewayContextState`
+ * to this same context — do not create a parallel context, or consumers
+ * will silently stop receiving updates.
+ */
+export declare const GatewayContext: import("react").Context<(import("./GatewayProviderState.ts").GatewayStateFields & {
+    provided: true;
+}) | (import("@xylabs/react-shared").FixedValues<import("@xylabs/react-shared").ProvidedContextExState<import("./GatewayProviderState.ts").GatewayStateFields>, never> & {
+    provided: false;
+}) | (import("@xylabs/react-shared").FixedValues<import("@xylabs/react-shared").NotProvidedContextExState<import("./GatewayProviderState.ts").GatewayStateFields>, never> & {
+    provided: false;
+})>;
+//# sourceMappingURL=GatewayContext.d.ts.map

package/dist/browser/client/context/GatewayContext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GatewayContext.d.ts","sourceRoot":"","sources":["../../../../src/client/context/GatewayContext.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,cAAc;;;;;;GAAyC,CAAA"}

package/dist/browser/client/context/GatewayProviderProps.d.ts

@@ -0,0 +1,6 @@
+import type { GatewayName } from '@xyo-network/xl1-sdk';
+import type { PropsWithChildren } from 'react';
+export interface GatewayProviderProps extends PropsWithChildren {
+    gatewayName?: GatewayName;
+}
+//# sourceMappingURL=GatewayProviderProps.d.ts.map

package/dist/browser/client/context/GatewayProviderProps.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GatewayProviderProps.d.ts","sourceRoot":"","sources":["../../../../src/client/context/GatewayProviderProps.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAA;AACvD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,OAAO,CAAA;AAE9C,MAAM,WAAW,oBAAqB,SAAQ,iBAAiB;IAC7D,WAAW,CAAC,EAAE,WAAW,CAAA;CAC1B"}

package/dist/browser/client/context/GatewayProviderState.d.ts

@@ -0,0 +1,33 @@
+import type { ContextExState } from '@xylabs/react-shared';
+import type { ContextGatewayType } from '../types/index.ts';
+/**
+ * The common surface area published to `GatewayContext`. Every gateway
+ * provider — wallet-backed, in-page, mock, or otherwise — must emit this
+ * shape so that consumers can ignore where the gateway came from.
+ *
+ * Fields use a three-state contract:
+ * - `undefined` — resolution is still in progress; show a loading state.
+ * - `null` — resolution completed and the gateway is definitively absent
+ *   (e.g. no wallet installed, RPC unreachable); safe to show fallback UI.
+ * - `XyoGateway` — resolved and ready to use.
+ *
+ * `defaultGateway` is what most consumers want — the provider picks the
+ * best available source. `gateways` exposes the individual sources for
+ * the rare consumer that needs to differentiate (e.g. a debug panel, or
+ * a flow that must sign with the wallet specifically).
+ *
+ * `resetGatewaysFromConfig` is optional because not every provider has
+ * rebuildable in-page gateways (the wallet-only provider, for instance,
+ * has nothing to reset).
+ */
+export interface GatewayStateFields {
+    defaultGateway: ContextGatewayType | undefined | null;
+    error: Error | null | undefined;
+    gateways: {
+        inPageGateway: ContextGatewayType | undefined | null;
+        walletGateway: ContextGatewayType | undefined | null;
+    };
+    resetGatewaysFromConfig?: () => void;
+}
+export type GatewayContextState = ContextExState<GatewayStateFields>;
+//# sourceMappingURL=GatewayProviderState.d.ts.map

package/dist/browser/client/context/GatewayProviderState.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GatewayProviderState.d.ts","sourceRoot":"","sources":["../../../../src/client/context/GatewayProviderState.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAA;AAE1D,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAA;AAE3D;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,WAAW,kBAAkB;IACjC,cAAc,EAAE,kBAAkB,GAAG,SAAS,GAAG,IAAI,CAAA;IACrD,KAAK,EAAE,KAAK,GAAG,IAAI,GAAG,SAAS,CAAA;IAC/B,QAAQ,EAAE;QACR,aAAa,EAAE,kBAAkB,GAAG,SAAS,GAAG,IAAI,CAAA;QACpD,aAAa,EAAE,kBAAkB,GAAG,SAAS,GAAG,IAAI,CAAA;KACrD,CAAA;IACD,uBAAuB,CAAC,EAAE,MAAM,IAAI,CAAA;CACrC;AAED,MAAM,MAAM,mBAAmB,GAAG,cAAc,CAAC,kBAAkB,CAAC,CAAA"}

package/dist/browser/client/context/in-page/InPageGatewaysContext.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Narrow, provider-internal context that `InPageGatewaysProvider` writes
+ * to and `GatewayProvider` reads from. Do not consume this in application
+ * code — use `useProvidedGateway` (which reads the shared
+ * `GatewayContext`) instead. This context only exists to decouple the
+ * single in-page *builder* from the many single-gateway *adapters* that
+ * sit between it and the shared gateway surface.
+ */
+export declare const InPageGatewaysContext: import("react").Context<(import("./InPageGatewaysState.ts").InPageGatewaysStateFields & {
+    provided: true;
+}) | (import("@xylabs/react-shared").FixedValues<import("@xylabs/react-shared").ProvidedContextExState<import("./InPageGatewaysState.ts").InPageGatewaysStateFields>, never> & {
+    provided: false;
+}) | (import("@xylabs/react-shared").FixedValues<import("@xylabs/react-shared").NotProvidedContextExState<import("./InPageGatewaysState.ts").InPageGatewaysStateFields>, never> & {
+    provided: false;
+})>;
+//# sourceMappingURL=InPageGatewaysContext.d.ts.map

package/dist/browser/client/context/in-page/InPageGatewaysContext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"InPageGatewaysContext.d.ts","sourceRoot":"","sources":["../../../../../src/client/context/in-page/InPageGatewaysContext.ts"],"names":[],"mappings":"AAIA;;;;;;;GAOG;AACH,eAAO,MAAM,qBAAqB;;;;;;GAAyC,CAAA"}

package/dist/browser/client/context/in-page/InPageGatewaysState.d.ts

@@ -0,0 +1,21 @@
+import type { ContextExState } from '@xylabs/react-shared';
+import type { GatewayName } from '@xyo-network/xl1-sdk';
+import type { ContextGatewayType } from '../../types/index.ts';
+/**
+ * Internal handoff shape published by `InPageGatewaysProvider` and
+ * consumed by `GatewayProvider`. Unlike `GatewayContextState`, this is a
+ * *map* of gateways keyed by network id — one builder near the tree root
+ * computes every network's gateway once, and individual `GatewayProvider`
+ * instances deeper in the tree pick out the one they need.
+ *
+ * This is not the cross-publisher surface area; consumers that want "a
+ * gateway" should read the shared `GatewayContext` via
+ * `useProvidedGateway`, not this map directly.
+ */
+export interface InPageGatewaysStateFields {
+    clearAll: () => void;
+    errors: Partial<Record<GatewayName, Error>>;
+    gateways: Partial<Record<GatewayName, ContextGatewayType>>;
+}
+export type InPageGatewaysState = ContextExState<InPageGatewaysStateFields>;
+//# sourceMappingURL=InPageGatewaysState.d.ts.map

package/dist/browser/client/context/in-page/InPageGatewaysState.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"InPageGatewaysState.d.ts","sourceRoot":"","sources":["../../../../../src/client/context/in-page/InPageGatewaysState.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAA;AAC1D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAA;AAEvD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAA;AAE9D;;;;;;;;;;GAUG;AACH,MAAM,WAAW,yBAAyB;IACxC,QAAQ,EAAE,MAAM,IAAI,CAAA;IACpB,MAAM,EAAE,OAAO,CAAC,MAAM,CAAC,WAAW,EAAE,KAAK,CAAC,CAAC,CAAA;IAC3C,QAAQ,EAAE,OAAO,CAAC,MAAM,CAAC,WAAW,EAAE,kBAAkB,CAAC,CAAC,CAAA;CAC3D;AAED,MAAM,MAAM,mBAAmB,GAAG,cAAc,CAAC,yBAAyB,CAAC,CAAA"}

package/dist/browser/client/context/in-page/Provider.d.ts

@@ -0,0 +1,60 @@
+import type { RpcTransport, XyoSignerRpcSchemas } from '@xyo-network/xl1-sdk';
+import type { PropsWithChildren } from 'react';
+import React from 'react';
+export interface InPageGatewaysProviderProps extends PropsWithChildren {
+    signerTransport?: RpcTransport<XyoSignerRpcSchemas>;
+}
+/**
+ * Publishes a keyed map of in-page gateways — one per network in
+ * `DefaultNetworks` — under the narrow `InPageGatewaysContext`.
+ *
+ * This provider is deliberately *not* a direct publisher of the shared
+ * `GatewayContext` that `useProvidedGateway` reads. Its consumer is the
+ * wrapping `GatewayProvider` in this same package, which picks the
+ * `gatewayName` the consumer asked for out of this map, adapts it into
+ * the single-gateway `GatewayContextState` shape, and then publishes *that*
+ * to the shared context. Splitting the work this way lets one
+ * `InPageGatewaysProvider` near the root build every network's gateway
+ * once, while many `GatewayProvider` instances deeper in the tree each
+ * expose whichever gateway their subtree cares about.
+ *
+ * Unlike `WalletGatewayProvider`, gateways here are constructed directly
+ * in the page (via `buildGateway`) against each network's RPC endpoint
+ * — no browser wallet extension is required. `signerTransport` switches
+ * between viewer (read-only) and runner (can sign/send) locators; supply
+ * it only when the app needs to sign.
+ *
+ * Behavior:
+ * - On mount, and whenever `signerTransport` changes, `buildGateway` is
+ *   called in parallel for every network in `DefaultNetworks` via
+ *   `Promise.allSettled`. Networks that resolve populate `gateways[id]`;
+ *   networks that reject populate `errors[id]`. One failed network does
+ *   not block the others.
+ * - If `signerTransport` is provided, gateways are built with a remote
+ *   *runner* locator, otherwise with a remote *viewer* locator.
+ * - When `signerTransport` changes identity mid-life, the provider clears
+ *   all cached gateways and errors synchronously during render (via
+ *   `previousSignerTransport` state) so consumers never see gateways
+ *   bound to the previous transport, then rebuilds in the effect.
+ * - State updates from the rebuild are wrapped in `startTransition` so a
+ *   slow network doesn't stall higher-priority UI updates.
+ * - A `cancelled` flag in the effect's cleanup discards results from a
+ *   prior `signerTransport` once a new one is in flight.
+ *
+ * Published `InPageGatewaysState` (narrower than `GatewayContextState` —
+ * this is an internal handoff shape, not the cross-publisher surface):
+ * - `gateways` — `Partial<Record<GatewayName, ContextGatewayType>>`. Keys
+ *   are only present for networks that built successfully.
+ * - `errors` — `Partial<Record<GatewayName, Error>>`. Per-network build
+ *   failures, keyed by `GatewayName`.
+ * - `clearAll()` — manually empties both maps. Also invoked internally on
+ *   transport changes. Forwarded by `GatewayProvider` to consumers as
+ *   `resetGatewaysFromConfig`.
+ * - `provided: true` — lets descendants detect a real provider.
+ *
+ * Note: the commented-out `SimpleXyoClient` at the top is intentionally
+ * disabled pending a type unification between `XyoGateway` and
+ * `XyoGatewayRunner`.
+ */
+export declare const InPageGatewaysProvider: React.FC<InPageGatewaysProviderProps>;
+//# sourceMappingURL=Provider.d.ts.map

package/dist/browser/client/context/in-page/Provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Provider.d.ts","sourceRoot":"","sources":["../../../../../src/client/context/in-page/Provider.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACG,YAAY,EAAE,mBAAmB,EAC/C,MAAM,sBAAsB,CAAA;AAE7B,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,OAAO,CAAA;AAC9C,OAAO,KAGN,MAAM,OAAO,CAAA;AAOd,MAAM,WAAW,2BAA4B,SAAQ,iBAAiB;IACpE,eAAe,CAAC,EAAE,YAAY,CAAC,mBAAmB,CAAC,CAAA;CACpD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmDG;AACH,eAAO,MAAM,sBAAsB,EAAE,KAAK,CAAC,EAAE,CAAC,2BAA2B,CAmExE,CAAA"}

package/dist/browser/client/context/in-page/index.d.ts

@@ -0,0 +1,5 @@
+export * from './InPageGatewaysContext.ts';
+export * from './InPageGatewaysState.ts';
+export * from './Provider.tsx';
+export * from './useProvidedInPageGateways.ts';
+//# sourceMappingURL=index.d.ts.map

package/dist/browser/client/context/in-page/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/client/context/in-page/index.ts"],"names":[],"mappings":"AAAA,cAAc,4BAA4B,CAAA;AAC1C,cAAc,0BAA0B,CAAA;AACxC,cAAc,gBAAgB,CAAA;AAC9B,cAAc,gCAAgC,CAAA"}

package/dist/browser/client/context/in-page/lib/buildGateway.d.ts

@@ -0,0 +1,3 @@
+import type { GatewayName, RpcTransport, SimpleXyoGateway, XyoSignerRpcSchemas } from '@xyo-network/xl1-sdk';
+export declare const buildGateway: (gatewayName: GatewayName, signerTransport?: RpcTransport<XyoSignerRpcSchemas>) => Promise<import("@xyo-network/xl1-sdk").CreatableProviderInstance<SimpleXyoGateway>>;
+//# sourceMappingURL=buildGateway.d.ts.map

package/dist/browser/client/context/in-page/lib/buildGateway.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"buildGateway.d.ts","sourceRoot":"","sources":["../../../../../../src/client/context/in-page/lib/buildGateway.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,WAAW,EACG,YAAY,EAAE,gBAAgB,EAC5C,mBAAmB,EACpB,MAAM,sBAAsB,CAAA;AAO7B,eAAO,MAAM,YAAY,GAAU,aAAa,WAAW,EAAE,kBAAkB,YAAY,CAAC,mBAAmB,CAAC,wFAkB/G,CAAA"}

package/dist/browser/client/context/in-page/lib/index.d.ts

@@ -0,0 +1,2 @@
+export * from './buildGateway.ts';
+//# sourceMappingURL=index.d.ts.map

package/dist/browser/client/context/in-page/lib/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/client/context/in-page/lib/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAA"}

package/dist/browser/client/context/in-page/useProvidedInPageGateways.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Reads the `InPageGatewaysContext` map of per-network in-page gateways.
+ * Intended for internal use by `GatewayProvider` — application code
+ * should prefer `useProvidedGateway`, which returns a single resolved
+ * gateway regardless of source.
+ *
+ * @param required - When `true` (default), throws if no
+ *   `InPageGatewaysProvider` is mounted above.
+ */
+export declare const useProvidedInPageGateways: (required?: boolean) => Omit<import("./InPageGatewaysState.ts").InPageGatewaysStateFields & {
+    provided: true;
+}, "provided"> | Omit<import("@xylabs/react-shared").NotProvidedContextExState<import("./InPageGatewaysState.ts").InPageGatewaysState>, "provided">;
+//# sourceMappingURL=useProvidedInPageGateways.d.ts.map

package/dist/browser/client/context/in-page/useProvidedInPageGateways.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useProvidedInPageGateways.d.ts","sourceRoot":"","sources":["../../../../../src/client/context/in-page/useProvidedInPageGateways.ts"],"names":[],"mappings":"AAIA;;;;;;;;GAQG;AACH,eAAO,MAAM,yBAAyB,GAAI,kBAAe;;mJAAoE,CAAA"}

package/dist/browser/client/context/index.d.ts

@@ -0,0 +1,7 @@
+export * from './GatewayContext.ts';
+export * from './GatewayProviderProps.ts';
+export * from './GatewayProviderState.ts';
+export * from './in-page/index.ts';
+export * from './providers/index.ts';
+export * from './useProvidedGateway.ts';
+//# sourceMappingURL=index.d.ts.map

package/dist/browser/client/context/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/client/context/index.ts"],"names":[],"mappings":"AAAA,cAAc,qBAAqB,CAAA;AACnC,cAAc,2BAA2B,CAAA;AACzC,cAAc,2BAA2B,CAAA;AACzC,cAAc,oBAAoB,CAAA;AAClC,cAAc,sBAAsB,CAAA;AACpC,cAAc,yBAAyB,CAAA"}

package/dist/browser/client/context/providers/GatewayProvider.d.ts

@@ -0,0 +1,47 @@
+import React from 'react';
+import type { GatewayProviderProps } from '../GatewayProviderProps.ts';
+/**
+ * Publishes the shared `GatewayContext` backed by two sources: the
+ * injected XL1 Wallet extension *and* the in-page gateways built by
+ * `InPageGatewaysProvider`. Use this provider when the host app can
+ * function without a wallet (falling back to the in-page client) but
+ * should still prefer the wallet when it is present.
+ *
+ * Required ancestry: an `InPageGatewaysProvider` must be mounted above
+ * this provider — `useProvidedInPageGateways(true)` throws if missing.
+ * If you only need a wallet-backed gateway, use `WalletGatewayProvider`
+ * instead.
+ *
+ * Source precedence for `defaultGateway`:
+ * - Wallet present and resolved (`XyoGatewayRunner`) → wallet wins; the
+ *   in-page gateway is still exposed via `gateways.inPageGateway` for
+ *   the rare consumer that needs to target it specifically.
+ * - Wallet definitively absent (`null`) → fall back to the in-page
+ *   gateway matching `gatewayName`.
+ * - Wallet still resolving (`undefined`) → leave `defaultGateway`
+ *   `undefined` so consumers render a loading state rather than
+ *   committing to the in-page fallback prematurely.
+ *
+ * The published `GatewayContextState` shape:
+ * - `defaultGateway` — resolved per the precedence above. Three-state:
+ *   `undefined` = loading, `null` is not produced by this provider
+ *   (wallet-null collapses to `gatewayFromConfig`), `XyoGateway` = ready.
+ * - `gateways.walletGateway` — raw wallet result (tri-state).
+ * - `gateways.inPageGateway` — raw in-page result for the requested
+ *   `gatewayName`, or `undefined` if no `gatewayName` was passed.
+ * - `error` — first non-null of wallet error, then in-page build error
+ *   for this `gatewayName`. Also rendered inline via `ErrorRender` above
+ *   `children` so mount-time failures surface even when no consumer
+ *   reads `error`.
+ * - `resetGatewaysFromConfig` — forwards `clearAll` from
+ *   `InPageGatewaysProvider`, letting consumers force a rebuild of the
+ *   in-page gateways (e.g. after a network or endpoint change).
+ * - `provided: true` — lets descendants detect a real provider in the
+ *   tree.
+ *
+ * `defaultGateway`, `gateways`, and the context `value` are memoized so
+ * consumers only re-render when wallet or in-page sources actually
+ * change identity.
+ */
+export declare const GatewayProvider: React.FC<GatewayProviderProps>;
+//# sourceMappingURL=GatewayProvider.d.ts.map

package/dist/browser/client/context/providers/GatewayProvider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GatewayProvider.d.ts","sourceRoot":"","sources":["../../../../../src/client/context/providers/GatewayProvider.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAkB,MAAM,OAAO,CAAA;AAItC,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,4BAA4B,CAAA;AAItE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AACH,eAAO,MAAM,eAAe,EAAE,KAAK,CAAC,EAAE,CAAC,oBAAoB,CAiE1D,CAAA"}