@tokamakdev/tok 0.1.1-beta.107 → 0.1.1-beta.112

package/dist/dev-socket.mjs

@@ -1,23 +1,13 @@
 import http from "node:http";
-import { createRequire } from "node:module";
-import { pathToFileURL } from "node:url";
+import { Readable } from "node:stream";
+import { pipeline } from "node:stream/promises";
 import { WebSocketServer } from "ws";
+import { decodeMessage, encodeMessage, messages } from "@tokamakdev/plugin/native-protocol";
+import { DevWorker } from "./dev-worker.mjs";
 /** The header that carries the device's session token, which `tok dev`'s relay forwards. */
 export const SESSION_HEADER = "x-tokamak-session";
 /** How long a plugin call waits for the device to connect. */
 const CONNECT_TIMEOUT = 10_000;
-/** Calls `TokamakEvents` in the Worker its `TOKAMAK` service binding names, through the dev registry. */
-const CALLER = `export default {
-  async fetch(request, env) {
-    const { name, event } = await request.json();
-    try {
-      const { reply } = await env.TOKAMAK.dispatch(name, event);
-      return Response.json({ reply: reply ?? null });
-    } catch (error) {
-      return new Response(error?.stack ?? String(error), { status: 500 });
-    }
-  },
-};`;
 /**
  * Listens on a loopback port, with `token`, for the device's dev WebSocket and the development
  * Worker's plugin calls. Delivers each event the device sends to `TokamakEvents` in the
@@ -32,6 +22,10 @@ export async function openDevSocket(workerName, token) {
             response.writeHead(401).end();
             return;
         }
+        if (request.url?.startsWith("/_tokamak/")) {
+            void forwardWorker(worker, request, response);
+            return;
+        }
         if (request.method === "POST" && (request.url === "/call" || request.url === "/subscribe")) {
             void forward(device, request, response);
             return;
@@ -44,6 +38,10 @@ export async function openDevSocket(workerName, token) {
             socket.end("HTTP/1.1 401 Unauthorized\r\nConnection: close\r\n\r\n");
             return;
         }
+        if (request.url?.startsWith("/_tokamak/")) {
+            void upgradeWorker(worker, request, socket, head, sockets);
+            return;
+        }
         sockets.handleUpgrade(request, socket, head, (websocket) => serve(websocket, worker, device));
     });
     await new Promise((resolve, reject) => {
@@ -61,70 +59,175 @@ export async function openDevSocket(workerName, token) {
         },
     };
 }
+async function forwardWorker(worker, request, response) {
+    const abort = new AbortController();
+    response.once("close", () => abort.abort());
+    try {
+        const result = await worker.fetch(request, abort.signal);
+        response.writeHead(result.status, [...result.headers].flat());
+        if (result.body)
+            await pipeline(Readable.fromWeb(result.body), response);
+        else
+            response.end();
+    }
+    catch (error) {
+        if (response.headersSent)
+            response.destroy(error instanceof Error ? error : new Error(String(error)));
+        else
+            response.writeHead(502).end(String(error));
+    }
+}
+async function upgradeWorker(worker, request, socket, head, sockets) {
+    const abort = new AbortController();
+    let pending;
+    const release = () => {
+        const pair = pending;
+        pending = undefined;
+        if (!pair)
+            return;
+        pair.accept();
+        pair.close(1000, "Caller disconnected");
+    };
+    socket.once("close", () => { abort.abort(); release(); });
+    socket.once("error", () => socket.destroy());
+    try {
+        const result = await worker.fetch(request, abort.signal);
+        const pair = result.webSocket;
+        if (!pair) {
+            socket.end(`HTTP/1.1 ${result.status} ${result.statusText}\r\nConnection: close\r\n\r\n`);
+            return;
+        }
+        pending = pair;
+        if (socket.destroyed) {
+            release();
+            return;
+        }
+        sockets.handleUpgrade(request, socket, head, websocket => {
+            void worker.couple(websocket, pair).then(() => { pending = undefined; }, () => { release(); websocket.terminate(); });
+        });
+    }
+    catch {
+        release();
+        socket.end("HTTP/1.1 502 Bad Gateway\r\nConnection: close\r\n\r\n");
+    }
+}
 function serve(websocket, worker, device) {
     device.connect(websocket);
     // The device opens another dev WebSocket after this one fails.
     websocket.on("error", () => websocket.terminate());
     websocket.on("message", (data) => {
-        const message = parseMessage(String(data));
-        if (message?.type === "result") {
-            device.receive(message.id, message.result);
+        let message;
+        try {
+            const bytes = Array.isArray(data) ? Buffer.concat(data) : new Uint8Array(data);
+            message = decodeMessage(bytes);
+        }
+        catch {
+            websocket.close(1002, "Invalid native message");
+            return;
+        }
+        const { header, payload } = message;
+        if (header.type === "result" && header.id !== undefined) {
+            device.receive(header.id, { payload, failed: header.failed === true, done: header.done === true });
+            return;
+        }
+        if (header.type === "pull" && header.id !== undefined) {
+            device.pull(header.id);
             return;
         }
-        if (message?.type !== "event")
+        if (header.type !== "event" || header.id === undefined || !header.name)
             return;
-        worker.dispatch(message.name, message.event).then((reply) => websocket.send(JSON.stringify({ type: "reply", id: message.id, reply })), (error) => websocket.send(JSON.stringify({ type: "error", id: message.id, message: String(error) })));
+        const send = (type, value) => {
+            if (websocket.readyState === websocket.OPEN)
+                websocket.send(encodeMessage({ type, id: header.id }, value));
+        };
+        worker.dispatch(header.name, payload).then((reply) => send("reply", reply), (error) => send("error", encoder.encode(String(error))));
     });
 }
+const encoder = new TextEncoder();
 /**
- * Passes the plugin call `request` carries to the device. A call's response is its result; a
- * subscription's streams each result as a line of JSON until one is done, and closing it ends the
- * subscription.
+ * Relays opaque endpoint payloads; closing the response cancels the native request. A call with a
+ * body sends its later messages to the device as the device pulls them.
  */
 async function forward(device, request, response) {
+    const frames = messages(request);
     let call;
     try {
-        call = JSON.parse(await readBody(request));
+        const first = await frames.next();
+        if (first.done)
+            throw new TypeError("Missing native request");
+        call = first.value;
+        if (!call.header.plugin || !call.header.method)
+            throw new TypeError("Missing native endpoint");
     }
     catch {
         response.writeHead(400).end();
         return;
     }
-    response.writeHead(200, { "content-type": "application/json" });
-    if (request.url === "/call") {
-        response.end(JSON.stringify(await new Promise((resolve) => device.send("call", call, resolve))));
-        return;
-    }
-    response.flushHeaders();
-    const cancel = device.send("subscribe", call, (result) => {
-        response.write(`${JSON.stringify(result)}\n`);
-        if (result.done)
-            response.end();
+    response.writeHead(200, { "content-type": "application/octet-stream" });
+    const subscribe = request.url === "/subscribe";
+    const type = subscribe ? "subscribe" : call.header.type === "callWithBody" ? "callWithBody" : "call";
+    if (subscribe)
+        response.flushHeaders();
+    const write = subscribe ? subscriptionWriter(response, call.header.overflow, () => { cancel(); }) : undefined;
+    const cancel = device.send(type, call, ({ payload, failed, done }) => {
+        const frame = encodeMessage({ type: "result", failed, done }, payload);
+        if (write)
+            write(frame, done);
+        else
+            response.end(frame);
+    }, async () => {
+        const next = await frames.next().catch(() => ({ done: true, value: undefined }));
+        return next.done ? failure("DataCloneError", "The call's body ended early") : chunkResult(next.value);
     });
     response.once("close", () => {
         if (!response.writableEnded)
             cancel();
     });
 }
-function readBody(request) {
-    return new Promise((resolve, reject) => {
-        const chunks = [];
-        request.on("data", (chunk) => chunks.push(chunk));
-        request.once("end", () => resolve(Buffer.concat(chunks).toString()));
-        request.once("error", reject);
-    });
+function chunkResult({ header, payload }) {
+    return { payload, failed: header.failed === true, done: header.done === true };
 }
-function parseMessage(text) {
-    try {
-        return JSON.parse(text);
-    }
-    catch {
-        return undefined;
-    }
+/** The most a subscription's response holds while the Worker is not reading it. */
+const SUBSCRIPTION_BUFFER = 1024 * 1024;
+/**
+ * Writes a subscription's frames to `response`, holding those it cannot take yet. Past
+ * `SUBSCRIPTION_BUFFER`, `overflow` drops the oldest held frame or ends the subscription with
+ * `fail`.
+ */
+function subscriptionWriter(response, overflow, fail) {
+    const held = [];
+    let bytes = 0;
+    let writable = true;
+    const flush = () => {
+        while (writable && held.length) {
+            const { frame, done } = held.shift();
+            bytes -= frame.byteLength;
+            if (done)
+                response.end(frame);
+            else
+                writable = response.write(frame);
+        }
+    };
+    response.on("drain", () => {
+        writable = true;
+        flush();
+    });
+    return (frame, done) => {
+        held.push({ frame, done });
+        bytes += frame.byteLength;
+        while (bytes > SUBSCRIPTION_BUFFER && held.length > 1) {
+            if (overflow !== "dropOldest") {
+                response.destroy(new Error("Native subscription consumer is too slow"));
+                fail();
+                return;
+            }
+            bytes -= held.shift().frame.byteLength;
+        }
+        flush();
+    };
 }
-/** A failed result, which ends a subscription. */
 function failure(name, message) {
-    return { error: { name, message }, done: true };
+    return { payload: encoder.encode(JSON.stringify({ name, message })), failed: true, done: true };
 }
 /** The device, through its latest dev WebSocket, and the plugin calls waiting for its results. */
 class Device {
@@ -151,15 +254,24 @@ class Device {
         const pending = this.#pending.get(id);
         if (!pending)
             return;
-        if (result.done || pending.type === "call")
+        if (result.done || pending.type !== "subscribe")
             this.#pending.delete(id);
         pending.receive(result);
     }
+    /** Sends the device the next chunk of the body of the call `id`, which it pulled. */
+    pull(id) {
+        const pending = this.#pending.get(id);
+        void pending?.pull?.().then(({ payload, failed, done }) => {
+            if (this.#pending.get(id) === pending)
+                pending.socket.send(encodeMessage({ type: "chunk", id, failed, done }, payload));
+        });
+    }
     /**
      * Sends a call or subscription once the device is connected, waiting up to 10 seconds for it,
-     * and passes each of its results to `receive`. Returns the function that unsubscribes.
+     * and passes each of its results to `receive`; `pull` reads the next chunk of a call's body.
+     * Returns the function that cancels the request.
      */
-    send(type, request, receive) {
+    send(type, request, receive, pull) {
         const id = this.#nextId++;
         let cancelled = false;
         void this.#connection().then((socket) => {
@@ -169,8 +281,8 @@ class Device {
                 receive(failure("NetworkError", "The device is not connected"));
                 return;
             }
-            this.#pending.set(id, { type, socket, receive });
-            socket.send(JSON.stringify({ type, id, ...request }));
+            this.#pending.set(id, { type, socket, receive, pull });
+            socket.send(encodeMessage({ ...request.header, type, id }, request.payload));
         });
         return () => {
             cancelled = true;
@@ -178,7 +290,7 @@ class Device {
             if (!pending)
                 return;
             this.#pending.delete(id);
-            pending.socket.send(JSON.stringify({ type: "unsubscribe", id }));
+            pending.socket.send(encodeMessage({ type: "cancel", id }));
         };
     }
     /** The open dev WebSocket, once the device connects, or undefined after 10 seconds without. */
@@ -198,44 +310,3 @@ class Device {
         });
     }
 }
-/** The development Worker's `TokamakEvents`, called through a Miniflare session started on first use. */
-class DevWorker {
-    name;
-    #miniflare;
-    constructor(name) {
-        this.name = name;
-    }
-    async dispatch(name, event) {
-        this.#miniflare ??= this.#start().catch((error) => {
-            this.#miniflare = undefined;
-            throw error;
-        });
-        const miniflare = await this.#miniflare;
-        const response = await miniflare.dispatchFetch("http://tokamak/", {
-            method: "POST",
-            body: JSON.stringify({ name, event }),
-        });
-        if (!response.ok)
-            throw new Error(await response.text());
-        return (await response.json()).reply;
-    }
-    async dispose() {
-        await (await this.#miniflare?.catch(() => undefined))?.dispose();
-    }
-    /** A Miniflare session from the Miniflare that Cloudflare's plugin uses. */
-    async #start() {
-        if (!this.name)
-            throw new Error("the Wrangler configuration names no Worker to deliver events to");
-        const require = createRequire(import.meta.resolve("@cloudflare/vite-plugin"));
-        const module = (await import(pathToFileURL(require.resolve("miniflare")).href));
-        const miniflare = new module.Miniflare(module.convertV4MiniflareOptions({
-            modules: true,
-            script: CALLER,
-            compatibilityDate: "2025-01-01",
-            serviceBindings: { TOKAMAK: { name: this.name, entrypoint: "TokamakEvents" } },
-            unsafeDevRegistryPath: module.getDefaultDevRegistryPath(),
-        }));
-        await miniflare.ready;
-        return miniflare;
-    }
-}

package/dist/dev-worker.d.mts

@@ -0,0 +1,21 @@
+import type { IncomingMessage } from "node:http";
+import type { WebSocket } from "ws";
+export interface WorkerSocket {
+    accept(): void;
+    close(code: number, reason: string): void;
+}
+interface WorkerResponse extends Response {
+    webSocket?: WorkerSocket | null;
+}
+/** The native Vite worker, reached through Miniflare's development registry. */
+export declare class DevWorker {
+    #private;
+    private readonly name;
+    constructor(name: string | undefined);
+    /** Delivers the event `name` with its encoded data, resolving to the encoded reply. */
+    dispatch(name: string, event: Uint8Array): Promise<Uint8Array>;
+    fetch(request: IncomingMessage, signal: AbortSignal): Promise<WorkerResponse>;
+    couple(socket: WebSocket, pair: WorkerSocket): Promise<void>;
+    dispose(): Promise<void>;
+}
+export {};

package/dist/dev-worker.mjs

@@ -0,0 +1,88 @@
+import { createRequire } from "node:module";
+import { Readable } from "node:stream";
+import { pathToFileURL } from "node:url";
+const CALLER = `export default {
+  async fetch(request, env) {
+    if (new URL(request.url).pathname.startsWith("/_tokamak/")) return env.TOKAMAK.fetch(request);
+    const name = request.headers.get("x-tokamak-event");
+    try {
+      const { reply } = await env.EVENTS.dispatch(name, new Uint8Array(await request.arrayBuffer()));
+      return new Response(reply);
+    } catch (error) {
+      return new Response(error?.stack ?? String(error), { status: 500 });
+    }
+  },
+};`;
+/** The native Vite worker, reached through Miniflare's development registry. */
+export class DevWorker {
+    name;
+    #session;
+    constructor(name) {
+        this.name = name;
+    }
+    /** Delivers the event `name` with its encoded data, resolving to the encoded reply. */
+    async dispatch(name, event) {
+        const { runtime } = await this.#connect();
+        const response = await runtime.dispatchFetch("http://tokamak/", {
+            method: "POST", headers: { "x-tokamak-event": name }, body: event,
+        });
+        if (!response.ok)
+            throw new Error(await response.text());
+        return new Uint8Array(await response.arrayBuffer());
+    }
+    async fetch(request, signal) {
+        const { runtime } = await this.#connect();
+        const headers = new Headers();
+        for (const [name, value] of Object.entries(request.headers)) {
+            if (value !== undefined)
+                headers.set(name, [value].flat().join(", "));
+        }
+        const host = headers.get("x-forwarded-host") ?? headers.get("host");
+        const protocol = headers.get("x-forwarded-proto") ?? "http";
+        const url = new URL(request.url ?? "/", `${protocol}://${host}`);
+        for (const name of ["x-tokamak-session", "x-tokamak-dev-socket", "x-forwarded-host", "x-forwarded-proto"])
+            headers.delete(name);
+        return runtime.dispatchFetch(url.href, {
+            method: request.method, headers, signal,
+            body: request.method === "GET" || request.method === "HEAD" ? undefined : Readable.toWeb(request),
+            duplex: "half",
+        });
+    }
+    async couple(socket, pair) {
+        const { module } = await this.#connect();
+        await module.coupleWebSocket(socket, pair);
+    }
+    async dispose() {
+        await (await this.#session?.catch(() => undefined))?.runtime.dispose();
+    }
+    #connect() {
+        return this.#session ??= this.#start().catch((error) => {
+            this.#session = undefined;
+            throw error;
+        });
+    }
+    async #start() {
+        if (!this.name)
+            throw new Error("the Wrangler configuration names no native Worker");
+        const require = createRequire(import.meta.resolve("@cloudflare/vite-plugin"));
+        const module = (await import(pathToFileURL(require.resolve("miniflare")).href));
+        const runtime = new module.Miniflare(module.convertV4MiniflareOptions({
+            modules: true,
+            script: CALLER,
+            compatibilityDate: "2025-01-01",
+            serviceBindings: {
+                TOKAMAK: { name: this.name },
+                EVENTS: { name: this.name, entrypoint: "TokamakEvents" },
+            },
+            unsafeDevRegistryPath: module.getDefaultDevRegistryPath(),
+        }));
+        try {
+            await runtime.ready;
+        }
+        catch (error) {
+            await runtime.dispose();
+            throw error;
+        }
+        return { runtime, module };
+    }
+}

package/dist/events.d.mts

@@ -1,3 +1,4 @@
+import { type LifecycleStage, type TokamakContext } from "@tokamakdev/plugin";
 /** Runs once per runtime start, including when the system starts the app in the background. */
 export declare const onStart: (listener: import("@tokamakdev/plugin/events").Listener<{
     readonly foreground: boolean;
@@ -6,11 +7,10 @@ export declare const onStart: (listener: import("@tokamakdev/plugin/events").Lis
 export declare const onResume: (listener: import("@tokamakdev/plugin/events").Listener<Readonly<Record<string, never>>, void>) => void;
 /** Runs each time the app moves out of the foreground. */
 export declare const onSuspend: (listener: import("@tokamakdev/plugin/events").Listener<Readonly<Record<string, never>>, void>) => void;
-/** Whether the app is on screen. */
-export type LifecycleStage = "foreground" | "background";
+export type { LifecycleStage } from "@tokamakdev/plugin";
 /**
  * The app's stage now, which can differ from the last event delivered: an `onSuspend` listener
  * that runs late reads `"foreground"` once the user has returned. Rejects with
  * `NotSupportedError` outside a tokamak Worker.
  */
-export declare function getLifecycleStage(): Promise<LifecycleStage>;
+export declare function getLifecycleStage(ctx: TokamakContext): Promise<LifecycleStage>;

package/dist/events.mjs

@@ -1,4 +1,4 @@
-import { Plugin } from "@tokamakdev/plugin";
+import { lifecycleStage } from "@tokamakdev/plugin";
 import { defineEvent } from "@tokamakdev/plugin/events";
 /** Runs once per runtime start, including when the system starts the app in the background. */
 export const onStart = defineEvent("start");
@@ -6,21 +6,11 @@ export const onStart = defineEvent("start");
 export const onResume = defineEvent("resume");
 /** Runs each time the app moves out of the foreground. */
 export const onSuspend = defineEvent("suspend");
-/** The functions the runtime answers itself, as the reserved plugin `tokamak`. */
-class Tokamak extends Plugin {
-    constructor() {
-        super("tokamak");
-    }
-    lifecycleStage() {
-        return this.call("lifecycleStage");
-    }
-}
-const tokamak = new Tokamak();
 /**
  * The app's stage now, which can differ from the last event delivered: an `onSuspend` listener
  * that runs late reads `"foreground"` once the user has returned. Rejects with
  * `NotSupportedError` outside a tokamak Worker.
  */
-export function getLifecycleStage() {
-    return tokamak.lifecycleStage();
+export function getLifecycleStage(ctx) {
+    return lifecycleStage(ctx);
 }

package/dist/index.d.mts

@@ -1,3 +1,5 @@
+export { TokamakEntrypoint } from "@tokamakdev/plugin/worker";
+export type { TokamakContext, TokamakEvent, WebView } from "@tokamakdev/plugin/worker";
 /** A setting value. */
 export type Value = string | number | boolean;
 /** One platform's settings: the shared keys and the settings its platform pack declares. */

package/dist/index.mjs

@@ -1 +1 @@
-export {};
+export { TokamakEntrypoint } from "@tokamakdev/plugin/worker";

package/dist/native-worker.d.mts

@@ -0,0 +1,12 @@
+import { type Plugin } from "vite";
+import type { Config } from "./index.mjs";
+import { type WorkerGraph } from "./worker-graph.mjs";
+export type TokamakOptions = Config & {
+    /** Native worker entrypoint, relative to the Vite root; defaults to src/tokamak.ts or .js. */
+    module?: string;
+};
+/** The native worker and its development relay. */
+export declare function createNativeWorker(options: TokamakOptions, output: string, prepare?: (root: string, graph: WorkerGraph) => void | Promise<void>): {
+    plugin: Plugin;
+    graph(): WorkerGraph;
+};

package/dist/native-worker.mjs

@@ -0,0 +1,101 @@
+import { X509Certificate } from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+import { normalizePath } from "vite";
+import { capabilitiesFor } from "@tokamakdev/plugin/capabilities";
+import { openDevSocket } from "./dev-socket.mjs";
+import { findModule } from "./worker-contract.mjs";
+import { createWorkerGraph } from "./worker-graph.mjs";
+const CAPABILITIES = "/_tokamak/capabilities.js";
+const MIDDLEWARE_MODE_ERROR = "Vite is running in middleware mode, so tokamak cannot find the development server's address; tok dev needs Vite's own dev server";
+/** The native worker and its development relay. */
+export function createNativeWorker(options, output, prepare) {
+    const { module, ...config } = options;
+    const token = process.env.TOKAMAK_SESSION_TOKEN;
+    const platform = process.env.TOKAMAK_PLATFORM;
+    let graph;
+    const plugin = {
+        name: "tokamak",
+        enforce: "pre",
+        async config(vite, environment) {
+            const root = normalizePath(path.resolve(vite.root ?? process.cwd()));
+            graph = createWorkerGraph(root, findModule(root, module), path.join(output, "worker"));
+            graph.plugin.config.call(this, vite, environment);
+            await prepare?.(root, graph);
+            writeJson(output, "config.json", { root, config });
+        },
+        configEnvironment: {
+            order: "post",
+            handler(name, config) {
+                return graph.plugin.configEnvironment.handler(name, config);
+            },
+        },
+        buildStart(options) {
+            return graph.plugin.buildStart.call(this, options);
+        },
+        hotUpdate(options) {
+            return graph.plugin.hotUpdate.call(this, options);
+        },
+        resolveId(...args) {
+            return graph.plugin.resolveId.call(this, ...args);
+        },
+        load(...args) {
+            return graph.plugin.load.call(this, ...args);
+        },
+        configureServer: {
+            order: "pre",
+            async handler(server) {
+                const devSocket = await serveNativeWorker(server, graph.names(), output, token);
+                if (devSocket && token)
+                    graph.relay(devSocket.port, token, platform);
+                // A page loaded from this server, not the device, still gets the device's capabilities.
+                server.middlewares.use(CAPABILITIES, (_request, response) => {
+                    const capabilities = capabilitiesFor(graph.availability(), platform);
+                    response.setHeader("content-type", "text/javascript; charset=utf-8");
+                    response.end(`export default ${JSON.stringify(capabilities)};\n`);
+                });
+            },
+        },
+    };
+    return { plugin, graph: () => graph };
+}
+async function serveNativeWorker(server, names, output, token) {
+    const httpServer = server.httpServer;
+    if (!httpServer) {
+        if (!fs.existsSync(path.join(output, "server.json"))) {
+            writeJson(output, "server.json", { error: MIDDLEWARE_MODE_ERROR });
+        }
+        return;
+    }
+    const socket = await openDevSocket(names.native, token);
+    httpServer.once("close", () => void socket.close());
+    httpServer.once("listening", () => {
+        const urls = server.resolvedUrls;
+        writeJson(output, "server.json", {
+            url: urls?.local[0] ?? urls?.network[0],
+            workerName: names.app,
+            certificates: endEntityCertificates(server.config.server.https),
+            socketPort: socket.port,
+        });
+    });
+    return socket;
+}
+function endEntityCertificates(https) {
+    const cert = typeof https?.cert === "string" ? readFileIfExists(https.cert) : https?.cert;
+    return cert && [cert].flat().map((chain) => new X509Certificate(chain).toString()).join("");
+}
+function readFileIfExists(file) {
+    try {
+        return fs.readFileSync(path.resolve(file));
+    }
+    catch {
+        return file;
+    }
+}
+/** Write reports atomically while tok watches for them. */
+function writeJson(output, name, value) {
+    const file = path.join(output, name);
+    fs.mkdirSync(output, { recursive: true });
+    fs.writeFileSync(`${file}.tmp`, `${JSON.stringify(value, null, 2)}\n`);
+    fs.renameSync(`${file}.tmp`, file);
+}

package/dist/native.d.mts

@@ -1,6 +1,19 @@
+import type { NativePlatform } from "@tokamakdev/plugin/capabilities";
 /**
- * Defines `__tokamakNativeCall` and `__tokamakNativeListen`, which post to the plugin's loopback
- * `port` with the session `token`. `waitUntil` keeps each listener's invocation running, as
- * `waitUntil` from `cloudflare:workers` does.
+ * The development invocation `ctx`'s native connection, which reaches the byte endpoints of a
+ * device on `platform` through the relay on `port`. Its subscriptions are `ctx`'s `waitUntil` work.
  */
-export declare function defineNativeCalls(port: number, token: string, waitUntil: (promise: Promise<unknown>) => void): void;
+export declare function connectDevice(port: number, token: string, ctx: {
+    waitUntil(promise: Promise<unknown>): void;
+}, platform?: NativePlatform): {
+    platform: NativePlatform | undefined;
+    call(plugin: string, method: string, payload: Uint8Array, { body, signal }?: {
+        body?: ReadableStream<Uint8Array>;
+        signal?: AbortSignal;
+    }): Promise<Uint8Array<ArrayBufferLike>>;
+    listen(plugin: string, method: string, payload: Uint8Array, { next, error, overflow }: {
+        next(value: Uint8Array, done: boolean): void;
+        error(error: DOMException, done: boolean): void;
+        overflow?: string;
+    }): () => void;
+};