@bardioc/app-sdk 0.4.11 → 1.0.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@bardioc/app-sdk",
-  "version": "0.4.11",
-  "description": "SDK for building apps for the Bardioc OS",
+  "version": "1.0.0",
+  "description": "SDK for building apps for Bardioc",
   "license": "MIT",
   "private": false,
   "type": "module",
@@ -41,6 +41,10 @@
       "types": "./dist/dev-proxy.d.ts",
       "default": "./dist/dev-proxy.js"
     },
+    "./testing": {
+      "types": "./dist/testing.d.ts",
+      "default": "./dist/testing.js"
+    },
     "./types": {
       "types": "./dist/types.d.ts"
     }
@@ -69,16 +73,20 @@
     }
   },
   "devDependencies": {
-    "@vitest/coverage-v8": "^4.1.8",
+    "@testing-library/react": "16.3.2",
     "@types/node": "^25.9.1",
     "@types/react": "19.1.16",
-    "@testing-library/react": "16.3.2",
+    "@vitest/coverage-v8": "^4.1.8",
+    "fake-indexeddb": "^6.2.6",
     "jsdom": "29.1.0",
     "react": "19.2.6",
     "react-dom": "19.2.6",
     "typescript": "6.0.3",
     "vitest": "^4.1.8"
   },
+  "dependencies": {
+    "zod": "^4.4.3"
+  },
   "scripts": {
     "build": "tsc",
     "lint": "eslint .",

package/dist/contract-matrix.d.ts

@@ -1,148 +0,0 @@
-import type { AppManifestPermission } from './manifest.js';
-export declare const SDK_CONTRACT_MATRIX: {
-    readonly SDK_INIT: {
-        readonly requestPayload: "{ appId?: string }";
-        readonly responsePayload: "SdkInitResponse";
-        readonly permission: null;
-        readonly expectedHostBehavior: "Handshake the iframe app and return SDK-owned host context.";
-    };
-    readonly SDK_NOTIFY: {
-        readonly requestPayload: "SdkNotifyPayload";
-        readonly responsePayload: "{ ok: true }";
-        readonly permission: "notify";
-        readonly expectedHostBehavior: "Surface a host-level notification and acknowledge delivery.";
-    };
-    readonly SDK_KERNEL_PROXY: {
-        readonly requestPayload: "SdkKernelProxyPayload";
-        readonly responsePayload: "KernelProtocol response";
-        readonly permission: "kernel-proxy";
-        readonly expectedHostBehavior: "Forward only allow-listed kernel messages through the host.";
-    };
-    readonly SDK_TRANSPORT: {
-        readonly requestPayload: "SdkTransportPayload";
-        readonly responsePayload: "Upstream transport response payload";
-        readonly permission: "transport";
-        readonly expectedHostBehavior: "Relay app-scoped transport requests with scope-aware host mediation.";
-    };
-    readonly SDK_SET_COMMANDS: {
-        readonly requestPayload: "SdkSetCommandsPayload";
-        readonly responsePayload: "{ ok: true }";
-        readonly permission: null;
-        readonly expectedHostBehavior: "Store the app command registry for host command invocation.";
-    };
-    readonly SDK_SET_MENU: {
-        readonly requestPayload: "SdkSetMenuPayload";
-        readonly responsePayload: "{ ok: true }";
-        readonly permission: null;
-        readonly expectedHostBehavior: "Store the app menu tree without degrading supported SDK menu kinds.";
-    };
-    readonly SDK_SET_ACTIVE_TAB: {
-        readonly requestPayload: "SdkSetActiveTabPayload";
-        readonly responsePayload: "{ ok: true }";
-        readonly permission: null;
-        readonly expectedHostBehavior: "Persist the app-reported active tab label in host window state.";
-    };
-    readonly SDK_SHORTCUT_EVENT: {
-        readonly requestPayload: "SdkShortcutEventPayload";
-        readonly responsePayload: null;
-        readonly permission: null;
-        readonly expectedHostBehavior: "Route a focused iframe shortcut event through host shortcut handling.";
-    };
-    readonly SDK_STORAGE_GET: {
-        readonly requestPayload: "SdkStorageGetPayload";
-        readonly responsePayload: "unknown";
-        readonly permission: "storage";
-        readonly expectedHostBehavior: "Host-owned storage bridge; currently deferred in bdf.";
-    };
-    readonly SDK_STORAGE_SET: {
-        readonly requestPayload: "SdkStorageSetPayload";
-        readonly responsePayload: "void";
-        readonly permission: "storage";
-        readonly expectedHostBehavior: "Host-owned storage bridge; currently deferred in bdf.";
-    };
-    readonly SDK_STORAGE_DELETE: {
-        readonly requestPayload: "SdkStorageDeletePayload";
-        readonly responsePayload: "void";
-        readonly permission: "storage";
-        readonly expectedHostBehavior: "Host-owned storage bridge; currently deferred in bdf.";
-    };
-    readonly SDK_STORAGE_KEYS: {
-        readonly requestPayload: "{}";
-        readonly responsePayload: "string[]";
-        readonly permission: "storage";
-        readonly expectedHostBehavior: "Host-owned storage bridge; currently deferred in bdf.";
-    };
-    readonly SDK_IDB_GET: {
-        readonly requestPayload: "SdkIdbGetPayload";
-        readonly responsePayload: "SdkIdbEntry | null";
-        readonly permission: "indexdb";
-        readonly expectedHostBehavior: "Perform app-scoped IndexedDB reads in host-owned storage.";
-    };
-    readonly SDK_IDB_PUT: {
-        readonly requestPayload: "SdkIdbPutPayload";
-        readonly responsePayload: "void";
-        readonly permission: "indexdb";
-        readonly expectedHostBehavior: "Perform app-scoped IndexedDB writes in host-owned storage.";
-    };
-    readonly SDK_IDB_DELETE: {
-        readonly requestPayload: "SdkIdbDeletePayload";
-        readonly responsePayload: "void";
-        readonly permission: "indexdb";
-        readonly expectedHostBehavior: "Perform app-scoped IndexedDB deletes in host-owned storage.";
-    };
-    readonly SDK_IDB_QUERY: {
-        readonly requestPayload: "SdkIdbQueryPayload";
-        readonly responsePayload: "SdkIdbEntry[]";
-        readonly permission: "indexdb";
-        readonly expectedHostBehavior: "Perform app-scoped IndexedDB queries in host-owned storage.";
-    };
-    readonly SDK_LAUNCH_APP: {
-        readonly requestPayload: "{ appId: string }";
-        readonly responsePayload: "{ windowId: string | null }";
-        readonly permission: null;
-        readonly expectedHostBehavior: "Launch another registered app through the host shell.";
-    };
-    readonly SDK_COMMAND_INVOKE: {
-        readonly requestPayload: "SdkCommandInvokePayload";
-        readonly responsePayload: "{ ok: true }";
-        readonly permission: null;
-        readonly expectedHostBehavior: "Host-to-app command callback delivery.";
-    };
-    readonly SDK_EVENT_SUBSCRIBE: {
-        readonly requestPayload: "EventSubscribeRequest";
-        readonly responsePayload: "EventSubscribeResponse";
-        readonly permission: "events";
-        readonly expectedHostBehavior: "Open a scoped graph-event SSE stream for the requested OGIT types.";
-    };
-    readonly SDK_EVENT_UNSUBSCRIBE: {
-        readonly requestPayload: "EventUnsubscribeRequest";
-        readonly responsePayload: "{ ok: true }";
-        readonly permission: "events";
-        readonly expectedHostBehavior: "Close the graph-event SSE stream for the given subscription.";
-    };
-    readonly SDK_GRAPH_EVENT: {
-        readonly requestPayload: "GraphEventPushPayload";
-        readonly responsePayload: null;
-        readonly permission: null;
-        readonly expectedHostBehavior: "Host-to-app graph-event push delivery (no ack).";
-    };
-    readonly SDK_OS_CONFIG_UPDATE: {
-        readonly requestPayload: "OsConfig";
-        readonly responsePayload: null;
-        readonly permission: null;
-        readonly expectedHostBehavior: "Host-to-app runtime OS configuration update delivery.";
-    };
-    readonly SDK_RESPONSE: {
-        readonly requestPayload: "SdkResponse";
-        readonly responsePayload: null;
-        readonly permission: null;
-        readonly expectedHostBehavior: "Request/response envelope used by the bridge runtime.";
-    };
-    readonly SDK_INIT_ACK: {
-        readonly requestPayload: "SdkInitResponse";
-        readonly responsePayload: null;
-        readonly permission: null;
-        readonly expectedHostBehavior: "Handshake acknowledgement used by the bridge runtime.";
-    };
-};
-export declare function getRequiredPermissionForSdkMessage(messageType: string): AppManifestPermission | null;

package/dist/contract-matrix.js

@@ -1,150 +0,0 @@
-import { SDK_MSG } from './protocol.js';
-export const SDK_CONTRACT_MATRIX = {
-    [SDK_MSG.INIT]: {
-        requestPayload: '{ appId?: string }',
-        responsePayload: 'SdkInitResponse',
-        permission: null,
-        expectedHostBehavior: 'Handshake the iframe app and return SDK-owned host context.',
-    },
-    [SDK_MSG.NOTIFY]: {
-        requestPayload: 'SdkNotifyPayload',
-        responsePayload: '{ ok: true }',
-        permission: 'notify',
-        expectedHostBehavior: 'Surface a host-level notification and acknowledge delivery.',
-    },
-    [SDK_MSG.KERNEL_PROXY]: {
-        requestPayload: 'SdkKernelProxyPayload',
-        responsePayload: 'KernelProtocol response',
-        permission: 'kernel-proxy',
-        expectedHostBehavior: 'Forward only allow-listed kernel messages through the host.',
-    },
-    [SDK_MSG.TRANSPORT]: {
-        requestPayload: 'SdkTransportPayload',
-        responsePayload: 'Upstream transport response payload',
-        permission: 'transport',
-        expectedHostBehavior: 'Relay app-scoped transport requests with scope-aware host mediation.',
-    },
-    [SDK_MSG.SET_COMMANDS]: {
-        requestPayload: 'SdkSetCommandsPayload',
-        responsePayload: '{ ok: true }',
-        permission: null,
-        expectedHostBehavior: 'Store the app command registry for host command invocation.',
-    },
-    [SDK_MSG.SET_MENU]: {
-        requestPayload: 'SdkSetMenuPayload',
-        responsePayload: '{ ok: true }',
-        permission: null,
-        expectedHostBehavior: 'Store the app menu tree without degrading supported SDK menu kinds.',
-    },
-    [SDK_MSG.SET_ACTIVE_TAB]: {
-        requestPayload: 'SdkSetActiveTabPayload',
-        responsePayload: '{ ok: true }',
-        permission: null,
-        expectedHostBehavior: 'Persist the app-reported active tab label in host window state.',
-    },
-    [SDK_MSG.SHORTCUT_EVENT]: {
-        requestPayload: 'SdkShortcutEventPayload',
-        responsePayload: null,
-        permission: null,
-        expectedHostBehavior: 'Route a focused iframe shortcut event through host shortcut handling.',
-    },
-    [SDK_MSG.STORAGE_GET]: {
-        requestPayload: 'SdkStorageGetPayload',
-        responsePayload: 'unknown',
-        permission: 'storage',
-        expectedHostBehavior: 'Host-owned storage bridge; currently deferred in bdf.',
-    },
-    [SDK_MSG.STORAGE_SET]: {
-        requestPayload: 'SdkStorageSetPayload',
-        responsePayload: 'void',
-        permission: 'storage',
-        expectedHostBehavior: 'Host-owned storage bridge; currently deferred in bdf.',
-    },
-    [SDK_MSG.STORAGE_DELETE]: {
-        requestPayload: 'SdkStorageDeletePayload',
-        responsePayload: 'void',
-        permission: 'storage',
-        expectedHostBehavior: 'Host-owned storage bridge; currently deferred in bdf.',
-    },
-    [SDK_MSG.STORAGE_KEYS]: {
-        requestPayload: '{}',
-        responsePayload: 'string[]',
-        permission: 'storage',
-        expectedHostBehavior: 'Host-owned storage bridge; currently deferred in bdf.',
-    },
-    [SDK_MSG.IDB_GET]: {
-        requestPayload: 'SdkIdbGetPayload',
-        responsePayload: 'SdkIdbEntry | null',
-        permission: 'indexdb',
-        expectedHostBehavior: 'Perform app-scoped IndexedDB reads in host-owned storage.',
-    },
-    [SDK_MSG.IDB_PUT]: {
-        requestPayload: 'SdkIdbPutPayload',
-        responsePayload: 'void',
-        permission: 'indexdb',
-        expectedHostBehavior: 'Perform app-scoped IndexedDB writes in host-owned storage.',
-    },
-    [SDK_MSG.IDB_DELETE]: {
-        requestPayload: 'SdkIdbDeletePayload',
-        responsePayload: 'void',
-        permission: 'indexdb',
-        expectedHostBehavior: 'Perform app-scoped IndexedDB deletes in host-owned storage.',
-    },
-    [SDK_MSG.IDB_QUERY]: {
-        requestPayload: 'SdkIdbQueryPayload',
-        responsePayload: 'SdkIdbEntry[]',
-        permission: 'indexdb',
-        expectedHostBehavior: 'Perform app-scoped IndexedDB queries in host-owned storage.',
-    },
-    [SDK_MSG.LAUNCH_APP]: {
-        requestPayload: '{ appId: string }',
-        responsePayload: '{ windowId: string | null }',
-        permission: null,
-        expectedHostBehavior: 'Launch another registered app through the host shell.',
-    },
-    [SDK_MSG.COMMAND_INVOKE]: {
-        requestPayload: 'SdkCommandInvokePayload',
-        responsePayload: '{ ok: true }',
-        permission: null,
-        expectedHostBehavior: 'Host-to-app command callback delivery.',
-    },
-    [SDK_MSG.EVENT_SUBSCRIBE]: {
-        requestPayload: 'EventSubscribeRequest',
-        responsePayload: 'EventSubscribeResponse',
-        permission: 'events',
-        expectedHostBehavior: 'Open a scoped graph-event SSE stream for the requested OGIT types.',
-    },
-    [SDK_MSG.EVENT_UNSUBSCRIBE]: {
-        requestPayload: 'EventUnsubscribeRequest',
-        responsePayload: '{ ok: true }',
-        permission: 'events',
-        expectedHostBehavior: 'Close the graph-event SSE stream for the given subscription.',
-    },
-    [SDK_MSG.GRAPH_EVENT]: {
-        requestPayload: 'GraphEventPushPayload',
-        responsePayload: null,
-        permission: null,
-        expectedHostBehavior: 'Host-to-app graph-event push delivery (no ack).',
-    },
-    [SDK_MSG.OS_CONFIG_UPDATE]: {
-        requestPayload: 'OsConfig',
-        responsePayload: null,
-        permission: null,
-        expectedHostBehavior: 'Host-to-app runtime OS configuration update delivery.',
-    },
-    [SDK_MSG.RESPONSE]: {
-        requestPayload: 'SdkResponse',
-        responsePayload: null,
-        permission: null,
-        expectedHostBehavior: 'Request/response envelope used by the bridge runtime.',
-    },
-    [SDK_MSG.INIT_ACK]: {
-        requestPayload: 'SdkInitResponse',
-        responsePayload: null,
-        permission: null,
-        expectedHostBehavior: 'Handshake acknowledgement used by the bridge runtime.',
-    },
-};
-export function getRequiredPermissionForSdkMessage(messageType) {
-    return SDK_CONTRACT_MATRIX[messageType]?.permission ?? null;
-}

package/dist/host-bridge.d.ts

@@ -1,3 +0,0 @@
-import type { HostBridge, HostBridgeConfig } from './types.js';
-/** Create a bridge between an iframe app and its host OS via `postMessage`. */
-export declare function createHostBridge(config: HostBridgeConfig): HostBridge;

package/dist/host-bridge.js

@@ -1,306 +0,0 @@
-import { SDK_MSG } from './protocol.js';
-import { BackendTransport } from './transports/backend-transport.js';
-import { GraphTransport } from './transports/graph-transport.js';
-import { OsTransport } from './transports/os-transport.js';
-let counter = 0;
-function nextId() {
-    return `sdk_${Date.now()}_${++counter}`;
-}
-function assertStoreName(storeName) {
-    const normalized = storeName.trim();
-    if (!normalized) {
-        throw new Error('storeName must be a non-empty string');
-    }
-    return normalized;
-}
-/** Create a bridge between an iframe app and its host OS via `postMessage`. */
-export function createHostBridge(config) {
-    const { appId: hintAppId, connectTimeout = 5000, debug = false } = config;
-    const hostWindow = globalThis.window;
-    // When inside an iframe, document.referrer gives us the parent's origin.
-    const inferredHostOrigin = (() => {
-        try {
-            if (hostWindow.parent !== hostWindow && document.referrer) {
-                return new URL(document.referrer).origin;
-            }
-        }
-        catch {
-            // ignore parse errors
-        }
-        return hostWindow.location.origin;
-    })();
-    const targetOrigin = config.targetOrigin ?? inferredHostOrigin;
-    const isInsideIframe = hostWindow.parent !== hostWindow;
-    function log(...args) {
-        if (debug)
-            console.log('[app-sdk]', ...args);
-    }
-    log('createHostBridge', { appId: hintAppId, targetOrigin, isInsideIframe });
-    let _connected = false;
-    let _context = null;
-    let _destroyed = false;
-    const commandHandlers = new Map();
-    const osConfigUpdateCallbacks = new Set();
-    const eventHandlers = new Map();
-    const pending = new Map();
-    function isAllowedMessageOrigin(origin) {
-        return origin === targetOrigin || origin === hostWindow.location.origin;
-    }
-    function handleCommandInvoke(data) {
-        const { commandId } = data.payload;
-        const handler = commandHandlers.get(commandId);
-        if (!handler) {
-            respondToHost(data.id, null, `Command "${commandId}" is not registered`);
-            return;
-        }
-        Promise.resolve()
-            .then(() => handler())
-            .then(() => {
-            respondToHost(data.id, { ok: true });
-        })
-            .catch((error) => {
-            const message = error instanceof Error ? error.message : String(error);
-            respondToHost(data.id, null, message);
-        });
-    }
-    function handleOsConfigUpdate(data) {
-        const newOsConfig = data.payload;
-        if (_context) {
-            _context.osConfig = newOsConfig;
-        }
-        for (const callback of osConfigUpdateCallbacks) {
-            try {
-                callback(newOsConfig);
-            }
-            catch (error) {
-                console.error('[app-sdk] OS config update callback error:', error);
-            }
-        }
-    }
-    function handleGraphEvent(data) {
-        const { subscriptionId, event } = data.payload;
-        const handler = eventHandlers.get(subscriptionId);
-        if (!handler) {
-            return;
-        }
-        try {
-            handler(event);
-        }
-        catch (error) {
-            console.error('[app-sdk] graph event handler error:', error);
-        }
-    }
-    function handlePendingResponse(data) {
-        const request = pending.get(data.id);
-        if (!request) {
-            return;
-        }
-        pending.delete(data.id);
-        if (data.error) {
-            request.reject(new Error(data.error));
-            return;
-        }
-        request.resolve(data.payload);
-    }
-    function onMessage(event) {
-        if (!isAllowedMessageOrigin(event.origin)) {
-            log('ignoring message from', event.origin, '(expected', targetOrigin, ')');
-            return;
-        }
-        const data = event.data;
-        if (!data || typeof data.type !== 'string')
-            return;
-        if (!data.id)
-            return;
-        log('received', data.type, data.id, data.error ? `error: ${data.error}` : '');
-        switch (data.type) {
-            case SDK_MSG.COMMAND_INVOKE:
-                handleCommandInvoke(data);
-                return;
-            case SDK_MSG.OS_CONFIG_UPDATE:
-                handleOsConfigUpdate(data);
-                return;
-            case SDK_MSG.GRAPH_EVENT:
-                handleGraphEvent(data);
-                return;
-            case SDK_MSG.INIT_ACK:
-            case SDK_MSG.RESPONSE:
-                handlePendingResponse(data);
-                return;
-            default:
-                return;
-        }
-    }
-    hostWindow.addEventListener('message', onMessage);
-    function postToHost(message) {
-        hostWindow.parent.postMessage(message, targetOrigin);
-    }
-    function respondToHost(id, payload, error) {
-        postToHost({
-            type: SDK_MSG.RESPONSE,
-            id,
-            payload: error ? undefined : payload,
-            error,
-        });
-    }
-    function send(type, payload) {
-        if (_destroyed)
-            throw new Error('Bridge is destroyed — cannot send messages');
-        const id = nextId();
-        const msg = { type, id, payload };
-        log('sending', type, id);
-        postToHost(msg);
-        return id;
-    }
-    function request(type, payload, timeout = 60000) {
-        return new Promise((resolve, reject) => {
-            const id = send(type, payload);
-            pending.set(id, { resolve, reject });
-            setTimeout(() => {
-                if (pending.has(id)) {
-                    pending.delete(id);
-                    reject(new Error(`SDK request ${type} timed out after ${timeout}ms`));
-                }
-            }, timeout);
-        });
-    }
-    const storage = {
-        get: key => request(SDK_MSG.STORAGE_GET, { key }),
-        set: (key, value) => request(SDK_MSG.STORAGE_SET, { key, value }),
-        delete: key => request(SDK_MSG.STORAGE_DELETE, { key }),
-        keys: () => request(SDK_MSG.STORAGE_KEYS, {}),
-    };
-    const baseRequest = (payload) => {
-        log('[SDK] transport.request', payload);
-        return request(SDK_MSG.TRANSPORT, payload);
-    };
-    const transport = {
-        graph: new GraphTransport(baseRequest, { debug }),
-        os: new OsTransport(baseRequest),
-        backend: routeKey => new BackendTransport(baseRequest, routeKey),
-    };
-    function idb(storeName) {
-        const normalizedStoreName = assertStoreName(storeName);
-        return {
-            get: key => request(SDK_MSG.IDB_GET, { storeName: normalizedStoreName, key }),
-            put: (key, value) => request(SDK_MSG.IDB_PUT, { storeName: normalizedStoreName, key, value }),
-            delete: key => request(SDK_MSG.IDB_DELETE, { storeName: normalizedStoreName, key }),
-            query: (options = {}) => request(SDK_MSG.IDB_QUERY, {
-                storeName: normalizedStoreName,
-                prefix: options.prefix,
-                limit: options.limit,
-            }),
-        };
-    }
-    const events = {
-        subscribe({ types }, handler) {
-            const subscriptionId = nextId();
-            eventHandlers.set(subscriptionId, handler);
-            // Fire-and-forget the ack: the app-generated id removes any race, so a
-            // failed ack only means no events will arrive — surface it and clean up.
-            request(SDK_MSG.EVENT_SUBSCRIBE, { subscriptionId, types }).catch((error) => {
-                eventHandlers.delete(subscriptionId);
-                console.error('[app-sdk] events.subscribe failed:', error);
-            });
-            return () => {
-                if (!eventHandlers.delete(subscriptionId)) {
-                    return;
-                }
-                if (_destroyed) {
-                    return;
-                }
-                send(SDK_MSG.EVENT_UNSUBSCRIBE, { subscriptionId });
-            };
-        },
-    };
-    const bridge = {
-        get connected() {
-            return _connected;
-        },
-        get context() {
-            return _context;
-        },
-        async connect() {
-            if (_connected && _context)
-                return _context;
-            const result = await request(SDK_MSG.INIT, { appId: hintAppId }, connectTimeout);
-            _context = result;
-            _connected = true;
-            return result;
-        },
-        notify(message, level = 'info') {
-            send(SDK_MSG.NOTIFY, { message, level });
-        },
-        storage,
-        transport,
-        idb,
-        events,
-        setCommands(commands) {
-            const payload = { commands };
-            return request(SDK_MSG.SET_COMMANDS, payload);
-        },
-        setMenu(menu) {
-            const payload = { menu };
-            return request(SDK_MSG.SET_MENU, payload);
-        },
-        setActiveTab(activeTab) {
-            const payload = { activeTab };
-            return request(SDK_MSG.SET_ACTIVE_TAB, payload);
-        },
-        sendShortcutEvent(payload) {
-            send(SDK_MSG.SHORTCUT_EVENT, payload);
-        },
-        registerCommandHandlers(handlers) {
-            for (const [commandId, handler] of Object.entries(handlers)) {
-                commandHandlers.set(commandId, handler);
-            }
-            return () => {
-                for (const [commandId, handler] of Object.entries(handlers)) {
-                    if (commandHandlers.get(commandId) === handler) {
-                        commandHandlers.delete(commandId);
-                    }
-                }
-            };
-        },
-        onOsConfigUpdate(callback) {
-            osConfigUpdateCallbacks.add(callback);
-            return () => {
-                osConfigUpdateCallbacks.delete(callback);
-            };
-        },
-        /**
-         * @deprecated Legacy/internal only. Hosted apps should use scoped SDK APIs
-         * such as `idb`, `transport`, and `launchApp` instead of kernel-proxy.
-         */
-        sendToKernel(kernelType, kernelPayload) {
-            return request(SDK_MSG.KERNEL_PROXY, { kernelType, kernelPayload });
-        },
-        launchApp(appId) {
-            return request(SDK_MSG.LAUNCH_APP, { appId });
-        },
-        destroy() {
-            if (_destroyed)
-                return;
-            log('bridge.destroy(), pending requests:', pending.size);
-            // Best-effort unsubscribe every open stream before flipping the flag.
-            for (const subscriptionId of eventHandlers.keys()) {
-                try {
-                    send(SDK_MSG.EVENT_UNSUBSCRIBE, { subscriptionId });
-                }
-                catch {
-                    // ignore — host will drop the frame on window close anyway
-                }
-            }
-            eventHandlers.clear();
-            _destroyed = true;
-            hostWindow.removeEventListener('message', onMessage);
-            for (const [, p] of pending)
-                p.reject(new Error('Bridge destroyed'));
-            pending.clear();
-            commandHandlers.clear();
-            _connected = false;
-            _context = null;
-        },
-    };
-    return bridge;
-}

package/dist/transports/backend-transport.d.ts

@@ -1,24 +0,0 @@
-import type { BackendRequestOptions, SdkTransportPayload } from '../types.js';
-export declare function isRouteKey(routeKey: string): boolean;
-/**
- * Client for an application's own REST backend, reached through the BFF relay at
- * `/relay/{routeKey}`. The host stamps the calling app id and scope; the BFF checks the
- * app against the route's whitelist and forwards the request with an app-scoped token.
- */
-export declare class BackendTransport {
-    private _request;
-    private readonly routeKey;
-    constructor(_request: <T = unknown>(payload: SdkTransportPayload) => Promise<T>, routeKey: string);
-    /**
-     * Send a request to the backend. `path` is what the backend sees, after the relay
-     * stripped `/relay/{routeKey}`. Scope is required unless stated otherwise: the relay
-     * refuses an app-scoped call without one.
-     *
-     * @throws {EntityNotFoundError} on 404 errors
-     * @throws {ValidationError} on 400 errors
-     * @throws {PermissionError} on 403 errors (app not whitelisted for the route)
-     * @throws {NetworkError} on HTTP errors, including 502 when the backend is unreachable
-     * @throws {TimeoutError} on request timeout
-     */
-    request<T = unknown>(options: BackendRequestOptions): Promise<T>;
-}