@rohal12/twee-ts 2.0.0 → 2.1.0

package/dist/plugins/vite.js

@@ -1,9 +1,11 @@
 /*! @rohal12/twee-ts (Unlicense). Bundles third-party code under its own licence: see THIRD_PARTY_NOTICES. */
-import { Ct as pushAll, Q as getFilenames, St as isRecord, V as sha256Hex, _t as viteWaitingPage, at as isSameOrInside, bt as trySyntax, et as outputPaths, gt as insertViteClient, ot as mediaTypeFromFilename, st as normalizedFileExt, xt as types$1, yt as AcornParser } from "../diagnostic-text-CebYCTPQ.js";
-import { a as checkViteVersion, c as createOutputRecord, d as keyWithin, f as outputLocations, h as fatalError, i as watchTargets, l as fileKey, m as compileStory, n as missingImportFolders, o as resolvePluginOptions, p as toPosix, s as canonicalPath, t as importWatchTargets, u as isViteConfigTemp } from "../watch-targets-BI7jYrwa.js";
+import { At as lineColumnFinder, Ct as viteWaitingPage, Dt as AcornParser, Et as javaScriptContexts, G as recordOwnOutput, Mt as isRecord, Ot as javaScriptNodes, St as insertViteClient, Tt as cssContexts, U as sha256Hex, at as outputPaths, dt as isSameOrInside, ft as mediaTypeFromFilename, jt as types$1, kt as trySyntax, lt as identify, nt as getFilenames, pt as normalizedFileExt } from "../diagnostic-text-DMVZfBh9.js";
+import { a as checkViteVersion, c as createOutputRecord, d as isViteConfigTemp, f as keyWithin, g as fatalError, h as compileStory, i as watchTargets, l as emittedFilePath, m as toPosix, n as missingImportFolders, o as resolvePluginOptions, p as outputLocations, s as canonicalPath, t as importWatchTargets, u as fileKey } from "../watch-targets-DzvPyWDo.js";
+import { findPackageJSON } from "node:module";
 import { basename, dirname, isAbsolute, join, posix, relative, resolve, win32 } from "node:path";
 import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
 import { stripVTControlCharacters } from "node:util";
+import { pathToFileURL } from "node:url";
 import { build, createIdResolver, loadConfigFromFile, mergeConfig, version } from "vite";
 //#region src/plugins/vite-glob.ts
 /**
@@ -14,8 +16,8 @@ import { build, createIdResolver, loadConfigFromFile, mergeConfig, version } fro
 *
 * A scope is a superset of what the glob matches: a file added to it or removed from it may not match (a negated
 * pattern, a name the wildcards leave out), which only bundles again for nothing. The calls are read with acorn as Vite reads them: patterns are
-* string literals, template literals without expressions, or arrays of those; `base` and `exhaustive` are literal
-* options. A call written otherwise is one Vite rejects, and the bundle fails before its scope matters.
+* string literals, template literals without expressions, or arrays of those. Options are static literal data,
+* including computed keys and repeated members; expressions outside that subset are diagnosed, never evaluated.
 *
 * Code that is a module is read whole, so only real calls count. Code that is not (yet) one, as a plugin may hand
 * on a component file or TypeScript it transforms later, is read the way Vite's import-glob reads every module:
@@ -32,18 +34,6 @@ const MODULE_OPTIONS = {
 function mayHoldGlob(code) {
 	return code.includes("import.meta.glob");
 }
-function isNode(value) {
-	return isRecord(value) && typeof value["type"] === "string";
-}
-/** Every node below `root`, `root` first, in source order. */
-function* nodesOf(root) {
-	const stack = [root];
-	for (let value = stack.pop(); value !== void 0; value = stack.pop()) {
-		if (isNode(value)) yield value;
-		const children = Array.isArray(value) ? value : isNode(value) ? Object.values(value) : [];
-		pushAll(stack, children.toReversed());
-	}
-}
 /** Whether `node` is the callee `import.meta.glob`. */
 function isGlobCallee(node) {
 	return node.type === "MemberExpression" && !node.computed && node.property.type === "Identifier" && node.property.name === "glob" && node.object.type === "MetaProperty" && node.object.meta.name === "import" && node.object.property.name === "meta";
@@ -54,24 +44,62 @@ function stringOf(node) {
 	if (node.type === "Literal") return typeof node.value === "string" ? node.value : void 0;
 	if (node.type === "TemplateLiteral" && node.expressions.length === 0) return node.quasis[0]?.value.raw;
 }
-/** The literal value of the option `name` of a call's options object. */
-function optionOf(options, name) {
-	for (const property of options?.properties ?? []) {
-		if (property.type !== "Property" || property.computed || property.value.type !== "Literal") continue;
-		const { key } = property;
-		if ((key.type === "Identifier" ? key.name : key.type === "Literal" ? key.value : void 0) === name) return property.value.value;
+/** An expression outside the static data subset: never run it or guess the folder it selects. */
+const UNREADABLE = Symbol("unreadable");
+/** Static option data, with JavaScript's cooked strings, computed keys and last-member precedence. */
+function staticValue(node, depth = 0) {
+	if (depth > 100) return UNREADABLE;
+	switch (node.type) {
+		case "Literal": return node.regex === void 0 && node.bigint === void 0 ? node.value : UNREADABLE;
+		case "TemplateLiteral": return node.expressions.length === 0 ? node.quasis[0]?.value.cooked ?? UNREADABLE : UNREADABLE;
+		case "UnaryExpression": {
+			const value = staticValue(node.argument, depth + 1);
+			if (value === UNREADABLE) return UNREADABLE;
+			if (node.operator === "!") return !value;
+			if (typeof value === "number") {
+				if (node.operator === "-") return -value;
+				if (node.operator === "+") return value;
+			}
+			return UNREADABLE;
+		}
+		case "ArrayExpression": {
+			const values = [];
+			for (const element of node.elements) {
+				if (element === null || element.type === "SpreadElement") return UNREADABLE;
+				const value = staticValue(element, depth + 1);
+				if (value === UNREADABLE) return UNREADABLE;
+				values.push(value);
+			}
+			return values;
+		}
+		case "ObjectExpression": {
+			const entries = /* @__PURE__ */ new Map();
+			for (const property of node.properties) {
+				if (property.type === "SpreadElement") return UNREADABLE;
+				if (property.kind !== "init" || property.method || property.shorthand) return UNREADABLE;
+				if (property.computed && property.key.type !== "Literal") return UNREADABLE;
+				const key = !property.computed && property.key.type === "Identifier" ? property.key.name : staticValue(property.key, depth + 1);
+				const value = staticValue(property.value, depth + 1);
+				if (depth === 0 && key === "exhaustive" && property.value.type !== "Literal") return UNREADABLE;
+				if (key !== null && typeof key !== "string" && typeof key !== "number" && typeof key !== "boolean" || value === UNREADABLE || !property.computed && key === "__proto__") return UNREADABLE;
+				entries.set(String(key), value);
+			}
+			return Object.fromEntries(entries);
+		}
+		default: return UNREADABLE;
 	}
 }
 /** The call a glob call's arguments make. */
 function callOf(args) {
 	const [first, second] = args;
 	const patterns = (first === void 0 ? [] : first.type === "ArrayExpression" ? first.elements : [first]).map(stringOf).filter((pattern) => pattern !== void 0);
-	const options = second?.type === "ObjectExpression" ? second : void 0;
-	const base = optionOf(options, "base");
+	const options = second === void 0 ? {} : second.type === "SpreadElement" ? UNREADABLE : staticValue(second);
+	if (options === UNREADABLE) return void 0;
+	const base = isRecord(options) ? options["base"] : void 0;
 	return {
 		patterns,
 		base: typeof base === "string" ? base : void 0,
-		exhaustive: optionOf(options, "exhaustive") === true
+		exhaustive: isRecord(options) && options["exhaustive"] === true
 	};
 }
 /** Where Vite's import-glob finds a call in a module's text: the callee, any TypeScript type arguments, `(`. */
@@ -81,13 +109,26 @@ const GLOB_CALL_START = /\bimport\.meta\.glob(?:<\w+>)?\s*\(/g;
 * there: past strings, template literals, regular expressions and comments that hold parentheses. Undefined when the
 * list does not close, or the text cannot be tokenized.
 */
-function argumentsEnd(code, paren) {
+function argumentsEnd(code, paren, budget) {
+	const tokenizer = Object.assign(AcornParser.tokenizer("", MODULE_OPTIONS), {
+		input: code,
+		pos: paren
+	});
 	const read = trySyntax(() => {
 		let depth = 0;
-		for (const token of AcornParser.tokenizer(code.slice(paren), MODULE_OPTIONS)) {
+		for (;;) {
+			const from = tokenizer.pos;
+			let token;
+			try {
+				token = tokenizer.getToken();
+			} finally {
+				const searched = token === void 0 || token.type === types$1.invalidTemplate ? code.length : tokenizer.pos;
+				budget.remaining -= Math.max(1, searched - from);
+			}
+			if (budget.remaining < 0 || token.type === types$1.eof) return void 0;
 			if (token.type === types$1.parenL) depth += 1;
 			else if (token.type === types$1.parenR) depth -= 1;
-			if (depth === 0) return paren + token.end;
+			if (depth === 0) return token.end;
 		}
 	});
 	return read.ok ? read.value : void 0;
@@ -102,9 +143,11 @@ function wholeExpression(text, options) {
 * of its argument list: as a call expression, or, with type arguments between the two (which JavaScript reads as
 * comparisons), as its argument list in parentheses. Undefined when acorn reads neither.
 */
-function callAt(code, start, paren) {
-	const end = argumentsEnd(code, paren);
+function callAt(code, start, paren, budget) {
+	const end = argumentsEnd(code, paren, budget);
 	if (end === void 0) return void 0;
+	budget.remaining -= end - start + end - paren;
+	if (budget.remaining < 0) return void 0;
 	const call = wholeExpression(code.slice(start, end), MODULE_OPTIONS);
 	if (call?.type === "CallExpression" && isGlobCallee(call.callee)) return callOf(call.arguments);
 	const list = wholeExpression(code.slice(paren, end), {
@@ -118,31 +161,46 @@ function callAt(code, start, paren) {
 /** The glob calls of a module's code: read whole when it is a module, else each call on its own. */
 function globCalls(code) {
 	const parsed = trySyntax(() => AcornParser.parse(code, MODULE_OPTIONS));
-	if (parsed.ok) return {
-		calls: [...nodesOf(parsed.value)].flatMap((node) => node.type === "CallExpression" && isGlobCallee(node.callee) ? [callOf(node.arguments)] : []),
-		unreadable: []
-	};
+	if (parsed.ok) {
+		const calls = [];
+		const unreadable = [];
+		for (const node of javaScriptNodes(parsed.value)) {
+			if (node.type !== "CallExpression" || !isGlobCallee(node.callee)) continue;
+			const call = callOf(node.arguments);
+			if (call === void 0) unreadable.push(node.start);
+			else calls.push(call);
+		}
+		return {
+			calls,
+			unreadable
+		};
+	}
 	const calls = [];
 	const unreadable = [];
+	const budget = { remaining: code.length * 16 };
 	for (const match of code.matchAll(GLOB_CALL_START)) {
-		const call = callAt(code, match.index, match.index + match[0].length - 1);
+		const call = callAt(code, match.index, match.index + match[0].length - 1, budget);
 		if (call === void 0) unreadable.push(match.index);
 		else calls.push(call);
+		if (budget.remaining < 0) return {
+			calls,
+			unreadable,
+			recoveryLimited: true
+		};
 	}
 	return {
 		calls,
 		unreadable
 	};
 }
-/** Where `offset` is in `code`, as `line:column`, both from 1. */
-function lineColumn(code, offset) {
-	const lines = code.slice(0, offset).split("\n");
-	return `${String(lines.length)}:${String((lines.at(-1)?.length ?? 0) + 1)}`;
-}
 /** Characters that make a segment of a pattern match more than its own name (picomatch's, and its escape). */
 const MAGIC = /[*?[\]{}()!+@\\]/;
-/** The characters at the end of a segment after its last MAGIC one. */
-const LITERAL_END = /[^*?[\]{}()!+@\\]*$/;
+/** The characters after the last MAGIC one, found without retrying each literal prefix as a regex start. */
+function literalEnd(segment) {
+	let start = segment.length;
+	while (start > 0 && !MAGIC.test(segment.charAt(start - 1))) start -= 1;
+	return segment.slice(start).toLowerCase();
+}
 /** Whether a pattern's segments may match a name starting with a dot, which a wildcard alone never does. */
 function namesDot(segments) {
 	return segments.some((segment) => segment !== ".." && /(?:^|[{,])\./.test(segment));
@@ -162,7 +220,7 @@ function scopeOf(dir, rest, exhaustive) {
 		deep: below.length > 1 || below.some((segment) => segment.includes("**")),
 		dot: exhaustive || namesDot(below),
 		exhaustive,
-		suffix: (LITERAL_END.exec(below.at(-1) ?? "")?.[0] ?? "").toLowerCase()
+		suffix: literalEnd(below.at(-1) ?? "")
 	};
 }
 /**
@@ -285,7 +343,7 @@ function scopeWatchTargets(scopes) {
 async function resolveGlob(context, pattern, importer) {
 	const isSubImportsPattern = pattern.startsWith("#") && pattern.includes("*");
 	try {
-		return (await context.resolve(pattern, importer, { custom: { "vite:import-glob": { isSubImportsPattern } } }))?.id.replace(/[?#].*$/s, "");
+		return (await context.resolve(pattern, importer, { custom: { "vite:import-glob": { isSubImportsPattern } } }))?.id;
 	} catch {
 		return;
 	}
@@ -297,10 +355,14 @@ async function resolveGlob(context, pattern, importer) {
 */
 async function moduleGlobScopes(context, code, id, root) {
 	if (!mayHoldGlob(code)) return [];
-	const { calls, unreadable } = globCalls(code);
+	const { calls, unreadable, recoveryLimited } = globCalls(code);
 	if (unreadable.length > 0) {
-		const where = unreadable.map((offset) => lineColumn(code, offset)).join(", ");
-		context.warn(`twee-ts could not read the import.meta.glob() call at ${where} of ${id}; files added to its folders are bundled the next time something else changes.`);
+		const locate = lineColumnFinder(code);
+		const where = unreadable.map((offset) => {
+			const { line, column } = locate(offset);
+			return `${String(line)}:${String(column)}`;
+		}).join(", ");
+		context.warn(`twee-ts could not read the import.meta.glob() call at ${where} of ${id}; ` + (recoveryLimited === true ? "recovery work limit reached; remaining calls were not read; " : "") + "files added to its folders are bundled the next time something else changes.");
 	}
 	const file = id.replace(/[?#].*$/s, "");
 	const importer = isAbsolute(file) && !id.startsWith("\0") ? file : void 0;
@@ -422,8 +484,24 @@ function entryInputSettings(inputName, entryPath, userOutput, outputFilename) {
 	};
 }
 /** Removes a trailing source-map comment that points at a file (a data: URL map stays). */
-function dropFileSourceMapComment(code) {
-	return code.replace(/\n?\/\/# sourceMappingURL=(?!data:)\S*\s*$/, "").replace(/\n?\/\*# sourceMappingURL=(?!data:)[^*]*\*\/\s*$/, "");
+function dropFileSourceMapComment(code, language) {
+	const end = code.trimEnd().length;
+	const start = Math.max(language === "js" ? code.lastIndexOf("//# sourceMappingURL=", end) : -1, code.lastIndexOf("/*# sourceMappingURL=", end));
+	if (start === -1) return code;
+	const candidate = code.slice(start, end);
+	if (!/^(?:\/\/# sourceMappingURL=(?!data:)\S*|\/\*# sourceMappingURL=(?!data:)[^*]*\*\/)$/u.test(candidate)) return code;
+	const ranges = [{
+		start,
+		end
+	}, {
+		start: Math.max(0, start - 1),
+		end
+	}];
+	const [at, before] = language === "js" ? javaScriptContexts(code, ranges) : cssContexts(code, ranges);
+	const kind = at?.context.kind;
+	if (kind !== "line-comment" && kind !== "block-comment" && kind !== "comment") return code;
+	if (start > 0 && before?.context.kind === kind) return code;
+	return code.slice(0, code[start - 1] === "\n" ? start - 1 : start);
 }
 /** A module id or watched file as a forward-slash file path, without a query or hash (like Vite's cleanUrl). */
 function fileOfId(id) {
@@ -458,14 +536,14 @@ function takeEntryFromBundle(bundle, inputName) {
 	const styles = [];
 	for (const [fileName, item] of Object.entries(bundle)) if (item.type === "chunk") {
 		if (!item.isEntry || inputName !== void 0 && item.name !== inputName) continue;
-		script = dropFileSourceMapComment(item.code);
+		script = dropFileSourceMapComment(item.code, "js");
 		for (const id of item.moduleIds) if (!id.startsWith("\0")) files.add(fileOfId(id));
 		removeFromBundle(bundle, fileName);
 	} else if (fileName.endsWith(".css") && !isImportedFile(item)) {
 		const css = typeof item.source === "string" ? item.source : new TextDecoder().decode(item.source);
-		styles.push(dropFileSourceMapComment(css));
+		styles.push(dropFileSourceMapComment(css, "css"));
 		removeFromBundle(bundle, fileName);
-	} else if (fileName.endsWith(".map")) removeFromBundle(bundle, fileName);
+	} else if (fileName.endsWith(".map") && (item.originalFileNames?.length ?? 0) === 0) removeFromBundle(bundle, fileName);
 	else assets.set(fileName, item.source);
 	return {
 		script,
@@ -567,31 +645,69 @@ function appliesTo(plugin, command, config, env) {
 /**
 * `plugin` as the entry build runs it: without `apply` (already decided by
 * appliesTo), and, for the dev command, with its `config`, `configEnvironment`
-* and `configResolved` hooks seeing the dev command, as the dev server's
-* instance of the plugin sees it. The plugin object itself is left untouched.
+* and `configResolved` hooks, environment selection and hook contexts seeing
+* the dev command. Vite's own build plugins still see build. The plugin object itself is left untouched.
 */
-function asEntryBuildPlugin(plugin, command) {
+function asEntryBuildPlugin(plugin, command, views) {
 	const overrides = /* @__PURE__ */ new Map([["apply", void 0]]);
 	if (command === "serve") {
 		const devEnv = (env) => Object.assign({}, env, {
 			command,
 			isSsrBuild: false
 		});
-		const wrap = (name, patch) => {
-			const hook = plugin[name];
+		const devConfig = (config) => {
+			if (!isRecord(config)) return config;
+			let view = views.configs.get(config);
+			if (view === void 0) {
+				view = withOverrides(config, /* @__PURE__ */ new Map([["command", command]]));
+				views.configs.set(config, view);
+			}
+			return view;
+		};
+		const devEnvironment = (environment) => {
+			if (!isRecord(environment)) return environment;
+			const known = views.environments.get(environment);
+			if (known !== void 0) return known;
+			const overrides = /* @__PURE__ */ new Map([["config", devConfig(environment["config"])]]);
+			const topLevel = environment["getTopLevelConfig"];
+			if (typeof topLevel === "function") overrides.set("getTopLevelConfig", () => devConfig(Reflect.apply(topLevel, environment, [])));
+			const view = withOverrides(environment, overrides);
+			views.environments.set(environment, view);
+			return view;
+		};
+		const devContext = (context) => {
+			if (!isRecord(context) || context["environment"] === void 0) return context;
+			const environment = devEnvironment(context["environment"]);
+			return new Proxy(context, { get(target, key) {
+				if (key === "environment") return environment;
+				const value = Reflect.get(target, key, target);
+				return typeof value === "function" ? value.bind(target) : value;
+			} });
+		};
+		const wrap = (name, patch = (args) => args) => {
+			const hook = Reflect.get(plugin, name);
 			const handler = hookHandler(hook);
 			if (typeof handler !== "function") return;
 			overrides.set(name, withHandler(hook, function(...args) {
-				return Reflect.apply(handler, this, patch(args));
+				return Reflect.apply(handler, devContext(this), patch(args));
 			}));
 		};
+		const keys = /* @__PURE__ */ new Set();
+		for (let object = plugin; object !== null && object !== Object.prototype; object = Reflect.getPrototypeOf(object)) for (const key of Reflect.ownKeys(object)) keys.add(key);
+		for (const key of keys) if (key !== "constructor" && key !== "apply" && key !== "applyToEnvironment") wrap(key);
 		wrap("config", ([config, env]) => [config, devEnv(env)]);
 		wrap("configEnvironment", ([name, config, env]) => [
 			name,
 			config,
 			devEnv(env)
 		]);
-		wrap("configResolved", ([config]) => [isRecord(config) ? withOverrides(config, /* @__PURE__ */ new Map([["command", command]])) : config]);
+		wrap("configResolved", ([config]) => [devConfig(config)]);
+		const select = plugin.applyToEnvironment;
+		if (select !== void 0) overrides.set("applyToEnvironment", async function(environment) {
+			const result = await Reflect.apply(select, this, [devEnvironment(environment)]);
+			if (result === true || !result) return result;
+			return (await flattenPlugins(result)).filter(isPlugin).map((selected) => asEntryBuildPlugin(selected, command, views));
+		});
 	}
 	return pluginWith(plugin, overrides);
 }
@@ -696,7 +812,7 @@ function entryBuildEnforcer(entryPath, command, outputFilename) {
 		}
 	};
 }
-/** Build-phase plugin hooks that may call `this.addWatchFile`. */
+/** Plugin hooks that may read an entry input and register it with `this.addWatchFile` before the story is emitted. */
 const WATCH_FILE_HOOKS = [
 	"buildStart",
 	"resolveId",
@@ -704,7 +820,11 @@ const WATCH_FILE_HOOKS = [
 	"load",
 	"transform",
 	"moduleParsed",
-	"buildEnd"
+	"buildEnd",
+	"renderStart",
+	"renderChunk",
+	"augmentChunkHash",
+	"generateBundle"
 ];
 /** A plugin context whose `addWatchFile` also passes the file to `record`. */
 function recordingContext(context, record) {
@@ -713,7 +833,7 @@ function recordingContext(context, record) {
 		if (typeof value !== "function") return value;
 		if (key !== "addWatchFile") return value.bind(target);
 		return (id) => {
-			if (typeof id === "string" && !id.startsWith("\0")) record(fileOfId(resolve(id)));
+			if (typeof id === "string" && !id.startsWith("\0")) record(resolve(id));
 			return Reflect.apply(value, target, [id]);
 		};
 	} });
@@ -724,13 +844,14 @@ function recordingContext(context, record) {
 * never collects wrappers. A plugin without such hooks (a built-in one, for
 * instance) is returned as it is.
 */
-function recordingPlugin(plugin, record) {
+function recordingPlugin(plugin, recordFor) {
 	const overrides = /* @__PURE__ */ new Map();
 	for (const name of WATCH_FILE_HOOKS) {
 		const hook = plugin[name];
 		const handler = hookHandler(hook);
 		if (typeof handler !== "function") continue;
 		overrides.set(name, withHandler(hook, function(...args) {
+			const record = recordFor(name, args);
 			const context = typeof this === "object" && this !== null ? recordingContext(this, record) : this;
 			return Reflect.apply(handler, context, args);
 		}));
@@ -784,6 +905,45 @@ function writtenPaths(source, importer, root) {
 	return from !== void 0 && isAbsolute(from) && /^\.\.?(?:[/\\]|$)/.test(source) ? [fileOfId(resolve(dirname(from), source))] : [];
 }
 /**
+* Package locations Node's upward node_modules search can use for an unresolved bare import. These are recovery
+* inputs only: Vite still decides aliases, exports and the actual module. Watching the package itself sees a
+* restored manifest, export target or nested subpath without watching every installed package recursively.
+*/
+function missingPackagePaths(source, importer) {
+	if (importer === void 0 || !isAbsolute(fileOfId(importer)) || source === "" || /^[./\\#\0]/.test(source) || source.includes(":")) return [];
+	const name = source.split("/").slice(0, source.startsWith("@") ? 2 : 1).join("/");
+	const paths = [];
+	for (let folder = dirname(fileOfId(importer));; folder = dirname(folder)) {
+		if (toPosix(folder).split("/").at(-1) !== "node_modules") paths.push(toPosix(join(folder, "node_modules", name)));
+		if (dirname(folder) === folder) break;
+	}
+	return paths;
+}
+/**
+* A package can import itself through its exports without living in node_modules. Node can locate its manifest
+* even when the export target is missing. Track the package's own file listing as a recovery scope, excluding
+* node_modules; recording the whole folder as a watch file would scan all of its installed dependencies too.
+* The node_modules candidates above remain necessary for packages that have no manifest yet.
+*/
+function missingPackageScope(source, importer, candidates) {
+	if (importer === void 0 || candidates.length === 0) return void 0;
+	let manifest;
+	try {
+		manifest = findPackageJSON(source, pathToFileURL(fileOfId(importer)));
+	} catch {
+		return;
+	}
+	if (manifest === void 0) return void 0;
+	const dir = toPosix(dirname(manifest));
+	return candidates.includes(dir) ? void 0 : {
+		dir,
+		deep: true,
+		dot: true,
+		exhaustive: false,
+		suffix: ""
+	};
+}
+/**
 * Every path an import of `source` by `importer` is spelled as (see writtenPaths), and the path Vite's resolver
 * reaches the file by, links kept (`kept`, see keptPath). A caller then sees a link on the way that is retargeted,
 * which the file's own path never shows. Nothing for an import from a virtual module, or of one.
@@ -809,55 +969,100 @@ async function importSpellings(context, source, importer, root) {
 * which sees the final plugin list, including the plugins Vite resolves per
 * environment (`applyToEnvironment`) after `configResolved`.
 */
-function recordWatchFiles(files, root, observer) {
+function recordWatchFiles(files, root, observer = {}) {
 	const { onLoad, onResolve, onGlob, onWatchFile } = observer;
+	const watches = /* @__PURE__ */ new Map();
+	const touched = /* @__PURE__ */ new Set();
+	let modules = /* @__PURE__ */ new Set();
+	let started = false;
 	const record = (file) => {
-		files.add(file);
+		files?.add(file);
 		onWatchFile?.(file);
 	};
+	const recordFor = (hook, args) => {
+		if (hook === "buildStart" && !started) {
+			started = true;
+			touched.clear();
+			watches.delete(void 0);
+		}
+		const owner = hook === "transform" || hook === "resolveId" || hook === "resolveDynamicImport" ? args[1] : hook === "load" ? args[0] : hook === "moduleParsed" && isRecord(args[0]) ? args[0]["id"] : void 0;
+		const id = typeof owner === "string" ? owner : void 0;
+		if (id !== void 0 && (hook === "load" || hook === "transform") && !touched.has(id)) {
+			touched.add(id);
+			watches.delete(id);
+		}
+		return (file) => {
+			record(file);
+			const owned = watches.get(id) ?? /* @__PURE__ */ new Set();
+			watches.set(id, owned.add(file));
+		};
+	};
 	return {
-		name: `${PLUGIN_NAME}:record-watch-files`,
-		load: {
-			order: "pre",
-			handler(id) {
-				const file = fileOfId(id);
-				if (!isAbsolute(file) || id.startsWith("\0")) return null;
-				onLoad?.(file);
-				onResolve?.(file);
-				return null;
-			}
-		},
-		resolveId: {
-			order: "pre",
-			async handler(source, importer) {
-				if (onResolve === void 0) return null;
-				for (const spelled of (await importSpellings(this, source, importer, root)).spellings) onResolve(spelled);
-				return null;
-			}
-		},
-		transform: {
-			filter: { code: "import.meta.glob" },
-			async handler(code, id) {
-				if (onGlob === void 0) return null;
-				for (const scope of await moduleGlobScopes(this, code, id, root)) onGlob(scope);
-				return null;
-			}
-		},
-		buildEnd() {
-			for (const id of this.getModuleIds()) {
-				const file = fileOfId(id);
-				if (isAbsolute(file)) files.add(file);
+		plugin: {
+			name: `${PLUGIN_NAME}:record-watch-files`,
+			buildStart() {
+				recordFor("buildStart", []);
+			},
+			load: {
+				order: "pre",
+				handler(id) {
+					const file = fileOfId(id);
+					if (!isAbsolute(file) || id.startsWith("\0")) return null;
+					onLoad?.(file);
+					onResolve?.(file);
+					return null;
+				}
+			},
+			resolveId: {
+				order: "pre",
+				async handler(source, importer) {
+					if (onResolve === void 0) return null;
+					const { spellings, kept } = await importSpellings(this, source, importer, root);
+					for (const spelled of spellings) onResolve(spelled);
+					if (kept === void 0 && spellings.length === 0) {
+						const candidates = missingPackagePaths(source, importer);
+						for (const path of candidates) record(path);
+						const scope = missingPackageScope(source, importer, candidates);
+						if (scope !== void 0) {
+							record(join(scope.dir, "package.json"));
+							onGlob?.(scope);
+						}
+					}
+					return null;
+				}
+			},
+			transform: {
+				filter: { code: "import.meta.glob" },
+				async handler(code, id) {
+					if (onGlob === void 0) return null;
+					for (const scope of await moduleGlobScopes(this, code, id, root)) onGlob(scope);
+					return null;
+				}
+			},
+			buildEnd() {
+				modules = new Set(this.getModuleIds());
+				started = false;
+				for (const owner of watches.keys()) if (owner !== void 0 && !modules.has(owner)) watches.delete(owner);
+				for (const id of modules) {
+					const file = fileOfId(id);
+					if (isAbsolute(file)) files?.add(file);
+				}
+			},
+			options: {
+				order: "post",
+				async handler(inputOptions) {
+					const plugins = (await flattenPlugins(inputOptions.plugins)).filter(isPlugin).map((p) => recordingPlugin(p, recordFor));
+					return {
+						...inputOptions,
+						plugins
+					};
+				}
 			}
 		},
-		options: {
-			order: "post",
-			async handler(inputOptions) {
-				const plugins = (await flattenPlugins(inputOptions.plugins)).filter(isPlugin).map((p) => recordingPlugin(p, record));
-				return {
-					...inputOptions,
-					plugins
-				};
-			}
+		inputs: () => {
+			const current = new Set([...modules].filter((id) => !id.startsWith("\0")).map(fileOfId).filter(isAbsolute));
+			for (const [owner, watched] of watches) if (owner === void 0 || modules.has(owner)) for (const file of watched) current.add(file);
+			return current;
 		}
 	};
 }
@@ -902,7 +1107,13 @@ async function bundleEntry(config, entryPath, command, outputFilename, observer
 		isPreview: false
 	};
 	const user = await userConfigFor(config, env);
-	const plugins = (await flattenPlugins(user.plugins)).filter(isPlugin).filter((plugin) => plugin.name !== "twee-ts" && appliesTo(plugin, command, user, env)).map((plugin) => asEntryBuildPlugin(plugin, command));
+	const views = {
+		configs: /* @__PURE__ */ new WeakMap(),
+		environments: /* @__PURE__ */ new WeakMap()
+	};
+	const entryPlugins = async (option) => (await flattenPlugins(option)).filter(isPlugin).filter((plugin) => plugin.name !== "twee-ts" && appliesTo(plugin, command, user, env)).map((plugin) => asEntryBuildPlugin(plugin, command, views));
+	const plugins = await entryPlugins(user.plugins);
+	const workerPlugins = user.worker?.plugins;
 	const inline = {
 		...withoutExcludedKeys(user),
 		configFile: false,
@@ -915,9 +1126,12 @@ async function bundleEntry(config, entryPath, command, outputFilename, observer
 		plugins: [
 			...plugins,
 			entryBuildEnforcer(entryPath, command, outputFilename),
-			recordWatchFiles(watchFiles, config.root, observer)
+			recordWatchFiles(watchFiles, config.root, observer).plugin
 		],
-		worker: withWorkerPlugin(user.worker, () => recordWatchFiles(watchFiles, config.root, observer))
+		worker: withWorkerPlugin({
+			...user.worker,
+			plugins: () => [entryPlugins(typeof workerPlugins === "function" ? workerPlugins() : workerPlugins)]
+		}, () => recordWatchFiles(watchFiles, config.root, observer).plugin)
 	};
 	const [result] = [await build(inline)].flat();
 	if (result === void 0 || !("output" in result)) throw new Error("twee-ts: the entry build returned no bundle.");
@@ -1058,9 +1272,9 @@ function fileState(file) {
 * `folder` is not a folder.
 */
 function folderState(folder) {
-	if (statSync(folder, { throwIfNoEntry: false })?.isDirectory() !== true) return void 0;
 	let names;
 	try {
+		if (statSync(folder, { throwIfNoEntry: false })?.isDirectory() !== true) return void 0;
 		names = readdirSync(folder, {
 			recursive: true,
 			encoding: "utf8"
@@ -1087,6 +1301,15 @@ function fileRead(file) {
 function tracked(paths) {
 	return new Map([...paths].map((path) => [fileKey(path), canonicalPath(path)]));
 }
+/** A native identity key and every parent above it, without identifying any path again. */
+function* keyParents(key) {
+	for (let current = key;;) {
+		yield current;
+		const parent = dirname(current);
+		if (parent === current) return;
+		current = parent;
+	}
+}
 /**
 * The key of the file `authored` reaches, when it reaches it through a link (somewhere along the path, or
 * at the end of it): the one case where the file's own path says nothing of a change of target.
@@ -1155,8 +1378,8 @@ function installStoryRoute(middlewares, route) {
 		handle: route
 	});
 }
-/** The story and assets each story instance of a dev server serves, so instances can see each other's names. */
-const devInstances = /* @__PURE__ */ new WeakMap();
+/** The instances and entry watches of each server; the watcher is shared by every story (#517). */
+const devServers = /* @__PURE__ */ new WeakMap();
 /** The error for a story page whose URL another story or an entry asset of the same dev server also claims. */
 function storyCollisionMessage(path) {
 	return `twee-ts: more than one generated file is served at ${path || "/"} (another story or an entry asset); set a distinct outputFilename.`;
@@ -1188,11 +1411,20 @@ async function setUpDevStory(server, dev) {
 	let lastError;
 	let entry;
 	let servedAssets;
-	const instances = devInstances.get(server) ?? /* @__PURE__ */ new Set();
-	devInstances.set(server, instances);
+	const state = devServers.get(server) ?? {
+		instances: /* @__PURE__ */ new Set(),
+		watched: /* @__PURE__ */ new Map(),
+		released: /* @__PURE__ */ new Map()
+	};
+	devServers.set(server, state);
+	const { instances, watched, released } = state;
+	const watchedForEntry = /* @__PURE__ */ new Map();
 	const self = {
 		paths,
-		assets: () => servedAssets
+		assets: () => servedAssets,
+		catchUp: () => catchUp(),
+		inputKeys,
+		entryWatches: watchedForEntry
 	};
 	instances.add(self);
 	const fail = (res, message) => {
@@ -1211,12 +1443,12 @@ async function setUpDevStory(server, dev) {
 	let entryFolders = /* @__PURE__ */ new Map();
 	let entryReads = /* @__PURE__ */ new Map();
 	const readsModules = config.server.watch !== null;
-	const watchedForEntry = /* @__PURE__ */ new Map();
 	let queue = Promise.resolve();
 	let pending = /* @__PURE__ */ new Set();
 	let timer;
 	let closed = false;
 	let compiledInputs = /* @__PURE__ */ new Map();
+	let compiledInputNames;
 	let catchingUp;
 	const closeWatcher = server.watcher.close.bind(server.watcher);
 	server.watcher.close = async () => {
@@ -1226,8 +1458,13 @@ async function setUpDevStory(server, dev) {
 		return closeWatcher();
 	};
 	const namedInputs = () => inputs.map((input) => {
-		const stat = statSync(input, { throwIfNoEntry: false });
-		const kind = stat === void 0 ? "none" : stat.isFile() ? "file" : stat.isDirectory() ? "folder" : "other";
+		let kind;
+		try {
+			const stat = statSync(input, { throwIfNoEntry: false });
+			kind = stat === void 0 ? "none" : stat.isFile() ? "file" : stat.isDirectory() ? "folder" : "other";
+		} catch (error) {
+			kind = `failed:${String(error)}`;
+		}
 		return `${fileKey(input)}\0${kind}`;
 	}).join("\0");
 	let inputWalk;
@@ -1236,7 +1473,7 @@ async function setUpDevStory(server, dev) {
 		const folders = /* @__PURE__ */ new Map();
 		const files = getFilenames(inputs, outputs, [], "source", (folder) => folders.set(folder, fileState(folder))).files.filter((file) => !excludedGlob(file.path)).map((file) => ({
 			key: file.key,
-			path: resolve(file.path),
+			path: identify(file.path).absolute,
 			link: file.link === true
 		}));
 		return {
@@ -1270,14 +1507,28 @@ async function setUpDevStory(server, dev) {
 	const entryWatchTargets = () => new Map([...entryFiles, ...tracked(scopeWatchTargets(entryGlobs.values()))]);
 	const watchEntryFiles = (files) => {
 		const added = [...files].filter(([key]) => !keyWithin(key, [root]) && !keyWithin(key, inputKeys()) && !watchedForEntry.has(key));
-		const dropped = [...watchedForEntry].filter(([key]) => !files.has(key));
-		for (const [key] of dropped) watchedForEntry.delete(key);
-		for (const [key, path] of added) watchedForEntry.set(key, path);
-		if (dropped.length > 0) server.watcher.unwatch(dropped.map(([, path]) => path));
-		if (added.length > 0) {
-			server.watcher.add(added.map(([, path]) => path));
-			recheckOnceWatched(new Map(added)).catch(keepQueueAlive);
+		for (const key of watchedForEntry.keys()) if (!files.has(key)) watchedForEntry.delete(key);
+		for (const [key, path] of added) {
+			watchedForEntry.set(key, path);
+			watched.set(key, path);
+		}
+		const owners = /* @__PURE__ */ new Set([root, ...[...instances].flatMap((instance) => [...instance.inputKeys(), ...instance.entryWatches.keys()])]);
+		const aboveOwners = new Set([...owners].flatMap((key) => [...keyParents(key)]));
+		const needed = (key) => aboveOwners.has(key) || [...keyParents(key)].some((parent) => owners.has(parent));
+		const dropped = [...watched].filter(([key]) => !needed(key));
+		for (const [key, path] of dropped) {
+			watched.delete(key);
+			released.set(key, path);
+		}
+		const restored = [...released].filter(([key]) => needed(key));
+		for (const [key, path] of restored) {
+			released.delete(key);
+			watched.set(key, path);
 		}
+		if (dropped.length > 0) server.watcher.unwatch(dropped.map(([, path]) => path));
+		const registrations = new Map([...restored, ...added]);
+		if (registrations.size > 0) server.watcher.add([...registrations.values()]);
+		if (added.length > 0) recheckOnceWatched(new Map(added)).catch(keepQueueAlive);
 	};
 	const isListed = (path) => {
 		return server.watcher.getWatched()[dirname(path)]?.includes(basename(path)) ?? false;
@@ -1382,7 +1633,6 @@ async function setUpDevStory(server, dev) {
 		globStates = globsRead;
 		entryFolders = folders;
 		entryReads = reads;
-		watchEntryFiles(entryWatchTargets());
 	};
 	const alreadyRead = (key) => {
 		const read = entryReads.get(key);
@@ -1402,8 +1652,10 @@ async function setUpDevStory(server, dev) {
 			outputs = dev.outputs(config);
 			output = outputPaths(outputs);
 			compiledInputs = storyInputFiles(true);
+			compiledInputNames = inputWalk?.named;
 			for (const key of [...cache.keys()]) if (changed.has(fileKey(key))) cache.delete(key);
 			if (entryStale || regrouped || unread.some(touchesEntry)) await bundle();
+			watchEntryFiles(entryWatchTargets());
 			const story = await compileStory(options.compile(entrySources(entry)), outputs, cache);
 			for (const warning of story.warnings) config.logger.warn(`[twee-ts] ${warning}`);
 			html = outputMode === "html" ? dev.injectClient(story.output, base) : story.output;
@@ -1451,6 +1703,7 @@ async function setUpDevStory(server, dev) {
 				if (queue === waited) break;
 			}
 			const changed = filesChanged(compiledInputs, storyInputFiles(false));
+			if (compiledInputNames !== inputWalk?.named) for (const input of inputs) changed.add(fileKey(input));
 			for (const file of filesChanged(entryStates, fileStates(entryFiles))) changed.add(file);
 			if (changed.size === 0 && pending.size === 0 && !linkMoved() && !globsChanged() && !foldersChanged()) return;
 			for (const file of pending) changed.add(file);
@@ -1493,33 +1746,63 @@ async function setUpDevStory(server, dev) {
 			next();
 			return;
 		}
-		const others = [...instances].filter((other) => other !== self);
 		const mine = paths.includes(path);
-		if ((mine || servedAssets?.has(path) === true) && others.some((other) => other.paths.includes(path) || mine && other.assets()?.has(path) === true)) {
-			fail(res, storyCollisionMessage(path));
+		if (!mine && servedAssets?.has(path) !== true) {
+			next();
 			return;
 		}
-		if (paths.includes(path)) {
-			catchUp().then(() => {
+		([...instances].some((instance) => instance.paths.includes(path)) ? Promise.all([...instances].map((instance) => instance.catchUp())) : Promise.resolve()).then(() => {
+			const others = [...instances].filter((other) => other !== self);
+			if ((mine || servedAssets?.has(path) === true) && others.some((other) => other.paths.includes(path) || mine && paths.some((storyPath) => other.assets()?.has(storyPath) === true))) {
+				fail(res, storyCollisionMessage(path));
+				return;
+			}
+			if (mine) {
+				if (paths.some((storyPath) => servedAssets?.has(storyPath) === true)) {
+					fail(res, storyCollisionMessage(path));
+					return;
+				}
 				if (html) send(req, res, OUTPUT_MEDIA_TYPES[outputMode], html);
 				else send(req, res, "text/html; charset=utf-8", waitingPage(base));
-			}, next);
-			return;
-		}
-		const asset = servedAssets?.get(path);
-		if (asset === void 0) {
-			next();
-			return;
-		}
-		for (const other of others) {
-			const theirs = other.assets()?.get(path);
-			if (theirs !== void 0 && !sameBytes(theirs, asset)) {
-				fail(res, entryCollisionMessage(path));
 				return;
 			}
+			const asset = servedAssets?.get(path);
+			if (asset === void 0) {
+				next();
+				return;
+			}
+			for (const other of others) {
+				const theirs = other.assets()?.get(path);
+				if (theirs !== void 0 && !sameBytes(theirs, asset)) {
+					fail(res, entryCollisionMessage(path));
+					return;
+				}
+			}
+			send(req, res, assetMediaType(path), asset);
+		}, next);
+	};
+}
+//#endregion
+//#region src/plugins/vite-public.ts
+/** Inventory public copies by their destination names, following directory links as Vite's copyDir does. */
+function publicFiles(publicDir) {
+	if (!existsSync(publicDir)) return [];
+	const files = [];
+	const ancestors = /* @__PURE__ */ new Set();
+	const walk = (folder) => {
+		const key = fileKey(folder);
+		if (ancestors.has(key)) return;
+		ancestors.add(key);
+		for (const name of readdirSync(folder)) {
+			const path = resolve(folder, name);
+			if (!existsSync(path)) continue;
+			if (statSync(path).isDirectory()) walk(path);
+			else files.push(relative(publicDir, path));
 		}
-		send(req, res, assetMediaType(path), asset);
+		ancestors.delete(key);
 	};
+	walk(publicDir);
+	return files;
 }
 //#endregion
 //#region src/plugins/vite.ts
@@ -1588,14 +1871,14 @@ function configOutputLocations(config) {
 * Every path a build with this config writes, as far as the config tells: each
 * output's folder (see configOutputLocations), the story in it, and the copies
 * of the public files Vite puts there. The plugin adds the files each bundle
-* writes as it builds (see createOutputRecord).
+* writes as it builds (see createOutputRecord). A build passes its persistent
+* record so public copies remain excluded after a file is removed or a link is retargeted.
 */
-function configOutputs(config, outputFilename) {
-	const record = createOutputRecord(outputFilename);
-	const publicFiles = config.build.copyPublicDir && config.publicDir ? getFilenames([config.publicDir]).filenames.map((file) => relative(config.publicDir, resolve(file))) : [];
+function configOutputs(config, record) {
+	const copiedFiles = config.build.copyPublicDir && config.publicDir ? publicFiles(config.publicDir) : [];
 	for (const location of configOutputLocations(config)) {
 		record.addLocation(location);
-		record.addFiles(location, publicFiles);
+		record.addFiles(location, copiedFiles);
 	}
 	return record.outputs();
 }
@@ -1659,8 +1942,9 @@ function tweeTsPlugin(options) {
 	const entryInput = `${ENTRY_INPUT_NAME}-${instances}`;
 	const cache = /* @__PURE__ */ new Map();
 	const ownBuilds = /* @__PURE__ */ new WeakMap();
+	const entryInputs = /* @__PURE__ */ new WeakMap();
 	const record = createOutputRecord(outputFilename);
-	const allOutputs = (config) => mergeOutputs(configOutputs(config, outputFilename), record.outputs());
+	const allOutputs = (config) => mergeOutputs(configOutputs(config, createOutputRecord(outputFilename)), record.outputs());
 	/**
 	* The build settings this instance adds to a client build: none when the
 	* user's config names an input (the entry is then bundled by a build of its
@@ -1784,6 +2068,11 @@ function tweeTsPlugin(options) {
 		},
 		configResolved(config) {
 			if (entryPath === void 0) return;
+			if (config.command === "build" && (bundlesEntryInside(config) || bundlesEntryInside({ build: config.environments[CLIENT]?.build }))) {
+				const recorder = recordWatchFiles(void 0, config.root);
+				entryInputs.set(config, recorder.inputs);
+				Reflect.set(config.plugins, config.plugins.length, pluginWith(recorder.plugin, /* @__PURE__ */ new Map([["applyToEnvironment", (environment) => environment.name === CLIENT]])));
+			}
 			if (config.command === "build" && config.build.watch && bundlesEntryInside(config)) config.plugins.forEach((plugin, at) => {
 				if (!isOwnPlugin(plugin)) Reflect.set(config.plugins, at, claimingPlugin(plugin, (key) => claimed.add(key)));
 			});
@@ -1795,7 +2084,7 @@ function tweeTsPlugin(options) {
 			watchOutputs = /* @__PURE__ */ new WeakMap();
 			forgetKeptResolver(config);
 			if (this.meta.watchMode) {
-				const outputs = outputPaths(allOutputs(config));
+				const outputs = outputPaths(allOutputs(config), "snapshot");
 				for (const target of watchTargets(resolved.inputs, resolved.excluded, outputs, "real")) this.addWatchFile(target);
 			}
 			if (entryPath === void 0 || bundlesEntryInside(config)) return;
@@ -1805,7 +2094,7 @@ function tweeTsPlugin(options) {
 			const registerEntryInputs = () => {
 				if (!this.meta.watchMode) return;
 				for (const file of watched) this.addWatchFile(canonicalPath(file));
-				const outputs = outputPaths(allOutputs(config));
+				const outputs = outputPaths(allOutputs(config), "snapshot");
 				for (const target of importWatchTargets(authored, outputs)) this.addWatchFile(target);
 				for (const target of globWatchTargets(globs, outputs)) this.addWatchFile(target);
 			};
@@ -1882,7 +2171,7 @@ function tweeTsPlugin(options) {
 					const items = bundle;
 					entry = bundlesEntryInside(config) ? takeEntryFromBundle(items, entryInput) : ownBuilds.get(this.environment);
 					if (!bundlesEntryInside(config)) for (const [fileName, source] of entry?.assets ?? []) {
-						if (Object.hasOwn(bundle, fileName)) return this.error(entryCollisionMessage(fileName));
+						if (fileName === outputFilename || Object.hasOwn(bundle, fileName)) return this.error(entryCollisionMessage(fileName));
 						this.emitFile({
 							type: "asset",
 							fileName,
@@ -1894,7 +2183,12 @@ function tweeTsPlugin(options) {
 				record.addFiles(outputOptions, [...Object.keys(bundle), ...entry?.assets.keys() ?? []]);
 				let story;
 				try {
-					story = await compileStory(resolved.compile(entrySources(entry)), allOutputs(config), cache, true);
+					const entryFiles = entryPath === void 0 ? [] : [
+						entryPath,
+						...entry?.files ?? [],
+						...entryInputs.get(this.environment.getTopLevelConfig())?.() ?? []
+					].filter((id) => !id.startsWith("\0"));
+					story = await compileStory(resolved.compile(entrySources(entry)), configOutputs(config, record), cache, true, entryFiles);
 				} catch (e) {
 					return this.error(fatalError(e));
 				}
@@ -1906,6 +2200,11 @@ function tweeTsPlugin(options) {
 				});
 			}
 		},
+		writeBundle(outputOptions, bundle) {
+			const story = bundle[outputFilename];
+			const path = emittedFilePath(outputOptions, outputFilename);
+			if (story?.type === "asset" && path !== void 0) recordOwnOutput(path, story.source);
+		},
 		async configureServer(server) {
 			const route = await setUpDevStory(server, {
 				options: resolved,