@pitlane/assets 0.0.0-stage → 0.2.0

package/dist/vite-plugin.mjs

@@ -0,0 +1,1411 @@
+import { n as quotedList, t as assetsSpecifier } from "./specifier-DLC81sXY.mjs";
+import { t as createAssetManifest } from "./build-BbA-Zq1m.mjs";
+import { existsSync, readFileSync, realpathSync, statSync } from "node:fs";
+import { basename, dirname, isAbsolute, join, posix, relative, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { createFilter, isCSSRequest, normalizePath, parseSync } from "vite";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import MagicString from "magic-string";
+import { AsyncLocalStorage } from "node:async_hooks";
+//#region src/vite/boundary-policy.ts
+/**
+* Builds the access check `remix/assets` applies to the files it serves.
+* `root` is a real path; files passed to the check are real absolute paths.
+*/
+function createBrowserBoundary(root, options) {
+	let allowMatchers = options.allowFiles.map((pattern) => fileMatcher(root, pattern));
+	let denyMatchers = (options.denyFiles ?? []).map((pattern) => ({
+		pattern,
+		matches: fileMatcher(root, pattern)
+	}));
+	let packageRoots = allowedPackageRoots(root, (options.allowPackages ?? []).map((name) => name.trim()));
+	return (file) => {
+		if (file.includes("/node_modules/@oxc-project/runtime/")) return { allowed: true };
+		if (!(allowMatchers.some((matches) => matches(file)) || packageRoots.some((directory) => within(directory, file)))) return { allowed: false };
+		let denial = denyMatchers.find(({ matches }) => matches(file));
+		return denial ? {
+			allowed: false,
+			deniedBy: denial.pattern
+		} : { allowed: true };
+	};
+}
+/** Whether `file` is `directory` or below it. */
+function within(directory, file) {
+	return file === directory || file.startsWith(`${directory}/`);
+}
+function fileMatcher(root, pattern) {
+	let path = normalizePath(isAbsolute(pattern) ? pattern : join(root, pattern));
+	if (/[*?[\]{}()!+@]/.test(pattern)) return createFilter(path, null, { resolve: false });
+	if (!existsSync(path)) return (file) => file === path;
+	let real = normalizePath(realpathSync(path));
+	return statSync(real).isDirectory() ? (file) => within(real, file) : (file) => file === real;
+}
+/** Whether `name` is a bare or scoped package name, not a path, as `remix/assets` requires. */
+function isPackageName(name) {
+	let scoped = name.startsWith("@");
+	let parts = (scoped ? name.slice(1) : name).split("/");
+	return parts.length === (scoped ? 2 : 1) && parts.every((part) => /^[\w.~-]+$/.test(part) && part !== "." && part !== "..");
+}
+/**
+* The real directories of each named package and of everything its
+* `dependencies` and installed `optionalDependencies` pull in, transitively.
+* Peer dependencies are left out, as `remix/assets` leaves them out.
+*/
+function allowedPackageRoots(root, names) {
+	let roots = /* @__PURE__ */ new Set();
+	let pending = names.map((name) => {
+		if (!isPackageName(name)) throw new Error(`[assets] allowPackages values must be package names. Received ${JSON.stringify(name)}.`);
+		let directory = packageDirectory(name, root);
+		if (!directory) throw new Error(`[assets] Could not resolve allowed package "${name}".`);
+		return directory;
+	});
+	while (pending.length > 0) {
+		let directory = pending.pop();
+		if (roots.has(directory)) continue;
+		roots.add(directory);
+		let manifest = JSON.parse(readFileSync(join(directory, "package.json"), "utf8"));
+		for (let name of Object.keys(manifest.dependencies ?? {})) {
+			let dependency = packageDirectory(name, directory);
+			if (!dependency) throw new Error(`[assets] Could not resolve dependency "${name}" of allowed package ${directory}.`);
+			pending.push(dependency);
+		}
+		for (let name of Object.keys(manifest.optionalDependencies ?? {})) {
+			let dependency = packageDirectory(name, directory);
+			if (dependency) pending.push(dependency);
+		}
+	}
+	return [...roots];
+}
+/** The real directory Node's lookup finds for package `name` from `from`, or `undefined`. */
+function packageDirectory(name, from) {
+	for (let directory = from;; directory = dirname(directory)) {
+		let candidate = join(directory, "node_modules", name);
+		if (existsSync(join(candidate, "package.json"))) return normalizePath(realpathSync(candidate));
+		if (dirname(directory) === directory) return void 0;
+	}
+}
+//#endregion
+//#region src/vite/entries.ts
+function sourceKey(root, id) {
+	let file = id.split("?")[0].split("#")[0];
+	if (file.startsWith("file://")) file = fileURLToPath(file);
+	return normalizePath(relative(root, file));
+}
+function inputPath(root, key) {
+	let path = key.split("#")[0];
+	if (path.startsWith("file://")) return fileURLToPath(path);
+	if (path.startsWith("file:")) path = path.slice(5);
+	return resolve(root, path.replace(/^\/+/, ""));
+}
+function fileModule(id) {
+	return !id.startsWith("\0") && isAbsolute(id.split("?")[0]);
+}
+//#endregion
+//#region src/vite/folded-files.ts
+/** `context`, with `addWatchFile` reporting each file to `observe` before Vite records it. */
+function watching(context, observe) {
+	return new Proxy(context, { get(target, property) {
+		if (property === "addWatchFile") return (file) => {
+			observe(file);
+			target.addWatchFile(file);
+		};
+		let value = Reflect.get(target, property, target);
+		return typeof value === "function" ? value.bind(target) : value;
+	} });
+}
+function unsupported(name) {
+	return /* @__PURE__ */ new Error(`[assets] This Vite version does not expose the ${name} hook the browser boundary reads. Use a supported Vite version.`);
+}
+/** Calls `observe` with every file the folding plugins report, by wrapping their hooks' contexts. */
+function observeFoldedFiles(config, observe) {
+	let plugin = (name) => config.plugins.find((candidate) => candidate.name === name);
+	for (let name of ["vite:css", "vite:worker-import-meta-url"]) {
+		let hook = plugin(name)?.transform;
+		if (typeof hook !== "object") throw unsupported(name);
+		let handler = hook.handler;
+		hook.handler = function(code, id, options) {
+			let context = watching(this, (file) => observe(this.environment, name, id, file));
+			return handler.call(context, code, id, options);
+		};
+	}
+	let hook = plugin("vite:worker")?.load;
+	if (typeof hook !== "object") throw unsupported("vite:worker");
+	let handler = hook.handler;
+	hook.handler = function(id, options) {
+		let context = watching(this, (file) => observe(this.environment, "vite:worker", id, file));
+		return handler.call(context, id, options);
+	};
+}
+//#endregion
+//#region src/vite/boundary.ts
+function describe({ file, importer, deniedBy }) {
+	let reason = deniedBy ? `matches denyFiles ${JSON.stringify(deniedBy)}` : "not in allowFiles or allowPackages";
+	return `${file}${importer ? ` (imported by ${importer})` : ""}: ${reason}`;
+}
+/** Query-free path of a module id or emitted file name. */
+function filePath(id) {
+	return normalizePath(id.split(/[?#]/, 1)[0]);
+}
+/**
+* A page, or an inline script Vite proxies out of one: the boundary governs
+* what a page loads, not the page. An HTML file a module imports is data.
+*/
+function htmlDocument(id) {
+	return filePath(id).endsWith(".html") && (!id.includes("?") || /[?&]html-proxy\b/.test(id));
+}
+/**
+* The server files a build copies into the client output: every stylesheet
+* the server graph imports, except as a string or URL, and the assets its
+* chunks link.
+*/
+function publishedServerFiles(bundle) {
+	let files = [];
+	for (let output of Object.values(bundle)) {
+		if (output.type !== "chunk" || !output.viteMetadata) continue;
+		for (let id of output.moduleIds) if (isCSSRequest(id) && !/[?&](?:inline|raw|url)\b/.test(id)) files.push(id);
+		for (let fileName of output.viteMetadata.importedAssets) {
+			let asset = bundle[fileName];
+			if (asset?.type === "asset") files.push(...asset.originalFileNames);
+		}
+	}
+	return files;
+}
+/**
+* Holds the client graph and every file the build publishes for the browser
+* to `allowFiles`, `allowPackages`, and `denyFiles`, the way `remix/assets`
+* holds the files its asset server answers.
+*/
+function browserBoundary(options, serverEnvironments) {
+	let root = "";
+	let inspect;
+	let viteClient = normalizePath(dirname(fileURLToPath(import.meta.resolve("vite/dist/client/client.mjs"))));
+	/** Build module id → the files a folding plugin read into it. */
+	let foldedFiles = /* @__PURE__ */ new Map();
+	function refusal(file, importer) {
+		let verdict = inspect(file);
+		if (verdict.allowed) return;
+		return {
+			file: sourceKey(root, file),
+			importer: importer && sourceKey(root, importer),
+			deniedBy: verdict.deniedBy
+		};
+	}
+	/** The real path of the file `path` names from the root, or `undefined` when none exists. */
+	function existingFile(path) {
+		let file = resolve(root, filePath(path));
+		if (!existsSync(file) || !statSync(file).isFile()) return;
+		return normalizePath(realpathSync(file));
+	}
+	/** The source file a dev request reaches, or `undefined` when Vite itself supplies it. */
+	function servedSource(environment, file) {
+		if (within(viteClient, file)) return;
+		let optimizer = environment.depsOptimizer;
+		if (!optimizer?.isOptimizedDepFile(file)) return file;
+		let { optimized, discovered } = optimizer.metadata;
+		let dependency = [...Object.values(optimized), ...Object.values(discovered)].find((info) => normalizePath(info.file) === file);
+		return dependency?.src && normalizePath(dependency.src);
+	}
+	function devRefusal(environment, file, importer) {
+		let source = servedSource(environment, file);
+		if (!source) return;
+		importer ??= [...environment.moduleGraph.getModulesByFile(file) ?? []].flatMap((module) => [...module.importers]).find((module) => module.file)?.file ?? void 0;
+		return refusal(source, importer);
+	}
+	return {
+		name: "pitlane-assets-boundary",
+		sharedDuringBuild: true,
+		configResolved(config) {
+			root = config.root;
+			inspect = createBrowserBoundary(normalizePath(realpathSync(root)), options);
+			observeFoldedFiles(config, (environment, plugin, module, file) => {
+				if (plugin === "vite:css" && !isCSSRequest(file) && !config.assetsInclude(file)) return;
+				if (environment.mode === "build") {
+					let files = foldedFiles.get(module);
+					if (!files) foldedFiles.set(module, files = /* @__PURE__ */ new Set());
+					files.add(file);
+					return;
+				}
+				if (environment.name !== "client" || environment.mode !== "dev") return;
+				let source = existingFile(file);
+				let refused = source && devRefusal(environment, source, module);
+				if (refused) throw new Error(`[assets] Outside the browser boundary: ${describe(refused)}`);
+			});
+		},
+		configureServer(server) {
+			let client = server.environments.client;
+			let { publicDir, base } = server.config;
+			server.middlewares.use(((request, _response, next) => {
+				let path;
+				try {
+					path = decodeURIComponent(filePath(request.url ?? "/"));
+				} catch {
+					return next();
+				}
+				if (base !== "/" && path.startsWith(base)) path = `/${path.slice(base.length)}`;
+				if (path.startsWith("/@") && !path.startsWith("/@fs/")) return next();
+				if (publicDir && existsSync(join(publicDir, path))) return next();
+				if (htmlDocument(path)) return next();
+				let requested = join(root, path);
+				if (path.startsWith("/@fs/")) {
+					let fsPath = path.slice(5);
+					requested = /^[A-Za-z]:\//.test(fsPath) ? fsPath : `/${fsPath}`;
+				}
+				let file = existingFile(requested);
+				let refused = file && devRefusal(client, file);
+				if (!refused) return next();
+				next(/* @__PURE__ */ new Error(`[assets] Outside the browser boundary: ${describe(refused)}`));
+			}));
+		},
+		transform: {
+			order: "pre",
+			handler(_code, id) {
+				let environment = this.environment;
+				if (environment.mode !== "dev" || environment.name !== "client" || !fileModule(id)) return;
+				if (htmlDocument(id)) return;
+				let refused = devRefusal(environment, existingFile(id) ?? filePath(id));
+				if (refused) throw new Error(`[assets] Outside the browser boundary: ${describe(refused)}`);
+			}
+		},
+		generateBundle(_options, bundle) {
+			let name = this.environment.name;
+			let published = [];
+			if (name === "client") {
+				for (let id of this.getModuleIds()) {
+					if (!fileModule(id)) continue;
+					let info = this.getModuleInfo(id);
+					let importer = [...info?.importers ?? [], ...info?.dynamicImporters ?? []].find(fileModule);
+					published.push({
+						path: id,
+						importer
+					});
+				}
+				for (let output of Object.values(bundle)) {
+					if (output.type !== "asset" || output.names.some(isCSSRequest)) continue;
+					for (let path of output.originalFileNames) published.push({ path });
+				}
+			} else if (serverEnvironments.includes(name)) for (let path of publishedServerFiles(bundle)) {
+				let importer = this.getModuleInfo(path)?.importers.find(fileModule);
+				published.push({
+					path,
+					importer
+				});
+			}
+			let refusals = /* @__PURE__ */ new Map();
+			for (let { path, importer } of published) {
+				let entries = [{
+					path,
+					importer
+				}, ...[...foldedFiles.get(path) ?? []].map((file) => ({
+					path: file,
+					importer: path
+				}))];
+				for (let entry of entries) {
+					let file = !htmlDocument(entry.path) && existingFile(entry.path);
+					let refused = file && refusal(file, entry.importer);
+					if (refused && !refusals.get(refused.file)?.importer) refusals.set(refused.file, refused);
+				}
+			}
+			if (refusals.size === 0) return;
+			let lines = [...refusals.values()].map(describe);
+			this.error(`[assets] Outside the browser boundary:\n  ${lines.join("\n  ")}`);
+		}
+	};
+}
+//#endregion
+//#region src/vite/output.ts
+function captureOutput(bundle, config, role, assetFiles, entryFiles) {
+	let graph = {
+		role,
+		chunks: Object.create(null),
+		entries: Object.create(null),
+		assets: Object.create(null)
+	};
+	let globalStylesheets = config.build.cssCodeSplit ? [] : Object.values(bundle).flatMap((output) => output.type === "asset" && output.originalFileNames.includes("style.css") ? [output.fileName] : []);
+	let linked = role === "server" ? linkedFiles(bundle, globalStylesheets) : void 0;
+	for (let output of Object.values(bundle)) {
+		if (output.type === "asset") {
+			if (linked && !linked.has(output.fileName)) continue;
+			let stylesheet = output.names.some(isCSSRequest);
+			for (let file of output.originalFileNames) {
+				if (stylesheet && !isCSSRequest(file)) continue;
+				let key = fileModule(file) ? sourceKey(config.root, file) : file.replace(/^\.\//, "");
+				graph.assets[key] = output.fileName;
+			}
+			continue;
+		}
+		graph.chunks[output.fileName] = {
+			file: output.fileName,
+			modules: [...new Set(output.moduleIds.filter(fileModule).map((id) => sourceKey(config.root, id)))],
+			imports: output.imports.filter((id) => bundle[id]?.type === "chunk"),
+			dynamicImports: output.dynamicImports.filter((id) => bundle[id]?.type === "chunk"),
+			stylesheets: [...globalStylesheets, ...output.viteMetadata?.importedCss ?? []]
+		};
+		if (role === "client" && output.isEntry && output.facadeModuleId && fileModule(output.facadeModuleId)) graph.entries[sourceKey(config.root, output.facadeModuleId)] = output.fileName;
+	}
+	for (let [key, file] of assetFiles) graph.assets[key] = file;
+	for (let [key, file] of entryFiles) if (bundle[file]?.type === "chunk") graph.entries[key] = file;
+	return graph;
+}
+function linkedFiles(bundle, globalStylesheets) {
+	let files = new Set(globalStylesheets);
+	for (let output of Object.values(bundle)) {
+		if (output.type !== "chunk" || !output.viteMetadata) continue;
+		for (let file of output.viteMetadata.importedCss) files.add(file);
+		for (let file of output.viteMetadata.importedAssets) files.add(file);
+	}
+	return files;
+}
+function captureImportMap(bundle, fileName) {
+	let output = bundle[fileName];
+	if (output?.type !== "asset") throw new Error(`[assets] The client build did not emit its configured import map "${fileName}".`);
+	let text = typeof output.source === "string" ? output.source : new TextDecoder().decode(output.source);
+	return JSON.parse(text);
+}
+/**
+* The public URL `renderBuiltUrl` chooses for a built file. A server document
+* has no importer to be relative to, so `{ relative: true }` keeps the
+* base-joined path.
+*/
+function publicFile(config, file) {
+	let render = config.experimental.renderBuiltUrl;
+	if (!render) return file;
+	let rendered = render(file, {
+		type: "asset",
+		hostType: "html",
+		hostId: "",
+		ssr: true
+	});
+	if (typeof rendered === "string") return rendered;
+	if (rendered && "runtime" in rendered && rendered.runtime) throw new Error("[assets] renderBuiltUrl must return a URL for server HTML; runtime JavaScript cannot be serialized in an asset manifest.");
+	return file;
+}
+//#endregion
+//#region src/vite/binding-names.ts
+/** Calls `visit` on every AST node below `root`, in no particular order. */
+function forEachNode(root, visit) {
+	let pending = [root];
+	while (pending.length) {
+		let node = pending.pop();
+		if (!node || typeof node !== "object") continue;
+		if (Array.isArray(node)) {
+			pending.push(...node);
+			continue;
+		}
+		visit(node);
+		for (let child of Object.values(node)) if (child && typeof child === "object") pending.push(child);
+	}
+}
+function patternNames(pattern) {
+	switch (pattern?.type) {
+		case "Identifier": return [pattern.name];
+		case "AssignmentPattern": return patternNames(pattern.left);
+		case "RestElement": return patternNames(pattern.argument);
+		case "TSParameterProperty": return patternNames(pattern.parameter);
+		case "ArrayPattern": return pattern.elements.flatMap(patternNames);
+		case "ObjectPattern": return pattern.properties.flatMap((property) => patternNames(property.type === "RestElement" ? property : property.value));
+		default: return [];
+	}
+}
+/** The names a declaration binds in the scope that contains it. */
+function declaredNames(node) {
+	switch (node?.type) {
+		case "VariableDeclaration": return node.declarations.flatMap((declarator) => patternNames(declarator.id));
+		case "FunctionDeclaration":
+		case "TSDeclareFunction":
+		case "ClassDeclaration":
+		case "TSEnumDeclaration":
+		case "TSImportEqualsDeclaration": return node.id ? [node.id.name] : [];
+		case "TSModuleDeclaration": return node.id.type === "Identifier" ? [node.id.name] : [];
+		default: return [];
+	}
+}
+function boundNames(node) {
+	switch (node.type) {
+		case "VariableDeclaration": return declaredNames(node);
+		case "FunctionDeclaration":
+		case "FunctionExpression":
+		case "ArrowFunctionExpression": {
+			let parameters = node.params.flatMap(patternNames);
+			return node.type !== "ArrowFunctionExpression" && node.id ? [node.id.name, ...parameters] : parameters;
+		}
+		case "ClassExpression": return node.id ? [node.id.name] : [];
+		case "CatchClause": return patternNames(node.param);
+		case "ImportSpecifier":
+		case "ImportDefaultSpecifier":
+		case "ImportNamespaceSpecifier": return [node.local.name];
+		default: return declaredNames(node);
+	}
+}
+/** How many times a module binds each name, counting every declaration in every scope. */
+function bindingCounts(program) {
+	let counts = /* @__PURE__ */ new Map();
+	forEachNode(program, (node) => {
+		for (let name of boundNames(node)) counts.set(name, (counts.get(name) ?? 0) + 1);
+	});
+	return counts;
+}
+//#endregion
+//#region src/vite/resolver-bindings.ts
+function moduleExportName(node) {
+	return node.type === "Literal" ? node.value : node.name;
+}
+function constructs(node, constructors) {
+	while (node?.type === "AwaitExpression" || node?.type === "ParenthesizedExpression") node = node.type === "AwaitExpression" ? node.argument : node.expression;
+	return node?.type === "CallExpression" && node.callee.type === "Identifier" && constructors.has(node.callee.name);
+}
+/** The name a chain of top-level `const a = b` copies starts from. */
+function aliasRoot(name, initializers) {
+	let seen = /* @__PURE__ */ new Set();
+	let init = initializers.get(name);
+	while (init?.type === "Identifier" && !seen.has(name)) {
+		seen.add(name);
+		name = init.name;
+		init = initializers.get(name);
+	}
+	return name;
+}
+function topLevelBindings(program) {
+	let counts = bindingCounts(program);
+	let importedConstructors = /* @__PURE__ */ new Set();
+	let imports = /* @__PURE__ */ new Map();
+	let initializers = /* @__PURE__ */ new Map();
+	for (let statement of program.body) {
+		if (statement.type === "ImportDeclaration") {
+			let module = statement.source.value;
+			for (let specifier of statement.specifiers) {
+				let local = specifier.local.name;
+				if (specifier.type === "ImportNamespaceSpecifier" || counts.get(local) !== 1) continue;
+				let name = specifier.type === "ImportDefaultSpecifier" ? "default" : moduleExportName(specifier.imported);
+				if (name === "createAssetResolver" && (module === "@pitlane/assets" || module === "pitlane/assets")) importedConstructors.add(local);
+				else imports.set(local, {
+					module,
+					name
+				});
+			}
+		}
+		let declaration = statement.type === "ExportNamedDeclaration" ? statement.declaration : statement;
+		if (declaration?.type !== "VariableDeclaration") continue;
+		for (let { id, init } of declaration.declarations) if (id.type === "Identifier" && init && counts.get(id.name) === 1) initializers.set(id.name, init);
+	}
+	let constructors = new Set(importedConstructors);
+	for (let name of initializers.keys()) if (importedConstructors.has(aliasRoot(name, initializers))) constructors.add(name);
+	let resolvers = /* @__PURE__ */ new Map();
+	for (let name of [...imports.keys(), ...initializers.keys()]) {
+		let root = aliasRoot(name, initializers);
+		let origin = imports.get(root) ?? (constructs(initializers.get(root), constructors) ? "local" : void 0);
+		if (origin) resolvers.set(name, origin);
+	}
+	return {
+		constructors,
+		resolvers
+	};
+}
+/** Where the resolver an expression evaluates to comes from, when the expression can name one. */
+function resolverOrigin(node, bindings) {
+	if (constructs(node, bindings.constructors)) return "local";
+	if (node.type === "Identifier") return bindings.resolvers.get(node.name);
+}
+//#endregion
+//#region src/vite/resolver-usage.ts
+const RELEVANT = /\bget(?:ScriptEntry|Href)\b|\bcreateAssetResolver\b|\bexport\b/;
+/** The method a member call names, through `.name` or a string-literal `["name"]`. */
+function memberName(callee) {
+	let { property } = callee;
+	if (!callee.computed) return property.type === "Identifier" ? property.name : void 0;
+	return property.type === "Literal" && typeof property.value === "string" ? property.value : void 0;
+}
+function literalCall(call, bindings) {
+	let { callee, arguments: args } = call;
+	if (callee.type !== "MemberExpression") return;
+	let method = memberName(callee);
+	let argument = args[0];
+	if (method !== "getScriptEntry" && method !== "getHref") return;
+	if (argument?.type !== "Literal" || typeof argument.value !== "string") return;
+	let receiver = resolverOrigin(callee.object, bindings);
+	if (!receiver) return;
+	return {
+		input: {
+			key: argument.value,
+			kind: method === "getScriptEntry" ? "script" : "asset"
+		},
+		receiver
+	};
+}
+function resolverExports(program, bindings) {
+	let exported = /* @__PURE__ */ new Map();
+	for (let statement of program.body) {
+		if (statement.type === "ExportDefaultDeclaration") exported.set("default", resolverOrigin(statement.declaration, bindings) ?? null);
+		if (statement.type === "ExportAllDeclaration" && statement.exported) exported.set(moduleExportName(statement.exported), null);
+		if (statement.type !== "ExportNamedDeclaration") continue;
+		for (let name of declaredNames(statement.declaration)) exported.set(name, bindings.resolvers.get(name) ?? null);
+		for (let specifier of statement.specifiers) {
+			let found = statement.source ? {
+				module: statement.source.value,
+				name: moduleExportName(specifier.local)
+			} : resolverOrigin(specifier.local, bindings);
+			exported.set(moduleExportName(specifier.exported), found ?? null);
+		}
+	}
+	return exported;
+}
+/**
+* A module's literal `getScriptEntry` and `getHref` calls whose receiver may be
+* a resolver, and its exports that may name one. Import specifiers stay
+* unresolved; pass the result to {@link linkResolverUsage}.
+*/
+function scanResolverUsage(code, id) {
+	if (!RELEVANT.test(code)) return;
+	let { program } = parseSync(id, code);
+	let bindings = topLevelBindings(program);
+	let calls = [];
+	forEachNode(program, (node) => {
+		let call = node.type === "CallExpression" ? literalCall(node, bindings) : void 0;
+		if (call) calls.push(call);
+	});
+	let exported = resolverExports(program, bindings);
+	let starExports = program.body.flatMap((statement) => statement.type === "ExportAllDeclaration" && !statement.exported ? [statement.source.value] : []);
+	let namesResolver = [...exported.values()].some((origin) => origin !== null);
+	if (calls.length === 0 && !namesResolver && starExports.length === 0) return;
+	return {
+		calls,
+		resolverExports: exported,
+		starExports
+	};
+}
+/** Replaces import specifiers with module ids, dropping those that are external or unresolved. */
+async function linkResolverUsage(usage, resolve) {
+	let specifiers = new Set(usage.starExports);
+	for (let origin of [...usage.calls.map((call) => call.receiver), ...usage.resolverExports.values()]) if (origin && origin !== "local") specifiers.add(origin.module);
+	let resolved = /* @__PURE__ */ new Map();
+	await Promise.all([...specifiers].map(async (specifier) => {
+		let module = await resolve(specifier);
+		if (module && !module.external) resolved.set(specifier, module.id);
+	}));
+	let link = (origin) => {
+		if (origin === "local") return origin;
+		let module = resolved.get(origin.module);
+		return module === void 0 ? void 0 : {
+			module,
+			name: origin.name
+		};
+	};
+	let calls = [];
+	for (let call of usage.calls) {
+		let receiver = link(call.receiver);
+		if (receiver) calls.push({
+			input: call.input,
+			receiver
+		});
+	}
+	let exported = /* @__PURE__ */ new Map();
+	for (let [name, origin] of usage.resolverExports) exported.set(name, origin && (link(origin) ?? null));
+	return {
+		calls,
+		resolverExports: exported,
+		starExports: usage.starExports.flatMap((specifier) => resolved.get(specifier) ?? [])
+	};
+}
+function isResolver(modules, origin, seen) {
+	if (origin === "local") return true;
+	let binding = `${origin.module}\0${origin.name}`;
+	if (seen.has(binding)) return false;
+	seen.add(binding);
+	let usage = modules.get(origin.module);
+	let exported = usage?.resolverExports.get(origin.name);
+	if (!usage || exported === null) return false;
+	if (exported) return isResolver(modules, exported, seen);
+	return origin.name !== "default" && usage.starExports.some((module) => isResolver(modules, {
+		module,
+		name: origin.name
+	}, seen));
+}
+/** The browser inputs a module's literal calls register, given its environment's linked usage. */
+function literalInputs(modules, id) {
+	return (modules.get(id)?.calls ?? []).filter((call) => isResolver(modules, call.receiver, /* @__PURE__ */ new Set())).map((call) => call.input);
+}
+//#endregion
+//#region src/vite/state.ts
+/**
+* The manifest module a build writes at the root of each server environment's
+* output directory. The server chunks that read the manifest import this file
+* by a relative path, so a host that deploys a single module must bundle it in.
+*/
+const ASSETS_MANIFEST_FILE = "__pitlane_assets_manifest.js";
+const MANIFEST_ID = "\0pitlane:assets-manifest";
+const MANIFEST_EXTERNAL = "pitlane:assets-build-manifest";
+const EMPTY_INPUT = "\0pitlane:assets-empty-input";
+/** The manifest was imported from a server environment `assets()` does not serve. */
+function unservedEnvironmentError(name, served) {
+	return /* @__PURE__ */ new Error(`[assets] The "${name}" environment imported ${assetsSpecifier("manifest")}, but assets() serves only ${quotedList(served, "conjunction")}. Add "${name}" to assets({ serverEnvironments }) from ${assetsSpecifier("vite-plugin")}.`);
+}
+//#endregion
+//#region src/vite/build.ts
+async function writeManifests(state) {
+	let config = state.config;
+	let client = state.outputs.get("client");
+	if (!client || state.serverEnvironments.some((name) => !state.outputs.has(name))) return;
+	let clientStylesheets = /* @__PURE__ */ new Map();
+	for (let asset of Object.values(client.bundle)) if (asset.type === "asset" && isCSSRequest(asset.fileName)) clientStylesheets.set(Buffer.from(asset.source).toString("latin1"), asset.fileName);
+	let environments = Object.create(null);
+	let twins = /* @__PURE__ */ new Map();
+	for (let [name, output] of state.outputs) {
+		let graph = output.graph;
+		let twin = /* @__PURE__ */ new Map();
+		if (output !== client) for (let asset of Object.values(output.bundle)) {
+			if (asset.type !== "asset" || !isCSSRequest(asset.fileName)) continue;
+			let file = clientStylesheets.get(Buffer.from(asset.source).toString("latin1"));
+			if (file) twin.set(asset.fileName, file);
+		}
+		twins.set(name, twin);
+		environments[name] = {
+			...graph,
+			chunks: Object.fromEntries(Object.entries(graph.chunks).map(([key, chunk]) => [key, {
+				...chunk,
+				file: publicFile(config, chunk.file),
+				stylesheets: chunk.stylesheets.map((file) => publicFile(config, twin.get(file) ?? file))
+			}])),
+			assets: Object.fromEntries(Object.entries(graph.assets).map(([key, file]) => [key, publicFile(config, twin.get(file) ?? file)]))
+		};
+	}
+	for (let name of state.serverEnvironments) {
+		let manifest = createAssetManifest({
+			base: config.base,
+			environments: {
+				client: environments.client,
+				[name]: environments[name]
+			},
+			importMap: state.importMap
+		});
+		let output = state.outputs.get(name);
+		await mkdir(output.outDir, { recursive: true });
+		await writeFile(resolve(output.outDir, ASSETS_MANIFEST_FILE), `export default JSON.parse(${JSON.stringify(JSON.stringify({
+			...manifest,
+			serverEnvironment: name
+		}))});\n`);
+		await publishLinkedFiles(output, twins.get(name), client.outDir);
+	}
+}
+/**
+* Copies the stylesheets and assets a server graph links into the public client
+* output, so every URL its manifest names is served. A stylesheet with a client
+* twin already is.
+*/
+async function publishLinkedFiles(output, twin, publicDir) {
+	let linked = /* @__PURE__ */ new Set([...Object.values(output.graph.chunks).flatMap((chunk) => chunk.stylesheets), ...Object.values(output.graph.assets)]);
+	for (let file of linked) {
+		let asset = output.bundle[file];
+		if (asset?.type !== "asset" || twin.has(file)) continue;
+		let destination = resolve(publicDir, file);
+		await mkdir(dirname(destination), { recursive: true });
+		await writeFile(destination, asset.source);
+	}
+}
+function importMapFileName(config) {
+	let options = config.build.rolldownOptions.experimental?.chunkImportMap;
+	return typeof options === "object" ? options.fileName ?? "importmap.json" : "importmap.json";
+}
+function assetBuild(state) {
+	return {
+		name: "pitlane-assets-build",
+		sharedDuringBuild: true,
+		apply: "build",
+		configEnvironment(name, config) {
+			if (state.serverEnvironments.includes(name)) return { build: { emitAssets: true } };
+			if (name === "client" && !config.build?.rolldownOptions?.input && !config.build?.rollupOptions?.input) return { build: { rolldownOptions: { input: EMPTY_INPUT } } };
+		},
+		resolveId(id) {
+			if (id === "\0pitlane:assets-empty-input") return id;
+		},
+		load(id) {
+			if (id === "\0pitlane:assets-empty-input") return "export {};";
+		},
+		async buildStart() {
+			if (this.environment.name !== "client") return;
+			let missing = state.serverEnvironments.filter((name) => !state.outputs.has(name));
+			if (missing.length) throw new Error(`[assets] Client built before server environments: ${missing.join(", ")}. Build servers before client.`);
+			let root = state.config.root;
+			state.assetReferences.clear();
+			state.scriptReferences.clear();
+			let inputs = new Map(state.inputs);
+			for (let modules of state.resolverUsage.values()) for (let owner of modules.keys()) for (let input of literalInputs(modules, owner)) {
+				let file = inputPath(root, input.key);
+				inputs.set(file, {
+					...input,
+					key: sourceKey(root, file)
+				});
+			}
+			for (let input of inputs.values()) {
+				let id = inputPath(state.config.root, input.key);
+				if (input.kind === "asset" && !isCSSRequest(id) && state.config.assetsInclude(id)) {
+					let reference = this.emitFile({
+						type: "asset",
+						name: basename(id),
+						originalFileName: id,
+						source: await readFile(id)
+					});
+					state.assetReferences.set(sourceKey(root, id), reference);
+				} else {
+					let reference = this.emitFile({
+						type: "chunk",
+						id,
+						preserveSignature: "exports-only"
+					});
+					if (!isCSSRequest(id)) state.scriptReferences.set(sourceKey(root, id), reference);
+				}
+			}
+		},
+		renderChunk(code, chunk) {
+			if (!code.includes("pitlane:assets-build-manifest")) return;
+			let file = posix.relative(posix.dirname(chunk.fileName), ASSETS_MANIFEST_FILE);
+			if (!file.startsWith(".")) file = `./${file}`;
+			return {
+				code: code.replaceAll(MANIFEST_EXTERNAL, file),
+				map: null
+			};
+		},
+		generateBundle: {
+			order: "post",
+			handler(_options, bundle) {
+				let removed = /* @__PURE__ */ new Set();
+				for (let [name, output] of Object.entries(bundle)) if (output.type === "chunk" && output.facadeModuleId === "\0pitlane:assets-empty-input") {
+					removed.add(name);
+					delete bundle[name];
+				}
+				if (this.environment.name !== "client" || !state.mapsEnabled) return;
+				let fileName = importMapFileName(this.environment.config);
+				let map = captureImportMap(bundle, fileName);
+				let base = this.environment.config.base;
+				for (let [key, href] of Object.entries(map.imports)) {
+					if (!href.startsWith(base)) continue;
+					let file = href.slice(base.length);
+					if (removed.has(file) || !(file in bundle)) delete map.imports[key];
+				}
+				let artifact = bundle[fileName];
+				if (artifact.type === "asset") artifact.source = JSON.stringify(map);
+			}
+		},
+		writeBundle: {
+			order: "post",
+			async handler(_options, bundle) {
+				let name = this.environment.name;
+				if (name !== "client" && !state.serverEnvironments.includes(name)) return;
+				let config = this.environment.config;
+				let assets = /* @__PURE__ */ new Map();
+				let scripts = /* @__PURE__ */ new Map();
+				if (name === "client") {
+					for (let [key, reference] of state.assetReferences) assets.set(key, this.getFileName(reference));
+					for (let [key, reference] of state.scriptReferences) scripts.set(key, this.getFileName(reference));
+					state.importMap = state.mapsEnabled ? captureImportMap(bundle, importMapFileName(config)) : void 0;
+				}
+				state.outputs.set(name, {
+					graph: captureOutput(bundle, config, name === "client" ? "client" : "server", assets, scripts),
+					bundle,
+					outDir: resolve(config.root, config.build.outDir)
+				});
+				await writeManifests(state);
+			}
+		},
+		buildApp: {
+			order: "pre",
+			async handler(builder) {
+				let build = builder.build.bind(builder);
+				builder.build = (async (environment) => {
+					if (environment.isBuilt) return;
+					return build(environment);
+				});
+				for (let name of state.serverEnvironments) {
+					let environment = builder.environments[name];
+					if (!environment) throw new Error(`[assets] Unknown server environment: ${name}`);
+					await builder.build(environment);
+				}
+				await builder.build(builder.environments.client);
+			}
+		}
+	};
+}
+//#endregion
+//#region src/vite/dev-css.ts
+function linkedStylesheetLookup(config) {
+	return `
+function pitlaneStyleKey(href) {
+  const url = new URL(href, document.baseURI);
+  url.searchParams.delete("t");
+  url.searchParams.delete("direct");
+  url.searchParams.sort();
+  return url.href;
+}
+function pitlaneHasLinkedStylesheet(id) {
+  const root = ${JSON.stringify(config.root + "/")};
+  const path = id.startsWith(root) ? id.slice(root.length) : "@fs/" + id.replace(/^\\//, "");
+  const key = pitlaneStyleKey(${JSON.stringify(config.base)} + path);
+  for (const link of document.querySelectorAll('link[rel="stylesheet"][href]')) {
+    if (pitlaneStyleKey(link.href) === key) return true;
+  }
+  return false;
+}
+`;
+}
+function assetStyles() {
+	let config;
+	let clientPath = normalizePath(fileURLToPath(import.meta.resolve("vite/dist/client/client.mjs")));
+	return {
+		name: "pitlane-assets-css",
+		apply: "serve",
+		configResolved(resolved) {
+			config = resolved;
+		},
+		configureServer(server) {
+			server.middlewares.use((request, _response, next) => {
+				if (request.headers.accept?.includes("text/css") && request.url?.includes("&lang.css=")) request.url = request.url.replace("&lang.css=", "?lang.css");
+				next();
+			});
+		},
+		transform: {
+			order: "post",
+			handler(code, id) {
+				if (id === clientPath) {
+					let position = code.indexOf("function updateStyle(id, content) {");
+					if (position === -1) throw new Error("[assets] This Vite client does not expose the expected CSS update function. Use a supported Vite version.");
+					let transformed = new MagicString(code);
+					transformed.prepend(linkedStylesheetLookup(config));
+					transformed.appendLeft(position + 35, "\nif (pitlaneHasLinkedStylesheet(id)) return;\n");
+					return {
+						code: transformed.toString(),
+						map: transformed.generateMap({ hires: true })
+					};
+				}
+				if (this.environment.mode !== "dev" || this.environment.name !== "client" || !isCSSRequest(id) || !/[?&]direct\b/.test(id)) return;
+				let module = this.environment.moduleGraph.getModuleById(id);
+				if (module) module.isSelfAccepting = true;
+			}
+		}
+	};
+}
+//#endregion
+//#region src/vite/transform-start.ts
+let invalidations = 0;
+let requestStart = new AsyncLocalStorage();
+/** Counts a hard invalidation and returns its place on the timeline. */
+function countInvalidation() {
+	return ++invalidations;
+}
+/** Runs `request`, which loads and transforms a module, as starting now. */
+function startRequest(request) {
+	return requestStart.run(invalidations, request);
+}
+/**
+* The place on the timeline where the calling transform's request started.
+* A transform no request started, such as one a plugin runs through
+* `pluginContainer.transform` itself, started where this is called.
+*/
+function requestStarted() {
+	return requestStart.getStore() ?? invalidations;
+}
+//#endregion
+//#region src/vite/dev-graph.ts
+/** CSS requests that import a string or URL rather than apply a stylesheet. */
+const NON_STYLESHEET_QUERY = /[?&](?:inline|url|raw)\b/;
+/**
+* The import specifiers of transformed JavaScript. Only literal `import()`
+* arguments count as dynamic edges; a computed argument names no module.
+*/
+function importSpecifiers(code) {
+	let { module } = parseSync("module.js", code, { sourceType: "module" });
+	let staticSpecifiers = new Set(module.staticImports.map((entry) => entry.moduleRequest.value));
+	for (let entry of module.staticExports) for (let item of entry.entries) if (item.moduleRequest) staticSpecifiers.add(item.moduleRequest.value);
+	let dynamicSpecifiers = /* @__PURE__ */ new Set();
+	for (let entry of module.dynamicImports) {
+		let literal = /^(["'`])([^"'`$]*)\1$/.exec(code.slice(entry.moduleRequest.start, entry.moduleRequest.end).trim());
+		if (literal) dynamicSpecifiers.add(literal[2]);
+	}
+	return {
+		static: [...staticSpecifiers],
+		dynamic: [...dynamicSpecifiers]
+	};
+}
+/** The path Vite's dev server serves a resolved module id at, before `base`. */
+function servedPath(root, id) {
+	if (id.startsWith("\0")) return `/@id/__x00__${id.slice(1)}`;
+	let query = id.indexOf("?");
+	let file = query === -1 ? id : id.slice(0, query);
+	let search = query === -1 ? "" : id.slice(query);
+	if (!isAbsolute(file)) return `/@id/${id}`;
+	if (file.startsWith(`${root}/`)) return file.slice(root.length) + search;
+	return `/@fs/${file.replace(/^\//, "")}${search}`;
+}
+/**
+* Whether discovery transforms a module. A server environment reads a package
+* from `node_modules` only when Vite transforms rather than externalizes it.
+* The client follows packages Vite serves as source, but not a prebundled
+* dependency: the optimizer's cache file is not a source module, and loading
+* it would wait for the optimizer.
+*/
+function followed(environment, id) {
+	if (id === "\0pitlane:assets-manifest" || environment.depsOptimizer?.isOptimizedDepFile(id)) return false;
+	let pkg = /.*\/node_modules\/((?:@[^/]+\/)?[^/?]+)/.exec(id)?.[1];
+	if (pkg === void 0 || environment.config.consumer === "client") return true;
+	let { noExternal } = environment.config.resolve;
+	if (noExternal === true) return true;
+	return (noExternal === void 0 ? [] : Array.isArray(noExternal) ? noExternal : [noExternal]).some((pattern) => typeof pattern === "string" ? pattern === pkg : pattern.test(pkg));
+}
+/**
+* A module is analyzed once. Its edge record was written by the transform
+* hook, whether the runner or discovery ran that transform, and stays
+* current until the module is invalidated, which drops the record. Keying
+* this on `transformResult` instead would re-transform every module the
+* runner has not executed on each rebuild.
+*
+* Client discovery goes through `transformRequest`, so it shares Vite's
+* in-flight and cached transforms with the import analysis that warms a
+* browser module's dependencies, and the browser later reads the cache.
+* Server discovery must not populate `transformResult`: the module runner
+* asks whether a module it already evaluated is still current by that
+* field, so a transform cached between a file change and the runner's next
+* import would keep its stale instance alive.
+*/
+async function analyze(environment, id, edges) {
+	if (edges.has(id)) return;
+	let { root } = environment.config;
+	try {
+		let url = servedPath(root, id);
+		if (environment.config.consumer === "client") {
+			await environment.transformRequest(url.startsWith("/@id/") ? id : url);
+			if (edges.has(id)) return;
+		}
+		await startRequest(() => transformOutsideCache(environment, id, url));
+	} catch (error) {
+		let name = fileModule(id) ? sourceKey(root, id) : id;
+		throw new Error(`[assets] Could not analyze "${name}" for the "${environment.name}" development asset manifest: ${error.message}`, { cause: error });
+	}
+}
+/**
+* Loads and transforms a module as `transformRequest` does, handing the load
+* result's source map and module type to the transform, but without reading
+* or populating Vite's transform cache.
+*/
+async function transformOutsideCache(environment, id, url) {
+	await environment.moduleGraph.ensureEntryFromUrl(url);
+	let loaded = await environment.pluginContainer.load(id);
+	let source = typeof loaded === "string" ? { code: loaded } : loaded;
+	let code = source?.code;
+	if (code == null) {
+		if (!fileModule(id)) throw new Error("No plugin loaded the module.");
+		code = await readFile(id.split("?")[0], "utf8");
+	}
+	await environment.pluginContainer.transform(code, id, {
+		inMap: source?.map,
+		moduleType: source?.moduleType
+	});
+}
+/**
+* Every module reachable from `roots` through static and dynamic edges,
+* transforming each one the graph has not analyzed yet. Stylesheets are
+* leaves: their own `@import`s are inlined by Vite's CSS pipeline. Passing
+* the result of an earlier walk extends it without revisiting its modules.
+*/
+async function walkGraph(environment, roots, edges, visited = /* @__PURE__ */ new Set()) {
+	let frontier = [...roots];
+	while (frontier.length > 0) {
+		let next = [];
+		await Promise.all(frontier.map(async (id) => {
+			if (visited.has(id) || !(isCSSRequest(id) || followed(environment, id))) return;
+			visited.add(id);
+			if (isCSSRequest(id)) return;
+			await analyze(environment, id, edges);
+			let record = edges.get(id);
+			if (record) next.push(...record.static, ...record.dynamic);
+		}));
+		frontier = next;
+	}
+	return visited;
+}
+/**
+* The stylesheet ids a module requires through static imports, in execution
+* order: each dependency's stylesheets before its importer's later imports.
+*/
+function staticStylesheets(edges, start) {
+	let seen = /* @__PURE__ */ new Set();
+	let stylesheets = [];
+	let visit = (id) => {
+		if (seen.has(id)) return;
+		seen.add(id);
+		if (isCSSRequest(id)) {
+			if (!NON_STYLESHEET_QUERY.test(id)) stylesheets.push(id);
+			return;
+		}
+		for (let dependency of edges.get(id)?.static ?? []) visit(dependency);
+	};
+	visit(start);
+	return stylesheets;
+}
+//#endregion
+//#region src/vite/dev-snapshot.ts
+function environmentEdges(graph, name) {
+	let edges = graph.edges.get(name);
+	if (!edges) graph.edges.set(name, edges = /* @__PURE__ */ new Map());
+	return edges;
+}
+/**
+* Whether a module id is a source file with a key of its own. Vite's `?v=`
+* version hash on a package module does not change which file it is; any
+* other query, such as a single-file component's style block, names a part
+* of its file that the file's own key already covers.
+*/
+function sourceModule(id) {
+	return fileModule(id) && !id.replace(/\?v=[\w-]+$/, "").includes("?");
+}
+/** The resolved, non-HTML build inputs an environment declares. */
+async function configuredInputs(environment) {
+	let { build, root } = environment.config;
+	let input = build.rolldownOptions.input;
+	let inputs = typeof input === "string" ? [input] : Array.isArray(input) ? input : Object.values(input ?? {});
+	let ids = [];
+	for (let entry of inputs) {
+		if (entry.endsWith(".html")) continue;
+		let file = resolve(root, entry);
+		let resolved = await environment.pluginContainer.resolveId(existsSync(file) ? file : entry);
+		if (!resolved) throw new Error(`[assets] Could not resolve the "${environment.name}" environment's input "${entry}".`);
+		ids.push(resolved.id);
+	}
+	return ids;
+}
+async function createDevSnapshot(server, state, graph, name) {
+	let config = state.config;
+	let { root } = config;
+	let base = config.base.replace(/\/$/, "");
+	let serverEnvironment = server.environments[name];
+	let clientEnvironment = server.environments.client;
+	let serverEdges = environmentEdges(graph, name);
+	let serverIds = await walkGraph(serverEnvironment, [...await configuredInputs(serverEnvironment), ...graph.roots.get(name) ?? []], serverEdges);
+	await clientEnvironment.depsOptimizer?.init();
+	let entryIds = /* @__PURE__ */ new Set([...state.inputs.keys(), ...await configuredInputs(clientEnvironment)]);
+	let usage = graph.resolverUsage.get(name) ?? /* @__PURE__ */ new Map();
+	let registrations = state.registrations.get(name);
+	for (let id of serverIds) {
+		for (let input of literalInputs(usage, id)) entryIds.add(inputPath(root, input.key));
+		for (let entry of registrations?.get(id) ?? []) entryIds.add(entry);
+	}
+	let entries = Object.create(null);
+	let assets = Object.create(null);
+	let scripts = [];
+	for (let id of entryIds) {
+		let url = base + servedPath(root, id);
+		if (isCSSRequest(id) || config.assetsInclude(id.split("?")[0])) assets[sourceKey(root, id)] = url;
+		else {
+			entries[sourceKey(root, id)] = url;
+			scripts.push(id);
+		}
+	}
+	let clientIds = await walkGraph(clientEnvironment, scripts, environmentEdges(graph, "client"));
+	let serverModules = Object.create(null);
+	for (let id of serverIds) {
+		if (!sourceModule(id)) continue;
+		serverModules[sourceKey(root, id)] = {
+			preloads: [],
+			stylesheets: staticStylesheets(serverEdges, id).map((stylesheet) => base + servedPath(root, stylesheet))
+		};
+	}
+	let clientModules = Object.create(null);
+	for (let id of clientIds) if (sourceModule(id)) clientModules[sourceKey(root, id)] = {
+		preloads: [],
+		stylesheets: []
+	};
+	return {
+		manifest: {
+			mode: "dev",
+			environments: {
+				client: {
+					role: "client",
+					modules: clientModules
+				},
+				[name]: {
+					role: "server",
+					modules: serverModules
+				}
+			},
+			entries,
+			assets,
+			serverEnvironment: name
+		},
+		server: serverIds,
+		client: clientIds
+	};
+}
+//#endregion
+//#region src/vite/dev.ts
+/**
+* Serves `@pitlane/assets/manifest` during `vite dev` as a data snapshot of
+* each server environment's module graph, and invalidates it when a change
+* could alter the stylesheets, routes, or browser entries it records.
+*/
+function assetDevelopment(state) {
+	let server;
+	let graph = {
+		roots: /* @__PURE__ */ new Map(),
+		edges: /* @__PURE__ */ new Map(),
+		resolverUsage: /* @__PURE__ */ new Map()
+	};
+	let snapshots = /* @__PURE__ */ new Map();
+	let building = /* @__PURE__ */ new Set();
+	/** Server environments invalidated while their snapshot was being built. */
+	let stale = /* @__PURE__ */ new Set();
+	/** Environment name → module id → where its last hard invalidation is on the transform timeline. */
+	let invalidations = /* @__PURE__ */ new Map();
+	/**
+	* Invalidates a server environment's manifest and, through Vite, every
+	* module importing it. A manifest being built is marked instead, and
+	* `load` builds it again, since Vite would cache the code `load` returns.
+	*/
+	function invalidate(name, timestamp) {
+		if (building.has(name)) return void stale.add(name);
+		let environment = server?.environments[name];
+		let manifest = environment?.moduleGraph.getModuleById(MANIFEST_ID);
+		if (manifest) environment.moduleGraph.invalidateModule(manifest, /* @__PURE__ */ new Set(), timestamp, true);
+	}
+	/** The modules of `environment` a server environment's snapshot was computed from. */
+	function tracked(environment, serverName) {
+		let snapshot = snapshots.get(serverName);
+		if (environment === serverName) return snapshot?.server;
+		if (environment === "client") return snapshot?.client;
+	}
+	/** Invalidates every snapshot computed, or being computed, from module `id` of `environment`. */
+	function invalidateSnapshotsWith(environment, id, timestamp) {
+		for (let serverName of snapshots.keys()) if (tracked(environment, serverName)?.has(id)) invalidate(serverName, timestamp);
+		for (let serverName of building) if (environment === serverName || environment === "client") stale.add(serverName);
+	}
+	function sameEdges(previous, next) {
+		return previous.static.length === next.static.length && previous.dynamic.length === next.dynamic.length && previous.static.every((edge, index) => edge === next.static[index]) && previous.dynamic.every((edge, index) => edge === next.dynamic[index]);
+	}
+	/**
+	* Records what a transform of module `id` found: its edges and, in a
+	* server environment, its resolver usage.
+	*/
+	function recordTransform(environment, id, edges, usage) {
+		let edgeRecords = environmentEdges(graph, environment);
+		let previous = edgeRecords.get(id);
+		edgeRecords.set(id, edges);
+		if (previous && !sameEdges(previous, edges)) invalidateSnapshotsWith(environment, id);
+		let usageRecords = graph.resolverUsage.get(environment);
+		if (usage) usageRecords?.set(id, usage);
+		else usageRecords?.delete(id);
+	}
+	return {
+		name: "pitlane-assets-dev",
+		apply: "serve",
+		enforce: "post",
+		configureServer: {
+			order: "pre",
+			handler(devServer) {
+				server = devServer;
+				for (let environment of Object.values(devServer.environments)) {
+					let { name, moduleGraph } = environment;
+					let edges = environmentEdges(graph, name);
+					let invalidated = /* @__PURE__ */ new Map();
+					invalidations.set(name, invalidated);
+					let invalidateModule = moduleGraph.invalidateModule;
+					moduleGraph.invalidateModule = (mod, seen, timestamp, isHmr, softInvalidate) => {
+						if (!softInvalidate && mod.id && mod.id !== "\0pitlane:assets-manifest" && !isCSSRequest(mod.id)) {
+							edges.delete(mod.id);
+							if (!isHmr) invalidated.set(mod.id, countInvalidation());
+							invalidateSnapshotsWith(name, mod.id, timestamp);
+						}
+						invalidateModule.call(moduleGraph, mod, seen, timestamp, isHmr, softInvalidate);
+					};
+					let { transformRequest, warmupRequest } = environment;
+					environment.transformRequest = (url) => startRequest(() => transformRequest.call(environment, url));
+					environment.warmupRequest = (url) => startRequest(() => warmupRequest.call(environment, url));
+					if (!state.serverEnvironments.includes(name)) continue;
+					let roots = /* @__PURE__ */ new Set();
+					graph.roots.set(name, roots);
+					graph.resolverUsage.set(name, /* @__PURE__ */ new Map());
+					let fetchModule = environment.fetchModule;
+					environment.fetchModule = async (id, importer, options) => {
+						let fetched = await fetchModule.call(environment, id, importer, options);
+						if (!importer && "id" in fetched && fetched.id !== "\0pitlane:assets-manifest") {
+							roots.add(fetched.id);
+							let snapshot = snapshots.get(name);
+							if (snapshot && !snapshot.server.has(fetched.id)) invalidate(name);
+						}
+						return fetched;
+					};
+				}
+				state.onRegistrationChange = (environment, owner) => {
+					if (building.has(environment)) return;
+					if (snapshots.get(environment)?.server.has(owner)) invalidate(environment);
+				};
+			}
+		},
+		async load(id) {
+			if (id !== "\0pitlane:assets-manifest") return;
+			let { name, config } = this.environment;
+			if (config.consumer === "client") {
+				let message = `[assets] ${assetsSpecifier("manifest")} describes the server's module graph and cannot run in the browser. Resolve asset URLs in server code and pass them to the page.`;
+				return `throw new Error(${JSON.stringify(message)});\nexport default undefined;\n`;
+			}
+			if (!state.serverEnvironments.includes(name)) throw unservedEnvironmentError(name, state.serverEnvironments);
+			building.add(name);
+			try {
+				let snapshot;
+				let passes = 0;
+				do {
+					stale.delete(name);
+					snapshot = await createDevSnapshot(server, state, graph, name);
+				} while (stale.has(name) && ++passes < 3);
+				snapshots.set(name, snapshot);
+				if (stale.has(name)) {
+					let { moduleGraph } = server.environments[name];
+					moduleGraph.invalidateModule(await moduleGraph.ensureEntryFromUrl(MANIFEST_ID));
+				}
+				return `export default JSON.parse(${JSON.stringify(JSON.stringify(snapshot.manifest))});\n`;
+			} finally {
+				building.delete(name);
+				stale.delete(name);
+			}
+		},
+		transform: { async handler(code, id) {
+			if (id === "\0pitlane:assets-manifest" || isCSSRequest(id)) return;
+			let name = this.environment.name;
+			let invalidated = invalidations.get(name);
+			let started = requestStarted();
+			let resolve = (specifier) => this.resolve(specifier, id);
+			let resolveAll = async (list) => {
+				let resolved = await Promise.all(list.map(resolve));
+				return [...new Set(resolved.flatMap((result) => result && !result.external ? [result.id] : []))];
+			};
+			let specifiers = importSpecifiers(code);
+			let usage = state.serverEnvironments.includes(name) ? scanResolverUsage(code, id) : void 0;
+			let [staticEdges, dynamicEdges, linkedUsage] = await Promise.all([
+				resolveAll(specifiers.static),
+				resolveAll(specifiers.dynamic),
+				usage && linkResolverUsage(usage, resolve)
+			]);
+			if ((invalidated?.get(id) ?? 0) > started) return;
+			recordTransform(name, id, {
+				static: staticEdges,
+				dynamic: dynamicEdges
+			}, linkedUsage);
+		} },
+		hotUpdate: {
+			order: "post",
+			handler({ type, file, modules, timestamp }) {
+				if (type === "update" && isCSSRequest(file)) return;
+				let path = normalizePath(file);
+				if (type === "delete") {
+					for (let roots of graph.roots.values()) for (let root of roots) if (root.split("?")[0] === path) roots.delete(root);
+					for (let owners of [...state.registrations.values(), ...graph.resolverUsage.values()]) for (let owner of owners.keys()) if (owner.split("?")[0] === path) owners.delete(owner);
+				}
+				let name = this.environment.name;
+				let ids = modules.flatMap((module) => module.id ? [module.id] : []);
+				for (let serverName of snapshots.keys()) {
+					let set = tracked(name, serverName);
+					if (set && (set.has(path) || ids.some((id) => set.has(id)))) invalidate(serverName, timestamp);
+				}
+			}
+		}
+	};
+}
+//#endregion
+//#region src/vite-plugin.ts
+/**
+* The Vite plugins that give `@pitlane/assets` its manifest: they serve
+* browser entries during `vite dev`, emit them in a build, and replace
+* `@pitlane/assets/manifest` with the manifest of the current dev server or
+* build. Setting `allowFiles` also enforces the browser boundary.
+*
+* @throws When `allowPackages` or `denyFiles` is set without `allowFiles`.
+*/
+function assets(options = {}) {
+	let { allowFiles, allowPackages, denyFiles } = options;
+	if (!allowFiles && (allowPackages || denyFiles)) throw new Error("[assets] allowPackages and denyFiles refine allowFiles. Set allowFiles to turn on the browser boundary.");
+	let state = {
+		serverEnvironments: options.serverEnvironments ?? ["ssr"],
+		inputs: /* @__PURE__ */ new Map(),
+		resolverUsage: /* @__PURE__ */ new Map(),
+		registrations: /* @__PURE__ */ new Map(),
+		assetReferences: /* @__PURE__ */ new Map(),
+		scriptReferences: /* @__PURE__ */ new Map(),
+		outputs: /* @__PURE__ */ new Map(),
+		mapsEnabled: false
+	};
+	return [
+		{
+			name: "pitlane-assets",
+			api: { setBrowserEntries({ environment, owner, entries }) {
+				if (!state.serverEnvironments.includes(environment)) throw new Error(`[assets] Cannot register browser entries from "${environment}": it is not in serverEnvironments.`);
+				let owners = state.registrations.get(environment);
+				let previous = owners?.get(owner);
+				if (!previous && entries.length === 0 || previous?.length === entries.length && entries.every((id, index) => id === previous[index])) return;
+				if (entries.length === 0) {
+					owners.delete(owner);
+					if (owners.size === 0) state.registrations.delete(environment);
+				} else {
+					if (!owners) state.registrations.set(environment, owners = /* @__PURE__ */ new Map());
+					owners.set(owner, entries.slice());
+				}
+				state.onRegistrationChange?.(environment, owner);
+			} },
+			enforce: "post",
+			sharedDuringBuild: true,
+			config(config) {
+				state.mapsEnabled = options.chunkImportMap ?? config.environments?.client?.build?.chunkImportMap ?? config.build?.chunkImportMap ?? false;
+				if (state.mapsEnabled && config.experimental?.renderBuiltUrl) throw new Error("[assets] chunkImportMap: true cannot be combined with experimental.renderBuiltUrl.");
+				return {
+					builder: {},
+					build: { assetsInlineLimit: 0 },
+					optimizeDeps: { exclude: ["@pitlane/assets/manifest", "pitlane/assets/manifest"] },
+					environments: { client: { build: { chunkImportMap: state.mapsEnabled } } }
+				};
+			},
+			configResolved(config) {
+				state.config = config;
+				for (let key of options.include ?? []) {
+					let id = inputPath(config.root, key);
+					state.inputs.set(id, {
+						key: sourceKey(config.root, id),
+						kind: "asset"
+					});
+				}
+			},
+			configEnvironment(name) {
+				if (!state.serverEnvironments.includes(name)) return;
+				return {
+					resolve: { noExternal: [/^@pitlane\/assets(?:\/|$)/, /^pitlane(?:\/|$)/] },
+					optimizeDeps: { exclude: ["@pitlane/assets/manifest", "pitlane/assets/manifest"] },
+					build: { chunkImportMap: false }
+				};
+			},
+			resolveId: {
+				order: "pre",
+				handler(id) {
+					if (id !== "@pitlane/assets/manifest" && id !== "pitlane/assets/manifest") return;
+					if (this.environment.mode === "build" && this.environment.name === "client") throw new Error("[assets] The asset manifest is server-only; keep resolver lookups out of browser modules.");
+					if (this.environment.mode !== "build") return MANIFEST_ID;
+					if (!state.serverEnvironments.includes(this.environment.name)) throw unservedEnvironmentError(this.environment.name, state.serverEnvironments);
+					return {
+						id: MANIFEST_EXTERNAL,
+						external: true
+					};
+				}
+			},
+			async transform(code, id) {
+				let { mode, name } = this.environment;
+				if (mode !== "build" || !state.serverEnvironments.includes(name)) return;
+				let modules = state.resolverUsage.get(name);
+				if (!modules) state.resolverUsage.set(name, modules = /* @__PURE__ */ new Map());
+				let usage = scanResolverUsage(code, id);
+				if (!usage) return void modules.delete(id);
+				modules.set(id, await linkResolverUsage(usage, (specifier) => this.resolve(specifier, id)));
+			}
+		},
+		assetBuild(state),
+		assetDevelopment(state),
+		assetStyles(),
+		allowFiles && browserBoundary({
+			allowFiles,
+			allowPackages,
+			denyFiles
+		}, state.serverEnvironments)
+	];
+}
+//#endregion
+export { ASSETS_MANIFEST_FILE, assets };