@tokamakdev/tok 0.1.1-beta.114 → 0.1.1-beta.116

package/dist/astro.mjs

@@ -8,6 +8,9 @@ import { normalizePath } from "vite";
 import { experimental_readRawConfig, unstable_readConfig } from "wrangler";
 import { createNativeWorker } from "./native-worker.mjs";
 import { createClientPlugin } from "./client.mjs";
+import { writeChanged } from "./worker-graph.mjs";
+/** The Worker entry Astro's Cloudflare adapter builds when the configuration names none. */
+const ASTRO_SERVER = "@astrojs/cloudflare/entrypoints/server";
 /** Astro's Cloudflare adapter, with Tokamak's native worker and development relay. */
 export function tokamak(options = {}, cloudflareOptions = {}) {
     const output = process.env.TOKAMAK_VITE_OUTPUT;
@@ -25,16 +28,11 @@ export function tokamak(options = {}, cloudflareOptions = {}) {
                         config(vite) {
                             const root = path.resolve(vite.root ?? process.cwd());
                             const source = configuration(root, cloudflareOptions.configPath, false);
-                            const raw = source ? experimental_readRawConfig({ config: source }, { useRedirectIfAvailable: false }).rawConfig : {};
-                            const environment = process.env.CLOUDFLARE_ENV;
-                            const selected = source ? unstable_readConfig({ config: source, env: environment }, { hideWarnings: true }) : {};
-                            const main = (environment ? raw.env?.[environment]?.main : undefined)
-                                ?? raw.main ?? "@astrojs/cloudflare/entrypoints/server";
+                            const selected = source ? readWorker(source).selected : { main: ASTRO_SERVER };
                             client.configure({
                                 ...selected,
                                 // Type inspection needs the server source, not a client-optimized module.
-                                main: main === "@astrojs/cloudflare/entrypoints/server"
-                                    ? fileURLToPath(import.meta.resolve(main)) : main,
+                                main: selected.main === ASTRO_SERVER ? fileURLToPath(import.meta.resolve(ASTRO_SERVER)) : selected.main,
                                 kv_namespaces: [...selected.kv_namespaces ?? [], ...sessionBinding ? [{ binding: sessionBinding }] : []],
                             });
                         },
@@ -85,42 +83,26 @@ export function tokamak(options = {}, cloudflareOptions = {}) {
     const native = createNativeWorker(options, output, (root, graph) => {
         const source = configuration(root, cloudflareOptions.configPath);
         generatedPath = path.resolve(root, generated);
-        const rawConfig = experimental_readRawConfig({ config: source }, { useRedirectIfAvailable: false }).rawConfig;
-        const environment = process.env.CLOUDFLARE_ENV;
-        const selected = unstable_readConfig({ config: source, env: environment }, { hideWarnings: true });
-        selected.main = (environment ? rawConfig.env?.[environment]?.main : undefined)
-            ?? rawConfig.main ?? "@astrojs/cloudflare/entrypoints/server";
-        const main = selected.main;
+        const { raw, selected } = readWorker(source);
+        const appMain = selected.main;
         graph.configure(selected);
-        const environments = [[undefined, rawConfig], ...Object.entries(rawConfig.env ?? {})];
-        for (const [env, config] of environments) {
+        // In development the graph serves main through its own module, which every environment uses.
+        const servedMain = selected.main === appMain ? undefined : selected.main;
+        for (const [env, config] of [[undefined, raw], ...Object.entries(raw.env ?? {})]) {
             const resolved = unstable_readConfig({ config: source, env }, { hideWarnings: true });
-            if (!resolved.name)
-                throw new Error("Tokamak requires a name in the main Worker's configuration.");
-            const services = graph.services(resolved.name);
-            const reserved = config.services?.find(binding => services.some(service => service.binding === binding.binding));
-            if (reserved) {
-                throw new Error(`${reserved.binding} is reserved for a generated native worker binding.`);
-            }
-            config.services = [...config.services ?? [], ...services];
-            if (selected.main !== main)
-                config.main = selected.main;
+            config.services = [...config.services ?? [], ...graph.serviceBindings(resolved)];
+            if (servedMain)
+                config.main = servedMain;
         }
         // Keeping the generated configuration beside its source preserves relative paths and .dev.vars.
-        const content = `${JSON.stringify(rawConfig, null, 2)}\n`;
-        if (!fs.existsSync(generatedPath) || fs.readFileSync(generatedPath, "utf8") !== content) {
-            fs.writeFileSync(generatedPath, content);
-        }
+        writeChanged(generatedPath, `${JSON.stringify(raw, null, 2)}\n`);
         process.off("exit", cleanup);
         process.once("exit", cleanup);
     });
     const adapter = cloudflare({
         ...cloudflareOptions,
         configPath: generated,
-        auxiliaryWorkers: [{
-                viteEnvironment: { name: "tokamak" },
-                config: (worker, context) => native.graph().native(worker, context),
-            }],
+        auxiliaryWorkers: [native.auxiliaryWorker],
     });
     return {
         ...adapter,
@@ -149,6 +131,14 @@ export function tokamak(options = {}, cloudflareOptions = {}) {
         },
     };
 }
+/** The Wrangler configuration at `source`: as written, and resolved for `CLOUDFLARE_ENV` with Astro's server as its default main. */
+function readWorker(source) {
+    const raw = experimental_readRawConfig({ config: source }, { useRedirectIfAvailable: false }).rawConfig;
+    const env = process.env.CLOUDFLARE_ENV;
+    const selected = unstable_readConfig({ config: source, env }, { hideWarnings: true });
+    selected.main = (env ? raw.env?.[env]?.main : undefined) ?? raw.main ?? ASTRO_SERVER;
+    return { raw, selected };
+}
 function configuration(root, configured, required = true) {
     if (configured)
         return path.resolve(root, configured);

package/dist/client.mjs

@@ -88,13 +88,11 @@ export default Object.assign(client, { capabilities: Object.freeze(Object.fromEn
             if (!files.includes(file))
                 return;
             contracts.refresh({ file, timestamp });
-            for (const id of clients) {
-                const client = this.environment.moduleGraph.getModuleById(id);
-                if (!client)
-                    continue;
+            const loaded = [...clients].map(id => this.environment.moduleGraph.getModuleById(id)).filter(client => client !== undefined);
+            for (const client of loaded)
                 this.environment.moduleGraph.invalidateModule(client);
+            if (loaded.length)
                 this.environment.hot.send({ type: "full-reload" });
-            }
         },
     };
 }

package/dist/dev-socket.mjs

@@ -17,8 +17,9 @@ const CONNECT_TIMEOUT = 10_000;
 export async function openDevSocket(workerName, token) {
     const worker = new DevWorker(workerName);
     const device = new Device();
+    const authorized = (request) => token !== undefined && request.headers[SESSION_HEADER] === token;
     const server = http.createServer((request, response) => {
-        if (!token || request.headers[SESSION_HEADER] !== token) {
+        if (!authorized(request)) {
             response.writeHead(401).end();
             return;
         }
@@ -34,7 +35,7 @@ export async function openDevSocket(workerName, token) {
     });
     const sockets = new WebSocketServer({ noServer: true });
     server.on("upgrade", (request, socket, head) => {
-        if (!token || request.headers[SESSION_HEADER] !== token) {
+        if (!authorized(request)) {
             socket.end("HTTP/1.1 401 Unauthorized\r\nConnection: close\r\n\r\n");
             return;
         }
@@ -127,7 +128,7 @@ function serve(websocket, worker, device) {
         }
         const { header, payload } = message;
         if (header.type === "result" && header.id !== undefined) {
-            device.receive(header.id, { payload, failed: header.failed === true, done: header.done === true });
+            device.receive(header.id, pluginResult(message));
             return;
         }
         if (header.type === "pull" && header.id !== undefined) {
@@ -177,14 +178,14 @@ async function forward(device, request, response) {
             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);
+        return next.done ? failure("DataCloneError", "The call's body ended early") : pluginResult(next.value);
     });
     response.once("close", () => {
         if (!response.writableEnded)
             cancel();
     });
 }
-function chunkResult({ header, payload }) {
+function pluginResult({ header, payload }) {
     return { payload, failed: header.failed === true, done: header.done === true };
 }
 /** The most a subscription's response holds while the Worker is not reading it. */

package/dist/native-worker.d.mts

@@ -1,3 +1,4 @@
+import type { PluginConfig } from "@cloudflare/vite-plugin";
 import { type Plugin } from "vite";
 import type { Config } from "./index.mjs";
 import { type WorkerGraph } from "./worker-graph.mjs";
@@ -5,8 +6,11 @@ export type TokamakOptions = Config & {
     /** Native worker entrypoint, relative to the Vite root; defaults to src/tokamak.ts or .js. */
     module?: string;
 };
+type AuxiliaryWorker = NonNullable<PluginConfig["auxiliaryWorkers"]>[number];
 /** 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;
+    auxiliaryWorker: AuxiliaryWorker;
 };
+export {};

package/dist/native-worker.mjs

@@ -47,7 +47,7 @@ export function createNativeWorker(options, output, prepare) {
             async handler(server) {
                 const devSocket = await serveNativeWorker(server, graph.names(), output, token);
                 if (devSocket && token)
-                    graph.relay(devSocket.port, token, platform);
+                    graph.relay({ port: 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);
@@ -57,7 +57,12 @@ export function createNativeWorker(options, output, prepare) {
             },
         },
     };
-    return { plugin, graph: () => graph };
+    return {
+        plugin,
+        graph: () => graph,
+        // The graph exists once Vite's config is known, after Cloudflare's plugin is created.
+        auxiliaryWorker: { viteEnvironment: { name: "tokamak" }, config: (worker, context) => graph.native(worker, context) },
+    };
 }
 async function serveNativeWorker(server, names, output, token) {
     const httpServer = server.httpServer;

package/dist/native.d.mts

@@ -1,11 +1,17 @@
 import type { NativePlatform } from "@tokamakdev/plugin/capabilities";
+/** The device relay a development Worker reaches native code through. */
+export interface DeviceRelay {
+    port: number;
+    token: string;
+    platform?: NativePlatform;
+}
 /**
- * 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.
+ * The development invocation `ctx`'s native connection, which reaches the byte endpoints of the
+ * `relay`'s device. Its subscriptions are `ctx`'s `waitUntil` work.
  */
-export declare function connectDevice(port: number, token: string, ctx: {
+export declare function connectDevice({ port, token, platform }: DeviceRelay, ctx: {
     waitUntil(promise: Promise<unknown>): void;
-}, platform?: NativePlatform): {
+}): {
     platform: NativePlatform | undefined;
     call(plugin: string, method: string, payload: Uint8Array, { body, signal }?: {
         body?: ReadableStream<Uint8Array>;

package/dist/native.mjs

@@ -2,10 +2,10 @@ import { decodeMessage, encodeMessage, messages, nativeError } from "@tokamakdev
 const encoder = new TextEncoder();
 const decoder = new TextDecoder();
 /**
- * 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.
+ * The development invocation `ctx`'s native connection, which reaches the byte endpoints of the
+ * `relay`'s device. Its subscriptions are `ctx`'s `waitUntil` work.
  */
-export function connectDevice(port, token, ctx, platform) {
+export function connectDevice({ port, token, platform }, ctx) {
     const post = async (path, request, signal) => {
         const response = await fetch(`http://127.0.0.1:${String(port)}${path}`, {
             method: "POST",

package/dist/plugin-manifest.d.mts

@@ -1,9 +1,9 @@
+import type { NativePlatform } from "@tokamakdev/plugin/capabilities";
+export type { NativePlatform };
 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. */

package/dist/rpc-contract.d.mts

@@ -7,3 +7,5 @@ export declare class WorkerOnlyMethod extends Error {
  * `workerOnly` type throws `WorkerOnlyMethod`.
  */
 export declare function checkRpcMethod(checker: ts.TypeChecker, method: ts.Type, name: string, workerOnly?: ts.Symbol): void;
+/** The symbol that `symbol` names: itself, or the declaration an import or re-export refers to. */
+export declare function aliased(checker: ts.TypeChecker, symbol: ts.Symbol): ts.Symbol;

package/dist/rpc-contract.mjs

@@ -56,7 +56,11 @@ function builtin(checker, type) {
 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));
+        aliased(checker, member) === symbol));
+}
+/** The symbol that `symbol` names: itself, or the declaration an import or re-export refers to. */
+export function aliased(checker, symbol) {
+    return symbol.flags & ts.SymbolFlags.Alias ? checker.getAliasedSymbol(symbol) : symbol;
 }
 function argumentsOf(checker, type) {
     return type.flags & ts.TypeFlags.Object && type.objectFlags & ts.ObjectFlags.Reference

package/dist/vite.mjs

@@ -19,17 +19,14 @@ export function tokamak(options = {}, cloudflareOptions = {}) {
                     ...worker, ...custom,
                     services: [...custom?.services ?? [], ...worker.services ?? []],
                 };
-                client.configure(configured);
-                if (!native)
+                if (!native) {
+                    client.configure(configured);
                     return custom;
-                const graph = native.graph();
-                graph.configure(configured);
+                }
+                const generated = native.graph().configure(configured);
                 // Cloudflare merges returned service entries with those already in the config.
-                return { ...custom, main: configured.main, services: [...custom?.services ?? [], ...graph.services(graph.names().main)] };
+                return { ...custom, main: configured.main, services: [...custom?.services ?? [], ...generated] };
             },
-            auxiliaryWorkers: native ? [{
-                    viteEnvironment: { name: "tokamak" },
-                    config: (worker, context) => native.graph().native(worker, context),
-                }] : cloudflareOptions.auxiliaryWorkers,
+            auxiliaryWorkers: native ? [native.auxiliaryWorker] : cloudflareOptions.auxiliaryWorkers,
         })];
 }

package/dist/worker-contract.d.mts

@@ -11,6 +11,8 @@ export interface PluginContract extends WorkerContract {
     /** Every operation of the native SDK, including those only the Tokamak worker can call. */
     operations: string[];
 }
+/** The contract of a Tokamak worker without a module. */
+export declare function emptyContract(): WorkerContract;
 export declare function findModule(root: string, name: string | undefined): string | undefined;
 /** Resolve the application's types before generating its service adapters. */
 export declare function readWorkerContract(entry: string, root: string): WorkerContract;

package/dist/worker-contract.mjs

@@ -2,8 +2,14 @@ import path from "node:path";
 import fs from "node:fs";
 import { fileURLToPath } from "node:url";
 import ts from "typescript";
-import { checkRpcMethod, WorkerOnlyMethod } from "./rpc-contract.mjs";
+import { aliased, checkRpcMethod, WorkerOnlyMethod } from "./rpc-contract.mjs";
 import { serviceTypes } from "./service-types.mjs";
+/** Worker handler names, which are not RPC methods. */
+const HANDLERS = ["fetch", "event", "queue", "scheduled", "email", "tail", "trace", "tailStream", "test"];
+/** The contract of a Tokamak worker without a module. */
+export function emptyContract() {
+    return { methods: [], files: [], declarations: serviceTypes("{}", []) };
+}
 export function findModule(root, name) {
     const candidates = (name ? [name] : ["src/tokamak.ts", "src/tokamak.js"])
         .map(candidate => path.resolve(root, candidate).split(path.sep).join("/"));
@@ -27,8 +33,7 @@ export function readWorkerContracts(entry, main, root, validate, plugins = []) {
     const project = entries.length ? workerProgram(entries, root) : undefined;
     const native = entry && project ? workerModule(entry, project) : undefined;
     return {
-        native: native ? classContract(native, "default", true, validate)
-            : { methods: [], files: [], declarations: serviceTypes("{}", []) },
+        native: native ? classContract(native, "default", true, validate) : emptyContract(),
         named: native ? namedContracts(native, validate) : {},
         main: main && project ? serviceContracts(workerModule(main, project), validate) : {},
         plugins: project ? plugins.map(plugin => pluginContract(workerModule(plugin.api.module, project), plugin, validate)) : [],
@@ -95,8 +100,7 @@ function workerModule(entry, project) {
         throw new Error(`Cannot read Tokamak entrypoint ${entry}.`);
     const module = checker.getSymbolAtLocation(source);
     const exports = new Map((module ? checker.getExportsOfModule(module) : []).map(exported => {
-        const symbol = exported.flags & ts.SymbolFlags.Alias ? checker.getAliasedSymbol(exported) : exported;
-        return [exported.name, checker.getTypeOfSymbolAtLocation(symbol, source)];
+        return [exported.name, checker.getTypeOfSymbolAtLocation(aliased(checker, exported), source)];
     }));
     return { ...project, entry, source, exports };
 }
@@ -126,7 +130,7 @@ function pluginContract(module, definition, validate) {
         if (property.name === "capabilities")
             continue;
         assertMethodName(property.name);
-        if (["fetch", "event", "queue", "scheduled", "email", "tail", "trace", "tailStream", "test"].includes(property.name)) {
+        if (HANDLERS.includes(property.name)) {
             throw new Error(`Plugin method ${property.name} is reserved for a Worker handler.`);
         }
         const method = checker.getTypeOfSymbolAtLocation(property, source);
@@ -146,7 +150,7 @@ function pluginContract(module, definition, validate) {
         }
         methods.push(methodDeclaration(checker, property, method));
     }
-    methods.sort((left, right) => left.name < right.name ? -1 : left.name > right.name ? 1 : 0);
+    methods.sort(byName);
     const unknown = Object.keys(definition.operations).find(name => !operations.includes(name));
     if (unknown)
         throw new Error(`${definition.manifest}: operations.${unknown} names no method of ${definition.api.export}.`);
@@ -244,13 +248,16 @@ function classContract(module, name, native, validate) {
             checkRpcMethod(checker, type, property.name);
         methods.push(methodDeclaration(checker, property, type));
     }
-    methods.sort((left, right) => left.name < right.name ? -1 : left.name > right.name ? 1 : 0);
+    methods.sort(byName);
     return {
         methods: methods.map((method) => method.name),
         declarations: serviceTypes(`InstanceType<typeof import(${JSON.stringify(entry.split(path.sep).join("/"))}, { with: { "resolution-mode": "import" } })[${JSON.stringify(name)}]>`, methods, native ? "Tokamak" : "Main"),
         files: module.files,
     };
 }
+function byName(left, right) {
+    return left.name < right.name ? -1 : left.name > right.name ? 1 : 0;
+}
 function methodDeclaration(checker, property, type) {
     return {
         name: property.name,
@@ -264,7 +271,7 @@ function methodDeclaration(checker, property, type) {
 function applicationPrototypes(program, checker, instance, entry, allowNative = false) {
     const module = checker.getAmbientModules().find((symbol) => symbol.name === '"cloudflare:workers"');
     const exported = module && checker.getExportsOfModule(module).find((symbol) => symbol.name === "WorkerEntrypoint");
-    const base = exported && (exported.flags & ts.SymbolFlags.Alias ? checker.getAliasedSymbol(exported) : exported);
+    const base = exported && aliased(checker, exported);
     const native = allowNative ? nativeSdkExport(program, checker, entry, "TokamakEntrypoint") : undefined;
     const prototypes = new Set();
     let current = instance;
@@ -288,7 +295,7 @@ function nativeSdkExport(program, checker, entry, name, specifier = "@tokamakdev
     const source = resolved && program.getSourceFile(resolved.resolvedFileName);
     const module = source && checker.getSymbolAtLocation(source);
     const exported = module && checker.getExportsOfModule(module).find(symbol => symbol.name === name);
-    return exported && (exported.flags & ts.SymbolFlags.Alias ? checker.getAliasedSymbol(exported) : exported);
+    return exported && aliased(checker, exported);
 }
 function exposedMethod(property) {
     const declarations = property.declarations?.filter(ts.isMethodDeclaration) ?? [];
@@ -299,7 +306,7 @@ function exposedMethod(property) {
         throw new Error(`Method ${property.name} is on the public JavaScript prototype; use a #private method for a local helper.`);
     }
     assertMethodName(property.name);
-    return !["fetch", "event", "queue", "scheduled", "email", "tail", "trace", "tailStream", "test"].includes(property.name);
+    return !HANDLERS.includes(property.name);
 }
 function assertMethodName(name) {
     if (["then", "connect", "dup", "constructor", "alarm", "webSocketMessage", "webSocketClose", "webSocketError", "__tokamakRpc"].includes(name)) {

package/dist/worker-graph.d.mts

@@ -1,28 +1,29 @@
 import type { PluginConfig } from "@cloudflare/vite-plugin";
 import { type EnvironmentOptions, type Plugin } from "vite";
-import type { Availability, NativePlatform } from "@tokamakdev/plugin/capabilities";
-import type { WorkerContract } from "./worker-contract.mjs";
+import type { Availability } from "@tokamakdev/plugin/capabilities";
+import type { DeviceRelay } from "./native.mjs";
 import { WorkerTypes, type WorkerConfiguration } from "./worker-types.mjs";
 type ServiceConfiguration = Pick<WorkerConfiguration, "name" | "topLevelName" | "services" | "main" | "configPath" | "vars" | "kv_namespaces" | "d1_databases" | "r2_buckets">;
+type ServiceBindings = NonNullable<ServiceConfiguration["services"]>;
 type Auxiliary = NonNullable<PluginConfig["auxiliaryWorkers"]>[number];
 type AuxiliaryCustomizer = Extract<Extract<Auxiliary, {
     config: unknown;
 }>["config"], (...args: never[]) => unknown>;
 export interface WorkerGraph {
-    generated: string;
-    /** Connects development invocations to a device on `platform` through the relay on `port`. */
-    relay(port: number, token: string, platform: NativePlatform | undefined): void;
+    /** Connects development invocations to a device through `relay`. */
+    relay(relay: DeviceRelay): void;
     /** Each plugin operation's native platforms, by plugin ID. */
     availability(): Availability;
-    configure(config: ServiceConfiguration): void;
-    services(name: string): NonNullable<ServiceConfiguration["services"]>;
+    /** Configures the main Worker `config`, returning the generated service bindings it adds. */
+    configure(config: ServiceConfiguration): ServiceBindings;
+    /** The generated service bindings of the main Worker configuration `config`, once it binds none of their names. */
+    serviceBindings(config: ServiceConfiguration): ServiceBindings;
     native: AuxiliaryCustomizer;
     names(): {
         main: string;
         native: string;
         app: string;
     };
-    contract(): WorkerContract;
     types: WorkerTypes;
     cloudflare: PluginConfig;
     plugin: Plugin & {
@@ -40,4 +41,6 @@ export interface WorkerGraph {
 /** Configure the two bundles through Cloudflare's public auxiliary-worker API. */
 export declare function createWorkerGraph(root: string, entry: string | undefined, output: string): WorkerGraph;
 export declare function workerName(main: string): string;
+/** Writes `source` to `file` unless it already holds it, so watchers see only changes. */
+export declare function writeChanged(file: string, source: string): void;
 export {};

package/dist/worker-graph.mjs

@@ -6,6 +6,8 @@ import { normalizePath } from "vite";
 import { WorkerTypes } from "./worker-types.mjs";
 const NATIVE_CONNECTION = "virtual:tokamak/native-connection";
 const NATIVE_CALLS = normalizePath(fileURLToPath(new URL("./native.mjs", import.meta.url)));
+/** The two Workers' roles: the app's main Worker and the Tokamak worker. */
+const ROLES = ["main", "native"];
 /** Configure the two bundles through Cloudflare's public auxiliary-worker API. */
 export function createWorkerGraph(root, entry, output) {
     const generated = path.join(output, "worker.mjs");
@@ -56,7 +58,8 @@ export function createWorkerGraph(root, entry, output) {
 export const TokamakEvents = eventEntrypoint(Worker, nativeContext);\n`);
         writeChanged(path.join(output, "methods.json"), `${JSON.stringify(contracts.native.methods)}\n`);
     }
-    const configure = (config) => {
+    /** The name of the main Worker configuration `config`, which binds none of the generated names. */
+    const checkedName = (config) => {
         if (!config.name)
             throw new Error("Tokamak requires a name in the main Worker's configuration.");
         const reserved = new Set(["MAIN", "TOKAMAK_RUNTIME", ...services(config.name).map(service => service.binding)]);
@@ -64,15 +67,20 @@ export const TokamakEvents = eventEntrypoint(Worker, nativeContext);\n`);
         if (collision) {
             throw new Error(`${collision} is reserved for a generated native worker binding.`);
         }
-        mainName = config.name;
+        return config.name;
+    };
+    const configure = (config) => {
+        mainName = checkedName(config);
         nativeName = workerName(mainName);
         appName = config.topLevelName ?? mainName;
         contracts.configure(config);
         if (dev)
             config.main = serviceModule("main");
-        config.services = [...config.services ?? [], ...services(mainName)];
+        const generated = services(mainName);
+        config.services = [...config.services ?? [], ...generated];
         mainServices = config.services;
         configuredEntrypoints = entrypoints();
+        return generated;
     };
     const native = (_config, { entryWorkerConfig }) => {
         if (!mainName)
@@ -95,17 +103,15 @@ export const TokamakEvents = eventEntrypoint(Worker, nativeContext);\n`);
     };
     refresh();
     return {
-        generated: normalizePath(generated),
-        relay(port, token, platform) { relay = { port, token, platform }; },
+        relay(configured) { relay = configured; },
         availability: () => availability(contracts.plugins),
         configure,
-        services,
+        serviceBindings: config => services(checkedName(config)),
         native,
         names: () => ({ main: mainName, native: nativeName, app: appName }),
-        contract: () => contracts.native,
         types: contracts,
         cloudflare: {
-            config: configure,
+            config: config => { configure(config); },
             auxiliaryWorkers: [{
                     viteEnvironment: { name: "tokamak" },
                     config: native,
@@ -171,20 +177,16 @@ export const TokamakEvents = eventEntrypoint(Worker, nativeContext);\n`);
                 return [];
             },
             resolveId(id) {
-                if (id === NATIVE_CONNECTION)
-                    return `\0${NATIVE_CONNECTION}`;
+                if ([NATIVE_CONNECTION, serviceModule("main"), serviceModule("native")].includes(id))
+                    return `\0${id}`;
                 if (id.startsWith("\0tokamak:") || id.startsWith("\0virtual:tokamak/"))
                     return id;
-                const role = id === serviceModule("native") ? "native" : id === serviceModule("main") ? "main" : undefined;
-                if (!role)
-                    return;
-                return `\0${serviceModule(role)}`;
             },
             async load(id) {
                 if (id === `\0${NATIVE_CONNECTION}`)
                     return nativeConnectionModule(dev ? relay : undefined);
-                const role = id.endsWith(":main") || id.endsWith("/main") ? "main" : "native";
-                if (id !== bindingsModule(role) && id !== `\0${serviceModule(role)}`)
+                const role = ROLES.find(role => id === bindingsModule(role) || id === `\0${serviceModule(role)}`);
+                if (!role)
                     return;
                 await contracts.resolve(source => this.resolve(source, undefined, { skipSelf: true }));
                 refresh();
@@ -253,7 +255,7 @@ function nativeConnectionModule(relay) {
     if (!relay)
         return "export const connect = () => undefined;";
     return `import { connectDevice } from ${JSON.stringify(NATIVE_CALLS)};
-export const connect = ctx => connectDevice(${String(relay.port)}, ${JSON.stringify(relay.token)}, ctx, ${JSON.stringify(relay.platform ?? null)} ?? undefined);`;
+export const connect = ctx => connectDevice(${JSON.stringify(relay)}, ctx);`;
 }
 /** Each plugin operation's native platforms: those its manifest names, or every one the plugin builds for. */
 function availability(plugins) {
@@ -325,7 +327,8 @@ export default class extends WorkerEntrypoint {
 ${named.join("")}
 `;
 }
-function writeChanged(file, source) {
+/** Writes `source` to `file` unless it already holds it, so watchers see only changes. */
+export function writeChanged(file, source) {
     if (fs.existsSync(file) && fs.readFileSync(file, "utf8") === source)
         return;
     fs.mkdirSync(path.dirname(file), { recursive: true });

package/dist/worker-types.mjs

@@ -1,13 +1,13 @@
 import fs from "node:fs";
 import path from "node:path";
-import { readWorkerContracts } from "./worker-contract.mjs";
+import { emptyContract, readWorkerContracts } from "./worker-contract.mjs";
 import { serviceTypes, writeEnvironmentTypes } from "./service-types.mjs";
 import { discoverPlugins } from "./plugin-manifest.mjs";
 /** Shared contracts for the two entrypoints and their generated callers. */
 export class WorkerTypes {
     root;
     entry;
-    native = { methods: [], files: [], declarations: serviceTypes("{}", []) };
+    native = emptyContract();
     /** The Tokamak worker's named entrypoints. */
     named = {};
     main = {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tokamakdev/tok",
-  "version": "0.1.1-beta.114",
+  "version": "0.1.1-beta.116",
   "description": "The tokamak CLI, Vite plugin and app API: build native apps from a Cloudflare Workers codebase",
   "repository": {
     "type": "git",
@@ -43,7 +43,7 @@
     "node": ">=18"
   },
   "dependencies": {
-    "@tokamakdev/plugin": "0.1.0-beta.114",
+    "@tokamakdev/plugin": "0.1.0-beta.116",
     "typescript": "5.9.3",
     "ws": "^8.22.0"
   },
@@ -75,17 +75,17 @@
     "wrangler": "4.147.0"
   },
   "optionalDependencies": {
-    "@tokamakdev/platform-android-arm64": "0.1.1-beta.114",
-    "@tokamakdev/platform-ios-arm64": "0.1.1-beta.114",
-    "@tokamakdev/platform-ios-simulator-arm64": "0.1.1-beta.114",
-    "@tokamakdev/platform-ios-simulator-x64": "0.1.1-beta.114",
-    "@tokamakdev/platform-macos-arm64": "0.1.1-beta.114",
-    "@tokamakdev/platform-macos-x64": "0.1.1-beta.114",
-    "@tokamakdev/platform-windows-x64": "0.1.1-beta.114",
-    "@tokamakdev/tok-darwin-arm64": "0.1.1-beta.114",
-    "@tokamakdev/tok-darwin-x64": "0.1.1-beta.114",
-    "@tokamakdev/tok-linux-x64": "0.1.1-beta.114",
-    "@tokamakdev/tok-win32-x64": "0.1.1-beta.114"
+    "@tokamakdev/platform-android-arm64": "0.1.1-beta.116",
+    "@tokamakdev/platform-ios-arm64": "0.1.1-beta.116",
+    "@tokamakdev/platform-ios-simulator-arm64": "0.1.1-beta.116",
+    "@tokamakdev/platform-ios-simulator-x64": "0.1.1-beta.116",
+    "@tokamakdev/platform-macos-arm64": "0.1.1-beta.116",
+    "@tokamakdev/platform-macos-x64": "0.1.1-beta.116",
+    "@tokamakdev/platform-windows-x64": "0.1.1-beta.116",
+    "@tokamakdev/tok-darwin-arm64": "0.1.1-beta.116",
+    "@tokamakdev/tok-darwin-x64": "0.1.1-beta.116",
+    "@tokamakdev/tok-linux-x64": "0.1.1-beta.116",
+    "@tokamakdev/tok-win32-x64": "0.1.1-beta.116"
   },
   "publishConfig": {
     "access": "public"