@bardioc/app-sdk 0.4.0

package/dist/dev.d.ts

@@ -0,0 +1,33 @@
+export interface InjectedDevAuthConfig {
+    hostUrl?: string;
+    sessionKey?: string;
+    proxyUrl?: string;
+}
+export interface DevAuthSession {
+    sessionKey?: string;
+    hostUrl?: string;
+    scopeId: string | null;
+}
+export interface DevAuthStorageOptions {
+    appId: string;
+    appName?: string;
+    storageKey?: string;
+}
+export interface EnsureDevAuthSessionOptions extends DevAuthStorageOptions {
+    baseUrl?: string;
+    loginPath?: string;
+    redirect?: (url: string) => void;
+}
+export interface DevBridgeOptions extends DevAuthStorageOptions {
+    debug?: boolean;
+    baseUrl?: string;
+    proxyPath?: string;
+}
+export declare function getInjectedDevAuthConfig(): InjectedDevAuthConfig | null;
+export declare function isInsideIframe(): boolean;
+export declare function isDevStandalone(): boolean;
+export declare function getDevSession(options: DevAuthStorageOptions): DevAuthSession | null;
+export declare function getDevScopeId(options: DevAuthStorageOptions): string | null;
+export declare function clearDevAuthSession(options: DevAuthStorageOptions): void;
+export declare function ensureDevAuthSession(options: EnsureDevAuthSessionOptions): Promise<void>;
+export declare function installDevBridge(options: DevBridgeOptions): () => void;

package/dist/dev.js

@@ -0,0 +1,223 @@
+import { SDK_MSG } from './protocol.js';
+function getBaseUrl(baseUrl) {
+    const metaEnv = import.meta.env;
+    return baseUrl ?? metaEnv?.BASE_URL ?? '/';
+}
+function resolveStorageKey(options) {
+    return options.storageKey ?? `bardioc.dev.auth.${options.appName ?? options.appId}`;
+}
+function writeDevSession(storageKey, session) {
+    localStorage.setItem(storageKey, JSON.stringify(session));
+}
+export function getInjectedDevAuthConfig() {
+    const config = globalThis.__BARDIOC_DEV_AUTH__;
+    if (!config?.hostUrl || !config?.sessionKey) {
+        return null;
+    }
+    return {
+        hostUrl: config.hostUrl,
+        sessionKey: config.sessionKey,
+        proxyUrl: typeof config.proxyUrl === 'string' ? config.proxyUrl : undefined,
+    };
+}
+function readStoredSession(storageKey) {
+    const raw = localStorage.getItem(storageKey);
+    if (!raw) {
+        return null;
+    }
+    try {
+        const parsed = JSON.parse(raw);
+        const hasHostSession = typeof parsed.sessionKey === 'string' && typeof parsed.hostUrl === 'string';
+        if (!hasHostSession) {
+            localStorage.removeItem(storageKey);
+            return null;
+        }
+        return {
+            sessionKey: typeof parsed.sessionKey === 'string' ? parsed.sessionKey : undefined,
+            hostUrl: typeof parsed.hostUrl === 'string' ? parsed.hostUrl : undefined,
+            scopeId: typeof parsed.scopeId === 'string' ? parsed.scopeId : null,
+        };
+    }
+    catch {
+        localStorage.removeItem(storageKey);
+        return null;
+    }
+}
+export function isInsideIframe() {
+    const currentWindow = globalThis;
+    return currentWindow.parent !== currentWindow;
+}
+export function isDevStandalone() {
+    const metaEnv = import.meta.env;
+    return Boolean(metaEnv?.DEV) && !isInsideIframe();
+}
+export function getDevSession(options) {
+    return readStoredSession(resolveStorageKey(options));
+}
+export function getDevScopeId(options) {
+    return getDevSession(options)?.scopeId ?? null;
+}
+export function clearDevAuthSession(options) {
+    localStorage.removeItem(resolveStorageKey(options));
+}
+export async function ensureDevAuthSession(options) {
+    const storageKey = resolveStorageKey(options);
+    const url = new URL(window.location.href);
+    const authError = url.searchParams.get('auth_error');
+    if (authError) {
+        console.error('[dev-auth] Authentication failed:', authError);
+        url.searchParams.delete('auth_error');
+        window.history.replaceState({}, '', url.toString());
+        throw new Error(`Authentication failed: ${authError}`);
+    }
+    const injectedConfig = getInjectedDevAuthConfig();
+    if (injectedConfig) {
+        const storedSession = readStoredSession(storageKey);
+        if (storedSession?.hostUrl !== injectedConfig.hostUrl ||
+            storedSession?.sessionKey !== injectedConfig.sessionKey) {
+            writeDevSession(storageKey, {
+                hostUrl: injectedConfig.hostUrl,
+                sessionKey: injectedConfig.sessionKey,
+                scopeId: null,
+            });
+        }
+        return;
+    }
+    const session = readStoredSession(storageKey);
+    if (session?.sessionKey) {
+        return;
+    }
+    const loginPath = options.loginPath ?? 'login';
+    const loginUrl = new URL(loginPath, window.location.origin + getBaseUrl(options.baseUrl)).toString();
+    console.info('[dev-auth] redirecting browser to login', {
+        currentUrl: url.toString(),
+        baseUrl: getBaseUrl(options.baseUrl),
+        loginUrl,
+    });
+    (options.redirect ?? ((nextUrl) => window.location.replace(nextUrl)))(loginUrl);
+    await new Promise(() => { });
+}
+export function installDevBridge(options) {
+    const { appId, debug = false } = options;
+    const origin = window.location.origin;
+    const proxyUrl = new URL(options.proxyPath ?? 'proxy', window.location.origin + getBaseUrl(options.baseUrl)).toString();
+    const readSession = () => getDevSession(options);
+    const log = (...args) => {
+        if (debug) {
+            console.log('[bardioc-dev-bridge]', ...args);
+        }
+    };
+    function reply(id, payload) {
+        window.postMessage({ type: SDK_MSG.RESPONSE, id, payload }, origin);
+    }
+    function replyError(id, error) {
+        window.postMessage({ type: SDK_MSG.RESPONSE, id, payload: null, error }, origin);
+    }
+    function ack(id, payload) {
+        window.postMessage({ type: SDK_MSG.INIT_ACK, id, payload }, origin);
+    }
+    async function handleTransport(payload) {
+        const session = readSession();
+        if (!session?.sessionKey) {
+            throw new Error('No auth session available');
+        }
+        const shouldForwardScope = payload.scopePolicy === 'optional' || payload.scopePolicy === 'required';
+        const forwardedScopeId = shouldForwardScope
+            ? (payload.scopeId ?? session.scopeId ?? null)
+            : null;
+        console.info('[bardioc-dev-bridge][1/2] sending dev session to local proxy', {
+            proxyUrl,
+            appId,
+            path: payload.path,
+            method: payload.method ?? 'GET',
+            scopePolicy: payload.scopePolicy ?? 'none',
+            forwardedScopeId,
+            hasDevSessionKey: !!session.sessionKey,
+            nextStep: 'local_proxy_relays_to_host_transport',
+        });
+        const response = await fetch(proxyUrl, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                sessionKey: session.sessionKey,
+                hostUrl: session.hostUrl,
+                scopeId: forwardedScopeId,
+                path: payload.path,
+                method: payload.method ?? 'GET',
+                body: payload.body,
+                contentType: payload.contentType,
+                scopePolicy: payload.scopePolicy,
+            }),
+            cache: 'no-store',
+        });
+        const text = await response.text();
+        let data = null;
+        if (text) {
+            try {
+                data = JSON.parse(text);
+            }
+            catch {
+                data = text;
+            }
+        }
+        if (!response.ok) {
+            console.error('[bardioc-dev-bridge] proxy request failed', {
+                proxyUrl,
+                path: payload.path,
+                method: payload.method ?? 'GET',
+                status: response.status,
+                failureStage: response.headers.get('X-Bardioc-Dev-Auth-Stage'),
+                responsePayload: data,
+            });
+            const err = new Error(`Transport ${payload.path} failed: ${response.status}`);
+            Object.assign(err, { status: response.status, responsePayload: data });
+            throw err;
+        }
+        return data;
+    }
+    async function handleKernelProxy(payload) {
+        if (payload.kernelType === 'PING') {
+            return { pong: true };
+        }
+        if (payload.kernelType === 'GET_SESSION_STATE') {
+            const session = readSession();
+            return { authenticated: !!session?.sessionKey };
+        }
+        throw new Error(`Kernel message ${payload.kernelType} not supported in dev bridge`);
+    }
+    async function onMessage(event) {
+        if (event.origin !== origin) {
+            return;
+        }
+        const data = event.data;
+        if (!data || typeof data.type !== 'string' || !data.id) {
+            return;
+        }
+        if (data.type === SDK_MSG.RESPONSE || data.type === SDK_MSG.INIT_ACK) {
+            return;
+        }
+        log('handle', data.type, data.id);
+        try {
+            switch (data.type) {
+                case SDK_MSG.INIT:
+                    ack(data.id, { appId, instanceId: null });
+                    return;
+                case SDK_MSG.NOTIFY:
+                    return;
+                case SDK_MSG.TRANSPORT:
+                    reply(data.id, await handleTransport(data.payload));
+                    return;
+                case SDK_MSG.KERNEL_PROXY:
+                    reply(data.id, await handleKernelProxy(data.payload));
+                    return;
+                default:
+                    replyError(data.id, `Dev bridge does not implement ${data.type}`);
+            }
+        }
+        catch (error) {
+            replyError(data.id, error instanceof Error ? error.message : 'unknown error');
+        }
+    }
+    window.addEventListener('message', onMessage);
+    return () => window.removeEventListener('message', onMessage);
+}

package/dist/dot-env.d.ts

@@ -0,0 +1,2 @@
+export declare function readDotEnvFile(filePath: string): Record<string, string>;
+export declare function readDotEnvValue(filePath: string, key: string): string | null;

package/dist/dot-env.js

@@ -0,0 +1,22 @@
+import { readFileSync } from 'node:fs';
+export function readDotEnvFile(filePath) {
+    const env = {};
+    const fileContents = readFileSync(filePath, 'utf8');
+    for (const line of fileContents.split(/\r?\n/)) {
+        const trimmedLine = line.trim();
+        if (!trimmedLine || trimmedLine.startsWith('#')) {
+            continue;
+        }
+        const separatorIndex = trimmedLine.indexOf('=');
+        if (separatorIndex <= 0) {
+            continue;
+        }
+        const key = trimmedLine.slice(0, separatorIndex).trim();
+        const rawValue = trimmedLine.slice(separatorIndex + 1).trim();
+        env[key] = rawValue.replace(/^['"]|['"]$/g, '');
+    }
+    return env;
+}
+export function readDotEnvValue(filePath, key) {
+    return readDotEnvFile(filePath)[key] ?? null;
+}

package/dist/errors.d.ts

@@ -0,0 +1,27 @@
+/** Base SDK error class with structured error information */
+export declare class SdkError extends Error {
+    code: string;
+    statusCode?: number | undefined;
+    context?: Record<string, unknown> | undefined;
+    constructor(message: string, code: string, statusCode?: number | undefined, context?: Record<string, unknown> | undefined);
+}
+/** Request timeout error */
+export declare class TimeoutError extends SdkError {
+    constructor(operation: string, timeoutMs: number);
+}
+/** Network/HTTP error (4xx, 5xx) */
+export declare class NetworkError extends SdkError {
+    constructor(message: string, statusCode: number);
+}
+/** Invalid parameters or validation error */
+export declare class ValidationError extends SdkError {
+    constructor(message: string, field?: string);
+}
+/** Missing permissions error */
+export declare class PermissionError extends SdkError {
+    constructor(permission: string);
+}
+/** Entity not found error (404) */
+export declare class EntityNotFoundError extends SdkError {
+    constructor(id: string);
+}

package/dist/errors.js

@@ -0,0 +1,57 @@
+/** Base SDK error class with structured error information */
+export class SdkError extends Error {
+    code;
+    statusCode;
+    context;
+    constructor(message, code, statusCode, context) {
+        super(message);
+        this.code = code;
+        this.statusCode = statusCode;
+        this.context = context;
+        this.name = 'SdkError';
+        Object.setPrototypeOf(this, SdkError.prototype);
+    }
+}
+/** Request timeout error */
+export class TimeoutError extends SdkError {
+    constructor(operation, timeoutMs) {
+        super(`Operation '${operation}' timed out after ${timeoutMs}ms`, 'TIMEOUT', undefined, {
+            operation,
+            timeoutMs,
+        });
+        this.name = 'TimeoutError';
+        Object.setPrototypeOf(this, TimeoutError.prototype);
+    }
+}
+/** Network/HTTP error (4xx, 5xx) */
+export class NetworkError extends SdkError {
+    constructor(message, statusCode) {
+        super(message, 'NETWORK_ERROR', statusCode);
+        this.name = 'NetworkError';
+        Object.setPrototypeOf(this, NetworkError.prototype);
+    }
+}
+/** Invalid parameters or validation error */
+export class ValidationError extends SdkError {
+    constructor(message, field) {
+        super(message, 'VALIDATION_ERROR', 400, field ? { field } : undefined);
+        this.name = 'ValidationError';
+        Object.setPrototypeOf(this, ValidationError.prototype);
+    }
+}
+/** Missing permissions error */
+export class PermissionError extends SdkError {
+    constructor(permission) {
+        super(`Missing required permission: ${permission}`, 'PERMISSION_ERROR', 403, { permission });
+        this.name = 'PermissionError';
+        Object.setPrototypeOf(this, PermissionError.prototype);
+    }
+}
+/** Entity not found error (404) */
+export class EntityNotFoundError extends SdkError {
+    constructor(id) {
+        super(`Entity not found: ${id}`, 'ENTITY_NOT_FOUND', 404, { id });
+        this.name = 'EntityNotFoundError';
+        Object.setPrototypeOf(this, EntityNotFoundError.prototype);
+    }
+}

package/dist/host-bridge.d.ts

@@ -0,0 +1,3 @@
+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

@@ -0,0 +1,260 @@
+import { getInjectedDevAuthConfig } from './dev.js';
+import { SDK_MSG } from './protocol.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 });
+    const standaloneDevAuthActive = !isInsideIframe && !!getInjectedDevAuthConfig();
+    if (!isInsideIframe && !standaloneDevAuthActive) {
+        console.warn('[app-sdk] NOT inside an iframe — bridge will not work standalone.');
+    }
+    let _connected = false;
+    let _context = null;
+    let _destroyed = false;
+    const commandHandlers = new Map();
+    const osConfigUpdateCallbacks = new Set();
+    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 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.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),
+    };
+    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 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,
+        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);
+            _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/index.d.ts

@@ -0,0 +1,9 @@
+export { createHostBridge } from './host-bridge.js';
+export { DEFAULT_WINDOW_SIZE, MANIFEST_FILENAME, WINDOW_SIZES, validateManifest, } from './manifest.js';
+export type { AppManifest, AppManifestPermission, AppManifestWindowConfig, CustomWindowSize, WindowSizePreset, } from './manifest.js';
+export { useOsConfig } from './react.js';
+export { SDK_CONTRACT_MATRIX, getRequiredPermissionForSdkMessage } from './contract-matrix.js';
+export { ALLOWED_KERNEL_MESSAGES, SDK_MSG } from './protocol.js';
+export type { SdkMessageType } from './protocol.js';
+export { EntityNotFoundError, NetworkError, PermissionError, SdkError, TimeoutError, ValidationError, } from './errors.js';
+export type { Application, BatchResult, Configuration, CreateMemberInput, CreateUnitInput, DeleteOptions, FileEntry, GetNodeOptions, GraphEdgeRaw, GraphNodeRaw, GraphTransport, GremlinOptions, HistoryEntry, HistoryOptions, HostBridge, HostBridgeConfig, InstanceList, MutationOptions, NotifyLevel, OrgMember, OrgStructure, OrgUnit, OsConfig, OsRequestOptions, OsTransport, QueryOptions, SdkCommandDefinition, SdkCommandHandler, SdkCommandInvokePayload, SdkIdbDeletePayload, SdkIdbEntry, SdkIdbGetPayload, SdkIdbPutPayload, SdkIdbQueryPayload, SdkIdbStore, SdkInitResponse, SdkKernelProxyPayload, SdkMenuItem, SdkMenuRoot, SdkMessage, SdkNotifyPayload, SdkResponse, SdkSetActiveTabPayload, SdkSetCommandsPayload, SdkSetMenuPayload, SdkShortcutEventPayload, SdkStorage, SdkStorageDeletePayload, SdkStorageGetPayload, SdkStorageSetPayload, SdkTransport, SdkTransportPayload, TimeseriesOptions, TimeseriesQueryOptions, TimeseriesValue, TransportScopeOptions, UpdateMemberInput, UpdateUnitInput, UserProfile, } from './types.js';

package/dist/index.js

@@ -0,0 +1,6 @@
+export { createHostBridge } from './host-bridge.js';
+export { DEFAULT_WINDOW_SIZE, MANIFEST_FILENAME, WINDOW_SIZES, validateManifest, } from './manifest.js';
+export { useOsConfig } from './react.js';
+export { SDK_CONTRACT_MATRIX, getRequiredPermissionForSdkMessage } from './contract-matrix.js';
+export { ALLOWED_KERNEL_MESSAGES, SDK_MSG } from './protocol.js';
+export { EntityNotFoundError, NetworkError, PermissionError, SdkError, TimeoutError, ValidationError, } from './errors.js';