@rohal12/twee-ts 1.18.1 → 2.0.0

package/dist/plugins/vite.cjs

@@ -0,0 +1,1926 @@
+/*! @rohal12/twee-ts (Unlicense). Bundles third-party code under its own licence: see THIRD_PARTY_NOTICES. */
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_diagnostic_text = require("../diagnostic-text-BRddVulf.cjs");
+const require_watch_targets = require("../watch-targets-C0Anuw17.cjs");
+let node_path = require("node:path");
+let node_fs = require("node:fs");
+let node_util = require("node:util");
+let vite = require("vite");
+//#region src/plugins/vite-glob.ts
+/**
+* The folders an entry's `import.meta.glob()` calls read. Vite replaces each call with the files that match it
+* when it bundles, so the bundle names those files and nothing else: a file added later that matches is in no
+* bundle's module list. To bundle again when the files a glob selects change, the plugin reads each call itself,
+* just before Vite's own import-glob transform does, and notes the folder below which it can match (its scope).
+*
+* 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.
+*
+* 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:
+* each `import.meta.glob(` in the text, with TypeScript type arguments allowed, is read on its own as a call.
+* Text in a comment or a string that reads as a call then adds a scope too, which only costs a bundle for nothing.
+*/
+/** A module, as the bundler hands it to a plugin's transform hook (the entry build's code is a module). */
+const MODULE_OPTIONS = {
+	ecmaVersion: "latest",
+	sourceType: "module",
+	allowHashBang: true
+};
+/** Whether `code` may hold a glob call, as Vite's import-glob filters the modules it reads. */
+function mayHoldGlob(code) {
+	return code.includes("import.meta.glob");
+}
+function isNode(value) {
+	return require_diagnostic_text.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) : [];
+		require_diagnostic_text.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";
+}
+/** The string a pattern argument spells: a string literal, or a template literal without expressions. */
+function stringOf(node) {
+	if (node === null) return void 0;
+	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;
+	}
+}
+/** 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");
+	return {
+		patterns,
+		base: typeof base === "string" ? base : void 0,
+		exhaustive: optionOf(options, "exhaustive") === true
+	};
+}
+/** Where Vite's import-glob finds a call in a module's text: the callee, any TypeScript type arguments, `(`. */
+const GLOB_CALL_START = /\bimport\.meta\.glob(?:<\w+>)?\s*\(/g;
+/**
+* The end (offset just past it) of the argument list that opens at `paren`, as acorn's tokenizer reads the text from
+* 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) {
+	const read = require_diagnostic_text.trySyntax(() => {
+		let depth = 0;
+		for (const token of require_diagnostic_text.AcornParser.tokenizer(code.slice(paren), MODULE_OPTIONS)) {
+			if (token.type === require_diagnostic_text.types$1.parenL) depth += 1;
+			else if (token.type === require_diagnostic_text.types$1.parenR) depth -= 1;
+			if (depth === 0) return paren + token.end;
+		}
+	});
+	return read.ok ? read.value : void 0;
+}
+/** `text` read as one expression, which must take all of it; undefined when acorn reads it otherwise. */
+function wholeExpression(text, options) {
+	const read = require_diagnostic_text.trySyntax(() => require_diagnostic_text.AcornParser.parseExpressionAt(text, 0, options));
+	return read.ok && read.value.end === text.length ? read.value : void 0;
+}
+/**
+* The call whose callee starts at `start` and whose argument list opens at `paren`, read on its own, up to the end
+* 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);
+	if (end === void 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), {
+		...MODULE_OPTIONS,
+		preserveParens: true
+	});
+	if (list?.type !== "ParenthesizedExpression") return void 0;
+	const { expression } = list;
+	return callOf(expression.type === "SequenceExpression" ? expression.expressions : [expression]);
+}
+/** 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 = require_diagnostic_text.trySyntax(() => require_diagnostic_text.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: []
+	};
+	const calls = [];
+	const unreadable = [];
+	for (const match of code.matchAll(GLOB_CALL_START)) {
+		const call = callAt(code, match.index, match.index + match[0].length - 1);
+		if (call === void 0) unreadable.push(match.index);
+		else calls.push(call);
+	}
+	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 = /[^*?[\]{}()!+@\\]*$/;
+/** 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));
+}
+/**
+* The scope of the pattern `rest` below an absolute folder `dir` (as the file system spells it, so nothing in it
+* is taken for a wildcard): the folder its leading plain segments name (`..` included), whether the segments after
+* those reach below it, and the literal end of its last segment.
+*/
+function scopeOf(dir, rest, exhaustive) {
+	const segments = node_path.posix.normalize(rest).split("/");
+	const magic = segments.findIndex((segment) => MAGIC.test(segment));
+	const plain = magic === -1 ? segments.slice(0, -1) : segments.slice(0, magic);
+	const below = segments.slice(plain.length);
+	return {
+		dir: require_watch_targets.toPosix(plain.reduce((folder, segment) => (0, node_path.resolve)(folder, segment), dir)),
+		deep: below.length > 1 || below.some((segment) => segment.includes("**")),
+		dot: exhaustive || namesDot(below),
+		exhaustive,
+		suffix: (LITERAL_END.exec(below.at(-1) ?? "")?.[0] ?? "").toLowerCase()
+	};
+}
+/**
+* The scopes of the patterns of `call`, made in the module `importer` (a file path, or undefined for a virtual
+* module) under `root`, as Vite's import-glob places them: `/` from the root, `./` and `../` from the importer's
+* folder or the `base` option, `**` from the root, and anything else (an alias, a `#` import) as the resolver
+* resolves it. A negated pattern only takes files away, and has none.
+*/
+async function scopesOf(call, importer, root, resolver) {
+	const folder = importer === void 0 ? root : (0, node_path.dirname)(importer);
+	const from = call.base === void 0 ? folder : call.base.startsWith("/") ? (0, node_path.join)(root, call.base) : (0, node_path.resolve)(folder, call.base);
+	const scopes = [];
+	for (const pattern of call.patterns) {
+		if (pattern.startsWith("!")) continue;
+		if (pattern.startsWith("/")) scopes.push(scopeOf(root, pattern.slice(1), call.exhaustive));
+		else if (pattern.startsWith("./") || pattern.startsWith("../")) scopes.push(scopeOf(from, pattern, call.exhaustive));
+		else if (pattern.startsWith("**")) scopes.push(scopeOf(root, pattern, call.exhaustive));
+		else {
+			const resolved = await resolver(pattern);
+			if (resolved === void 0 || !(0, node_path.isAbsolute)(resolved)) continue;
+			const spelled = require_watch_targets.toPosix(resolved);
+			let shared = 0;
+			while (shared < Math.min(spelled.length, pattern.length) && spelled.at(-1 - shared) === pattern.at(-1 - shared)) shared += 1;
+			const cut = spelled.lastIndexOf("/", spelled.length - shared);
+			scopes.push(scopeOf(spelled.slice(0, Math.max(cut, 0)) || "/", spelled.slice(cut + 1), call.exhaustive));
+		}
+	}
+	return scopes;
+}
+/** A key that is the same for two equal scopes. */
+function scopeId(scope) {
+	return JSON.stringify([
+		scope.dir,
+		scope.deep,
+		scope.dot,
+		scope.exhaustive,
+		scope.suffix
+	]);
+}
+/**
+* Whether an entry named `name` of a folder in the scope may be matched, or, for a folder, lead to a match. The
+* temporary copies Vite makes of a config file never are: they come and go with every entry build.
+*/
+function admits(scope, name, isDir) {
+	if (name.startsWith(".") && !scope.dot || require_watch_targets.isViteConfigTemp(name)) return false;
+	if (isDir) return scope.deep && (scope.exhaustive || name !== "node_modules");
+	return name.toLowerCase().endsWith(scope.suffix);
+}
+/** The real path (forward slashes) of the folder the link at `path` leads to; undefined for a link to anything else. */
+function linkedFolder(path) {
+	try {
+		return (0, node_fs.statSync)(path).isDirectory() ? require_watch_targets.canonicalPath(path) : void 0;
+	} catch {
+		return;
+	}
+}
+/**
+* What is in a scope: the files of its folder that `admits` lets through, and for a deep scope the folders below
+* it and theirs. A link to a folder is followed, as Vite's import-glob follows it, and listed with its target, so
+* retargeting it shows; a folder already listed (a link back to a folder above, or a second link to one) is not
+* listed again, as Vite's crawler does not crawl it again. A link to a file is listed as a file. A scope whose folder
+* does not exist (yet) lists as missing.
+*/
+function readScope(scope) {
+	const entries = [];
+	const linked = /* @__PURE__ */ new Set();
+	const visited = /* @__PURE__ */ new Set();
+	const list = (dir, prefix) => {
+		let found;
+		try {
+			found = (0, node_fs.readdirSync)(dir, { withFileTypes: true });
+		} catch {
+			return false;
+		}
+		visited.add(require_watch_targets.fileKey(dir));
+		for (const entry of found.sort((a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : 0)) {
+			const path = `${prefix}${entry.name}`;
+			const target = entry.isSymbolicLink() ? linkedFolder((0, node_path.join)(dir, entry.name)) : void 0;
+			const isDir = entry.isDirectory() || target !== void 0;
+			if (!admits(scope, entry.name, isDir)) continue;
+			entries.push(target === void 0 ? `${isDir ? "d" : "f"}:${path}` : `l:${path}>${target}`);
+			if (target !== void 0) {
+				if (visited.has(require_watch_targets.fileKey(target))) continue;
+				linked.add(target);
+			}
+			if (isDir) list((0, node_path.join)(dir, entry.name), `${path}/`);
+		}
+		return true;
+	};
+	return {
+		listing: list(scope.dir, "") ? entries.join("\n") : "\0missing",
+		linked: [...linked]
+	};
+}
+/**
+* Whether adding or removing the file (or folder, `isDir`) at `path` may change what the glob of `scope` matches:
+* it is in the scope, or in one of the folders it reaches through links (`linked`, see readScope), and `admits`
+* lets it through, or it is one of those folders itself. Folders are compared by identity key, so one is
+* recognised however the path spells it, through a link or not.
+*/
+function scopeAdmits(scope, path, isDir, linked) {
+	const folders = [scope.dir, ...scope.deep ? linked : []].map(require_watch_targets.fileKey);
+	if (folders.includes(require_watch_targets.fileKey(path))) return true;
+	const parent = require_watch_targets.fileKey((0, node_path.dirname)(path));
+	return (scope.deep ? require_watch_targets.keyWithin(parent, folders) : parent === folders[0]) && admits(scope, (0, node_path.basename)(path), isDir);
+}
+/**
+* The folders a watcher watches for `scopes`: each scope's folder, or, for one that does not exist, the nearest
+* folder above it that does, where creating it shows; and the folders a deep scope reaches through links, which a
+* watcher of the scope's folder may not follow.
+*/
+function scopeWatchTargets(scopes) {
+	return [...new Set([...scopes].flatMap((scope) => [require_watch_targets.toPosix(require_watch_targets.missingImportFolders([scope.dir])[0] ?? scope.dir), ...readScope(scope).linked]))];
+}
+/**
+* The file `pattern` (an alias or a `#` import, not a path) resolves to from `importer`, asked as Vite's
+* import-glob asks; undefined when it resolves to none, or the resolver fails (Vite's import-glob then reports
+* the pattern itself).
+*/
+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, "");
+	} catch {
+		return;
+	}
+}
+/**
+* The scopes of the glob calls in a module's code, read in a plugin's transform hook, whose `context` resolves an
+* alias or `#` pattern as Vite's import-glob would; a call acorn cannot read is reported with a warning and has
+* none.
+*/
+async function moduleGlobScopes(context, code, id, root) {
+	if (!mayHoldGlob(code)) return [];
+	const { calls, unreadable } = 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 file = id.replace(/[?#].*$/s, "");
+	const importer = (0, node_path.isAbsolute)(file) && !id.startsWith("\0") ? file : void 0;
+	const resolver = (pattern) => resolveGlob(context, pattern, id);
+	return (await Promise.all(calls.map((call) => scopesOf(call, importer, root, resolver)))).flat();
+}
+//#endregion
+//#region src/plugins/vite-entry.ts
+/**
+* Bundling the Vite plugin's `entry` into one script and one stylesheet for the
+* story. In a build, the plugin bundles the entry inside the user's build when
+* it can (see entryInputSettings), and otherwise, and always in dev, with a
+* build of its own: bundleEntry() below, which replays the user's configuration.
+*/
+/** The plugin's name, which is also how the entry build tells it from the user's other plugins. */
+const PLUGIN_NAME = "twee-ts";
+/** Passage names the bundled entry takes inside the story. */
+const ENTRY_SCRIPT_NAME = "twee-ts-entry.js";
+const ENTRY_STYLE_NAME = "twee-ts-entry.css";
+/** How the name of the entry's input starts when the plugin bundles it inside the user's build. */
+const ENTRY_INPUT_NAME = "twee-ts-entry";
+/** The error for a file the entry emits under a name the build (or another story's entry) already writes. */
+function entryCollisionMessage(fileName) {
+	return `twee-ts: the entry emits ${fileName}, a file the build already writes; rename one of them.`;
+}
+/** The entry's script and stylesheet as inline sources of the story (none without an entry). */
+function entrySources(entry) {
+	if (entry === void 0) return [];
+	return [{
+		filename: ENTRY_SCRIPT_NAME,
+		content: `;${entry.script}`
+	}, ...entry.style === "" ? [] : [{
+		filename: ENTRY_STYLE_NAME,
+		content: entry.style
+	}]];
+}
+/**
+* The output options of the entry's bundle: one IIFE script, and assets under
+* their own names, so a build writes them where the dev server serves them.
+*/
+const ENTRY_OUTPUT = {
+	format: "iife",
+	entryFileNames: ENTRY_SCRIPT_NAME,
+	assetFileNames: "[name][extname]"
+};
+/**
+* The output options of the entry's bundle given the user's `output` option:
+* the user's own when it is one object, with the entry's format and file names
+* on top. An array of outputs describes the user's own files; none of them
+* applies to the entry.
+*/
+function entryOutput(userOutput) {
+	return userOutput === void 0 || Array.isArray(userOutput) ? { ...ENTRY_OUTPUT } : {
+		...userOutput,
+		...ENTRY_OUTPUT
+	};
+}
+/**
+* Settings that make every font and image the entry uses inline as a data URL,
+* and its CSS one stylesheet, so the story stays one file; only an import marked
+* `?no-inline` is still emitted separately.
+*/
+const ONE_FILE = {
+	cssCodeSplit: false,
+	assetsInlineLimit: () => true
+};
+/**
+* What `import.meta.url` stands for in the entry's script, given the story's output file name. The script runs
+* as a classic script inside the story page, where `import.meta` does not exist (the bundler leaves `{}.url`, so
+* `new URL(asset, import.meta.url)` and Vite's worker URLs throw `Invalid URL`). The files the build writes
+* besides the story, such as an asset marked `?no-inline`, are found from the output folder the story is below,
+* so the base is the story page's URL, taken up one level for each folder of a nested `outputFilename`.
+*/
+function entryDefine(outputFilename) {
+	const depth = folderDepth(outputFilename);
+	return { "import.meta.url": depth === 0 ? "document.baseURI" : `new URL(${JSON.stringify("../".repeat(depth))}, document.baseURI).href` };
+}
+/** How many folders deep `outputFilename` puts the story below the output folder. */
+function folderDepth(outputFilename) {
+	return outputFilename.split("/").length - 1;
+}
+/**
+* The `experimental.renderBuiltUrl` of a build that bundles the entry, given the build's `base`, the story's
+* `outputFilename` and the configuration's own `renderBuiltUrl` (`user`, which decides first), or `user` itself
+* when nothing changes. With a relative `base` (`''` or `'./'`), Vite makes the URL of a file the build writes
+* besides the story (an asset marked `?no-inline`, a worker) relative to the script or stylesheet that names it.
+* The story page holds both inline, so such a URL resolves against the page, which a nested `outputFilename` puts
+* below the output folder the files are written to. For the entry's script, the URL is then resolved at run time
+* against the output folder, as `import.meta.url` is (see `entryDefine`); in its stylesheet, it is a path up from
+* the page. Every stylesheet of such a build is the entry's: the build bundles nothing else.
+*/
+function entryRenderBuiltUrl(base, outputFilename, user) {
+	const depth = folderDepth(outputFilename);
+	if (base !== "" && base !== "./" || depth === 0) return user;
+	const outputFolder = entryDefine(outputFilename)["import.meta.url"];
+	return (filename, type) => {
+		const own = user?.(filename, type);
+		if (own !== void 0) return own;
+		const path = filename.replaceAll("%", "%25");
+		if (type.hostType === "js" && type.hostId === ENTRY_SCRIPT_NAME) return { runtime: `new URL(${JSON.stringify(path)}, ${outputFolder}).href` };
+		return type.hostType === "css" ? `${"../".repeat(depth)}${path}` : void 0;
+	};
+}
+/**
+* Build settings that bundle the entry inside the user's build, as its only
+* input, under `inputName`, which tells the plugin instance it is its own, and
+* what the bundled script needs to run in the story (`define`).
+*/
+function entryInputSettings(inputName, entryPath, userOutput, outputFilename) {
+	return {
+		build: {
+			...ONE_FILE,
+			rolldownOptions: {
+				input: { [inputName]: entryPath },
+				output: entryOutput(userOutput)
+			}
+		},
+		define: entryDefine(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*$/, "");
+}
+/** A module id or watched file as a forward-slash file path, without a query or hash (like Vite's cleanUrl). */
+function fileOfId(id) {
+	return require_watch_targets.toPosix(id.replace(/[?#].*$/s, ""));
+}
+/** Removes a file from a bundle, which bundlers hand plugins as a plain object keyed by file name. */
+function removeFromBundle(bundle, fileName) {
+	delete bundle[fileName];
+}
+/**
+* Whether an asset is a file the entry imported as a URL (`theme.css?url`), not the stylesheet the bundler made
+* of the entry's CSS. The bundler names the files an asset came from; for its own stylesheet that is a bare
+* output name (`style.css`), for an imported file the file's path.
+*/
+function isImportedFile(item) {
+	return (item.originalFileNames ?? []).some((name) => (0, node_path.isAbsolute)(name) || node_path.win32.isAbsolute(name));
+}
+/**
+* Takes the entry out of a bundle: its entry chunk (the one named `inputName`,
+* when the entry is one input of the user's build; the only one, from the
+* entry's own build), every stylesheet it made of the entry's CSS (a CSS file imported as a URL stays an asset), and the map files, which the story
+* cannot ship. The chunk is found by its input's name, not by its module's
+* path, which the bundler may spell another way (a root reached through a
+* link is read by its real path). Anything else the bundler emitted for it
+* stays in the bundle, so a build writes it next to the HTML, and is also
+* returned, so the dev server can serve it.
+*/
+function takeEntryFromBundle(bundle, inputName) {
+	let script = "";
+	const files = /* @__PURE__ */ new Set();
+	const assets = /* @__PURE__ */ new Map();
+	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);
+		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));
+		removeFromBundle(bundle, fileName);
+	} else if (fileName.endsWith(".map")) removeFromBundle(bundle, fileName);
+	else assets.set(fileName, item.source);
+	return {
+		script,
+		style: styles.join("\n"),
+		files,
+		assets
+	};
+}
+/**
+* The entry build's logger: its warnings go to the outer logger; its progress
+* lines and its own "build failed" line are dropped, because the plugin
+* reports a failed bundle itself. (The progress lines Vite 8 prints itself are
+* kept quiet by the entry build's log level; see bundleEntry.)
+*/
+function entryBuildLogger(outer) {
+	return {
+		info: () => {},
+		warn: (message, options) => {
+			outer.warn(message, options);
+		},
+		warnOnce: (message, options) => {
+			outer.warnOnce(message, options);
+		},
+		error: () => {},
+		clearScreen: () => {},
+		hasErrorLogged: () => false,
+		get hasWarned() {
+			return outer.hasWarned;
+		}
+	};
+}
+/**
+* The entry build's log level: no progress lines (Vite 8 prints those itself
+* at `info`), and no more than the outer build or server shows.
+*/
+function entryBuildLogLevel(outer) {
+	return outer === void 0 || outer === "info" ? "warn" : outer;
+}
+/**
+* Top-level keys of the user's configuration the entry build doesn't take, and
+* why. Everything else (define, resolve, css, json, esbuild/oxc, env options,
+* base, assetsInclude, worker, build options, environments, experimental and
+* the rest) comes across as the user gave it, so the entry bundles the same in
+* dev as in a build.
+*/
+const ENTRY_BUILD_EXCLUDED_KEYS = {
+	configFile: "the entry build is given the loaded config file itself",
+	plugins: "replaced by the same plugins without twee-ts, plus the entry build’s own",
+	root: "set to the resolved root",
+	mode: "set to the resolved mode",
+	logLevel: "set so the entry build prints no progress lines",
+	customLogger: "the entry build reports through the outer logger",
+	clearScreen: "the entry build never clears the screen",
+	publicDir: "set to the outer build’s resolved public directory, which the entry build resolves from but never copies",
+	server: "configures the dev server, not a build",
+	preview: "configures the preview server, not a build",
+	builder: "would build every environment instead of the entry",
+	devtools: "starts Vite’s devtools integration, which belongs to the outer server or build"
+};
+/** The user's configuration without the keys the entry build doesn't take. */
+function withoutExcludedKeys(config) {
+	const copy = { ...config };
+	for (const key of Object.keys(ENTRY_BUILD_EXCLUDED_KEYS)) Reflect.deleteProperty(copy, key);
+	return copy;
+}
+/** A plugin option (nested arrays, promises, falsy entries) as one flat list. */
+async function flattenPlugins(option) {
+	const value = await option;
+	if (Array.isArray(value)) return (await Promise.all(value.map(flattenPlugins))).flat();
+	return value ? [value] : [];
+}
+function isPlugin(value) {
+	return require_diagnostic_text.isRecord(value) && typeof value["name"] === "string";
+}
+/** The handler of a plugin hook in function or object form. */
+function hookHandler(hook) {
+	return require_diagnostic_text.isRecord(hook) ? hook["handler"] : hook;
+}
+/** A hook with its handler replaced, keeping the object form's order and other fields. */
+function withHandler(hook, handler) {
+	return require_diagnostic_text.isRecord(hook) ? {
+		...hook,
+		handler
+	} : handler;
+}
+/**
+* Whether Vite applies `plugin` for `command`: as Vite reads `apply`, with
+* the configuration and environment the plugin would see.
+*/
+function appliesTo(plugin, command, config, env) {
+	const { apply } = plugin;
+	if (apply === void 0) return true;
+	if (typeof apply === "function") return apply({
+		...config,
+		mode: env.mode
+	}, env);
+	return apply === command;
+}
+/**
+* `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.
+*/
+function asEntryBuildPlugin(plugin, command) {
+	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 handler = hookHandler(hook);
+			if (typeof handler !== "function") return;
+			overrides.set(name, withHandler(hook, function(...args) {
+				return Reflect.apply(handler, this, patch(args));
+			}));
+		};
+		wrap("config", ([config, env]) => [config, devEnv(env)]);
+		wrap("configEnvironment", ([name, config, env]) => [
+			name,
+			config,
+			devEnv(env)
+		]);
+		wrap("configResolved", ([config]) => [require_diagnostic_text.isRecord(config) ? withOverrides(config, /* @__PURE__ */ new Map([["command", command]])) : config]);
+	}
+	return pluginWith(plugin, overrides);
+}
+/**
+* A copy of `plugin` with some properties of its own reading differently; the plugin itself is left untouched. The
+* copy has the plugin's prototype (a class's methods and getters) and each of its own properties as they are
+* defined (a getter stays a getter), so a frozen plugin, or one whose hooks are getters, is copied as well: a Proxy
+* may not answer differently for a property a frozen object defines. The copy stands in for the plugin wherever
+* the plugin list has it.
+*/
+function pluginWith(plugin, overrides) {
+	const copy = { ...plugin };
+	const layer = {};
+	Object.setPrototypeOf(layer, Reflect.getPrototypeOf(plugin));
+	for (const [key, value] of overrides) Object.defineProperty(layer, key, {
+		value,
+		writable: true,
+		enumerable: false,
+		configurable: true
+	});
+	Object.setPrototypeOf(copy, layer);
+	for (const key of Reflect.ownKeys(plugin)) {
+		const descriptor = Object.getOwnPropertyDescriptor(plugin, key);
+		if (descriptor !== void 0 && !overrides.has(key)) Object.defineProperty(copy, key, descriptor);
+	}
+	for (const [key, value] of overrides) Object.defineProperty(copy, key, {
+		value,
+		writable: true,
+		enumerable: true,
+		configurable: true
+	});
+	return copy;
+}
+/** `target` with some properties reading differently; the object itself is left untouched. */
+function withOverrides(target, overrides) {
+	return new Proxy(target, { get(object, key, receiver) {
+		return overrides.has(key) ? overrides.get(key) : Reflect.get(object, key, receiver);
+	} });
+}
+/**
+* Build settings that make the entry the build's one input and its bundle one
+* script and one stylesheet held in memory, whatever the user's build settings
+* say; for the dev command also unminified, with an inline source map. Settings
+* that would build something else (`lib`, `ssr`) or write files are dropped.
+*/
+function entryBuildSettings(userBuild, entryPath, command) {
+	const { lib: _lib, ssr: _ssr, rollupOptions, rolldownOptions, ...rest } = { ...userBuild };
+	const { input: _input, output, ...bundler } = rolldownOptions ?? rollupOptions ?? {};
+	return {
+		...rest,
+		...ONE_FILE,
+		write: false,
+		watch: null,
+		emptyOutDir: false,
+		copyPublicDir: false,
+		...command === "serve" ? {
+			minify: false,
+			sourcemap: "inline"
+		} : {},
+		rolldownOptions: {
+			...bundler,
+			input: entryPath,
+			output: entryOutput(output)
+		}
+	};
+}
+/**
+* Applies entryBuildSettings last, after every config hook, in the
+* configuration and in the client environment's own options (which the build
+* reads), so no setting from the user or a plugin makes the entry build build
+* or write anything else.
+*/
+function entryBuildEnforcer(entryPath, command, outputFilename) {
+	return {
+		name: `${PLUGIN_NAME}:entry-build`,
+		enforce: "post",
+		config: {
+			order: "post",
+			handler(config) {
+				config.build = entryBuildSettings(config.build, entryPath, command);
+				config.define = {
+					...config.define,
+					...entryDefine(outputFilename)
+				};
+				const renderBuiltUrl = entryRenderBuiltUrl(config.base, outputFilename, config.experimental?.renderBuiltUrl);
+				if (renderBuiltUrl !== void 0) config.experimental = {
+					...config.experimental,
+					renderBuiltUrl
+				};
+			}
+		},
+		configEnvironment: {
+			order: "post",
+			handler(name, config) {
+				if (name !== "client") return;
+				config.build = entryBuildSettings(config.build, entryPath, command);
+				config.define = {
+					...config.define,
+					...entryDefine(outputFilename)
+				};
+			}
+		}
+	};
+}
+/** Build-phase plugin hooks that may call `this.addWatchFile`. */
+const WATCH_FILE_HOOKS = [
+	"buildStart",
+	"resolveId",
+	"resolveDynamicImport",
+	"load",
+	"transform",
+	"moduleParsed",
+	"buildEnd"
+];
+/** A plugin context whose `addWatchFile` also passes the file to `record`. */
+function recordingContext(context, record) {
+	return new Proxy(context, { get(target, key) {
+		const value = Reflect.get(target, key, target);
+		if (typeof value !== "function") return value;
+		if (key !== "addWatchFile") return value.bind(target);
+		return (id) => {
+			if (typeof id === "string" && !id.startsWith("\0")) record(fileOfId((0, node_path.resolve)(id)));
+			return Reflect.apply(value, target, [id]);
+		};
+	} });
+}
+/**
+* `plugin` with hooks that pass the file of each of its `addWatchFile` calls to `record`. The
+* original stays untouched, so a plugin object shared across entry builds
+* never collects wrappers. A plugin without such hooks (a built-in one, for
+* instance) is returned as it is.
+*/
+function recordingPlugin(plugin, record) {
+	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 context = typeof this === "object" && this !== null ? recordingContext(this, record) : this;
+			return Reflect.apply(handler, context, args);
+		}));
+	}
+	return overrides.size === 0 ? plugin : pluginWith(plugin, overrides);
+}
+const isFile = (path) => (0, node_fs.statSync)(path, { throwIfNoEntry: false })?.isFile() === true;
+/** How an import is resolved with its links kept (see keptPath), one resolver per configuration. */
+const keptResolvers = /* @__PURE__ */ new WeakMap();
+/**
+* Makes keptPath resolve with a new resolver for `config`: Vite's resolver remembers what it found, which a build of
+* `vite build --watch` must not take from the one before.
+*/
+function forgetKeptResolver(config) {
+	keptResolvers.delete(config);
+}
+/**
+* The file `source`, imported by `importer`, reaches as Vite's resolver finds it, with the links on the way kept
+* (`resolve.preserveSymlinks`): the path through a linked file, folder or package folder, which the module's own
+* (real) path never shows. It follows every spelling Vite's resolver reads: relative and absolute paths, the root's
+* `/`, missing extensions, a folder's index, `resolve.alias`, bare package names, a package's subpaths and exports,
+* `#` subpath imports and `resolve.tsconfigPaths`. Undefined for an import it resolves to no file (a virtual module,
+* an external one, one it cannot resolve), or when resolving fails, which the bundle itself then reports.
+*/
+async function keptPath(context, source, importer) {
+	const { environment } = context;
+	let resolver = keptResolvers.get(environment.config);
+	if (resolver === void 0) {
+		resolver = (0, vite.createIdResolver)(environment.config, { preserveSymlinks: true });
+		keptResolvers.set(environment.config, resolver);
+	}
+	try {
+		const id = await resolver(environment, source, importer);
+		return id === void 0 || id.startsWith("\0") ? void 0 : fileOfId(id);
+	} catch {
+		return;
+	}
+}
+/**
+* The paths an import of `source` by `importer` is written as, absolute and with forward slashes, when it is written
+* as a path: relative to the importer, or absolute; also when that reaches nothing yet, so creating it shows. None for
+* a bare name or an alias. An absolute path that starts with `/` is read as Vite reads it: from the root first, unless
+* it already names a path inside the root, and as a path of the file system when that is where it reaches a file.
+*/
+function writtenPaths(source, importer, root) {
+	const from = importer === void 0 ? void 0 : fileOfId(importer);
+	if ((0, node_path.isAbsolute)(source)) {
+		const file = fileOfId(source);
+		return [.../^[/\\]/.test(source) && !file.startsWith(`${require_watch_targets.toPosix(root).replace(/\/$/, "")}/`) && !(0, node_fs.existsSync)(file) ? [fileOfId((0, node_path.join)(root, source))] : [], file];
+	}
+	return from !== void 0 && (0, node_path.isAbsolute)(from) && /^\.\.?(?:[/\\]|$)/.test(source) ? [fileOfId((0, node_path.resolve)((0, node_path.dirname)(from), source))] : [];
+}
+/**
+* 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.
+*/
+async function importSpellings(context, source, importer, root) {
+	if (source.startsWith("\0") || (importer?.startsWith("\0") ?? false)) return {
+		spellings: [],
+		kept: void 0
+	};
+	const written = writtenPaths(source, importer, root);
+	const resolved = written.find(isFile) ?? await keptPath(context, source, importer);
+	const kept = resolved !== void 0 && (0, node_path.isAbsolute)(resolved) ? resolved : void 0;
+	return {
+		spellings: [.../* @__PURE__ */ new Set([...written, ...kept === void 0 ? [] : [kept]])],
+		kept
+	};
+}
+/**
+* Collects the files the entry build's plugins add with `addWatchFile`. These
+* are not modules of the bundle: Vite's CSS plugin adds the stylesheets pulled
+* in by `@import` and the files `url()` points at this way. The build runs on
+* recording stand-ins of its plugins, made in the bundler's `options` hook,
+* which sees the final plugin list, including the plugins Vite resolves per
+* environment (`applyToEnvironment`) after `configResolved`.
+*/
+function recordWatchFiles(files, root, observer) {
+	const { onLoad, onResolve, onGlob, onWatchFile } = observer;
+	const record = (file) => {
+		files.add(file);
+		onWatchFile?.(file);
+	};
+	return {
+		name: `${PLUGIN_NAME}:record-watch-files`,
+		load: {
+			order: "pre",
+			handler(id) {
+				const file = fileOfId(id);
+				if (!(0, node_path.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 ((0, node_path.isAbsolute)(file)) files.add(file);
+			}
+		},
+		options: {
+			order: "post",
+			async handler(inputOptions) {
+				const plugins = (await flattenPlugins(inputOptions.plugins)).filter(isPlugin).map((p) => recordingPlugin(p, record));
+				return {
+					...inputOptions,
+					plugins
+				};
+			}
+		}
+	};
+}
+/**
+* `worker` with `plugin()` after its own `worker.plugins`, which Vite calls for each worker build (nested ones
+* too); the user's plugins come first, in their order, whether given as a function or as the list older Vite
+* versions took.
+*/
+function withWorkerPlugin(worker, plugin) {
+	const own = worker?.plugins;
+	return {
+		...worker,
+		plugins: () => [typeof own === "function" ? own() : own, plugin()]
+	};
+}
+/**
+* The user's own configuration as Vite evaluated it for the outer server or
+* build, but for `command`: the config file (when there is one) evaluated
+* again for that command and mode, with what was passed to `createServer()` or
+* `build()` (or the CLI flags) on top, as Vite merges them.
+*/
+async function userConfigFor(config, env) {
+	const inline = config.inlineConfig;
+	if (!config.configFile) return inline;
+	const loaded = await (0, vite.loadConfigFromFile)(env, config.configFile, config.root, entryBuildLogLevel(config.logLevel), entryBuildLogger(config.logger), inline.configLoader);
+	return loaded === null ? inline : (0, vite.mergeConfig)(loaded.config, inline);
+}
+/**
+* Bundles the entry with a Vite build of its own, from the user's own
+* configuration, evaluated for `command`: the config file's function and each
+* plugin's `apply` see that command, and so do the `config`, `configEnvironment`
+* and `configResolved` hooks of the user's plugins. Every setting comes across
+* but those ENTRY_BUILD_EXCLUDED_KEYS lists and the build settings
+* entryBuildSettings decides. twee-ts itself (every instance) is left out.
+*/
+async function bundleEntry(config, entryPath, command, outputFilename, observer = {}) {
+	const watchFiles = observer.watchFiles ?? /* @__PURE__ */ new Set();
+	const env = {
+		command,
+		mode: config.mode,
+		isSsrBuild: false,
+		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 inline = {
+		...withoutExcludedKeys(user),
+		configFile: false,
+		root: config.root,
+		mode: config.mode,
+		logLevel: entryBuildLogLevel(config.logLevel),
+		customLogger: entryBuildLogger(config.logger),
+		clearScreen: false,
+		publicDir: config.publicDir || false,
+		plugins: [
+			...plugins,
+			entryBuildEnforcer(entryPath, command, outputFilename),
+			recordWatchFiles(watchFiles, config.root, observer)
+		],
+		worker: withWorkerPlugin(user.worker, () => recordWatchFiles(watchFiles, config.root, observer))
+	};
+	const [result] = [await (0, vite.build)(inline)].flat();
+	if (result === void 0 || !("output" in result)) throw new Error("twee-ts: the entry build returned no bundle.");
+	const entry = takeEntryFromBundle(Object.fromEntries(result.output.map((item) => [item.fileName, item])));
+	return {
+		...entry,
+		files: /* @__PURE__ */ new Set([...entry.files, ...watchFiles])
+	};
+}
+//#endregion
+//#region src/plugins/vite-dev.ts
+/** How long after a change the story is compiled, so saves landing together compile once. */
+const DEBOUNCE_MS = 50;
+/**
+* How long a file the watcher was asked to add may take to be listed as watched, and how long after that its
+* watch may still miss an edit (macOS FSEvents starts reporting a moment after the watch is set up); see
+* `recheckOnceWatched` in setUpDevStory.
+*/
+const WATCH_LISTED_TIMEOUT_MS = 1e4;
+const WATCH_START_MS = 500;
+/** Resolves after `ms`, without keeping the process alive. */
+function delay(ms) {
+	return new Promise((done) => setTimeout(done, ms).unref());
+}
+/**
+* The paths under the base URL the story is served at: the output file name,
+* and, as a static host serves it, the folder of an `index.html`.
+*/
+function storyPaths(outputFilename) {
+	const index = "index.html";
+	return outputFilename === index || outputFilename.endsWith(`/${index}`) ? [outputFilename, outputFilename.slice(0, -10)] : [outputFilename];
+}
+/**
+* `path` (a decoded URL path below the base, with no leading slash) as one spelling: a backslash is a slash, as in
+* an http URL, a `.` segment is dropped and a `..` segment drops the one before it, as the URL standard resolves
+* them (a last `.` or `..` leaves a trailing slash), and empty segments (`a//b`) are dropped, as Vite's file
+* middlewares and static hosts drop them. A `..` never leaves the base.
+*/
+function oneSpelling(path) {
+	const segments = path.replaceAll("\\", "/").split("/");
+	const kept = [];
+	segments.forEach((segment, at) => {
+		const last = at === segments.length - 1;
+		if (segment === "..") kept.pop();
+		if (segment !== "" && segment !== "." && segment !== "..") kept.push(segment);
+		else if (last) kept.push("");
+	});
+	return kept.join("/");
+}
+/**
+* A request URL's path below `base`, decoded, without query or hash, and with its dot segments, empty segments and
+* backslashes resolved (see oneSpelling), so that every spelling of the story's path is the story (#401); undefined
+* when the path is outside the base or is not a valid percent-encoding.
+*/
+function pathBelowBase(url, base) {
+	const raw = url.replace(/[?#].*$/s, "");
+	let path;
+	let decodedBase;
+	try {
+		path = decodeURIComponent(raw);
+		decodedBase = decodeURIComponent(base);
+	} catch {
+		return;
+	}
+	return path.startsWith(decodedBase) ? oneSpelling(path.slice(decodedBase.length)) : void 0;
+}
+/** The reload message for a rebuilt story: limited to the story's pages unless Vite's client could not match them. */
+function reloadPayload(base, outputFilename) {
+	let decoded;
+	try {
+		decoded = decodeURI(base);
+	} catch {
+		return { type: "full-reload" };
+	}
+	return decoded === base ? {
+		type: "full-reload",
+		path: `/${outputFilename}`
+	} : { type: "full-reload" };
+}
+/** The media type of the story as each output mode writes it. */
+const OUTPUT_MEDIA_TYPES = {
+	html: "text/html; charset=utf-8",
+	"twine2-archive": "text/html; charset=utf-8",
+	"twine1-archive": "text/html; charset=utf-8",
+	twee3: "text/plain; charset=utf-8",
+	twee1: "text/plain; charset=utf-8",
+	json: "application/json; charset=utf-8"
+};
+/** Served until the first successful compile, so the overlay has a page to appear on. */
+function waitingPage(base) {
+	return require_diagnostic_text.viteWaitingPage(`${base}@vite/client`);
+}
+function toOverlayError(e) {
+	const error = require_watch_targets.fatalError(e);
+	return {
+		message: (0, node_util.stripVTControlCharacters)(error.message),
+		stack: "",
+		plugin: PLUGIN_NAME,
+		...error.id ? { id: error.id } : {},
+		...error.loc ? { loc: error.loc } : {}
+	};
+}
+/**
+* Media types of the files a bundle emits that Tweego's table of story media does not have: a browser
+* refuses a worker or stylesheet served as `application/octet-stream`.
+*/
+const BUNDLE_MEDIA_TYPES = /* @__PURE__ */ new Map([
+	["js", "text/javascript"],
+	["mjs", "text/javascript"],
+	["css", "text/css"],
+	["json", "application/json"],
+	["map", "application/json"],
+	["wasm", "application/wasm"],
+	["html", "text/html; charset=utf-8"],
+	["txt", "text/plain; charset=utf-8"]
+]);
+/** The media type the dev server gives an asset of the entry's bundle. */
+function assetMediaType(path) {
+	return BUNDLE_MEDIA_TYPES.get(require_diagnostic_text.normalizedFileExt(path)) ?? require_diagnostic_text.mediaTypeFromFilename(path);
+}
+/**
+* What a change to a file alters: modification time, change time (which an in-place edit that restores the
+* modification time still moves, as the loader's file signature relies on), size and inode (a file replaced by a
+* new one).
+*/
+function fileState(file) {
+	try {
+		const stat = (0, node_fs.statSync)(file);
+		return `${stat.mtimeMs}:${stat.ctimeMs}:${stat.size}:${stat.ino}`;
+	} catch {
+		return;
+	}
+}
+/**
+* What is in the folder `folder`, at any depth: the name and state (see fileState) of each file and folder in it,
+* links to folders not followed. A file added, removed, renamed or changed anywhere in it changes this, as it
+* makes the bundler's own watcher (`vite build --watch`) build again for a folder a plugin watches. undefined when
+* `folder` is not a folder.
+*/
+function folderState(folder) {
+	if ((0, node_fs.statSync)(folder, { throwIfNoEntry: false })?.isDirectory() !== true) return void 0;
+	let names;
+	try {
+		names = (0, node_fs.readdirSync)(folder, {
+			recursive: true,
+			encoding: "utf8"
+		});
+	} catch {
+		return;
+	}
+	return names.sort().map((name) => `${name}\0${fileState((0, node_path.join)(folder, name)) ?? ""}`).join("\0");
+}
+/** `file` as it is now, as a FileRead; undefined when it can't be read. */
+function fileRead(file) {
+	const state = fileState(file);
+	if (state === void 0) return void 0;
+	try {
+		return {
+			state,
+			hash: require_diagnostic_text.sha256Hex((0, node_fs.readFileSync)(file))
+		};
+	} catch {
+		return;
+	}
+}
+/** `paths` as TrackedFiles. */
+function tracked(paths) {
+	return new Map([...paths].map((path) => [require_watch_targets.fileKey(path), require_watch_targets.canonicalPath(path)]));
+}
+/**
+* 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.
+* undefined for a path with no link in it, and for one that reaches nothing.
+*/
+function linkKey(authored) {
+	if (!(0, node_fs.existsSync)(authored)) return void 0;
+	return require_watch_targets.canonicalPath(authored) === require_watch_targets.toPosix((0, node_path.resolve)(authored)) ? void 0 : require_watch_targets.fileKey(authored);
+}
+/** The state of each of `files`, by key, for telling later which changed (see filesChanged). */
+function fileStates(files) {
+	const states = /* @__PURE__ */ new Map();
+	for (const [key, path] of files) {
+		const state = fileState(path);
+		if (state !== void 0) states.set(key, state);
+	}
+	return states;
+}
+/**
+* The states to compare later changes with, for the files a bundle was made from: each file as it was just
+* before the bundle read it (`observed`, noted as each module loads), else as it was before the bundle began
+* (`before`, for a file known from the last bundle), else as it is now. An edit while the bundle was made
+* then differs from the recorded state afterwards, and the next request makes the bundle again.
+*/
+function settledStates(files, observed, before) {
+	const states = /* @__PURE__ */ new Map();
+	for (const [key, path] of files) {
+		const state = observed.get(key) ?? before.get(key) ?? fileState(path);
+		if (state !== void 0) states.set(key, state);
+	}
+	return states;
+}
+/** The keys of the files added, removed or changed between two `fileStates` results. */
+function filesChanged(before, after) {
+	const changed = /* @__PURE__ */ new Set();
+	for (const [file, state] of after) if (before.get(file) !== state) changed.add(file);
+	for (const file of before.keys()) if (!after.has(file)) changed.add(file);
+	return changed;
+}
+/**
+* The names of Vite's middlewares that answer a request with a file: from the public folder, the module
+* transform, the files of the root and the file system, and the HTML fallback.
+*/
+const VITE_FILE_MIDDLEWARES = /* @__PURE__ */ new Set([
+	"viteServePublicMiddleware",
+	"viteTriggerLazyBundlingMiddleware",
+	"viteMemoryFilesMiddleware",
+	"viteTransformMiddleware",
+	"viteServeRawFsMiddleware",
+	"viteServeStaticMiddleware",
+	"viteHtmlFallbackMiddleware",
+	"viteIndexHtmlMiddleware"
+]);
+/**
+* Installs the story's route (see setUpDevStory) among `middlewares`, as the plugin's post hook does: after Vite's
+* checks of a request (host, CORS, proxy, base), so they apply to the story as to any page, and before the first
+* of its middlewares that serve files. A build writes the story and the entry's assets over a public file of the
+* same name, and a static host serves nothing else at their paths, so the dev server must not answer them with a
+* file from the public folder or the root (#339). Appended when none of those middlewares is there.
+*/
+function installStoryRoute(middlewares, route) {
+	const at = middlewares.stack.findIndex(({ handle }) => typeof handle === "function" && VITE_FILE_MIDDLEWARES.has(handle.name));
+	if (at === -1) middlewares.use(route);
+	else middlewares.stack.splice(at, 0, {
+		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 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.`;
+}
+function sameBytes(a, b) {
+	return Buffer.from(a).equals(Buffer.from(b));
+}
+/**
+* Sets up the story in `server`: the first compile, the watcher, and a
+* middleware that notes each request's URL before Vite's own middlewares
+* rewrite it. Resolves, after the first compile, to the middleware that serves
+* the story and the entry's assets, for installStoryRoute.
+*/
+async function setUpDevStory(server, dev) {
+	const { options, cache } = dev;
+	const config = server.config;
+	const { base } = config;
+	const paths = storyPaths(options.outputFilename);
+	const { inputs, excluded: excludedGlob } = options;
+	const entryPath = options.entry;
+	const root = require_watch_targets.fileKey(config.root);
+	const inputKeys = () => inputs.map(require_watch_targets.fileKey);
+	let outputs = dev.outputs(config);
+	let output = require_diagnostic_text.outputPaths(outputs);
+	const excluded = (file) => excludedGlob(file) || output.isOutput(file, inputs);
+	server.watcher.add([...inputs]);
+	const outputMode = options.compile().outputMode ?? "html";
+	let html = "";
+	let lastError;
+	let entry;
+	let servedAssets;
+	const instances = devInstances.get(server) ?? /* @__PURE__ */ new Set();
+	devInstances.set(server, instances);
+	const self = {
+		paths,
+		assets: () => servedAssets
+	};
+	instances.add(self);
+	const fail = (res, message) => {
+		config.logger.error(`[twee-ts] ${message}`);
+		res.statusCode = 500;
+		res.setHeader("Content-Type", "text/plain; charset=utf-8");
+		res.end(message);
+	};
+	let entryStale = true;
+	let entryFiles = /* @__PURE__ */ new Map();
+	let entryStates = /* @__PURE__ */ new Map();
+	let entryLinks = /* @__PURE__ */ new Map();
+	let entryMissingFolders = [];
+	let entryGlobs = /* @__PURE__ */ new Map();
+	let globStates = /* @__PURE__ */ new Map();
+	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 catchingUp;
+	const closeWatcher = server.watcher.close.bind(server.watcher);
+	server.watcher.close = async () => {
+		closed = true;
+		clearTimeout(timer);
+		pending.clear();
+		return closeWatcher();
+	};
+	const namedInputs = () => inputs.map((input) => {
+		const stat = (0, node_fs.statSync)(input, { throwIfNoEntry: false });
+		const kind = stat === void 0 ? "none" : stat.isFile() ? "file" : stat.isDirectory() ? "folder" : "other";
+		return `${require_watch_targets.fileKey(input)}\0${kind}`;
+	}).join("\0");
+	let inputWalk;
+	const walkInputs = () => {
+		const named = namedInputs();
+		const folders = /* @__PURE__ */ new Map();
+		const files = require_diagnostic_text.getFilenames(inputs, outputs, [], "source", (folder) => folders.set(folder, fileState(folder))).files.filter((file) => !excludedGlob(file.path)).map((file) => ({
+			key: file.key,
+			path: (0, node_path.resolve)(file.path),
+			link: file.link === true
+		}));
+		return {
+			outputs,
+			named,
+			folders,
+			files
+		};
+	};
+	const storyInputFiles = (walk) => {
+		const last = inputWalk;
+		const used = last !== void 0 && !walk && last.outputs === outputs && last.named === namedInputs() && [...last.folders].every(([folder, state]) => fileState(folder) === state) ? last : walkInputs();
+		inputWalk = used;
+		const states = /* @__PURE__ */ new Map();
+		for (const { key, path, link } of used.files) {
+			const state = fileState(path);
+			if (state !== void 0) states.set(link ? require_watch_targets.fileKey(path) : key, state);
+		}
+		return states;
+	};
+	const touchesEntry = (key) => entryPath !== void 0 && (entryFiles.has(key) || entryStale && require_watch_targets.keyWithin(key, [root, ...entryMissingFolders]));
+	const linkMoved = () => [...entryLinks].some(([spelled, key]) => linkKey(spelled) !== key);
+	const globsChanged = () => [...entryGlobs].some(([id, scope]) => readScope(scope).listing !== globStates.get(id)?.listing);
+	const foldersChanged = () => [...entryFolders.values()].some(({ path, state }) => folderState(path) !== state);
+	const inWatchedFolder = (path) => {
+		if (entryPath === void 0 || entryFolders.size === 0) return false;
+		const folders = [...entryFolders.keys()];
+		return require_watch_targets.keyWithin(require_watch_targets.fileKey(path), folders) || require_watch_targets.keyWithin(require_watch_targets.fileKey((0, node_path.dirname)(path)), folders);
+	};
+	const inGlobScope = (path, isDir) => [...entryGlobs].some(([id, scope]) => scopeAdmits(scope, path, isDir, globStates.get(id)?.linked ?? []));
+	const entryWatchTargets = () => new Map([...entryFiles, ...tracked(scopeWatchTargets(entryGlobs.values()))]);
+	const watchEntryFiles = (files) => {
+		const added = [...files].filter(([key]) => !require_watch_targets.keyWithin(key, [root]) && !require_watch_targets.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);
+		}
+	};
+	const isListed = (path) => {
+		return server.watcher.getWatched()[(0, node_path.dirname)(path)]?.includes((0, node_path.basename)(path)) ?? false;
+	};
+	const recheckOnceWatched = async (files) => {
+		if (config.server.watch === null) return;
+		const deadline = Date.now() + WATCH_LISTED_TIMEOUT_MS;
+		while (!closed && Date.now() < deadline && ![...files.values()].every(isListed)) await delay(DEBOUNCE_MS);
+		await delay(WATCH_START_MS);
+		if (closed) return;
+		queue = queue.then(() => {
+			const own = new Map([...files].filter(([key]) => entryFiles.has(key)));
+			const now = fileStates(own);
+			const then = new Map([...entryStates].filter(([key]) => own.has(key)));
+			for (const key of filesChanged(then, now)) if (watchedForEntry.has(key)) noteChange(key);
+			const [folder] = [...files.keys()].filter((key) => !own.has(key) && watchedForEntry.has(key));
+			if (folder !== void 0 && globsChanged()) noteChange(folder);
+			const [watched] = [...files.keys()].filter((key) => entryFolders.has(key) && watchedForEntry.has(key));
+			if (watched !== void 0 && foldersChanged()) noteChange(watched);
+		}).catch(keepQueueAlive);
+		await queue;
+	};
+	const bundle = async () => {
+		if (entryPath === void 0) return;
+		entryStale = true;
+		const spelled = /* @__PURE__ */ new Map();
+		const authoredPaths = /* @__PURE__ */ new Set();
+		const watchFiles = /* @__PURE__ */ new Set();
+		const noteSpelling = (authored) => {
+			authoredPaths.add(authored);
+			const key = linkKey(authored);
+			if (key !== void 0 && !spelled.has(authored)) spelled.set(authored, key);
+		};
+		noteSpelling(entryPath);
+		if (entry === void 0) {
+			entryFiles = tracked([entryPath]);
+			entryStates = fileStates(entryFiles);
+			watchEntryFiles(entryWatchTargets());
+		}
+		const globs = /* @__PURE__ */ new Map();
+		const globsRead = /* @__PURE__ */ new Map();
+		const globsBefore = new Map([...entryGlobs].map(([id, scope]) => [id, readScope(scope)]));
+		const folders = /* @__PURE__ */ new Map();
+		const before = fileStates(entryFiles);
+		const observed = /* @__PURE__ */ new Map();
+		const loaded = /* @__PURE__ */ new Map();
+		const reads = /* @__PURE__ */ new Map();
+		let next;
+		try {
+			next = await bundleEntry(config, entryPath, "serve", options.outputFilename, {
+				watchFiles,
+				onWatchFile: (file) => {
+					const key = require_watch_targets.fileKey(file);
+					if (folders.has(key)) return;
+					const path = require_watch_targets.canonicalPath(file);
+					const state = folderState(path);
+					if (state !== void 0) folders.set(key, {
+						path,
+						state
+					});
+				},
+				onLoad: (file) => {
+					const key = require_watch_targets.fileKey(file);
+					const read = readsModules ? fileRead(require_watch_targets.canonicalPath(file)) : void 0;
+					const state = read?.state ?? fileState(require_watch_targets.canonicalPath(file));
+					if (state !== void 0 && !observed.has(key)) observed.set(key, state);
+					if (read !== void 0 && !reads.has(key)) reads.set(key, read);
+					if (!loaded.has(key)) loaded.set(key, require_watch_targets.canonicalPath(file));
+				},
+				onResolve: noteSpelling,
+				onGlob: (scope) => {
+					const id = scopeId(scope);
+					if (globs.has(id)) return;
+					globs.set(id, scope);
+					globsRead.set(id, readScope(scope));
+				}
+			});
+		} catch (error) {
+			const missing = require_watch_targets.missingImportFolders(authoredPaths);
+			entryMissingFolders = missing.map(require_watch_targets.fileKey);
+			entryFiles = new Map([
+				...entryFiles,
+				...loaded,
+				...tracked(watchFiles),
+				...tracked(missing)
+			]);
+			entryStates = settledStates(entryFiles, observed, before);
+			entryLinks = new Map([...entryLinks, ...spelled]);
+			entryGlobs = new Map([...entryGlobs, ...globs]);
+			globStates = new Map([...globsBefore, ...globsRead]);
+			entryFolders = new Map([...entryFolders, ...folders]);
+			watchEntryFiles(entryWatchTargets());
+			throw error;
+		}
+		entry = next;
+		entryStale = false;
+		entryFiles = tracked(next.files);
+		entryStates = settledStates(entryFiles, observed, before);
+		entryLinks = spelled;
+		entryMissingFolders = [];
+		entryGlobs = globs;
+		globStates = globsRead;
+		entryFolders = folders;
+		entryReads = reads;
+		watchEntryFiles(entryWatchTargets());
+	};
+	const alreadyRead = (key) => {
+		const read = entryReads.get(key);
+		const path = entryFiles.get(key);
+		if (entryStale || require_watch_targets.keyWithin(key, inputKeys())) return false;
+		if (read === void 0 && !entryFiles.has(key) && require_watch_targets.keyWithin(key, [...entryFolders.keys()])) return !foldersChanged();
+		if (read === void 0 || path === void 0) return false;
+		const now = fileRead(path);
+		return now?.state === read.state && now.hash === read.hash;
+	};
+	const rebuild = async (changed, initial = false) => {
+		if (closed) return;
+		try {
+			const unread = [...changed].filter((key) => !alreadyRead(key));
+			const regrouped = linkMoved() || globsChanged() || foldersChanged();
+			if (changed.size > 0 && unread.length === 0 && !regrouped) return;
+			outputs = dev.outputs(config);
+			output = require_diagnostic_text.outputPaths(outputs);
+			compiledInputs = storyInputFiles(true);
+			for (const key of [...cache.keys()]) if (changed.has(require_watch_targets.fileKey(key))) cache.delete(key);
+			if (entryStale || regrouped || unread.some(touchesEntry)) await bundle();
+			const story = await require_watch_targets.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;
+			servedAssets = entry?.assets;
+			lastError = void 0;
+			if (!initial) server.ws.send(reloadPayload(base, options.outputFilename));
+		} catch (e) {
+			lastError = toOverlayError(e);
+			config.logger.error(`[twee-ts] ${lastError.message}`);
+			server.ws.send({
+				type: "error",
+				err: lastError
+			});
+		}
+	};
+	const keepQueueAlive = (e) => {
+		try {
+			config.logger.error(`[twee-ts] ${require_watch_targets.fatalError(e).message}`);
+		} catch {}
+	};
+	const noteChange = (changed) => {
+		if (closed) return;
+		pending.add(changed);
+		clearTimeout(timer);
+		timer = setTimeout(() => {
+			const files = pending;
+			pending = /* @__PURE__ */ new Set();
+			queue = queue.then(() => rebuild(files)).catch(keepQueueAlive);
+		}, DEBOUNCE_MS);
+	};
+	await rebuild(/* @__PURE__ */ new Set(), true);
+	server.watcher.on("all", (event, path) => {
+		if (require_watch_targets.isViteConfigTemp(path)) return;
+		const changed = require_watch_targets.fileKey(path);
+		const isDir = event === "addDir" || event === "unlinkDir";
+		const regrouped = event !== "change" && inGlobScope(path, isDir) || inWatchedFolder(path) || isDir && entryPath !== void 0 && entryFiles.has(changed);
+		if (event !== "add" && event !== "change" && event !== "unlink" && !regrouped) return;
+		if (!regrouped && (!require_watch_targets.keyWithin(changed, inputKeys()) || excluded(path)) && !touchesEntry(changed) && !linkMoved()) return;
+		noteChange(changed);
+	});
+	const catchUp = () => {
+		catchingUp ??= (async () => {
+			for (let waited = queue;; waited = queue) {
+				await waited;
+				if (queue === waited) break;
+			}
+			const changed = filesChanged(compiledInputs, storyInputFiles(false));
+			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);
+			pending = /* @__PURE__ */ new Set();
+			clearTimeout(timer);
+			queue = queue.then(() => rebuild(changed)).catch(keepQueueAlive);
+			await queue;
+		})().finally(() => {
+			catchingUp = void 0;
+		});
+		return catchingUp;
+	};
+	server.ws.on("connection", () => {
+		if (lastError) server.ws.send({
+			type: "error",
+			err: lastError
+		});
+	});
+	const requestUrls = /* @__PURE__ */ new WeakMap();
+	server.middlewares.use((req, _res, next) => {
+		requestUrls.set(req, String(req.url));
+		next();
+	});
+	const send = (req, res, type, body) => {
+		for (const [name, value] of Object.entries({ ...config.server.headers })) if (typeof value === "string" || typeof value === "number") res.setHeader(name, value);
+		else if (Array.isArray(value)) res.setHeader(name, value.map(String));
+		res.statusCode = 200;
+		res.setHeader("Content-Type", type);
+		res.setHeader("Content-Length", typeof body === "string" ? Buffer.byteLength(body) : body.byteLength);
+		res.setHeader("Cache-Control", "no-cache");
+		res.end(req.method === "HEAD" ? void 0 : body);
+	};
+	return (req, res, next) => {
+		if (req.method !== "GET" && req.method !== "HEAD") {
+			next();
+			return;
+		}
+		const path = pathBelowBase(String(requestUrls.get(req)), base);
+		if (path === void 0) {
+			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));
+			return;
+		}
+		if (paths.includes(path)) {
+			catchUp().then(() => {
+				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;
+			}
+		}
+		send(req, res, assetMediaType(path), asset);
+	};
+}
+//#endregion
+//#region src/plugins/vite.ts
+/**
+* Ready-made Vite plugin for twee-ts.
+*
+* Compiles Twee sources into the story HTML. With `entry`, Vite also bundles a
+* script, and the CSS it imports, into the story as its Story JavaScript and
+* Story Stylesheet.
+*
+* In dev the compiled HTML is served at the base URL with Vite's client added.
+* Every change to a source, the head file, a module or a file the entry was
+* bundled from recompiles it and reloads the page, and errors appear in Vite's
+* overlay (see vite-dev.ts). A build emits the story with the configured file
+* name, in the client environment only.
+*/
+/**
+* A build input that stands in when the user's config names none, so Vite does
+* not look for an index.html (whose page would replace the story). Its empty
+* chunk is dropped from the output.
+*/
+const EMPTY_INPUT = "virtual:twee-ts-empty-input";
+const RESOLVED_EMPTY_INPUT = "\0" + EMPTY_INPUT;
+/** The environment the story belongs to: the browser's. */
+const CLIENT = "client";
+/** Vite's plugin that bundles workers, and keeps their bundles between the builds of `vite build --watch`. */
+const VITE_WORKER_PLUGIN = "vite:worker";
+/** The plugin instances created so far, which numbers each instance's entry input. */
+let instances = 0;
+/** The bundler options of build settings: `rolldownOptions`, or the older name Vite 8 still reads. */
+function bundlerOptionsOf(build) {
+	if (!require_diagnostic_text.isRecord(build)) return void 0;
+	const options = build["rolldownOptions"] ?? build["rollupOptions"];
+	return require_diagnostic_text.isRecord(options) ? options : void 0;
+}
+/**
+* Whether a config (or an environment's options) names what the build builds:
+* a bundler input, Vite 8's top-level `input`, a library entry or an SSR entry.
+*/
+function namesInput(config) {
+	const build = Reflect.get(config, "build");
+	return Reflect.get(config, "input") !== void 0 || bundlerOptionsOf(build)?.["input"] !== void 0 || require_diagnostic_text.isRecord(build) && (Boolean(build["lib"]) || Boolean(build["ssr"]));
+}
+/** Build settings naming one input. */
+function inputOnly(input) {
+	return { rolldownOptions: { input } };
+}
+/**
+* Where a build with this config writes: each output's folder, the bundler's
+* `output.dir` or else `build.outDir`, or the bundler's `output.file`. Vite
+* resolves an `output.dir` against the root when it empties the folder and
+* copies the public files into it, while the bundler resolves it against the
+* working directory when it writes; both count.
+*/
+function configOutputLocations(config) {
+	const outDir = (0, node_path.resolve)(config.root, config.build.outDir);
+	const option = bundlerOptionsOf(config.build)?.["output"];
+	return (option === void 0 ? [{}] : Array.isArray(option) ? option : [option]).flatMap((output) => {
+		const [location] = require_watch_targets.outputLocations(output);
+		if (location === void 0) return [{ dir: outDir }];
+		if (location.dir === void 0) return [location];
+		return [{ dir: (0, node_path.resolve)(location.dir) }, { dir: (0, node_path.resolve)(config.root, location.dir) }];
+	});
+}
+/**
+* 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).
+*/
+function configOutputs(config, outputFilename) {
+	const record = require_watch_targets.createOutputRecord(outputFilename);
+	const publicFiles = config.build.copyPublicDir && config.publicDir ? require_diagnostic_text.getFilenames([config.publicDir]).filenames.map((file) => (0, node_path.relative)(config.publicDir, (0, node_path.resolve)(file))) : [];
+	for (const location of configOutputLocations(config)) {
+		record.addLocation(location);
+		record.addFiles(location, publicFiles);
+	}
+	return record.outputs();
+}
+/** Both builds' outputs together. */
+function mergeOutputs(a, b) {
+	return {
+		files: [...a.files, ...b.files],
+		stories: [...a.stories ?? [], ...b.stories ?? []],
+		dirs: [...a.dirs, ...b.dirs]
+	};
+}
+/** Adds Vite's client to the page, first in its head, so reloads and the error overlay reach it. */
+function injectViteClient(html, base) {
+	return require_diagnostic_text.insertViteClient(html, `${base}@vite/client`);
+}
+/**
+* What `vite build --watch` is told to watch for the entry's globs: each glob's folder (or the nearest one above it
+* that exists), by real path, as the bundler's watcher reports it. A folder that holds a build output is left out,
+* since the watcher would report what the build writes there and rebuild for ever: a file added to it is bundled
+* with the next build something else starts.
+*/
+function globWatchTargets(scopes, outputs) {
+	return scopeWatchTargets(scopes).map(require_watch_targets.canonicalPath).filter((folder) => !outputs.holds(folder));
+}
+/** Whether a resolved config is a build of the client, the only build that carries the story. */
+function isStoryBuild(config) {
+	return config.command === "build" && !config.build.ssr;
+}
+/** An import as written: its importer and its source. */
+function importKey(importer, source) {
+	return `${importer ?? ""}\0${source}`;
+}
+/** Whether a plugin is Vite's own (its resolver, alias and the rest) or one of twee-ts's. */
+function isOwnPlugin(plugin) {
+	return plugin.name === "alias" || plugin.name.startsWith("vite:") || plugin.name.startsWith("builtin:") || plugin.name === "twee-ts" || plugin.name.startsWith(`twee-ts:`);
+}
+/**
+* A copy of `plugin` (see pluginWith) with a `resolveId` hook that passes each import it resolves (see importKey) to
+* `claim`. A plugin without a `resolveId` hook in JavaScript is returned as it is.
+*/
+function claimingPlugin(plugin, claim) {
+	const hook = plugin.resolveId;
+	const handler = typeof hook === "function" ? hook : hook?.handler;
+	if (typeof handler !== "function") return plugin;
+	const claiming = async function(...args) {
+		const result = await Reflect.apply(handler, this, args);
+		const [source, importer] = args;
+		if (result !== null && result !== void 0 && typeof source === "string") claim(importKey(typeof importer === "string" ? importer : void 0, source));
+		return result;
+	};
+	return pluginWith(plugin, /* @__PURE__ */ new Map([["resolveId", typeof hook === "function" ? claiming : {
+		...hook,
+		handler: claiming
+	}]]));
+}
+function tweeTsPlugin(options) {
+	require_watch_targets.checkViteVersion(vite.version);
+	const resolved = require_watch_targets.resolvePluginOptions("vite", options);
+	const { outputFilename, entry: entryPath } = resolved;
+	instances += 1;
+	const entryInput = `${ENTRY_INPUT_NAME}-${instances}`;
+	const cache = /* @__PURE__ */ new Map();
+	const ownBuilds = /* @__PURE__ */ new WeakMap();
+	const record = require_watch_targets.createOutputRecord(outputFilename);
+	const allOutputs = (config) => mergeOutputs(configOutputs(config, 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
+	* own); else, with an entry, the entry as the only input (unless the user's
+	* output is an array, which the entry's IIFE can't use); else the stand-in
+	* input.
+	*/
+	const inputSettings = (config) => {
+		if (namesInput(config)) return void 0;
+		if (entryPath === void 0) return { build: inputOnly(EMPTY_INPUT) };
+		const output = config.build?.rolldownOptions?.output;
+		if (Array.isArray(output)) return { build: inputOnly(EMPTY_INPUT) };
+		return entryInputSettings(entryInput, entryPath, output, outputFilename);
+	};
+	/** Whether this instance's entry is an input of the build with this config. */
+	const bundlesEntryInside = (config) => {
+		const input = bundlerOptionsOf(config.build)?.["input"];
+		return require_diagnostic_text.isRecord(input) && Object.hasOwn(input, entryInput);
+	};
+	/** The resolved config of the build a hook runs in: its environment's, so builds sharing the instance keep apart. */
+	const configOf = (context) => context.environment.config;
+	let watchOutputs = /* @__PURE__ */ new WeakMap();
+	const keptTargets = /* @__PURE__ */ new Map();
+	const claimed = /* @__PURE__ */ new Set();
+	const outputsOf = (config) => {
+		const known = watchOutputs.get(config);
+		if (known !== void 0) return known;
+		const outputs = require_diagnostic_text.outputPaths(allOutputs(config));
+		watchOutputs.set(config, outputs);
+		return outputs;
+	};
+	/**
+	* `vite build --watch` with the entry bundled inside the build: the bundler watches each module by its real path,
+	* so the links an import of the entry's graph goes through (or the folder where an import that reaches nothing
+	* would be created) are registered here, as the import is resolved (see importWatchTargets).
+	*/
+	const registerImport = async (context, source, importer) => {
+		const config = configOf(context);
+		const { spellings, kept } = await importSpellings(context, source, importer, config.root);
+		for (const target of require_watch_targets.importWatchTargets(spellings, outputsOf(config))) context.addWatchFile(target);
+		return kept;
+	};
+	/** Likewise, each glob's folder: Vite's import-glob reads the files a glob matches, and registers no folder. */
+	const registerGlobs = async (context, code, id) => {
+		const config = configOf(context);
+		const scopes = await moduleGlobScopes(context, code, id, config.root);
+		for (const target of globWatchTargets(scopes, outputsOf(config))) context.addWatchFile(target);
+		return scopes;
+	};
+	const workerGlobs = /* @__PURE__ */ new Map();
+	let warnedWorkerCache = false;
+	/**
+	* `vite build --watch` keeps each worker's bundle until a file it read changes, and a file added to the folder of
+	* one of its globs is none of those. When `file` is added to (or removed from) the scope of a worker's glob, the
+	* bundles of the workers whose modules call the glob are let go, through Vite's own worker plugin, as an edit of
+	* those modules would; the build that follows bundles them again (#424).
+	*/
+	const releaseWorkerGlobs = async (context, file) => {
+		const importers = [...workerGlobs.values()].filter(({ scope }) => {
+			const { linked } = readScope(scope);
+			return scopeAdmits(scope, file, false, linked) || scopeAdmits(scope, file, true, linked);
+		}).flatMap(({ importers: modules }) => [...modules]);
+		if (importers.length === 0) return;
+		const hook = configOf(context).plugins.find((plugin) => plugin.name === VITE_WORKER_PLUGIN)?.watchChange;
+		const handler = typeof hook === "function" ? hook : hook?.handler;
+		if (typeof handler !== "function") {
+			if (!warnedWorkerCache) {
+				warnedWorkerCache = true;
+				configOf(context).logger.warn(`[twee-ts] This Vite version has no ${VITE_WORKER_PLUGIN} plugin with a watchChange hook, through which twee-ts has Vite bundle a worker again: a file added to the folder of a worker's import.meta.glob() is bundled when one of the worker's modules changes.`);
+			}
+			return;
+		}
+		for (const module of importers) await Reflect.apply(handler, context, [module, { event: "update" }]);
+	};
+	/**
+	* The same registrations in each build of a worker the entry starts, which Vite bundles nested in the entry's
+	* build with the plugins of `worker.plugins` (#424). What a worker build registers is watched by the outer build.
+	*/
+	const workerWatcher = () => ({
+		name: `${PLUGIN_NAME}:worker-watch`,
+		resolveId: {
+			order: "pre",
+			async handler(source, importer) {
+				await registerImport(this, source, importer);
+			}
+		},
+		transform: {
+			filter: { code: "import.meta.glob" },
+			async handler(code, id) {
+				for (const scope of await registerGlobs(this, code, id)) {
+					const key = scopeId(scope);
+					const known = workerGlobs.get(key) ?? {
+						scope,
+						importers: /* @__PURE__ */ new Set()
+					};
+					known.importers.add(fileOfId(id));
+					workerGlobs.set(key, known);
+				}
+			}
+		}
+	});
+	return {
+		name: PLUGIN_NAME,
+		applyToEnvironment: (environment) => environment.name === CLIENT,
+		config: {
+			order: "post",
+			handler(config, env) {
+				const client = config.environments?.[CLIENT] ?? {};
+				if (env.command !== "build" || entryPath === void 0 || namesInput(config) || namesInput(client)) return;
+				const renderBuiltUrl = entryRenderBuiltUrl(config.base, outputFilename, config.experimental?.renderBuiltUrl);
+				if (renderBuiltUrl !== void 0) config.experimental = {
+					...config.experimental,
+					renderBuiltUrl
+				};
+				if (config.build?.watch) config.worker = withWorkerPlugin(config.worker, workerWatcher);
+			}
+		},
+		configEnvironment(name, environmentConfig, env) {
+			if (name !== CLIENT || env.command !== "build") return void 0;
+			return inputSettings(environmentConfig);
+		},
+		configResolved(config) {
+			if (entryPath === void 0) return;
+			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)));
+			});
+			if (resolved.inputs.some((input) => require_diagnostic_text.isSameOrInside(entryPath, input))) config.logger.warn(`[twee-ts] The entry ${require_watch_targets.toPosix(entryPath)} is inside the story sources (${resolved.sources.join(", ")}). twee-ts also loads the .js and .css files it finds in source folders, unbundled, as Story JavaScript and Story Stylesheet; keep the entry's folder out of \`sources\`.`);
+		},
+		async buildStart() {
+			const config = configOf(this);
+			if (!isStoryBuild(config)) return;
+			watchOutputs = /* @__PURE__ */ new WeakMap();
+			forgetKeptResolver(config);
+			if (this.meta.watchMode) {
+				const outputs = require_diagnostic_text.outputPaths(allOutputs(config));
+				for (const target of require_watch_targets.watchTargets(resolved.inputs, resolved.excluded, outputs, "real")) this.addWatchFile(target);
+			}
+			if (entryPath === void 0 || bundlesEntryInside(config)) return;
+			const watched = /* @__PURE__ */ new Set();
+			const authored = /* @__PURE__ */ new Set([entryPath]);
+			const globs = [];
+			const registerEntryInputs = () => {
+				if (!this.meta.watchMode) return;
+				for (const file of watched) this.addWatchFile(require_watch_targets.canonicalPath(file));
+				const outputs = require_diagnostic_text.outputPaths(allOutputs(config));
+				for (const target of require_watch_targets.importWatchTargets(authored, outputs)) this.addWatchFile(target);
+				for (const target of globWatchTargets(globs, outputs)) this.addWatchFile(target);
+			};
+			watched.add(entryPath);
+			let bundle;
+			try {
+				bundle = await bundleEntry(config, entryPath, "build", outputFilename, {
+					watchFiles: watched,
+					onLoad: (file) => watched.add(file),
+					onResolve: (spelling) => authored.add(spelling),
+					onGlob: (scope) => globs.push(scope)
+				});
+			} catch (e) {
+				registerEntryInputs();
+				return this.error(require_watch_targets.fatalError(e));
+			}
+			ownBuilds.set(this.environment, bundle);
+			for (const file of bundle.files) watched.add(file);
+			registerEntryInputs();
+		},
+		async watchChange(id, change) {
+			const changed = require_watch_targets.fileKey(id);
+			for (const key of [...cache.keys()]) if (require_watch_targets.fileKey(key) === changed) cache.delete(key);
+			if (change.event !== "update") await releaseWorkerGlobs(this, id);
+		},
+		transform: {
+			filter: { code: "import.meta.glob" },
+			async handler(code, id) {
+				const config = configOf(this);
+				if (!this.meta.watchMode || !isStoryBuild(config) || !bundlesEntryInside(config)) return;
+				await registerGlobs(this, code, id);
+			}
+		},
+		resolveId: {
+			order: "pre",
+			async handler(id, importer, options) {
+				if (id === EMPTY_INPUT) return RESOLVED_EMPTY_INPUT;
+				const config = configOf(this);
+				if (!this.meta.watchMode || !isStoryBuild(config) || !bundlesEntryInside(config)) return void 0;
+				const kept = await registerImport(this, id, importer);
+				if (kept === void 0) return void 0;
+				const now = require_watch_targets.canonicalPath(kept);
+				const written = importKey(importer, id);
+				const targets = keptTargets.get(written) ?? /* @__PURE__ */ new Set();
+				keptTargets.set(written, targets.add(now));
+				if (targets.size < 2) return void 0;
+				claimed.delete(written);
+				const resolved = await this.resolve(id, importer, {
+					...options,
+					skipSelf: true
+				});
+				if (claimed.has(written)) return void 0;
+				if (resolved === null || resolved.external === true || resolved.external === "absolute") return void 0;
+				const file = require_watch_targets.canonicalPath(fileOfId(resolved.id));
+				if (file === now || !targets.has(file)) return void 0;
+				return {
+					...resolved,
+					id: `${now}${/[?#].*$/s.exec(resolved.id)?.[0] ?? ""}`
+				};
+			}
+		},
+		load(id) {
+			return id === RESOLVED_EMPTY_INPUT ? "globalThis.tweeTsEmptyInput = true;" : void 0;
+		},
+		generateBundle: {
+			order: "post",
+			async handler(outputOptions, bundle) {
+				const config = configOf(this);
+				if (!isStoryBuild(config)) return;
+				for (const [fileName, item] of Object.entries(bundle)) if (item.type === "chunk" && item.facadeModuleId === RESOLVED_EMPTY_INPUT) removeFromBundle(bundle, fileName);
+				if (Object.hasOwn(bundle, outputFilename)) return this.error(`twee-ts: the build already writes a file named ${outputFilename} (another input or plugin emits it); set the plugin's outputFilename to another name.`);
+				let entry;
+				if (entryPath !== void 0) {
+					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));
+						this.emitFile({
+							type: "asset",
+							fileName,
+							source
+						});
+					}
+				}
+				record.addLocation(outputOptions);
+				record.addFiles(outputOptions, [...Object.keys(bundle), ...entry?.assets.keys() ?? []]);
+				let story;
+				try {
+					story = await require_watch_targets.compileStory(resolved.compile(entrySources(entry)), allOutputs(config), cache, true);
+				} catch (e) {
+					return this.error(require_watch_targets.fatalError(e));
+				}
+				for (const warning of story.warnings) this.warn(warning);
+				this.emitFile({
+					type: "asset",
+					fileName: outputFilename,
+					source: story.output
+				});
+			}
+		},
+		async configureServer(server) {
+			const route = await setUpDevStory(server, {
+				options: resolved,
+				cache,
+				outputs: allOutputs,
+				injectClient: injectViteClient
+			});
+			return () => {
+				installStoryRoute(server.middlewares, route);
+			};
+		}
+	};
+}
+//#endregion
+exports.tweeTsPlugin = tweeTsPlugin;
+
+//# sourceMappingURL=vite.cjs.map