@ogygia/core 0.0.0 → 0.11.1

package/dist/compiler/link/island-deps.js

@@ -0,0 +1,525 @@
+import { path } from "../host.js";
+import { merge_page_keys } from "./page-keys.js";
+import { hydration_hazards } from "../../insights/hydration-hazards.js";
+import { OWN_FILE_RE, OWN_PACKAGE_NAMES } from "../../own-package.js";
+// src/compiler/link/island-deps.ts
+/**
+* Whole-program island dependency collection — from a finished client bundle, the transitive static
+* import + CSS chains for each `og-region.<id>.js` facade, so SSR can `modulepreload` a hydrate
+* island's hashed dependency chunks (Vite's auto graph does not cover `@vite-ignore` `import(entry)`).
+* Pure over the bundle it is handed. Covered by unit tests.
+*/
+/** Deterministic island facade filename (content-hashed Vite deps are separate). */
+const ISLAND_FACADE_RE = /(?:^|\/)og-region\.[0-9a-f]+\.js$/;
+const LEADING_SLASH = /^\//;
+/** A Kit remote-function module (`*.remote.js` / `.ts`, Kit's `moduleExtensions` defaults), once
+*  its `?query` is stripped. In the CLIENT graph Kit swaps its body for fetching stubs, but the
+*  module keeps its file id — which is how an island's chunk closure names the remotes it can call. */
+const REMOTE_MODULE_RE = /\.remote\.[cm]?[jt]s$/;
+const BACKSLASH_G = /\\/g;
+/**
+* Kit's own `hash()` (`@sveltejs/kit/src/utils/hash.js`: djb2 ×33 xor, unsigned, base36) — the
+* function a remote's id is minted with: `${hash(file)}/${exportName}`, `file` the module's path
+* relative to `process.cwd()`, posix. Mirrored here (Kit does not export it) so the build can
+* name a remote by the same id the server sees on `internals.id` at render time. Covered by a
+* vector test against ids observed from a real Kit build.
+*/
+function kit_remote_hash(file) {
+	let hash = 5381;
+	let i = file.length;
+	while (i) hash = hash * 33 ^ file.charCodeAt(--i);
+	return (hash >>> 0).toString(36);
+}
+/**
+* The Kit remote id-hash of a CLIENT module id, or `null` for a module that is not a remote file.
+* `cwd` is what Kit hashed the file against (`process.cwd()` at build), either separator.
+*
+* @internal Exported for the plugin and unit tests.
+*/
+function remote_hash_of(module_id, cwd) {
+	const id = module_id.split("?")[0].replace(BACKSLASH_G, "/");
+	if (!REMOTE_MODULE_RE.test(id)) return null;
+	const root = cwd.replace(BACKSLASH_G, "/").replace(TRAILING_SLASH_RE, "");
+	return kit_remote_hash(id.startsWith(root + "/") ? id.slice(root.length + 1) : path.posix.relative(root, id));
+}
+const TRAILING_SLASH_RE = /\/+$/;
+/**
+* From a client `generateBundle` output, collect transitive static `imports` for each
+* `og-region.<id>.js` facade. Keys/values are public URLs (`/_app/immutable/…`).
+* Used so SSR can `modulepreload` hashed dependency chunks for `hydrate: 'load'` islands
+* (Vite’s auto graph does not apply to `@vite-ignore` `import(entry)`).
+*
+* @internal Exported for unit tests.
+*/
+function collectIslandDepModulepreloads(bundle, page_reader_files = [], remote_hash = null, page_keys_of = null, read_source = null, runtime_file = null, entries = null) {
+	const js = {};
+	const css = {};
+	const page = {};
+	const page_keys = {};
+	const remotes = {};
+	const interactivity = {};
+	const hazards = {};
+	const hazards_cache = /* @__PURE__ */ new Map();
+	const hazards_of = (id) => {
+		if (!read_source) return [];
+		const clean = norm(id.split("?")[0]);
+		if (!clean.endsWith(".svelte") || OWN_OR_DEP_RE.test(clean) && !SITE_KIT_RE.test(clean)) return [];
+		const hit = hazards_cache.get(clean);
+		if (hit) return hit;
+		const src = read_source(clean);
+		const at_src = clean.lastIndexOf("/src/");
+		const file = SITE_KIT_RE.test(clean) ? `ogygia/${clean.slice(clean.lastIndexOf("/content/") + 1)}` : at_src !== -1 ? clean.slice(at_src + 1) : clean.split("/").slice(-2).join("/");
+		const out = src === null ? [] : hydration_hazards(src).slice(0, 3).map((h) => ({
+			file,
+			...h
+		}));
+		hazards_cache.set(clean, out);
+		return out;
+	};
+	const facts_cache = /* @__PURE__ */ new Map();
+	const facts_of = (id) => {
+		if (!read_source) return null;
+		const clean = norm(id.split("?")[0]);
+		if (!clean.endsWith(".svelte") || OWN_OR_DEP_RE.test(clean)) return null;
+		const hit = facts_cache.get(clean);
+		if (hit !== void 0) return hit;
+		const src = read_source(clean);
+		const f = src === null ? null : interactivity_facts(src);
+		facts_cache.set(clean, f);
+		return f;
+	};
+	const norm = (p) => p.split("\\").join("/");
+	const readers = new Set(page_reader_files.map(norm));
+	const keys_in = (fileName) => {
+		if (!page_keys_of) return void 0;
+		let acc = null;
+		let any = false;
+		for (const id of bundle[fileName]?.moduleIds ?? []) {
+			const k = page_keys_of(norm(id.split("?")[0]));
+			if (k === null) continue;
+			any = true;
+			acc = merge_page_keys(acc, k);
+			if (acc === "all") break;
+		}
+		return any ? acc : void 0;
+	};
+	const reads_page = (fileName) => {
+		if (!readers.size) return false;
+		for (const id of bundle[fileName]?.moduleIds ?? []) if (readers.has(norm(id.split("?")[0]))) return true;
+		return false;
+	};
+	const remotes_in = (fileName, acc) => {
+		if (!remote_hash) return;
+		for (const id of bundle[fileName]?.moduleIds ?? []) {
+			const h = remote_hash(id);
+			if (h) acc.add(h);
+		}
+	};
+	const closure_all = (fileName) => {
+		const seen = /* @__PURE__ */ new Set([fileName]);
+		const queue = [fileName];
+		while (queue.length) {
+			const chunk = bundle[queue.pop()];
+			if (!chunk || chunk.type !== "chunk") continue;
+			for (const imp of [...chunk.imports ?? [], ...chunk.dynamicImports ?? []]) {
+				if (seen.has(imp)) continue;
+				const dep = bundle[imp];
+				if (!dep || dep.type !== "chunk") continue;
+				seen.add(imp);
+				queue.push(imp);
+			}
+		}
+		return seen;
+	};
+	const css_of = (fileName) => {
+		const imported = bundle[fileName]?.viteMetadata?.importedCss;
+		if (!imported) return [];
+		return [...imported].map((f) => f.startsWith("/") ? f : "/" + f);
+	};
+	const walk = (fileName, seen, css_acc) => {
+		const chunk = bundle[fileName];
+		if (!chunk || chunk.type !== "chunk") return [];
+		const deps = [];
+		for (const imp of chunk.imports ?? []) {
+			if (seen.has(imp)) continue;
+			seen.add(imp);
+			const dep = bundle[imp];
+			if (!dep || dep.type !== "chunk") continue;
+			deps.push(imp.startsWith("/") ? imp : "/" + imp);
+			css_acc.push(...css_of(imp));
+			deps.push(...walk(imp, seen, css_acc));
+		}
+		return deps;
+	};
+	const identity_of = (fileName) => entries ? entries.islands.get(fileName) ?? null : ISLAND_FACADE_RE.test(fileName) ? fileName.startsWith("/") ? fileName : "/" + fileName : null;
+	for (const [key, chunk] of Object.entries(bundle)) {
+		if (chunk.type !== "chunk") continue;
+		const fileName = chunk.fileName || key;
+		const entryUrl = identity_of(fileName);
+		if (!entryUrl) continue;
+		const seen = /* @__PURE__ */ new Set([fileName]);
+		const css_acc = css_of(fileName);
+		const raw = walk(fileName, seen, css_acc);
+		const uniq = [];
+		const have = /* @__PURE__ */ new Set([entryUrl, "/" + fileName.replace(LEADING_SLASH, "")]);
+		for (const d of raw) {
+			if (have.has(d)) continue;
+			have.add(d);
+			uniq.push(d);
+		}
+		js[entryUrl] = uniq;
+		css[entryUrl] = [...new Set(css_acc)];
+		const full = closure_all(fileName);
+		let reads = false;
+		for (const s of full) if (reads_page(s)) {
+			reads = true;
+			break;
+		}
+		page[entryUrl] = reads;
+		if (reads) {
+			let acc = null;
+			let saw_reader = false;
+			for (const s of full) {
+				const k = keys_in(s);
+				if (k === void 0) continue;
+				saw_reader = true;
+				acc = merge_page_keys(acc, k);
+				if (acc === "all") break;
+			}
+			page_keys[entryUrl] = !saw_reader || acc === "all" || acc === null ? null : [...acc].sort();
+		}
+		const found = /* @__PURE__ */ new Set();
+		for (const s of full) remotes_in(s, found);
+		remotes[entryUrl] = [...found].sort();
+		if (read_source) {
+			let acc;
+			const seen_files = /* @__PURE__ */ new Set();
+			const lines = [];
+			for (const s of full) for (const id of bundle[s]?.moduleIds ?? []) {
+				const clean = norm(id.split("?")[0]);
+				if (seen_files.has(clean)) continue;
+				seen_files.add(clean);
+				const f = facts_of(id);
+				if (f) acc = merge_facts(acc, f);
+				if (lines.length < 5) {
+					for (const h of hazards_of(id)) if (lines.length < 5) lines.push(h);
+				}
+			}
+			if (lines.length) hazards[entryUrl] = lines;
+			if (acc) interactivity[entryUrl] = {
+				...acc,
+				remotes: remotes[entryUrl].length
+			};
+		}
+	}
+	if (runtime_file) {
+		const runtime_key = norm(runtime_file).replace(LEADING_SLASH, "");
+		const chunk = bundle[runtime_key];
+		if (chunk && chunk.type === "chunk") js[entries?.runtime ?? "/" + runtime_key] = [...new Set(walk(runtime_key, /* @__PURE__ */ new Set([runtime_key]), []))];
+	}
+	const contents = {};
+	const heavy = {};
+	const summarize = (s) => {
+		const url = s.startsWith("/") ? s : "/" + s;
+		if (contents[url]) return;
+		const chunk = bundle[s];
+		const ids = chunk?.moduleIds ?? [];
+		const mods = chunk?.modules;
+		const size_of = mods ? (id) => mods[id]?.renderedLength ?? 0 : void 0;
+		if (ids.length) contents[url] = summarize_chunk_contents(ids, 6, 5, size_of);
+		if (ids.length && size_of) {
+			const named = chunk_module_bytes(ids, size_of);
+			if (named.top.length) heavy[url] = named;
+		}
+	};
+	for (const [key, chunk] of Object.entries(bundle)) {
+		if (chunk.type !== "chunk") continue;
+		const fileName = chunk.fileName || key;
+		if (!identity_of(fileName)) continue;
+		for (const s of closure_all(fileName)) summarize(s);
+	}
+	for (const [key, chunk] of Object.entries(bundle)) if (chunk.type === "chunk") summarize(chunk.fileName || key);
+	return {
+		js,
+		css,
+		page,
+		page_keys,
+		remotes,
+		interactivity,
+		hazards,
+		contents,
+		heavy,
+		dupes: duplicate_modules(Object.entries(bundle).filter(([, c]) => c.type === "chunk").map(([key, c]) => {
+			const mods = c.modules;
+			return {
+				file: c.fileName || key,
+				ids: c.moduleIds ?? [],
+				...mods ? { size_of: (id) => mods[id]?.renderedLength ?? 0 } : {}
+			};
+		}))
+	};
+}
+/** Where a module id's copy came from: an installed package's version (`name@1.2.3`, from a pnpm
+*  store path), else the package's top folder (`name/src`, `name/dist`). */
+function module_origin(id) {
+	const p = id.split("\\").join("/");
+	const store = p.lastIndexOf("/.pnpm/");
+	if (store !== -1) {
+		const seg = p.slice(store + 7, p.indexOf("/", store + 7));
+		const cut = seg.indexOf("_");
+		return (cut === -1 ? seg : seg.slice(0, cut)).split("+").join("/");
+	}
+	if (!module_key(id)) return void 0;
+	let at = -1;
+	let top = "";
+	for (const t of [
+		"/src/",
+		"/dist/",
+		"/esm/",
+		"/build/"
+	]) {
+		const i = p.lastIndexOf(t);
+		if (i > at) {
+			at = i;
+			top = t;
+		}
+	}
+	return at === -1 ? void 0 : `${p.slice(p.lastIndexOf("/", at - 1) + 1, at)}${top.slice(0, -1)}`;
+}
+/** A module id as the file of its package, the build-or-source folder and the extension left out:
+*  two ids with one key are one module twice. Null for ids that are no file (virtual, `\0`). */
+function module_key(id) {
+	if (!id || id.startsWith("\0") || id.startsWith("virtual:")) return null;
+	let p = id.split("\\").join("/");
+	const q = p.indexOf("?");
+	if (q !== -1) p = p.slice(0, q);
+	let pkg;
+	let rest;
+	const nm = p.lastIndexOf("/node_modules/");
+	if (nm !== -1) {
+		const after = p.slice(nm + 14).split("/");
+		const n = after[0].startsWith("@") ? 2 : 1;
+		pkg = after.slice(0, n).join("/");
+		rest = after.slice(n).join("/");
+	} else {
+		const at = Math.max(p.lastIndexOf("/src/"), p.lastIndexOf("/dist/"));
+		if (at === -1) return null;
+		pkg = p.slice(p.lastIndexOf("/", at - 1) + 1, at);
+		rest = p.slice(at + 1);
+	}
+	for (const top of [
+		"src/",
+		"dist/",
+		"esm/",
+		"build/"
+	]) if (rest.startsWith(top)) rest = rest.slice(top.length);
+	for (const ext of [
+		".mjs",
+		".cjs",
+		".mts",
+		".ts",
+		".js"
+	]) if (rest.endsWith(ext)) rest = rest.slice(0, -ext.length);
+	return pkg && rest ? `${pkg}/${rest}` : null;
+}
+/** Every module the build shipped more than once: one key, two or more ids (a single id is in one
+*  chunk only). The heaviest first, copies of 512 bytes or more, at most 50.
+*  @internal exported for the tests */
+function duplicate_modules(chunks) {
+	const by = /* @__PURE__ */ new Map();
+	for (const c of chunks) for (const id of c.ids) {
+		const key = module_key(id);
+		if (!key) continue;
+		const ids = by.get(key) ?? by.set(key, /* @__PURE__ */ new Map()).get(key);
+		if (!ids.has(id)) {
+			const from = module_origin(id);
+			ids.set(id, {
+				file: c.file.startsWith("/") ? c.file : "/" + c.file,
+				bytes: c.size_of?.(id) ?? 0,
+				...from ? { from } : {}
+			});
+		}
+	}
+	const out = [];
+	for (const [name, ids] of by) {
+		if (ids.size < 2) continue;
+		const copies = [...ids.values()].filter((c) => c.bytes >= 512);
+		if (copies.length >= 2) out.push({
+			name,
+			copies
+		});
+	}
+	const weight = (d) => d.copies.reduce((s, c) => s + c.bytes, 0);
+	return out.sort((a, b) => weight(b) - weight(a)).slice(0, 50);
+}
+/** A chunk's modules as readable names (the same names `contents` uses) with their rendered bytes,
+*  heaviest first, the five heaviest; a package's modules summed under its name.
+*  @internal exported for the tests */
+function chunk_module_bytes(module_ids, size_of) {
+	const by = /* @__PURE__ */ new Map();
+	let total = 0;
+	for (const raw of module_ids) {
+		if (!raw || raw.startsWith("\0") || raw.startsWith("virtual:")) continue;
+		const name = summarize_chunk_contents([raw], 1, 1)[0];
+		if (!name) continue;
+		const bytes = size_of(raw) || 0;
+		total += bytes;
+		by.set(name, (by.get(name) ?? 0) + bytes);
+	}
+	const top = [...by].filter(([, bytes]) => bytes > 0).sort((a, b) => b[1] - a[1]).slice(0, 5).map(([name, bytes]) => ({
+		name,
+		bytes
+	}));
+	return {
+		total,
+		top
+	};
+}
+const PKG_IN_PATH_RE = /\/node_modules\/((?:@[^/]+\/)?[^/]+)/;
+const SRC_IN_PATH_RE = /\/src\/(.+)$/;
+/**
+* A chunk's source modules as a short readable list: the app's own files first (relative to
+* `src/`), then the packages, the framework runtimes named plainly. Capped; the tail is "+N more".
+* @internal exported for the tests
+*/
+function summarize_chunk_contents(module_ids, max_files = 6, max_pkgs = 5, size_of) {
+	const files = [];
+	const pkgs = [];
+	const bytes = /* @__PURE__ */ new Map();
+	const add = (list, v, raw) => {
+		if (!list.includes(v)) list.push(v);
+		if (size_of) bytes.set(v, (bytes.get(v) ?? 0) + (size_of(raw) || 0));
+	};
+	const ordered = (list) => size_of ? [...list].sort((a, b) => (bytes.get(b) ?? 0) - (bytes.get(a) ?? 0)) : list;
+	for (const raw of module_ids) {
+		if (!raw || raw.startsWith("\0") || raw.startsWith("virtual:")) continue;
+		const id = raw.split("\\").join("/").split("?")[0];
+		const nm = id.lastIndexOf("/node_modules/");
+		if (nm !== -1) {
+			const pkg = PKG_IN_PATH_RE.exec(id.slice(nm))?.[1];
+			if (pkg === "svelte") add(pkgs, "svelte runtime", raw);
+			else if (pkg && OWN_PACKAGE_NAMES.includes(pkg)) add(pkgs, "ogygia runtime", raw);
+			else if (pkg) add(pkgs, pkg, raw);
+			continue;
+		}
+		if (OWN_FILE_RE.test(id)) add(pkgs, "ogygia runtime", raw);
+		else {
+			const rel = SRC_IN_PATH_RE.exec(id);
+			add(files, rel ? "src/" + rel[1] : id.split("/").slice(-2).join("/"), raw);
+		}
+	}
+	const out = [...ordered(files).slice(0, max_files), ...ordered(pkgs).slice(0, max_pkgs)];
+	const more = files.length - Math.min(files.length, max_files) + (pkgs.length - Math.min(pkgs.length, max_pkgs));
+	if (more > 0) out.push(`+${more} more`);
+	return out;
+}
+const OWN_OR_DEP_RE = new RegExp(`/node_modules/|${OWN_FILE_RE.source}`);
+/** the site kit's components (ogygia's content/site): an app's own islands in all but location */
+const SITE_KIT_RE = /\/ogygia\/(?:src|dist)\/content\//;
+const HANDLER_RE = /\son[a-z]+\s*=\s*\{|\son:[a-z]+/g;
+const STATE_RE = /\$state(?:\.raw)?\s*\(/g;
+const EFFECT_RE = /\$effect(?:\.pre)?\s*\(/g;
+const BIND_RE = /\sbind:[a-zA-Z]/g;
+const ACTION_RE = /\suse:[a-zA-Z]/g;
+const AWAIT_RE = /\{\s*(?:#\s*)?await\s/g;
+const SHARED_RE = /\bgetContext\s*(?:<[^>]*>\s*)?\(|\bfrom\s*['"][^'"]+\.svelte\.(?:js|ts)['"]/g;
+const count = (src, re) => (src.match(re) ?? []).length;
+/** Count a component source's interactivity markers. */
+function interactivity_facts(src) {
+	return {
+		handlers: count(src, HANDLER_RE),
+		state: count(src, STATE_RE),
+		effects: count(src, EFFECT_RE),
+		binds: count(src, BIND_RE),
+		actions: count(src, ACTION_RE),
+		awaits: count(src, AWAIT_RE),
+		shared: count(src, SHARED_RE),
+		files: 1
+	};
+}
+function merge_facts(a, b) {
+	if (!a) return { ...b };
+	return {
+		handlers: a.handlers + b.handlers,
+		state: a.state + b.state,
+		effects: a.effects + b.effects,
+		binds: a.binds + b.binds,
+		actions: a.actions + b.actions,
+		awaits: (a.awaits ?? 0) + (b.awaits ?? 0),
+		shared: (a.shared ?? 0) + (b.shared ?? 0),
+		files: a.files + b.files
+	};
+}
+/** Stable handoff path under Kit's `outDir`: client `generateBundle` writes; SSR reads at render
+*  (Kit is SSR-first). */
+function islandDepsHandoffPath(out_dir) {
+	return path.join(out_dir, "og-region-deps.json");
+}
+/**
+* `virtual:ogygia/island-deps` emitter — the SSR-render-time reader of the deps handoff.
+* Client: unused (modulepreload is SSR HTML). SSR: read the handoff JSON at *render* time — Kit
+* builds the server bundle before the client, so baking at `load()` would always be empty;
+* prerender/live SSR run after client generateBundle. Resolve via import.meta.url walk (not absolute
+* build-machine paths) so adapters find `output/server/og-region-deps.json` next to the server bundle.
+* `out_dir_rel` — Kit's `outDir` relative to the app root (`.svelte-kit` by default) — is the cwd
+* fallback for adapter-node / preview run from the app root.
+*/
+/** A CSS text that would close its own `<style>` cannot be inlined — link it instead. */
+const STYLE_CLOSE_RE = /<\/style/i;
+/**
+* INLINE REGION CSS. For every region CSS asset (`hrefs`: the union of the handoff's `css` and
+* `content_css` lists) whose bytes are under `threshold` — Kit's `inlineStyleThreshold`, the same
+* number Kit inlines its own route sheets under — keep the asset's text, keyed by its public href.
+* The render then emits `<style data-ogygia-region-css="href">` in place of a blocking `<link>`:
+* a page carrying twenty-five small island sheets (42 KB on a measured home page, twenty of them
+* under 3 KB) stops paying twenty-five requests before first paint. `0` = keep nothing (Kit's
+* default: never inline). Above the threshold, or not an emitted asset, → not in the map → linked.
+*
+* @internal Exported for unit tests.
+*/
+function collect_inline_css(bundle, hrefs, threshold) {
+	const out = {};
+	if (!(threshold > 0)) return out;
+	const by_href = /* @__PURE__ */ new Map();
+	for (const key in bundle) {
+		const item = bundle[key];
+		if (item.type !== "asset") continue;
+		const file = item.fileName || key;
+		by_href.set(file.startsWith("/") ? file : "/" + file, item);
+	}
+	for (const href of hrefs) {
+		if (href in out) continue;
+		const asset = by_href.get(href);
+		if (!asset || asset.source == null) continue;
+		const text = typeof asset.source === "string" ? asset.source : new TextDecoder().decode(asset.source);
+		if (text.length >= threshold) continue;
+		if (STYLE_CLOSE_RE.test(text)) continue;
+		out[href] = text;
+	}
+	return out;
+}
+function island_deps_module(ssr, is_dev, out_dir_rel = ".svelte-kit") {
+	if (!ssr) return `export function islandDeps(_entry) { return []; }\nexport function islandCss(_entry) { return []; }\nexport function islandCssInline(_href) { return null; }\nexport function contentCss(_id) { return []; }\nexport function islandReadsPage(_entry) { return false; }\nexport function islandPageKeys(_entry) { return null; }\nexport function islandPageWhy(_entry) { return null; }\nexport function islandRemotes(_entry) { return null; }\nexport function islandInteractivity(_entry) { return null; }\nexport function islandHazards(_entry) { return null; }\nexport function chunkContents(_href) { return null; }\nexport function chunkHeavy(_href) { return null; }\nexport function chunkBarrels(_href) { return null; }\nexport function chunkDuplicates() { return null; }\nexport function fnManifest() { return null; }\nexport function entryLocation(_identity) { return null; }`;
+	if (is_dev) return `export function islandDeps(_entry) { return []; }\nexport function islandCss(entry) { return entry ? [entry] : []; }\nexport function islandCssInline(_href) { return null; }\nexport function contentCss(_id) { return []; }\nexport function islandReadsPage(_entry) { return true; }\nexport function islandPageKeys(_entry) { return null; }\nexport function islandPageWhy(_entry) { return null; }\nexport function islandRemotes(_entry) { return null; }\nexport function islandInteractivity(_entry) { return null; }\nexport function islandHazards(_entry) { return null; }\nexport function chunkContents(_href) { return null; }\nexport function chunkHeavy(_href) { return null; }\nexport function chunkBarrels(_href) { return null; }\nexport function chunkDuplicates() { return null; }\nexport function fnManifest() { return null; }\nexport function entryLocation(_identity) { return null; }`;
+	return `import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+const __OG_INLINE = '__OGYGIA_ISLAND_DEPS_INLINE__';
+let cache = null;
+try { if (__OG_INLINE.charCodeAt(0) === 123) cache = JSON.parse(__OG_INLINE); } catch {}
+function candidates() {
+  const out = [];
+  try {
+    let dir = path.dirname(fileURLToPath(import.meta.url));
+    for (let i = 0; i < 8; i++) {
+      out.push(path.join(dir, 'og-region-deps.json'));
+      const parent = path.dirname(dir);
+      if (parent === dir) break;
+      dir = parent;
+    }
+  } catch {}
+  if (typeof process !== 'undefined' && process.cwd) {
+    const cwd = process.cwd();
+    out.push(path.join(cwd, ${JSON.stringify(out_dir_rel)}, 'og-region-deps.json'));\n    out.push(path.join(cwd, ${JSON.stringify(out_dir_rel)}, 'output', 'server', 'og-region-deps.json'));\n  }\n  return out;\n}\nfunction load() {\n  if (cache) return cache;\n  for (const p of candidates()) {\n    try { cache = JSON.parse(fs.readFileSync(p, 'utf8')); return cache; } catch {}\n  }\n  cache = {};\n  return cache;\n}\n// map (pre-css build) degrades gracefully: js falls back to the root, css to [].\nfunction pick(kind, entry) {\n  const all = load();\n  const map = all && typeof all[kind] === 'object' ? all[kind] : kind === 'js' ? all : null;\n  const list = map ? map[entry] : null;\n  return Array.isArray(list) ? list : [];\n}\nexport function islandDeps(entry) {\n  return entry ? pick('js', entry) : [];\n}\nexport function islandCss(entry) {\n  return entry ? pick('css', entry) : [];\n}\nexport function islandCssInline(href) {\n  const all = load();\n  const map = all && typeof all.css_inline === 'object' && all.css_inline ? all.css_inline : null;\n  if (!map || !href) return null;\n  const v = map[href];\n  return typeof v === 'string' ? v : null;\n}\nexport function contentCss(id) {\n  return id ? pick('content_css', id) : [];\n}\nexport function islandReadsPage(entry) {\n  const all = load();\n  const map = all && typeof all.page === 'object' && all.page ? all.page : null;\n  if (!map || !entry) return true;\n  const v = map[entry];\n  return v === undefined ? true : !!v;\n}\nexport function islandPageKeys(entry) {\n  const all = load();\n  const map = all && typeof all.page_keys === 'object' && all.page_keys ? all.page_keys : null;\n  if (!map || !entry) return null;\n  const v = map[entry];\n  return Array.isArray(v) ? v : null;\n}\nexport function islandPageWhy(entry) {\n  const all = load();\n  const map = all && typeof all.page_why === 'object' && all.page_why ? all.page_why : null;\n  if (!map || !entry) return null;\n  const v = map[entry];\n  return Array.isArray(v) ? v : null;\n}\nexport function islandRemotes(entry) {\n  const all = load();\n  const map = all && typeof all.remotes === 'object' && all.remotes ? all.remotes : null;\n  if (!map || !entry) return null;\n  const v = map[entry];\n  return Array.isArray(v) ? v : null;\n}\nexport function islandInteractivity(entry) {\n  const all = load();\n  const map = all && typeof all.interactivity === 'object' && all.interactivity ? all.interactivity : null;\n  if (!map || !entry) return null;\n  const v = map[entry];\n  return v && typeof v === 'object' ? v : null;\n}\nexport function chunkContents(href) {\n  const all = load();\n  const map = all && typeof all.contents === 'object' && all.contents ? all.contents : null;\n  if (!map || !href) return null;\n  const key = href.startsWith('/') ? href : '/' + href.replace(/^\\.\\//, '');\n  const v = map[key] ?? map[href];\n  return Array.isArray(v) ? v : null;\n}\nexport function chunkHeavy(href) {\n  const all = load();\n  const map = all && typeof all.heavy === 'object' && all.heavy ? all.heavy : null;\n  if (!map || !href) return null;\n  const key = href.startsWith('/') ? href : '/' + href.replace(/^\\.\\//, '');\n  const v = map[key] ?? map[href];\n  return v && typeof v === 'object' && Array.isArray(v.top) ? v : null;\n}\nexport function chunkDuplicates() {\n  const all = load();\n  const v = all && Array.isArray(all.dupes) ? all.dupes : null;\n  return v && v.length ? v : null;\n}\nexport function islandHazards(entry) {\n  const all = load();\n  const map = all && typeof all.hazards === 'object' && all.hazards ? all.hazards : null;\n  if (!map || !entry) return null;\n  const v = map[entry];\n  return Array.isArray(v) ? v : null;\n}\nexport function chunkBarrels(href) {\n  const all = load();\n  const map = all && typeof all.barrels === 'object' && all.barrels ? all.barrels : null;\n  if (!map || !href) return null;\n  const key = href.startsWith('/') ? href : '/' + href.replace(/^\\.\\//, '');\n  const v = map[key] ?? map[href];\n  return Array.isArray(v) ? v : null;\n}\nexport function fnManifest() {\n  const m = load().fn_manifest;\n  return m && typeof m === 'object' && Object.keys(m).length ? m : null;\n}\nexport function entryLocation(identity) {\n  const m = load().entries;\n  const v = m && typeof m === 'object' && identity ? m[identity] : null;\n  return typeof v === 'string' ? v : null;\n}\n`;
+}
+export { chunk_module_bytes, collectIslandDepModulepreloads, collect_inline_css, duplicate_modules, interactivity_facts, islandDepsHandoffPath, island_deps_module, kit_remote_hash, module_key, module_origin, remote_hash_of, summarize_chunk_contents };

package/dist/compiler/link/manifest.d.ts

@@ -0,0 +1,5 @@
+/**
+ * `virtual:ogygia/manifest` emitter — a legacy stub. Hydrate modules are loaded via
+ * `<ogygia-region entry>` URLs, not this map; only the `dev` flag is still read.
+ */
+export declare function manifest_module(is_dev: boolean): string;

package/dist/compiler/link/manifest.js

@@ -0,0 +1,9 @@
+// src/compiler/link/manifest.ts
+/**
+* `virtual:ogygia/manifest` emitter — a legacy stub. Hydrate modules are loaded via
+* `<ogygia-region entry>` URLs, not this map; only the `dev` flag is still read.
+*/
+function manifest_module(is_dev) {
+	return `export const dev = ${is_dev ? "true" : "false"};\nexport const regions = {};`;
+}
+export { manifest_module };

package/dist/compiler/link/page-keys.d.ts

@@ -0,0 +1,64 @@
+import { AstNode } from "../parse/oxc.js";
+type Node = AstNode;
+export type PageKeys = ReadonlySet<string> | "all";
+/** `'all'` with its reason: which construct, at which line. */
+export type AllReason = {
+  why: string;
+  line: number | null;
+};
+/**
+ * A call that hands the page to an IMPORTED helper: `getParams(page)`. The module alone cannot say
+ * what the helper reads; the build resolves the specifier, summarizes the helper's export
+ * ({@link summarize_export}) and folds the answer in — one level deep. A CMS app passed the page
+ * to one `url`-reading helper from 149 modules; following the call pins all of them.
+ */
+export type PendingCall = {
+  specifier: string;
+  imported: string;
+  arg: number;
+  line: number | null;
+};
+export type PageKeysAnswer = {
+  keys: PageKeys | null;
+  reason: AllReason | null;
+  pending: PendingCall[];
+};
+/**
+ * The top-level `page.data` keys a module reads, or `'all'` when a read cannot be pinned to a
+ * literal key, or `null` when the module never imports the page (nothing to ship for it).
+ * `kind` picks the parser: `'svelte'` for a component source, `'script'` for `.ts` / `.js`.
+ */
+export declare function page_data_keys(code: string, id: string, kind: "svelte" | "script"): PageKeys | null;
+/** The same answer with the reason an `'all'` was given (for the build report). */
+export declare function page_data_keys_answer(code: string, id: string, kind: "svelte" | "script"): PageKeysAnswer;
+/**
+ * What an exported helper reads of a page handed to it as its `arg`-th parameter — the bundle-time
+ * half of following `helper(page)`. `'all'` when the export is not a plain function (a re-export,
+ * a class, a variable the analysis cannot follow), when the parameter is not a plain name, or when
+ * the helper itself hands the page on (one level only).
+ */
+export type ExportSummary = PageKeys | {
+  follow: string[];
+  imported: string;
+};
+export declare function summarize_export(code: string, id: string, kind: "svelte" | "script", name: string, arg: number): ExportSummary;
+/** Union two answers: `'all'` absorbs everything, `null` is the identity. */
+export declare function merge_page_keys(a: PageKeys | null, b: PageKeys | null): PageKeys | null;
+/** Does this module even mention a page-store specifier? (the transform's pre-filter) */
+export declare function mentions_page_store(code: string): boolean;
+export declare function parse_roots(code: string, id: string, kind: "svelte" | "script"): Node[] | null;
+export type PendingResolver = (specifier: string, importer: string) => Promise<{
+  id: string;
+} | null | undefined>;
+/**
+ * For every module with pending `helper(page)` calls: resolve each helper, summarize its export,
+ * fold the answer into the module's keys (`'all'` with a reason when the helper cannot be
+ * summarized). Runs once per build, before the closure union. `read` and `resolve` are the
+ * build's (fs + the bundler's resolver), threaded in so this stays testable.
+ */
+export declare function follow_pending_page_calls(program: {
+  page_keys: Map<string, PageKeys>;
+  page_key_reasons: Map<string, AllReason>;
+  page_pending: Map<string, PendingCall[]>;
+}, resolve: PendingResolver, read?: (file: string) => string | null): Promise<void>;
+export {};