@bardioc/app-sdk 0.5.0 → 1.0.0

package/dist/serve.js

@@ -0,0 +1,64 @@
+import * as z from 'zod/mini';
+import { APP_METHODS, HOST_METHODS, PROTOCOL_VERSION, } from './contract.js';
+import { BardiocError } from './errors.js';
+import { isHandshake, openStream, Peer } from './wire.js';
+const parse = (schema, params) => {
+    const parsed = schema.safeParse(params);
+    if (parsed.success)
+        return parsed.data;
+    throw new BardiocError('invalid', z.prettifyError(parsed.error), {
+        details: parsed.error.issues,
+    });
+};
+/** Answers an app's calls on `port` with `handlers`, validating every call against the contract. */
+export function serve(port, handlers) {
+    const streams = new Set();
+    const route = (name, method) => {
+        const handler = handlers[name];
+        if (method.kind === 'call') {
+            return (params, signal) => handler(parse(method.input, params), signal);
+        }
+        return params => {
+            const input = parse(method.input, params);
+            const { port: reader, dispose } = openStream(emit => {
+                const stop = handler(input, emit);
+                return () => {
+                    streams.delete(dispose);
+                    stop();
+                };
+            });
+            streams.add(dispose);
+            return reader;
+        };
+    };
+    const peer = new Peer(port, new Map(Object.entries(APP_METHODS).map(([name, method]) => [name, route(name, method)])));
+    return {
+        call: (method, params) => peer.call(method, params, { timeoutMs: HOST_METHODS[method].timeoutMs }),
+        emit: (event, payload) => peer.emit(event, payload),
+        close: () => {
+            streams.forEach(dispose => dispose());
+            peer.close();
+        },
+    };
+}
+/** Waits for an app's `ready` and answers each one with a fresh port. */
+export function acceptApp({ source, origin, context, onConnect, onReject }) {
+    const onMessage = (event) => {
+        const app = source();
+        if (!app || event.source !== app || event.origin !== origin)
+            return;
+        if (!isHandshake(event.data) || event.data.bardioc !== 'ready')
+            return;
+        const reply = (message, transfer = []) => app.postMessage(message, origin, transfer);
+        if (event.data.protocol !== PROTOCOL_VERSION) {
+            reply({ bardioc: 'reject', protocol: PROTOCOL_VERSION });
+            onReject?.(event.data.protocol);
+            return;
+        }
+        const { port1, port2 } = new MessageChannel();
+        onConnect(port1);
+        reply({ bardioc: 'connect', protocol: PROTOCOL_VERSION, context: context() }, [port2]);
+    };
+    window.addEventListener('message', onMessage);
+    return () => window.removeEventListener('message', onMessage);
+}

package/dist/testing.d.ts

@@ -0,0 +1,17 @@
+import type { GraphEvent } from './contract.js';
+import { type HostHandlers } from './serve.js';
+export interface ConformanceCase {
+    name: string;
+    run(): Promise<void>;
+}
+/** An EventSource double: cases push events into the sources a host opens. */
+export declare class FakeEventSource extends EventTarget {
+    readonly url: string;
+    static readonly opened: FakeEventSource[];
+    readyState: number;
+    constructor(url: string);
+    push(event: GraphEvent): void;
+    close(): void;
+}
+/** Behaviour every host shares; run each case under any test runner. */
+export declare function hostConformance(makeHandlers: () => Promise<HostHandlers>): ConformanceCase[];

package/dist/testing.js

@@ -0,0 +1,128 @@
+import { deepStrictEqual, equal, ok, rejects } from 'node:assert/strict';
+import { BardiocError } from './errors.js';
+import { serve } from './serve.js';
+import { Peer, readStream } from './wire.js';
+/** An EventSource double: cases push events into the sources a host opens. */
+export class FakeEventSource extends EventTarget {
+    url;
+    static opened = [];
+    readyState = 1;
+    constructor(url) {
+        super();
+        this.url = url;
+        FakeEventSource.opened.push(this);
+    }
+    push(event) {
+        this.dispatchEvent(new MessageEvent(event.type, { data: JSON.stringify(event) }));
+    }
+    close() {
+        this.readyState = 2;
+    }
+}
+async function withGlobals(globals, run) {
+    const saved = { fetch: globalThis.fetch, EventSource: globalThis.EventSource };
+    Object.assign(globalThis, { EventSource: FakeEventSource }, globals);
+    FakeEventSource.opened.length = 0;
+    try {
+        await run();
+    }
+    finally {
+        Object.assign(globalThis, saved);
+    }
+}
+const connect = (handlers) => {
+    const { port1, port2 } = new MessageChannel();
+    const connection = serve(port1, handlers);
+    const peer = new Peer(port2, new Map());
+    const call = (method, params) => peer.call(method, params, { timeoutMs: 2000 });
+    return { call, close: () => (connection.close(), peer.close()) };
+};
+const respond = (body, init = {}) => new Response(body, {
+    ...init,
+    headers: init.json ? { 'Content-Type': 'application/json' } : init.headers,
+});
+/** Behaviour every host shares; run each case under any test runner. */
+export function hostConformance(makeHandlers) {
+    const test = (name, run) => ({
+        name,
+        run: async () => {
+            const host = connect(await makeHandlers());
+            try {
+                await run(host);
+            }
+            finally {
+                host.close();
+            }
+        },
+    });
+    return [
+        test('acknowledges ui calls', async ({ call }) => {
+            equal(await call('ui.notify', { message: 'Hi.', level: 'info' }), undefined);
+            equal(await call('ui.setCommands', { commands: [{ id: 'save' }] }), undefined);
+            equal(await call('ui.setMenu', { menu: null }), undefined);
+            equal(await call('ui.setActiveTab', { activeTab: 'Overview' }), undefined);
+        }),
+        test('stores idb entries per store', async ({ call }) => {
+            await call('idb.put', { store: 'notes', key: 'b', value: { n: 2 } });
+            await call('idb.put', { store: 'notes', key: 'a', value: { n: 1 } });
+            await call('idb.put', { store: 'other', key: 'a', value: 0 });
+            const entry = (await call('idb.get', { store: 'notes', key: 'a' }));
+            deepStrictEqual(entry, { key: 'a', value: { n: 1 }, updatedAt: entry.updatedAt });
+            const keys = (await call('idb.query', { store: 'notes' }));
+            deepStrictEqual(keys.map(({ key }) => key), ['a', 'b']);
+            await call('idb.delete', { store: 'notes', key: 'a' });
+            equal(await call('idb.get', { store: 'notes', key: 'a' }), null);
+        }),
+        test('answers bff requests with the parsed body', async ({ call }) => {
+            const requests = [];
+            const fetch = async (input, init) => {
+                requests.push(new Request(new URL(String(input), 'http://host'), init));
+                return respond(JSON.stringify({ ok: 1 }), { json: true });
+            };
+            await withGlobals({ fetch }, async () => {
+                const value = await call('bff.request', {
+                    path: '/os/units',
+                    method: 'POST',
+                    body: { name: 'x' },
+                    contentType: 'application/json',
+                    scopePolicy: 'none',
+                });
+                deepStrictEqual(value, { ok: 1 });
+            });
+            const [request] = requests;
+            ok(request);
+            ok(request.url.endsWith('/os/units'));
+            equal(request.method, 'POST');
+            equal(request.headers.get('Content-Type'), 'application/json');
+            equal(request.headers.get('X-Requested-With'), 'XMLHttpRequest');
+            equal(await request.text(), '{"name":"x"}');
+        }),
+        test('classifies bff failures by status', async ({ call }) => {
+            const fetch = async () => respond('gone', { status: 404 });
+            await withGlobals({ fetch }, () => rejects(call('bff.request', { path: '/os/x', scopePolicy: 'none' }), (error) => {
+                ok(error instanceof BardiocError);
+                equal(error.code, 'not_found');
+                equal(error.status, 404);
+                return true;
+            }));
+        }),
+        test('streams graph events until the reader ends', async ({ call }) => {
+            await withGlobals({}, async () => {
+                const port = (await call('events.graph', { types: ['ogit/Note'] }));
+                const received = [];
+                const end = readStream(port, event => received.push(event));
+                const [source] = FakeEventSource.opened;
+                ok(source);
+                const filter = new URL(source.url, 'http://host').searchParams.get('filter');
+                equal(filter, '(element.ogit/_type=ogit/Note)');
+                const event = { id: 'e1', type: 'CREATE', timestamp: 1 };
+                source.push(event);
+                await new Promise(resolve => setTimeout(resolve, 20));
+                deepStrictEqual(received, [event]);
+                end();
+                await new Promise(resolve => setTimeout(resolve, 20));
+                equal(source.readyState, 2);
+            });
+        }),
+    ];
+}

package/dist/types.d.ts

@@ -1,218 +1,6 @@
-/** Wire-level envelope sent from iframe → host. */
-export interface SdkMessage<T extends string = string, P = unknown> {
-    type: T;
-    id: string;
-    payload: P;
-}
-/** Wire-level envelope sent from host → iframe as a response. */
-export interface SdkResponse<P = unknown> {
-    type: string;
-    id: string;
-    payload: P;
-    error?: string;
-}
-/** OS configuration provided to apps. */
-export interface OsConfig {
-    theme: string;
-    language: string;
-    tabId: string;
-    windowId: string;
-    instanceId: string | null;
-    systemSize?: string;
-}
-/** Context returned by the host after a successful handshake. */
-export interface SdkInitResponse {
-    appId: string;
-    instanceId: string | null;
-    osConfig?: OsConfig;
-}
-export type SdkCommandHandler = () => void | Promise<void>;
-export interface SdkCommandDefinition {
-    id: string;
-    title?: string;
-    disabled?: boolean;
-    checked?: boolean;
-}
-export interface SdkMenuCommandItem {
-    type: 'command';
-    commandId: string;
-    label?: string;
-    leftIcon?: string;
-    separatorAbove?: boolean;
-    shortcut?: string;
-    variant?: 'default' | 'destructive';
-}
-export interface SdkMenuSubmenuItem {
-    type: 'submenu';
-    label: string;
-    leftIcon?: string;
-    separatorAbove?: boolean;
-    items: SdkMenuItem[];
-    contentWidth?: string;
-}
-export type SdkMenuItem = SdkMenuCommandItem | SdkMenuSubmenuItem;
-export type SdkMenuRootKind = 'app' | 'menu';
-export interface SdkMenuRoot {
-    label: string;
-    kind?: SdkMenuRootKind;
-    leftIcon?: string;
-    items: SdkMenuItem[];
-    contentWidth?: string;
-}
-export interface SdkSetCommandsPayload {
-    commands: SdkCommandDefinition[];
-}
-export interface SdkSetMenuPayload {
-    menu: SdkMenuRoot[] | null;
-}
-export interface SdkSetActiveTabPayload {
-    activeTab: string | null;
-}
-export interface SdkCommandInvokePayload {
-    commandId: string;
-}
-export interface SdkShortcutEventPayload {
-    /**
-     * Physical-key identifier (`KeyboardEvent.code`), e.g. `"KeyS"`, `"Digit1"`,
-     * `"Comma"`. Layout- and modifier-independent. Hosts that match shortcuts
-     * by physical key (recommended for cross-platform / cross-layout
-     * correctness, especially macOS Option combinations) use this field.
-     */
-    code: string;
-    ctrlKey: boolean;
-    metaKey: boolean;
-    altKey: boolean;
-    shiftKey: boolean;
-}
-/** Mirrors the BFF `GraphEvent` SSE contract delivered by the host. */
-export type GraphEventType = 'CREATE' | 'REPLACE' | 'UPDATE' | 'CONNECT' | 'DISCONNECT' | 'DELETE' | 'WRITE_TIMESERIES';
-export interface GraphEvent {
-    id: string;
-    type: GraphEventType;
-    timestamp: number;
-    nanotime?: number;
-    body?: Record<string, unknown>;
-    metadata?: Record<string, unknown>;
-}
-export interface EventSubscribeRequest {
-    /** App-generated subscription id, echoed by the host and stamped on pushes. */
-    subscriptionId: string;
-    /** OGIT types to subscribe to, e.g. `['ogit/Documents/Document']`. */
-    types: string[];
-}
-export interface EventSubscribeResponse {
-    subscriptionId: string;
-}
-export interface EventUnsubscribeRequest {
-    subscriptionId: string;
-}
-export interface GraphEventPushPayload {
-    subscriptionId: string;
-    event: GraphEvent;
-}
-/** Live graph-event subscription surface exposed to hosted apps. */
-export interface EventsApi {
-    /**
-     * Subscribe to graph mutations for the given OGIT types. Returns an
-     * unsubscribe function; the handler fires for each matching event.
-     */
-    subscribe(options: {
-        types: string[];
-    }, handler: (event: GraphEvent) => void): () => void;
-}
-export type NotifyLevel = 'success' | 'error' | 'info' | 'warning';
-export interface SdkNotifyPayload {
-    message: string;
-    level: NotifyLevel;
-}
-export interface SdkStorageGetPayload {
-    key: string;
-}
-export interface SdkStorageSetPayload {
-    key: string;
-    value: unknown;
-}
-export interface SdkStorageDeletePayload {
-    key: string;
-}
-export interface SdkKernelProxyPayload {
-    kernelType: string;
-    kernelPayload?: unknown;
-}
-export interface SdkTransportPayload {
-    path: string;
-    method?: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
-    body?: unknown;
-    contentType?: string;
-    scopeId?: string;
-    scopePolicy?: 'none' | 'optional' | 'required';
-}
 export interface TransportScopeOptions {
     scopeId?: string;
 }
-export interface SdkIdbGetPayload {
-    storeName: string;
-    key: string;
-}
-export interface SdkIdbPutPayload {
-    storeName: string;
-    key: string;
-    value: unknown;
-}
-export interface SdkIdbDeletePayload {
-    storeName: string;
-    key: string;
-}
-export interface SdkIdbQueryPayload {
-    storeName: string;
-    prefix?: string;
-    limit?: number;
-}
-/** How bridge messages travel between an app and its host. */
-export interface SdkChannel {
-    /** Delivers one message to the host. */
-    post(message: SdkMessage | SdkResponse): void;
-    /** Hands every message from the host to `receive`; returns the unsubscribe. */
-    subscribe(receive: (message: SdkResponse) => void): () => void;
-}
-/** Configuration passed to {@link createHostBridge}. */
-export interface HostBridgeConfig {
-    appId?: string;
-    /** Message transport. Default: `postMessage` with the parent window. */
-    channel?: SdkChannel;
-    /** Override the host origin for `postMessage`. Inferred from `document.referrer` by default. */
-    targetOrigin?: string;
-    /** Handshake timeout in ms. Default: `5000`. */
-    connectTimeout?: number;
-    /** Enable verbose `[app-sdk]` console output. Default: `false`. */
-    debug?: boolean;
-}
-/** Key-value storage sandboxed to this app by the host. */
-export interface SdkStorage {
-    get<T = unknown>(key: string): Promise<T | null>;
-    set(key: string, value: unknown): Promise<void>;
-    delete(key: string): Promise<void>;
-    keys(): Promise<string[]>;
-}
-export interface SdkIdbEntry<T = unknown> {
-    key: string;
-    value: T;
-    updatedAt: number;
-}
-export interface SdkIdbStore {
-    get<T = unknown>(key: string): Promise<T | null>;
-    put(key: string, value: unknown): Promise<void>;
-    delete(key: string): Promise<void>;
-    query<T = unknown>(options?: {
-        prefix?: string;
-        limit?: number;
-    }): Promise<SdkIdbEntry<T>[]>;
-}
-export interface SdkTransport {
-    graph: GraphTransport;
-    os: OsTransport;
-    backend(routeKey: string): BackendTransport;
-}
 /** Graph node in raw backend format (ogit/* fields) */
 export interface GraphNodeRaw {
     'ogit/_id': string;
@@ -366,41 +154,3 @@ export interface UpdateMemberInput {
     lastName?: string;
     [key: string]: unknown;
 }
-export interface OsRequestOptions extends TransportScopeOptions {
-    path: string;
-    method?: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
-    body?: unknown;
-    contentType?: string;
-    scopePolicy?: 'none' | 'optional' | 'required';
-}
-export type BackendRequestOptions = OsRequestOptions;
-/** Live connection between an iframe app and its host OS. */
-export interface HostBridge {
-    /** Perform the SDK handshake. Resolves with host context. Cached after first call. */
-    connect(): Promise<SdkInitResponse>;
-    /** Tear down the bridge and reject all pending requests. */
-    destroy(): void;
-    readonly connected: boolean;
-    readonly context: SdkInitResponse | null;
-    notify(message: string, level?: NotifyLevel): void;
-    storage: SdkStorage;
-    idb(storeName: string): SdkIdbStore;
-    transport: SdkTransport;
-    events: EventsApi;
-    setCommands(commands: SdkCommandDefinition[]): Promise<void>;
-    setMenu(menu: SdkMenuRoot[] | null): Promise<void>;
-    setActiveTab(activeTab: string | null): Promise<void>;
-    sendShortcutEvent(payload: SdkShortcutEventPayload): void;
-    registerCommandHandlers(handlers: Record<string, SdkCommandHandler>): () => void;
-    onOsConfigUpdate(callback: (config: OsConfig) => void): () => void;
-    /** Forward a whitelisted message to the OS service worker. */
-    sendToKernel<R = unknown>(kernelType: string, kernelPayload?: unknown): Promise<R>;
-    /** Launch an app by ID in the OS. Returns the window ID if successful. */
-    launchApp(appId: string): Promise<{
-        windowId: string | null;
-    }>;
-}
-/** Forward declarations for transport classes */
-export type GraphTransport = import('./transports/graph-transport.js').GraphTransport;
-export type OsTransport = import('./transports/os-transport.js').OsTransport;
-export type BackendTransport = import('./transports/backend-transport.js').BackendTransport;

package/dist/vite.js

@@ -33,6 +33,7 @@ function devProxy(opts) {
         },
     };
 }
+const FRAME_ANCESTORS = "frame-ancestors 'self' http://localhost:* http://127.0.0.1:*";
 const FONTS_URL_PREFIX = '/fonts/';
 const FONT_CONTENT_TYPES = {
     css: 'text/css; charset=utf-8',
@@ -203,6 +204,8 @@ export function bardiocApp(opts) {
                 server: {
                     port,
                     allowedHosts: true,
+                    // Only a shell on this machine may frame the dev server and receive its port.
+                    headers: { 'Content-Security-Policy': FRAME_ANCESTORS },
                 },
                 preview: {
                     port: previewPort ?? port + 1000,

package/dist/wire.d.ts

@@ -0,0 +1,46 @@
+import { type Context } from './contract.js';
+/** Window messages that open a connection; everything after them travels over its port. */
+export type Handshake = {
+    bardioc: 'ready';
+    protocol: number;
+} | {
+    bardioc: 'connect';
+    protocol: number;
+    context: Context;
+} | {
+    bardioc: 'reject';
+    protocol: number;
+};
+export declare const isHandshake: (data: unknown) => data is Handshake;
+export declare const READY: Handshake;
+export type Handler = (params: unknown, signal: AbortSignal) => unknown;
+export interface CallOptions {
+    timeoutMs: number;
+    signal?: AbortSignal;
+    transfer?: Transferable[];
+}
+/** One side of a connection: calls the other side and answers its calls. */
+export declare class Peer {
+    private readonly port;
+    private readonly handlers;
+    private nextId;
+    private closed;
+    private readonly pending;
+    private readonly running;
+    private readonly listeners;
+    constructor(port: MessagePort, handlers: ReadonlyMap<string, Handler>);
+    call(method: string, params: unknown, options: CallOptions): Promise<unknown>;
+    emit(event: string, payload: unknown): void;
+    on(event: string, listener: (payload: unknown) => void): () => void;
+    close(): void;
+    private post;
+    private receive;
+    private answer;
+}
+/** Opens a stream; its port goes to the reader, `dispose` stops it from either side. */
+export declare function openStream(start: (emit: (value: unknown) => void) => () => void): {
+    port: MessagePort;
+    dispose: () => void;
+};
+/** Reads a stream opened by the other side; the returned function ends it. */
+export declare function readStream(port: MessagePort, onValue: (value: unknown) => void): () => void;

package/dist/wire.js

@@ -0,0 +1,138 @@
+import { PROTOCOL_VERSION } from './contract.js';
+import { BardiocError } from './errors.js';
+export const isHandshake = (data) => typeof data === 'object' && data !== null && 'bardioc' in data;
+export const READY = { bardioc: 'ready', protocol: PROTOCOL_VERSION };
+/** One side of a connection: calls the other side and answers its calls. */
+export class Peer {
+    port;
+    handlers;
+    nextId = 0;
+    closed = false;
+    pending = new Map();
+    running = new Map();
+    listeners = new Map();
+    constructor(port, handlers) {
+        this.port = port;
+        this.handlers = handlers;
+        port.onmessage = ({ data }) => this.receive(data);
+    }
+    call(method, params, options) {
+        const { timeoutMs, signal, transfer = [] } = options;
+        if (this.closed)
+            return Promise.reject(new BardiocError('unavailable', 'Connection closed'));
+        if (signal?.aborted)
+            return Promise.reject(cancelled(method));
+        const id = ++this.nextId;
+        return new Promise((resolve, reject) => {
+            const settle = (done) => {
+                clearTimeout(timer);
+                signal?.removeEventListener('abort', onAbort);
+                this.pending.delete(id);
+                done();
+            };
+            const abandon = (error) => {
+                this.post({ t: 'cancel', id });
+                settle(() => reject(error));
+            };
+            const onAbort = () => abandon(cancelled(method));
+            const timer = setTimeout(() => abandon(new BardiocError('timeout', `${method} timed out after ${timeoutMs} ms`)), timeoutMs);
+            signal?.addEventListener('abort', onAbort, { once: true });
+            this.pending.set(id, {
+                resolve: value => settle(() => resolve(value)),
+                reject: error => settle(() => reject(BardiocError.fromWire(error, method))),
+            });
+            this.post({ t: 'call', id, m: method, p: params }, transfer);
+        });
+    }
+    emit(event, payload) {
+        this.post({ t: 'event', m: event, p: payload });
+    }
+    on(event, listener) {
+        const listeners = this.listeners.get(event) ?? new Set();
+        this.listeners.set(event, listeners.add(listener));
+        return () => listeners.delete(listener);
+    }
+    close() {
+        if (this.closed)
+            return;
+        this.closed = true;
+        const error = new BardiocError('unavailable', 'Connection closed').toWire();
+        this.pending.forEach(call => call.reject(error));
+        this.running.forEach(controller => controller.abort());
+        this.port.close();
+    }
+    post(message, transfer = []) {
+        if (!this.closed)
+            this.port.postMessage(message, transfer);
+    }
+    receive(message) {
+        switch (message.t) {
+            case 'call':
+                return void this.answer(message.id, message.m, message.p);
+            case 'result':
+                return this.pending.get(message.id)?.resolve(message.v);
+            case 'error':
+                return this.pending.get(message.id)?.reject(message.e);
+            case 'event':
+                return this.listeners.get(message.m)?.forEach(listener => listener(message.p));
+            case 'cancel':
+                return this.running.get(message.id)?.abort();
+        }
+    }
+    async answer(id, method, params) {
+        const handler = this.handlers.get(method);
+        if (!handler) {
+            return this.post({
+                t: 'error',
+                id,
+                e: { code: 'protocol', message: `Unknown method ${method}` },
+            });
+        }
+        const controller = new AbortController();
+        this.running.set(id, controller);
+        try {
+            const value = await handler(params, controller.signal);
+            if (controller.signal.aborted)
+                return;
+            this.post({ t: 'result', id, v: value }, value instanceof MessagePort ? [value] : []);
+        }
+        catch (error) {
+            if (!controller.signal.aborted) {
+                this.post({ t: 'error', id, e: BardiocError.from(error).toWire() });
+            }
+        }
+        finally {
+            this.running.delete(id);
+        }
+    }
+}
+const cancelled = (method) => new BardiocError('cancelled', `${method} was cancelled`);
+/** Opens a stream; its port goes to the reader, `dispose` stops it from either side. */
+export function openStream(start) {
+    const { port1, port2 } = new MessageChannel();
+    const stop = start(value => port1.postMessage({ t: 'next', v: value }));
+    let open = true;
+    const dispose = () => {
+        if (!open)
+            return;
+        open = false;
+        stop();
+        port1.close();
+    };
+    port1.onmessage = ({ data }) => {
+        if (data.t === 'end')
+            dispose();
+    };
+    return { port: port2, dispose };
+}
+/** Reads a stream opened by the other side; the returned function ends it. */
+export function readStream(port, onValue) {
+    port.onmessage = ({ data }) => {
+        if (data.t === 'next')
+            onValue(data.v);
+    };
+    return () => {
+        port.postMessage({ t: 'end' });
+        port.close();
+    };
+}