@omochi-ui/cli 0.0.0-stage → 0.1.0

package/dist/help.js

@@ -0,0 +1,187 @@
+const overview = `omochi-ui — attach a declarative UI to your program
+
+Usage: omochi-ui <command> [options]
+
+Develop an app:
+  dev -- <command> [args...]   Run an app behind a stdio/WebSocket bridge
+  generate catalog           Generate typed bindings from a local catalog
+
+Compose dashboards:
+  up [FILE]                  Start a composition and its dashboard preset
+  hub                        Serve the dashboard UI; auto-start a local gateway
+  gateway                    Publish running apps on this machine
+
+Connect machines:
+  id                         Show or name this machine's identity
+  pair HOST:PORT             Pair with a gateway using its one-time code
+  trust list                 List paired peers
+  trust forget <nodeId>      Remove a paired peer
+
+Start here:
+  omochi-ui dev -- <command>  Preview one app (requires a separate UI server)
+  omochi-ui up --open         Start ./omochi.toml and open its preset
+  omochi-ui hub               Open dashboards at http://127.0.0.1:5555/
+
+Use omochi-ui <command> --help or omochi-ui help <command> for options.
+`;
+const topics = {
+    up: `Start services and a read-only dashboard preset from a TOML composition.
+
+Usage: omochi-ui up [options] [FILE]
+
+Options:
+  --host HOST            Hub bind address (default: 127.0.0.1)
+  --port PORT            Hub port (default: 5555; 0 selects a port)
+  --allow-origin ORIGIN  Allow an additional exact browser origin; repeatable
+  --open                 Open the selected preset in the desktop browser
+
+FILE defaults to ./omochi.toml. Commands run without an implicit shell and
+receive OMOCHI_SERVICE. Utility entries invoke the matching omochi-utils mode.
+The preset is temporary; use Save as dashboard in the hub to keep and edit it.
+If a child service exits, its view becomes unavailable while the hub continues.
+`,
+    dev: `Run an application and bridge its JSONL stdin/stdout to WebSocket.
+
+Usage: omochi-ui dev [options] -- <command> [args...]
+
+Options:
+  --host HOST    Bind address (default: 127.0.0.1)
+  --port PORT    WebSocket port (default: 5555; 0 selects an available port)
+
+This command starts the app and bridge. Start the browser preview separately:
+  bun run --filter @omochi-ui/dev-server dev
+  omochi-ui dev -- uv run --project examples/python examples/python/app.py
+
+Open http://127.0.0.1:5173/ with the default bridge port. For another port,
+use the ?ws= URL printed at startup. All arguments after -- go to the app.
+The bridge has no authentication or TLS; keep the loopback default.
+`,
+    hub: `Serve dashboards combining surfaces from running applications.
+
+Usage: omochi-ui hub [options]
+
+Options:
+  --host HOST            HTTP/WebSocket bind address (default: 127.0.0.1)
+  --port PORT            HTTP/WebSocket port (default: 5555; 0 selects a port)
+  --gateway TARGET       Gateway socket path or <nodeId>@HOST:PORT; repeatable
+  --ssh HOST             Reach a remote gateway through SSH (one target)
+  --ssh-socket PATH      Override the remote socket; requires --ssh
+  --no-auto-gateway      Do not start a missing local gateway
+  --discover-lan         Also discover paired gateways through mDNS
+  --allow-origin ORIGIN  Allow an additional exact browser origin; repeatable
+
+With no target, the hub reuses or starts the local gateway. --gateway and
+--ssh replace that default; add --gateway with the local socket to include it.
+The hub serves its own UI at http://127.0.0.1:5555/; no Vite server is needed.
+Apps must already be running with UnixSocketServerTransport.
+
+Examples:
+  omochi-ui hub
+  omochi-ui hub --ssh user@remote
+  omochi-ui hub --gateway <nodeId>@192.168.1.42:5556
+
+SSH requires a running remote gateway. TCP requires pairing first.
+The hub has no authentication or TLS; keep the loopback default.
+`,
+    gateway: `Discover and publish the current user's running apps on one machine.
+
+Usage: omochi-ui gateway [options]
+
+Options:
+  --root DIR        App registry directory (default: $XDG_RUNTIME_DIR/omochi)
+  --socket PATH     Gateway socket (default: <root>/gateway.sock)
+  --node-name NAME  Set this machine's display name
+  --listen HOST:PORT  Enable the certificate-authenticated mTLS listener
+  --advertise       Advertise with mDNS; requires --listen or --lan
+  --pair            Open a one-time pairing window; requires --listen or --lan
+  --lan             Shorthand for --listen 0.0.0.0:5556 --advertise
+
+The gateway discovers apps; it does not launch them or serve a browser UI.
+Without network flags, it listens only on a Unix socket. If XDG_RUNTIME_DIR
+is unset, the registry is <temp>/omochi-<uid>/omochi.
+
+Examples:
+  omochi-ui gateway
+  omochi-ui gateway --lan --pair
+`,
+    id: `Show this machine's persistent node ID and display name.
+
+Usage: omochi-ui id [--node-name NAME]
+
+Creates an identity on first use. --node-name sets its display name.
+Configuration: $XDG_CONFIG_HOME/omochi (default: ~/.config/omochi).
+`,
+    pair: `Pair this machine with a gateway accepting a one-time code.
+
+Usage: omochi-ui pair HOST:PORT [--code CODE]
+
+Start omochi-ui gateway --lan --pair on the machine running the apps first.
+Without --code, read the code from stdin to keep it out of shell history.
+Use the printed random pairing port; it differs from the normal mTLS port.
+After pairing, use the printed hub --gateway command to connect.
+
+Example:
+  omochi-ui pair 192.168.1.42:42317  # use the printed random pairing port
+`,
+    trust: `Manage paired peers stored in $XDG_CONFIG_HOME/omochi/peers.json.
+
+Usage:
+  omochi-ui trust list
+  omochi-ui trust forget <nodeId>
+
+list shows peer IDs, roles, names, and pairing times.
+forget removes the local entry and waits for running processes to close revoked connections.
+The machines must pair again to reconnect.
+`,
+    'trust list': `List this machine's paired peers.
+
+Usage: omochi-ui trust list
+
+Prints peer IDs, roles, names, pairing times, and last-seen times when known.
+`,
+    'trust forget': `Remove a peer from this machine's trust store.
+
+Usage: omochi-ui trust forget <nodeId>
+
+Use omochi-ui trust list to find its ID. Pair again to reconnect.
+Returns exit code 1 if the peer was not found.
+`,
+    generate: `Generate SDK bindings from local schema files.
+
+Usage: omochi-ui generate catalog [options]
+
+Use omochi-ui generate catalog --help for required inputs and output flags.
+`,
+    'generate catalog': `Generate typed SDK bindings from a local A2UI v0.9 catalog.
+
+Usage: omochi-ui generate catalog --catalog FILE [options]
+
+Options:
+  --catalog FILE     Required local catalog JSON file
+  --name NAME        Type name (default: catalog title or GeneratedCatalog)
+  --typescript FILE Write TypeScript bindings
+  --python FILE     Write Python bindings
+  --rust FILE       Write Rust bindings
+  --check           Fail if output files are missing or stale; do not write
+
+Choose at least one output language. Output directories must already exist.
+Schema resolution is local-only; no network fetches are performed.
+
+Example:
+  omochi-ui generate catalog --catalog ./catalog.json --typescript ./catalog.ts
+`,
+};
+export function helpText(topic = '') {
+    if (!topic)
+        return overview;
+    const body = Object.hasOwn(topics, topic) ? topics[topic] : undefined;
+    return body === undefined ? undefined : `${body}\n  -h, --help    Show this help\n`;
+}
+/** Only command words select a topic; options and child arguments never do. */
+export function helpTopic(args) {
+    const command = args[0] ?? '';
+    const subcommand = args[1];
+    return (command === 'trust' || command === 'generate') && subcommand && !subcommand.startsWith('-')
+        ? `${command} ${subcommand}`
+        : command;
+}

package/dist/hub/dashboards.d.ts

@@ -0,0 +1,17 @@
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import { type Dashboard, type DashboardInput, type DashboardPreset } from '@omochi-ui/hub-ui/contracts';
+export declare function validateDashboard(value: unknown): DashboardInput;
+/** Re-read under the mutation queue and cross-process lock; failed writes never replace the last good file. */
+export declare class DashboardStore {
+    private readonly root;
+    private queue;
+    private readonly file;
+    constructor(root?: string);
+    private read;
+    list(): Promise<Dashboard[]>;
+    mutate(id: string | null, input: unknown, remove?: boolean): Promise<Dashboard | null>;
+}
+export declare function dashboardEndpoints(store: DashboardStore, allowed: (origin: string | undefined) => boolean): (request: IncomingMessage, response: ServerResponse) => boolean;
+export declare function validatePresets(values: readonly DashboardPreset[]): DashboardPreset[];
+/** Read-only presets live only for the lifetime of this hub process. */
+export declare function presetEndpoints(presets: readonly DashboardPreset[], allowed: (origin: string | undefined) => boolean): (request: IncomingMessage, response: ServerResponse) => boolean;

package/dist/hub/dashboards.js

@@ -0,0 +1,230 @@
+import { randomUUID } from 'node:crypto';
+import { readFile, writeFile, rename, unlink } from 'node:fs/promises';
+import path from 'node:path';
+import { isValidNodeId, isValidServiceId } from '@omochi-ui/core';
+import { ensureConfigRoot, omochiConfigRoot, withStateLock } from '@omochi-ui/discovery';
+import { overlaps, referenceId } from '@omochi-ui/hub-ui/contracts';
+class HttpError extends Error {
+    status;
+    constructor(status, message) {
+        super(message);
+        this.status = status;
+    }
+}
+const record = (value) => !!value && typeof value === 'object' && !Array.isArray(value);
+const text = (value, max = 200) => typeof value === 'string' && value.trim().length > 0 && value.length <= max;
+const integer = (value, min, max) => Number.isSafeInteger(value) && Number(value) >= min && Number(value) <= max;
+export function validateDashboard(value) {
+    if (!record(value) || !text(value.name) || !Array.isArray(value.panels) || value.panels.length > 200) {
+        throw new HttpError(400, 'A dashboard needs a name and at most 200 panels');
+    }
+    const panels = [];
+    const ids = new Set();
+    const references = new Set();
+    for (const p of value.panels) {
+        if (!record(p) || !text(p.id, 100) || !text(p.title) || !record(p.reference)
+            || typeof p.reference.nodeId !== 'string' || !isValidNodeId(p.reference.nodeId)
+            || typeof p.reference.serviceId !== 'string' || !isValidServiceId(p.reference.serviceId)
+            || !text(p.reference.surfaceId, 4096)
+            || !integer(p.x, 0, 11) || !integer(p.y, 0, 100000) || !integer(p.w, 1, 12) || !integer(p.h, 1, 1000)
+            || p.x + p.w > 12)
+            throw new HttpError(400, 'Invalid panel reference or grid position');
+        const panel = {
+            id: p.id, title: p.title, reference: { nodeId: p.reference.nodeId, serviceId: p.reference.serviceId, surfaceId: p.reference.surfaceId },
+            x: p.x, y: p.y, w: p.w, h: p.h,
+        };
+        const ref = referenceId(panel.reference);
+        if (ids.has(panel.id) || references.has(ref))
+            throw new HttpError(400, 'Duplicate panel or surface');
+        if (panels.some(other => overlaps(panel, other)))
+            throw new HttpError(400, 'Panels must not overlap');
+        ids.add(panel.id);
+        references.add(ref);
+        panels.push(panel);
+    }
+    return { name: value.name.trim(), panels };
+}
+/** Re-read under the mutation queue and cross-process lock; failed writes never replace the last good file. */
+export class DashboardStore {
+    root;
+    queue = Promise.resolve();
+    file;
+    constructor(root = omochiConfigRoot()) {
+        this.root = root;
+        this.file = path.join(root, 'dashboards.json');
+    }
+    async read() {
+        let raw;
+        try {
+            raw = await readFile(this.file, 'utf8');
+        }
+        catch (error) {
+            if (error.code === 'ENOENT')
+                return { version: 1, dashboards: [] };
+            throw new HttpError(503, 'Could not read dashboard storage');
+        }
+        try {
+            const data = JSON.parse(raw);
+            if (!record(data) || data.version !== 1 || !Array.isArray(data.dashboards))
+                throw new Error();
+            const ids = new Set();
+            const dashboards = data.dashboards.map((item) => {
+                if (!record(item) || !text(item.id, 100) || !integer(item.revision, 1, Number.MAX_SAFE_INTEGER) || ids.has(item.id))
+                    throw new Error();
+                ids.add(item.id);
+                return { ...validateDashboard(item), id: item.id, revision: item.revision };
+            });
+            return { version: 1, dashboards };
+        }
+        catch {
+            throw new HttpError(503, 'Dashboard storage is invalid; repair dashboards.json before saving');
+        }
+    }
+    async list() { await this.queue; return (await this.read()).dashboards; }
+    mutate(id, input, remove = false) {
+        const next = this.queue.then(async () => {
+            try {
+                await ensureConfigRoot(this.root);
+                return await withStateLock(this.file, async () => {
+                    const file = await this.read();
+                    const current = id === null ? undefined : file.dashboards.find(d => d.id === id);
+                    if (id !== null && !current)
+                        throw new HttpError(404, 'Dashboard not found');
+                    if (current && (!record(input) || input.revision !== current.revision))
+                        throw new HttpError(409, 'This dashboard changed elsewhere. Reload before saving.');
+                    const dashboard = remove ? null : {
+                        ...validateDashboard(input), id: current?.id ?? randomUUID(), revision: (current?.revision ?? 0) + 1,
+                    };
+                    file.dashboards = file.dashboards.filter(d => d.id !== id);
+                    if (dashboard)
+                        file.dashboards.push(dashboard);
+                    const temporary = path.join(this.root, `.dashboards-${randomUUID()}.tmp`);
+                    try {
+                        await writeFile(temporary, JSON.stringify(file, null, 2) + '\n', { mode: 0o600, flag: 'wx' });
+                        await rename(temporary, this.file);
+                    }
+                    finally {
+                        await unlink(temporary).catch(() => { });
+                    }
+                    return dashboard;
+                });
+            }
+            catch (error) {
+                if (error instanceof HttpError)
+                    throw error;
+                throw new HttpError(503, 'Could not save dashboard storage');
+            }
+        });
+        this.queue = next.catch(() => { });
+        return next;
+    }
+}
+async function body(request) {
+    if (request.headers['content-type']?.split(';')[0]?.trim() !== 'application/json')
+        throw new HttpError(415, 'Use application/json');
+    const chunks = [];
+    let size = 0;
+    for await (const chunk of request) {
+        size += Buffer.byteLength(chunk);
+        if (size > 1024 * 1024)
+            throw new HttpError(413, 'Dashboard request is too large');
+        chunks.push(Buffer.from(chunk));
+    }
+    try {
+        return JSON.parse(Buffer.concat(chunks).toString('utf8'));
+    }
+    catch {
+        throw new HttpError(400, 'Invalid JSON');
+    }
+}
+export function dashboardEndpoints(store, allowed) {
+    return (request, response) => {
+        const pathname = new URL(request.url ?? '/', 'http://localhost').pathname;
+        if (pathname !== '/api/dashboards' && !pathname.startsWith('/api/dashboards/'))
+            return false;
+        const send = (status, value) => {
+            response.writeHead(status, { 'Content-Type': 'application/json; charset=utf-8', 'Cache-Control': 'no-store' });
+            response.end(JSON.stringify(value));
+        };
+        if (!allowed(request.headers.origin)) {
+            send(403, { error: 'Forbidden origin' });
+            return true;
+        }
+        response.setHeader('Vary', 'Origin');
+        if (request.headers.origin)
+            response.setHeader('Access-Control-Allow-Origin', request.headers.origin);
+        if (request.method === 'OPTIONS') {
+            response.writeHead(204, { 'Access-Control-Allow-Methods': 'GET, POST, PUT, DELETE, OPTIONS', 'Access-Control-Allow-Headers': 'Content-Type' });
+            response.end();
+            return true;
+        }
+        void (async () => {
+            const id = pathname === '/api/dashboards' ? null : decodeURIComponent(pathname.slice('/api/dashboards/'.length));
+            if (id !== null && (!id || id.includes('/')))
+                throw new HttpError(404, 'Dashboard not found');
+            if (request.method === 'GET') {
+                const dashboards = await store.list();
+                if (id === null)
+                    send(200, dashboards);
+                else {
+                    const dashboard = dashboards.find(d => d.id === id);
+                    if (!dashboard)
+                        throw new HttpError(404, 'Dashboard not found');
+                    send(200, dashboard);
+                }
+            }
+            else if (request.method === 'POST' && id === null)
+                send(201, await store.mutate(null, await body(request)));
+            else if (request.method === 'PUT' && id !== null)
+                send(200, await store.mutate(id, await body(request)));
+            else if (request.method === 'DELETE' && id !== null) {
+                await store.mutate(id, await body(request), true);
+                send(200, { deleted: true });
+            }
+            else
+                throw new HttpError(405, 'Method not allowed');
+        })().catch(error => send(error instanceof HttpError ? error.status : error instanceof URIError ? 400 : 503, { error: error instanceof HttpError ? error.message : 'Could not save dashboard' }));
+        return true;
+    };
+}
+export function validatePresets(values) {
+    const ids = new Set();
+    return values.map((value) => {
+        if (!text(value.id, 100) || ids.has(value.id))
+            throw new Error(`Invalid or duplicate dashboard preset id: ${JSON.stringify(value.id)}`);
+        ids.add(value.id);
+        return { id: value.id, ...validateDashboard(value) };
+    });
+}
+/** Read-only presets live only for the lifetime of this hub process. */
+export function presetEndpoints(presets, allowed) {
+    const validated = validatePresets(presets);
+    return (request, response) => {
+        const pathname = new URL(request.url ?? '/', 'http://localhost').pathname;
+        if (pathname !== '/api/presets')
+            return false;
+        const send = (status, value) => {
+            const headers = { 'Cache-Control': 'no-store' };
+            if (value !== undefined)
+                headers['Content-Type'] = 'application/json; charset=utf-8';
+            response.writeHead(status, headers);
+            response.end(value === undefined ? undefined : JSON.stringify(value));
+        };
+        if (!allowed(request.headers.origin)) {
+            send(403, { error: 'Forbidden origin' });
+            return true;
+        }
+        response.setHeader('Vary', 'Origin');
+        if (request.headers.origin)
+            response.setHeader('Access-Control-Allow-Origin', request.headers.origin);
+        if (request.method === 'OPTIONS') {
+            response.setHeader('Access-Control-Allow-Methods', 'GET, OPTIONS');
+            send(204);
+        }
+        else if (request.method === 'GET')
+            send(200, validated);
+        else
+            send(405, { error: 'Method not allowed' });
+        return true;
+    };
+}

package/dist/hub/gateway-supervisor.d.ts

@@ -0,0 +1,19 @@
+export interface GatewaySupervisor {
+    /** True when this hub started the gateway and is therefore responsible for it. */
+    readonly spawned: boolean;
+    close(): Promise<void>;
+}
+export interface SuperviseOptions {
+    /** Overridden in tests; defaults to this CLI's own `gateway` command. */
+    command?: string[];
+    startTimeoutMs?: number;
+}
+/**
+ * Makes sure a gateway is listening on this machine.
+ *
+ * A gateway already there is reused and left running, because it is not ours to stop and
+ * other hubs may be attached to it. Only a socket that refuses a connection is removed,
+ * and only then is a gateway started — a live socket is never unlinked, so two hubs
+ * racing to start end up sharing the winner's gateway instead of destroying it.
+ */
+export declare function superviseLocalGateway(socketPath: string, options?: SuperviseOptions): Promise<GatewaySupervisor>;

package/dist/hub/gateway-supervisor.js

@@ -0,0 +1,75 @@
+import { spawn } from 'node:child_process';
+import { once } from 'node:events';
+import { rm } from 'node:fs/promises';
+import process from 'node:process';
+import { fileURLToPath } from 'node:url';
+import { probeGateway } from '@omochi-ui/discovery';
+const START_TIMEOUT_MS = 10000;
+const POLL_MS = 50;
+/**
+ * How long to let a child report that it lost the race.
+ *
+ * The winner starts listening before the loser's bind fails, so a probe can succeed
+ * while our own child is still on its way out. Waiting for that exit is what makes
+ * `spawned` mean "this hub owns the gateway" rather than "this hub tried".
+ */
+const EXIT_GRACE_MS = 250;
+const idle = { spawned: false, close: async () => { } };
+function gatewayCommand() {
+    // `dist/hub/gateway-supervisor.js` sits one directory below `dist/cli.js`.
+    return [process.execPath, fileURLToPath(new URL('../cli.js', import.meta.url)), 'gateway'];
+}
+async function waitForGateway(socketPath, deadline, child) {
+    while (Date.now() < deadline) {
+        if (await probeGateway({ kind: 'unix', socketPath }))
+            return true;
+        // A child that exited lost the race for the socket, or failed outright; either way
+        // the next probe decides, because the winner is already listening.
+        if (child && child.exitCode !== null)
+            return (await probeGateway({ kind: 'unix', socketPath })) !== null;
+        await new Promise((resolveDelay) => setTimeout(resolveDelay, POLL_MS));
+    }
+    return false;
+}
+/**
+ * Makes sure a gateway is listening on this machine.
+ *
+ * A gateway already there is reused and left running, because it is not ours to stop and
+ * other hubs may be attached to it. Only a socket that refuses a connection is removed,
+ * and only then is a gateway started — a live socket is never unlinked, so two hubs
+ * racing to start end up sharing the winner's gateway instead of destroying it.
+ */
+export async function superviseLocalGateway(socketPath, options = {}) {
+    if (await probeGateway({ kind: 'unix', socketPath }))
+        return idle;
+    // Nothing answered, so any socket file here is left over from a gateway that died.
+    await rm(socketPath, { force: true });
+    const command = options.command ?? gatewayCommand();
+    const child = spawn(command[0], command.slice(1), { stdio: ['ignore', 'ignore', 'inherit'] });
+    child.unref();
+    const deadline = Date.now() + (options.startTimeoutMs ?? START_TIMEOUT_MS);
+    if (!(await waitForGateway(socketPath, deadline, child))) {
+        if (child.exitCode === null)
+            child.kill('SIGTERM');
+        throw new Error(`the gateway did not start on ${socketPath}`);
+    }
+    if (child.exitCode === null) {
+        await Promise.race([
+            once(child, 'exit'),
+            new Promise((resolveGrace) => setTimeout(resolveGrace, EXIT_GRACE_MS)),
+        ]);
+    }
+    // Losing the race is normal: another hub bound the socket first and owns that process.
+    if (child.exitCode !== null)
+        return idle;
+    return {
+        // Reported live, so a gateway that dies later is never mistaken for ours to stop.
+        get spawned() {
+            return child.exitCode === null;
+        },
+        async close() {
+            if (child.exitCode === null)
+                child.kill('SIGTERM');
+        },
+    };
+}

package/dist/hub/hub.d.ts

@@ -0,0 +1,41 @@
+import { type GatewayLocator, type NodeIdentity, type TrustStore } from '@omochi-ui/discovery';
+import type { DashboardPreset } from '@omochi-ui/hub-ui/contracts';
+export interface HubOptions {
+    host?: string;
+    port?: number;
+    allowOrigins?: string[];
+    /** Where to look for gateways. Defaults to the gateway on this machine. */
+    gateways?: GatewayLocator[];
+    /** The local gateway's socket; defaults to `<runtime root>/gateway.sock`. */
+    gatewaySocket?: string;
+    /** Start a local gateway when none is listening. Defaults to true. */
+    autoGateway?: boolean;
+    /** Where the persisted identity and pinned peers live; defaults to the config root. */
+    configRoot?: string;
+    /** Overrides this hub's identity and trust store; mainly useful in tests. */
+    identity?: NodeIdentity;
+    trust?: TrustStore;
+    /** Also look for gateways on the local link. Off by default. */
+    discoverLan?: boolean;
+    /** Read-only dashboard compositions exposed for this hub process only. */
+    presets?: DashboardPreset[];
+}
+export interface HubHandle {
+    readonly url: string;
+    readonly httpUrl: string;
+    /** How many gateways are currently connected. */
+    readonly nodeCount: number;
+    close(): Promise<void>;
+}
+/**
+ * Aggregates every reachable gateway into one A2UI stream.
+ *
+ * The hub knows nothing about manifests, runtime directories, or application sockets:
+ * a gateway owns all of that, and the hub only ever speaks the gateway contract. That is
+ * what lets a gateway on another machine join on exactly the same terms as the local one.
+ *
+ * Surfaces arrive namespaced by service id and are re-namespaced as
+ * `<nodeId>~<serviceId>/<surfaceId>`, so two machines running the same service stay
+ * distinct all the way out to the renderer.
+ */
+export declare function startHub(options?: HubOptions): Promise<HubHandle>;