@bardioc/app-sdk 0.5.0 → 1.0.0

package/dist/api/os.js

@@ -0,0 +1,48 @@
+import { json } from './request.js';
+const segment = encodeURIComponent;
+/** The Bardioc OS API, called through the host. */
+export function osApi(request) {
+    const unit = (id) => `/os/organization/units/${segment(id)}`;
+    const member = (id) => `/os/organization/members/${segment(id)}`;
+    const app = (id, suffix = '') => `/os/applications/${segment(id)}${suffix}`;
+    return {
+        profile: {
+            get: () => request({ path: '/os/me/profile' }),
+            getAvatar: () => request({ path: '/os/me/avatar' }),
+            setAvatar: (image) => request({
+                path: '/os/me/avatar',
+                method: 'POST',
+                body: image,
+                contentType: 'application/octet-stream',
+            }),
+            getInstances: () => request({ path: '/os/me/instances' }),
+        },
+        organization: {
+            getStructure: () => request({ path: '/os/organization/structure' }),
+            createUnit: (data) => request({ path: '/os/organization/units', ...json(data) }),
+            updateUnit: (id, data) => request({ path: unit(id), ...json(data, 'PATCH') }),
+            createMember: (data) => request({ path: '/os/organization/members', ...json(data) }),
+            updateMember: (id, data) => request({ path: member(id), ...json(data, 'PATCH') }),
+            deleteMember: (id) => request({ path: member(id), method: 'DELETE' }),
+            inviteMember: (id) => request({
+                path: `${member(id)}/invite`,
+                method: 'POST',
+                contentType: 'application/json',
+            }),
+        },
+        applications: {
+            list: () => request({ path: '/os/applications' }),
+            get: (id) => request({ path: app(id) }),
+            upload: (id, zip) => request({
+                path: app(id, '/upload'),
+                method: 'POST',
+                body: zip,
+                contentType: 'application/zip',
+            }),
+            download: (id) => request({ path: app(id, '/download') }),
+            getFiles: (id) => request({ path: app(id, '/files') }),
+            getFile: (id, path) => request({ path: app(id, `/files/${segment(path)}`) }),
+            getConfigurations: (id) => request({ path: app(id, '/configurations') }),
+        },
+    };
+}

package/dist/api/relay.d.ts

@@ -0,0 +1,7 @@
+import type { BffRequest } from '../contract.js';
+import type { BffRequester } from './request.js';
+/** An application's own backend, reached through the BFF relay; scoped unless told otherwise. */
+export declare function relayApi(request: BffRequester, routeKey: string): {
+    request: <T = unknown>({ path, ...rest }: BffRequest) => Promise<T>;
+};
+export type RelayApi = ReturnType<typeof relayApi>;

package/dist/api/relay.js

@@ -0,0 +1,16 @@
+import { BardiocError } from '../errors.js';
+// Mirrors the BFF's route key rule: one path segment, "." and ".." excluded.
+const ROUTE_KEY = /^[A-Za-z0-9._-]+$/;
+/** An application's own backend, reached through the BFF relay; scoped unless told otherwise. */
+export function relayApi(request, routeKey) {
+    if (routeKey === '.' || routeKey === '..' || !ROUTE_KEY.test(routeKey)) {
+        throw new BardiocError('invalid', `Invalid relay route key "${routeKey}"`);
+    }
+    return {
+        request: ({ path, ...rest }) => request({
+            scopePolicy: 'required',
+            ...rest,
+            path: `/relay/${routeKey}${path.startsWith('/') ? path : `/${path}`}`,
+        }),
+    };
+}

package/dist/api/request.d.ts

@@ -0,0 +1,18 @@
+import type { BffRequest } from '../contract.js';
+import type { TransportScopeOptions } from '../types.js';
+export type BffRequester = <T>(request: BffRequest) => Promise<T>;
+type QueryValue = string | number | boolean | undefined;
+export declare function withQuery(path: string, params: Record<string, QueryValue>): string;
+export declare const json: (body: unknown, method?: BffRequest["method"]) => {
+    readonly method: "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
+    readonly body: unknown;
+    readonly contentType: "application/json";
+};
+export declare const scoped: ({ scopeId }?: TransportScopeOptions) => {
+    readonly scopeId: string;
+    readonly scopePolicy: "required";
+} | {
+    readonly scopeId?: undefined;
+    readonly scopePolicy?: undefined;
+};
+export {};

package/dist/api/request.js

@@ -0,0 +1,12 @@
+export function withQuery(path, params) {
+    const query = new URLSearchParams();
+    for (const [key, value] of Object.entries(params)) {
+        if (value !== undefined && value !== '')
+            query.set(key, String(value));
+    }
+    const search = query.toString();
+    return search ? `${path}?${search}` : path;
+}
+export const json = (body, method = 'POST') => ({ method, body, contentType: 'application/json' });
+// An explicit scope must hold; without one the host applies the window's instance.
+export const scoped = ({ scopeId } = {}) => scopeId ? { scopeId, scopePolicy: 'required' } : {};

package/dist/client.d.ts

@@ -0,0 +1,104 @@
+import { type AppRecord, type AppUpload, type BffRequest, type Command, type Context, type GraphEvent, type IdbEntry, type MenuRoot, type NotifyLevel, type Shortcut } from './contract.js';
+declare function open(port: MessagePort, initial: Context): {
+    readonly context: Context;
+    onContextChange: (listener: (context: Context) => void) => () => void;
+    ui: {
+        notify: (message: string, level?: NotifyLevel) => Promise<void>;
+        setCommands: (commands: Command[]) => Promise<void>;
+        setMenu: (menu: MenuRoot[] | null) => Promise<void>;
+        setActiveTab: (activeTab: string | null) => Promise<void>;
+        shortcut: (shortcut: Shortcut) => Promise<void>;
+        /** Runs `run` when the host invokes the command; the returned function unregisters it. */
+        onCommand: (id: string, run: () => unknown) => () => void;
+    };
+    bff: {
+        request: <T = unknown>(bffRequest: BffRequest, options?: {
+            signal?: AbortSignal;
+        }) => Promise<T>;
+    };
+    graph: {
+        get: <T = import("./types.js").GraphNodeRaw>(id: string, options?: import("./types.js").GetNodeOptions) => Promise<T>;
+        getMany: <T = import("./types.js").GraphNodeRaw>(ids: string[], options?: import("./types.js").GetNodeOptions) => Promise<(T | undefined)[]>;
+        getByXid: <T = import("./types.js").GraphNodeRaw>(xid: string, options?: import("./types.js").GetNodeOptions) => Promise<T>;
+        query: <T = import("./types.js").GraphNodeRaw>(lucene: string, options?: import("./types.js").QueryOptions) => Promise<T[]>;
+        gremlin: <T = unknown>(rootId: string, query: string, options?: import("./types.js").GremlinOptions) => Promise<T[]>;
+        combined: <T = unknown>(elasticsearchQuery: string, gremlinQuery: string, options?: import("./types.js").CombinedQueryOptions) => Promise<T[]>;
+        create: <T = import("./types.js").GraphNodeRaw>(type: string, data: Record<string, unknown>, options?: import("./types.js").MutationOptions) => Promise<T>;
+        update: <T = import("./types.js").GraphNodeRaw>(id: string, data: Record<string, unknown>, options?: import("./types.js").MutationOptions) => Promise<T>;
+        delete: (id: string, options?: import("./types.js").DeleteOptions) => Promise<void>;
+        connect: <T = import("./types.js").GraphEdgeRaw>(from: string, to: string, type: string, options?: import("./types.js").MutationOptions) => Promise<T>;
+        history: (id: string, options?: import("./types.js").HistoryOptions) => Promise<import("./types.js").HistoryEntry[]>;
+        batch: {
+            delete: (ids: string[], options?: import("./types.js").DeleteOptions) => Promise<import("./types.js").BatchResult>;
+        };
+        timeseries: {
+            get: (id: string, options?: import("./types.js").TimeseriesOptions) => Promise<import("./types.js").TimeseriesValue[]>;
+            add: (id: string, values: import("./types.js").TimeseriesValue[], options?: import("./types.js").TransportScopeOptions) => Promise<void>;
+            query: (options: import("./types.js").TimeseriesQueryOptions) => Promise<import("./types.js").TimeseriesValue[]>;
+            history: (id: string, timestamp: number, options?: import("./types.js").TimeseriesHistoryOptions) => Promise<import("./types.js").TimeseriesHistory>;
+        };
+        content: {
+            set: (id: string, data: Blob, contentType: string, options?: import("./types.js").TransportScopeOptions) => Promise<string>;
+            get: (id: string, contentId: string, options?: import("./types.js").TransportScopeOptions) => Promise<Blob>;
+        };
+    };
+    os: {
+        profile: {
+            get: () => Promise<import("./types.js").UserProfile>;
+            getAvatar: () => Promise<Blob>;
+            setAvatar: (image: Blob) => Promise<void>;
+            getInstances: () => Promise<import("./types.js").InstanceList>;
+        };
+        organization: {
+            getStructure: () => Promise<import("./types.js").OrgStructure>;
+            createUnit: (data: import("./types.js").CreateUnitInput) => Promise<import("./types.js").OrgUnit>;
+            updateUnit: (id: string, data: import("./types.js").UpdateUnitInput) => Promise<import("./types.js").OrgUnit>;
+            createMember: (data: import("./types.js").CreateMemberInput) => Promise<import("./types.js").OrgMember>;
+            updateMember: (id: string, data: import("./types.js").UpdateMemberInput) => Promise<import("./types.js").OrgMember>;
+            deleteMember: (id: string) => Promise<void>;
+            inviteMember: (id: string) => Promise<void>;
+        };
+        applications: {
+            list: () => Promise<import("./types.js").Application[]>;
+            get: (id: string) => Promise<import("./types.js").Application>;
+            upload: (id: string, zip: Blob) => Promise<void>;
+            download: (id: string) => Promise<Blob>;
+            getFiles: (id: string) => Promise<import("./types.js").FileEntry[]>;
+            getFile: (id: string, path: string) => Promise<string>;
+            getConfigurations: (id: string) => Promise<import("./types.js").Configuration[]>;
+        };
+    };
+    relay: (routeKey: string) => {
+        request: <T = unknown>({ path, ...rest }: BffRequest) => Promise<T>;
+    };
+    idb: (store: string) => {
+        get: <T = unknown>(key: string) => Promise<IdbEntry<T> | null>;
+        put: (key: string, value: unknown) => Promise<void>;
+        delete: (key: string) => Promise<void>;
+        query: <T = unknown>(options?: {
+            prefix?: string;
+            limit?: number;
+        }) => Promise<IdbEntry<T>[]>;
+    };
+    events: {
+        /** Streams graph events of `types`; resolves to the function that ends the stream. */
+        graph: (filter: {
+            types: string[];
+        }, onEvent: (event: GraphEvent) => void) => Promise<() => void>;
+    };
+    apps: {
+        list: () => Promise<import("./contract.js").InstalledApp[]>;
+        get: (id: string) => Promise<import("./contract.js").InstalledApp>;
+        save: (app: AppRecord) => Promise<import("./contract.js").InstalledApp>;
+        delete: (id: string) => Promise<void>;
+        /** The file contents are transferred to the host and unusable here afterwards. */
+        upload: (upload: AppUpload) => Promise<import("./contract.js").UploadResult>;
+        launch: (id: string) => Promise<{
+            windowId: string | null;
+        }>;
+    };
+};
+export type Bardioc = ReturnType<typeof open>;
+/** Connects this document to its host; every call shares the one connection. */
+export declare function connect(): Promise<Bardioc>;
+export {};

package/dist/client.js

@@ -0,0 +1,106 @@
+import { graphApi } from './api/graph.js';
+import { osApi } from './api/os.js';
+import { relayApi } from './api/relay.js';
+import { APP_METHODS, PROTOCOL_VERSION, } from './contract.js';
+import { BardiocError } from './errors.js';
+import { isHandshake, Peer, readStream, READY } from './wire.js';
+const CONNECT_TIMEOUT_MS = 10_000;
+function handshake() {
+    const host = window.parent;
+    return new Promise((resolve, reject) => {
+        const settle = (done) => {
+            clearTimeout(timer);
+            window.removeEventListener('message', onMessage);
+            done();
+        };
+        const timer = setTimeout(() => settle(() => reject(new BardiocError('unavailable', 'No Bardioc host answered'))), CONNECT_TIMEOUT_MS);
+        const onMessage = ({ source, data, ports: [port] }) => {
+            if (source !== host || !isHandshake(data))
+                return;
+            if (data.bardioc === 'connect' && port) {
+                settle(() => resolve({ port, context: data.context }));
+            }
+            else if (data.bardioc === 'reject') {
+                const message = `The host speaks protocol ${data.protocol}, this SDK ${PROTOCOL_VERSION}`;
+                settle(() => reject(new BardiocError('protocol', message)));
+            }
+        };
+        window.addEventListener('message', onMessage);
+        host.postMessage(READY, '*');
+    });
+}
+function open(port, initial) {
+    let context = initial;
+    const commands = new Map();
+    const runCommand = async (params) => {
+        const { id } = params;
+        const run = commands.get(id);
+        if (!run)
+            throw new BardiocError('not_found', `Command ${id} is not registered`);
+        await run();
+    };
+    const peer = new Peer(port, new Map([['ui.command', runCommand]]));
+    peer.on('context.changed', next => (context = next));
+    const call = (method, params, options = {}) => peer.call(method, params, {
+        timeoutMs: APP_METHODS[method].timeoutMs,
+        ...options,
+    });
+    const request = (bffRequest, options) => call('bff.request', bffRequest, options);
+    return {
+        get context() {
+            return context;
+        },
+        onContextChange: (listener) => peer.on('context.changed', next => listener(next)),
+        ui: {
+            notify: (message, level = 'info') => call('ui.notify', { message, level }),
+            setCommands: (commands) => call('ui.setCommands', { commands }),
+            setMenu: (menu) => call('ui.setMenu', { menu }),
+            setActiveTab: (activeTab) => call('ui.setActiveTab', { activeTab }),
+            shortcut: (shortcut) => call('ui.shortcut', shortcut),
+            /** Runs `run` when the host invokes the command; the returned function unregisters it. */
+            onCommand: (id, run) => {
+                commands.set(id, run);
+                return () => {
+                    if (commands.get(id) === run)
+                        commands.delete(id);
+                };
+            },
+        },
+        bff: { request },
+        graph: graphApi(request),
+        os: osApi(request),
+        relay: (routeKey) => relayApi(request, routeKey),
+        idb: (store) => ({
+            get: (key) => call('idb.get', { store, key }),
+            put: (key, value) => call('idb.put', { store, key, value }),
+            delete: (key) => call('idb.delete', { store, key }),
+            query: (options = {}) => call('idb.query', { store, ...options }),
+        }),
+        events: {
+            /** Streams graph events of `types`; resolves to the function that ends the stream. */
+            graph: async (filter, onEvent) => {
+                const { timeoutMs } = APP_METHODS['events.graph'];
+                const stream = (await peer.call('events.graph', filter, { timeoutMs }));
+                return readStream(stream, event => onEvent(event));
+            },
+        },
+        apps: {
+            list: () => call('apps.list', undefined),
+            get: (id) => call('apps.get', { id }),
+            save: (app) => call('apps.save', app),
+            delete: (id) => call('apps.delete', { id }),
+            /** The file contents are transferred to the host and unusable here afterwards. */
+            upload: (upload) => call('apps.upload', upload, { transfer: upload.files.map(file => file.content) }),
+            launch: (id) => call('apps.launch', { id }),
+        },
+    };
+}
+let connecting;
+/** Connects this document to its host; every call shares the one connection. */
+export function connect() {
+    connecting ??= handshake().then(({ port, context }) => open(port, context), (error) => {
+        connecting = undefined;
+        throw error;
+    });
+    return connecting;
+}

package/dist/contract.d.ts

@@ -0,0 +1,294 @@
+import * as z from 'zod/mini';
+export declare const PROTOCOL_VERSION = 1;
+export interface CallMethod<I extends z.ZodMiniType = z.ZodMiniType, O = unknown> {
+    readonly kind: 'call';
+    readonly input: I;
+    readonly timeoutMs: number;
+    readonly output?: O;
+}
+export interface StreamMethod<I extends z.ZodMiniType = z.ZodMiniType, O = unknown> {
+    readonly kind: 'stream';
+    readonly input: I;
+    readonly timeoutMs: number;
+    readonly output?: O;
+}
+export type Method = CallMethod | StreamMethod;
+declare const Command: z.ZodMiniObject<{
+    id: z.ZodMiniString<string>;
+    title: z.ZodMiniOptional<z.ZodMiniString<string>>;
+    disabled: z.ZodMiniOptional<z.ZodMiniBoolean<boolean>>;
+    checked: z.ZodMiniOptional<z.ZodMiniBoolean<boolean>>;
+}, z.core.$strict>;
+export type MenuItem = {
+    type: 'command';
+    commandId: string;
+    label?: string;
+    leftIcon?: string;
+    separatorAbove?: boolean;
+    shortcut?: string;
+    variant?: 'default' | 'destructive';
+} | {
+    type: 'submenu';
+    label: string;
+    leftIcon?: string;
+    separatorAbove?: boolean;
+    contentWidth?: string;
+    items: MenuItem[];
+};
+declare const MenuRoot: z.ZodMiniObject<{
+    label: z.ZodMiniString<string>;
+    kind: z.ZodMiniOptional<z.ZodMiniEnum<{
+        app: "app";
+        menu: "menu";
+    }>>;
+    leftIcon: z.ZodMiniOptional<z.ZodMiniString<string>>;
+    contentWidth: z.ZodMiniOptional<z.ZodMiniString<string>>;
+    items: z.ZodMiniArray<z.ZodMiniType<MenuItem, unknown, z.core.$ZodTypeInternals<MenuItem, unknown>>>;
+}, z.core.$strict>;
+declare const Notify: z.ZodMiniObject<{
+    message: z.ZodMiniString<string>;
+    level: z.ZodMiniEnum<{
+        success: "success";
+        error: "error";
+        info: "info";
+        warning: "warning";
+    }>;
+}, z.core.$strict>;
+declare const Shortcut: z.ZodMiniObject<{
+    code: z.ZodMiniString<string>;
+    ctrlKey: z.ZodMiniBoolean<boolean>;
+    metaKey: z.ZodMiniBoolean<boolean>;
+    altKey: z.ZodMiniBoolean<boolean>;
+    shiftKey: z.ZodMiniBoolean<boolean>;
+}, z.core.$strict>;
+declare const BffRequest: z.ZodMiniObject<{
+    path: z.ZodMiniString<string>;
+    method: z.ZodMiniOptional<z.ZodMiniEnum<{
+        GET: "GET";
+        POST: "POST";
+        PUT: "PUT";
+        PATCH: "PATCH";
+        DELETE: "DELETE";
+    }>>;
+    body: z.ZodMiniOptional<z.ZodMiniUnknown>;
+    contentType: z.ZodMiniOptional<z.ZodMiniString<string>>;
+    scopeId: z.ZodMiniOptional<z.ZodMiniString<string>>;
+    scopePolicy: z.ZodMiniOptional<z.ZodMiniEnum<{
+        none: "none";
+        optional: "optional";
+        required: "required";
+    }>>;
+}, z.core.$strict>;
+declare const AppRecord: z.ZodMiniObject<{
+    id: z.ZodMiniString<string>;
+    name: z.ZodMiniString<string>;
+    version: z.ZodMiniString<string>;
+    launchUrl: z.ZodMiniString<string>;
+    source: z.ZodMiniEnum<{
+        uploaded: "uploaded";
+        dev: "dev";
+    }>;
+    description: z.ZodMiniOptional<z.ZodMiniString<string>>;
+    icon: z.ZodMiniOptional<z.ZodMiniString<string>>;
+    appId: z.ZodMiniOptional<z.ZodMiniString<string>>;
+    bundleSize: z.ZodMiniOptional<z.ZodMiniNumberFormat>;
+    fileCount: z.ZodMiniOptional<z.ZodMiniNumberFormat>;
+}, z.core.$strict>;
+declare const AppUpload: z.ZodMiniObject<{
+    alias: z.ZodMiniString<string>;
+    name: z.ZodMiniString<string>;
+    files: z.ZodMiniArray<z.ZodMiniObject<{
+        path: z.ZodMiniString<string>;
+        content: z.ZodMiniCustom<ArrayBuffer, ArrayBuffer>;
+    }, z.core.$strict>>;
+    appId: z.ZodMiniOptional<z.ZodMiniString<string>>;
+    source: z.ZodMiniOptional<z.ZodMiniEnum<{
+        uploaded: "uploaded";
+        dev: "dev";
+    }>>;
+}, z.core.$strict>;
+export type Command = z.infer<typeof Command>;
+export type MenuRoot = z.infer<typeof MenuRoot>;
+export type Shortcut = z.infer<typeof Shortcut>;
+export type NotifyLevel = z.infer<typeof Notify>['level'];
+export type BffRequest = z.infer<typeof BffRequest>;
+export type AppRecord = z.infer<typeof AppRecord>;
+export type AppUpload = z.infer<typeof AppUpload>;
+export interface OsConfig {
+    theme: 'light' | 'dark';
+    language: string;
+    systemSize?: string;
+    tabId: string;
+    windowId: string;
+    instanceId: string | null;
+}
+/** What the host tells an app when it connects, and again whenever it changes. */
+export interface Context {
+    appId: string;
+    host: 'os' | 'dev';
+    osConfig: OsConfig;
+}
+export interface IdbEntry<T = unknown> {
+    key: string;
+    value: T;
+    updatedAt: number;
+}
+export declare const GRAPH_EVENT_TYPES: readonly ["CREATE", "REPLACE", "UPDATE", "CONNECT", "DISCONNECT", "DELETE", "WRITE_TIMESERIES"];
+export interface GraphEvent {
+    id: string;
+    type: (typeof GRAPH_EVENT_TYPES)[number];
+    timestamp: number;
+    nanotime?: number;
+    body?: Record<string, unknown>;
+    metadata?: Record<string, unknown>;
+}
+export interface InstalledApp extends AppRecord {
+    installedAt: number;
+    updatedAt?: number;
+}
+export interface UploadResult {
+    appId: string;
+    name: string;
+    entryUrl: string;
+    runtime: 'iframe-v1';
+    storedFiles: number;
+    totalSize: number;
+}
+/** Methods an app calls on its host. */
+export declare const APP_METHODS: {
+    readonly 'ui.notify': CallMethod<z.ZodMiniObject<{
+        message: z.ZodMiniString<string>;
+        level: z.ZodMiniEnum<{
+            success: "success";
+            error: "error";
+            info: "info";
+            warning: "warning";
+        }>;
+    }, z.core.$strict>, void>;
+    readonly 'ui.setCommands': CallMethod<z.ZodMiniObject<{
+        commands: z.ZodMiniArray<z.ZodMiniObject<{
+            id: z.ZodMiniString<string>;
+            title: z.ZodMiniOptional<z.ZodMiniString<string>>;
+            disabled: z.ZodMiniOptional<z.ZodMiniBoolean<boolean>>;
+            checked: z.ZodMiniOptional<z.ZodMiniBoolean<boolean>>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>, void>;
+    readonly 'ui.setMenu': CallMethod<z.ZodMiniObject<{
+        menu: z.ZodMiniNullable<z.ZodMiniArray<z.ZodMiniObject<{
+            label: z.ZodMiniString<string>;
+            kind: z.ZodMiniOptional<z.ZodMiniEnum<{
+                app: "app";
+                menu: "menu";
+            }>>;
+            leftIcon: z.ZodMiniOptional<z.ZodMiniString<string>>;
+            contentWidth: z.ZodMiniOptional<z.ZodMiniString<string>>;
+            items: z.ZodMiniArray<z.ZodMiniType<MenuItem, unknown, z.core.$ZodTypeInternals<MenuItem, unknown>>>;
+        }, z.core.$strict>>>;
+    }, z.core.$strict>, void>;
+    readonly 'ui.setActiveTab': CallMethod<z.ZodMiniObject<{
+        activeTab: z.ZodMiniNullable<z.ZodMiniString<string>>;
+    }, z.core.$strict>, void>;
+    readonly 'ui.shortcut': CallMethod<z.ZodMiniObject<{
+        code: z.ZodMiniString<string>;
+        ctrlKey: z.ZodMiniBoolean<boolean>;
+        metaKey: z.ZodMiniBoolean<boolean>;
+        altKey: z.ZodMiniBoolean<boolean>;
+        shiftKey: z.ZodMiniBoolean<boolean>;
+    }, z.core.$strict>, void>;
+    readonly 'bff.request': CallMethod<z.ZodMiniObject<{
+        path: z.ZodMiniString<string>;
+        method: z.ZodMiniOptional<z.ZodMiniEnum<{
+            GET: "GET";
+            POST: "POST";
+            PUT: "PUT";
+            PATCH: "PATCH";
+            DELETE: "DELETE";
+        }>>;
+        body: z.ZodMiniOptional<z.ZodMiniUnknown>;
+        contentType: z.ZodMiniOptional<z.ZodMiniString<string>>;
+        scopeId: z.ZodMiniOptional<z.ZodMiniString<string>>;
+        scopePolicy: z.ZodMiniOptional<z.ZodMiniEnum<{
+            none: "none";
+            optional: "optional";
+            required: "required";
+        }>>;
+    }, z.core.$strict>, unknown>;
+    readonly 'events.graph': StreamMethod<z.ZodMiniObject<{
+        types: z.ZodMiniArray<z.ZodMiniString<string>>;
+    }, z.core.$strict>, GraphEvent>;
+    readonly 'idb.get': CallMethod<z.ZodMiniObject<{
+        store: z.ZodMiniString<string>;
+        key: z.ZodMiniString<string>;
+    }, z.core.$strict>, IdbEntry<unknown> | null>;
+    readonly 'idb.put': CallMethod<z.ZodMiniObject<{
+        store: z.ZodMiniString<string>;
+        key: z.ZodMiniString<string>;
+        value: z.ZodMiniUnknown;
+    }, z.core.$strict>, void>;
+    readonly 'idb.delete': CallMethod<z.ZodMiniObject<{
+        store: z.ZodMiniString<string>;
+        key: z.ZodMiniString<string>;
+    }, z.core.$strict>, void>;
+    readonly 'idb.query': CallMethod<z.ZodMiniObject<{
+        store: z.ZodMiniString<string>;
+        prefix: z.ZodMiniOptional<z.ZodMiniString<string>>;
+        limit: z.ZodMiniOptional<z.ZodMiniNumberFormat>;
+    }, z.core.$strict>, IdbEntry<unknown>[]>;
+    readonly 'apps.list': CallMethod<z.ZodMiniUndefined, InstalledApp[]>;
+    readonly 'apps.get': CallMethod<z.ZodMiniObject<{
+        id: z.ZodMiniString<string>;
+    }, z.core.$strict>, InstalledApp>;
+    readonly 'apps.save': CallMethod<z.ZodMiniObject<{
+        id: z.ZodMiniString<string>;
+        name: z.ZodMiniString<string>;
+        version: z.ZodMiniString<string>;
+        launchUrl: z.ZodMiniString<string>;
+        source: z.ZodMiniEnum<{
+            uploaded: "uploaded";
+            dev: "dev";
+        }>;
+        description: z.ZodMiniOptional<z.ZodMiniString<string>>;
+        icon: z.ZodMiniOptional<z.ZodMiniString<string>>;
+        appId: z.ZodMiniOptional<z.ZodMiniString<string>>;
+        bundleSize: z.ZodMiniOptional<z.ZodMiniNumberFormat>;
+        fileCount: z.ZodMiniOptional<z.ZodMiniNumberFormat>;
+    }, z.core.$strict>, InstalledApp>;
+    readonly 'apps.delete': CallMethod<z.ZodMiniObject<{
+        id: z.ZodMiniString<string>;
+    }, z.core.$strict>, void>;
+    readonly 'apps.upload': CallMethod<z.ZodMiniObject<{
+        alias: z.ZodMiniString<string>;
+        name: z.ZodMiniString<string>;
+        files: z.ZodMiniArray<z.ZodMiniObject<{
+            path: z.ZodMiniString<string>;
+            content: z.ZodMiniCustom<ArrayBuffer, ArrayBuffer>;
+        }, z.core.$strict>>;
+        appId: z.ZodMiniOptional<z.ZodMiniString<string>>;
+        source: z.ZodMiniOptional<z.ZodMiniEnum<{
+            uploaded: "uploaded";
+            dev: "dev";
+        }>>;
+    }, z.core.$strict>, UploadResult>;
+    readonly 'apps.launch': CallMethod<z.ZodMiniObject<{
+        id: z.ZodMiniString<string>;
+    }, z.core.$strict>, {
+        windowId: string | null;
+    }>;
+};
+/** Methods a host calls on its app. */
+export declare const HOST_METHODS: {
+    readonly 'ui.command': CallMethod<z.ZodMiniObject<{
+        id: z.ZodMiniString<string>;
+    }, z.core.$strict>, void>;
+};
+/** Events a host pushes to its app. */
+export interface HostEvents {
+    'context.changed': Context;
+}
+export type AppMethods = typeof APP_METHODS;
+export type HostMethods = typeof HOST_METHODS;
+export type Params<M extends Method> = z.infer<M['input']>;
+export type Result<M extends Method> = Exclude<M['output'], undefined>;
+/** The BFF event-stream filter matching any of `types`. */
+export declare function graphEventFilter(types: readonly string[]): string;
+export {};