@ogygia/core 0.0.0 → 0.11.0

package/dist/compiler/kit.js

@@ -0,0 +1,563 @@
+import { dir_entries, fs, path } from "./host.js";
+import "./region/transform.js";
+import { parse_module } from "./parse/oxc.js";
+import { createRequire } from "node:module";
+// src/compiler/kit.ts
+/**
+* Locate Kit's internal wire-protocol + client remote-functions modules by resolving `@sveltejs/kit`'s
+* package.json (that IS exported) and joining the src path — deep-importing the file bypasses the exports
+* map. Also finds the app's universal hooks. Resolved from the APP root (`createRequire` off a root path),
+* so a monorepo sub-package still finds Kit. Never throws (a missing Kit → the devalue-codec fallback).
+*/
+function resolve_kit_paths(root) {
+	let kit_wire_path = null;
+	let kit_remote_index = null;
+	let universal_hooks = null;
+	let kit_transport_init = null;
+	try {
+		const require = createRequire(path.join(root, "noop.js"));
+		const kitRoot = path.dirname(require.resolve("@sveltejs/kit/package.json"));
+		const candidate = path.join(kitRoot, "src", "runtime", "shared.js");
+		if (fs.existsSync(candidate)) kit_wire_path = candidate;
+		const codec = path.join(kitRoot, "src", "runtime", "app", "internal", "transport.js");
+		if (fs.existsSync(codec)) kit_transport_init = codec;
+		const remoteIdx = path.join(kitRoot, "src", "runtime", "client", "remote-functions", "index.js");
+		if (fs.existsSync(remoteIdx)) kit_remote_index = remoteIdx;
+	} catch {
+		kit_wire_path = null;
+	}
+	for (const f of ["hooks.ts", "hooks.js"]) {
+		const abs = path.join(root, "src", f);
+		if (fs.existsSync(abs)) {
+			universal_hooks = abs;
+			break;
+		}
+	}
+	let client_hooks = null;
+	for (const f of ["hooks.client.ts", "hooks.client.js"]) {
+		const abs = path.join(root, "src", f);
+		if (fs.existsSync(abs)) {
+			client_hooks = abs;
+			break;
+		}
+	}
+	return {
+		kit_wire_path,
+		kit_remote_index,
+		universal_hooks,
+		client_hooks,
+		kit_transport_init
+	};
+}
+/**
+* The app's Kit MAJOR version (resolved off the app root, like {@link resolve_kit_paths}), or null when
+* no Kit resolves. The one fact `kit_asset` needs: Kit 2's `asset()` takes a path with its leading
+* slash, Kit 3's without — and no runtime probe can tell them apart (Kit 2 refuses a slash-less path
+* only in dev; in a build it returns it page-relative, and every island entry on a nested page 404'd).
+*/
+function kit_major(root) {
+	try {
+		const require = createRequire(path.join(root, "noop.js"));
+		const pkg = JSON.parse(fs.readFileSync(require.resolve("@sveltejs/kit/package.json"), "utf8"));
+		const major = Number.parseInt(pkg.version ?? "", 10);
+		return Number.isFinite(major) ? major : null;
+	} catch {
+		return null;
+	}
+}
+const DEFAULT_KIT_DIRS = {
+	routes: "src/routes",
+	out: ".svelte-kit"
+};
+const _kit_dirs = /* @__PURE__ */ new Map();
+function set_kit_dirs(root, dirs) {
+	_kit_dirs.set(root, dirs);
+}
+function kit_dirs(root) {
+	return _kit_dirs.get(root) ?? {
+		routes_dir: path.join(root, DEFAULT_KIT_DIRS.routes),
+		out_dir: path.join(root, DEFAULT_KIT_DIRS.out)
+	};
+}
+const _kit_inline_style_threshold = /* @__PURE__ */ new Map();
+function set_kit_inline_style_threshold(root, bytes) {
+	_kit_inline_style_threshold.set(root, bytes);
+}
+function kit_inline_style_threshold(root) {
+	return _kit_inline_style_threshold.get(root) ?? 0;
+}
+const CSR_EXPORT = /export\s+const\s+csr(?:\s*:\s*boolean)?\s*=\s*(true|false)/;
+const BLOCK_COMMENT_G = /\/\*[\s\S]*?\*\//g;
+const LINE_COMMENT_G = /^[ \t]*\/\/.*$/gm;
+/** Each option file's `csr`, read once until a route file changes (`clear_route_csr_cache`): every
+*  transform asks for its route's chain of option files, cache hits included, and each read was a
+*  file read (or an ENOENT throw) per directory level. */
+const _csr_of_file = /* @__PURE__ */ new Map();
+/** Read `export const csr = true|false` from a route options file; `undefined` if unset/absent. */
+function read_csr(file) {
+	if (_csr_of_file.has(file)) return _csr_of_file.get(file);
+	const v = read_csr_uncached(file);
+	_csr_of_file.set(file, v);
+	return v;
+}
+function read_csr_uncached(file) {
+	try {
+		let src = fs.readFileSync(file, "utf-8");
+		src = src.replace(BLOCK_COMMENT_G, "").replace(LINE_COMMENT_G, "");
+		const m = CSR_EXPORT.exec(src);
+		return m ? m[1] === "true" : void 0;
+	} catch {
+		return;
+	}
+}
+/** Each module's claimed `config` keys, read once until a route file changes (`clear_route_csr_cache`). */
+const _config_of_file = /* @__PURE__ */ new Map();
+/** `x as T` · `x satisfies T` · `<T>x` · `x!` · `(x)` → `x`. */
+function unwrap_expression(node) {
+	let n = node ?? null;
+	while (n && (n.type === "TSAsExpression" || n.type === "TSSatisfiesExpression" || n.type === "TSTypeAssertion" || n.type === "TSNonNullExpression" || n.type === "ParenthesizedExpression")) n = n.expression;
+	return n;
+}
+/** The object literal `export const config = {…}` declares in `program`, or null. */
+function config_object(program) {
+	for (const statement of program.body ?? []) {
+		if (statement.type !== "ExportNamedDeclaration") continue;
+		const declaration = statement.declaration;
+		if (declaration?.type !== "VariableDeclaration") continue;
+		for (const d of declaration.declarations ?? []) {
+			if (d.id?.type !== "Identifier" || d.id.name !== "config") continue;
+			const init = unwrap_expression(d.init);
+			return init?.type === "ObjectExpression" ? init : null;
+		}
+	}
+	return null;
+}
+/** A plain literal value (boolean, number, string, null), or `NOT_LITERAL`. */
+const NOT_LITERAL = Symbol("not-literal");
+function literal_value(node) {
+	const n = unwrap_expression(node);
+	if (n?.type !== "Literal" || n.regex || n.bigint !== void 0) return NOT_LITERAL;
+	return n.value;
+}
+/**
+* The claimed keys `export const config = {…}` sets in one route module: its literal-valued top-level
+* properties named in `keys`. `{}` when the file, the export or the keys are absent (a spread or a
+* `config` that is not an object literal is Kit's to read, not ours). A claimed key with a computed
+* value is a build error: it is read at build time, so ogygia could not honour it.
+*/
+function read_route_config(file, keys) {
+	const memo = file + "\0" + keys.join(",");
+	let out = _config_of_file.get(memo);
+	if (!out) _config_of_file.set(memo, out = read_route_config_uncached(file, keys));
+	return out;
+}
+function read_route_config_uncached(file, keys) {
+	const out = {};
+	let src;
+	try {
+		src = fs.readFileSync(file, "utf-8");
+	} catch {
+		return out;
+	}
+	if (!src.includes("config") || !keys.some((k) => src.includes(k))) return out;
+	const { program } = parse_module(src, file);
+	const object = program && config_object(program);
+	if (!object) return out;
+	for (const property of object.properties ?? []) {
+		if (property.type !== "Property" || property.computed) continue;
+		const key = property.key?.type === "Identifier" ? property.key.name : property.key?.value;
+		if (typeof key !== "string" || !keys.includes(key)) continue;
+		const value = literal_value(property.value);
+		if (value === NOT_LITERAL) throw new Error(`[ogygia] ${file}: \`config.${key}\` must be a literal (true, false, a number, a string or null) — ogygia reads it at build time.`);
+		out[key] = value;
+	}
+	return out;
+}
+const CONFIG_FILES_PAGE = [
+	"+page.server.js",
+	"+page.server.ts",
+	"+page.js",
+	"+page.ts"
+];
+const CONFIG_FILES_LAYOUT = [
+	"+layout.server.js",
+	"+layout.server.ts",
+	"+layout.js",
+	"+layout.ts"
+];
+const OPTION_FILES_PAGE = [
+	"+page.js",
+	"+page.ts",
+	"+page.server.js",
+	"+page.server.ts"
+];
+const OPTION_FILES_LAYOUT = [
+	"+layout.js",
+	"+layout.ts",
+	"+layout.server.js",
+	"+layout.server.ts"
+];
+/**
+* Own-chain Kit-effective `csr === false` for one route host — Kit's per-PAGE rule verbatim:
+* walk the layout option files root → host dir (then the page's own option files), deepest
+* declaration wins. `undefined` in sources means Kit's default (`true`).
+*/
+function own_chain_csr_false(hostFile, routesDir, layouts_only = false) {
+	let csr;
+	const dir = path.dirname(hostFile);
+	const rel = path.relative(routesDir, dir);
+	const parts = rel ? rel.split(path.sep) : [];
+	let cur = routesDir;
+	const chain = [cur];
+	for (const p of parts) {
+		cur = path.join(cur, p);
+		chain.push(cur);
+	}
+	for (const d of chain) for (const f of OPTION_FILES_LAYOUT) {
+		const v = read_csr(path.join(d, f));
+		if (v !== void 0) csr = v;
+	}
+	if (!layouts_only && path.basename(hostFile) === "+page.svelte") for (const f of OPTION_FILES_PAGE) {
+		const v = read_csr(path.join(dir, f));
+		if (v !== void 0) csr = v;
+	}
+	return csr === false;
+}
+/**
+* The ERROR-RENDER csr of every page route: Kit renders a page's `+error.svelte` with the LAYOUT
+* branch only (`PageNodes(layouts)` in its server renderer — the page node is dropped), so `csr`
+* for a 404 / 500 under a `csr = false` page is the layouts' answer, usually `true`. A document
+* keyed on the page's csr there is rendered client-off while Kit hydrates it: the lakes came out
+* in their bare form, Kit's hydration mismatched, and a site's header vanished on every error page
+* (customer deploy, 2026-09-15). Same walk as {@link csrTrueRouteIds}, page option files ignored.
+*/
+function errorCsrTrueRouteIds(routesDir) {
+	const ids = /* @__PURE__ */ new Set();
+	for (const page of pageLeaves(routesDir)) {
+		if (own_chain_csr_false(page, routesDir, true)) continue;
+		const rel = path.relative(routesDir, path.dirname(page));
+		const raw = "/" + (rel ? rel.split(path.sep).join("/") : "");
+		ids.add(normalize_route_id(raw));
+	}
+	return [...ids];
+}
+/** The error-render csr of a ROUTELESS response (no route matched: Kit renders the root layout and
+*  the root error page) — the root layout's own option, Kit's default `true` when unset. */
+function rootLayoutCsrTrue(routesDir) {
+	return !own_chain_csr_false(path.join(routesDir, "+page.svelte"), routesDir, true);
+}
+const _page_worlds = /* @__PURE__ */ new Map();
+function page_worlds(routesDir) {
+	let m = _page_worlds.get(routesDir);
+	if (!m) {
+		m = /* @__PURE__ */ new Map();
+		for (const page of pageLeaves(routesDir)) m.set(path.dirname(page), own_chain_csr_false(page, routesDir));
+		_page_worlds.set(routesDir, m);
+	}
+	return m;
+}
+/** The worlds of the pages a layout serves (its dir + everything below). */
+function layout_page_worlds(layoutDir, routesDir) {
+	let any_false = false;
+	let any_true = false;
+	const prefix = layoutDir + path.sep;
+	for (const [dir, is_false] of page_worlds(routesDir)) {
+		if (dir !== layoutDir && !dir.startsWith(prefix)) continue;
+		if (is_false) any_false = true;
+		else any_true = true;
+	}
+	return {
+		any_false,
+		any_true
+	};
+}
+/**
+* Kit-effective `csr === false` for a `+page.svelte` / `+layout.svelte` host. Pages use Kit's
+* own-chain rule; a LAYOUT is csr=false exactly when EVERY page it serves is csr=false (a layout
+* with no pages below — endpoint-only subtree — falls back to its own chain).
+* @param hostFile abs path to a route `.svelte`
+* @param routesDir abs `src/routes`
+*/
+function routeCsrIsFalse(hostFile, routesDir) {
+	if (!hostFile.startsWith(routesDir)) return false;
+	const base = path.basename(hostFile);
+	if (base === "+page.svelte") return own_chain_csr_false(hostFile, routesDir);
+	if (base !== "+layout.svelte") return false;
+	const { any_false, any_true } = layout_page_worlds(path.dirname(hostFile), routesDir);
+	if (any_false && !any_true) return true;
+	if (any_false || any_true) return false;
+	return own_chain_csr_false(hostFile, routesDir);
+}
+/**
+* True when `hostFile` is a route host whose islands ogygia must STRIP (Kit hydrates every page
+* this host serves). Pages: Kit's own-chain rule (default true, or an explicit `csr = true` that
+* beats a `false` up the chain). LAYOUTS: strippable ONLY when no page at/below them is
+* csr=false — on a mixed layout both this and {@link routeCsrIsFalse} are false (shared world:
+* islands kept, `documentIsCsrTrue` degrades them per document). `false` for non-route files
+* (shared components): their csr depends on which page renders them, so they keep their islands.
+*/
+function routeCsrIsTrue(hostFile, routesDir) {
+	const base = path.basename(hostFile);
+	if (base !== "+page.svelte" && base !== "+layout.svelte") return false;
+	if (!hostFile.startsWith(routesDir)) return false;
+	if (base === "+page.svelte") return !own_chain_csr_false(hostFile, routesDir);
+	const { any_false, any_true } = layout_page_worlds(path.dirname(hostFile), routesDir);
+	if (any_false) return false;
+	if (any_true) return true;
+	return !own_chain_csr_false(hostFile, routesDir);
+}
+/**
+* A routes directory's entries with SYMLINKS RESOLVED — Kit parity. Kit discovers routes by name +
+* `statSync` (which follows links), so a symlinked `+layout.ts` or a symlinked route directory is a
+* real node to Kit; a dirent's `isFile()` / `isDirectory()` is false for a link, which made a
+* linked root `+layout.ts` (csr=false) invisible here → "client build stays" predicted while Kit
+* skipped it → the runtime 404'd. (An app sharing routes between two trees links them.)
+*/
+function route_entries(dir) {
+	const out = [];
+	for (const e of dir_entries(dir)) {
+		let is_dir = e.isDirectory();
+		let is_file = e.isFile();
+		if (!is_dir && !is_file) try {
+			const st = fs.statSync(path.join(dir, e.name));
+			is_dir = st.isDirectory();
+			is_file = st.isFile();
+		} catch {
+			continue;
+		}
+		out.push({
+			name: e.name,
+			is_dir,
+			is_file
+		});
+	}
+	return out;
+}
+function pageLeaves(routesDir) {
+	const leaves = [];
+	const walk = (dir) => {
+		for (const e of route_entries(dir)) {
+			const full = path.join(dir, e.name);
+			if (e.is_dir) walk(full);
+			else if (e.name === "+page.svelte") leaves.push(full);
+		}
+	};
+	walk(routesDir);
+	return leaves;
+}
+/** Kit's `route.id` for a page host, with layout GROUP segments (`(app)`) stripped — the same
+*  normalization {@link csrTrueRouteIds} applies, so the two sides match whether or not Kit keeps
+*  groups in `route.id`. Root → `/`. */
+function normalize_route_id(id) {
+	return "/" + id.split("/").filter(Boolean).filter((s) => !(s.startsWith("(") && s.endsWith(")"))).join("/");
+}
+/**
+* The set of route ids (Kit `route.id`, group-stripped) whose EFFECTIVE csr is TRUE — i.e. Kit
+* hydrates the whole document there. A csr=false layout's islands rendered under one of these must
+* degrade to inline on BOTH legs (Kit owns hydration); Region reads this map on the server, and
+* `kit_hydrates_page()` is the identical client signal. Empty for a fully csr=false app (the norm);
+* only the csr=true exceptions land here.
+*/
+function csrTrueRouteIds(routesDir) {
+	const ids = /* @__PURE__ */ new Set();
+	for (const [dir, is_false] of page_worlds(routesDir)) {
+		if (is_false) continue;
+		const rel = path.relative(routesDir, dir);
+		const raw = "/" + (rel ? rel.split(path.sep).join("/") : "");
+		ids.add(normalize_route_id(raw));
+	}
+	return [...ids];
+}
+const _page_config = /* @__PURE__ */ new Map();
+const PAGE_FILE_RE = /^\+page(\.server)?\.(svelte|js|ts)$/;
+/** Every route dir with a `+page.*` file — a route that produces a page response (rendered HTML or
+*  a stored redirect). Broader than {@link pageLeaves} (svelte-only) on purpose. */
+function config_page_dirs(routesDir) {
+	const dirs = /* @__PURE__ */ new Set();
+	const walk = (dir) => {
+		for (const e of route_entries(dir)) {
+			const full = path.join(dir, e.name);
+			if (e.is_dir) walk(full);
+			else if (PAGE_FILE_RE.test(e.name)) dirs.add(dir);
+		}
+	};
+	walk(routesDir);
+	return [...dirs];
+}
+/** One page DIR's merged config, claimed keys only — Kit's own merge (`get_config`): the layout chain
+*  root → the dir (its own `+layout` included), then the page; at each level the server module, then
+*  the universal one; a later level replaces a key, top level only. A key no level sets is absent. */
+function own_chain_config(pageDir, routesDir, keys) {
+	const rel = path.relative(routesDir, pageDir);
+	const parts = rel ? rel.split(path.sep) : [];
+	let cur = routesDir;
+	const chain = [cur];
+	for (const p of parts) {
+		cur = path.join(cur, p);
+		chain.push(cur);
+	}
+	let merged = {};
+	for (const d of chain) for (const f of CONFIG_FILES_LAYOUT) merged = {
+		...merged,
+		...read_route_config(path.join(d, f), keys)
+	};
+	for (const f of CONFIG_FILES_PAGE) merged = {
+		...merged,
+		...read_route_config(path.join(pageDir, f), keys)
+	};
+	return merged;
+}
+/** A page directory's Kit `route.id`, group-stripped (`normalize_route_id`). */
+function page_route_id(dir, routesDir) {
+	const rel = path.relative(routesDir, dir);
+	return normalize_route_id("/" + (rel ? rel.split(path.sep).join("/") : ""));
+}
+/** Every page route id (group-stripped) → its merged config, claimed keys only. A key no level sets
+*  is absent, so the plugin applies its default; a page that sets none maps to `{}`. */
+function page_route_config(routesDir, keys) {
+	const memo = routesDir + "\0" + keys.join(",");
+	let m = _page_config.get(memo);
+	if (!m) {
+		m = {};
+		for (const dir of config_page_dirs(routesDir)) m[page_route_id(dir, routesDir)] = own_chain_config(dir, routesDir, keys);
+		_page_config.set(memo, m);
+	}
+	return m;
+}
+const _has_csr_true = /* @__PURE__ */ new Map();
+/**
+* Does the app have ANY csr=true page (Kit hydrates the whole document there)? Drives whether a
+* csr=false LAYOUT must link its island wrapper on the CLIENT leg: on a csr=true child page Kit
+* hydrates the layout, so its chrome islands must be REAL wrappers (Region degrades them inline),
+* not the thin stub the pure-csr=false path uses. A pure-csr=false app keeps the stub (thin client
+* graph); only mixed apps pay for the layout wrappers.
+*/
+function hasAnyCsrTrueRoute(routesDir) {
+	let v = _has_csr_true.get(routesDir);
+	if (v === void 0) {
+		v = csrTrueRouteIds(routesDir).length > 0;
+		_has_csr_true.set(routesDir, v);
+	}
+	return v;
+}
+/** Drop the memoized csr-topology answers (a route/`csr`-export add/remove invalidates them). */
+function clear_route_csr_cache() {
+	_csr_of_file.clear();
+	_has_csr_true.clear();
+	_page_worlds.clear();
+	_page_config.clear();
+	_config_of_file.clear();
+}
+const KEEP_CLIENT_DIR = ".ogygia-keep-client";
+const PAGE_UNIVERSAL = ["+page.js", "+page.ts"];
+const PAGE_SERVER = ["+page.server.js", "+page.server.ts"];
+const LAYOUT_UNIVERSAL = ["+layout.js", "+layout.ts"];
+const LAYOUT_SERVER = ["+layout.server.js", "+layout.server.ts"];
+/** A node's OWN csr (server module then universal wins), independent of the layout chain. */
+function own_csr(dir, universal, server) {
+	let csr;
+	for (const f of server) {
+		const v = read_csr(path.join(dir, f));
+		if (v !== void 0) csr = v;
+	}
+	for (const f of universal) {
+		const v = read_csr(path.join(dir, f));
+		if (v !== void 0) csr = v;
+	}
+	return csr;
+}
+/**
+* Collects every route node's EFFECTIVE csr the way Kit does — a node exists per `+page` and per
+* `+layout` (component OR standalone module), and Kit's static analysis resolves each node's
+* `page_options` through the LAYOUT CHAIN (`page_options = { ...parent_options, ...own }`), so a
+* root-layout `csr = false` makes every option-less descendant node `csr === false` too. Layout
+* groups like `(ogygia)/+layout.ts` count too.
+*
+* Issue #4/#1 root cause lived here: reading each node's OWN csr only, a fresh app with `csr =
+* false` in nothing but the root layout looked like "client build runs" (pages read `undefined`),
+* so the keepalive was never injected — while Kit, resolving the chain, skipped the client build
+* and the runtime `<script src>` 404'd.
+* @returns one entry per node (undefined = unset anywhere up-chain)
+*/
+function collectNodeEffectiveCsr(routesDir) {
+	const nodes = [];
+	let saw_root_layout = false;
+	const walk = (dir, is_root, inherited) => {
+		const entries = route_entries(dir);
+		const names = new Set(entries.filter((e) => e.is_file).map((e) => e.name));
+		const has = (list) => list.some((f) => names.has(f));
+		const layout_own = own_csr(dir, LAYOUT_UNIVERSAL, LAYOUT_SERVER);
+		const chain = layout_own !== void 0 ? layout_own : inherited;
+		if (names.has("+layout.svelte") || has(LAYOUT_UNIVERSAL) || has(LAYOUT_SERVER)) {
+			if (is_root) saw_root_layout = true;
+			nodes.push(chain);
+		}
+		if (names.has("+page.svelte") || has(PAGE_UNIVERSAL) || has(PAGE_SERVER)) {
+			const page_own = own_csr(dir, PAGE_UNIVERSAL, PAGE_SERVER);
+			nodes.push(page_own !== void 0 ? page_own : chain);
+		}
+		for (const e of entries) {
+			if (!e.is_dir) continue;
+			if (e.name === ".ogygia-keep-client") continue;
+			walk(path.join(dir, e.name), false, chain);
+		}
+	};
+	walk(routesDir, true, void 0);
+	if (!saw_root_layout) nodes.push(void 0);
+	return nodes;
+}
+/**
+* Replicates Kit's `manifest_data.nodes.every(n => n.page_options?.csr === false)` — the exact
+* condition under which Kit skips the client build — with `page_options` CHAIN-RESOLVED exactly as
+* Kit's static analysis resolves it. A single node whose effective csr is `true` or simply unset
+* keeps the build alive. When this is true, ogygia's runtime is never emitted, so index.ts injects
+* the keepalive. Deviations (a `+page@` reset, a statically-unanalysable option file) can only err
+* toward injecting a keepalive Kit didn't need — a harmless extra client build, never a 404.
+*/
+function clientBuildWillSkip(routesDir) {
+	if (!fs.existsSync(routesDir)) return false;
+	const nodes = collectNodeEffectiveCsr(routesDir);
+	if (nodes.length === 0) return false;
+	return nodes.every((csr) => csr === false);
+}
+/**
+* True when AT LEAST ONE page route is csr=false. A pure csr=true app (this returns false) needs no
+* ogygia runtime at all — Kit hydrates everything itself — so the runtime chunk is skipped entirely.
+*/
+function hasAnyCsrFalseRoute(routesDir) {
+	if (!fs.existsSync(routesDir)) return false;
+	return pageLeaves(routesDir).some((page_file) => routeCsrIsFalse(page_file, routesDir));
+}
+/** On-disk path of the injected keepalive route for a given app root. */
+function keep_client_dir(r) {
+	return path.join(kit_dirs(r).routes_dir, KEEP_CLIENT_DIR);
+}
+/** Write the URL-less `csr = true` keepalive layout into the app's routes (removed at process exit). */
+function inject_keep_client_route(r) {
+	const dir = keep_client_dir(r);
+	fs.mkdirSync(dir, { recursive: true });
+	fs.writeFileSync(path.join(dir, "+layout.ts"), "// Generated by ogygia for the duration of the build, then removed. A layout-only node —\n// no +page, so no servable URL — that stops SvelteKit skipping its client build when every\n// real route is csr = false. Safe to delete (gitignored; ogygia self-heals it).\nexport const csr = true;\n");
+}
+/** Remove leftover on-disk `.ogygia` trees from an earlier materialization approach. */
+function clean_stale_ogygia_dirs(dir) {
+	let entries;
+	try {
+		entries = dir_entries(dir);
+	} catch {
+		return;
+	}
+	for (const entry of entries) {
+		if (!entry.isDirectory()) continue;
+		const full = path.join(dir, entry.name);
+		if (entry.name === "node_modules") continue;
+		if (entry.name === ".ogygia") {
+			fs.rmSync(full, {
+				recursive: true,
+				force: true
+			});
+			continue;
+		}
+		clean_stale_ogygia_dirs(full);
+	}
+}
+export { DEFAULT_KIT_DIRS, KEEP_CLIENT_DIR, clean_stale_ogygia_dirs, clear_route_csr_cache, clientBuildWillSkip, csrTrueRouteIds, errorCsrTrueRouteIds, hasAnyCsrFalseRoute, hasAnyCsrTrueRoute, inject_keep_client_route, keep_client_dir, kit_dirs, kit_inline_style_threshold, kit_major, normalize_route_id, page_route_config, read_csr, read_route_config, resolve_kit_paths, rootLayoutCsrTrue, routeCsrIsFalse, routeCsrIsTrue, set_kit_dirs, set_kit_inline_style_threshold };

package/dist/compiler/link/build-output.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Guardrail: a content collection must never reach a CLIENT chunk. Ground truth is the finished
+ * bundle. A compiled corpus module (.svx/.md) in a client chunk means a `content()` collection was
+ * imported into client-shipped code (usually an island), which drags its eager `import.meta.glob` —
+ * every doc — into the browser. On a csr=false site the corpus renders server-side and should never
+ * appear here, so any hit is a real leak. A warning, not a throw: the guardrail must never break a build.
+ */
+export declare function warn_content_leaks(bundle: Record<string, unknown>, root: string, is_island_path: (id: string) => boolean): void;
+/**
+ * Write the island-deps handoff JSON (the map SSR reads at render): the stable path under Kit's
+ * `outDir` (`.svelte-kit` unless the app configured `kit.outDir`), an adapter-friendly copy next
+ * to the server bundle, AND an in-place inline into every server chunk that carries the token slot
+ * — inlining is what makes it survive serverless tracing (@vercel/nft only bundles *imported*
+ * files, not runtime fs reads, so the co-located JSON is dropped there; that is why held/dual
+ * regions that cross the wire rendered unstyled on Vercel/Netlify). Unpatched builds keep the fs
+ * fallback (adapter-node, dev-preview).
+ */
+export declare function emit_island_deps_handoff(root: string, json: string, out_dir: string): void;
+/**
+ * SEED SHAPING report (client `writeBundle`): which islands read `page.data` through the shim, how
+ * many keys they were pinned to, and — the actionable part — the modules whose reads could not be
+ * pinned, each with its line and why, since one such module makes every page carrying that island
+ * ship its whole `page.data`. Same shape as the barrels report: a few lines, a count for the rest.
+ */
+export declare function report_seed_shaping(map: {
+  page: Record<string, boolean>;
+  page_keys: Record<string, string[] | null>;
+}, bundle: Record<string, {
+  type: string;
+  moduleIds?: string[];
+  imports?: string[];
+}>, program: {
+  page_key_reasons: Map<string, {
+    why: string;
+    line: number | null;
+  }>;
+}, root: string, file_of?: (identity: string) => string): Record<string, SeedWhy[]>;
+/** a module that made an island ship all of `page.data`: where (root-relative when inside the app)
+ *  and why — what the profiler points at when the island's own file reads nothing whole */
+export interface SeedWhy {
+  file: string;
+  line: number | null;
+  why: string;
+}