@pitlane/assets 0.0.0-stage → 0.1.0

package/dist/vite-plugin.mjs

@@ -0,0 +1,968 @@
+import { n as quotedList, t as assetsSpecifier } from "./specifier-DLC81sXY.mjs";
+import { t as createAssetManifest } from "./build-BbA-Zq1m.mjs";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { basename, dirname, isAbsolute, posix, relative, resolve } from "node:path";
+import { isCSSRequest, normalizePath, parseSync } from "vite";
+import { fileURLToPath } from "node:url";
+import MagicString from "magic-string";
+import { existsSync } from "node:fs";
+//#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/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] : []);
+	for (let output of Object.values(bundle)) {
+		if (output.type === "asset") {
+			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 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
+const 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, MANIFEST_FILE), `export default JSON.parse(${JSON.stringify(JSON.stringify({
+			...manifest,
+			serverEnvironment: name
+		}))});\n`);
+		for (let asset of Object.values(output.bundle)) {
+			if (asset.type !== "asset" || twins.get(name).has(asset.fileName)) continue;
+			let destination = resolve(client.outDir, asset.fileName);
+			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), 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/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));
+}
+/**
+* Server discovery must not populate `transformResult`: the module runner
+* would treat its stale instance as current. Client transforms may warm
+* and cache their dependencies after the optimizer has initialized.
+*/
+async function analyze(environment, id, edges) {
+	if (environment.moduleGraph.getModuleById(id)?.transformResult && edges.has(id)) return;
+	let { root } = environment.config;
+	try {
+		await environment.moduleGraph.ensureEntryFromUrl(servedPath(root, id));
+		let loaded = await environment.pluginContainer.load(id);
+		let code = loaded == null ? null : typeof loaded === "string" ? loaded : loaded.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);
+	} 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 });
+	}
+}
+/**
+* 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();
+	/** Invalidates a server environment's manifest and, through Vite, every module importing it. */
+	function invalidate(name, timestamp) {
+		let environment = server?.environments[name];
+		let manifest = environment?.moduleGraph.getModuleById(MANIFEST_ID);
+		if (manifest) environment.moduleGraph.invalidateModule(manifest, /* @__PURE__ */ new Set(), timestamp, true);
+	}
+	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 } = environment;
+					if (!state.serverEnvironments.includes(name)) continue;
+					let roots = /* @__PURE__ */ new Set();
+					graph.roots.set(name, roots);
+					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 = await createDevSnapshot(server, state, graph, name);
+				snapshots.set(name, snapshot);
+				return `export default JSON.parse(${JSON.stringify(JSON.stringify(snapshot.manifest))});\n`;
+			} finally {
+				building.delete(name);
+			}
+		},
+		transform: { async handler(code, id) {
+			if (id === "\0pitlane:assets-manifest" || isCSSRequest(id)) return;
+			let name = this.environment.name;
+			let specifiers = importSpecifiers(code);
+			let resolveAll = async (list) => {
+				let resolved = await Promise.all(list.map((specifier) => this.resolve(specifier, id)));
+				return [...new Set(resolved.flatMap((result) => result && !result.external ? [result.id] : []))];
+			};
+			let [staticEdges, dynamicEdges] = await Promise.all([resolveAll(specifiers.static), resolveAll(specifiers.dynamic)]);
+			environmentEdges(graph, name).set(id, {
+				static: staticEdges,
+				dynamic: dynamicEdges
+			});
+			if (!state.serverEnvironments.includes(name)) return;
+			let modules = graph.resolverUsage.get(name);
+			if (!modules) graph.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)));
+		} },
+		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, snapshot] of snapshots) {
+					let tracked = name === serverName ? snapshot.server : name === "client" ? snapshot.client : void 0;
+					if (tracked && (tracked.has(path) || ids.some((id) => tracked.has(id)))) invalidate(serverName, timestamp);
+				}
+			}
+		}
+	};
+}
+//#endregion
+//#region src/vite-plugin.ts
+function assets(options = {}) {
+	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()
+	];
+}
+//#endregion
+export { assets };