@iota-uz/sdk 0.6.1 → 0.8.0

package/README.md

@@ -4,11 +4,14 @@ This is the single public JavaScript distribution for iota-sdk. Its bounded
 subpath APIs are built from separate internal workspace modules:
 
 - `@iota-uz/sdk/client-host`
+- `@iota-uz/sdk/solid`
+- `@iota-uz/sdk/styles.css`
 - `@iota-uz/sdk/lens`
 - `@iota-uz/sdk/lens/styles.css`
 - `@iota-uz/sdk/identity`
 
 Version 0.5 is a clean break: legacy root, BiChat, applet, Tailwind, and asset
-exports are intentionally absent. React and ReactDOM are peer dependencies;
+exports are intentionally absent. Solid is the standard client-route renderer;
+React and ReactDOM remain optional peers for migration compatibility;
 Lens implementation dependencies are contained in lazy Lens chunks and are not
 loaded by client-host imports.

package/dist/client-host/bootstrap.d.ts

@@ -0,0 +1,41 @@
+export declare const CLIENT_BOOTSTRAP_VERSION = "1.0.0";
+export declare class ClientHostProtocolError extends Error {
+    readonly expected: string;
+    readonly actual: string;
+    constructor(expected: string, actual: string, contract?: string);
+}
+export interface ClientRouteContext<TInitial = unknown> {
+    bootstrapVersion?: string;
+    protocolVersion: string;
+    sdkReleaseVersion: string;
+    sdkCommit: string;
+    initial: TInitial;
+    theme: 'light' | 'dark';
+    csrf?: string;
+    route?: {
+        id: string;
+        path: string;
+        featureId: string;
+    };
+    session?: {
+        csrf?: string;
+        expiresAt?: string;
+        refreshEndpoint?: string;
+        reauthUrl?: string;
+    };
+    locale?: {
+        language: string;
+        messages: Readonly<Record<string, string>>;
+    };
+    user?: unknown;
+    tenant?: unknown;
+    permissions?: readonly string[];
+    services?: {
+        rpc?: string;
+        telemetry?: string;
+    };
+}
+export declare function assertClientHostProtocol(actual: string): void;
+export declare function assertClientBootstrap(context: unknown, requireVersion?: boolean): asserts context is ClientRouteContext;
+export declare function readClientBootstrap<TInitial = unknown>(document: Document, elementID?: string): ClientRouteContext<TInitial>;
+//# sourceMappingURL=bootstrap.d.ts.map

package/dist/client-host/bootstrap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bootstrap.d.ts","sourceRoot":"","sources":["../src/bootstrap.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,wBAAwB,UAAU,CAAA;AAE/C,qBAAa,uBAAwB,SAAQ,KAAK;IACpC,QAAQ,CAAC,QAAQ,EAAE,MAAM;IAAE,QAAQ,CAAC,MAAM,EAAE,MAAM;gBAAzC,QAAQ,EAAE,MAAM,EAAW,MAAM,EAAE,MAAM,EAAE,QAAQ,SAAyB;CAIlG;AAED,MAAM,WAAW,kBAAkB,CAAC,QAAQ,GAAG,OAAO;IACpD,gBAAgB,CAAC,EAAE,MAAM,CAAA;IACzB,eAAe,EAAE,MAAM,CAAA;IACvB,iBAAiB,EAAE,MAAM,CAAA;IACzB,SAAS,EAAE,MAAM,CAAA;IACjB,OAAO,EAAE,QAAQ,CAAA;IACjB,KAAK,EAAE,OAAO,GAAG,MAAM,CAAA;IACvB,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,KAAK,CAAC,EAAE;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAE,CAAA;IACvD,OAAO,CAAC,EAAE;QAAE,IAAI,CAAC,EAAE,MAAM,CAAC;QAAC,SAAS,CAAC,EAAE,MAAM,CAAC;QAAC,eAAe,CAAC,EAAE,MAAM,CAAC;QAAC,SAAS,CAAC,EAAE,MAAM,CAAA;KAAE,CAAA;IAC7F,MAAM,CAAC,EAAE;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAA;KAAE,CAAA;IACzE,IAAI,CAAC,EAAE,OAAO,CAAA;IACd,MAAM,CAAC,EAAE,OAAO,CAAA;IAChB,WAAW,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;IAC/B,QAAQ,CAAC,EAAE;QAAE,GAAG,CAAC,EAAE,MAAM,CAAC;QAAC,SAAS,CAAC,EAAE,MAAM,CAAA;KAAE,CAAA;CAChD;AAeD,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAI7D;AAED,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,OAAO,EAAE,cAAc,UAAO,GAAG,OAAO,CAAC,OAAO,IAAI,kBAAkB,CAwBpH;AAED,wBAAgB,mBAAmB,CAAC,QAAQ,GAAG,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,SAAS,SAAwB,GAAG,kBAAkB,CAAC,QAAQ,CAAC,CAM3I"}

package/dist/client-host/bootstrap.js

@@ -0,0 +1,63 @@
+import { assertSDKIdentity } from './identity';
+import { CLIENT_HOST_PROTOCOL_VERSION } from './protocol';
+export const CLIENT_BOOTSTRAP_VERSION = '1.0.0';
+export class ClientHostProtocolError extends Error {
+    expected;
+    actual;
+    constructor(expected, actual, contract = 'client host protocol') {
+        super(`${contract} ${actual} is incompatible with ${expected}`);
+        this.expected = expected;
+        this.actual = actual;
+        this.name = 'ClientHostProtocolError';
+    }
+}
+function major(version) { return version.split('.', 1)[0] ?? ''; }
+function invalidBootstrapField(field, value) {
+    const actual = value === null ? 'null' : typeof value;
+    throw new ClientHostProtocolError('string', actual, `client bootstrap ${field}`);
+}
+function requiredString(context, field) {
+    const value = context[field];
+    if (typeof value !== 'string')
+        invalidBootstrapField(field, value);
+    return value;
+}
+export function assertClientHostProtocol(actual) {
+    if (major(actual) !== major(CLIENT_HOST_PROTOCOL_VERSION)) {
+        throw new ClientHostProtocolError(CLIENT_HOST_PROTOCOL_VERSION, actual);
+    }
+}
+export function assertClientBootstrap(context, requireVersion = true) {
+    if (!context || typeof context !== 'object' || Array.isArray(context)) {
+        throw new ClientHostProtocolError(CLIENT_BOOTSTRAP_VERSION, context === null ? 'null' : typeof context, 'client bootstrap');
+    }
+    const payload = context;
+    const protocolVersion = requiredString(payload, 'protocolVersion');
+    const sdkReleaseVersion = requiredString(payload, 'sdkReleaseVersion');
+    const sdkCommit = requiredString(payload, 'sdkCommit');
+    if (!Object.hasOwn(payload, 'initial'))
+        invalidBootstrapField('initial', undefined);
+    if (payload.theme !== 'light' && payload.theme !== 'dark')
+        invalidBootstrapField('theme', payload.theme);
+    if (payload.bootstrapVersion !== undefined && typeof payload.bootstrapVersion !== 'string') {
+        invalidBootstrapField('bootstrapVersion', payload.bootstrapVersion);
+    }
+    assertClientHostProtocol(protocolVersion);
+    assertSDKIdentity({
+        releaseVersion: sdkReleaseVersion,
+        sourceCommit: sdkCommit,
+        protocolVersion,
+    });
+    const bootstrapVersion = payload.bootstrapVersion;
+    if ((requireVersion || bootstrapVersion !== undefined) && major(bootstrapVersion ?? '') !== major(CLIENT_BOOTSTRAP_VERSION)) {
+        throw new ClientHostProtocolError(CLIENT_BOOTSTRAP_VERSION, bootstrapVersion ?? 'missing', 'client bootstrap');
+    }
+}
+export function readClientBootstrap(document, elementID = 'iota-client-context') {
+    const element = document.getElementById(elementID);
+    if (!element?.textContent)
+        throw new ClientHostProtocolError(CLIENT_BOOTSTRAP_VERSION, 'missing', 'client bootstrap');
+    const context = JSON.parse(element.textContent);
+    assertClientBootstrap(context);
+    return context;
+}

package/dist/client-host/draft.d.ts

@@ -0,0 +1,22 @@
+import { type SetStoreFunction, type Store } from 'solid-js/store';
+import { type HostError } from './errors';
+import type { NavigationService } from './navigation';
+export interface DraftOptions {
+    navigation?: NavigationService;
+}
+export declare function createDraft<T extends object>(initial: T, options?: DraftOptions): {
+    value: Store<T>;
+    set: SetStoreFunction<T>;
+    snapshot: () => T;
+    baseline: import("solid-js").Accessor<T>;
+    dirty: () => boolean;
+    pending: import("solid-js").Accessor<boolean>;
+    error: import("solid-js").Accessor<HostError | undefined>;
+    fieldErrors: () => Readonly<Record<string, string>>;
+    accept: (snapshot: T) => void;
+    reset: () => void;
+    offerServerSnapshot: (snapshot: T) => boolean;
+    save: (persist: (snapshot: T, signal: AbortSignal) => Promise<T>) => Promise<boolean>;
+    cancelSave: () => void | undefined;
+};
+//# sourceMappingURL=draft.d.ts.map

package/dist/client-host/draft.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"draft.d.ts","sourceRoot":"","sources":["../src/draft.ts"],"names":[],"mappings":"AACA,OAAO,EAAkC,KAAK,gBAAgB,EAAE,KAAK,KAAK,EAAE,MAAM,gBAAgB,CAAA;AAElG,OAAO,EAAe,KAAK,SAAS,EAAE,MAAM,UAAU,CAAA;AACtD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,cAAc,CAAA;AAIrD,MAAM,WAAW,YAAY;IAC3B,UAAU,CAAC,EAAE,iBAAiB,CAAA;CAC/B;AAED,wBAAgB,WAAW,CAAC,CAAC,SAAS,MAAM,EAAE,OAAO,EAAE,CAAC,EAAE,OAAO,GAAE,YAAiB;WA6DhE,KAAK,CAAC,CAAC,CAAC;;;;;;;;uBArCA,CAAC;;oCAUY,CAAC,KAAG,OAAO;oBAKrB,CAAC,QAAQ,EAAE,CAAC,EAAE,MAAM,EAAE,WAAW,KAAK,OAAO,CAAC,CAAC,CAAC,KAAG,OAAO,CAAC,OAAO,CAAC;;EA0BjG"}

package/dist/client-host/draft.js

@@ -0,0 +1,73 @@
+import { createSignal, onCleanup } from 'solid-js';
+import { createStore, reconcile, unwrap } from 'solid-js/store';
+import { stableSerialize } from './cache';
+import { asHostError } from './errors';
+function clone(value) { return structuredClone(unwrap(value)); }
+export function createDraft(initial, options = {}) {
+    const [value, setStore] = createStore(clone(initial));
+    const [baseline, setBaseline] = createSignal(clone(initial));
+    const [revision, setRevision] = createSignal(0);
+    const [pending, setPending] = createSignal(false);
+    const [error, setError] = createSignal();
+    let saveGeneration = 0;
+    let saveController;
+    const dirty = () => {
+        revision();
+        return stableSerialize(value) !== stableSerialize(baseline());
+    };
+    const releaseGuard = options.navigation?.guard(() => !dirty());
+    onCleanup(() => {
+        saveController?.abort();
+        releaseGuard?.();
+    });
+    const set = ((...args) => {
+        setRevision((current) => current + 1);
+        setError(undefined);
+        setStore(...args);
+    });
+    const accept = (snapshot) => {
+        const next = clone(snapshot);
+        setStore(reconcile(next));
+        setBaseline(() => clone(next));
+        setRevision((current) => current + 1);
+        setError(undefined);
+    };
+    const reset = () => accept(baseline());
+    const snapshot = () => clone(value);
+    const offerServerSnapshot = (snapshot) => {
+        if (dirty())
+            return false;
+        accept(snapshot);
+        return true;
+    };
+    const save = async (persist) => {
+        const currentGeneration = ++saveGeneration;
+        const startRevision = revision();
+        const snapshot = clone(value);
+        saveController?.abort();
+        saveController = new AbortController();
+        setPending(true);
+        setError(undefined);
+        try {
+            const saved = await persist(snapshot, saveController.signal);
+            if (currentGeneration !== saveGeneration || saveController.signal.aborted || revision() !== startRevision)
+                return false;
+            accept(saved);
+            return true;
+        }
+        catch (cause) {
+            if (currentGeneration === saveGeneration && !saveController.signal.aborted)
+                setError(asHostError(cause));
+            throw cause;
+        }
+        finally {
+            if (currentGeneration === saveGeneration)
+                setPending(false);
+        }
+    };
+    return {
+        value: value, set, snapshot, baseline, dirty, pending, error,
+        fieldErrors: () => error()?.fieldErrors ?? {}, accept, reset, offerServerSnapshot, save,
+        cancelSave: () => saveController?.abort(),
+    };
+}

package/dist/client-host/errors.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,aAAa,GACrB,iBAAiB,GACjB,mBAAmB,GACnB,YAAY,GACZ,kBAAkB,GAClB,WAAW,GACX,UAAU,GACV,SAAS,CAAA;AAEb,qBAAa,SAAU,SAAQ,KAAK;IAEhC,QAAQ,CAAC,IAAI,EAAE,aAAa;IAE5B,QAAQ,CAAC,OAAO,CAAC,EAAE,OAAO;IAC1B,QAAQ,CAAC,WAAW,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;gBAH7C,IAAI,EAAE,aAAa,EAC5B,OAAO,EAAE,MAAM,EACN,OAAO,CAAC,EAAE,OAAO,YAAA,EACjB,WAAW,GAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAM;IAM7D,IAAI,SAAS,IAAI,OAAO,CAAqC;CAC9D;AAED,MAAM,WAAW,iBAAiB;IAChC,eAAe,CAAC,CAAC,KAAK,EAAE,SAAS,GAAG,IAAI,CAAA;IACxC,gBAAgB,CAAC,CAAC,KAAK,EAAE,SAAS,GAAG,IAAI,CAAA;IACzC,UAAU,CAAC,CAAC,KAAK,EAAE,SAAS,GAAG,IAAI,CAAA;CACpC;AAED,wBAAgB,WAAW,CAAC,KAAK,EAAE,OAAO,GAAG,SAAS,CAsBrD;AAED,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,SAAS,EAAE,QAAQ,CAAC,EAAE,iBAAiB,GAAG,IAAI,CAItF"}
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,aAAa,GACrB,iBAAiB,GACjB,mBAAmB,GACnB,YAAY,GACZ,kBAAkB,GAClB,WAAW,GACX,UAAU,GACV,SAAS,CAAA;AAEb,qBAAa,SAAU,SAAQ,KAAK;IAIhC,QAAQ,CAAC,IAAI,EAAE,aAAa;IAE5B,QAAQ,CAAC,OAAO,CAAC,EAAE,OAAO;IAL5B,QAAQ,CAAC,WAAW,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAA;gBAG3C,IAAI,EAAE,aAAa,EAC5B,OAAO,EAAE,MAAM,EACN,OAAO,CAAC,EAAE,OAAO,YAAA,EAC1B,WAAW,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAWhD,IAAI,SAAS,IAAI,OAAO,CAAqC;CAC9D;AAED,MAAM,WAAW,iBAAiB;IAChC,eAAe,CAAC,CAAC,KAAK,EAAE,SAAS,GAAG,IAAI,CAAA;IACxC,gBAAgB,CAAC,CAAC,KAAK,EAAE,SAAS,GAAG,IAAI,CAAA;IACzC,UAAU,CAAC,CAAC,KAAK,EAAE,SAAS,GAAG,IAAI,CAAA;CACpC;AAED,wBAAgB,WAAW,CAAC,KAAK,EAAE,OAAO,GAAG,SAAS,CAwBrD;AAED,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,SAAS,EAAE,QAAQ,CAAC,EAAE,iBAAiB,GAAG,IAAI,CAItF"}

package/dist/client-host/errors.js

@@ -2,12 +2,14 @@ export class HostError extends Error {
     code;
     details;
     fieldErrors;
-    constructor(code, message, details, fieldErrors = {}) {
+    constructor(code, message, details, fieldErrors) {
         super(message);
         this.code = code;
         this.details = details;
-        this.fieldErrors = fieldErrors;
         this.name = 'HostError';
+        this.fieldErrors = fieldErrors ?? (code === 'field_validation' && details && typeof details === 'object'
+            ? details
+            : {});
     }
     get retryable() { return this.code === 'transient'; }
 }
@@ -15,7 +17,9 @@ export function asHostError(input) {
     if (input instanceof HostError)
         return input;
     const candidate = input;
-    const raw = String(candidate?.code ?? 'unknown');
+    const details = candidate?.details ?? candidate?.data;
+    const detailRecord = details && typeof details === 'object' ? details : undefined;
+    const raw = String(detailRecord?.code ?? candidate?.code ?? 'unknown');
     const code = raw === 'unauthenticated' || raw === 'unauthorized'
         ? 'unauthenticated'
         : raw === 'forbidden' || raw === 'permission_denied'
@@ -29,9 +33,9 @@ export function asHostError(input) {
                         : raw === 'protocol'
                             ? 'protocol'
                             : 'unknown';
-    const details = candidate?.details;
-    const fieldErrors = code === 'field_validation' && details && typeof details === 'object'
-        ? details
+    const fields = detailRecord?.fieldErrors ?? detailRecord?.fields ?? details;
+    const fieldErrors = code === 'field_validation' && fields && typeof fields === 'object'
+        ? fields
         : {};
     return new HostError(code, String(candidate?.message ?? input ?? 'Unknown host error'), details, fieldErrors);
 }

package/dist/client-host/identity.d.ts

@@ -1,9 +1,9 @@
-export declare const SDK_RELEASE_VERSION = "0.6.1";
-export declare const SDK_SOURCE_COMMIT = "c8cac3d20d74aa31afb6b1f915b2701e943c6b4b";
+export declare const SDK_RELEASE_VERSION = "0.8.0";
+export declare const SDK_SOURCE_COMMIT = "4db430f807b23db5df725e623b23b45ccb30c9db";
 export declare const SDK_PROTOCOL_VERSION = "1.0.0";
 export declare const SDK_IDENTITY: Readonly<{
-    releaseVersion: "0.6.1";
-    sourceCommit: "c8cac3d20d74aa31afb6b1f915b2701e943c6b4b";
+    releaseVersion: "0.8.0";
+    sourceCommit: "4db430f807b23db5df725e623b23b45ccb30c9db";
     protocolVersion: "1.0.0";
 }>;
 export interface SDKRuntimeIdentity {

package/dist/client-host/identity.js

@@ -1,6 +1,6 @@
 import { CLIENT_HOST_PROTOCOL_VERSION } from './protocol';
-export const SDK_RELEASE_VERSION = '0.6.1';
-export const SDK_SOURCE_COMMIT = 'c8cac3d20d74aa31afb6b1f915b2701e943c6b4b';
+export const SDK_RELEASE_VERSION = '0.8.0';
+export const SDK_SOURCE_COMMIT = '4db430f807b23db5df725e623b23b45ccb30c9db';
 export const SDK_PROTOCOL_VERSION = CLIENT_HOST_PROTOCOL_VERSION;
 export const SDK_IDENTITY = Object.freeze({
     releaseVersion: SDK_RELEASE_VERSION,

package/dist/client-host/index.d.ts

@@ -1,11 +1,14 @@
 export * from './applet';
+export * from './bootstrap';
 export * from './cache';
 export * from './errors';
 export * from './identity';
+export * from './navigation';
 export * from './portals';
 export * from './protocol';
 export * from './route';
 export * from './rpc';
+export * from './services';
 export * from './streaming';
 export * from './transport';
 //# sourceMappingURL=index.d.ts.map

package/dist/client-host/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,UAAU,CAAA;AACxB,cAAc,SAAS,CAAA;AACvB,cAAc,UAAU,CAAA;AACxB,cAAc,YAAY,CAAA;AAC1B,cAAc,WAAW,CAAA;AACzB,cAAc,YAAY,CAAA;AAC1B,cAAc,SAAS,CAAA;AACvB,cAAc,OAAO,CAAA;AACrB,cAAc,aAAa,CAAA;AAC3B,cAAc,aAAa,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,UAAU,CAAA;AACxB,cAAc,aAAa,CAAA;AAC3B,cAAc,SAAS,CAAA;AACvB,cAAc,UAAU,CAAA;AACxB,cAAc,YAAY,CAAA;AAC1B,cAAc,cAAc,CAAA;AAC5B,cAAc,WAAW,CAAA;AACzB,cAAc,YAAY,CAAA;AAC1B,cAAc,SAAS,CAAA;AACvB,cAAc,OAAO,CAAA;AACrB,cAAc,YAAY,CAAA;AAC1B,cAAc,aAAa,CAAA;AAC3B,cAAc,aAAa,CAAA"}

package/dist/client-host/index.js

@@ -1,10 +1,13 @@
 export * from './applet';
+export * from './bootstrap';
 export * from './cache';
 export * from './errors';
 export * from './identity';
+export * from './navigation';
 export * from './portals';
 export * from './protocol';
 export * from './route';
 export * from './rpc';
+export * from './services';
 export * from './streaming';
 export * from './transport';

package/dist/client-host/navigation.d.ts

@@ -0,0 +1,16 @@
+export type NavigationGuard = () => boolean;
+export interface NavigationService {
+    guard(check: NavigationGuard): () => void;
+    canNavigate(): boolean;
+}
+export declare class BrowserNavigationService implements NavigationService {
+    private readonly owner;
+    private readonly guards;
+    private readonly beforeUnload;
+    private readonly click;
+    constructor(owner?: Window);
+    guard(check: NavigationGuard): () => void;
+    canNavigate(): boolean;
+    dispose(): void;
+}
+//# sourceMappingURL=navigation.d.ts.map

package/dist/client-host/navigation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"navigation.d.ts","sourceRoot":"","sources":["../src/navigation.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,eAAe,GAAG,MAAM,OAAO,CAAA;AAE3C,MAAM,WAAW,iBAAiB;IAChC,KAAK,CAAC,KAAK,EAAE,eAAe,GAAG,MAAM,IAAI,CAAA;IACzC,WAAW,IAAI,OAAO,CAAA;CACvB;AAED,qBAAa,wBAAyB,YAAW,iBAAiB;IAgBpD,OAAO,CAAC,QAAQ,CAAC,KAAK;IAflC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAA6B;IACpD,OAAO,CAAC,QAAQ,CAAC,YAAY,CAI5B;IACD,OAAO,CAAC,QAAQ,CAAC,KAAK,CAOrB;gBAE4B,KAAK,GAAE,MAAe;IAKnD,KAAK,CAAC,KAAK,EAAE,eAAe,GAAG,MAAM,IAAI;IAKzC,WAAW,IAAI,OAAO;IAKtB,OAAO,IAAI,IAAI;CAKhB"}

package/dist/client-host/navigation.js

@@ -0,0 +1,41 @@
+export class BrowserNavigationService {
+    owner;
+    guards = new Set();
+    beforeUnload = (event) => {
+        if (this.canNavigate())
+            return;
+        event.preventDefault();
+        event.returnValue = '';
+    };
+    click = (event) => {
+        const eventTarget = event.target;
+        const target = typeof eventTarget?.closest === 'function' ? eventTarget.closest('a[href]') : null;
+        if (!target || event.defaultPrevented || event.button !== 0 || event.metaKey || event.ctrlKey || event.shiftKey || event.altKey)
+            return;
+        const anchor = target;
+        if (anchor.target === '_blank' || anchor.download || anchor.origin !== this.owner.location.origin)
+            return;
+        if (!this.canNavigate())
+            event.preventDefault();
+    };
+    constructor(owner = window) {
+        this.owner = owner;
+        owner.addEventListener('beforeunload', this.beforeUnload);
+        owner.document.addEventListener('click', this.click, true);
+    }
+    guard(check) {
+        this.guards.add(check);
+        return () => this.guards.delete(check);
+    }
+    canNavigate() {
+        for (const check of this.guards)
+            if (!check())
+                return false;
+        return true;
+    }
+    dispose() {
+        this.owner.removeEventListener('beforeunload', this.beforeUnload);
+        this.owner.document.removeEventListener('click', this.click, true);
+        this.guards.clear();
+    }
+}

package/dist/client-host/route.d.ts

@@ -1,18 +1,7 @@
 import type { ComponentType } from 'react';
 import { type WidgetSlotName } from './portals';
-export declare class ClientHostProtocolError extends Error {
-    readonly expected: string;
-    readonly actual: string;
-    constructor(expected: string, actual: string);
-}
-export interface ClientRouteContext<TInitial = unknown> {
-    protocolVersion: string;
-    sdkReleaseVersion: string;
-    sdkCommit: string;
-    initial: TInitial;
-    theme: 'light' | 'dark';
-    csrf?: string;
-}
+import { type ClientRouteContext } from './bootstrap';
+export { ClientHostProtocolError, assertClientHostProtocol, type ClientRouteContext } from './bootstrap';
 export interface MountClientRouteOptions<TInitial, TProps extends object> {
     root: HTMLElement;
     portals: HTMLElement;
@@ -24,6 +13,5 @@ export interface MountClientRouteOptions<TInitial, TProps extends object> {
     props: TProps;
     context: ClientRouteContext<TInitial>;
 }
-export declare function assertClientHostProtocol(actual: string): void;
 export declare function mountClientRoute<TInitial, TProps extends object>(options: MountClientRouteOptions<TInitial, TProps>): () => void;
 //# sourceMappingURL=route.d.ts.map

package/dist/client-host/route.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"route.d.ts","sourceRoot":"","sources":["../src/route.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,OAAO,CAAA;AAE1C,OAAO,EAAsB,KAAK,cAAc,EAAE,MAAM,WAAW,CAAA;AAInE,qBAAa,uBAAwB,SAAQ,KAAK;IACpC,QAAQ,CAAC,QAAQ,EAAE,MAAM;IAAE,QAAQ,CAAC,MAAM,EAAE,MAAM;gBAAzC,QAAQ,EAAE,MAAM,EAAW,MAAM,EAAE,MAAM;CAI/D;AAED,MAAM,WAAW,kBAAkB,CAAC,QAAQ,GAAG,OAAO;IACpD,eAAe,EAAE,MAAM,CAAA;IACvB,iBAAiB,EAAE,MAAM,CAAA;IACzB,SAAS,EAAE,MAAM,CAAA;IACjB,OAAO,EAAE,QAAQ,CAAA;IACjB,KAAK,EAAE,OAAO,GAAG,MAAM,CAAA;IACvB,IAAI,CAAC,EAAE,MAAM,CAAA;CACd;AAED,MAAM,WAAW,uBAAuB,CAAC,QAAQ,EAAE,MAAM,SAAS,MAAM;IACtE,IAAI,EAAE,WAAW,CAAA;IACjB,OAAO,EAAE,WAAW,CAAA;IACpB,UAAU,CAAC,EAAE,WAAW,CAAA;IACxB,WAAW,CAAC,EAAE,OAAO,CAAC,MAAM,CAAC,cAAc,EAAE,WAAW,CAAC,CAAC,CAAA;IAC1D,SAAS,EAAE,aAAa,CAAC,MAAM,GAAG;QAAE,KAAK,EAAE,kBAAkB,CAAC,QAAQ,CAAC,CAAA;KAAE,CAAC,CAAA;IAC1E,KAAK,EAAE,MAAM,CAAA;IACb,OAAO,EAAE,kBAAkB,CAAC,QAAQ,CAAC,CAAA;CACtC;AAED,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAI7D;AAED,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,MAAM,SAAS,MAAM,EAAE,OAAO,EAAE,uBAAuB,CAAC,QAAQ,EAAE,MAAM,CAAC,GAAG,MAAM,IAAI,CAehI"}
+{"version":3,"file":"route.d.ts","sourceRoot":"","sources":["../src/route.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,OAAO,CAAA;AAE1C,OAAO,EAAsB,KAAK,cAAc,EAAE,MAAM,WAAW,CAAA;AACnE,OAAO,EAAyB,KAAK,kBAAkB,EAAE,MAAM,aAAa,CAAA;AAE5E,OAAO,EAAE,uBAAuB,EAAE,wBAAwB,EAAE,KAAK,kBAAkB,EAAE,MAAM,aAAa,CAAA;AAExG,MAAM,WAAW,uBAAuB,CAAC,QAAQ,EAAE,MAAM,SAAS,MAAM;IACtE,IAAI,EAAE,WAAW,CAAA;IACjB,OAAO,EAAE,WAAW,CAAA;IACpB,UAAU,CAAC,EAAE,WAAW,CAAA;IACxB,WAAW,CAAC,EAAE,OAAO,CAAC,MAAM,CAAC,cAAc,EAAE,WAAW,CAAC,CAAC,CAAA;IAC1D,SAAS,EAAE,aAAa,CAAC,MAAM,GAAG;QAAE,KAAK,EAAE,kBAAkB,CAAC,QAAQ,CAAC,CAAA;KAAE,CAAC,CAAA;IAC1E,KAAK,EAAE,MAAM,CAAA;IACb,OAAO,EAAE,kBAAkB,CAAC,QAAQ,CAAC,CAAA;CACtC;AAED,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,MAAM,SAAS,MAAM,EAAE,OAAO,EAAE,uBAAuB,CAAC,QAAQ,EAAE,MAAM,CAAC,GAAG,MAAM,IAAI,CAgBhI"}

package/dist/client-host/route.js

@@ -1,32 +1,19 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 import { createRoot } from 'react-dom/client';
 import { ClientHostProvider } from './portals';
-import { assertSDKIdentity } from './identity';
-import { CLIENT_HOST_PROTOCOL_VERSION } from './protocol';
-export class ClientHostProtocolError extends Error {
-    expected;
-    actual;
-    constructor(expected, actual) {
-        super(`Client host protocol ${actual} is incompatible with ${expected}`);
-        this.expected = expected;
-        this.actual = actual;
-        this.name = 'ClientHostProtocolError';
-    }
-}
-export function assertClientHostProtocol(actual) {
-    if (actual.split('.', 1)[0] !== CLIENT_HOST_PROTOCOL_VERSION.split('.', 1)[0]) {
-        throw new ClientHostProtocolError(CLIENT_HOST_PROTOCOL_VERSION, actual);
-    }
-}
+import { assertClientBootstrap } from './bootstrap';
+export { ClientHostProtocolError, assertClientHostProtocol } from './bootstrap';
 export function mountClientRoute(options) {
-    assertClientHostProtocol(options.context.protocolVersion);
-    assertSDKIdentity({
-        releaseVersion: options.context.sdkReleaseVersion,
-        sourceCommit: options.context.sdkCommit,
-        protocolVersion: options.context.protocolVersion,
-    });
+    assertClientBootstrap(options.context, false);
+    const currentOwner = options.root.dataset.iotaClientOwner;
+    if (currentOwner)
+        throw new Error(`Client route root is already owned by ${currentOwner}`);
+    options.root.dataset.iotaClientOwner = 'react';
     const root = createRoot(options.root);
     const Component = options.component;
     root.render(_jsx(ClientHostProvider, { portalOwner: options.portals, background: options.background, widgetSlots: options.widgetSlots, theme: options.context.theme, children: _jsx(Component, { ...options.props, route: options.context }) }));
-    return () => root.unmount();
+    return () => {
+        root.unmount();
+        delete options.root.dataset.iotaClientOwner;
+    };
 }

package/dist/client-host/rpc-core.d.ts

@@ -0,0 +1,37 @@
+import { type QueryCache, type QueryKey } from './cache';
+import { HostError, type HostErrorHandlers } from './errors';
+export interface RPCMethodContract {
+    namespace: string;
+    method: string;
+    kind: 'query' | 'mutation';
+    cacheable?: boolean;
+    maxRetries?: number;
+    invalidates?: readonly string[];
+}
+export interface RPCTransport {
+    call<TRequest, TResponse>(method: string, request: TRequest, signal: AbortSignal): Promise<TResponse>;
+}
+export interface RPCDiagnostics {
+    call?(event: {
+        method: string;
+        key?: QueryKey;
+        state: 'start' | 'success' | 'error' | 'cancelled';
+        error?: HostError;
+    }): void;
+}
+export interface RPCClientOptions {
+    cache?: QueryCache;
+    errors?: HostErrorHandlers;
+    diagnostics?: RPCDiagnostics;
+}
+export declare class RPCClient {
+    readonly transport: RPCTransport;
+    readonly options: RPCClientOptions;
+    readonly cache: QueryCache;
+    private queryGeneration;
+    private readonly latestQueryGenerations;
+    constructor(transport: RPCTransport, options?: RPCClientOptions);
+    query<TRequest, TResponse>(contract: RPCMethodContract, request: TRequest, signal: AbortSignal): Promise<TResponse>;
+    mutate<TRequest, TResponse>(contract: RPCMethodContract, request: TRequest, signal: AbortSignal): Promise<TResponse>;
+}
+//# sourceMappingURL=rpc-core.d.ts.map

package/dist/client-host/rpc-core.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rpc-core.d.ts","sourceRoot":"","sources":["../src/rpc-core.ts"],"names":[],"mappings":"AAAA,OAAO,EAA8B,KAAK,UAAU,EAAE,KAAK,QAAQ,EAAE,MAAM,SAAS,CAAA;AACpF,OAAO,EAAkC,SAAS,EAAE,KAAK,iBAAiB,EAAE,MAAM,UAAU,CAAA;AAE5F,MAAM,WAAW,iBAAiB;IAChC,SAAS,EAAE,MAAM,CAAA;IACjB,MAAM,EAAE,MAAM,CAAA;IACd,IAAI,EAAE,OAAO,GAAG,UAAU,CAAA;IAC1B,SAAS,CAAC,EAAE,OAAO,CAAA;IACnB,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,WAAW,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;CAChC;AAED,MAAM,WAAW,YAAY;IAC3B,IAAI,CAAC,QAAQ,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAE,WAAW,GAAG,OAAO,CAAC,SAAS,CAAC,CAAA;CACtG;AAED,MAAM,WAAW,cAAc;IAC7B,IAAI,CAAC,CAAC,KAAK,EAAE;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,GAAG,CAAC,EAAE,QAAQ,CAAC;QAAC,KAAK,EAAE,OAAO,GAAG,SAAS,GAAG,OAAO,GAAG,WAAW,CAAC;QAAC,KAAK,CAAC,EAAE,SAAS,CAAA;KAAE,GAAG,IAAI,CAAA;CAC9H;AAED,MAAM,WAAW,gBAAgB;IAC/B,KAAK,CAAC,EAAE,UAAU,CAAA;IAClB,MAAM,CAAC,EAAE,iBAAiB,CAAA;IAC1B,WAAW,CAAC,EAAE,cAAc,CAAA;CAC7B;AAED,qBAAa,SAAS;IAIR,QAAQ,CAAC,SAAS,EAAE,YAAY;IAAE,QAAQ,CAAC,OAAO,EAAE,gBAAgB;IAHhF,QAAQ,CAAC,KAAK,EAAE,UAAU,CAAA;IAC1B,OAAO,CAAC,eAAe,CAAI;IAC3B,OAAO,CAAC,QAAQ,CAAC,sBAAsB,CAA4B;gBAC9C,SAAS,EAAE,YAAY,EAAW,OAAO,GAAE,gBAAqB;IAI/E,KAAK,CAAC,QAAQ,EAAE,SAAS,EAAE,QAAQ,EAAE,iBAAiB,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAE,WAAW,GAAG,OAAO,CAAC,SAAS,CAAC;IA0CnH,MAAM,CAAC,QAAQ,EAAE,SAAS,EAAE,QAAQ,EAAE,iBAAiB,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAE,WAAW,GAAG,OAAO,CAAC,SAAS,CAAC;CAe3H"}

package/dist/client-host/rpc-core.js

@@ -0,0 +1,79 @@
+import { MemoryQueryCache, queryKey } from './cache';
+import { asHostError, dispatchHostError, HostError } from './errors';
+export class RPCClient {
+    transport;
+    options;
+    cache;
+    queryGeneration = 0;
+    latestQueryGenerations = new Map();
+    constructor(transport, options = {}) {
+        this.transport = transport;
+        this.options = options;
+        this.cache = options.cache ?? new MemoryQueryCache();
+    }
+    async query(contract, request, signal) {
+        if (contract.kind !== 'query')
+            throw new HostError('protocol', `${contract.method} is not a query`);
+        const key = queryKey(contract.namespace, contract.method, request);
+        if (contract.cacheable !== false) {
+            const cached = this.cache.get(key);
+            if (cached !== undefined)
+                return cached;
+        }
+        const encodedKey = JSON.stringify(key);
+        const generation = ++this.queryGeneration;
+        this.latestQueryGenerations.set(encodedKey, generation);
+        let attempt = 0;
+        const configuredRetries = contract.maxRetries ?? 2;
+        const maxRetries = Number.isFinite(configuredRetries)
+            ? Math.max(0, Math.min(3, Math.trunc(configuredRetries)))
+            : 2;
+        try {
+            for (;;) {
+                this.options.diagnostics?.call?.({ method: contract.method, key, state: 'start' });
+                try {
+                    const response = await this.transport.call(contract.method, request, signal);
+                    if (contract.cacheable !== false && this.latestQueryGenerations.get(encodedKey) === generation)
+                        this.cache.set(key, response);
+                    this.options.diagnostics?.call?.({ method: contract.method, key, state: 'success' });
+                    return response;
+                }
+                catch (cause) {
+                    if (signal.aborted) {
+                        this.options.diagnostics?.call?.({ method: contract.method, key, state: 'cancelled' });
+                        throw cause;
+                    }
+                    const error = asHostError(cause);
+                    if (!error.retryable || attempt >= maxRetries) {
+                        dispatchHostError(error, this.options.errors);
+                        this.options.diagnostics?.call?.({ method: contract.method, key, state: 'error', error });
+                        throw error;
+                    }
+                    attempt += 1;
+                }
+            }
+        }
+        finally {
+            if (this.latestQueryGenerations.get(encodedKey) === generation)
+                this.latestQueryGenerations.delete(encodedKey);
+        }
+    }
+    async mutate(contract, request, signal) {
+        if (contract.kind !== 'mutation')
+            throw new HostError('protocol', `${contract.method} is not a mutation`);
+        this.options.diagnostics?.call?.({ method: contract.method, state: 'start' });
+        try {
+            const response = await this.transport.call(contract.method, request, signal);
+            this.cache.invalidate(contract.namespace, contract.invalidates ?? []);
+            this.options.diagnostics?.call?.({ method: contract.method, state: 'success' });
+            return response;
+        }
+        catch (cause) {
+            const error = asHostError(cause);
+            if (!signal.aborted)
+                dispatchHostError(error, this.options.errors);
+            this.options.diagnostics?.call?.({ method: contract.method, state: signal.aborted ? 'cancelled' : 'error', error });
+            throw error;
+        }
+    }
+}

package/dist/client-host/rpc.d.ts

@@ -1,37 +1,6 @@
-import { type QueryCache, type QueryKey } from './cache';
-import { HostError, type HostErrorHandlers } from './errors';
-export interface RPCMethodContract {
-    namespace: string;
-    method: string;
-    kind: 'query' | 'mutation';
-    cacheable?: boolean;
-    maxRetries?: number;
-    invalidates?: readonly string[];
-}
-export interface RPCTransport {
-    call<TRequest, TResponse>(method: string, request: TRequest, signal: AbortSignal): Promise<TResponse>;
-}
-export interface RPCDiagnostics {
-    call?(event: {
-        method: string;
-        key?: QueryKey;
-        state: 'start' | 'success' | 'error' | 'cancelled';
-        error?: HostError;
-    }): void;
-}
-export interface RPCClientOptions {
-    cache?: QueryCache;
-    errors?: HostErrorHandlers;
-    diagnostics?: RPCDiagnostics;
-}
-export declare class RPCClient {
-    readonly transport: RPCTransport;
-    readonly options: RPCClientOptions;
-    readonly cache: QueryCache;
-    constructor(transport: RPCTransport, options?: RPCClientOptions);
-    query<TRequest, TResponse>(contract: RPCMethodContract, request: TRequest, signal: AbortSignal): Promise<TResponse>;
-    mutate<TRequest, TResponse>(contract: RPCMethodContract, request: TRequest, signal: AbortSignal): Promise<TResponse>;
-}
+import { type HostError } from './errors';
+import { RPCClient, type RPCMethodContract } from './rpc-core';
+export * from './rpc-core';
 export type QueryState<T> = {
     status: 'loading';
 } | {