gesso-vite-plugin 0.1.0

package/CHANGELOG.md

@@ -0,0 +1,17 @@
+# gesso-vite-plugin
+
+## 0.1.0
+
+First public release.
+
+`gesso()` finds an application's worker entries, writes the constructions and
+the hot-replacement wiring, and mounts the development error overlay.
+
+It is optional by design: nothing in `gesso-core` or `gesso-framework`
+mentions Vite, and the literal `new Worker(new URL(...))` construction stays
+the documented fallback. The plugin's factories go in first, so your own
+options spread over them.
+
+It also names the one failure that looks like a bug in the framework: a save
+that reloads the page instead of replacing a module, because a module is
+reached from the main thread as well as from the render worker.

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Kevin Baker
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,40 @@
+# gesso-vite-plugin
+
+Finds a Gesso application's worker entries, writes the constructions and the hot-replacement wiring, and says when a save will reload the page.
+
+```bash
+npm install --save-dev gesso-vite-plugin
+```
+
+```ts
+// vite.config.ts
+import { gesso } from 'gesso-vite-plugin';
+
+export default defineConfig({
+  plugins: [gesso()]
+});
+```
+
+Then the worker boilerplate goes away:
+
+```ts
+// main.ts
+createApp({ history: { mode: 'path' } }).mount('#app');
+
+// RenderWorker.ts
+renderRoot(AppRoot).useService(Feed);
+```
+
+## It is optional, deliberately
+
+Nothing in `gesso-core` or `gesso-framework` mentions Vite, and no bundler is imported into the framework. Everything this plugin writes, you can write by hand: the literal `new Worker(new URL(...))` construction stays the documented fallback, and the plugin's factories go in first so your own options spread over them.
+
+## The diagnostic that is worth the install
+
+One failure looks exactly like a bug in the framework: a save that reloads the whole page instead of replacing a module. The cause is a module reached from the main thread as well as from the render worker, which Vite cannot hot-replace because it propagates the invalidation to a main-thread importer that does not accept it. The plugin says so, and names the module, instead of leaving you to guess.
+
+## Documentation
+
+[The Vite plugin](https://github.com/kevinpbaker/gesso/blob/main/apps/docs/tooling/vite-plugin.md)
+
+MIT (c) Kevin Baker

package/dist/index.d.ts

@@ -0,0 +1,246 @@
+import { Plugin } from "vite";
+//#region src/render.d.ts
+/** What the plugin found in a render worker entry, and could wire. */
+interface RenderWiring {
+  /** The rewritten module, or null when there was nothing to wire. */
+  readonly code: string | null;
+  /**
+   * Why nothing was wired, when nothing was. A sentence for the
+   * developer, not an error: an entry the plugin cannot wire still
+   * runs, it just full-reloads on a save.
+   */
+  readonly skipped: string | null;
+}
+/**
+ * Writes the two lines an author would otherwise write by hand.
+ *
+ * The example below is the specification:
+ *
+ *   const app = renderRoot(LiveApp).useService(LiveFeed);
+ *   import.meta.hot?.accept('./LiveExampleApp', module => {
+ *     app.reload(module.LiveApp, [module.LiveFeed]);
+ *   });
+ *
+ * Three things have to be found for that to be written mechanically:
+ * the handle the chain returns, the module the root component came
+ * from, and the modules the services came from. The handle is taken by
+ * routing the call through a wrapper of the plugin's own, which keeps
+ * the chain that follows it intact whether or not the author assigned
+ * it. The modules come from the entry's own import statements, which is
+ * exactly the question `importSources` answers.
+ *
+ * A service declared in a module of its own is accepted alongside the
+ * root, because a registry keyed by class object cannot tell a
+ * replacement from a stranger and `reload` is where that is repaired.
+ * What is deliberately *not* wired is `useRoutes`: routes are read once
+ * when the runtime is built, so a change to the route table is a full
+ * reload and saying so is better than replacing a tree that still
+ * resolves the old routes.
+ */
+declare function transformRenderWorker(code: string): RenderWiring;
+//#endregion
+//#region src/source.d.ts
+/**
+ * Just enough of a JavaScript scanner to find a call and to say which
+ * module a name was imported from.
+ *
+ * Written here rather than taken from npm for the reason the rest of
+ * this repository's tooling gives (`packages/devtools/src/sourceMap.ts`,
+ * `scripts/gen-layout-fixtures.ts`): the whole of what the plugin needs
+ * is "where does `createApp(` open and close" and "where did `SegueApp`
+ * come from", and a parser is a dependency, a TypeScript dialect
+ * question and a version to keep in step, in exchange for two
+ * questions a scanner answers.
+ *
+ * The trick that makes it safe is `blankLiterals`: every string,
+ * template and comment is replaced by spaces of the same length, so the
+ * positions found in the blanked copy are positions in the original,
+ * and no brace inside a string can be mistaken for code. Everything
+ * below searches the blank copy and slices the original.
+ *
+ * What it does not do is understand scope. A `createApp` that a module
+ * defined for itself would be found the same way an imported one is,
+ * which is why the plugin checks the imports first and only then looks
+ * for the call.
+ */
+/** Where a call expression starts, where its arguments are, where it ends. */
+interface CallSite {
+  /** Index of the first character of the callee name. */
+  readonly start: number;
+  /** Index just after the opening parenthesis. */
+  readonly argsStart: number;
+  /** Index of the closing parenthesis. */
+  readonly argsEnd: number;
+  /** Index just after the closing parenthesis. */
+  readonly end: number;
+}
+/**
+ * A copy of `code` in which every string, template literal, regular
+ * expression body and comment is spaces, and everything else is
+ * untouched.
+ *
+ * Same length as the input, and newlines are kept, so an index into
+ * the result is an index into the original and a line number is still
+ * a line number. String and template delimiters are kept as well, so a
+ * specifier can be found by its quotes here and read from there.
+ */
+declare function blankLiterals(code: string): string;
+/**
+ * Every call of `name` in the module, in source order.
+ *
+ * A bare name has to stand alone: `renderRoot(` matches, `myRenderRoot(`
+ * and `thing.renderRoot(` do not, because a method of that name on some
+ * other object is not the framework's function. A name written with a
+ * leading dot is the opposite and matches only the method call:
+ * `.useService(` is how a builder chain reads and the only way it is
+ * ever written.
+ */
+declare function findCalls(code: string, name: string, blank?: string): CallSite[];
+/** The first call of `name`, or null. */
+declare function findCall(code: string, name: string, blank?: string): CallSite | null;
+/**
+ * The identifier a call's first argument is, or null when the argument
+ * is anything more complicated than a name.
+ *
+ * `renderRoot(SegueApp)` is the shape every entry in this repository
+ * writes and the only one that can be hot-replaced, because a
+ * replacement has to be looked up by name in the module that changed.
+ * `renderRoot(<App x={1} />)` is legal and gets no HMR wiring, which
+ * the plugin says rather than guessing.
+ */
+declare function firstArgumentName(code: string, call: CallSite, blank?: string): string | null;
+/**
+ * Which module each imported name came from: local name to specifier,
+ * exactly as the import wrote it.
+ *
+ * Default and namespace imports are recorded under their local names
+ * too, so `import App from './App'` and `import * as app from './App'`
+ * both answer. What the map does not carry is whether the binding is a
+ * type, because `import type` is stripped before this runs in every
+ * configuration that matters and a type never reaches a call.
+ */
+declare function importSources(code: string, blank?: string): Map<string, string>;
+//#endregion
+//#region src/shell.d.ts
+/** Where the plugin found the two worker entries, as the shell imports them. */
+interface WorkerEntries {
+  /** A specifier relative to the shell module, e.g. `./RenderWorker.ts`. */
+  readonly renderWorker: string;
+  /** The same for the application worker, or null when there is none. */
+  readonly appLogicWorker: string | null;
+}
+/** A `createApp` call the plugin could write for, and what it still needs. */
+interface ShellCall {
+  readonly call: CallSite;
+  /**
+   * False when the author wrote `renderWorker` themselves, which is the
+   * documented fallback and the case where the plugin has no worker to
+   * find. It still wires the overlay in.
+   */
+  readonly needsWorkers: boolean;
+}
+interface ShellTransformOptions {
+  /** The entries to construct, or null when the author named them. */
+  readonly entries: WorkerEntries | null;
+  /**
+   * Whether to wire the error overlay in as well. True while the dev
+   * server is running and never in a build, so a production bundle
+   * carries no reference to `gesso-devtools`.
+   */
+  readonly overlay: boolean;
+}
+/**
+ * The `createApp` call in a module, when the module has one that came
+ * from the framework.
+ *
+ * Separate from the transform because finding the worker entries is an
+ * asynchronous resolution against the bundler and worth doing only for
+ * a module that turns out to be a shell, which is one module in an
+ * application.
+ */
+declare function findShellCall(code: string, blank?: string): ShellCall | null;
+/**
+ * Rewrites the shell module so that it names no worker.
+ *
+ * The one edit inside the author's own code is the call itself:
+ * `createApp(...)` becomes `createApp(__gessoOptions(...))`, on the
+ * same line, so every line number in the module is the one it was.
+ * Everything else is appended below, as function declarations, which
+ * hoist and are therefore usable from the line above them.
+ *
+ * The merge order is what keeps the promise that the
+ * literal construction stays the documented fallback: the plugin's
+ * factories go in first and the author's options spread over them, so
+ * a `renderWorker` written by hand still wins.
+ *
+ * Returns null when there is nothing to do, which is the common case:
+ * most modules do not call `createApp`.
+ */
+declare function transformShell(code: string, options: ShellTransformOptions): string | null;
+//#endregion
+//#region src/index.d.ts
+/**
+ * `gesso-vite-plugin` — the plumbing between saving a file and seeing
+ * the result.
+ *
+ * A Gesso application is three files either side of a thread barrier
+ *, and until now the barrier cost the author four
+ * incantations: `new Worker(new URL('./RenderWorker.ts',
+ * import.meta.url), { type: 'module' })` twice, because only a literal
+ * gets a chunk; `import.meta.hot.accept` with the root module named by
+ * hand; and `mountErrorOverlay` wired to `onError`, without which a
+ * worker exception reaches a console nobody has selected. None of them
+ * is a decision. All of them are written the same way in every
+ * application, and getting one wrong fails silently.
+ *
+ * The three-file shape stays. What this removes is the incantations,
+ * and what it adds is the one diagnostic that cannot be read off the
+ * screen: a save that reloads the page rather than replacing a module,
+ * which traces to the root module having a
+ * main-thread importer and which otherwise looks like HMR simply not
+ * working.
+ *
+ *   // vite.config.ts
+ *   import { gesso } from 'gesso-vite-plugin';
+ *   export default defineConfig({ plugins: [gesso()] });
+ *
+ *   // main.ts
+ *   createApp({ history: { mode: 'path' } }).mount('#app');
+ *
+ * The literal construction stays supported and stays documented: the
+ * plugin merges its factories *under* the options the author wrote, so
+ * a hand-written `renderWorker` wins and an application that would
+ * rather say it out loud can.
+ */
+interface GessoPluginOptions {
+  /**
+   * The render worker entry, as a specifier the shell module could
+   * import. By default the plugin tries the names below, in order, and
+   * uses the first that resolves beside the shell.
+   */
+  readonly renderWorker?: string;
+  /**
+   * The application worker entry, or false for an application that has
+   * none. By default the plugin looks for it and leaves it out when
+   * there is nothing to find, which is the single-worker shape the
+   * scaffold produces.
+   */
+  readonly appLogicWorker?: string | false;
+  /**
+   * Wire `gesso-devtools`'s error overlay into `onError` (default
+   * true). Only ever in a dev server: a build carries no reference to
+   * the package.
+   */
+  readonly overlay?: boolean;
+  /** Emit the `import.meta.hot.accept` wiring (default true). */
+  readonly hmr?: boolean;
+  /**
+   * Report a save that will reload the page instead of replacing a
+   * module (default true).
+   */
+  readonly diagnostics?: boolean;
+}
+declare function gesso(options?: GessoPluginOptions): Plugin;
+//#endregion
+export { type CallSite, GessoPluginOptions, type RenderWiring, type ShellCall, type ShellTransformOptions, type WorkerEntries, blankLiterals, gesso as default, gesso, findCall, findCalls, findShellCall, firstArgumentName, importSources, transformRenderWorker, transformShell };
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,584 @@
+//#region src/source.ts
+const IDENTIFIER = /[A-Za-z0-9_$]/;
+/**
+* A copy of `code` in which every string, template literal, regular
+* expression body and comment is spaces, and everything else is
+* untouched.
+*
+* Same length as the input, and newlines are kept, so an index into
+* the result is an index into the original and a line number is still
+* a line number. String and template delimiters are kept as well, so a
+* specifier can be found by its quotes here and read from there.
+*/
+function blankLiterals(code) {
+	const out = code.split("");
+	let index = 0;
+	let regexAllowed = true;
+	const blank = (from, to) => {
+		for (let i = from; i < to; i++) if (out[i] !== "\n") out[i] = " ";
+	};
+	while (index < code.length) {
+		const char = code[index];
+		if (char === "/" && code[index + 1] === "/") {
+			const end = code.indexOf("\n", index);
+			blank(index, end === -1 ? code.length : end);
+			index = end === -1 ? code.length : end;
+			continue;
+		}
+		if (char === "/" && code[index + 1] === "*") {
+			const end = code.indexOf("*/", index + 2);
+			const stop = end === -1 ? code.length : end + 2;
+			blank(index, stop);
+			index = stop;
+			continue;
+		}
+		if (char === "\"" || char === "'") {
+			const end = closingQuote(code, index, char);
+			blank(index + 1, end);
+			index = end + 1;
+			regexAllowed = false;
+			continue;
+		}
+		if (char === "`") {
+			const end = closingQuote(code, index, "`");
+			blank(index + 1, end);
+			index = end + 1;
+			regexAllowed = false;
+			continue;
+		}
+		if (char === "/" && regexAllowed) {
+			const end = closingRegex(code, index);
+			if (end !== -1) {
+				blank(index + 1, end);
+				index = end + 1;
+				regexAllowed = false;
+				continue;
+			}
+		}
+		if (!/\s/.test(char)) regexAllowed = !IDENTIFIER.test(char) && char !== ")" && char !== "]";
+		index++;
+	}
+	return out.join("");
+}
+/** The index of the quote that closes the one at `open`, or the end. */
+function closingQuote(code, open, quote) {
+	for (let i = open + 1; i < code.length; i++) {
+		if (code[i] === "\\") {
+			i++;
+			continue;
+		}
+		if (code[i] === quote) return i;
+	}
+	return code.length;
+}
+/**
+* The index of the slash closing a regular expression, or -1 when the
+* slash was division after all.
+*
+* A newline inside means it was not a regular expression, which is the
+* cheap test that keeps `a / b` and `c / d` on one line from swallowing
+* everything between them.
+*/
+function closingRegex(code, open) {
+	let inClass = false;
+	for (let i = open + 1; i < code.length; i++) {
+		const char = code[i];
+		if (char === "\\") {
+			i++;
+			continue;
+		}
+		if (char === "\n") return -1;
+		if (char === "[") {
+			inClass = true;
+			continue;
+		}
+		if (char === "]") {
+			inClass = false;
+			continue;
+		}
+		if (char === "/" && !inClass) return i;
+	}
+	return -1;
+}
+/**
+* Every call of `name` in the module, in source order.
+*
+* A bare name has to stand alone: `renderRoot(` matches, `myRenderRoot(`
+* and `thing.renderRoot(` do not, because a method of that name on some
+* other object is not the framework's function. A name written with a
+* leading dot is the opposite and matches only the method call:
+* `.useService(` is how a builder chain reads and the only way it is
+* ever written.
+*/
+function findCalls(code, name, blank = blankLiterals(code)) {
+	const member = name.startsWith(".");
+	const bare = member ? name.slice(1) : name;
+	const sites = [];
+	let from = 0;
+	for (;;) {
+		const at = blank.indexOf(bare, from);
+		if (at === -1) return sites;
+		from = at + bare.length;
+		const before = at === 0 ? "" : blank[at - 1];
+		if (member ? before !== "." : before !== "" && (IDENTIFIER.test(before) || before === ".")) continue;
+		let cursor = from;
+		while (cursor < blank.length && /\s/.test(blank[cursor])) cursor++;
+		if (blank[cursor] !== "(") continue;
+		const argsEnd = matchingBracket(blank, cursor);
+		if (argsEnd === -1) continue;
+		sites.push({
+			start: at,
+			argsStart: cursor + 1,
+			argsEnd,
+			end: argsEnd + 1
+		});
+		from = argsEnd + 1;
+	}
+}
+/** The first call of `name`, or null. */
+function findCall(code, name, blank = blankLiterals(code)) {
+	return findCalls(code, name, blank)[0] ?? null;
+}
+/** The index of the bracket closing the one at `open`, or -1. */
+function matchingBracket(blank, open) {
+	const stack = [];
+	for (let i = open; i < blank.length; i++) {
+		const char = blank[i];
+		if (char === "(" || char === "[" || char === "{") {
+			stack.push(char);
+			continue;
+		}
+		if (char === ")" || char === "]" || char === "}") {
+			stack.pop();
+			if (stack.length === 0) return i;
+		}
+	}
+	return -1;
+}
+/**
+* The identifier a call's first argument is, or null when the argument
+* is anything more complicated than a name.
+*
+* `renderRoot(SegueApp)` is the shape every entry in this repository
+* writes and the only one that can be hot-replaced, because a
+* replacement has to be looked up by name in the module that changed.
+* `renderRoot(<App x={1} />)` is legal and gets no HMR wiring, which
+* the plugin says rather than guessing.
+*/
+function firstArgumentName(code, call, blank = blankLiterals(code)) {
+	const first = (splitTopLevel(blank.slice(call.argsStart, call.argsEnd))[0] ?? "").trim();
+	return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(first) ? first : null;
+}
+/** Splits an argument list on its top-level commas. */
+function splitTopLevel(text) {
+	const parts = [];
+	let depth = 0;
+	let start = 0;
+	for (let i = 0; i < text.length; i++) {
+		const char = text[i];
+		if (char === "(" || char === "[" || char === "{") depth++;
+		else if (char === ")" || char === "]" || char === "}") depth--;
+		else if (char === "," && depth === 0) {
+			parts.push(text.slice(start, i));
+			start = i + 1;
+		}
+	}
+	parts.push(text.slice(start));
+	return parts;
+}
+/**
+* Which module each imported name came from: local name to specifier,
+* exactly as the import wrote it.
+*
+* Default and namespace imports are recorded under their local names
+* too, so `import App from './App'` and `import * as app from './App'`
+* both answer. What the map does not carry is whether the binding is a
+* type, because `import type` is stripped before this runs in every
+* configuration that matters and a type never reaches a call.
+*/
+function importSources(code, blank = blankLiterals(code)) {
+	const sources = /* @__PURE__ */ new Map();
+	const statement = /\bimport\b([\s\S]*?)\bfrom\b\s*(['"])/g;
+	for (;;) {
+		const match = statement.exec(blank);
+		if (match === null) return sources;
+		const quote = match[2];
+		const open = match.index + match[0].length;
+		const close = code.indexOf(quote, open);
+		if (close === -1) continue;
+		const specifier = code.slice(open, close);
+		for (const local of importedNames(match[1])) sources.set(local, specifier);
+		statement.lastIndex = close + 1;
+	}
+}
+/** The local names an import clause binds. */
+function importedNames(clause) {
+	const names = [];
+	const braces = clause.indexOf("{");
+	const head = (braces === -1 ? clause : clause.slice(0, braces)).replace(/\btype\b/g, "");
+	for (const part of head.split(",")) {
+		const named = /^\s*(?:\*\s*as\s*)?([A-Za-z_$][A-Za-z0-9_$]*)\s*$/.exec(part);
+		if (named !== null) names.push(named[1]);
+	}
+	if (braces !== -1) {
+		const close = clause.lastIndexOf("}");
+		const list = clause.slice(braces + 1, close === -1 ? clause.length : close);
+		for (const part of list.split(",")) {
+			const aliased = /^\s*(?:type\s+)?[A-Za-z_$][A-Za-z0-9_$]*\s+as\s+([A-Za-z_$][A-Za-z0-9_$]*)\s*$/.exec(part);
+			const plain = /^\s*(?:type\s+)?([A-Za-z_$][A-Za-z0-9_$]*)\s*$/.exec(part);
+			const name = aliased?.[1] ?? plain?.[1];
+			if (name !== void 0) names.push(name);
+		}
+	}
+	return names;
+}
+//#endregion
+//#region src/render.ts
+const MARKER$1 = "/* gesso-vite-plugin: hot replacement */";
+/**
+* Writes the two lines an author would otherwise write by hand.
+*
+* The example below is the specification:
+*
+*   const app = renderRoot(LiveApp).useService(LiveFeed);
+*   import.meta.hot?.accept('./LiveExampleApp', module => {
+*     app.reload(module.LiveApp, [module.LiveFeed]);
+*   });
+*
+* Three things have to be found for that to be written mechanically:
+* the handle the chain returns, the module the root component came
+* from, and the modules the services came from. The handle is taken by
+* routing the call through a wrapper of the plugin's own, which keeps
+* the chain that follows it intact whether or not the author assigned
+* it. The modules come from the entry's own import statements, which is
+* exactly the question `importSources` answers.
+*
+* A service declared in a module of its own is accepted alongside the
+* root, because a registry keyed by class object cannot tell a
+* replacement from a stranger and `reload` is where that is repaired.
+* What is deliberately *not* wired is `useRoutes`: routes are read once
+* when the runtime is built, so a change to the route table is a full
+* reload and saying so is better than replacing a tree that still
+* resolves the old routes.
+*/
+function transformRenderWorker(code) {
+	if (code.includes(MARKER$1)) return {
+		code: null,
+		skipped: null
+	};
+	const blank = blankLiterals(code);
+	const imports = importSources(code, blank);
+	if (imports.get("renderRoot") !== "gesso-framework") return {
+		code: null,
+		skipped: null
+	};
+	const call = findCall(code, "renderRoot", blank);
+	if (call === null) return {
+		code: null,
+		skipped: null
+	};
+	const root = firstArgumentName(code, call, blank);
+	if (root === null) return {
+		code: null,
+		skipped: "renderRoot() is not called with the name of a component, so there is nothing to look up in a replaced module."
+	};
+	const rootSource = imports.get(root);
+	if (rootSource === void 0) return {
+		code: null,
+		skipped: `${root} is declared in the worker entry itself rather than imported, so replacing it would replace the entry and reload the page.`
+	};
+	const services = [];
+	for (const site of findCalls(code, ".useService", blank)) {
+		const name = firstArgumentName(code, site, blank);
+		const source = name === null ? void 0 : imports.get(name);
+		if (name !== null && source !== void 0) services.push({
+			name,
+			source
+		});
+	}
+	const sources = [rootSource, ...services.map((service) => service.source)].filter((source, index, all) => all.indexOf(source) === index);
+	const namespace = (source) => `__gessoModule${sources.indexOf(source)}`;
+	return {
+		code: `${`${code.slice(0, call.start)}__gessoRenderRoot${code.slice(call.start + 10)}`}\n${[
+			MARKER$1,
+			...sources.map((source, index) => `import * as __gessoImported${index} from ${JSON.stringify(source)};`),
+			"function __gessoRenderRoot(root) {",
+			"  __gessoRenderRoot.app = renderRoot(root);",
+			"  return __gessoRenderRoot.app;",
+			"}",
+			`const __gessoLatest = [${sources.map((_, index) => `__gessoImported${index}`).join(", ")}];`,
+			"if (import.meta.hot) {",
+			`  import.meta.hot.accept([${sources.map((source) => JSON.stringify(source)).join(", ")}], replaced => {`,
+			"    replaced.forEach((module, index) => {",
+			"      if (module !== undefined) {",
+			"        __gessoLatest[index] = module;",
+			"      }",
+			"    });",
+			`    __gessoRenderRoot.app.reload(${namespaceRead(namespace(rootSource), root)}, [${services.map((service) => namespaceRead(namespace(service.source), service.name)).join(", ")}]);`,
+			"  });",
+			"}"
+		].join("\n")}\n`,
+		skipped: null
+	};
+}
+/** `__gessoLatest[n].Name`, written through the array so a replacement wins. */
+function namespaceRead(namespaceName, exported) {
+	return `__gessoLatest[${namespaceName.slice(13)}].${exported}`;
+}
+//#endregion
+//#region src/shell.ts
+/** Marks a module the plugin has already rewritten, so it is not done twice. */
+const MARKER = "/* gesso-vite-plugin */";
+/**
+* The `createApp` call in a module, when the module has one that came
+* from the framework.
+*
+* Separate from the transform because finding the worker entries is an
+* asynchronous resolution against the bundler and worth doing only for
+* a module that turns out to be a shell, which is one module in an
+* application.
+*/
+function findShellCall(code, blank = blankLiterals(code)) {
+	if (code.includes(MARKER)) return null;
+	if (importSources(code, blank).get("createApp") !== "gesso-framework") return null;
+	const call = findCall(code, "createApp", blank);
+	if (call === null) return null;
+	return {
+		call,
+		needsWorkers: !blank.slice(call.argsStart, call.argsEnd).includes("renderWorker")
+	};
+}
+/**
+* Rewrites the shell module so that it names no worker.
+*
+* The one edit inside the author's own code is the call itself:
+* `createApp(...)` becomes `createApp(__gessoOptions(...))`, on the
+* same line, so every line number in the module is the one it was.
+* Everything else is appended below, as function declarations, which
+* hoist and are therefore usable from the line above them.
+*
+* The merge order is what keeps the promise that the
+* literal construction stays the documented fallback: the plugin's
+* factories go in first and the author's options spread over them, so
+* a `renderWorker` written by hand still wins.
+*
+* Returns null when there is nothing to do, which is the common case:
+* most modules do not call `createApp`.
+*/
+function transformShell(code, options) {
+	const shell = findShellCall(code, blankLiterals(code));
+	if (shell === null) return null;
+	if (options.entries === null && !options.overlay) return null;
+	const { call } = shell;
+	const args = code.slice(call.argsStart, call.argsEnd).trim();
+	return `${`${code.slice(0, call.argsStart)}__gessoOptions(${args === "" ? "{}" : args})${code.slice(call.argsEnd)}`}\n${prelude(options)}`;
+}
+/**
+* The appended half: the worker construction, and in development the
+* error overlay.
+*
+* `new Worker(new URL(...), { type: 'module', ... })` is written out
+* literally because that is the only shape a bundler splits a worker
+* out of, which is the whole reason this text has to be emitted into
+* the author's module rather than living inside the framework. `name`
+* is passed as a member whose value may be undefined, which a
+* dictionary conversion treats as absent, so one construction serves
+* both the named and the unnamed case.
+*/
+function prelude(options) {
+	const entries = options.entries;
+	const lines = [
+		MARKER,
+		"function __gessoOptions(options = {}) {",
+		"  return {",
+		...entries === null ? [] : [`    renderWorker: () => new Worker(new URL(${JSON.stringify(entries.renderWorker)}, import.meta.url), { type: 'module', name: options.workerName }),`],
+		...entries?.appLogicWorker == null ? [] : [`    appLogicWorker: () => new Worker(new URL(${JSON.stringify(entries.appLogicWorker)}, import.meta.url), { type: 'module', name: options.workerName }),`],
+		...options.overlay ? ["    onError: __gessoReportError,"] : [],
+		"    ...options",
+		"  };",
+		"}"
+	];
+	return options.overlay ? `${lines.join("\n")}\n${OVERLAY}` : `${lines.join("\n")}\n`;
+}
+/**
+* The development error overlay, loaded the first time something
+* throws and not before.
+*
+* Lazy because it costs nothing until it is needed: a page that never
+* throws never fetches `gesso-devtools`, and a page that does gets
+* the overlay within a network round trip of the error rather than
+* paying for the package on every start.
+*
+* The host is the canvas's parent, which is the element the
+* application was mounted into: the overlay covers the application it
+* is reporting on rather than the viewport, and a Gesso app is not
+* necessarily the whole page. `document.body` is the fallback for an
+* error thrown before there is a canvas at all.
+*
+* State is kept on the function object rather than in module-level
+* `let` bindings, because this block is appended below the code that
+* calls it and a `let` read from above it would be in its temporal
+* dead zone.
+*/
+const OVERLAY = `function __gessoReportError(message, stack, source) {
+  const state = (__gessoReportError.state ??= { pending: [], overlay: null, loading: false });
+  state.pending.push([message, stack, source]);
+  if (state.overlay !== null) {
+    __gessoFlushErrors();
+    return;
+  }
+  if (state.loading) {
+    return;
+  }
+  state.loading = true;
+  void import('gesso-devtools').then(({ mountErrorOverlay }) => {
+    const canvas = document.querySelector('canvas');
+    state.overlay = mountErrorOverlay(canvas?.parentElement ?? document.body);
+    __gessoFlushErrors();
+  });
+}
+function __gessoFlushErrors() {
+  const state = __gessoReportError.state;
+  for (const [message, stack, source] of state.pending.splice(0)) {
+    state.overlay.report(message, stack, source);
+  }
+}
+addEventListener('error', event => {
+  const error = event.error;
+  __gessoReportError(error?.message ?? event.message, error?.stack, 'window');
+});
+addEventListener('unhandledrejection', event => {
+  const reason = event.reason;
+  __gessoReportError(reason?.message ?? String(reason), reason?.stack, 'window');
+});
+`;
+//#endregion
+//#region src/index.ts
+/**
+* Where a render worker entry is looked for, beside the shell.
+*
+* Ordered so that a name that says what the file is beats the generic
+* one: an application with both `RenderWorker.ts` and `worker.ts` means
+* the first, and the scaffold, which has only `worker.ts`, still
+* resolves.
+*/
+const RENDER_WORKER_NAMES = [
+	"./RenderWorker.ts",
+	"./RenderWorker.tsx",
+	"./render.worker.ts",
+	"./app.render.worker.ts",
+	"./worker.ts"
+];
+/** Where an application worker entry is looked for, beside the shell. */
+const APP_WORKER_NAMES = [
+	"./AppWorker.ts",
+	"./AppWorker.tsx",
+	"./app.worker.ts",
+	"./app.logic.worker.ts"
+];
+/** Modules the plugin will read: the application's own source, not its dependencies. */
+const SOURCE = /\.(?:[cm]?[jt]sx?)(?:$|\?)/;
+function gesso(options = {}) {
+	let serving = false;
+	/** The shell module, once one has been transformed. */
+	let shellId = null;
+	/** The render worker entry, once the shell has named it. */
+	let renderWorkerId = null;
+	/** Files already reported as reloading, so a save is not a stream of warnings. */
+	const reported = /* @__PURE__ */ new Set();
+	return {
+		name: "gesso",
+		enforce: "pre",
+		configResolved(config) {
+			serving = config.command === "serve";
+		},
+		async transform(code, id) {
+			if (!SOURCE.test(id) || id.includes("/node_modules/")) return null;
+			if (serving && options.hmr !== false) {
+				const wiring = transformRenderWorker(code);
+				if (wiring.skipped !== null) this.warn(`${wiring.skipped} Saving it will reload the page rather than replace the tree.`);
+				if (wiring.code !== null) {
+					renderWorkerId = id;
+					return {
+						code: wiring.code,
+						map: null
+					};
+				}
+			}
+			const call = findShellCall(code);
+			if (call === null) return null;
+			shellId = id;
+			const shell = transformShell(code, {
+				entries: call.needsWorkers ? await resolveEntries(this, id, options) : null,
+				overlay: serving && options.overlay !== false
+			});
+			return shell === null ? null : {
+				code: shell,
+				map: null
+			};
+		},
+		/**
+		* The failure that looks like a bug in the framework.
+		*
+		* A module reached from the main thread as well
+		* as from the render worker cannot be hot-replaced, because Vite
+		* propagates the invalidation to a main-thread importer that does
+		* not accept and reloads the page. The screen blinks, the app
+		* restarts, and nothing anywhere says why. Both ends of the module
+		* graph are known here, so the answer is one walk of the importers.
+		*/
+		hotUpdate({ modules, server }) {
+			if (options.diagnostics === false || shellId === null || renderWorkerId === null) return;
+			for (const module of modules) {
+				if (module.id === null || reported.has(module.id)) continue;
+				const importers = importerClosure(module);
+				if (!importers.has(shellId) || !importers.has(renderWorkerId)) continue;
+				reported.add(module.id);
+				server.config.logger.warn(`[gesso] ${short(module.id, server.config.root)} is imported by the main thread as well as by the render worker, so saving it reloads the page instead of replacing the tree. Reach it only from the render worker's own graph to get hot replacement back.`);
+			}
+		}
+	};
+}
+/** Every module that transitively imports this one, plus this one. */
+function importerClosure(module) {
+	const seen = /* @__PURE__ */ new Set();
+	const queue = [module];
+	while (queue.length > 0) {
+		const next = queue.pop();
+		if (next.id === null || seen.has(next.id)) continue;
+		seen.add(next.id);
+		queue.push(...next.importers);
+	}
+	return seen;
+}
+/** A path relative to the project, for a message a person reads. */
+function short(id, root) {
+	return id.startsWith(root) ? id.slice(root.length + 1) : id;
+}
+/**
+* Finds the worker entries beside a shell module.
+*
+* The names are tried against the bundler's own resolver rather than
+* read off the disk: it already has the answer cached, it applies the
+* project's aliases and extensions, and it is the only thing that can
+* say whether the specifier the plugin is about to write would have
+* resolved. Nothing here touches the filesystem, which is also why the
+* package needs no node types.
+*/
+async function resolveEntries(context, id, options) {
+	const renderWorker = await firstResolved(context, id, options.renderWorker === void 0 ? RENDER_WORKER_NAMES : [options.renderWorker]);
+	if (renderWorker === null) throw new Error(`gesso-vite-plugin found no render worker beside ${id}. It looked for ${RENDER_WORKER_NAMES.join(", ")}. Name it with the plugin's \`renderWorker\` option, or write \`renderWorker\` in createApp() yourself.`);
+	return {
+		renderWorker,
+		appLogicWorker: options.appLogicWorker === false ? null : await firstResolved(context, id, options.appLogicWorker === void 0 ? APP_WORKER_NAMES : [options.appLogicWorker])
+	};
+}
+/** The first specifier that resolves beside `importer`, as written. */
+async function firstResolved(context, importer, names) {
+	for (const name of names) if (await context.resolve(name, importer) !== null) return name;
+	return null;
+}
+//#endregion
+export { blankLiterals, gesso as default, gesso, findCall, findCalls, findShellCall, firstArgumentName, importSources, transformRenderWorker, transformShell };
+
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":["MARKER"],"sources":["../src/source.ts","../src/render.ts","../src/shell.ts","../src/index.ts"],"sourcesContent":["/**\n * Just enough of a JavaScript scanner to find a call and to say which\n * module a name was imported from.\n *\n * Written here rather than taken from npm for the reason the rest of\n * this repository's tooling gives (`packages/devtools/src/sourceMap.ts`,\n * `scripts/gen-layout-fixtures.ts`): the whole of what the plugin needs\n * is \"where does `createApp(` open and close\" and \"where did `SegueApp`\n * come from\", and a parser is a dependency, a TypeScript dialect\n * question and a version to keep in step, in exchange for two\n * questions a scanner answers.\n *\n * The trick that makes it safe is `blankLiterals`: every string,\n * template and comment is replaced by spaces of the same length, so the\n * positions found in the blanked copy are positions in the original,\n * and no brace inside a string can be mistaken for code. Everything\n * below searches the blank copy and slices the original.\n *\n * What it does not do is understand scope. A `createApp` that a module\n * defined for itself would be found the same way an imported one is,\n * which is why the plugin checks the imports first and only then looks\n * for the call.\n */\n\n/** Where a call expression starts, where its arguments are, where it ends. */\nexport interface CallSite {\n  /** Index of the first character of the callee name. */\n  readonly start: number;\n  /** Index just after the opening parenthesis. */\n  readonly argsStart: number;\n  /** Index of the closing parenthesis. */\n  readonly argsEnd: number;\n  /** Index just after the closing parenthesis. */\n  readonly end: number;\n}\n\nconst IDENTIFIER = /[A-Za-z0-9_$]/;\n\n/**\n * A copy of `code` in which every string, template literal, regular\n * expression body and comment is spaces, and everything else is\n * untouched.\n *\n * Same length as the input, and newlines are kept, so an index into\n * the result is an index into the original and a line number is still\n * a line number. String and template delimiters are kept as well, so a\n * specifier can be found by its quotes here and read from there.\n */\nexport function blankLiterals(code: string): string {\n  const out = code.split('');\n  let index = 0;\n  // What may legally precede a regular expression: an operator, an\n  // opening bracket, or the start of the file. After a name, a number\n  // or a closing bracket, a slash is division.\n  let regexAllowed = true;\n\n  const blank = (from: number, to: number): void => {\n    for (let i = from; i < to; i++) {\n      if (out[i] !== '\\n') {\n        out[i] = ' ';\n      }\n    }\n  };\n\n  while (index < code.length) {\n    const char = code[index];\n    if (char === '/' && code[index + 1] === '/') {\n      const end = code.indexOf('\\n', index);\n      blank(index, end === -1 ? code.length : end);\n      index = end === -1 ? code.length : end;\n      continue;\n    }\n    if (char === '/' && code[index + 1] === '*') {\n      const end = code.indexOf('*/', index + 2);\n      const stop = end === -1 ? code.length : end + 2;\n      blank(index, stop);\n      index = stop;\n      continue;\n    }\n    if (char === '\"' || char === \"'\") {\n      const end = closingQuote(code, index, char);\n      blank(index + 1, end);\n      index = end + 1;\n      regexAllowed = false;\n      continue;\n    }\n    if (char === '`') {\n      const end = closingQuote(code, index, '`');\n      blank(index + 1, end);\n      index = end + 1;\n      regexAllowed = false;\n      continue;\n    }\n    if (char === '/' && regexAllowed) {\n      const end = closingRegex(code, index);\n      if (end !== -1) {\n        blank(index + 1, end);\n        index = end + 1;\n        regexAllowed = false;\n        continue;\n      }\n    }\n    if (!/\\s/.test(char)) {\n      regexAllowed = !IDENTIFIER.test(char) && char !== ')' && char !== ']';\n    }\n    index++;\n  }\n  return out.join('');\n}\n\n/** The index of the quote that closes the one at `open`, or the end. */\nfunction closingQuote(code: string, open: number, quote: string): number {\n  for (let i = open + 1; i < code.length; i++) {\n    if (code[i] === '\\\\') {\n      i++;\n      continue;\n    }\n    if (code[i] === quote) {\n      return i;\n    }\n  }\n  return code.length;\n}\n\n/**\n * The index of the slash closing a regular expression, or -1 when the\n * slash was division after all.\n *\n * A newline inside means it was not a regular expression, which is the\n * cheap test that keeps `a / b` and `c / d` on one line from swallowing\n * everything between them.\n */\nfunction closingRegex(code: string, open: number): number {\n  let inClass = false;\n  for (let i = open + 1; i < code.length; i++) {\n    const char = code[i];\n    if (char === '\\\\') {\n      i++;\n      continue;\n    }\n    if (char === '\\n') {\n      return -1;\n    }\n    if (char === '[') {\n      inClass = true;\n      continue;\n    }\n    if (char === ']') {\n      inClass = false;\n      continue;\n    }\n    if (char === '/' && !inClass) {\n      return i;\n    }\n  }\n  return -1;\n}\n\n/**\n * Every call of `name` in the module, in source order.\n *\n * A bare name has to stand alone: `renderRoot(` matches, `myRenderRoot(`\n * and `thing.renderRoot(` do not, because a method of that name on some\n * other object is not the framework's function. A name written with a\n * leading dot is the opposite and matches only the method call:\n * `.useService(` is how a builder chain reads and the only way it is\n * ever written.\n */\nexport function findCalls(code: string, name: string, blank = blankLiterals(code)): CallSite[] {\n  const member = name.startsWith('.');\n  const bare = member ? name.slice(1) : name;\n  const sites: CallSite[] = [];\n  let from = 0;\n  for (;;) {\n    const at = blank.indexOf(bare, from);\n    if (at === -1) {\n      return sites;\n    }\n    from = at + bare.length;\n    const before = at === 0 ? '' : blank[at - 1];\n    if (member ? before !== '.' : before !== '' && (IDENTIFIER.test(before) || before === '.')) {\n      continue;\n    }\n    let cursor = from;\n    while (cursor < blank.length && /\\s/.test(blank[cursor])) {\n      cursor++;\n    }\n    if (blank[cursor] !== '(') {\n      continue;\n    }\n    const argsEnd = matchingBracket(blank, cursor);\n    if (argsEnd === -1) {\n      continue;\n    }\n    sites.push({ start: at, argsStart: cursor + 1, argsEnd, end: argsEnd + 1 });\n    from = argsEnd + 1;\n  }\n}\n\n/** The first call of `name`, or null. */\nexport function findCall(code: string, name: string, blank = blankLiterals(code)): CallSite | null {\n  return findCalls(code, name, blank)[0] ?? null;\n}\n\n/** The index of the bracket closing the one at `open`, or -1. */\nexport function matchingBracket(blank: string, open: number): number {\n  const stack: string[] = [];\n  for (let i = open; i < blank.length; i++) {\n    const char = blank[i];\n    if (char === '(' || char === '[' || char === '{') {\n      stack.push(char);\n      continue;\n    }\n    if (char === ')' || char === ']' || char === '}') {\n      stack.pop();\n      if (stack.length === 0) {\n        return i;\n      }\n    }\n  }\n  return -1;\n}\n\n/**\n * The identifier a call's first argument is, or null when the argument\n * is anything more complicated than a name.\n *\n * `renderRoot(SegueApp)` is the shape every entry in this repository\n * writes and the only one that can be hot-replaced, because a\n * replacement has to be looked up by name in the module that changed.\n * `renderRoot(<App x={1} />)` is legal and gets no HMR wiring, which\n * the plugin says rather than guessing.\n */\nexport function firstArgumentName(code: string, call: CallSite, blank = blankLiterals(code)): string | null {\n  const first = (splitTopLevel(blank.slice(call.argsStart, call.argsEnd))[0] ?? '').trim();\n  return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(first) ? first : null;\n}\n\n/** Splits an argument list on its top-level commas. */\nfunction splitTopLevel(text: string): string[] {\n  const parts: string[] = [];\n  let depth = 0;\n  let start = 0;\n  for (let i = 0; i < text.length; i++) {\n    const char = text[i];\n    if (char === '(' || char === '[' || char === '{') {\n      depth++;\n    } else if (char === ')' || char === ']' || char === '}') {\n      depth--;\n    } else if (char === ',' && depth === 0) {\n      parts.push(text.slice(start, i));\n      start = i + 1;\n    }\n  }\n  parts.push(text.slice(start));\n  return parts;\n}\n\n/**\n * Which module each imported name came from: local name to specifier,\n * exactly as the import wrote it.\n *\n * Default and namespace imports are recorded under their local names\n * too, so `import App from './App'` and `import * as app from './App'`\n * both answer. What the map does not carry is whether the binding is a\n * type, because `import type` is stripped before this runs in every\n * configuration that matters and a type never reaches a call.\n */\nexport function importSources(code: string, blank = blankLiterals(code)): Map<string, string> {\n  const sources = new Map<string, string>();\n  const statement = /\\bimport\\b([\\s\\S]*?)\\bfrom\\b\\s*(['\"])/g;\n  for (;;) {\n    const match = statement.exec(blank);\n    if (match === null) {\n      return sources;\n    }\n    const quote = match[2];\n    const open = match.index + match[0].length;\n    const close = code.indexOf(quote, open);\n    if (close === -1) {\n      continue;\n    }\n    const specifier = code.slice(open, close);\n    for (const local of importedNames(match[1])) {\n      sources.set(local, specifier);\n    }\n    statement.lastIndex = close + 1;\n  }\n}\n\n/** The local names an import clause binds. */\nfunction importedNames(clause: string): string[] {\n  const names: string[] = [];\n  const braces = clause.indexOf('{');\n  const head = (braces === -1 ? clause : clause.slice(0, braces)).replace(/\\btype\\b/g, '');\n  for (const part of head.split(',')) {\n    const named = /^\\s*(?:\\*\\s*as\\s*)?([A-Za-z_$][A-Za-z0-9_$]*)\\s*$/.exec(part);\n    if (named !== null) {\n      names.push(named[1]);\n    }\n  }\n  if (braces !== -1) {\n    const close = clause.lastIndexOf('}');\n    const list = clause.slice(braces + 1, close === -1 ? clause.length : close);\n    for (const part of list.split(',')) {\n      const aliased = /^\\s*(?:type\\s+)?[A-Za-z_$][A-Za-z0-9_$]*\\s+as\\s+([A-Za-z_$][A-Za-z0-9_$]*)\\s*$/.exec(part);\n      const plain = /^\\s*(?:type\\s+)?([A-Za-z_$][A-Za-z0-9_$]*)\\s*$/.exec(part);\n      const name = aliased?.[1] ?? plain?.[1];\n      if (name !== undefined) {\n        names.push(name);\n      }\n    }\n  }\n  return names;\n}\n","import { blankLiterals, findCall, findCalls, firstArgumentName, importSources } from './source.ts';\n\n/** What the plugin found in a render worker entry, and could wire. */\nexport interface RenderWiring {\n  /** The rewritten module, or null when there was nothing to wire. */\n  readonly code: string | null;\n  /**\n   * Why nothing was wired, when nothing was. A sentence for the\n   * developer, not an error: an entry the plugin cannot wire still\n   * runs, it just full-reloads on a save.\n   */\n  readonly skipped: string | null;\n}\n\nconst MARKER = '/* gesso-vite-plugin: hot replacement */';\n\n/**\n * Writes the two lines an author would otherwise write by hand.\n *\n * The example below is the specification:\n *\n *   const app = renderRoot(LiveApp).useService(LiveFeed);\n *   import.meta.hot?.accept('./LiveExampleApp', module => {\n *     app.reload(module.LiveApp, [module.LiveFeed]);\n *   });\n *\n * Three things have to be found for that to be written mechanically:\n * the handle the chain returns, the module the root component came\n * from, and the modules the services came from. The handle is taken by\n * routing the call through a wrapper of the plugin's own, which keeps\n * the chain that follows it intact whether or not the author assigned\n * it. The modules come from the entry's own import statements, which is\n * exactly the question `importSources` answers.\n *\n * A service declared in a module of its own is accepted alongside the\n * root, because a registry keyed by class object cannot tell a\n * replacement from a stranger and `reload` is where that is repaired.\n * What is deliberately *not* wired is `useRoutes`: routes are read once\n * when the runtime is built, so a change to the route table is a full\n * reload and saying so is better than replacing a tree that still\n * resolves the old routes.\n */\nexport function transformRenderWorker(code: string): RenderWiring {\n  if (code.includes(MARKER)) {\n    return { code: null, skipped: null };\n  }\n  const blank = blankLiterals(code);\n  const imports = importSources(code, blank);\n  if (imports.get('renderRoot') !== 'gesso-framework') {\n    return { code: null, skipped: null };\n  }\n  const call = findCall(code, 'renderRoot', blank);\n  if (call === null) {\n    return { code: null, skipped: null };\n  }\n\n  const root = firstArgumentName(code, call, blank);\n  if (root === null) {\n    return {\n      code: null,\n      skipped:\n        'renderRoot() is not called with the name of a component, so there is nothing to look up in a replaced module.'\n    };\n  }\n  const rootSource = imports.get(root);\n  if (rootSource === undefined) {\n    return {\n      code: null,\n      skipped: `${root} is declared in the worker entry itself rather than imported, so replacing it would replace the entry and reload the page.`\n    };\n  }\n\n  // Every service the chain registers, paired with the module it came\n  // from. One declared beside the root is the common case and needs no\n  // second dependency; one in a module of its own adds one.\n  const services: { name: string; source: string }[] = [];\n  for (const site of findCalls(code, '.useService', blank)) {\n    const name = firstArgumentName(code, site, blank);\n    const source = name === null ? undefined : imports.get(name);\n    if (name !== null && source !== undefined) {\n      services.push({ name, source });\n    }\n  }\n\n  const sources = [rootSource, ...services.map(service => service.source)].filter(\n    (source, index, all) => all.indexOf(source) === index\n  );\n  const namespace = (source: string): string => `__gessoModule${sources.indexOf(source)}`;\n  const rewritten = `${code.slice(0, call.start)}__gessoRenderRoot${code.slice(call.start + 'renderRoot'.length)}`;\n\n  const lines = [\n    MARKER,\n    ...sources.map((source, index) => `import * as __gessoImported${index} from ${JSON.stringify(source)};`),\n    'function __gessoRenderRoot(root) {',\n    '  __gessoRenderRoot.app = renderRoot(root);',\n    '  return __gessoRenderRoot.app;',\n    '}',\n    `const __gessoLatest = [${sources.map((_, index) => `__gessoImported${index}`).join(', ')}];`,\n    'if (import.meta.hot) {',\n    `  import.meta.hot.accept([${sources.map(source => JSON.stringify(source)).join(', ')}], replaced => {`,\n    '    replaced.forEach((module, index) => {',\n    '      if (module !== undefined) {',\n    '        __gessoLatest[index] = module;',\n    '      }',\n    '    });',\n    `    __gessoRenderRoot.app.reload(${namespaceRead(namespace(rootSource), root)}, [${services\n      .map(service => namespaceRead(namespace(service.source), service.name))\n      .join(', ')}]);`,\n    '  });',\n    '}'\n  ];\n  return { code: `${rewritten}\\n${lines.join('\\n')}\\n`, skipped: null };\n}\n\n/** `__gessoLatest[n].Name`, written through the array so a replacement wins. */\nfunction namespaceRead(namespaceName: string, exported: string): string {\n  const index = namespaceName.slice('__gessoModule'.length);\n  return `__gessoLatest[${index}].${exported}`;\n}\n","import { blankLiterals, findCall, importSources, type CallSite } from './source.ts';\n\n/** Where the plugin found the two worker entries, as the shell imports them. */\nexport interface WorkerEntries {\n  /** A specifier relative to the shell module, e.g. `./RenderWorker.ts`. */\n  readonly renderWorker: string;\n  /** The same for the application worker, or null when there is none. */\n  readonly appLogicWorker: string | null;\n}\n\n/** A `createApp` call the plugin could write for, and what it still needs. */\nexport interface ShellCall {\n  readonly call: CallSite;\n  /**\n   * False when the author wrote `renderWorker` themselves, which is the\n   * documented fallback and the case where the plugin has no worker to\n   * find. It still wires the overlay in.\n   */\n  readonly needsWorkers: boolean;\n}\n\nexport interface ShellTransformOptions {\n  /** The entries to construct, or null when the author named them. */\n  readonly entries: WorkerEntries | null;\n  /**\n   * Whether to wire the error overlay in as well. True while the dev\n   * server is running and never in a build, so a production bundle\n   * carries no reference to `gesso-devtools`.\n   */\n  readonly overlay: boolean;\n}\n\n/** Marks a module the plugin has already rewritten, so it is not done twice. */\nconst MARKER = '/* gesso-vite-plugin */';\n\n/**\n * The `createApp` call in a module, when the module has one that came\n * from the framework.\n *\n * Separate from the transform because finding the worker entries is an\n * asynchronous resolution against the bundler and worth doing only for\n * a module that turns out to be a shell, which is one module in an\n * application.\n */\nexport function findShellCall(code: string, blank = blankLiterals(code)): ShellCall | null {\n  if (code.includes(MARKER)) {\n    return null;\n  }\n  if (importSources(code, blank).get('createApp') !== 'gesso-framework') {\n    return null;\n  }\n  const call = findCall(code, 'createApp', blank);\n  if (call === null) {\n    return null;\n  }\n  return { call, needsWorkers: !blank.slice(call.argsStart, call.argsEnd).includes('renderWorker') };\n}\n\n/**\n * Rewrites the shell module so that it names no worker.\n *\n * The one edit inside the author's own code is the call itself:\n * `createApp(...)` becomes `createApp(__gessoOptions(...))`, on the\n * same line, so every line number in the module is the one it was.\n * Everything else is appended below, as function declarations, which\n * hoist and are therefore usable from the line above them.\n *\n * The merge order is what keeps the promise that the\n * literal construction stays the documented fallback: the plugin's\n * factories go in first and the author's options spread over them, so\n * a `renderWorker` written by hand still wins.\n *\n * Returns null when there is nothing to do, which is the common case:\n * most modules do not call `createApp`.\n */\nexport function transformShell(code: string, options: ShellTransformOptions): string | null {\n  const blank = blankLiterals(code);\n  const shell = findShellCall(code, blank);\n  if (shell === null) {\n    return null;\n  }\n  if (options.entries === null && !options.overlay) {\n    return null;\n  }\n  const { call } = shell;\n  const args = code.slice(call.argsStart, call.argsEnd).trim();\n  const rewritten = `${code.slice(0, call.argsStart)}__gessoOptions(${args === '' ? '{}' : args})${code.slice(call.argsEnd)}`;\n  return `${rewritten}\\n${prelude(options)}`;\n}\n\n/**\n * The appended half: the worker construction, and in development the\n * error overlay.\n *\n * `new Worker(new URL(...), { type: 'module', ... })` is written out\n * literally because that is the only shape a bundler splits a worker\n * out of, which is the whole reason this text has to be emitted into\n * the author's module rather than living inside the framework. `name`\n * is passed as a member whose value may be undefined, which a\n * dictionary conversion treats as absent, so one construction serves\n * both the named and the unnamed case.\n */\nfunction prelude(options: ShellTransformOptions): string {\n  const entries = options.entries;\n  const lines = [\n    MARKER,\n    'function __gessoOptions(options = {}) {',\n    '  return {',\n    ...(entries === null\n      ? []\n      : [\n          `    renderWorker: () => new Worker(new URL(${JSON.stringify(entries.renderWorker)}, import.meta.url), { type: 'module', name: options.workerName }),`\n        ]),\n    ...(entries?.appLogicWorker == null\n      ? []\n      : [\n          `    appLogicWorker: () => new Worker(new URL(${JSON.stringify(entries.appLogicWorker)}, import.meta.url), { type: 'module', name: options.workerName }),`\n        ]),\n    ...(options.overlay ? ['    onError: __gessoReportError,'] : []),\n    '    ...options',\n    '  };',\n    '}'\n  ];\n  return options.overlay ? `${lines.join('\\n')}\\n${OVERLAY}` : `${lines.join('\\n')}\\n`;\n}\n\n/**\n * The development error overlay, loaded the first time something\n * throws and not before.\n *\n * Lazy because it costs nothing until it is needed: a page that never\n * throws never fetches `gesso-devtools`, and a page that does gets\n * the overlay within a network round trip of the error rather than\n * paying for the package on every start.\n *\n * The host is the canvas's parent, which is the element the\n * application was mounted into: the overlay covers the application it\n * is reporting on rather than the viewport, and a Gesso app is not\n * necessarily the whole page. `document.body` is the fallback for an\n * error thrown before there is a canvas at all.\n *\n * State is kept on the function object rather than in module-level\n * `let` bindings, because this block is appended below the code that\n * calls it and a `let` read from above it would be in its temporal\n * dead zone.\n */\nconst OVERLAY = `function __gessoReportError(message, stack, source) {\n  const state = (__gessoReportError.state ??= { pending: [], overlay: null, loading: false });\n  state.pending.push([message, stack, source]);\n  if (state.overlay !== null) {\n    __gessoFlushErrors();\n    return;\n  }\n  if (state.loading) {\n    return;\n  }\n  state.loading = true;\n  void import('gesso-devtools').then(({ mountErrorOverlay }) => {\n    const canvas = document.querySelector('canvas');\n    state.overlay = mountErrorOverlay(canvas?.parentElement ?? document.body);\n    __gessoFlushErrors();\n  });\n}\nfunction __gessoFlushErrors() {\n  const state = __gessoReportError.state;\n  for (const [message, stack, source] of state.pending.splice(0)) {\n    state.overlay.report(message, stack, source);\n  }\n}\naddEventListener('error', event => {\n  const error = event.error;\n  __gessoReportError(error?.message ?? event.message, error?.stack, 'window');\n});\naddEventListener('unhandledrejection', event => {\n  const reason = event.reason;\n  __gessoReportError(reason?.message ?? String(reason), reason?.stack, 'window');\n});\n`;\n","import type { EnvironmentModuleNode, Plugin } from 'vite';\n\nimport { transformRenderWorker } from './render.ts';\nimport { findShellCall, transformShell, type WorkerEntries } from './shell.ts';\n\nexport { transformRenderWorker, type RenderWiring } from './render.ts';\nexport {\n  findShellCall,\n  transformShell,\n  type ShellCall,\n  type ShellTransformOptions,\n  type WorkerEntries\n} from './shell.ts';\nexport { blankLiterals, findCall, findCalls, firstArgumentName, importSources, type CallSite } from './source.ts';\n\n/**\n * `gesso-vite-plugin` — the plumbing between saving a file and seeing\n * the result.\n *\n * A Gesso application is three files either side of a thread barrier\n *, and until now the barrier cost the author four\n * incantations: `new Worker(new URL('./RenderWorker.ts',\n * import.meta.url), { type: 'module' })` twice, because only a literal\n * gets a chunk; `import.meta.hot.accept` with the root module named by\n * hand; and `mountErrorOverlay` wired to `onError`, without which a\n * worker exception reaches a console nobody has selected. None of them\n * is a decision. All of them are written the same way in every\n * application, and getting one wrong fails silently.\n *\n * The three-file shape stays. What this removes is the incantations,\n * and what it adds is the one diagnostic that cannot be read off the\n * screen: a save that reloads the page rather than replacing a module,\n * which traces to the root module having a\n * main-thread importer and which otherwise looks like HMR simply not\n * working.\n *\n *   // vite.config.ts\n *   import { gesso } from 'gesso-vite-plugin';\n *   export default defineConfig({ plugins: [gesso()] });\n *\n *   // main.ts\n *   createApp({ history: { mode: 'path' } }).mount('#app');\n *\n * The literal construction stays supported and stays documented: the\n * plugin merges its factories *under* the options the author wrote, so\n * a hand-written `renderWorker` wins and an application that would\n * rather say it out loud can.\n */\nexport interface GessoPluginOptions {\n  /**\n   * The render worker entry, as a specifier the shell module could\n   * import. By default the plugin tries the names below, in order, and\n   * uses the first that resolves beside the shell.\n   */\n  readonly renderWorker?: string;\n  /**\n   * The application worker entry, or false for an application that has\n   * none. By default the plugin looks for it and leaves it out when\n   * there is nothing to find, which is the single-worker shape the\n   * scaffold produces.\n   */\n  readonly appLogicWorker?: string | false;\n  /**\n   * Wire `gesso-devtools`'s error overlay into `onError` (default\n   * true). Only ever in a dev server: a build carries no reference to\n   * the package.\n   */\n  readonly overlay?: boolean;\n  /** Emit the `import.meta.hot.accept` wiring (default true). */\n  readonly hmr?: boolean;\n  /**\n   * Report a save that will reload the page instead of replacing a\n   * module (default true).\n   */\n  readonly diagnostics?: boolean;\n}\n\n/**\n * Where a render worker entry is looked for, beside the shell.\n *\n * Ordered so that a name that says what the file is beats the generic\n * one: an application with both `RenderWorker.ts` and `worker.ts` means\n * the first, and the scaffold, which has only `worker.ts`, still\n * resolves.\n */\nconst RENDER_WORKER_NAMES = [\n  './RenderWorker.ts',\n  './RenderWorker.tsx',\n  './render.worker.ts',\n  './app.render.worker.ts',\n  './worker.ts'\n];\n\n/** Where an application worker entry is looked for, beside the shell. */\nconst APP_WORKER_NAMES = ['./AppWorker.ts', './AppWorker.tsx', './app.worker.ts', './app.logic.worker.ts'];\n\n/** Modules the plugin will read: the application's own source, not its dependencies. */\nconst SOURCE = /\\.(?:[cm]?[jt]sx?)(?:$|\\?)/;\n\nexport function gesso(options: GessoPluginOptions = {}): Plugin {\n  let serving = false;\n  /** The shell module, once one has been transformed. */\n  let shellId: string | null = null;\n  /** The render worker entry, once the shell has named it. */\n  let renderWorkerId: string | null = null;\n  /** Files already reported as reloading, so a save is not a stream of warnings. */\n  const reported = new Set<string>();\n\n  return {\n    name: 'gesso',\n    // Before Vite's own worker and asset plugins, which are what turn\n    // the emitted `new Worker(new URL(...))` into a chunk, and before\n    // the TypeScript transform, so the module still reads as it was\n    // written.\n    enforce: 'pre',\n\n    configResolved(config) {\n      serving = config.command === 'serve';\n    },\n\n    async transform(code, id) {\n      if (!SOURCE.test(id) || id.includes('/node_modules/')) {\n        return null;\n      }\n\n      if (serving && options.hmr !== false) {\n        const wiring = transformRenderWorker(code);\n        if (wiring.skipped !== null) {\n          this.warn(`${wiring.skipped} Saving it will reload the page rather than replace the tree.`);\n        }\n        if (wiring.code !== null) {\n          renderWorkerId = id;\n          return { code: wiring.code, map: null };\n        }\n      }\n\n      const call = findShellCall(code);\n      if (call === null) {\n        return null;\n      }\n      shellId = id;\n      const entries = call.needsWorkers ? await resolveEntries(this, id, options) : null;\n      const shell = transformShell(code, { entries, overlay: serving && options.overlay !== false });\n      return shell === null ? null : { code: shell, map: null };\n    },\n\n    /**\n     * The failure that looks like a bug in the framework.\n     *\n     * A module reached from the main thread as well\n     * as from the render worker cannot be hot-replaced, because Vite\n     * propagates the invalidation to a main-thread importer that does\n     * not accept and reloads the page. The screen blinks, the app\n     * restarts, and nothing anywhere says why. Both ends of the module\n     * graph are known here, so the answer is one walk of the importers.\n     */\n    hotUpdate({ modules, server }) {\n      if (options.diagnostics === false || shellId === null || renderWorkerId === null) {\n        return;\n      }\n      for (const module of modules) {\n        if (module.id === null || reported.has(module.id)) {\n          continue;\n        }\n        const importers = importerClosure(module);\n        if (!importers.has(shellId) || !importers.has(renderWorkerId)) {\n          continue;\n        }\n        reported.add(module.id);\n        server.config.logger.warn(\n          `[gesso] ${short(module.id, server.config.root)} is imported by the main thread as well as by the render ` +\n            'worker, so saving it reloads the page instead of replacing the tree. Reach it only from the render ' +\n            \"worker's own graph to get hot replacement back.\"\n        );\n      }\n    }\n  };\n}\n\nexport default gesso;\n\n/** Every module that transitively imports this one, plus this one. */\nfunction importerClosure(module: EnvironmentModuleNode): Set<string> {\n  const seen = new Set<string>();\n  const queue = [module];\n  while (queue.length > 0) {\n    const next = queue.pop()!;\n    if (next.id === null || seen.has(next.id)) {\n      continue;\n    }\n    seen.add(next.id);\n    queue.push(...next.importers);\n  }\n  return seen;\n}\n\n/** A path relative to the project, for a message a person reads. */\nfunction short(id: string, root: string): string {\n  return id.startsWith(root) ? id.slice(root.length + 1) : id;\n}\n\n/** What the plugin resolves against, so a spec can hand it a fake. */\ninterface Resolver {\n  resolve(source: string, importer: string): Promise<{ id: string } | null>;\n}\n\n/**\n * Finds the worker entries beside a shell module.\n *\n * The names are tried against the bundler's own resolver rather than\n * read off the disk: it already has the answer cached, it applies the\n * project's aliases and extensions, and it is the only thing that can\n * say whether the specifier the plugin is about to write would have\n * resolved. Nothing here touches the filesystem, which is also why the\n * package needs no node types.\n */\nasync function resolveEntries(context: Resolver, id: string, options: GessoPluginOptions): Promise<WorkerEntries> {\n  const renderWorker = await firstResolved(\n    context,\n    id,\n    options.renderWorker === undefined ? RENDER_WORKER_NAMES : [options.renderWorker]\n  );\n  if (renderWorker === null) {\n    throw new Error(\n      `gesso-vite-plugin found no render worker beside ${id}. It looked for ${RENDER_WORKER_NAMES.join(', ')}. ` +\n        \"Name it with the plugin's `renderWorker` option, or write `renderWorker` in createApp() yourself.\"\n    );\n  }\n  const appLogicWorker =\n    options.appLogicWorker === false\n      ? null\n      : await firstResolved(\n          context,\n          id,\n          options.appLogicWorker === undefined ? APP_WORKER_NAMES : [options.appLogicWorker]\n        );\n  return { renderWorker, appLogicWorker };\n}\n\n/** The first specifier that resolves beside `importer`, as written. */\nasync function firstResolved(context: Resolver, importer: string, names: readonly string[]): Promise<string | null> {\n  for (const name of names) {\n    if ((await context.resolve(name, importer)) !== null) {\n      return name;\n    }\n  }\n  return null;\n}\n"],"mappings":"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"}

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "gesso-vite-plugin",
+  "version": "0.1.0",
+  "description": "Finds a Gesso application's worker entries, writes the constructions and the hot-replacement wiring, and says when a save will reload the page.",
+  "license": "MIT",
+  "author": "Kevin Baker",
+  "homepage": "https://github.com/kevinpbaker/gesso#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/kevinpbaker/gesso.git",
+    "directory": "packages/vite-plugin"
+  },
+  "bugs": {
+    "url": "https://github.com/kevinpbaker/gesso/issues"
+  },
+  "keywords": [
+    "gesso",
+    "canvas",
+    "ui",
+    "typescript",
+    "vite",
+    "vite-plugin",
+    "hmr",
+    "web-worker",
+    "build-tool"
+  ],
+  "type": "module",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "README.md",
+    "CHANGELOG.md",
+    "dist",
+    "LICENSE"
+  ],
+  "peerDependencies": {
+    "vite": "^8.0.0"
+  },
+  "devDependencies": {
+    "vite": "^8.2.0"
+  },
+  "scripts": {
+    "build": "tsdown"
+  }
+}