@warlock.js/web 5.1.0 → 5.2.0

package/esm/server/stylesheet-urls.mjs

@@ -1,10 +1,10 @@
 import { CLIENT_ASSET_URL_PREFIX } from "./client-asset-url-prefix.mjs";
-import path from "node:path";
 import { readFileSync } from "node:fs";
+import path from "node:path";
 
-//#region ../web/src/server/stylesheet-urls.ts
+//#region web/src/server/stylesheet-urls.ts
 /**
-* Which stylesheets a document must link, in each of the two modes.
+* Which stylesheets a REGISTERED HANDLER must link, in each of the two modes.
 *
 * WHY THIS EXISTS AT ALL. Nothing used to put CSS into the server-rendered
 * document. A stylesheet reached the browser only because the CLIENT bundle
@@ -13,13 +13,22 @@ import { readFileSync } from "node:fs";
 * moment later. The markup was correct the whole time, which is precisely why
 * it was easy to miss.
 *
+* THE SCOPE IS PER HANDLER, NOT PER APPLICATION. Every page renders inside
+* `[root, ...outer-to-inner matched layouts, page]` — that is the exact triple
+* (widened to a chain) `create-page-route-handler.ts` loads per request — so a
+* handler's CSS is the ordered, deduped union of what those specific source
+* files pull in, and nothing else. Collecting across the WHOLE application
+* (every page's manifest entry, every root import) is the bug this shape
+* exists to avoid: it ships page B's stylesheet on page A's response, and it
+* only gets worse as an application grows.
+*
 * The two modes learn the answer from different places, and neither can use
 * the other's:
 *
-*  - PRODUCTION reads Vite's client manifest, the same artifact the hydration
-*    entry is already resolved from.
+*  - PRODUCTION reads Vite's client manifest, matching each source file's own
+*    id and walking its recorded `css` and imported chunks.
 *  - DEV has no manifest — Vite serves modules on demand — so the URLs are
-*    derived from the source files themselves.
+*    derived from each source file's own import statements.
 */
 /** Stylesheet extensions Vite can serve directly. Mirrors the build's list. */
 const STYLE_EXTENSIONS = [
@@ -30,39 +39,53 @@ const STYLE_EXTENSIONS = [
 	".styl"
 ];
 /**
-* The stylesheets the ROOT document imports, as dev URLs.
-*
-* Dev has no manifest, so the source is the root file itself: whatever
-* `root.tsx` imports with a stylesheet extension is what the document needs.
-* That is deliberately narrow — it answers "what CSS does this application
-* set up globally", which is where `app.css` lives and where Tailwind is
-* wired, and it does NOT try to reproduce Vite's per-route CSS graph.
-*
-* The narrowness is the honest part: production splits CSS per chunk, dev
-* links the root's stylesheets on every page. A page whose own module imports
-* its own stylesheet still gets it in dev — Vite's client graph injects it as
-* before — it simply is not render-blocking the way the root's is. That is a
-* smaller gap than the flash this removes, and it is stated rather than
-* hidden.
-*
-* Specifiers are resolved against the root file and expressed relative to the
-* app root, because that is the shape Vite's dev server serves from.
+* A stylesheet Vite serves in DEV must be requested with `?direct`.
+*
+* Without it Vite answers the same URL with `text/javascript` — its CSS-as-JS
+* module transform, meant for `import "./app.css"` — and a
+* `<link rel="stylesheet">` pointing at a JavaScript response applies
+* NOTHING, silently. No console error, no network failure, just an unstyled
+* page. `?direct` is what makes Vite reply with real `text/css`.
 */
-function devStylesheetUrls(appRoot, appFile) {
+const VITE_DIRECT_CSS_QUERY = "?direct";
+/**
+* ONE source file's own directly imported stylesheets, as dev URLs.
+*
+* Dev has no manifest, so the source is the file itself: whatever it imports
+* with a stylesheet extension is what it needs. This is deliberately narrow —
+* it answers "what CSS does THIS file set up", not "what CSS does the whole
+* module graph this file eventually reaches end up pulling in" — because the
+* latter would require reproducing Vite's module graph, which is precisely
+* what dev has no manifest to shortcut.
+*
+* The narrowness is the honest part: production splits CSS per chunk and can
+* follow imported chunks (`productionStylesheetUrls` below); dev can only read
+* the ONE file handed to it. A page whose own module imports its own
+* stylesheet still gets it in dev — Vite's client graph injects it as before —
+* it simply is not render-blocking the way a chain member's own import is.
+*
+* Called once per chain member — root, then every matched layout outer to
+* inner, then the page — by the installers below, which is what turns "one
+* file's own imports" into a handler's whole CSS chain.
+*
+* Specifiers are resolved against `sourceFile` and expressed relative to
+* `appRoot`, because that is the shape Vite's dev server serves from.
+*/
+function devStylesheetUrls(appRoot, sourceFile) {
 	let source;
 	try {
-		source = readFileSync(appFile, "utf-8");
+		source = readFileSync(sourceFile, "utf-8");
 	} catch {
 		return [];
 	}
 	const urls = [];
-	const pattern = /\bimport\s*["']([^"']+)["']/g;
+	const pattern = /\bimport\s*(?:\(\s*)?["']([^"']+)["']/g;
 	let match = pattern.exec(source);
 	while (match !== null) {
 		const specifier = match[1];
 		const lowered = specifier.toLowerCase();
 		if (STYLE_EXTENSIONS.some((extension) => lowered.endsWith(extension))) {
-			const absolute = path.resolve(path.dirname(appFile), specifier);
+			const absolute = path.resolve(path.dirname(sourceFile), specifier);
 			const relative = path.relative(appRoot, absolute).split(path.sep).join("/");
 			if (!relative.startsWith("..")) {
 				const url = `/${relative}${VITE_DIRECT_CSS_QUERY}`;
@@ -74,33 +97,93 @@ function devStylesheetUrls(appRoot, appFile) {
 	return urls;
 }
 /**
-* A stylesheet Vite serves in DEV must be requested with `?direct`.
+* ONE handler's whole dev CSS chain: every `sourceFiles` member's own direct
+* stylesheet imports (`devStylesheetUrls`), in the order given — the caller
+* passes `[root, ...outer-to-inner matched layouts, page]` — concatenated and
+* deduped across the WHOLE chain, not just within one file.
 *
-* Without it Vite answers the same URL with `text/javascript` — its CSS-as-JS
-* module transform, meant for `import "./app.css"` — and a
-* `<link rel="stylesheet">` pointing at a JavaScript response applies
-* NOTHING, silently. No console error, no network failure, just an unstyled
-* page. `?direct` is what makes Vite reply with real `text/css`.
+* Cross-file dedup matters as much as within-file dedup: an application-wide
+* `app.css` imported by both the root and a page must still produce one
+* `<link>`, not two.
 */
-const VITE_DIRECT_CSS_QUERY = "?direct";
+function devHandlerStylesheetUrls(appRoot, sourceFiles) {
+	const urls = [];
+	for (const sourceFile of sourceFiles) for (const url of devStylesheetUrls(appRoot, sourceFile)) if (!urls.includes(url)) urls.push(url);
+	return urls;
+}
 /**
-* Every stylesheet the client build emitted, as URLs the asset route serves.
+* Find the manifest key for an app-root-relative POSIX source id.
 *
-* Vite records CSS against the CHUNK that imported it — an app whose
-* `root.tsx` imports `app.css` produces a `root.tsx` entry carrying
-* `css: ["assets/root-<hash>.css"]`, not a hydration entry carrying it. So
-* this collects across every entry rather than looking under one name, which
-* would silently find nothing the moment a stylesheet moved file.
+* VITE KEYS BY SOURCE PATH RELATIVE TO ITS OWN `root`, not to the app's
+* `appRoot` — the client build's `root` is the framework's own package
+* (`build-client.ts`), so a key for an app source file carries a `../`-laden
+* prefix (`"../my-app/src/web/root.tsx"`) rather than matching `sourceFile`
+* (`"src/web/root.tsx"`) byte for byte. The two forms always share the same
+* TAIL, though — both are anchored at the same file — so an exact match is
+* tried first (the case where the client build's root IS the app root, which
+* every fixture and every test below uses) and a `/`-boundary suffix match
+* second, rather than trying to reconstruct the build's own root here, which
+* this runtime read has no way to independently confirm.
+*/
+function findManifestKey(manifest, sourceFile) {
+	if (manifest[sourceFile] !== void 0) return sourceFile;
+	const suffix = `/${sourceFile}`;
+	for (const key of Object.keys(manifest)) if (key.endsWith(suffix)) return key;
+}
+/**
+* Every stylesheet reachable from ONE manifest entry: its own recorded `css`,
+* plus the same walk repeated over every chunk it STATICALLY `imports`.
+*
+* `imports` only, never `dynamicImports`. Vite's manifest records
+* `dynamicImports` on shared entry points (the hydration entry names every
+* page as one) precisely because the browser must NOT download them eagerly —
+* walking that array here would pull every other page's CSS onto this one,
+* which is the exact "unrelated pages" leak this module exists to end.
+* `imports`, by contrast, are chunks THIS module synchronously depends on:
+* code Vite split out of it but that loads whenever it does, so their CSS is
+* this handler's CSS too.
 *
-* Duplicates are collapsed and order is preserved: two chunks importing the
-* same stylesheet must not emit two `<link>` tags.
+* `visited` guards against a chunk graph cycle; sharing one set across the
+* whole walk from a single entry is enough; a shared chunk revisited from a
+* SEPARATE top-level entry (root vs. a layout vs. the page) is deliberately
+* walked again — the final merge in `productionStylesheetUrls` dedupes by URL,
+* and a fresh `visited` set per entry is simpler to reason about than one
+* threaded across unrelated chains.
+*/
+function collectManifestCss(manifest, key, visited) {
+	if (visited.has(key)) return [];
+	visited.add(key);
+	const entry = manifest[key];
+	if (entry === void 0) return [];
+	const ownCss = Array.isArray(entry.css) ? entry.css.filter((file) => typeof file === "string" && file !== "") : [];
+	const imports = Array.isArray(entry.imports) ? entry.imports.filter((id) => typeof id === "string") : [];
+	return [...ownCss, ...imports.flatMap((importedKey) => collectManifestCss(manifest, importedKey, visited))];
+}
+/**
+* ONE handler's whole production CSS chain.
+*
+* `sourceFiles` is `[root, ...outer-to-inner matched layouts, page]`, each an
+* app-root-relative POSIX source id — the SAME id
+* `install-page-routes-from-manifest.ts` already carries as `sourceFile` on
+* every manifest entry, because that identity is what lets this function match
+* EXPLICITLY rather than guess: every id is looked up on its own
+* (`findManifestKey`), its own chunk's CSS is collected
+* (`collectManifestCss`), and an id with no matching entry contributes
+* nothing — it is never treated as license to fall back to scanning the whole
+* manifest, which is what let an unrelated page's CSS leak onto this handler
+* before.
+*
+* Duplicates are collapsed and order is preserved across the WHOLE chain, in
+* the order `sourceFiles` was given — root's own CSS first, then each
+* layout's outer to inner, then the page's — so cascade order matches the
+* chain's own outer-to-inner rendering order.
 *
 * A missing or malformed manifest returns NOTHING rather than throwing. The
 * hydration resolver already fails loudly on exactly those conditions, from
 * exactly the same file, and it runs first — a second, worse error for the
 * same cause helps nobody.
 */
-function productionStylesheetUrls(clientDir) {
+function productionStylesheetUrls(clientDir, sourceFiles) {
 	const manifestPath = path.join(clientDir, ".vite", "manifest.json");
 	let manifest;
 	try {
@@ -109,19 +192,21 @@ function productionStylesheetUrls(clientDir) {
 		return [];
 	}
 	if (typeof manifest !== "object" || manifest === null) return [];
+	const files = [];
+	for (const sourceFile of sourceFiles) {
+		const key = findManifestKey(manifest, sourceFile);
+		if (key === void 0) continue;
+		files.push(...collectManifestCss(manifest, key, /* @__PURE__ */ new Set()));
+	}
 	const urls = [];
-	for (const entry of Object.values(manifest)) {
-		if (entry === void 0 || !Array.isArray(entry.css)) continue;
-		for (const file of entry.css) {
-			if (typeof file !== "string" || file === "") continue;
-			const url = `/${file}`;
-			if (!url.startsWith(`${"/assets"}/`)) continue;
-			if (!urls.includes(url)) urls.push(url);
-		}
+	for (const file of files) {
+		const url = `/${file}`;
+		if (!url.startsWith(`${"/assets"}/`)) continue;
+		if (!urls.includes(url)) urls.push(url);
 	}
 	return urls;
 }
 
 //#endregion
-export { VITE_DIRECT_CSS_QUERY, devStylesheetUrls, productionStylesheetUrls };
+export { VITE_DIRECT_CSS_QUERY, devHandlerStylesheetUrls, devStylesheetUrls, productionStylesheetUrls };
 //# sourceMappingURL=stylesheet-urls.mjs.map

package/esm/server/stylesheet-urls.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"stylesheet-urls.mjs","names":[],"sources":["../../../../../../../web/src/server/stylesheet-urls.ts"],"sourcesContent":["/**\n * Which stylesheets a document must link, in each of the two modes.\n *\n * WHY THIS EXISTS AT ALL. Nothing used to put CSS into the server-rendered\n * document. A stylesheet reached the browser only because the CLIENT bundle\n * imported it, which means JavaScript applied it after the module graph\n * loaded — so every full page load painted unstyled first and restyled a\n * moment later. The markup was correct the whole time, which is precisely why\n * it was easy to miss.\n *\n * The two modes learn the answer from different places, and neither can use\n * the other's:\n *\n *  - PRODUCTION reads Vite's client manifest, the same artifact the hydration\n *    entry is already resolved from.\n *  - DEV has no manifest — Vite serves modules on demand — so the URLs are\n *    derived from the source files themselves.\n */\nimport { readFileSync } from \"node:fs\";\nimport path from \"node:path\";\nimport { CLIENT_ASSET_URL_PREFIX } from \"./client-asset-url-prefix\";\n\n/** Stylesheet extensions Vite can serve directly. Mirrors the build's list. */\nconst STYLE_EXTENSIONS = [\".css\", \".scss\", \".sass\", \".less\", \".styl\"];\n\n/**\n * The stylesheets the ROOT document imports, as dev URLs.\n *\n * Dev has no manifest, so the source is the root file itself: whatever\n * `root.tsx` imports with a stylesheet extension is what the document needs.\n * That is deliberately narrow — it answers \"what CSS does this application\n * set up globally\", which is where `app.css` lives and where Tailwind is\n * wired, and it does NOT try to reproduce Vite's per-route CSS graph.\n *\n * The narrowness is the honest part: production splits CSS per chunk, dev\n * links the root's stylesheets on every page. A page whose own module imports\n * its own stylesheet still gets it in dev — Vite's client graph injects it as\n * before — it simply is not render-blocking the way the root's is. That is a\n * smaller gap than the flash this removes, and it is stated rather than\n * hidden.\n *\n * Specifiers are resolved against the root file and expressed relative to the\n * app root, because that is the shape Vite's dev server serves from.\n */\nexport function devStylesheetUrls(appRoot: string, appFile: string): string[] {\n  let source: string;\n\n  try {\n    source = readFileSync(appFile, \"utf-8\");\n  } catch {\n    return [];\n  }\n\n  const urls: string[] = [];\n  const pattern = /\\bimport\\s*[\"']([^\"']+)[\"']/g;\n\n  let match = pattern.exec(source);\n\n  while (match !== null) {\n    const specifier = match[1];\n    const lowered = specifier.toLowerCase();\n\n    if (STYLE_EXTENSIONS.some((extension) => lowered.endsWith(extension))) {\n      const absolute = path.resolve(path.dirname(appFile), specifier);\n      const relative = path.relative(appRoot, absolute).split(path.sep).join(\"/\");\n\n      // Outside the app root Vite would need an `/@fs/` URL and a widened\n      // `fs.allow`; a stylesheet living there is unusual enough that guessing\n      // is worse than leaving it to the client import.\n      if (!relative.startsWith(\"..\")) {\n        const url = `/${relative}${VITE_DIRECT_CSS_QUERY}`;\n\n        if (!urls.includes(url)) urls.push(url);\n      }\n    }\n\n    match = pattern.exec(source);\n  }\n\n  return urls;\n}\n\n/**\n * A stylesheet Vite serves in DEV must be requested with `?direct`.\n *\n * Without it Vite answers the same URL with `text/javascript` — its CSS-as-JS\n * module transform, meant for `import \"./app.css\"` — and a\n * `<link rel=\"stylesheet\">` pointing at a JavaScript response applies\n * NOTHING, silently. No console error, no network failure, just an unstyled\n * page. `?direct` is what makes Vite reply with real `text/css`.\n */\nexport const VITE_DIRECT_CSS_QUERY = \"?direct\";\n\ntype ManifestEntry = {\n  css?: unknown;\n  file?: unknown;\n};\n\n/**\n * Every stylesheet the client build emitted, as URLs the asset route serves.\n *\n * Vite records CSS against the CHUNK that imported it — an app whose\n * `root.tsx` imports `app.css` produces a `root.tsx` entry carrying\n * `css: [\"assets/root-<hash>.css\"]`, not a hydration entry carrying it. So\n * this collects across every entry rather than looking under one name, which\n * would silently find nothing the moment a stylesheet moved file.\n *\n * Duplicates are collapsed and order is preserved: two chunks importing the\n * same stylesheet must not emit two `<link>` tags.\n *\n * A missing or malformed manifest returns NOTHING rather than throwing. The\n * hydration resolver already fails loudly on exactly those conditions, from\n * exactly the same file, and it runs first — a second, worse error for the\n * same cause helps nobody.\n */\nexport function productionStylesheetUrls(clientDir: string): string[] {\n  const manifestPath = path.join(clientDir, \".vite\", \"manifest.json\");\n\n  let manifest: Record<string, ManifestEntry | undefined>;\n\n  try {\n    manifest = JSON.parse(readFileSync(manifestPath, \"utf-8\")) as Record<\n      string,\n      ManifestEntry | undefined\n    >;\n  } catch {\n    return [];\n  }\n\n  if (typeof manifest !== \"object\" || manifest === null) return [];\n\n  const urls: string[] = [];\n\n  for (const entry of Object.values(manifest)) {\n    if (entry === undefined || !Array.isArray(entry.css)) continue;\n\n    for (const file of entry.css) {\n      if (typeof file !== \"string\" || file === \"\") continue;\n\n      // Built EXACTLY as the hydration entry's URL is built — `/${file}`, then\n      // checked against the prefix — rather than reassembled from a basename.\n      // The manifest already records `assets/root-<hash>.css`, and rebuilding\n      // that path here would be a second expression of a convention\n      // `client-asset-url-prefix.ts` owns.\n      const url = `/${file}`;\n\n      // A stylesheet outside the directory the asset route mounts would 404.\n      // Dropped rather than emitted, because a dead <link> in <head> is a\n      // silent styling failure — the exact thing this module exists to end.\n      if (!url.startsWith(`${CLIENT_ASSET_URL_PREFIX}/`)) continue;\n\n      if (!urls.includes(url)) urls.push(url);\n    }\n  }\n\n  return urls;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;AAuBA,MAAM,mBAAmB;CAAC;CAAQ;CAAS;CAAS;CAAS;AAAO;;;;;;;;;;;;;;;;;;;;AAqBpE,SAAgB,kBAAkB,SAAiB,SAA2B;CAC5E,IAAI;CAEJ,IAAI;EACF,SAAS,aAAa,SAAS,OAAO;CACxC,QAAQ;EACN,OAAO,CAAC;CACV;CAEA,MAAM,OAAiB,CAAC;CACxB,MAAM,UAAU;CAEhB,IAAI,QAAQ,QAAQ,KAAK,MAAM;CAE/B,OAAO,UAAU,MAAM;EACrB,MAAM,YAAY,MAAM;EACxB,MAAM,UAAU,UAAU,YAAY;EAEtC,IAAI,iBAAiB,MAAM,cAAc,QAAQ,SAAS,SAAS,CAAC,GAAG;GACrE,MAAM,WAAW,KAAK,QAAQ,KAAK,QAAQ,OAAO,GAAG,SAAS;GAC9D,MAAM,WAAW,KAAK,SAAS,SAAS,QAAQ,CAAC,CAAC,MAAM,KAAK,GAAG,CAAC,CAAC,KAAK,GAAG;GAK1E,IAAI,CAAC,SAAS,WAAW,IAAI,GAAG;IAC9B,MAAM,MAAM,IAAI,WAAW;IAE3B,IAAI,CAAC,KAAK,SAAS,GAAG,GAAG,KAAK,KAAK,GAAG;GACxC;EACF;EAEA,QAAQ,QAAQ,KAAK,MAAM;CAC7B;CAEA,OAAO;AACT;;;;;;;;;;AAWA,MAAa,wBAAwB;;;;;;;;;;;;;;;;;;AAwBrC,SAAgB,yBAAyB,WAA6B;CACpE,MAAM,eAAe,KAAK,KAAK,WAAW,SAAS,eAAe;CAElE,IAAI;CAEJ,IAAI;EACF,WAAW,KAAK,MAAM,aAAa,cAAc,OAAO,CAAC;CAI3D,QAAQ;EACN,OAAO,CAAC;CACV;CAEA,IAAI,OAAO,aAAa,YAAY,aAAa,MAAM,OAAO,CAAC;CAE/D,MAAM,OAAiB,CAAC;CAExB,KAAK,MAAM,SAAS,OAAO,OAAO,QAAQ,GAAG;EAC3C,IAAI,UAAU,UAAa,CAAC,MAAM,QAAQ,MAAM,GAAG,GAAG;EAEtD,KAAK,MAAM,QAAQ,MAAM,KAAK;GAC5B,IAAI,OAAO,SAAS,YAAY,SAAS,IAAI;GAO7C,MAAM,MAAM,IAAI;GAKhB,IAAI,CAAC,IAAI,WAAW,aAA2B,EAAE,GAAG;GAEpD,IAAI,CAAC,KAAK,SAAS,GAAG,GAAG,KAAK,KAAK,GAAG;EACxC;CACF;CAEA,OAAO;AACT"}
+{"version":3,"file":"stylesheet-urls.mjs","names":[],"sources":["C:/Work/Warlock.js/web/src/server/stylesheet-urls.ts"],"sourcesContent":["/**\n * Which stylesheets a REGISTERED HANDLER must link, in each of the two modes.\n *\n * WHY THIS EXISTS AT ALL. Nothing used to put CSS into the server-rendered\n * document. A stylesheet reached the browser only because the CLIENT bundle\n * imported it, which means JavaScript applied it after the module graph\n * loaded — so every full page load painted unstyled first and restyled a\n * moment later. The markup was correct the whole time, which is precisely why\n * it was easy to miss.\n *\n * THE SCOPE IS PER HANDLER, NOT PER APPLICATION. Every page renders inside\n * `[root, ...outer-to-inner matched layouts, page]` — that is the exact triple\n * (widened to a chain) `create-page-route-handler.ts` loads per request — so a\n * handler's CSS is the ordered, deduped union of what those specific source\n * files pull in, and nothing else. Collecting across the WHOLE application\n * (every page's manifest entry, every root import) is the bug this shape\n * exists to avoid: it ships page B's stylesheet on page A's response, and it\n * only gets worse as an application grows.\n *\n * The two modes learn the answer from different places, and neither can use\n * the other's:\n *\n *  - PRODUCTION reads Vite's client manifest, matching each source file's own\n *    id and walking its recorded `css` and imported chunks.\n *  - DEV has no manifest — Vite serves modules on demand — so the URLs are\n *    derived from each source file's own import statements.\n */\nimport { readFileSync } from \"node:fs\";\nimport path from \"node:path\";\nimport { CLIENT_ASSET_URL_PREFIX } from \"./client-asset-url-prefix\";\n\n/** Stylesheet extensions Vite can serve directly. Mirrors the build's list. */\nconst STYLE_EXTENSIONS = [\".css\", \".scss\", \".sass\", \".less\", \".styl\"];\n\n/**\n * A stylesheet Vite serves in DEV must be requested with `?direct`.\n *\n * Without it Vite answers the same URL with `text/javascript` — its CSS-as-JS\n * module transform, meant for `import \"./app.css\"` — and a\n * `<link rel=\"stylesheet\">` pointing at a JavaScript response applies\n * NOTHING, silently. No console error, no network failure, just an unstyled\n * page. `?direct` is what makes Vite reply with real `text/css`.\n */\nexport const VITE_DIRECT_CSS_QUERY = \"?direct\";\n\n/**\n * ONE source file's own directly imported stylesheets, as dev URLs.\n *\n * Dev has no manifest, so the source is the file itself: whatever it imports\n * with a stylesheet extension is what it needs. This is deliberately narrow —\n * it answers \"what CSS does THIS file set up\", not \"what CSS does the whole\n * module graph this file eventually reaches end up pulling in\" — because the\n * latter would require reproducing Vite's module graph, which is precisely\n * what dev has no manifest to shortcut.\n *\n * The narrowness is the honest part: production splits CSS per chunk and can\n * follow imported chunks (`productionStylesheetUrls` below); dev can only read\n * the ONE file handed to it. A page whose own module imports its own\n * stylesheet still gets it in dev — Vite's client graph injects it as before —\n * it simply is not render-blocking the way a chain member's own import is.\n *\n * Called once per chain member — root, then every matched layout outer to\n * inner, then the page — by the installers below, which is what turns \"one\n * file's own imports\" into a handler's whole CSS chain.\n *\n * Specifiers are resolved against `sourceFile` and expressed relative to\n * `appRoot`, because that is the shape Vite's dev server serves from.\n */\nexport function devStylesheetUrls(appRoot: string, sourceFile: string): string[] {\n  let source: string;\n\n  try {\n    source = readFileSync(sourceFile, \"utf-8\");\n  } catch {\n    return [];\n  }\n\n  const urls: string[] = [];\n  const pattern = /\\bimport\\s*(?:\\(\\s*)?[\"']([^\"']+)[\"']/g;\n\n  let match = pattern.exec(source);\n\n  while (match !== null) {\n    const specifier = match[1];\n    const lowered = specifier.toLowerCase();\n\n    if (STYLE_EXTENSIONS.some((extension) => lowered.endsWith(extension))) {\n      const absolute = path.resolve(path.dirname(sourceFile), specifier);\n      const relative = path.relative(appRoot, absolute).split(path.sep).join(\"/\");\n\n      // Outside the app root Vite would need an `/@fs/` URL and a widened\n      // `fs.allow`; a stylesheet living there is unusual enough that guessing\n      // is worse than leaving it to the client import.\n      if (!relative.startsWith(\"..\")) {\n        const url = `/${relative}${VITE_DIRECT_CSS_QUERY}`;\n\n        if (!urls.includes(url)) urls.push(url);\n      }\n    }\n\n    match = pattern.exec(source);\n  }\n\n  return urls;\n}\n\n/**\n * ONE handler's whole dev CSS chain: every `sourceFiles` member's own direct\n * stylesheet imports (`devStylesheetUrls`), in the order given — the caller\n * passes `[root, ...outer-to-inner matched layouts, page]` — concatenated and\n * deduped across the WHOLE chain, not just within one file.\n *\n * Cross-file dedup matters as much as within-file dedup: an application-wide\n * `app.css` imported by both the root and a page must still produce one\n * `<link>`, not two.\n */\nexport function devHandlerStylesheetUrls(\n  appRoot: string,\n  sourceFiles: readonly string[],\n): string[] {\n  const urls: string[] = [];\n\n  for (const sourceFile of sourceFiles) {\n    for (const url of devStylesheetUrls(appRoot, sourceFile)) {\n      if (!urls.includes(url)) urls.push(url);\n    }\n  }\n\n  return urls;\n}\n\ntype ManifestEntry = {\n  css?: unknown;\n  imports?: unknown;\n};\n\n/**\n * Find the manifest key for an app-root-relative POSIX source id.\n *\n * VITE KEYS BY SOURCE PATH RELATIVE TO ITS OWN `root`, not to the app's\n * `appRoot` — the client build's `root` is the framework's own package\n * (`build-client.ts`), so a key for an app source file carries a `../`-laden\n * prefix (`\"../my-app/src/web/root.tsx\"`) rather than matching `sourceFile`\n * (`\"src/web/root.tsx\"`) byte for byte. The two forms always share the same\n * TAIL, though — both are anchored at the same file — so an exact match is\n * tried first (the case where the client build's root IS the app root, which\n * every fixture and every test below uses) and a `/`-boundary suffix match\n * second, rather than trying to reconstruct the build's own root here, which\n * this runtime read has no way to independently confirm.\n */\nfunction findManifestKey(\n  manifest: Record<string, ManifestEntry | undefined>,\n  sourceFile: string,\n): string | undefined {\n  if (manifest[sourceFile] !== undefined) return sourceFile;\n\n  const suffix = `/${sourceFile}`;\n\n  for (const key of Object.keys(manifest)) {\n    if (key.endsWith(suffix)) return key;\n  }\n\n  return undefined;\n}\n\n/**\n * Every stylesheet reachable from ONE manifest entry: its own recorded `css`,\n * plus the same walk repeated over every chunk it STATICALLY `imports`.\n *\n * `imports` only, never `dynamicImports`. Vite's manifest records\n * `dynamicImports` on shared entry points (the hydration entry names every\n * page as one) precisely because the browser must NOT download them eagerly —\n * walking that array here would pull every other page's CSS onto this one,\n * which is the exact \"unrelated pages\" leak this module exists to end.\n * `imports`, by contrast, are chunks THIS module synchronously depends on:\n * code Vite split out of it but that loads whenever it does, so their CSS is\n * this handler's CSS too.\n *\n * `visited` guards against a chunk graph cycle; sharing one set across the\n * whole walk from a single entry is enough; a shared chunk revisited from a\n * SEPARATE top-level entry (root vs. a layout vs. the page) is deliberately\n * walked again — the final merge in `productionStylesheetUrls` dedupes by URL,\n * and a fresh `visited` set per entry is simpler to reason about than one\n * threaded across unrelated chains.\n */\nfunction collectManifestCss(\n  manifest: Record<string, ManifestEntry | undefined>,\n  key: string,\n  visited: Set<string>,\n): string[] {\n  if (visited.has(key)) return [];\n  visited.add(key);\n\n  const entry = manifest[key];\n  if (entry === undefined) return [];\n\n  const ownCss = Array.isArray(entry.css)\n    ? entry.css.filter((file): file is string => typeof file === \"string\" && file !== \"\")\n    : [];\n\n  const imports = Array.isArray(entry.imports)\n    ? entry.imports.filter((id): id is string => typeof id === \"string\")\n    : [];\n\n  return [\n    ...ownCss,\n    ...imports.flatMap((importedKey) => collectManifestCss(manifest, importedKey, visited)),\n  ];\n}\n\n/**\n * ONE handler's whole production CSS chain.\n *\n * `sourceFiles` is `[root, ...outer-to-inner matched layouts, page]`, each an\n * app-root-relative POSIX source id — the SAME id\n * `install-page-routes-from-manifest.ts` already carries as `sourceFile` on\n * every manifest entry, because that identity is what lets this function match\n * EXPLICITLY rather than guess: every id is looked up on its own\n * (`findManifestKey`), its own chunk's CSS is collected\n * (`collectManifestCss`), and an id with no matching entry contributes\n * nothing — it is never treated as license to fall back to scanning the whole\n * manifest, which is what let an unrelated page's CSS leak onto this handler\n * before.\n *\n * Duplicates are collapsed and order is preserved across the WHOLE chain, in\n * the order `sourceFiles` was given — root's own CSS first, then each\n * layout's outer to inner, then the page's — so cascade order matches the\n * chain's own outer-to-inner rendering order.\n *\n * A missing or malformed manifest returns NOTHING rather than throwing. The\n * hydration resolver already fails loudly on exactly those conditions, from\n * exactly the same file, and it runs first — a second, worse error for the\n * same cause helps nobody.\n */\nexport function productionStylesheetUrls(\n  clientDir: string,\n  sourceFiles: readonly string[],\n): string[] {\n  const manifestPath = path.join(clientDir, \".vite\", \"manifest.json\");\n\n  let manifest: Record<string, ManifestEntry | undefined>;\n\n  try {\n    manifest = JSON.parse(readFileSync(manifestPath, \"utf-8\")) as Record<\n      string,\n      ManifestEntry | undefined\n    >;\n  } catch {\n    return [];\n  }\n\n  if (typeof manifest !== \"object\" || manifest === null) return [];\n\n  const files: string[] = [];\n\n  for (const sourceFile of sourceFiles) {\n    const key = findManifestKey(manifest, sourceFile);\n    if (key === undefined) continue;\n\n    files.push(...collectManifestCss(manifest, key, new Set()));\n  }\n\n  const urls: string[] = [];\n\n  for (const file of files) {\n    // Built EXACTLY as the hydration entry's URL is built — `/${file}`, then\n    // checked against the prefix — rather than reassembled from a basename.\n    // The manifest already records `assets/root-<hash>.css`, and rebuilding\n    // that path here would be a second expression of a convention\n    // `client-asset-url-prefix.ts` owns.\n    const url = `/${file}`;\n\n    // A stylesheet outside the directory the asset route mounts would 404.\n    // Dropped rather than emitted, because a dead <link> in <head> is a\n    // silent styling failure — the exact thing this module exists to end.\n    if (!url.startsWith(`${CLIENT_ASSET_URL_PREFIX}/`)) continue;\n\n    if (!urls.includes(url)) urls.push(url);\n  }\n\n  return urls;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgCA,MAAM,mBAAmB;CAAC;CAAQ;CAAS;CAAS;CAAS;AAAO;;;;;;;;;;AAWpE,MAAa,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;AAyBrC,SAAgB,kBAAkB,SAAiB,YAA8B;CAC/E,IAAI;CAEJ,IAAI;EACF,SAAS,aAAa,YAAY,OAAO;CAC3C,QAAQ;EACN,OAAO,CAAC;CACV;CAEA,MAAM,OAAiB,CAAC;CACxB,MAAM,UAAU;CAEhB,IAAI,QAAQ,QAAQ,KAAK,MAAM;CAE/B,OAAO,UAAU,MAAM;EACrB,MAAM,YAAY,MAAM;EACxB,MAAM,UAAU,UAAU,YAAY;EAEtC,IAAI,iBAAiB,MAAM,cAAc,QAAQ,SAAS,SAAS,CAAC,GAAG;GACrE,MAAM,WAAW,KAAK,QAAQ,KAAK,QAAQ,UAAU,GAAG,SAAS;GACjE,MAAM,WAAW,KAAK,SAAS,SAAS,QAAQ,EAAE,MAAM,KAAK,GAAG,EAAE,KAAK,GAAG;GAK1E,IAAI,CAAC,SAAS,WAAW,IAAI,GAAG;IAC9B,MAAM,MAAM,IAAI,WAAW;IAE3B,IAAI,CAAC,KAAK,SAAS,GAAG,GAAG,KAAK,KAAK,GAAG;GACxC;EACF;EAEA,QAAQ,QAAQ,KAAK,MAAM;CAC7B;CAEA,OAAO;AACT;;;;;;;;;;;AAYA,SAAgB,yBACd,SACA,aACU;CACV,MAAM,OAAiB,CAAC;CAExB,KAAK,MAAM,cAAc,aACvB,KAAK,MAAM,OAAO,kBAAkB,SAAS,UAAU,GACrD,IAAI,CAAC,KAAK,SAAS,GAAG,GAAG,KAAK,KAAK,GAAG;CAI1C,OAAO;AACT;;;;;;;;;;;;;;;AAqBA,SAAS,gBACP,UACA,YACoB;CACpB,IAAI,SAAS,gBAAgB,QAAW,OAAO;CAE/C,MAAM,SAAS,IAAI;CAEnB,KAAK,MAAM,OAAO,OAAO,KAAK,QAAQ,GACpC,IAAI,IAAI,SAAS,MAAM,GAAG,OAAO;AAIrC;;;;;;;;;;;;;;;;;;;;;AAsBA,SAAS,mBACP,UACA,KACA,SACU;CACV,IAAI,QAAQ,IAAI,GAAG,GAAG,OAAO,CAAC;CAC9B,QAAQ,IAAI,GAAG;CAEf,MAAM,QAAQ,SAAS;CACvB,IAAI,UAAU,QAAW,OAAO,CAAC;CAEjC,MAAM,SAAS,MAAM,QAAQ,MAAM,GAAG,IAClC,MAAM,IAAI,QAAQ,SAAyB,OAAO,SAAS,YAAY,SAAS,EAAE,IAClF,CAAC;CAEL,MAAM,UAAU,MAAM,QAAQ,MAAM,OAAO,IACvC,MAAM,QAAQ,QAAQ,OAAqB,OAAO,OAAO,QAAQ,IACjE,CAAC;CAEL,OAAO,CACL,GAAG,QACH,GAAG,QAAQ,SAAS,gBAAgB,mBAAmB,UAAU,aAAa,OAAO,CAAC,CACxF;AACF;;;;;;;;;;;;;;;;;;;;;;;;;AA0BA,SAAgB,yBACd,WACA,aACU;CACV,MAAM,eAAe,KAAK,KAAK,WAAW,SAAS,eAAe;CAElE,IAAI;CAEJ,IAAI;EACF,WAAW,KAAK,MAAM,aAAa,cAAc,OAAO,CAAC;CAI3D,QAAQ;EACN,OAAO,CAAC;CACV;CAEA,IAAI,OAAO,aAAa,YAAY,aAAa,MAAM,OAAO,CAAC;CAE/D,MAAM,QAAkB,CAAC;CAEzB,KAAK,MAAM,cAAc,aAAa;EACpC,MAAM,MAAM,gBAAgB,UAAU,UAAU;EAChD,IAAI,QAAQ,QAAW;EAEvB,MAAM,KAAK,GAAG,mBAAmB,UAAU,qBAAK,IAAI,IAAI,CAAC,CAAC;CAC5D;CAEA,MAAM,OAAiB,CAAC;CAExB,KAAK,MAAM,QAAQ,OAAO;EAMxB,MAAM,MAAM,IAAI;EAKhB,IAAI,CAAC,IAAI,WAAW,aAA2B,EAAE,GAAG;EAEpD,IAAI,CAAC,KAAK,SAAS,GAAG,GAAG,KAAK,KAAK,GAAG;CACxC;CAEA,OAAO;AACT"}

package/esm/server/unregistered-pages.mjs

@@ -0,0 +1,42 @@
+import { matchPath } from "./match-page-route.mjs";
+import { isNotFoundPageFile } from "./not-found-page.mjs";
+import { discoverPages, isDiscoveredRoutablePage, toPosix } from "../build/discover-pages.mjs";
+import path from "node:path";
+
+//#region web/src/server/unregistered-pages.ts
+function fileKey(file) {
+	const posix = toPosix(file);
+	return process.platform === "win32" ? posix.toLowerCase() : posix;
+}
+function findUnregisteredPages(options) {
+	const { appRoot, appSrcRoot, registeredPageFiles, discover = discoverPages } = options;
+	const registered = new Set(registeredPageFiles().map(fileKey));
+	const webRoot = path.resolve(appSrcRoot, "web");
+	return discover({
+		appRoot,
+		srcDir: path.relative(appRoot, appSrcRoot)
+	}).filter(isDiscoveredRoutablePage).filter((page) => path.resolve(page.webRoot) === webRoot && !isNotFoundPageFile(page.pageFile) && !registered.has(fileKey(page.pageFile)));
+}
+function describeUnregisteredPages(pageFiles, appRoot, request) {
+	const named = pageFiles.map((pageFile) => `  - ${toPosix(path.relative(appRoot, pageFile))}`).join("\n");
+	return `[warlock:web] ${request.method} ${request.url} answered 404. These src/web page files exist on disk but are absent from the active route table:
+` + named;
+}
+function createUnregisteredPageReporter(options) {
+	const { appRoot, warn = console.warn } = options;
+	const reported = /* @__PURE__ */ new Set();
+	return (request) => {
+		try {
+			const unregistered = findUnregisteredPages(options).find((page) => !reported.has(fileKey(page.pageFile)) && matchPath(page.routePath, request.pathname) !== void 0);
+			if (unregistered === void 0) return;
+			reported.add(fileKey(unregistered.pageFile));
+			warn(describeUnregisteredPages([unregistered.pageFile], appRoot, request));
+		} catch {
+			return;
+		}
+	};
+}
+
+//#endregion
+export { createUnregisteredPageReporter };
+//# sourceMappingURL=unregistered-pages.mjs.map

package/esm/server/unregistered-pages.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"unregistered-pages.mjs","names":[],"sources":["C:/Work/Warlock.js/web/src/server/unregistered-pages.ts"],"sourcesContent":["import path from \"node:path\";\nimport {\n  discoverPages,\n  isDiscoveredRoutablePage,\n  toPosix,\n  type DiscoverPagesOptions,\n  type DiscoveredPage,\n} from \"../build/discover-pages\";\nimport { matchPath } from \"./match-page-route\";\nimport { isNotFoundPageFile } from \"./not-found-page\";\n\ntype DiscoveredGlobalPage = Extract<DiscoveredPage, { type: \"page\" }>;\ntype DiscoverPages = (options: DiscoverPagesOptions) => readonly DiscoveredPage[];\n\nexport type UnregisteredPagesOptions = {\n  appRoot: string;\n  appSrcRoot: string;\n  registeredPageFiles: () => readonly string[];\n  discover?: DiscoverPages;\n  warn?: (message: string) => void;\n};\n\nfunction fileKey(file: string): string {\n  const posix = toPosix(file);\n\n  return process.platform === \"win32\" ? posix.toLowerCase() : posix;\n}\n\nfunction findUnregisteredPages(options: UnregisteredPagesOptions): DiscoveredGlobalPage[] {\n  const { appRoot, appSrcRoot, registeredPageFiles, discover = discoverPages } = options;\n  const registered = new Set(registeredPageFiles().map(fileKey));\n  const webRoot = path.resolve(appSrcRoot, \"web\");\n\n  return discover({ appRoot, srcDir: path.relative(appRoot, appSrcRoot) })\n    .filter(isDiscoveredRoutablePage)\n    .filter(\n      (page) =>\n      path.resolve(page.webRoot) === webRoot &&\n      !isNotFoundPageFile(page.pageFile) &&\n      !registered.has(fileKey(page.pageFile)),\n    );\n}\n\nexport function findUnregisteredPageFiles(options: UnregisteredPagesOptions): string[] {\n  return findUnregisteredPages(options).map((page) => page.pageFile);\n}\n\nexport function describeUnregisteredPages(\n  pageFiles: readonly string[],\n  appRoot: string,\n  request: { method: string; url: string },\n): string {\n  const named = pageFiles\n    .map((pageFile) => `  - ${toPosix(path.relative(appRoot, pageFile))}`)\n    .join(\"\\n\");\n\n  return (\n    `[warlock:web] ${request.method} ${request.url} answered 404. ` +\n    \"These src/web page files exist on disk but are absent from the active route table:\\n\" +\n    named\n  );\n}\n\nexport function createUnregisteredPageReporter(\n  options: UnregisteredPagesOptions,\n): (request: { method: string; url: string; pathname: string }) => void {\n  const { appRoot, warn = console.warn } = options;\n  const reported = new Set<string>();\n\n  return (request) => {\n    // `discoverPages()` deliberately refuses malformed pages. Its install/build\n    // diagnostic is authoritative, so a response hook must leave this 404 alone.\n    try {\n      const unregistered = findUnregisteredPages(options).find(\n        (page) =>\n          !reported.has(fileKey(page.pageFile)) &&\n          matchPath(page.routePath, request.pathname) !== undefined,\n      );\n\n      if (unregistered === undefined) return;\n\n      reported.add(fileKey(unregistered.pageFile));\n      warn(describeUnregisteredPages([unregistered.pageFile], appRoot, request));\n    } catch {\n      return;\n    }\n  };\n}\n"],"mappings":";;;;;;AAsBA,SAAS,QAAQ,MAAsB;CACrC,MAAM,QAAQ,QAAQ,IAAI;CAE1B,OAAO,QAAQ,aAAa,UAAU,MAAM,YAAY,IAAI;AAC9D;AAEA,SAAS,sBAAsB,SAA2D;CACxF,MAAM,EAAE,SAAS,YAAY,qBAAqB,WAAW,kBAAkB;CAC/E,MAAM,aAAa,IAAI,IAAI,oBAAoB,EAAE,IAAI,OAAO,CAAC;CAC7D,MAAM,UAAU,KAAK,QAAQ,YAAY,KAAK;CAE9C,OAAO,SAAS;EAAE;EAAS,QAAQ,KAAK,SAAS,SAAS,UAAU;CAAE,CAAC,EACpE,OAAO,wBAAwB,EAC/B,QACE,SACD,KAAK,QAAQ,KAAK,OAAO,MAAM,WAC/B,CAAC,mBAAmB,KAAK,QAAQ,KACjC,CAAC,WAAW,IAAI,QAAQ,KAAK,QAAQ,CAAC,CACxC;AACJ;AAMA,SAAgB,0BACd,WACA,SACA,SACQ;CACR,MAAM,QAAQ,UACX,KAAK,aAAa,OAAO,QAAQ,KAAK,SAAS,SAAS,QAAQ,CAAC,GAAG,EACpE,KAAK,IAAI;CAEZ,OACE,iBAAiB,QAAQ,OAAO,GAAG,QAAQ,IAAI;IAE/C;AAEJ;AAEA,SAAgB,+BACd,SACsE;CACtE,MAAM,EAAE,SAAS,OAAO,QAAQ,SAAS;CACzC,MAAM,2BAAW,IAAI,IAAY;CAEjC,QAAQ,YAAY;EAGlB,IAAI;GACF,MAAM,eAAe,sBAAsB,OAAO,EAAE,MACjD,SACC,CAAC,SAAS,IAAI,QAAQ,KAAK,QAAQ,CAAC,KACpC,UAAU,KAAK,WAAW,QAAQ,QAAQ,MAAM,MACpD;GAEA,IAAI,iBAAiB,QAAW;GAEhC,SAAS,IAAI,QAAQ,aAAa,QAAQ,CAAC;GAC3C,KAAK,0BAA0B,CAAC,aAAa,QAAQ,GAAG,SAAS,OAAO,CAAC;EAC3E,QAAQ;GACN;EACF;CACF;AACF"}

package/esm/server/web-connector-factory.d.mts

@@ -2,12 +2,11 @@ import { WebBuildOptions } from "../build/contribution.mjs";
 import { WebConnectorOptions } from "./web-connector.mjs";
 import { Connector } from "@warlock.js/core";
 
-//#region ../web/src/server/web-connector-factory.d.ts
+//#region web/src/server/web-connector-factory.d.ts
 type WebConnectorFactoryOptions = WebConnectorOptions & {
   /**
    * What web contributes to `warlock build`. Passed straight to
-   * {@link createWebBuildContribution}; JSON-serializable values only — no
-   * plugin or pipeline instances, so a config load never pulls Vite in.
+   * {@link createWebBuildContribution}; JSON-serializable values only.
    */
   build?: WebBuildOptions;
 };

package/esm/server/web-connector-factory.mjs

@@ -1,9 +1,9 @@
 import { createWebBuildContribution } from "../build/contribution.mjs";
+import { ConnectorLifecyclePhase } from "@warlock.js/core";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
-import { ConnectorLifecyclePhase } from "@warlock.js/core";
 
-//#region ../web/src/server/web-connector-factory.ts
+//#region web/src/server/web-connector-factory.ts
 /**
 * `webConnector()` — the ONE thing `warlock.config.ts` imports from
 * `@warlock.js/web/connector`, and the only value the `./connector` barrel
@@ -74,11 +74,11 @@ function deriveWebRoot() {
 function webConnector(options = {}) {
 	const { build: buildOptions, ...connectorOptions } = options;
 	const webRoot = connectorOptions.webRoot ?? deriveWebRoot();
+	const connectorPlugins = [...connectorOptions.plugins ?? []];
 	const build = createWebBuildContribution({
 		...buildOptions,
-		webRoot: buildOptions?.webRoot ?? webRoot,
-		connectorPluginCount: connectorOptions.plugins?.length ?? 0
-	});
+		webRoot: buildOptions?.webRoot ?? webRoot
+	}, connectorPlugins);
 	let instance;
 	/**
 	* Load the heavy half on first lifecycle call. `boot()` is always the first
@@ -90,6 +90,7 @@ function webConnector(options = {}) {
 			const { WebConnector: WebConnectorClass } = await import("./web-connector.mjs");
 			instance = new WebConnectorClass({
 				...connectorOptions,
+				plugins: connectorPlugins,
 				webRoot
 			});
 		}
@@ -113,7 +114,7 @@ function webConnector(options = {}) {
 		shutdown: async () => {
 			await instance?.shutdown();
 		},
-		shouldRestart: () => false
+		shouldRestart: (changedFiles) => instance?.shouldRestart(changedFiles) ?? false
 	};
 }
 

package/esm/server/web-connector-factory.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"web-connector-factory.mjs","names":[],"sources":["../../../../../../../web/src/server/web-connector-factory.ts"],"sourcesContent":["/**\n * `webConnector()` — the ONE thing `warlock.config.ts` imports from\n * `@warlock.js/web/connector`, and the only value the `./connector` barrel\n * adds beyond the build/runtime seams.\n *\n * WHY THIS MODULE EXISTS AT ALL, rather than the barrel exporting\n * `WebConnector` directly: `./web-connector.ts` imports `../vite`\n * (`web-connector.ts:52` → `@babel/parser` + `magic-string`),\n * `../../../core/src/router/router` (`:51`) and `./dev-server` (`:53`, which\n * itself pulls core's http stack and `../vite`) at VALUE level. Re-exporting\n * that class from `web/src/connector/index.ts` would drag every one of those\n * into the static graph of every consuming app's config file — the exact\n * config-load weight the `./connector` subpath was created to prevent.\n *\n * So the factory returns a LAZY DELEGATE: a `Connector` whose identity fields\n * (`name`, `priority`, `lifecyclePhase`, `build`) are plain data available\n * synchronously, and whose lifecycle methods `await import(\"./web-connector\")`\n * on first use. `warlock build` reads `build` off this object and never boots\n * anything, so a build never loads Vite or React through\n * here either. This is the third instance of a pattern the codebase already\n * uses twice — `core/src/connectors/access-connector.ts:39` and\n * `web/src/server/dev-cli.ts:61` — not a new one.\n *\n * KEEP THIS MODULE LIGHT. Its whole value-level static graph is `node:path`,\n * `node:url`, `../../../core/src/connectors/types` (whose own two imports are\n * both `import type` and therefore erased — `core/src/connectors/types.ts:1-2`)\n * and `../build/contribution` (`node:fs` + `node:path` + type-only core).\n * Everything else here is `import type`, which `verbatimModuleSyntax` erases.\n */\nimport path from \"node:path\";\nimport { fileURLToPath } from \"node:url\";\nimport {\n  type Connector,\n  type ConnectorBuildContribution,\n  ConnectorLifecyclePhase,\n  type ConnectorName,\n} from \"@warlock.js/core\";\nimport { createWebBuildContribution, type WebBuildOptions } from \"../build/contribution\";\nimport type { WebConnector, WebConnectorOptions } from \"./web-connector\";\n\n/**\n * Boot/shutdown position relative to core's own connectors.\n *\n * `ConnectorPriority.HTTP` is `5` and `ConnectorPriority.STORAGE` is `6`\n * (`core/src/connectors/types.ts:187-188`), and the manager sorts on a plain\n * numeric compare (`core/src/connectors/connectors-manager.ts:46`) — so `5.5`\n * is \"immediately after http, before everything else\".\n *\n * Defined HERE and re-exported by `./web-connector` rather than the other way\n * round: the delegate must publish `priority` synchronously, and reading it\n * from the heavy module would defeat the whole point of the delegate.\n */\nexport const WEB_CONNECTOR_PRIORITY = 5.5;\n\nexport type WebConnectorFactoryOptions = WebConnectorOptions & {\n  /**\n   * What web contributes to `warlock build`. Passed straight to\n   * {@link createWebBuildContribution}; JSON-serializable values only — no\n   * plugin or pipeline instances, so a config load never pulls Vite in.\n   */\n  build?: WebBuildOptions;\n};\n\n/**\n * The `@warlock.js/web` package root, derived once from THIS module's location\n * and then passed EXPLICITLY to both halves.\n *\n * `web/src/server/web-connector-factory.ts` → `web/src/server` → `web/src` →\n * `web`; published as `web/esm/server/web-connector-factory.js`, two levels up\n * is the package root under both layouts — the same arithmetic\n * `contribution.ts:136-140` documents.\n *\n * Deriving it here and handing it down means the build contribution never falls\n * back to its own `import.meta.url` guess (`contribution.ts:129-141`): one\n * derivation, one place to be wrong, and `assertWebPackageRoot` verifies it\n * against `<root>/package.json`'s `name` either way.\n */\nfunction deriveWebRoot(): string {\n  return path.resolve(path.dirname(fileURLToPath(import.meta.url)), \"..\", \"..\");\n}\n\n/**\n * Construct web's connector for `warlock.config.ts > connectors`.\n *\n * @example\n * ```ts\n * export default defineConfig({ connectors: [webConnector()] });\n * ```\n */\nexport function webConnector(options: WebConnectorFactoryOptions = {}): Connector {\n  const { build: buildOptions, ...connectorOptions } = options;\n  const webRoot = connectorOptions.webRoot ?? deriveWebRoot();\n\n  const build: ConnectorBuildContribution = createWebBuildContribution({\n    ...buildOptions,\n    webRoot: buildOptions?.webRoot ?? webRoot,\n    // The COUNT, never the array. `connectorOptions.plugins` are dev-server\n    // plugins and the production build cannot apply them; the build contribution\n    // refuses the build rather than let them vanish silently\n    // (`ConnectorPluginsNotSupportedError`). Passing a number keeps this options\n    // object JSON-serializable — handing the plugin instances over would pull\n    // Vite into every config load, which is the one thing this module exists to\n    // prevent — and the refusal needs nothing more than \"how many\".\n    connectorPluginCount: connectorOptions.plugins?.length ?? 0,\n  });\n\n  let instance: WebConnector | undefined;\n\n  /**\n   * Load the heavy half on first lifecycle call. `boot()` is always the first\n   * of these to run (`core/src/connectors/connectors-manager.ts:87-93`), so the\n   * import lands in a process that has already committed to serving pages.\n   */\n  const load = async (): Promise<WebConnector> => {\n    if (!instance) {\n      const { WebConnector: WebConnectorClass } = await import(\"./web-connector\");\n\n      instance = new WebConnectorClass({ ...connectorOptions, webRoot });\n    }\n\n    return instance;\n  };\n\n  return {\n    name: \"web\" satisfies ConnectorName,\n    priority: WEB_CONNECTOR_PRIORITY,\n    lifecyclePhase: ConnectorLifecyclePhase.Late,\n    build,\n\n    // Never loads the heavy half: a connector that was never booted is not\n    // active, and answering that must not cost a Vite import.\n    isActive: () => instance?.isActive() ?? false,\n\n    boot: async () => {\n      await (await load()).boot();\n    },\n    start: async () => {\n      await (await load()).start();\n    },\n    restart: async () => {\n      await (await load()).restart();\n    },\n\n    // Both of these are asked of every registered connector, including ones\n    // that never booted — so neither may force the import.\n    shutdown: async () => {\n      await instance?.shutdown();\n    },\n    shouldRestart: () => false,\n  };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAoDA,MAAa,yBAAyB;;;;;;;;;;;;;;;AAyBtC,SAAS,gBAAwB;CAC/B,OAAO,KAAK,QAAQ,KAAK,QAAQ,cAAc,OAAO,KAAK,GAAG,CAAC,GAAG,MAAM,IAAI;AAC9E;;;;;;;;;AAUA,SAAgB,aAAa,UAAsC,CAAC,GAAc;CAChF,MAAM,EAAE,OAAO,cAAc,GAAG,qBAAqB;CACrD,MAAM,UAAU,iBAAiB,WAAW,cAAc;CAE1D,MAAM,QAAoC,2BAA2B;EACnE,GAAG;EACH,SAAS,cAAc,WAAW;EAQlC,sBAAsB,iBAAiB,SAAS,UAAU;CAC5D,CAAC;CAED,IAAI;;;;;;CAOJ,MAAM,OAAO,YAAmC;EAC9C,IAAI,CAAC,UAAU;GACb,MAAM,EAAE,cAAc,sBAAsB,MAAM,OAAO;GAEzD,WAAW,IAAI,kBAAkB;IAAE,GAAG;IAAkB;GAAQ,CAAC;EACnE;EAEA,OAAO;CACT;CAEA,OAAO;EACL,MAAM;EACN,UAAU;EACV,gBAAgB,wBAAwB;EACxC;EAIA,gBAAgB,UAAU,SAAS,KAAK;EAExC,MAAM,YAAY;GAChB,OAAO,MAAM,KAAK,EAAC,CAAE,KAAK;EAC5B;EACA,OAAO,YAAY;GACjB,OAAO,MAAM,KAAK,EAAC,CAAE,MAAM;EAC7B;EACA,SAAS,YAAY;GACnB,OAAO,MAAM,KAAK,EAAC,CAAE,QAAQ;EAC/B;EAIA,UAAU,YAAY;GACpB,MAAM,UAAU,SAAS;EAC3B;EACA,qBAAqB;CACvB;AACF"}
+{"version":3,"file":"web-connector-factory.mjs","names":[],"sources":["C:/Work/Warlock.js/web/src/server/web-connector-factory.ts"],"sourcesContent":["/**\n * `webConnector()` — the ONE thing `warlock.config.ts` imports from\n * `@warlock.js/web/connector`, and the only value the `./connector` barrel\n * adds beyond the build/runtime seams.\n *\n * WHY THIS MODULE EXISTS AT ALL, rather than the barrel exporting\n * `WebConnector` directly: `./web-connector.ts` imports `../vite`\n * (`web-connector.ts:52` → `@babel/parser` + `magic-string`),\n * `../../../core/src/router/router` (`:51`) and `./dev-server` (`:53`, which\n * itself pulls core's http stack and `../vite`) at VALUE level. Re-exporting\n * that class from `web/src/connector/index.ts` would drag every one of those\n * into the static graph of every consuming app's config file — the exact\n * config-load weight the `./connector` subpath was created to prevent.\n *\n * So the factory returns a LAZY DELEGATE: a `Connector` whose identity fields\n * (`name`, `priority`, `lifecyclePhase`, `build`) are plain data available\n * synchronously, and whose lifecycle methods `await import(\"./web-connector\")`\n * on first use. `warlock build` reads `build` off this object and never boots\n * anything, so a build never loads Vite or React through\n * here either. This is the third instance of a pattern the codebase already\n * uses twice — `core/src/connectors/access-connector.ts:39` and\n * `web/src/server/dev-cli.ts:61` — not a new one.\n *\n * KEEP THIS MODULE LIGHT. Its whole value-level static graph is `node:path`,\n * `node:url`, `../../../core/src/connectors/types` (whose own two imports are\n * both `import type` and therefore erased — `core/src/connectors/types.ts:1-2`)\n * and `../build/contribution` (`node:fs` + `node:path` + type-only core).\n * Everything else here is `import type`, which `verbatimModuleSyntax` erases.\n */\nimport path from \"node:path\";\nimport { fileURLToPath } from \"node:url\";\nimport {\n  type Connector,\n  type ConnectorBuildContribution,\n  ConnectorLifecyclePhase,\n  type ConnectorName,\n} from \"@warlock.js/core\";\nimport {\n  createWebBuildContribution,\n  type WebBuildOptions,\n} from \"../build/contribution\";\nimport type { WebConnector, WebConnectorOptions } from \"./web-connector\";\n\n/**\n * Boot/shutdown position relative to core's own connectors.\n *\n * `ConnectorPriority.HTTP` is `5` and `ConnectorPriority.STORAGE` is `6`\n * (`core/src/connectors/types.ts:187-188`), and the manager sorts on a plain\n * numeric compare (`core/src/connectors/connectors-manager.ts:46`) — so `5.5`\n * is \"immediately after http, before everything else\".\n *\n * Defined HERE and re-exported by `./web-connector` rather than the other way\n * round: the delegate must publish `priority` synchronously, and reading it\n * from the heavy module would defeat the whole point of the delegate.\n */\nexport const WEB_CONNECTOR_PRIORITY = 5.5;\n\nexport type WebConnectorFactoryOptions = WebConnectorOptions & {\n  /**\n   * What web contributes to `warlock build`. Passed straight to\n   * {@link createWebBuildContribution}; JSON-serializable values only.\n   */\n  build?: WebBuildOptions;\n};\n\n/**\n * The `@warlock.js/web` package root, derived once from THIS module's location\n * and then passed EXPLICITLY to both halves.\n *\n * `web/src/server/web-connector-factory.ts` → `web/src/server` → `web/src` →\n * `web`; published as `web/esm/server/web-connector-factory.js`, two levels up\n * is the package root under both layouts — the same arithmetic\n * `contribution.ts:136-140` documents.\n *\n * Deriving it here and handing it down means the build contribution never falls\n * back to its own `import.meta.url` guess (`contribution.ts:129-141`): one\n * derivation, one place to be wrong, and `assertWebPackageRoot` verifies it\n * against `<root>/package.json`'s `name` either way.\n */\nfunction deriveWebRoot(): string {\n  return path.resolve(path.dirname(fileURLToPath(import.meta.url)), \"..\", \"..\");\n}\n\n/**\n * Construct web's connector for `warlock.config.ts > connectors`.\n *\n * @example\n * ```ts\n * export default defineConfig({ connectors: [webConnector()] });\n * ```\n */\nexport function webConnector(\n  options: WebConnectorFactoryOptions = {},\n): Connector {\n  const { build: buildOptions, ...connectorOptions } = options;\n  const webRoot = connectorOptions.webRoot ?? deriveWebRoot();\n  // One snapshot feeds both halves. Mutating the caller's array after config\n  // construction cannot make dev and `warlock build` observe different lists.\n  const connectorPlugins = [...(connectorOptions.plugins ?? [])];\n\n  const build: ConnectorBuildContribution = createWebBuildContribution(\n    {\n      ...buildOptions,\n      webRoot: buildOptions?.webRoot ?? webRoot,\n    },\n    connectorPlugins,\n  );\n\n  let instance: WebConnector | undefined;\n\n  /**\n   * Load the heavy half on first lifecycle call. `boot()` is always the first\n   * of these to run (`core/src/connectors/connectors-manager.ts:87-93`), so the\n   * import lands in a process that has already committed to serving pages.\n   */\n  const load = async (): Promise<WebConnector> => {\n    if (!instance) {\n      const { WebConnector: WebConnectorClass } =\n        await import(\"./web-connector\");\n\n      instance = new WebConnectorClass({\n        ...connectorOptions,\n        plugins: connectorPlugins,\n        webRoot,\n      });\n    }\n\n    return instance;\n  };\n\n  return {\n    name: \"web\" satisfies ConnectorName,\n    priority: WEB_CONNECTOR_PRIORITY,\n    lifecyclePhase: ConnectorLifecyclePhase.Late,\n    build,\n\n    // Never loads the heavy half: a connector that was never booted is not\n    // active, and answering that must not cost a Vite import.\n    isActive: () => instance?.isActive() ?? false,\n\n    boot: async () => {\n      await (await load()).boot();\n    },\n    start: async () => {\n      await (await load()).start();\n    },\n    restart: async () => {\n      await (await load()).restart();\n    },\n\n    // Both of these are asked of every registered connector, including ones\n    // that never booted — so neither may force the import.\n    shutdown: async () => {\n      await instance?.shutdown();\n    },\n\n    // Asked on EVERY watcher batch, so the `instance?.` is load-bearing twice:\n    // it keeps the answer free for a connector that never booted, and it is the\n    // only reason this delegate can forward the question at all — by the time a\n    // watcher batch exists, `boot()` has already loaded the heavy half, so\n    // reading the real answer off it costs nothing beyond the call.\n    //\n    // It used to be a hard `false`, which meant a `*.page.tsx` created while\n    // `warlock dev` was running was never noticed: page routes are installed\n    // once, in `WebConnector.boot()`, so the new page's URL 404'd in silence.\n    // The connector itself now decides: add/remove and route-identity edits are\n    // live route-table work; component-body-only edits remain Vite HMR work.\n    shouldRestart: (changedFiles: string[]) =>\n      instance?.shouldRestart(changedFiles) ?? false,\n  };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuDA,MAAa,yBAAyB;;;;;;;;;;;;;;;AAwBtC,SAAS,gBAAwB;CAC/B,OAAO,KAAK,QAAQ,KAAK,QAAQ,cAAc,OAAO,KAAK,GAAG,CAAC,GAAG,MAAM,IAAI;AAC9E;;;;;;;;;AAUA,SAAgB,aACd,UAAsC,CAAC,GAC5B;CACX,MAAM,EAAE,OAAO,cAAc,GAAG,qBAAqB;CACrD,MAAM,UAAU,iBAAiB,WAAW,cAAc;CAG1D,MAAM,mBAAmB,CAAC,GAAI,iBAAiB,WAAW,CAAC,CAAE;CAE7D,MAAM,QAAoC,2BACxC;EACE,GAAG;EACH,SAAS,cAAc,WAAW;CACpC,GACA,gBACF;CAEA,IAAI;;;;;;CAOJ,MAAM,OAAO,YAAmC;EAC9C,IAAI,CAAC,UAAU;GACb,MAAM,EAAE,cAAc,sBACpB,MAAM,OAAO;GAEf,WAAW,IAAI,kBAAkB;IAC/B,GAAG;IACH,SAAS;IACT;GACF,CAAC;EACH;EAEA,OAAO;CACT;CAEA,OAAO;EACL,MAAM;EACN,UAAU;EACV,gBAAgB,wBAAwB;EACxC;EAIA,gBAAgB,UAAU,SAAS,KAAK;EAExC,MAAM,YAAY;GAChB,OAAO,MAAM,KAAK,GAAG,KAAK;EAC5B;EACA,OAAO,YAAY;GACjB,OAAO,MAAM,KAAK,GAAG,MAAM;EAC7B;EACA,SAAS,YAAY;GACnB,OAAO,MAAM,KAAK,GAAG,QAAQ;EAC/B;EAIA,UAAU,YAAY;GACpB,MAAM,UAAU,SAAS;EAC3B;EAaA,gBAAgB,iBACd,UAAU,cAAc,YAAY,KAAK;CAC7C;AACF"}

package/esm/server/web-connector.d.mts

@@ -1,7 +1,7 @@
 import { BaseConnector, ConnectorLifecyclePhase } from "@warlock.js/core";
 import { Alias, PluginOption, ViteDevServer } from "vite";
 
-//#region ../web/src/server/web-connector.d.ts
+//#region web/src/server/web-connector.d.ts
 type WebConnectorOptions = {
   /**
    * Vite's `root` — the application directory that owns `src/`, `package.json`