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

package/dist/native.mjs

@@ -1,72 +1,119 @@
-// Defines the development Worker's native calls, which reach the device through the tokamak Vite
-// plugin. The plugin's entry Worker transform imports this module in development only.
+import { decodeMessage, encodeMessage, messages, nativeError } from "@tokamakdev/plugin/native-protocol";
+const encoder = new TextEncoder();
+const decoder = new TextDecoder();
 /**
- * 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 function defineNativeCalls(port, token, waitUntil) {
-    const post = async (path, plugin, method, arguments_, signal) => {
+export function connectDevice(port, token, ctx, platform) {
+    const post = async (path, request, signal) => {
         const response = await fetch(`http://127.0.0.1:${String(port)}${path}`, {
             method: "POST",
             headers: { "x-tokamak-session": token },
-            body: JSON.stringify({ plugin, method, arguments: arguments_ }),
+            body: request,
             signal,
+            duplex: "half",
         });
         if (!response.ok)
             throw new Error(`the tokamak Vite plugin answered HTTP ${String(response.status)}`);
         return response;
     };
-    globalThis.__tokamakNativeCall = async (plugin, method, arguments_ = null) => {
-        let result;
-        try {
-            result = (await (await post("/call", plugin, method, arguments_)).json());
-        }
-        catch (error) {
-            throw networkError(error);
-        }
-        if (result.error)
-            throw new DOMException(result.error.message, result.error.name);
-        return result.value;
+    const result = ({ header, payload }) => {
+        if (header.failed)
+            throw nativeError(JSON.parse(decoder.decode(payload)));
+        return payload;
     };
-    globalThis.__tokamakNativeListen = (plugin, method, arguments_, next, error) => {
-        const listening = new AbortController();
-        const deliver = (result) => {
+    return {
+        platform,
+        async call(plugin, method, payload, { body, signal } = {}) {
+            signal?.throwIfAborted();
+            const header = { type: body ? "callWithBody" : "call", plugin, method };
+            let message;
             try {
-                if (result.error)
-                    error(new DOMException(result.error.message, result.error.name));
-                else
-                    next(result.value);
+                const request = body ? framed(encodeMessage(header, payload), body) : encodeMessage(header, payload);
+                message = decodeMessage(new Uint8Array(await (await post("/call", request, signal)).arrayBuffer()));
             }
-            catch (thrown) {
-                reportError(thrown);
+            catch (error) {
+                if (signal?.aborted)
+                    throw signal.reason;
+                throw networkError(error);
             }
-        };
-        const listen = async () => {
-            const response = await post("/subscribe", plugin, method, arguments_ ?? null, listening.signal);
-            for await (const result of lines(response))
-                deliver(result);
-        };
-        waitUntil(listen().catch((failure) => {
-            if (!listening.signal.aborted)
-                deliver({ error: networkError(failure), done: true });
-        }));
-        return () => {
-            listening.abort();
-        };
+            return result(message);
+        },
+        listen(plugin, method, payload, { next, error, overflow = "error" }) {
+            const listening = new AbortController();
+            const deliver = (message) => {
+                let value;
+                try {
+                    value = result(message);
+                }
+                catch (failure) {
+                    try {
+                        error(failure, message.header.done === true);
+                    }
+                    catch (thrown) {
+                        reportError(thrown);
+                    }
+                    return;
+                }
+                try {
+                    next(value, message.header.done === true);
+                }
+                catch (thrown) {
+                    reportError(thrown);
+                }
+            };
+            const listen = async () => {
+                const request = encodeMessage({ type: "subscribe", plugin, method, overflow }, payload);
+                const response = await post("/subscribe", request, listening.signal);
+                for await (const message of messages(response.body))
+                    deliver(message);
+            };
+            ctx.waitUntil(listen().catch((failure) => {
+                if (!listening.signal.aborted) {
+                    try {
+                        error(networkError(failure), true);
+                    }
+                    catch (thrown) {
+                        reportError(thrown);
+                    }
+                }
+            }));
+            return () => { listening.abort(); };
+        },
     };
 }
-/** Each line of `response`'s body, parsed as a result. */
-async function* lines(response) {
-    const decoder = new TextDecoder();
-    let text = "";
-    for await (const chunk of response.body ?? []) {
-        text += decoder.decode(chunk, { stream: true });
-        const complete = text.split("\n");
-        text = complete.pop() ?? "";
-        for (const line of complete)
-            yield JSON.parse(line);
-    }
+/** The call message `first`, then a `chunk` message per chunk of `body` as the relay reads them. */
+function framed(first, body) {
+    const reader = body.getReader();
+    let started = false;
+    const chunk = (header, payload) => encodeMessage({ type: "chunk", ...header }, payload);
+    return new ReadableStream({
+        async pull(controller) {
+            if (!started) {
+                started = true;
+                controller.enqueue(first);
+                return;
+            }
+            try {
+                const { value, done } = await reader.read();
+                if (done) {
+                    controller.enqueue(chunk({ done: true }, new Uint8Array()));
+                    controller.close();
+                    return;
+                }
+                if (!(value instanceof Uint8Array))
+                    throw new TypeError("A native call's body must contain Uint8Array chunks");
+                controller.enqueue(chunk({}, value));
+            }
+            catch (error) {
+                const failure = { name: error?.name ?? "Error", message: String(error?.message ?? error) };
+                controller.enqueue(chunk({ failed: true, done: true }, encoder.encode(JSON.stringify(failure))));
+                controller.close();
+            }
+        },
+        cancel(reason) { return reader.cancel(reason); },
+    });
 }
 function networkError(error) {
     return new DOMException(`The device could not be reached: ${String(error)}`, "NetworkError");

package/dist/plugin-manifest.d.mts

@@ -0,0 +1,31 @@
+export interface ModuleExport {
+    module: string;
+    export: string;
+}
+/** A native platform a plugin builds for. */
+export type NativePlatform = "ios" | "macos" | "android" | "windows" | "linux";
+/** Where an operation runs, and what it needs there. */
+export interface Operation {
+    /** The native platforms that implement it, with any minimum OS version. */
+    platforms: {
+        name: NativePlatform;
+        minimum?: string;
+    }[];
+    /** The native platforms where it needs the app in the foreground, to show UI. */
+    foreground: NativePlatform[];
+}
+export interface PluginDefinition {
+    id: string;
+    package: string;
+    manifest: string;
+    api: ModuleExport;
+    web?: ModuleExport;
+    binding: string;
+    client: string;
+    /** The native platforms the plugin builds for. */
+    platforms: NativePlatform[];
+    /** Each operation the manifest describes; others run on every platform the plugin builds for. */
+    operations: Record<string, Operation>;
+}
+/** Installed direct dependencies select the application's plugin services. */
+export declare function discoverPlugins(root: string): PluginDefinition[];

package/dist/plugin-manifest.mjs

@@ -0,0 +1,96 @@
+import fs from "node:fs";
+import { createRequire } from "node:module";
+import path from "node:path";
+const nativePlatforms = ["ios", "macos", "android", "windows", "linux"];
+const reservedIds = ["tokamak", "android", "ios", "macos", "windows", "name", "identifier", "icon", "version",
+    "module", "build", "project", "platform", "skip", "host", "help", "vite", "session"];
+/** Installed direct dependencies select the application's plugin services. */
+export function discoverPlugins(root) {
+    const file = path.join(root, "package.json");
+    if (!fs.existsSync(file))
+        return [];
+    const app = JSON.parse(fs.readFileSync(file, "utf8"));
+    const dependencies = new Set(["dependencies", "devDependencies", "peerDependencies"]
+        .flatMap(key => Object.keys(app[key] ?? {})));
+    const require = createRequire(file);
+    const plugins = new Map();
+    for (const name of dependencies) {
+        const directory = require.resolve.paths(name)?.map(base => path.join(base, name))
+            .find(candidate => fs.existsSync(path.join(candidate, "package.json")));
+        if (!directory)
+            continue;
+        const candidate = path.join(directory, "tokamak-plugin.json");
+        if (!fs.existsSync(candidate))
+            continue;
+        const manifest = fs.realpathSync(candidate).split(path.sep).join("/");
+        const data = JSON.parse(fs.readFileSync(manifest, "utf8"));
+        // Schema version one supplies only native build metadata.
+        if (data.schemaVersion === 1)
+            continue;
+        if (data.schemaVersion !== 2)
+            throw new Error(`${manifest}: unsupported plugin schema version ${data.schemaVersion}.`);
+        if (typeof data.id !== "string" || !/^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$/.test(data.id) || data.id.length > 63) {
+            throw new Error(`${manifest}: plugin id must be lowercase words joined by single hyphens.`);
+        }
+        const reserved = reservedIds.find(word => data.id === word || data.id.startsWith(`${word}-`));
+        if (reserved)
+            throw new Error(`${manifest}: plugin id must not start with '${reserved}', which Tokamak's options use.`);
+        const api = moduleExport(directory, data.api, "api");
+        if (plugins.has(data.id))
+            throw new Error(`Duplicate Tokamak plugin id ${data.id}.`);
+        const platforms = nativePlatforms.filter(platform => data.platforms?.[platform] !== undefined);
+        plugins.set(data.id, {
+            id: data.id, package: name, manifest, api,
+            web: data.web === undefined ? undefined : moduleExport(directory, data.web, "web"),
+            binding: `TOKAMAK_${data.id.toUpperCase().replaceAll("-", "_")}`,
+            client: `${name}/client`,
+            platforms,
+            operations: operations(manifest, data.operations ?? {}, platforms),
+        });
+    }
+    return [...plugins.values()].sort((left, right) => left.id.localeCompare(right.id));
+}
+function moduleExport(root, reference, field) {
+    const value = reference;
+    if (!value || typeof value.module !== "string" || typeof value.export !== "string" || !value.export) {
+        throw new Error(`${root}: ${field} must name a module and export.`);
+    }
+    const module = fs.realpathSync(path.resolve(root, value.module));
+    const relative = path.relative(fs.realpathSync(root), module);
+    if (relative === ".." || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative) || !fs.statSync(module).isFile()) {
+        throw new Error(`${root}: ${field}.module must be a file inside the plugin package.`);
+    }
+    return { module: module.split(path.sep).join("/"), export: value.export };
+}
+/** The manifest's `operations`, each on platforms the plugin builds for. */
+function operations(manifest, value, built) {
+    const fail = (message) => { throw new Error(`${manifest}: ${message}`); };
+    const platform = (name, field) => built.includes(name) ? name : fail(`${field} names ${name}, which the plugin does not build for.`);
+    if (!isRecord(value))
+        return fail("operations must be an object.");
+    const result = {};
+    for (const [name, entry] of Object.entries(value)) {
+        const field = `operations.${name}`;
+        if (!isRecord(entry))
+            return fail(`${field} must be an object.`);
+        const { platforms, foreground = false, ...unknown } = entry;
+        if (Object.keys(unknown).length)
+            fail(`${field} has unknown keys: ${Object.keys(unknown).join(", ")}.`);
+        if (platforms !== undefined && (!isRecord(platforms) ||
+            !Object.values(platforms).every(version => typeof version === "string" || version === true))) {
+            fail(`${field}.platforms must map platforms to a minimum OS version, or true for the app's minimum.`);
+        }
+        if (typeof foreground !== "boolean" && !(Array.isArray(foreground) && foreground.every(name => typeof name === "string"))) {
+            fail(`${field}.foreground must be true or a list of platforms.`);
+        }
+        const implemented = platforms === undefined
+            ? built.map(name => ({ name }))
+            : Object.entries(platforms).map(([name, minimum]) => ({ name: platform(name, `${field}.platforms`), minimum: minimum === true ? undefined : minimum }));
+        const needs = foreground === true ? implemented.map(({ name }) => name) : foreground === false ? [] : foreground;
+        result[name] = { platforms: implemented, foreground: needs.map(name => platform(name, `${field}.foreground`)) };
+    }
+    return result;
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/dist/rpc-contract.d.mts

@@ -0,0 +1,9 @@
+import ts from "typescript";
+/** A method that passes a value only the Tokamak worker can hold. */
+export declare class WorkerOnlyMethod extends Error {
+}
+/**
+ * Validates every overload before generating a remote method. A signature containing the
+ * `workerOnly` type throws `WorkerOnlyMethod`.
+ */
+export declare function checkRpcMethod(checker: ts.TypeChecker, method: ts.Type, name: string, workerOnly?: ts.Symbol): void;

package/dist/rpc-contract.mjs

@@ -0,0 +1,168 @@
+import ts from "typescript";
+const scalars = ts.TypeFlags.StringLike | ts.TypeFlags.NumberLike | ts.TypeFlags.BooleanLike |
+    ts.TypeFlags.BigIntLike | ts.TypeFlags.Null | ts.TypeFlags.Undefined | ts.TypeFlags.Never;
+const binaryViews = new Set([
+    "Int8Array", "Uint8Array", "Uint8ClampedArray", "Int16Array", "Uint16Array",
+    "Int32Array", "Uint32Array", "Float16Array", "Float32Array", "Float64Array",
+    "BigInt64Array", "BigUint64Array", "DataView",
+]);
+const errors = new Set(["Error", "DOMException", "AggregateError", "EvalError", "RangeError", "ReferenceError", "SyntaxError", "TypeError", "URIError"]);
+/** A method that passes a value only the Tokamak worker can hold. */
+export class WorkerOnlyMethod extends Error {
+}
+/**
+ * Validates every overload before generating a remote method. A signature containing the
+ * `workerOnly` type throws `WorkerOnlyMethod`.
+ */
+export function checkRpcMethod(checker, method, name, workerOnly) {
+    const signatures = method.getCallSignatures();
+    if (!signatures.length)
+        reject(checker, method, name, "expected a callable method");
+    for (const signature of signatures)
+        checkSignature(checker, signature, name, workerOnly);
+}
+function checkSignature(checker, signature, name, workerOnly) {
+    if (signature.typeParameters?.length) {
+        throw new Error(`Unsupported RPC signature at ${name}: generic methods need a concrete service signature.`);
+    }
+    const traversal = { seen: new Set(), depth: 0, workerOnly };
+    for (const parameter of signature.parameters) {
+        checkValue(checker, checker.getTypeOfSymbol(parameter), `${name}.${parameter.name}`, traversal);
+    }
+    const result = checker.getAwaitedType(signature.getReturnType());
+    if (!result)
+        throw new Error(`Unsupported RPC result at ${name}.result: cannot resolve the awaited result.`);
+    for (const member of result.isUnion() ? result.types : [result]) {
+        if (!(member.flags & ts.TypeFlags.Void))
+            checkValue(checker, member, `${name}.result`, traversal);
+    }
+}
+function reject(checker, type, path, reason) {
+    throw new Error(`Unsupported RPC type at ${path}: ${reason ?? checker.typeToString(type)}.`);
+}
+/** Global ambient types identify host values; module-local names do not. */
+function builtin(checker, type) {
+    const symbol = type.getSymbol();
+    if (!symbol)
+        return;
+    if (symbol.name === "ReadableStream" && nodeReadableStream(checker, symbol))
+        return symbol.name;
+    if (symbol !== checker.resolveName(symbol.name, undefined, ts.SymbolFlags.Type, false))
+        return;
+    const ambient = symbol.declarations?.some((declaration) => declaration.getSourceFile().isDeclarationFile);
+    const value = checker.resolveName(symbol.name, undefined, ts.SymbolFlags.Value, false);
+    return ambient && (value || ["ReadonlyArray", "ReadonlyMap", "ReadonlySet"].includes(symbol.name)) ? symbol.name : undefined;
+}
+function nodeReadableStream(checker, symbol) {
+    return checker.getAmbientModules().filter((module) => ["\"stream/web\"", "\"node:stream/web\""].includes(module.name))
+        .some((module) => checker.getExportsOfModule(module).some((member) => member.name === "ReadableStream" &&
+        (member.flags & ts.SymbolFlags.Alias ? checker.getAliasedSymbol(member) : member) === symbol));
+}
+function argumentsOf(checker, type) {
+    return type.flags & ts.TypeFlags.Object && type.objectFlags & ts.ObjectFlags.Reference
+        ? checker.getTypeArguments(type) : [];
+}
+function checkValue(checker, type, path, traversal) {
+    if (type.flags & scalars || traversal.seen.has(type))
+        return;
+    if (traversal.depth >= 100)
+        reject(checker, type, path, "type expansion is too deep to verify; use a finite recursive data shape");
+    traversal.seen.add(type);
+    traversal.depth++;
+    try {
+        checkObject(checker, type, path, traversal);
+    }
+    finally {
+        traversal.depth--;
+    }
+}
+function checkObject(checker, type, path, traversal) {
+    if (type.isIntersection() && type.types.some((member) => Boolean(member.flags & scalars)) &&
+        !type.getCallSignatures().length && !type.getConstructSignatures().length)
+        return;
+    if (type.isUnionOrIntersection()) {
+        for (const member of type.types)
+            checkValue(checker, member, path, traversal);
+        return;
+    }
+    if (!(type.flags & ts.TypeFlags.Object))
+        reject(checker, type, path);
+    if (traversal.workerOnly && type.getSymbol() === traversal.workerOnly) {
+        throw new WorkerOnlyMethod(`${path} is ${checker.typeToString(type)}, which stays in the Tokamak worker.`);
+    }
+    if (type.getCallSignatures().length || type.getConstructSignatures().length)
+        reject(checker, type, path);
+    const name = builtin(checker, type);
+    if (name === "Date" || name === "RegExp" || name === "ArrayBuffer")
+        return;
+    if (name && binaryViews.has(name))
+        return checkBuffer(checker, type, path);
+    if (name === "ReadableStream")
+        return checkStream(checker, type, path);
+    if (checker.isArrayType(type) || checker.isTupleType(type) || name === "ReadonlyArray") {
+        checkArguments(checker, type, path, traversal);
+        return;
+    }
+    if (["Map", "ReadonlyMap", "Set", "ReadonlySet"].includes(name ?? "")) {
+        checkArguments(checker, type, path, traversal);
+        return;
+    }
+    if (isError(checker, type))
+        return checkProperties(checker, type, path, traversal, true);
+    const classType = type.getSymbol()?.declarations?.some((node) => ts.isClassDeclaration(node) || ts.isClassExpression(node));
+    if (name || classType)
+        reject(checker, type, path);
+    checkProperties(checker, type, path, traversal);
+}
+function isError(checker, type) {
+    if (errors.has(builtin(checker, type) ?? ""))
+        return true;
+    if (!(type.flags & ts.TypeFlags.Object))
+        return false;
+    const object = type;
+    const target = object.objectFlags & ts.ObjectFlags.Reference ? type.target : object;
+    return Boolean(target.objectFlags & ts.ObjectFlags.ClassOrInterface) &&
+        checker.getBaseTypes(target).some((base) => isError(checker, base));
+}
+function checkArguments(checker, type, path, traversal) {
+    for (const [index, argument] of argumentsOf(checker, type).entries()) {
+        checkValue(checker, argument, `${path}[${index}]`, traversal);
+    }
+}
+function checkBuffer(checker, type, path) {
+    const [buffer] = argumentsOf(checker, type);
+    // Default ArrayBufferLike views require the runtime's non-shared-buffer check.
+    if (buffer && builtin(checker, buffer) === "SharedArrayBuffer")
+        reject(checker, type, path, "shared buffers cannot cross RPC");
+    if (buffer && buffer.flags & (ts.TypeFlags.Any | ts.TypeFlags.Unknown | ts.TypeFlags.TypeParameter))
+        reject(checker, buffer, path);
+}
+function checkStream(checker, type, path) {
+    const [chunk] = argumentsOf(checker, type);
+    if (!chunk || builtin(checker, chunk) !== "Uint8Array") {
+        reject(checker, type, path, "readable streams must contain Uint8Array chunks");
+    }
+    checkBuffer(checker, chunk, path);
+}
+function checkProperties(checker, type, path, traversal, error = false) {
+    const properties = type.getProperties();
+    const indexes = checker.getIndexInfosOfType(type);
+    if (!error && !properties.length && !indexes.length)
+        reject(checker, type, path, "an unconstrained object is not a data shape");
+    for (const property of properties) {
+        if (String(property.escapedName).startsWith("__@"))
+            reject(checker, type, path, "symbol properties cannot cross RPC");
+        if (error && standardErrorField(checker, property))
+            continue;
+        checkValue(checker, checker.getTypeOfSymbol(property), `${path}.${property.name}`, traversal);
+    }
+    for (const index of indexes) {
+        if (index.keyType.flags & ts.TypeFlags.ESSymbolLike)
+            reject(checker, type, path, "symbol indexes cannot cross RPC");
+        checkValue(checker, index.type, `${path}[key]`, traversal);
+    }
+}
+function standardErrorField(checker, property) {
+    return property.declarations?.some(({ parent }) => (ts.isInterfaceDeclaration(parent) || ts.isClassDeclaration(parent)) &&
+        errors.has(builtin(checker, checker.getTypeAtLocation(parent)) ?? "")) ?? false;
+}

package/dist/service-types.d.mts

@@ -0,0 +1,9 @@
+import type { NativeService } from "./worker-types.mjs";
+export interface ServiceMethod {
+    name: string;
+    overloads: number;
+    documentation: string;
+}
+/** Retain the original types while making every exposed overload asynchronous. */
+export declare function serviceTypes(instance: string, methods: ServiceMethod[], name?: string): string;
+export declare function writeEnvironmentTypes(root: string, services: NativeService[], main: string, bindings: string[]): void;

package/dist/service-types.mjs

@@ -0,0 +1,64 @@
+import fs from "node:fs";
+import path from "node:path";
+/** Retain the original types while making every exposed overload asynchronous. */
+export function serviceTypes(instance, methods, name = "Tokamak") {
+    const counts = [...new Set(methods.map((method) => method.overloads))].sort((a, b) => a - b);
+    const helpers = counts.map((count) => {
+        const signatures = Array.from({ length: count }, (_, index) => index);
+        const match = signatures.map((index) => `(...args: infer A${index}): infer R${index};`);
+        const wrapped = signatures.map((index) => `(...args: A${index}): Promise<Awaited<R${index}>>;`);
+        return `type Async${count}<T> = T extends {\n  ${match.join("\n  ")}\n} ? {\n  ${wrapped.join("\n  ")}\n} : never;`;
+    });
+    const members = methods.map(({ name, overloads, documentation }) => {
+        const comment = documentation ? `  /** ${documentation.replaceAll("*/", "* /").replaceAll("\n", "\n   * ")} */\n` : "";
+        return `${comment}  ${JSON.stringify(name)}: Async${overloads}<Worker[${JSON.stringify(name)}]>;`;
+    });
+    const operations = methods.map(({ name }) => JSON.stringify(name)).join(" | ") || "never";
+    return `type Worker = ${instance};
+
+${helpers.join("\n\n")}
+
+export interface ${name}Operations {
+${members.join("\n")}
+}
+
+export interface ${name}Client extends ${name}Operations {
+  /** Whether each operation is implemented where the app runs. It does not report permission or promise that a call succeeds. */
+  readonly capabilities: Readonly<Record<${operations}, boolean>>;
+}
+
+export interface ${name}Service extends ${name}Operations {
+  fetch(input: Request | string | URL, init?: RequestInit): Promise<Response>;
+}
+`;
+}
+export function writeEnvironmentTypes(root, services, main, bindings) {
+    const file = path.join(root, "tokamak-env.d.ts");
+    const previous = fs.existsSync(file) ? fs.readFileSync(file, "utf8") : undefined;
+    if (previous !== undefined && !previous.startsWith("// Generated by tokamak.\n")) {
+        throw new Error(`${file} is reserved for generated Tokamak types; move the existing declarations to another file.`);
+    }
+    const clients = services.map(service => `declare module ${JSON.stringify(service.client)} {
+${service.contract.declarations.trimEnd().split("\n").map(line => line ? `  ${line}` : line).join("\n")}
+  const client: TokamakClient;
+  export default client;
+}`).join("\n\n");
+    const source = `// Generated by tokamak.
+${clients}
+
+declare namespace Cloudflare {
+  interface Env {
+${services.map(service => `    ${service.binding}?: import(${JSON.stringify(service.client)}).TokamakService;`).join("\n")}
+  }
+}
+
+declare namespace Tokamak {
+${main.trimEnd().split("\n").map(line => line ? `  ${line}` : line).join("\n")}
+  interface Env extends Pick<Cloudflare.Env, Extract<keyof Cloudflare.Env, ${bindings.map(name => JSON.stringify(name)).join(" | ") || "never"}>> {
+    MAIN: MainService;
+  }
+}
+`;
+    if (previous !== source)
+        fs.writeFileSync(file, source);
+}

package/dist/vite.d.mts

@@ -1,17 +1,6 @@
-import { type Plugin } from "vite";
-import type { Config } from "./index.mjs";
-/**
- * Reports the app's tokamak configuration, and the development server's
- * address, HTTPS certificate, Worker name and dev socket port, to `tok`, and
- * makes the entry Worker import `module` and export `TokamakEvents`. In
- * development, the entry Worker also defines native calls that reach the
- * device through the dev socket. Without `TOKAMAK_VITE_OUTPUT`, which `tok`
- * sets, it adds no hooks.
- */
-export declare function tokamak({ module, ...config }?: Config & {
-    /**
-     * The module the entry Worker imports, relative to the Vite root; by
-     * default `src/tokamak.ts`, then `src/tokamak.js`, when one exists.
-     */
-    module?: string;
-}): Plugin[];
+import { type PluginConfig } from "@cloudflare/vite-plugin";
+import type { Plugin } from "vite";
+import { type TokamakOptions } from "./native-worker.mjs";
+export type { TokamakOptions } from "./native-worker.mjs";
+/** Cloudflare's Vite integration, with a separate native worker when run by tok. */
+export declare function tokamak(options?: TokamakOptions, cloudflareOptions?: PluginConfig): Plugin[];