@parity/product-sdk-host 0.15.1 → 0.17.0

package/src/testing.ts

@@ -10,21 +10,25 @@
  * makes a default `SignerManager`, `local-storage` auto-detection, and the
  * `statement-store` / `cloud-storage` host paths testable.
  *
- * Not modeled: the PAPI `chain` JSON-RPC surface behind `getHostProvider()` —
- * there's no chain-read fake, by design; the host owns RPC selection — and the
- * `chat` / `coinPayment` / `entropy` / `notifications` / `payment` /
- * `permissions` / `resourceAllocation` / `theme` domains. Touching an unmodeled
- * domain throws a descriptive error rather than failing with `undefined is not
- * a function`.
+ * Of the `chain` domain only `getChainInfo` is modeled, so host chain discovery
+ * (and `getChainAPI()` on top of it) resolves in tests; see the `chainInfo`
+ * option. Not modeled: the rest of the PAPI `chain` JSON-RPC surface behind
+ * `getHostProvider()` — there's no chain-read fake, by design; the host owns RPC
+ * selection — and the `chat` / `coinPayment` / `entropy` / `notifications` /
+ * `payment` / `permissions` / `resourceAllocation` / `theme` domains. Touching
+ * an unmodeled domain throws a descriptive error rather than failing with
+ * `undefined is not a function`.
  *
  * @packageDocumentation
  */
 import type { ObservableLike, Observer, Subscription, TrUApiClient } from "@parity/truapi";
-import { okAsync } from "neverthrow";
+import { errAsync, okAsync } from "neverthrow";
 
-import { setTruApiClient } from "./transport.js";
+import type { HostChainIdentifier } from "./chain-discovery.js";
 
-export { setTruApiClient };
+import { type HostConnectionStatus, emitConnectionStatus, setTruApiClient } from "./transport.js";
+
+export { setTruApiClient, emitConnectionStatus };
 
 /**
  * The public surface of a generated truapi domain client. `keyof` skips private
@@ -91,10 +95,17 @@ function oneShotObservable<Item>(item: Item): ObservableLike<Item> {
  * member access throws with a pointer here, instead of the bare TypeError an
  * empty stub would give. The empty-object cast is the one concession a Proxy
  * needs; every modeled domain is checked structurally.
+ *
+ * `modeled` carries the members that _are_ implemented, for a domain where the
+ * fake covers some calls but not the whole surface.
  */
-function notModeled<D extends keyof TrUApiClient>(domain: D): PublicSurface<TrUApiClient[D]> {
-    return new Proxy({} as PublicSurface<TrUApiClient[D]>, {
-        get(_target, member) {
+function notModeled<D extends keyof TrUApiClient>(
+    domain: D,
+    modeled?: Partial<PublicSurface<TrUApiClient[D]>>,
+): PublicSurface<TrUApiClient[D]> {
+    return new Proxy((modeled ?? {}) as PublicSurface<TrUApiClient[D]>, {
+        get(target, member) {
+            if (member in target) return target[member as keyof typeof target];
             // Stay quiet for inspection probes (console.log, await-resolution).
             if (typeof member === "symbol" || member === "then") return undefined;
             throw new Error(
@@ -114,6 +125,22 @@ function preimageKey(hexValue: string): `0x${string}` {
     return `0x${(h >>> 0).toString(16).padStart(8, "0")}`;
 }
 
+/**
+ * What a fake host reports through `chain.getChainInfo`: the network id it is
+ * configured for, and a genesis hash per chain role it serves.
+ *
+ * Roles left out are answered `NotSupported`, exactly as a host that does not
+ * serve them. Use the genesis hashes the descriptors expose (e.g.
+ * `paseo_asset_hub.genesis`) if the test drives `getChainAPI()`, since the
+ * environment is derived by matching the asset hub genesis against the bundle.
+ */
+export interface FakeChainInfo {
+    /** Ecosystem the fake host claims, e.g. `"paseo"`. */
+    network: string;
+    /** Genesis hash per chain role served. */
+    chains: Partial<Record<HostChainIdentifier, `0x${string}`>>;
+}
+
 /** Options for {@link createFakeTruApiClient}. */
 export interface CreateFakeTruApiClientOptions {
     /** `account.getUserId` primary username. Default `"alice.dot"`. */
@@ -130,6 +157,12 @@ export interface CreateFakeTruApiClientOptions {
     legacyAccounts?: Array<{ publicKey: Uint8Array; name: string }>;
     /** Seed the in-memory preimage store, keyed by the `0x` preimage key. */
     preimages?: Record<string, Uint8Array>;
+    /**
+     * What `chain.getChainInfo` reports. Omit to model a host predating chain
+     * discovery: the call is refused as `Unsupported`, so `getHostChainInfo`
+     * resolves `null` and `getChainAPI` needs an explicit environment.
+     */
+    chainInfo?: FakeChainInfo;
 }
 
 /**
@@ -143,6 +176,7 @@ export function createFakeTruApiClient(options?: CreateFakeTruApiClientOptions):
     const publicKey = toHex(options?.publicKey ?? new Uint8Array(32).fill(0x11));
     const signature = toHex(options?.signature ?? new Uint8Array(64).fill(0x22));
     const chainSupported = options?.chainSupported ?? true;
+    const chainInfo = options?.chainInfo;
 
     // Real in-memory KV (hex values) so getHostLocalStorage()/createLocalKvStore() round-trip.
     const kv = new Map<string, `0x${string}`>();
@@ -193,6 +227,9 @@ export function createFakeTruApiClient(options?: CreateFakeTruApiClientOptions):
                     ringIndex: 0,
                     ringRevision: 0,
                 }),
+            registerRingVrfKey: () => okAsync(publicKey),
+            listRingVrfKeys: () => okAsync([]),
+            ringVrfSign: () => okAsync(signature),
             signVrf: () => okAsync({ preOutput: publicKey, proof: signature }),
             connectionStatusSubscribe: () => inertObservable(),
         },
@@ -226,7 +263,20 @@ export function createFakeTruApiClient(options?: CreateFakeTruApiClientOptions):
                 return okAsync(key);
             },
         },
-        chain: notModeled("chain"),
+        // Only `getChainInfo` is modeled; the rest of the domain still throws.
+        chain: notModeled("chain", {
+            getChainInfo: ({ chain }) => {
+                if (!chainInfo) return errAsync({ tag: "Unsupported" } as const);
+                const genesisHash = chainInfo.chains[chain];
+                if (!genesisHash) {
+                    return errAsync({
+                        tag: "Domain",
+                        value: { tag: "V1", value: { tag: "NotSupported" } },
+                    } as const);
+                }
+                return okAsync({ network: chainInfo.network, chain, genesisHash });
+            },
+        }),
         chat: notModeled("chat"),
         coinPayment: notModeled("coinPayment"),
         entropy: notModeled("entropy"),
@@ -254,6 +304,12 @@ type TestFinishedHook = (fn: () => void) => void;
 export interface FakeHost extends Disposable {
     /** The injected fake client (also what `getTruApi()` returns). */
     client: TrUApiClient;
+    /**
+     * Push a status to `subscribeConnectionStatus` subscribers, so a product's
+     * reconnecting / offline UI can be exercised. `dispose()` already reports
+     * `"disconnected"`; use this to drive the states in between.
+     */
+    emitConnectionStatus(status: HostConnectionStatus): void;
     /** Clear the override. Idempotent; safe to call more than once. */
     dispose(): void;
     /** `using host = createFakeHost()` restores the real client at scope end. */
@@ -305,6 +361,7 @@ export function createFakeHost(options?: CreateFakeTruApiClientOptions): FakeHos
 
     return {
         client,
+        emitConnectionStatus,
         dispose,
         [Symbol.dispose]: dispose,
     };
@@ -317,6 +374,7 @@ if (import.meta.vitest) {
         "./container.js"
     );
     const { getAccountsProvider } = await import("./accounts.js");
+    const { getHostChainInfo } = await import("./chain-discovery.js");
     const { getPreimageManager } = await import("./truapi.js");
 
     const lookupOnce = (
@@ -360,6 +418,50 @@ if (import.meta.vitest) {
             expect(userId?.primaryUsername).toBe("carol.dot");
         });
 
+        test("signVrf round-trips through the real adapter", async () => {
+            // The fake is the only way a product can test a VRF flow: there is no
+            // dev-provider implementation and the e2e test host does not expose the
+            // call. So the fake's wire shape has to stay decodable by the adapter.
+            createFakeHost();
+            const accounts = await getAccountsProvider();
+            const signature = await accounts
+                ?.signVrf({ dotNsIdentifier: "app.dot" }, new Uint8Array([1]), [
+                    { label: new Uint8Array([2]), value: new Uint8Array([3]) },
+                ])
+                .match(
+                    (s) => s,
+                    () => null,
+                );
+            expect(signature?.preOutput).toBeInstanceOf(Uint8Array);
+            expect(signature?.proof).toBeInstanceOf(Uint8Array);
+            expect(signature?.preOutput).toHaveLength(32);
+            expect(signature?.proof).toHaveLength(64);
+        });
+
+        test("chain discovery is refused by default, so a legacy host is modeled", async () => {
+            createFakeHost();
+            // Refused, not unmodeled: a bare `getChainAPI("paseo")` in a consumer
+            // test must not warn about the fake on every call.
+            expect(await getHostChainInfo(["AssetHub"])).toBeNull();
+        });
+
+        test("chainInfo drives discovery, with unserved roles left out", async () => {
+            createFakeHost({
+                chainInfo: { network: "paseo", chains: { AssetHub: "0xaa", Bulletin: "0xbb" } },
+            });
+            expect(await getHostChainInfo(["AssetHub", "Bulletin", "People"])).toEqual({
+                network: "paseo",
+                chains: { AssetHub: "0xaa", Bulletin: "0xbb" },
+            });
+        });
+
+        test("the rest of the chain domain still reports itself unmodeled", async () => {
+            const host = createFakeHost();
+            expect(() => (host.client.chain as { chainName?: unknown }).chainName).toThrow(
+                /not modeled by the fake/,
+            );
+        });
+
         test("statement store resolves", async () => {
             createFakeHost();
             expect(await getStatementStore()).not.toBeNull();

package/src/transport.ts

@@ -3,18 +3,21 @@
 /**
  * Access to the in-house TruAPI client (`@parity/truapi`) for the host package.
  *
- * Environment detection and the lazily-built, cached client come from
- * `@parity/truapi/sandbox`; this module layers the product-sdk-specific glue on
- * top — an async {@link getClient} accessor and {@link subscribeWithInterrupt},
- * which adapts a truapi stream into the host's {@link HostSubscription} shape.
+ * Environment detection, the lazily-built cached client, and the connection-status
+ * signal come from `@parity/truapi/sandbox`; this module layers the
+ * product-sdk-specific glue on top — an async {@link getClient} accessor,
+ * {@link subscribeConnectionStatus}, and {@link subscribeWithInterrupt}, which
+ * adapts a truapi stream into the host's {@link HostSubscription} shape.
  *
  * @module
  */
 
 import type { ObservableLike, TrUApiClient } from "@parity/truapi";
 import {
+    type ConnectionStatus,
     getClientSync as sandboxGetClientSync,
     isCorrectEnvironment as sandboxIsCorrectEnvironment,
+    subscribeConnectionStatus as sandboxSubscribeConnectionStatus,
 } from "@parity/truapi/sandbox";
 
 import type { HostSubscription } from "./types.js";
@@ -30,6 +33,11 @@ export interface TransportSubscription extends HostSubscription {
 // no-ops there.
 let clientOverride: TrUApiClient | null = null;
 
+// Status subscribers registered here rather than only in the sandbox, so that
+// flipping the test seam is an *event*. The sandbox tracks only the client it
+// built itself, so it cannot know an injected client appeared or went away.
+const localStatusListeners = new Set<(status: HostConnectionStatus) => void>();
+
 function isProductionBuild(): boolean {
     try {
         // Must stay a plain `process.env.NODE_ENV` member expression: bundlers
@@ -51,6 +59,9 @@ function isProductionBuild(): boolean {
  * Calling this in a production build silently reroutes every host accessor to
  * the injected client, so we warn — it almost always means a `/testing` import
  * leaked into a production path.
+ *
+ * Injecting or clearing notifies {@link subscribeConnectionStatus} subscribers,
+ * so a product's "host lost" path can be exercised by disposing the fake host.
  */
 export function setTruApiClient(client: TrUApiClient | null): void {
     if (client !== null && isProductionBuild()) {
@@ -58,7 +69,11 @@ export function setTruApiClient(client: TrUApiClient | null): void {
             "[product-sdk] setTruApiClient() was called in a production build. This is a test-only seam from @parity/product-sdk-host/testing; a leaked import will silently reroute all host access to the injected client.",
         );
     }
+    const wasOverridden = clientOverride !== null;
     clientOverride = client;
+    if (wasOverridden !== (client !== null)) {
+        notifyLocalStatusListeners(client !== null ? "connected" : "disconnected");
+    }
 }
 
 /**
@@ -85,6 +100,103 @@ export async function getClient(): Promise<TrUApiClient | null> {
     return getClientSync();
 }
 
+/**
+ * Connection lifecycle of the host channel: `"connecting"` while the client waits
+ * for the host, `"connected"` once the channel is established, `"disconnected"`
+ * outside a host container or after the channel closes.
+ *
+ * Not the same concept as `@parity/product-sdk-signer`'s identically-shaped
+ * `ConnectionStatus`, which tracks a signer provider rather than the transport.
+ */
+export type HostConnectionStatus = ConnectionStatus;
+
+/**
+ * Correct one defect in the sandbox's status signal: `@parity/truapi` never clears
+ * its cached client when the pipe closes, so a subscriber arriving after a
+ * disconnect re-derives `"connecting"` from the dead client — and because the
+ * sandbox fans every change out to all listeners, that rewrites everyone's state
+ * with no way back. Hold `"disconnected"` until a real `"connected"` arrives.
+ *
+ * Applies to sandbox-sourced statuses only. A status pushed by the test seam is
+ * deliberate and passes through, so a fake host can still drive a reconnect.
+ *
+ * Outstanding upstream, not tied to the version we happen to be on: `sandbox.js`
+ * is byte-identical from 0.7.0 through 0.9.0 (npm latest) and still unfixed on
+ * `paritytech/host-rust-core` main, the repo formerly named truapi. Remove once
+ * it clears the cached client on close.
+ */
+function latchDisconnected(
+    previous: HostConnectionStatus | null,
+    next: HostConnectionStatus,
+): HostConnectionStatus {
+    return next === "connecting" && previous === "disconnected" ? "disconnected" : next;
+}
+
+function notifyLocalStatusListeners(status: HostConnectionStatus): void {
+    // Iterate a snapshot: a listener that unsubscribes itself, or re-enters
+    // `setTruApiClient`, must not mutate the set mid-loop.
+    for (const listener of [...localStatusListeners]) listener(status);
+}
+
+/**
+ * Test-only: push `status` to every {@link subscribeConnectionStatus} subscriber,
+ * so a product can exercise its reconnecting / offline UI. The host-side
+ * counterpart of `@parity/product-sdk-signer`'s `FakeSignerProvider.emitStatus`.
+ * Exposed through `@parity/product-sdk-host/testing`, not the main entry.
+ */
+export function emitConnectionStatus(status: HostConnectionStatus): void {
+    if (isProductionBuild()) {
+        console.warn(
+            "[product-sdk] emitConnectionStatus() was called in a production build. This is a test-only seam from @parity/product-sdk-host/testing; a leaked import will report a fabricated connection status to real subscribers.",
+        );
+    }
+    notifyLocalStatusListeners(status);
+}
+
+/**
+ * Subscribe to host-channel connection status. The callback fires synchronously
+ * with the current status and again on every change; the returned function
+ * unsubscribes. Repeats of the status you already have are suppressed.
+ *
+ * This is the **transport** channel. For the host's account-level connection —
+ * what drives `@parity/product-sdk-signer`'s `ConnectionStatus` — use
+ * `AccountsProvider.subscribeAccountConnectionStatus` instead.
+ *
+ * Subscribing is not passive: outside an established channel the first subscribe
+ * builds the client and provider, so this can be what constructs the transport.
+ *
+ * Honours the `setTruApiClient` seam — an injected client is connected by
+ * definition, and injecting or clearing one notifies live subscribers.
+ */
+export function subscribeConnectionStatus(
+    callback: (status: HostConnectionStatus) => void,
+): () => void {
+    let last: HostConnectionStatus | null = null;
+
+    // One wrapped callback for both sources, so `last` stays coherent: the seam
+    // and the sandbox must not each keep their own idea of what was delivered.
+    const deliver = (status: HostConnectionStatus, fromSandbox: boolean): void => {
+        const next = fromSandbox ? latchDisconnected(last, status) : status;
+        if (next === last) return;
+        last = next;
+        callback(next);
+    };
+
+    const onLocal = (status: HostConnectionStatus) => deliver(status, false);
+    localStatusListeners.add(onLocal);
+
+    if (clientOverride !== null) {
+        onLocal("connected");
+        return () => void localStatusListeners.delete(onLocal);
+    }
+
+    const unsubscribeSandbox = sandboxSubscribeConnectionStatus((status) => deliver(status, true));
+    return () => {
+        localStatusListeners.delete(onLocal);
+        unsubscribeSandbox();
+    };
+}
+
 /**
  * Adapt a truapi `ObservableLike` stream into the host's callback-style
  * {@link HostSubscription} (`unsubscribe` + `onInterrupt`). `onNext` fires for
@@ -163,6 +275,118 @@ if (import.meta.vitest) {
         }
     });
 
+    test("subscribeConnectionStatus reports disconnected outside a container", () => {
+        const statuses: HostConnectionStatus[] = [];
+
+        const unsubscribe = subscribeConnectionStatus((status) => statuses.push(status));
+
+        expect(statuses).toEqual(["disconnected"]);
+        unsubscribe();
+    });
+
+    test("subscribeConnectionStatus reports connected for an injected client", () => {
+        setTruApiClient({} as TrUApiClient);
+        const statuses: HostConnectionStatus[] = [];
+
+        const unsubscribe = subscribeConnectionStatus((status) => statuses.push(status));
+
+        // The sandbox only tracks the client it built itself, so without the
+        // override branch this would report "disconnected" while every other
+        // accessor resolved the injected client.
+        expect(statuses).toEqual(["connected"]);
+        unsubscribe();
+    });
+
+    test("disposing the injected client notifies live subscribers", () => {
+        setTruApiClient({} as TrUApiClient);
+        const statuses: HostConnectionStatus[] = [];
+        const unsubscribe = subscribeConnectionStatus((status) => statuses.push(status));
+
+        setTruApiClient(null);
+
+        expect(statuses).toEqual(["connected", "disconnected"]);
+        unsubscribe();
+    });
+
+    test("injecting a client notifies subscribers that started without one", () => {
+        const statuses: HostConnectionStatus[] = [];
+        const unsubscribe = subscribeConnectionStatus((status) => statuses.push(status));
+
+        setTruApiClient({} as TrUApiClient);
+
+        expect(statuses).toEqual(["disconnected", "connected"]);
+        unsubscribe();
+    });
+
+    test("unsubscribe stops seam notifications", () => {
+        setTruApiClient({} as TrUApiClient);
+        const statuses: HostConnectionStatus[] = [];
+        const unsubscribe = subscribeConnectionStatus((status) => statuses.push(status));
+
+        unsubscribe();
+        setTruApiClient(null);
+
+        expect(statuses).toEqual(["connected"]);
+        expect(localStatusListeners.size).toBe(0);
+    });
+
+    test("emitConnectionStatus drives transitions, including a reconnect", () => {
+        setTruApiClient({} as TrUApiClient);
+        const statuses: HostConnectionStatus[] = [];
+        const unsubscribe = subscribeConnectionStatus((status) => statuses.push(status));
+
+        emitConnectionStatus("disconnected");
+        // A seam-pushed "connecting" after "disconnected" is deliberate, so it must
+        // survive the sandbox latch — otherwise no test could drive a reconnect.
+        emitConnectionStatus("connecting");
+        emitConnectionStatus("connected");
+
+        expect(statuses).toEqual(["connected", "disconnected", "connecting", "connected"]);
+        unsubscribe();
+    });
+
+    test("repeats of the current status are suppressed", () => {
+        setTruApiClient({} as TrUApiClient);
+        const statuses: HostConnectionStatus[] = [];
+        const unsubscribe = subscribeConnectionStatus((status) => statuses.push(status));
+
+        emitConnectionStatus("connected");
+        emitConnectionStatus("connected");
+
+        expect(statuses).toEqual(["connected"]);
+        unsubscribe();
+    });
+
+    test("a listener that unsubscribes itself mid-notification is safe", () => {
+        setTruApiClient({} as TrUApiClient);
+        const statuses: HostConnectionStatus[] = [];
+        const handle: { unsubscribe?: () => void } = {};
+        handle.unsubscribe = subscribeConnectionStatus((status) => {
+            statuses.push(status);
+            handle.unsubscribe?.();
+        });
+
+        setTruApiClient(null);
+
+        expect(statuses).toEqual(["connected", "disconnected"]);
+        expect(localStatusListeners.size).toBe(0);
+    });
+
+    // The sandbox latch can't be driven through the public surface — it needs a
+    // real provider close — so the correction is pinned as a pure function.
+    test("latchDisconnected holds disconnected through the stale-cache connecting", () => {
+        expect(latchDisconnected("disconnected", "connecting")).toBe("disconnected");
+    });
+
+    test("latchDisconnected passes every other transition through", () => {
+        expect(latchDisconnected(null, "disconnected")).toBe("disconnected");
+        expect(latchDisconnected(null, "connecting")).toBe("connecting");
+        expect(latchDisconnected("connecting", "connected")).toBe("connected");
+        expect(latchDisconnected("connected", "disconnected")).toBe("disconnected");
+        // A genuine reconnect still gets through once the channel re-establishes.
+        expect(latchDisconnected("connected", "connecting")).toBe("connecting");
+    });
+
     test("subscribeWithInterrupt preserves the transport subscription id", () => {
         const observable = {
             subscribe: () => ({

package/src/truapi.ts

@@ -183,8 +183,9 @@ export async function createHostPreimageManager(): Promise<PreimageManager | nul
 // Resource-allocation / permission types, re-exported verbatim from
 // `@parity/truapi` (imported above for the local signatures):
 // - `AllocatableResource` — resource types requestable via `requestResourceAllocation`.
-//   Since truapi 0.6.0 its `SmartContractAllowance` variant carries the tagged
-//   `DerivationIndex` selector (`{ tag: "Left", value: number }` for a plain index).
+//   Its `SmartContractAllowance` variant carries the tagged `DerivationIndex`
+//   selector (`{ tag: "Index", value: number }` for a plain index, `{ tag:
+//   "Raw", value: HexString }` for a raw 32-byte index).
 // - `AllocationOutcome` — per-resource outcome, the string union
 //   `"Allocated" | "Rejected" | "NotAvailable"` (RFC-10).
 // - `RemotePermission` — permission the dapp asks the host to grant via `requestPermission`.

package/dist/chunk-GDXSV7JV.js

@@ -1,50 +0,0 @@
-import { isCorrectEnvironment as isCorrectEnvironment$1, getClientSync as getClientSync$1 } from '@parity/truapi/sandbox';
-
-// src/transport.ts
-var clientOverride = null;
-function isProductionBuild() {
-  try {
-    return process.env.NODE_ENV === "production";
-  } catch {
-    return false;
-  }
-}
-function setTruApiClient(client) {
-  if (client !== null && isProductionBuild()) {
-    console.warn(
-      "[product-sdk] setTruApiClient() was called in a production build. This is a test-only seam from @parity/product-sdk-host/testing; a leaked import will silently reroute all host access to the injected client."
-    );
-  }
-  clientOverride = client;
-}
-function getClientSync() {
-  return clientOverride ?? getClientSync$1();
-}
-function isCorrectEnvironment() {
-  return clientOverride !== null || isCorrectEnvironment$1();
-}
-async function getClient() {
-  return getClientSync();
-}
-function subscribeWithInterrupt(observable, onNext) {
-  let interruptCallback;
-  const sub = observable.subscribe({
-    next: onNext,
-    error: (reason) => interruptCallback?.(reason),
-    complete: () => interruptCallback?.()
-  });
-  return {
-    subscriptionId: sub.subscriptionId,
-    unsubscribe: () => sub.unsubscribe(),
-    onInterrupt: (callback) => {
-      interruptCallback = callback;
-      return () => {
-        if (interruptCallback === callback) interruptCallback = void 0;
-      };
-    }
-  };
-}
-
-export { getClient, isCorrectEnvironment, setTruApiClient, subscribeWithInterrupt };
-//# sourceMappingURL=chunk-GDXSV7JV.js.map
-//# sourceMappingURL=chunk-GDXSV7JV.js.map

package/dist/chunk-GDXSV7JV.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/transport.ts"],"names":["sandboxGetClientSync","sandboxIsCorrectEnvironment"],"mappings":";;;AA8BA,IAAI,cAAA,GAAsC,IAAA;AAE1C,SAAS,iBAAA,GAA6B;AAClC,EAAA,IAAI;AAIA,IAAA,OAAO,OAAA,CAAQ,IAAI,QAAA,KAAa,YAAA;AAAA,EACpC,CAAA,CAAA,MAAQ;AAEJ,IAAA,OAAO,KAAA;AAAA,EACX;AACJ;AAYO,SAAS,gBAAgB,MAAA,EAAmC;AAC/D,EAAA,IAAI,MAAA,KAAW,IAAA,IAAQ,iBAAA,EAAkB,EAAG;AACxC,IAAA,OAAA,CAAQ,IAAA;AAAA,MACJ;AAAA,KACJ;AAAA,EACJ;AACA,EAAA,cAAA,GAAiB,MAAA;AACrB;AAMO,SAAS,aAAA,GAAqC;AACjD,EAAA,OAAO,kBAAkBA,eAAA,EAAqB;AAClD;AAMO,SAAS,oBAAA,GAAgC;AAC5C,EAAA,OAAO,cAAA,KAAmB,QAAQC,sBAAA,EAA4B;AAClE;AAMA,eAAsB,SAAA,GAA0C;AAC5D,EAAA,OAAO,aAAA,EAAc;AACzB;AAUO,SAAS,sBAAA,CACZ,YACA,MAAA,EACqB;AACrB,EAAA,IAAI,iBAAA;AACJ,EAAA,MAAM,GAAA,GAAM,WAAW,SAAA,CAAU;AAAA,IAC7B,IAAA,EAAM,MAAA;AAAA,IACN,KAAA,EAAO,CAAC,MAAA,KAAW,iBAAA,GAAoB,MAAM,CAAA;AAAA,IAC7C,QAAA,EAAU,MAAM,iBAAA;AAAoB,GACvC,CAAA;AACD,EAAA,OAAO;AAAA,IACH,gBAAgB,GAAA,CAAI,cAAA;AAAA,IACpB,WAAA,EAAa,MAAM,GAAA,CAAI,WAAA,EAAY;AAAA,IACnC,WAAA,EAAa,CAAC,QAAA,KAAa;AACvB,MAAA,iBAAA,GAAoB,QAAA;AACpB,MAAA,OAAO,MAAM;AACT,QAAA,IAAI,iBAAA,KAAsB,UAAU,iBAAA,GAAoB,MAAA;AAAA,MAC5D,CAAA;AAAA,IACJ;AAAA,GACJ;AACJ","file":"chunk-GDXSV7JV.js","sourcesContent":["// Copyright 2026 Parity Technologies (UK) Ltd.\n// SPDX-License-Identifier: Apache-2.0\n/**\n * Access to the in-house TruAPI client (`@parity/truapi`) for the host package.\n *\n * Environment detection and the lazily-built, cached client come from\n * `@parity/truapi/sandbox`; this module layers the product-sdk-specific glue on\n * top — an async {@link getClient} accessor and {@link subscribeWithInterrupt},\n * which adapts a truapi stream into the host's {@link HostSubscription} shape.\n *\n * @module\n */\n\nimport type { ObservableLike, TrUApiClient } from \"@parity/truapi\";\nimport {\n    getClientSync as sandboxGetClientSync,\n    isCorrectEnvironment as sandboxIsCorrectEnvironment,\n} from \"@parity/truapi/sandbox\";\n\nimport type { HostSubscription } from \"./types.js\";\n\n/** A {@link HostSubscription} carrying the transport-assigned subscription id. */\nexport interface TransportSubscription extends HostSubscription {\n    readonly subscriptionId: string;\n}\n\n// Test-only override. When set — via `setTruApiClient`, exposed through\n// `@parity/product-sdk-host/testing` — every host accessor resolves this client\n// instead of the sandbox one. `null` in production, so the branches below are\n// no-ops there.\nlet clientOverride: TrUApiClient | null = null;\n\nfunction isProductionBuild(): boolean {\n    try {\n        // Must stay a plain `process.env.NODE_ENV` member expression: bundlers\n        // (Vite, esbuild, webpack) substitute it textually, which is how this\n        // check works in browser builds where `process` doesn't exist.\n        return process.env.NODE_ENV === \"production\";\n    } catch {\n        // No `process` and no bundler define — can't tell, stay quiet.\n        return false;\n    }\n}\n\n/**\n * Test-only seam: force {@link getClient} / {@link getClientSync} to return\n * `client`, and {@link isCorrectEnvironment} to report `true`. Pass `null` to\n * restore normal detection. Exposed through `@parity/product-sdk-host/testing`,\n * not the package's main entry.\n *\n * Calling this in a production build silently reroutes every host accessor to\n * the injected client, so we warn — it almost always means a `/testing` import\n * leaked into a production path.\n */\nexport function setTruApiClient(client: TrUApiClient | null): void {\n    if (client !== null && isProductionBuild()) {\n        console.warn(\n            \"[product-sdk] setTruApiClient() was called in a production build. This is a test-only seam from @parity/product-sdk-host/testing; a leaked import will silently reroute all host access to the injected client.\",\n        );\n    }\n    clientOverride = client;\n}\n\n/**\n * Synchronous TruAPI client accessor. Returns the injected test client when one\n * is set, otherwise the sandbox client (`null` outside a host container).\n */\nexport function getClientSync(): TrUApiClient | null {\n    return clientOverride ?? sandboxGetClientSync();\n}\n\n/**\n * Host-container detection. `true` when a test client is injected, otherwise the\n * sandbox heuristic (iframe / webview marker / injected message port).\n */\nexport function isCorrectEnvironment(): boolean {\n    return clientOverride !== null || sandboxIsCorrectEnvironment();\n}\n\n/**\n * Get the TruAPI client. Returns `null` outside a host container. Async wrapper\n * over {@link getClientSync} for the host wrappers that already `await` it.\n */\nexport async function getClient(): Promise<TrUApiClient | null> {\n    return getClientSync();\n}\n\n/**\n * Adapt a truapi `ObservableLike` stream into the host's callback-style\n * {@link HostSubscription} (`unsubscribe` + `onInterrupt`). `onNext` fires for\n * each item; the registered `onInterrupt` callback fires when the host ends the\n * subscription server-side — which the generated client surfaces as either\n * `complete` (a host interrupt frame) or `error` (transport close). Shared by\n * the statement-store and preimage adapters, which both expose this shape.\n */\nexport function subscribeWithInterrupt<Item, Reason = never>(\n    observable: ObservableLike<Item, Reason>,\n    onNext: (item: Item) => void,\n): TransportSubscription {\n    let interruptCallback: ((reason?: unknown) => void) | undefined;\n    const sub = observable.subscribe({\n        next: onNext,\n        error: (reason) => interruptCallback?.(reason),\n        complete: () => interruptCallback?.(),\n    });\n    return {\n        subscriptionId: sub.subscriptionId,\n        unsubscribe: () => sub.unsubscribe(),\n        onInterrupt: (callback) => {\n            interruptCallback = callback;\n            return () => {\n                if (interruptCallback === callback) interruptCallback = undefined;\n            };\n        },\n    };\n}\n\nif (import.meta.vitest) {\n    const { test, expect, afterEach } = import.meta.vitest;\n\n    afterEach(() => setTruApiClient(null));\n\n    // Environment detection and client building are covered by `@parity/truapi`'s\n    // own sandbox tests; here we only assert the local glue degrades outside a\n    // host container.\n    test(\"getClientSync returns null outside a container\", () => {\n        expect(getClientSync()).toBeNull();\n    });\n\n    test(\"getClient resolves null outside a container\", async () => {\n        expect(await getClient()).toBeNull();\n    });\n\n    test(\"setTruApiClient overrides the client and container detection\", async () => {\n        const fake = {} as TrUApiClient;\n        setTruApiClient(fake);\n        expect(getClientSync()).toBe(fake);\n        expect(await getClient()).toBe(fake);\n        expect(isCorrectEnvironment()).toBe(true);\n\n        setTruApiClient(null);\n        expect(getClientSync()).toBeNull();\n        expect(isCorrectEnvironment()).toBe(false);\n    });\n\n    test(\"setTruApiClient warns when injecting in a production build\", () => {\n        const original = process.env.NODE_ENV;\n        const warnings: string[] = [];\n        const realWarn = console.warn;\n        console.warn = (...args: unknown[]) => void warnings.push(String(args[0]));\n        try {\n            process.env.NODE_ENV = \"production\";\n            setTruApiClient({} as TrUApiClient);\n            expect(warnings).toHaveLength(1);\n            expect(warnings[0]).toContain(\"production build\");\n\n            // Clearing the override must not warn.\n            setTruApiClient(null);\n            expect(warnings).toHaveLength(1);\n        } finally {\n            console.warn = realWarn;\n            process.env.NODE_ENV = original;\n        }\n    });\n\n    test(\"subscribeWithInterrupt preserves the transport subscription id\", () => {\n        const observable = {\n            subscribe: () => ({\n                subscriptionId: \"p:17\",\n                unsubscribe: () => {},\n            }),\n            [Symbol.observable]() {\n                return this;\n            },\n        } as ObservableLike<never>;\n\n        const subscription = subscribeWithInterrupt(observable, () => {});\n\n        expect(subscription.subscriptionId).toBe(\"p:17\");\n    });\n}\n"]}

package/dist/transport-B0cdhwrp.d.ts

@@ -1,31 +0,0 @@
-import { TrUApiClient } from '@parity/truapi';
-
-/**
- * Access to the in-house TruAPI client (`@parity/truapi`) for the host package.
- *
- * Environment detection and the lazily-built, cached client come from
- * `@parity/truapi/sandbox`; this module layers the product-sdk-specific glue on
- * top — an async {@link getClient} accessor and {@link subscribeWithInterrupt},
- * which adapts a truapi stream into the host's {@link HostSubscription} shape.
- *
- * @module
- */
-
-/**
- * Test-only seam: force {@link getClient} / {@link getClientSync} to return
- * `client`, and {@link isCorrectEnvironment} to report `true`. Pass `null` to
- * restore normal detection. Exposed through `@parity/product-sdk-host/testing`,
- * not the package's main entry.
- *
- * Calling this in a production build silently reroutes every host accessor to
- * the injected client, so we warn — it almost always means a `/testing` import
- * leaked into a production path.
- */
-declare function setTruApiClient(client: TrUApiClient | null): void;
-/**
- * Host-container detection. `true` when a test client is injected, otherwise the
- * sandbox heuristic (iframe / webview marker / injected message port).
- */
-declare function isCorrectEnvironment(): boolean;
-
-export { isCorrectEnvironment as i, setTruApiClient as s };