@ogygia/core 0.0.0 → 0.11.0

package/dist/compiler/driver.js

@@ -0,0 +1,1352 @@
+import { createHash, dir_entries, fs, path } from "./host.js";
+import { fnv1a32 } from "../runtime/hash.js";
+import { CLIENT_BINDING_STUB, is_island_path, transformHost, transformTsRegions, wrapperVirtualId } from "./region/transform.js";
+import { clean_stale_ogygia_dirs, hasAnyCsrTrueRoute, kit_dirs, routeCsrIsFalse, routeCsrIsTrue } from "./kit.js";
+import { run_module_macros } from "./macros/pipeline.js";
+import { is_script_request } from "./script-request.js";
+import { generateHydrateFeaturesSource, generateRuntimeEntrySource, resolveFeatures } from "./link/runtime-entry.js";
+import { resolveFoucImportSpec } from "./fouc-css.js";
+import { appendSvelteModuleRegistrations, appendTransportRegistrations, moduleHasTransportable, svelteModuleHasTransportable } from "./content/transportables.js";
+import { APP_SHIM_IMPORT, FOREIGN_HYDRATE_MARK, rewrite_lake_import_to_placeholder } from "./region/emit.js";
+import { island_deps_module } from "./link/island-deps.js";
+import { island_shim_source, runtime_shim_source } from "./link/entry-shim.js";
+import { context_string_keys, source_uses_ogygia_context } from "./link/context-detect.js";
+import { collect_flag_sites } from "./flags.js";
+import { router_css_module, router_css_roots } from "./link/router-css.js";
+import { rate_limit_module, region_ttl_module, route_config_module, route_csr_module, secret_module, server_plugins_module, session_cookie_module, sign_module } from "./link/caps.js";
+import { router_config_module } from "./link/router-config.js";
+import { kit_transport_module, source_crosses_wire, transport_module, transportables_module } from "./link/transport.js";
+import { PAGE_DATA_READS_TOKEN, server_island_ids, server_islands_module, server_manifest_module } from "./link/server-manifest.js";
+import { manifest_module } from "./link/manifest.js";
+import { dev_hmr_client_source } from "./dev/dev-hmr.js";
+import { island_vpaths_affected_by_file, same_module_path } from "./dev/hmr.js";
+import { PROFILER_MAPS_PLACEHOLDER, RESOLVED, V_DEVTOOLS_BOOT, V_DEVTOOLS_BOOT_URL, V_DEVTOOLS_META, V_DEV_HMR, V_DEV_HMR_URL, V_FN_MANIFEST, V_HYDRATE_FEATURES, V_ISLAND_DEPS, V_KIT_TRANSPORT, V_MANIFEST, V_PROFILER_MAPS, V_RATE_LIMIT, V_REGION_ENDPOINT, V_REGION_TTL, V_REQUEST_EVENT, V_ROUTER_CONFIG, V_ROUTER_CSS, V_ROUTE_CONFIG, V_ROUTE_CSR, V_RUNTIME, V_RUNTIME_ENTRY, V_RUNTIME_URL, V_SECRET, V_SERVER_ISLANDS, V_SERVER_MANIFEST, V_SERVER_PLUGINS, V_SESSION_COOKIE, V_SIGN, V_TRANSPORT, V_TRANSPORTABLES, V_TRANSPORTABLES_EAGER } from "./ids.js";
+import { host_key, strip_id } from "./program.js";
+import { mentions_page_store, page_data_keys_answer } from "./link/page-keys.js";
+import { export_names, is_registry_stub_id, registry_client_id, registry_client_path, registry_client_source, registry_stub_names, registry_stub_source, static_script_specs } from "./link/registry-stub.js";
+import { island_host_loaded } from "./link/emit-gate.js";
+import { stamp_opaque } from "./ownership-stamps.js";
+import { strip_bom } from "./bom.js";
+// src/compiler/driver.ts
+/**
+* The `Compiler` — the driver / long-lived compile session. It holds the `Program` (cross-file
+* linker), the resolved `CompileCtx`, and the per-file transform cache, and exposes the file-local
+* front-end as one call: `transform(source, id)` → parse ▸ analyze ▸ lower ▸ emit (today fused inside
+* `transformHost`), memoized. It is bundler-agnostic by construction — it imports no Vite; the adapter
+* drives it. That independence is the design goal: a future REPL is just a second adapter over the
+* same driver, feeding a `CompileCtx` + source and rendering the returned freeze.
+*
+* The transform cache is content-keyed (`hit.code === source`), so a changed source misses and
+* recomputes on its own; the linker's `unregister_host` deliberately does NOT clear it.
+*/
+const performance = globalThis.performance;
+/** The chunk names our content-hashed entries are emitted under (`entry_file_pattern` keys on them). */
+const ISLAND_ENTRY_NAME_PREFIX = "og-region.";
+const RUNTIME_ENTRY_NAME = "og-runtime";
+const LEADING_SLASH = /^\//;
+const BACKSLASH_G = /\\/g;
+const COMPONENT_EXT_RE = /\.(svelte|js|ts)$/;
+/** A Kit route host file (`+page.svelte`, `+layout.ts`, …) — the page node's own client modules. */
+const ROUTE_HOST_FILE_RE = /^\+(page|layout)\.(svelte|ts|js|mjs)$/;
+/** A `.ts`/`.js` module that can be a region registry (a minted `.ts` region host). */
+const TS_REGISTRY_EXT_RE = /\.(ts|js|mjs)$/;
+/** A Svelte rune module (`.svelte.ts` / `.svelte.js`). */
+const SVELTE_RUNE_MODULE_RE = /\.svelte\.(ts|js)$/;
+/** A script module the seed-shaping analysis parses with oxc (`.svelte.ts` included). */
+const SCRIPT_MODULE_RE = /\.(?:[cm]?[jt]sx?)$/;
+const SOURCE_EXT_RE = /\.(svelte|ts|js|mjs|cjs)$/;
+const SERVER_MODULE_EXT_RE = /\.(server|remote)\.(ts|js|mjs)$/;
+const SERVER_DIR_RE = /\/(src\/lib\/server|server)\//;
+/** Static import / export-from / `import()` specifiers, for the island-graph dep walk (shared `g`
+*  regex — `walk_dep` resets `lastIndex` before each scan). */
+const IMPORT_SPEC_G = /\bfrom\s*['"]([^'"\n]+)['"]|\bimport\s*['"]([^'"\n]+)['"]|\bimport\s*\(\s*['"]([^'"\n]+)['"]/g;
+/** The extensions an extension-less island import may resolve to (bare, then index files). */
+const ISLAND_DEP_EXTS = [
+	"",
+	".svelte",
+	".ts",
+	".js",
+	".svelte.ts",
+	".svelte.js",
+	".mjs"
+];
+const MODULE_SPEC_RE = /(?:^|[\n;])\s*(?:import|export)\b[^;'"()]*?from\s*['"]([^'"]+)['"]|(?:^|[\n;])\s*import\s*['"]([^'"]+)['"]/g;
+/** Where Kit's `$app` alias points (Kit 2 and 3: `resolve.alias` `$app` → `<kit>/src/runtime/app`). */
+const KIT_RUNTIME_APP = "/@sveltejs/kit/src/runtime/app/";
+/**
+* The island shim for an `$app/*` import, by specifier or by where Kit's alias sent it: Vite's alias
+* plugin runs before any plugin's resolveId, so an import the transform did not rewrite (a module
+* that joined the island graph late) arrives as `<kit>/src/runtime/app/state`, `…/state/index.js`.
+*/
+function app_shim_for(source, shims) {
+	const direct = shims[source];
+	if (direct) return direct;
+	const at = source.indexOf(KIT_RUNTIME_APP);
+	if (at === -1) return null;
+	let name = source.slice(at + 31);
+	if (name.endsWith("/index.js")) name = name.slice(0, -9);
+	else if (name.endsWith(".js")) name = name.slice(0, -3);
+	return shims["$app/" + name] ?? null;
+}
+/** Manifest path for a flag site: package-relative for declared surfaces, root-relative else. */
+function flag_site_file(ctx, full) {
+	return (ctx.pkg_identity(full) ?? path.relative(ctx.root, full)).split(path.sep).join("/");
+}
+function extract_module_specs(src) {
+	MODULE_SPEC_RE.lastIndex = 0;
+	const specs = [];
+	let m;
+	while (m = MODULE_SPEC_RE.exec(src)) specs.push(m[1] ?? m[2]);
+	return specs;
+}
+const fnv = fnv1a32;
+/** Once per module id: a dependency file carries ogygia marks but its package declares no
+*  `ogygia.files` — the marks are then silently inert (a `with { }` attribute is valid syntax,
+*  it just never rewrites), which is the worst way to fail. Say it loudly, once. */
+const warned_undeclared = /* @__PURE__ */ new Set();
+function warn_undeclared_pkg_marks(id) {
+	if (warned_undeclared.has(id)) return;
+	warned_undeclared.add(id);
+	console.warn(`[ogygia] ${id} uses ogygia marks, but its package declares no \`"ogygia": { "files": [...] }\` — the marks are IGNORED. Add the field to that package's package.json (npm-"files"-style paths/globs) to put it on ogygia's compile surface.`);
+}
+/** The client-hooks boot snippet for a generated runtime entry: an import of the runtime runner and
+*  a call that dynamic-imports the app's `hooks.client.*` — empty when the app has none. Runs the
+*  file's `init` on boot for csr=false pages (the runner skips a csr=true document). */
+/**
+* DEV: the folder `ogygia/runtime` resolves to — this package's own `exports["./runtime"]` (the
+* dev boot imports that specifier). A published package points it at `dist/runtime` (= the
+* prebuilt `runtime_dir`); this repo's workspace points it at `src/runtime` (`.ts` files). Null
+* when it cannot be read (then `runtime_dir` stands). Once per runtime dir.
+*/
+const dev_runtimes = /* @__PURE__ */ new Map();
+function dev_runtime_of(runtime_dir) {
+	if (dev_runtimes.has(runtime_dir)) return dev_runtimes.get(runtime_dir);
+	let out = null;
+	try {
+		const pkg_dir = path.dirname(path.dirname(runtime_dir));
+		const exp = JSON.parse(fs.readFileSync(path.join(pkg_dir, "package.json"), "utf8"))?.exports?.["./runtime"];
+		const rel = typeof exp === "string" ? exp : exp?.default;
+		if (typeof rel === "string") {
+			const file = path.join(pkg_dir, rel);
+			if (fs.existsSync(file)) out = {
+				dir: path.dirname(file),
+				ts: file.endsWith(".ts")
+			};
+		}
+	} catch {
+		out = null;
+	}
+	dev_runtimes.set(runtime_dir, out);
+	return out;
+}
+/** The plugins' browser halves for a generated boot: one static import each, and the list to pass. */
+function client_plugins_boot(ctx) {
+	if (!ctx.client_plugins.length) return {
+		imports: "",
+		list: ""
+	};
+	return {
+		imports: ctx.client_plugins.map((spec, i) => `import __og_client_${i} from ${JSON.stringify(spec)};\n`).join(""),
+		list: `[${ctx.client_plugins.map((_, i) => `__og_client_${i}`).join(", ")}]`
+	};
+}
+function client_hooks_boot(ctx) {
+	if (!ctx.client_hooks) return {
+		imports: "",
+		call: ""
+	};
+	const runner = `${ctx.runtime_dir}/client-hooks.js`.replace(BACKSLASH_G, "/");
+	return {
+		imports: `import { run_app_client_hooks as __og_run_client_hooks } from ${JSON.stringify(runner)};\n`,
+		call: `__og_run_client_hooks(() => import(${JSON.stringify(ctx.client_hooks)}));\n`
+	};
+}
+var Compiler = class {
+	program;
+	transform_cache = /* @__PURE__ */ new Map();
+	profiler;
+	/** Every `import.meta.og.$` hoist collected across the build (tag → factory source). Filled by
+	*  `macros()`; drained by the adapter's fn-manifest emit (dev load leg, renderChunk, writeBundle). */
+	dollar_hoists = /* @__PURE__ */ new Map();
+	/** `prescan()` is once-per-session — guarded so the adapter can call it from any hook. */
+	#scanned = false;
+	/**
+	* DEV: the server-island ids the last emitted `virtual:ogygia/server-manifest` carried. A HOST edit
+	* drops its islands' rows (`invalidate_for_file`) and invalidates the manifest; Kit re-imports the
+	* handle BEFORE the page transform re-registers them, so that manifest is emitted WITHOUT the ids —
+	* and nothing re-invalidated it afterwards: every hole answered 403 until a restart. The adapter
+	* asks `server_manifest_stale()` after each transform and invalidates again when a registered
+	* server id is missing from this set. `null` until the first emit (nothing to compare).
+	*/
+	#emitted_server_ids = null;
+	/** True (once) when a server island registered since the last manifest emit — re-invalidate it. */
+	server_manifest_stale() {
+		const emitted = this.#emitted_server_ids;
+		if (!emitted) return false;
+		for (const id of server_island_ids(this.program)) if (!emitted.has(id)) {
+			this.#emitted_server_ids = null;
+			return true;
+		}
+		return false;
+	}
+	#ctx = null;
+	constructor(program, profiler) {
+		this.program = program;
+		this.profiler = profiler;
+	}
+	/** Bind the resolved compile context (called once the bundler has resolved the build). */
+	configure(ctx) {
+		this.#ctx = ctx;
+	}
+	/**
+	* Devtools: the `island id → component name` map, read at call time off the live registry (so a
+	* dev-server middleware serves a COMPLETE, current map — no stale virtual-module snapshot). Keys
+	* are the island id (`<hash>` in `virtual:ogygia/island/<hash>.js`); values the component's
+	* basename. A held/generated island with no source file is skipped (the tab keeps its short hash).
+	*/
+	region_names() {
+		const names = {};
+		for (const [iid, vpath] of this.program.by_id) {
+			const cp = this.program.registry.get(vpath)?.componentPath;
+			if (!cp) continue;
+			const base = (cp.split("?")[0].split("#")[0].split("/").pop() || "").replace(COMPONENT_EXT_RE, "");
+			if (base && base !== iid) names[iid] = base;
+		}
+		return names;
+	}
+	/**
+	* Run the module-macro passes (`wire`/`$`/`source`/`store`/auto-brand, the plugins' macros, then
+	* `bake`) over one module — the leg that must land before the island transform / svelte compile /
+	* ts-region minting sees it. `source` is the CURRENT text (a plugin's pre-transform may already have
+	* edited it). Returns `{ code, touched }`; the caller nulls its own sourcemap when `touched`.
+	*/
+	macros(source, id) {
+		const ctx = this.#ctx;
+		return run_module_macros(source, id, {
+			root: ctx.root,
+			resolveAlias: ctx.resolve_alias,
+			pkgRoot: ctx.pkg_root,
+			dollarHoists: this.dollar_hoists,
+			macros: ctx.macros
+		}, this.profiler);
+	}
+	/**
+	* Transform a content (`.svx`/`.md`) island source the markdown preprocessor hands back — always
+	* wrapper-linked (`linkVirtual: true`), because a preprocessor output is shared across the ssr/client
+	* legs and can't take the csr=false stub split; content files aren't routes, so they'd get wrappers
+	* anyway. Registers the descriptors and returns the rewritten code, or `null` when it has no islands.
+	* This is the transform the adapter installs on the content-island bridge.
+	*/
+	transform_content_island(source, filename) {
+		const result = this.transform(source, filename, {
+			ssr: false,
+			linkVirtual: true
+		});
+		if (!result || !result.islands?.length) return null;
+		this.program.register(result, filename);
+		return result.code;
+	}
+	/**
+	* Lower one file: run the fused parse ▸ analyze ▸ lower ▸ emit front-end and register nothing —
+	* the caller registers the returned descriptors into the `Program`. Memoized per
+	* `(id, ssr, linkVirtual, routeCsr)`, content-gated on the source.
+	*/
+	/**
+	* The REAL source file a module derives from. A real file is its own origin. A generated entry
+	* (a portable-snippet synth, re-processed under its `virtual:ogygia/island/<iid>.svelte` id)
+	* resolves through the registry's `hostPath` — transitively, so an entry minted while re-processing
+	* another entry still lands on the file the outermost slice was cut from. This is the ONE rule
+	* `resolve_id` already applies to an entry's plain imports; threading it into the transform keeps
+	* a re-minted marked import (whose resolved path is BAKED into a region module's source, bypassing
+	* resolveId) on the same base. Normalized like `transform_module`'s gate (`strip_id`, `/@id/`).
+	*/
+	#origin_of(id) {
+		const { registry } = this.program;
+		const bare = (s) => {
+			const n = strip_id(s);
+			return n.startsWith("/@id/") ? n.slice(5) : n;
+		};
+		let cur = bare(id);
+		const seen = /* @__PURE__ */ new Set([cur]);
+		for (;;) {
+			const host = registry.get(cur)?.hostPath;
+			if (!host) break;
+			const next = bare(host);
+			if (seen.has(next)) break;
+			seen.add(next);
+			cur = next;
+		}
+		return cur;
+	}
+	transform(source, id, opts = {}) {
+		const ctx = this.#ctx;
+		const { prof, P, outHash } = this.profiler;
+		const ssr = opts.ssr !== false;
+		const routesDir = kit_dirs(ctx.root).routes_dir;
+		const is_layout_host = path.basename(id) === "+layout.svelte";
+		const link_virtual = opts.linkVirtual !== void 0 ? opts.linkVirtual : ssr || !routeCsrIsFalse(id, routesDir) || is_layout_host && hasAnyCsrTrueRoute(routesDir);
+		const route_csr = routeCsrIsTrue(id, routesDir) ? true : routeCsrIsFalse(id, routesDir) ? false : void 0;
+		const cache_key = `${id}\0${ssr ? "s" : "c"}\0${link_virtual ? "1" : "0"}\0${route_csr === true ? "t" : route_csr === false ? "f" : "n"}`;
+		const hit = this.transform_cache.get(cache_key);
+		if (hit && hit.code === source) {
+			if (P) prof.transformHit++;
+			return hit.result;
+		}
+		const th0 = P ? performance.now() : 0;
+		const result = transformHost(source, id, {
+			root: ctx.root,
+			libDir: ctx.libDir,
+			readFile: (abs) => ctx.read_file(abs),
+			pathModule: path,
+			dev: ctx.is_dev,
+			virtualPathFor: (_hostId, iid) => ctx.island_virtual_id(iid),
+			wrapperPathFor: (_hostId, iid) => wrapperVirtualId(iid),
+			devUrlFor: (virtualPath) => ctx.dev_url_for(virtualPath),
+			originOf: (host) => this.#origin_of(host),
+			appDir: ctx.app_dir,
+			visibleMargin: ctx.visibleMargin,
+			presets: ctx.presets,
+			importKeys: ctx.import_keys,
+			idSalt: ctx.id_salt,
+			pkg_identity: (abs) => ctx.pkg_identity(abs),
+			linkVirtualIsland: link_virtual,
+			clientBindingStub: CLIENT_BINDING_STUB,
+			routeCsr: route_csr,
+			ssr
+		});
+		if (P) {
+			prof.transformMs += performance.now() - th0;
+			prof.transformN++;
+			outHash.set(cache_key, fnv(JSON.stringify(result?.code ?? result)));
+		}
+		this.transform_cache.set(cache_key, {
+			code: source,
+			result
+		});
+		return result;
+	}
+	/**
+	* Mint the `.ts` / `.js` regions in one module — `with { wake: … }` load/remote imports become
+	* island descriptors. The ts-region half of the front-end, sharing the driver's resolved context
+	* (so both the prescan and the transform hook mint identically). Not memoized — the caller gates it
+	* on the id + marker; the returned descriptors are the caller's to `register`.
+	*/
+	ts_regions(source, id) {
+		const ctx = this.#ctx;
+		return transformTsRegions(source, id, {
+			root: ctx.root,
+			libDir: ctx.libDir,
+			pathModule: path,
+			dev: ctx.is_dev,
+			virtualPathFor: (_hostId, iid) => ctx.island_virtual_id(iid),
+			devUrlFor: (virtualPath) => ctx.dev_url_for(virtualPath),
+			appDir: ctx.app_dir,
+			importKeys: ctx.import_keys,
+			idSalt: ctx.id_salt,
+			pkg_identity: (abs) => ctx.pkg_identity(abs)
+		});
+	}
+	/**
+	* Discover every island up front — walk `src/`, transform each `.svelte` host and mint each
+	* `.ts`/`.js` region, register the descriptors, then complete `island_graph` TRANSITIVELY and
+	* finalize the runtime capability marks (so the sticky runtime entry bundles only what the app
+	* uses, and its immutable chunk name busts on a feature-set change). Once per session, so the
+	* adapter can call it from any hook. Populates the `Program`; the fs walk is the only side effect.
+	*/
+	prescan() {
+		if (this.#scanned) return;
+		this.#scanned = true;
+		const ctx = this.#ctx;
+		const { prof, P } = this.profiler;
+		const program = this.program;
+		const { registry, island_graph, transportable_modules, runtime_marks } = program;
+		const root = ctx.root;
+		const src_dir = path.join(root, "src");
+		clean_stale_ogygia_dirs(src_dir);
+		const page_importers = ctx.page_importers;
+		const imports_page_spec = (specs) => page_importers.length > 0 && specs.some((s) => page_importers.includes(s));
+		const scan_file = (full, name) => {
+			if (name.endsWith(".svelte")) {
+				const src = ctx.read_file(full);
+				if (src == null) return;
+				if (!runtime_marks.context && source_uses_ogygia_context(src)) runtime_marks.context = true;
+				if (!program.crosses_wire && source_crosses_wire(src)) program.crosses_wire = true;
+				{
+					const specs = extract_module_specs(src);
+					if (specs.length) program.module_specs.set(full, specs);
+					if (imports_page_spec(specs)) program.router_modules.add(full);
+					if (specs.includes("@ogygia/flags")) program.flag_sites.push(...collect_flag_sites(src, full, flag_site_file(ctx, full)));
+				}
+				if (svelteModuleHasTransportable(src, full)) transportable_modules.add(full);
+				const result = this.transform(src, full);
+				if (result) program.register(result, full);
+			} else if ((name.endsWith(".ts") || name.endsWith(".js") || name.endsWith(".mjs")) && !name.endsWith(".d.ts")) {
+				const src = ctx.read_file(full);
+				if (src == null) return;
+				if (!runtime_marks.context && source_uses_ogygia_context(src)) runtime_marks.context = true;
+				if (!program.crosses_wire && (name.endsWith(".remote.ts") || name.endsWith(".remote.js") || source_crosses_wire(src))) program.crosses_wire = true;
+				{
+					const specs = extract_module_specs(src);
+					if (specs.length) program.module_specs.set(full, specs);
+					if (imports_page_spec(specs)) program.router_modules.add(full);
+					if (specs.includes("@ogygia/flags")) program.flag_sites.push(...collect_flag_sites(src, full, flag_site_file(ctx, full)));
+				}
+				if (moduleHasTransportable(src, full)) transportable_modules.add(full);
+				const result = this.ts_regions(src, full);
+				if (result) program.register(result, full);
+			}
+		};
+		const walk = (dir) => {
+			let entries;
+			try {
+				entries = dir_entries(dir);
+			} catch {
+				return;
+			}
+			for (const entry of entries) {
+				const full = path.join(dir, entry.name);
+				if (entry.isDirectory()) {
+					if (entry.name === "node_modules" || entry.name === ".ogygia") continue;
+					walk(full);
+				} else scan_file(full, entry.name);
+			}
+		};
+		{
+			const __ps = P ? performance.now() : 0;
+			walk(src_dir);
+			for (const p of ctx.pkg_scan) {
+				for (const d of p.dirs) walk(d);
+				for (const f of p.files) scan_file(f, f.slice(f.lastIndexOf("/") + 1));
+			}
+			for (const f of ctx.page_files) {
+				program.router_modules.add(f);
+				if (!program.module_specs.has(f)) {
+					const src = ctx.read_file(f);
+					const specs = src == null ? [] : extract_module_specs(src);
+					if (specs.length) program.module_specs.set(f, specs);
+				}
+			}
+			if (P) prof.prescanMs += performance.now() - __ps;
+		}
+		{
+			const __ws = P ? performance.now() : 0;
+			for (const entry of registry.values()) if (entry.componentPath) this.mark_island_closure(entry.componentPath);
+			if (P) prof.prescanMs += performance.now() - __ws;
+		}
+		if (!runtime_marks.context) {
+			const reads = [];
+			const island_set = /* @__PURE__ */ new Set();
+			for (const file of island_graph) {
+				if (!file.endsWith(".svelte") && !SCRIPT_MODULE_RE.test(file)) continue;
+				const src = ctx.read_file(file);
+				if (src == null) continue;
+				const { reads: r, sets } = context_string_keys(src, file.endsWith(".svelte") ? "svelte" : "script");
+				for (const k of sets) island_set.add(k);
+				if (r.length) reads.push({
+					file,
+					keys: r
+				});
+			}
+			for (const { file, keys } of reads) for (const key of keys) {
+				if (island_set.has(key)) continue;
+				console.warn(`[ogygia] island code ${path.relative(root, file)} reads getContext('${key}'), but this app registers no ogygia context provider and no island code sets '${key}'. On a csr=false page a value set with Svelte's setContext in a page/layout does NOT cross the island boundary — the island reads undefined on the client, re-renders a different tree, and Svelte discards its server-rendered DOM on hydration (a silent full re-render). Fix: provide '${key}' with setContext / <Provide> / createContext imported from 'ogygia' (in a csr=false layout); the read stays getContext('${key}').`);
+			}
+		}
+		if (transportable_modules.size > 0) runtime_marks.wire = true;
+		runtime_marks.complete = true;
+		program.runtime_feature_hash = createHash("sha256").update(resolveFeatures(runtime_marks).join(",")).digest("hex").slice(0, 8);
+	}
+	/** Files the island-closure walk has already read (see `mark_island_closure`). Lives for the
+	*  program, so a closure marked at prescan is never re-walked when a later island shares it. */
+	#island_closure_seen = /* @__PURE__ */ new Set();
+	/**
+	* Mark `componentAbs` and EVERYTHING it imports (transitively) as island code, so the `$app/*`
+	* shim decision for each of those modules is DETERMINISTIC — before the bundler resolves a single
+	* one of them. A module shared between an island and a non-island route is otherwise marked lazily
+	* during the bundler's own walk: if its `$app/*` resolves before the island path reaches it, it
+	* keeps Kit's real client store — which under `csr = false` is never populated → `page.url`
+	* undefined, `page.data` empty → the island crashes or reads nothing at hydrate. Shimming it is
+	* right in both worlds: on a Kit-booted document the shim reads Kit's real page (the kit-page
+	* thread). (The `?og-region` module-id fork was tried and reverted — it broke Svelte's scoped-CSS
+	* emission; membership rides OUTSIDE the module id here, the walk only READS.)
+	*
+	* Follows relative, `$lib` AND the app's aliases (`kit.alias` / `resolve.alias` — a customer's
+	* `$lib_x/utils/boot` import was where the walk used to stop, and its `$app/state` went to whichever
+	* page loaded first). Bare package specifiers stop it; the lazy resolveId marking stays their
+	* backstop. Called at prescan for every island, and again in dev for an island registered by a
+	* later transform (a file added while the server runs). Returns the modules marked for the first
+	* time by this call, so a dev caller can drop their cached transforms.
+	*/
+	/** DEV: modules `mark_island_closure` marked for the first time AFTER prescan — an island a later
+	*  transform registered (a file added while the server runs). Each may already sit in the dev
+	*  server's module graph, transformed with Kit's real `$app/*` for a non-island importer; the
+	*  plugin drains this list and drops those cached transforms so the next load re-resolves them. */
+	#closure_added = [];
+	#mark_registered_closures(result) {
+		if (!this.#ctx.is_dev) return;
+		for (const isl of result.islands ?? []) if (isl.componentPath) this.#closure_added.push(...this.mark_island_closure(isl.componentPath));
+	}
+	/** DEV: take the modules newly marked as island code since the last drain (see above). */
+	drain_closure_marks() {
+		const out = this.#closure_added;
+		this.#closure_added = [];
+		return out;
+	}
+	mark_island_closure(componentAbs) {
+		const ctx = this.#ctx;
+		const { island_graph } = this.program;
+		const aliases = ctx.resolve_alias;
+		const added = [];
+		const resolve_dep = (spec, importerAbs) => {
+			const base = resolveFoucImportSpec(spec, importerAbs, ctx.libDir, aliases);
+			if (!base) return null;
+			for (const ext of ISLAND_DEP_EXTS) try {
+				if (fs.statSync(base + ext).isFile()) return base + ext;
+			} catch {}
+			for (const ext of ISLAND_DEP_EXTS.slice(1)) {
+				const idx = path.join(base, "index" + ext);
+				try {
+					if (fs.statSync(idx).isFile()) return idx;
+				} catch {}
+			}
+			return null;
+		};
+		const walk = (abs) => {
+			const norm = strip_id(abs);
+			if (this.#island_closure_seen.has(norm)) return;
+			this.#island_closure_seen.add(norm);
+			if (!island_graph.has(norm)) {
+				island_graph.add(norm);
+				added.push(norm);
+			}
+			if (!SOURCE_EXT_RE.test(norm)) return;
+			const src = ctx.read_file(norm);
+			if (src == null) return;
+			IMPORT_SPEC_G.lastIndex = 0;
+			let m;
+			while (m = IMPORT_SPEC_G.exec(src)) {
+				const spec = m[1] || m[2] || m[3];
+				if (!spec || spec[0] === "\0" || spec.startsWith("$app/") || spec.startsWith("$env/") || spec.startsWith("virtual:")) continue;
+				const dep = resolve_dep(spec, norm);
+				if (dep) walk(dep);
+			}
+		};
+		walk(componentAbs);
+		return added;
+	}
+	/**
+	* Scan ENTRIES for Vite's dep optimizer: every hydrate island's component file and the host file
+	* that places it — real, absolute, on-disk source paths. Under `csr = false` Kit ships no client
+	* entry and registers only `routes/**\/+*` as scan entries, so Vite's scanner reaches an island
+	* only when a route file imports it statically. An island behind a block registry, an
+	* `import.meta.og.regions()` glob or a `.remote.ts` mint is never crawled: its client deps are
+	* discovered LAZILY on its first wake, and every discovery re-optimizes, rotates the optimizer's
+	* browserHash and full-reloads — on a large app a reload storm that never settles. The adapter
+	* appends these to `optimizeDeps.entries` (dev) so Vite's OWN scanner crawls them at startup with
+	* the full plugin pipeline: its resolver, every plugin's `resolveId` (a `?client` import resolves
+	* through vite-plugin-iso-import), a linked workspace package followed as SOURCE and never
+	* pre-bundled, the app's `exclude` honoured.
+	*
+	* Deliberately NOT a self-computed `optimizeDeps.include` list. A resolver that is not Vite's
+	* mis-classifies something Vite knows — a plugin query, a workspace link, an `exports` map — and
+	* a wrong `include` hands rolldown an id it cannot load: `UNLOADABLE_DEPENDENCY`, a dead dev
+	* server (two field-reported regressions). An entry can only ever ADD a crawl root; what the
+	* crawl finds is Vite's call. A `defer` island renders on the server (its closure is not client
+	* code) and a lake ships no client JS, so neither is an entry; the host file covers a
+	* portable-snippet synth, which has no component file of its own. Needs `prescan()`; deduped,
+	* sorted, existing source files only.
+	*/
+	island_scan_entries() {
+		const { registry, region_kinds } = this.program;
+		const out = /* @__PURE__ */ new Set();
+		const add = (p) => {
+			if (!p) return;
+			const abs = strip_id(p);
+			if (!SOURCE_EXT_RE.test(abs)) return;
+			try {
+				if (fs.statSync(abs).isFile()) out.add(abs);
+			} catch {}
+		};
+		for (const entry of registry.values()) {
+			if (entry.role !== "entry" || entry.server) continue;
+			if (region_kinds.get(entry.id) !== "hydrate") continue;
+			add(entry.componentPath);
+			add(entry.hostPath);
+		}
+		return [...out].sort();
+	}
+	/** The feature-selected runtime chunk name (immutable-cached). Needs prescan to have run for a
+	*  non-empty feature hash; both build legs prescan the same source → the same name. */
+	runtime_chunk_filename() {
+		return this.#ctx.runtime_chunk_filename(this.program.runtime_feature_hash);
+	}
+	/** Public URL of the runtime chunk (asset prefix + filename — honors a non-root base / assets CDN). */
+	runtime_chunk_url() {
+		return this.#ctx.runtime_chunk_url(this.program.runtime_feature_hash);
+	}
+	/**
+	* Client-build chunk emit (via the injected `emitFile`): the feature-selected runtime entry (when
+	* `emitRuntime`), then one chunk per deduped HYDRATE region id. IDENTITY vs LOCATION: SSR bakes the
+	* stable name (`island_public_url`) as the region's identity; the file the browser loads is named
+	* by its content (the bundler hashes it), and the bundle end hands the stable → hashed map to the
+	* server (the handoff's `entries`). The stable name is emitted too, as a shim of the hashed file.
+	* csr=false hosts omit wrapper imports so this emit owns the module. Idempotent per id.
+	*/
+	#router_css_roots_cache = null;
+	/** The server-router component roots (link/router-css.ts). Build: prescan is complete before any
+	*  consumer runs — memoized. Dev: modules appear lazily (HMR), recompute per call. */
+	router_css_roots() {
+		const ctx = this.#ctx;
+		if (ctx.is_build && this.#router_css_roots_cache) return this.#router_css_roots_cache;
+		const sorted = [...new Set(router_css_roots(this.program.router_modules, this.program.module_specs, ctx.libDir))].sort();
+		if (ctx.is_build) this.#router_css_roots_cache = sorted;
+		return sorted;
+	}
+	/** Does the program hold ANY hydrate island? The runtime-emission gate needs this because
+	*  `hasAnyCsrFalseRoute` only inspects Kit PAGE leaves — an app whose islands live solely in
+	*  router-rendered components (a pure-router / fragment-only service has ZERO `+page` files)
+	*  answers "no csr=false page" while its documents still `<script src>` the runtime. */
+	/**
+	* Server-only islands — `render: 'deferred'` with no client chunk — and the component file each
+	* renders. Nothing on any page links such a component's CSS (Kit collects stylesheets from the
+	* client graph; this subtree is never in it), so the client leg compiles each one's whole tree
+	* CSS into a dedicated asset the hole response links (vite/index.ts, `region_css_links`).
+	* Sorted for determinism; a component shared by several ids is emitted once (by `abs`).
+	*/
+	server_island_css_roots() {
+		const out = [];
+		for (const [iid, vpath] of this.program.by_id) {
+			const entry = this.program.registry.get(vpath);
+			if (!entry?.server || !entry.componentPath) continue;
+			if (this.program.region_kinds.get(iid) === "hydrate") continue;
+			out.push({
+				iid,
+				abs: host_key(entry.componentPath)
+			});
+		}
+		return out.sort((a, b) => a.iid < b.iid ? -1 : a.iid > b.iid ? 1 : 0);
+	}
+	/** The public URL key a server island's CSS is handed off under (matches `island_url[id]`). */
+	island_public_url(iid) {
+		return this.#ctx.island_public_url(iid);
+	}
+	has_hydrate_regions() {
+		for (const kind of this.program.region_kinds.values()) if (kind === "hydrate") return true;
+		return false;
+	}
+	/** The server leg's real module graph, for the client-leg handoff (link/emit-gate.ts). */
+	ssr_transformed_hosts() {
+		return [...this.program.ssr_transformed].sort();
+	}
+	/**
+	* Client leg: the runtime chunk + one deterministic chunk per deduped hydrate region. `loaded` —
+	* the server leg's transformed-module set (the handoff the plugin reads) — gates the emit to
+	* islands whose HOST the server bundle actually contains; `null` (no handoff: standalone, or a
+	* client-only build) keeps every prescanned island, as before. Returns how many were skipped.
+	*/
+	emit_build_chunks(emitFile, { emitRuntime, loaded = null }) {
+		this.island_entry_refs.clear();
+		this.runtime_entry_ref = null;
+		if (emitRuntime) {
+			const feat = this.#ctx.runtime_features(this.program.runtime_feature_hash);
+			this.runtime_entry_ref = emitFile({
+				type: "chunk",
+				id: V_RUNTIME_ENTRY,
+				name: RUNTIME_ENTRY_NAME + (feat ? "-" + feat : "")
+			});
+		}
+		const { region_kinds, by_id, emitted_island_chunks, registry } = this.program;
+		let skipped = 0;
+		for (const [rid, kind] of region_kinds) {
+			if (kind !== "hydrate") continue;
+			const virtualPath = by_id.get(rid);
+			if (!virtualPath) continue;
+			if (emitted_island_chunks.has(rid)) continue;
+			if (!island_host_loaded(registry.get(virtualPath)?.hostPath, loaded)) {
+				skipped++;
+				continue;
+			}
+			this.emit_island_entry(emitFile, rid, virtualPath);
+		}
+		return skipped;
+	}
+	/** Client-build refs of each emitted island entry (by island id) and of the runtime entry: the
+	*  bundle end turns them into the hashed file names the handoff maps the stable names to. */
+	island_entry_refs = /* @__PURE__ */ new Map();
+	runtime_entry_ref = null;
+	/**
+	* At the bundle's end (the names are final): each entry's IDENTITY → its LOCATION. `islands` maps
+	* an island entry's hashed file to its identity (the collector keys every map by identity);
+	* `locations` is what the handoff carries to the server (`entries`): identity → served path.
+	* `get_file_name` is the bundler's `this.getFileName`.
+	*/
+	entry_locations(get_file_name) {
+		const islands = /* @__PURE__ */ new Map();
+		const locations = {};
+		const served = (file) => file.startsWith("/") ? file : "/" + file;
+		for (const [rid, ref] of this.island_entry_refs) {
+			const file = get_file_name(ref);
+			const identity = this.island_public_url(rid);
+			islands.set(file, identity);
+			locations[identity] = served(file);
+		}
+		let runtime = null;
+		let runtime_file = null;
+		if (this.runtime_entry_ref) {
+			runtime_file = get_file_name(this.runtime_entry_ref);
+			runtime = this.runtime_chunk_url();
+			locations[runtime] = served(runtime_file);
+		}
+		return {
+			islands,
+			runtime,
+			runtime_file,
+			locations
+		};
+	}
+	/** One hydrate island's entry, content-hashed by the bundler (its stable-name shim is written at
+	*  the bundle's end: `entry_shims`). */
+	emit_island_entry(emitFile, rid, virtualPath) {
+		this.program.emitted_island_chunks.add(rid);
+		this.island_entry_refs.set(rid, emitFile({
+			type: "chunk",
+			id: virtualPath,
+			name: ISLAND_ENTRY_NAME_PREFIX + rid
+		}));
+	}
+	/**
+	* The output file pattern for one of OUR entries (by the chunk name `emit_island_entry` / the
+	* runtime emit gave it), else null (the app's own naming applies). Readable and content-hashed:
+	* `<appDir>/immutable/og-region.<iid>.<hash>.js`, `…/og-runtime-<features>.<hash>.js` — the hash is the
+	* cache law, the name is for people (a network tab, a CDN rule, a profile). It never equals a
+	* stable name, which has no hash segment.
+	*/
+	entry_file_pattern(chunk_name) {
+		if (!chunk_name) return null;
+		if (!(chunk_name.startsWith(ISLAND_ENTRY_NAME_PREFIX) || chunk_name === RUNTIME_ENTRY_NAME || chunk_name.startsWith("og-runtime-"))) return null;
+		return `${this.#ctx.app_dir}/immutable/[name].[hash].js`;
+	}
+	/**
+	* The stable-name shims (link/entry-shim.ts), for the bundle's end (the names are final): one per
+	* island entry, plus the runtime's — each a plain file at the old stable name re-exporting the
+	* hashed file. `get_file_name` is the bundler's `this.getFileName`.
+	*/
+	entry_shims(get_file_name) {
+		const ctx = this.#ctx;
+		const out = [];
+		for (const [rid, ref] of this.island_entry_refs) {
+			const fileName = ctx.island_chunk_filename(rid);
+			out.push({
+				fileName,
+				source: island_shim_source(fileName, get_file_name(ref))
+			});
+		}
+		if (this.runtime_entry_ref) {
+			const fileName = this.runtime_chunk_filename();
+			out.push({
+				fileName,
+				source: runtime_shim_source(fileName, get_file_name(this.runtime_entry_ref))
+			});
+		}
+		return out;
+	}
+	/**
+	* Emit one ogygia VIRTUAL module's source: the config/capability virtuals (secret / sign / rate-limit
+	* / router / session / ttl / manifests / runtime entry+url / transport / dev-hmr / request-event /
+	* region-endpoint), and the registered island/region sources (with the client leg's `$app/*`-shim +
+	* lake-placeholder rewrites). Returns the source string, or `null` if `id` is not an ogygia virtual —
+	* the adapter owns only the FOUC-css virtuals (they carry a Vite `moduleType`) and the Vite build
+	* value threaded in here (the `universalHooks` path).
+	*/
+	emit(id, { ssr, universalHooks, resolve, kitCodec = null }) {
+		const ctx = this.#ctx;
+		const program = this.program;
+		const is_dev = ctx.is_dev;
+		if (is_registry_stub_id(id)) return registry_stub_source(registry_stub_names(id));
+		const registry_client = registry_client_path(id);
+		if (registry_client) return this.#registry_client_emit(registry_client);
+		if (id === RESOLVED("virtual:ogygia/runtime-url")) {
+			if (!is_dev) this.prescan();
+			const url = is_dev ? "/@id/__x00__" + V_RUNTIME : this.runtime_chunk_url();
+			return `export default ${JSON.stringify(url)};`;
+		}
+		if (id === RESOLVED("virtual:ogygia/fn-manifest")) {
+			const regs = () => [...this.dollar_hoists.entries()].map(([tag, src]) => `globalThis.__og_reg_fn(${JSON.stringify(tag)}, (${src}));`).join("\n");
+			const bridge = `import { __register_fn } from 'ogygia/internal';\nglobalThis.__og_reg_fn = __register_fn;\n`;
+			if (is_dev) return bridge + regs();
+			return bridge + `/*__OGYGIA_FN_MANIFEST__*/`;
+		}
+		if (id === RESOLVED("virtual:ogygia/runtime-entry")) {
+			this.prescan();
+			const { code } = generateRuntimeEntrySource(program.runtime_marks, ctx.runtime_dir, ctx.client_plugins);
+			const ch = client_hooks_boot(ctx);
+			return ch.imports + code + ch.call;
+		}
+		if (id === RESOLVED("virtual:ogygia/hydrate-features")) {
+			if (!ctx.is_build) {
+				const rt = dev_runtime_of(ctx.runtime_dir);
+				const code = generateHydrateFeaturesSource({}, rt?.dir ?? ctx.runtime_dir, true).code;
+				return rt?.ts ? code.split(".js\";").join(".ts\";") : code;
+			}
+			this.prescan();
+			return `import ${JSON.stringify(V_FN_MANIFEST)};\n` + generateHydrateFeaturesSource(program.runtime_marks, ctx.runtime_dir).code;
+		}
+		if (id === RESOLVED("virtual:ogygia-runtime")) {
+			const ch = client_hooks_boot(ctx);
+			const cp = client_plugins_boot(ctx);
+			return `import { bootDev } from 'ogygia/runtime';\n${ch.imports}${cp.imports}bootDev(${cp.list});\n${ch.call}`;
+		}
+		if (id === RESOLVED("virtual:ogygia/dev-hmr")) {
+			if (!is_dev) return `export {}`;
+			return dev_hmr_client_source();
+		}
+		if (id === RESOLVED("virtual:ogygia/dev-hmr-url")) {
+			if (!is_dev) return `export default '';`;
+			return `export default ${JSON.stringify("/@id/__x00__" + V_DEV_HMR)};`;
+		}
+		if (id === RESOLVED("virtual:ogygia/devtools-boot")) {
+			if (!ctx.client_plugins.length) return `export {}`;
+			const cp = client_plugins_boot(ctx);
+			return (is_dev ? `import '/@vite/env';\n` : "") + cp.imports + `import { boot_client_plugins } from ${JSON.stringify(`${ctx.runtime_dir}/client-plugins.js`.replace(BACKSLASH_G, "/"))};\nimport { beacon_watch } from ${JSON.stringify(`${ctx.runtime_dir}/beacon.js`.replace(BACKSLASH_G, "/"))};\nbeacon_watch();\nboot_client_plugins(${cp.list}, true);\n`;
+		}
+		if (id === RESOLVED("virtual:ogygia/devtools-meta")) {
+			if (is_dev) return `export const names = {};`;
+			this.prescan();
+			return `export const names = ${JSON.stringify(this.region_names())};`;
+		}
+		if (id === RESOLVED("virtual:ogygia/devtools-boot-url")) {
+			if (!ctx.client_plugins.length || !is_dev) return `export default '';`;
+			return `export default ${JSON.stringify("/@id/__x00__" + V_DEVTOOLS_BOOT)};`;
+		}
+		if (id === RESOLVED("virtual:ogygia/island-deps")) return island_deps_module(ssr, is_dev, path.relative(ctx.root, kit_dirs(ctx.root).out_dir));
+		if (id === RESOLVED("virtual:ogygia/transport")) return transport_module(universalHooks, ssr ? null : kitCodec);
+		if (id === RESOLVED("virtual:ogygia/kit-transport")) {
+			const crosses = this.program.runtime_marks.wire === true || this.program.crosses_wire;
+			const transport_spec = `${ctx.runtime_dir}/../transport.js`.replace(BACKSLASH_G, "/");
+			return kit_transport_module(crosses, transport_spec);
+		}
+		if (id === RESOLVED("virtual:ogygia/router-css")) return router_css_module(this.router_css_roots(), {
+			root: ctx.root,
+			lib_dir: ctx.libDir,
+			is_dev,
+			read_file: (p) => ctx.read_file(p),
+			resolve
+		});
+		if (id === RESOLVED("virtual:ogygia/secret")) return secret_module(ssr, ctx.build_secret, ctx.id_salt !== "");
+		if (id === RESOLVED("virtual:ogygia/sign")) return sign_module(ssr, ctx.hmac_module);
+		if (id === RESOLVED("virtual:ogygia/request-event")) {
+			if (!ssr) return `export function getRequestEvent() { throw new Error('[ogygia] getRequestEvent is server-only'); }`;
+			return `export { getRequestEvent } from '$app/server';`;
+		}
+		if (id === RESOLVED("virtual:ogygia/region-endpoint")) {
+			if (!ssr) return "export function makeRegionEndpoint(_entry, _props) { return ''; }\nexport function mintServerIsland(_entry, _props, _ttl) { return ''; }\nexport function known_region_fps() { return new Set(); }\nexport function islandFingerprint(_entry, _canonical) { return ''; }\nexport function holeCss(_entry) { return []; }";
+			return `export { makeRegionEndpoint, mintServerIsland, known_region_fps, islandFingerprint, holeCss } from ${JSON.stringify(ctx.region_endpoint_module)};`;
+		}
+		if (id === RESOLVED("virtual:ogygia/rate-limit")) return rate_limit_module(ssr, ctx.rate_limit);
+		if (id === RESOLVED("virtual:ogygia/server-plugins")) return server_plugins_module(ssr, ctx.server_plugins);
+		if (id === RESOLVED("virtual:ogygia/profiler-maps")) return ssr && ctx.is_build && ctx.measure ? `export default ${JSON.stringify(PROFILER_MAPS_PLACEHOLDER)};` : "export default null;";
+		if (id === RESOLVED("virtual:ogygia/router-config")) return router_config_module(ctx.router_enabled, ctx.router_view_transitions);
+		if (id === RESOLVED("virtual:ogygia/session-cookie")) return session_cookie_module(ssr, ctx.session_cookie);
+		if (id === RESOLVED("virtual:ogygia/region-ttl")) return region_ttl_module(ssr, ctx.region_ttl, ctx.renew_window);
+		if (id === RESOLVED("virtual:ogygia/route-csr")) return route_csr_module(ssr, kit_dirs(ctx.root).routes_dir);
+		if (id === RESOLVED("virtual:ogygia/route-config")) return route_config_module(ssr, kit_dirs(ctx.root).routes_dir, ctx.route_config);
+		if (id === RESOLVED("virtual:ogygia/server-manifest")) {
+			if (ssr) this.prescan();
+			if (ssr && is_dev) this.#emitted_server_ids = new Set(server_island_ids(program));
+			return server_manifest_module(ssr, program, is_dev, (vp) => ctx.dev_url_for(vp), (iid) => ctx.island_public_url(iid));
+		}
+		if (id === RESOLVED("virtual:ogygia/server-islands")) {
+			if (ssr) this.prescan();
+			return server_islands_module(ssr, program);
+		}
+		if (id === RESOLVED("virtual:ogygia/manifest")) return manifest_module(is_dev);
+		if (id === RESOLVED("virtual:ogygia/transportables-eager")) {
+			if (!ssr) return "export {};\n";
+			this.prescan();
+			return transportables_module(program.transportable_modules, true, (abs) => abs);
+		}
+		if (id === RESOLVED("virtual:ogygia/transportables")) {
+			this.prescan();
+			return transportables_module(program.transportable_modules, !!ssr, (abs) => path.relative(ctx.root, abs).split(path.sep).join("/"), program.crosses_wire);
+		}
+		const srcEntry = program.registry.get(id);
+		if (srcEntry && srcEntry.role === "region") return ssr ? srcEntry.ssrSource : srcEntry.clientSource;
+		if (srcEntry) {
+			let src = !ssr && srcEntry.clientSource ? srcEntry.clientSource : srcEntry.source;
+			const foreign = src.indexOf(FOREIGN_HYDRATE_MARK);
+			if (foreign !== -1 && (ssr || !ctx.foreign_hydrate)) src = src.slice(0, foreign);
+			if (!ssr) {
+				src = src.replace(APP_SHIM_IMPORT, (_m, _q, name) => JSON.stringify(ctx.app_shims["$app/" + name]));
+				for (const local of srcEntry.lakes ?? []) src = rewrite_lake_import_to_placeholder(src, local, ctx.client_binding_stub_file);
+			}
+			return src;
+		}
+		return null;
+	}
+	/**
+	* Resolve an ogygia-owned import id: the virtual-module vocabulary (config/manifest virtuals + FOUC
+	* graph + client-binding stub), and the island CLIENT graph — `$app/*` shims for island importers,
+	* virtual island/wrapper ids, and relative imports of a generated island module resolved against its
+	* host (marking each resolved dep into `island_graph` so its own `$app/*` stays shimmed). `resolve` is
+	* the bundler's own resolver (Vite `this.resolve`), threaded in so the driver stays bundler-agnostic.
+	* Returns a resolved id / result, or `null` to defer to the bundler. The adapter handles the few
+	* package/Kit-specific ids first (ogygia injected imports, Kit's remote runtime, the kit-wire path).
+	*/
+	async resolve_id(source, importer, { ssr, resolve }) {
+		const ctx = this.#ctx;
+		const { registry, island_graph } = this.program;
+		if (source === "virtual:ogygia/fn-manifest") return RESOLVED(V_FN_MANIFEST);
+		if (source === "virtual:ogygia/runtime-url") return RESOLVED(V_RUNTIME_URL);
+		if (source === "virtual:ogygia/manifest") return RESOLVED(V_MANIFEST);
+		if (source === "virtual:ogygia-runtime") return RESOLVED(V_RUNTIME);
+		if (source === "virtual:ogygia/runtime-entry") return RESOLVED(V_RUNTIME_ENTRY);
+		if (source === "virtual:ogygia/hydrate-features") return RESOLVED(V_HYDRATE_FEATURES);
+		if (source === "virtual:ogygia/dev-hmr") return RESOLVED(V_DEV_HMR);
+		if (source === "virtual:ogygia/dev-hmr-url") return RESOLVED(V_DEV_HMR_URL);
+		if (source === "virtual:ogygia/devtools-boot") return RESOLVED(V_DEVTOOLS_BOOT);
+		if (source === "virtual:ogygia/devtools-boot-url") return RESOLVED(V_DEVTOOLS_BOOT_URL);
+		if (source === "virtual:ogygia/devtools-meta") return RESOLVED(V_DEVTOOLS_META);
+		if (source === "virtual:ogygia/island-deps") return RESOLVED(V_ISLAND_DEPS);
+		if (source === "virtual:ogygia/kit-transport") return RESOLVED(V_KIT_TRANSPORT);
+		if (source === "virtual:ogygia/router-css") return RESOLVED(V_ROUTER_CSS);
+		if (source === "virtual:ogygia/secret") return RESOLVED(V_SECRET);
+		if (source === "virtual:ogygia/sign") return RESOLVED(V_SIGN);
+		if (source === "virtual:ogygia/rate-limit") return RESOLVED(V_RATE_LIMIT);
+		if (source === "virtual:ogygia/server-plugins") return RESOLVED(V_SERVER_PLUGINS);
+		if (source === "virtual:ogygia/profiler-maps") return RESOLVED(V_PROFILER_MAPS);
+		if (source === "virtual:ogygia/router-config") return RESOLVED(V_ROUTER_CONFIG);
+		if (source === "virtual:ogygia/session-cookie") return RESOLVED(V_SESSION_COOKIE);
+		if (source === "virtual:ogygia/region-ttl") return RESOLVED(V_REGION_TTL);
+		if (source === "virtual:ogygia/route-csr") return RESOLVED(V_ROUTE_CSR);
+		if (source === "virtual:ogygia/route-config") return RESOLVED(V_ROUTE_CONFIG);
+		if (source === "virtual:ogygia/server-manifest") return RESOLVED(V_SERVER_MANIFEST);
+		if (source === "virtual:ogygia/server-islands") return RESOLVED(V_SERVER_ISLANDS);
+		if (source === "virtual:ogygia/request-event") return RESOLVED(V_REQUEST_EVENT);
+		if (source === "virtual:ogygia/region-endpoint") return RESOLVED(V_REGION_ENDPOINT);
+		if (source === "virtual:ogygia/client-binding-stub") return ctx.client_binding_stub_file;
+		if (source.startsWith("virtual:ogygia/fouc-css/") || source.startsWith("virtual:ogygia/fouc-scoped/")) return RESOLVED(source);
+		if (source === "virtual:ogygia/transport") return RESOLVED(V_TRANSPORT);
+		if (source === "virtual:ogygia/transportables") return RESOLVED(V_TRANSPORTABLES);
+		if (source === "virtual:ogygia/transportables-eager") return RESOLVED(V_TRANSPORTABLES_EAGER);
+		if (is_registry_stub_id(source)) return RESOLVED(source);
+		const registry_stub = await this.#registry_stub_for(source, importer, {
+			ssr,
+			resolve
+		});
+		if (registry_stub) return registry_stub;
+		const importer_id = importer ? strip_id(importer) : void 0;
+		const from_island = importer_id && (registry.has(importer_id) || island_graph.has(importer_id));
+		if (!ssr && from_island) {
+			const shim = app_shim_for(source, ctx.app_shims);
+			if (shim) return shim;
+		}
+		if (is_island_path(source)) {
+			let candidate = source.split("?")[0];
+			if (candidate.startsWith("/@id/")) candidate = candidate.slice(5);
+			if (candidate.startsWith("/@fs/")) candidate = candidate.slice(4);
+			if (registry.has(candidate)) {
+				island_graph.add(candidate);
+				return candidate;
+			}
+			const abs = path.isAbsolute(candidate) ? candidate : path.join(ctx.root, candidate.replace(LEADING_SLASH, ""));
+			if (registry.has(abs)) {
+				island_graph.add(abs);
+				return abs;
+			}
+		}
+		if (importer_id && registry.has(importer_id) && !is_island_path(source)) {
+			const host = registry.get(importer_id).hostPath ?? "";
+			const resolved = await resolve(source, host, { skipSelf: true });
+			if (resolved?.id) island_graph.add(strip_id(resolved.id));
+			if (!resolved && !source.startsWith(".") && !source.startsWith("\0") && !source.startsWith("virtual:") && !path.isAbsolute(source)) throw new Error(`[ogygia] cannot resolve '${source}' imported by the generated island module for ${path.relative(ctx.root, host)}. That island was marked on a package import, so the specifier must resolve from the host file: check the package is installed and its "exports" map exposes this subpath (with a "svelte" condition for .svelte components).`);
+			return resolved;
+		}
+		if (!ssr && importer_id && island_graph.has(importer_id) && !is_island_path(source)) {
+			const resolved = await resolve(source, importer, { skipSelf: true });
+			if (resolved?.id) island_graph.add(strip_id(resolved.id));
+			return resolved;
+		}
+		return null;
+	}
+	/**
+	* The client-leg registry decision for one import edge (see link/registry-stub.ts). Fires only on
+	* the client leg of a build, for an importer that is either a csr=false ROUTE host (`+page`/
+	* `+layout` `.svelte`/`.ts`/`.js` — the page node's own files, whose client JS never runs) or a
+	* module already in that variant world (its id carries the variant query), and only when the
+	* resolved target is a local `.ts`/`.js` module that IS a region registry or REACHES one through
+	* static script imports. The variant world is contagious along script edges only: a registry
+	* behind a plain helper (`+page.svelte` → `$lib/factory.ts` → `registry.ts`) gets the same
+	* treatment as a direct import, while modules that reach no registry stay shared (no copies).
+	* `.svelte` edges never fork (forking a component's id breaks its scoped CSS). Returns the
+	* variant id, or `null` to let resolution continue.
+	*/
+	async #registry_stub_for(source, importer, { ssr, resolve }) {
+		const ctx = this.#ctx;
+		if (ssr || ctx.is_dev || !ctx.is_build || !importer) return null;
+		if (source.startsWith("\0") || source.startsWith("virtual:") || source.startsWith("$app/")) return null;
+		if (registry_client_path(importer) == null && !this.#is_csr_false_route_host(importer)) return null;
+		const target = await this.#resolve_local_script(source, importer, resolve);
+		if (!target) return null;
+		this.prescan();
+		if (!await this.#reaches_registry(target, resolve)) return null;
+		return registry_client_id(target);
+	}
+	/** True for a csr=false route host file (`+page`/`+layout` `.svelte`/`.ts`/`.js`). A `+page.ts`
+	*  shares its route's world with the sibling `.svelte` host. */
+	#is_csr_false_route_host(importer) {
+		const importer_abs = strip_id(importer);
+		const routes_dir = kit_dirs(this.#ctx.root).routes_dir;
+		if (!importer_abs.startsWith(routes_dir + path.sep)) return false;
+		const m = ROUTE_HOST_FILE_RE.exec(path.basename(importer_abs));
+		if (!m) return false;
+		return routeCsrIsFalse(path.join(importer_abs, "..", `+${m[1]}.svelte`), routes_dir);
+	}
+	/** `source` resolved from `importer` to a local `.ts`/`.js` file on disk, or `null` (virtuals,
+	*  components, assets, unresolvable). Package files count only when the prescan registered them
+	*  as region hosts (an `ogygia.files` package registry) — package internals are never walked. */
+	async #resolve_local_script(source, importer, resolve) {
+		const memo_key = strip_id(importer) + "\n" + source;
+		const memo = this.#resolve_memo.get(memo_key);
+		if (memo !== void 0) return memo;
+		const target = await this.#resolve_local_script_uncached(source, importer, resolve);
+		this.#resolve_memo.set(memo_key, target);
+		return target;
+	}
+	#resolve_memo = /* @__PURE__ */ new Map();
+	async #resolve_local_script_uncached(source, importer, resolve) {
+		let resolved = null;
+		try {
+			resolved = await resolve(source, importer, { skipSelf: true });
+		} catch {
+			return null;
+		}
+		if (!resolved?.id || resolved.id.startsWith("\0")) return null;
+		const target = strip_id(resolved.id);
+		if (!TS_REGISTRY_EXT_RE.test(target) || !fs.existsSync(target)) return null;
+		const posix = target.split(path.sep).join("/");
+		if (SERVER_MODULE_EXT_RE.test(posix) || SERVER_DIR_RE.test(posix)) return null;
+		if (SVELTE_RUNE_MODULE_RE.test(posix)) return null;
+		return target;
+	}
+	/**
+	* Whether `file` is a region registry or reaches one through static script imports (`.svelte`
+	* and package-internal edges are not walked). Every module is read, parsed and walked AT MOST
+	* ONCE per build: a shared helper reached from thousands of import edges answers from the memo.
+	*
+	* Cycles are why that needs care. A NEGATIVE computed while the walk was inside a cycle may
+	* depend on a file still open above it (that file can still turn out to reach a registry), so it
+	* is not final yet. Tarjan's strongly-connected-components bookkeeping decides exactly when it
+	* is: each open file gets its depth on the walk, every step reports the shallowest open file its
+	* subtree looped back to (`low`), and when a file finishes with `low >= depth` nothing below it
+	* depends on anything above it — the file and every file still parked on the component stack
+	* above it form one finished component, all with the same answer. A positive is always final.
+	* (Keeping only top-level negatives instead, as this did first, re-walked every shared module
+	* once per path to it — a large app's build never finished.)
+	*/
+	async #reaches_registry(file, resolve) {
+		return (await this.#reach(file, resolve, /* @__PURE__ */ new Map(), [])).reaches;
+	}
+	#reach_memo = /* @__PURE__ */ new Map();
+	#specs_memo = /* @__PURE__ */ new Map();
+	async #reach(file, resolve, open, component) {
+		const key = host_key(file);
+		const memo = this.#reach_memo.get(key);
+		if (memo !== void 0) return {
+			reaches: memo,
+			low: Infinity
+		};
+		if (this.program.host_index.has(key)) {
+			this.#reach_memo.set(key, true);
+			return {
+				reaches: true,
+				low: Infinity
+			};
+		}
+		const open_depth = open.get(key);
+		if (open_depth !== void 0) return {
+			reaches: false,
+			low: open_depth
+		};
+		if (file.includes("/node_modules/")) return {
+			reaches: false,
+			low: Infinity
+		};
+		const depth = open.size;
+		open.set(key, depth);
+		const parked = component.length;
+		component.push(key);
+		let reaches = false;
+		let low = Infinity;
+		for (const spec of this.#script_specs(key, file)) {
+			const target = await this.#resolve_local_script(spec, file, resolve);
+			if (!target) continue;
+			const step = await this.#reach(target, resolve, open, component);
+			if (step.low < low) low = step.low;
+			if (step.reaches) {
+				reaches = true;
+				break;
+			}
+		}
+		open.delete(key);
+		if (reaches) {
+			this.#reach_memo.set(key, true);
+			component.length = parked + 1;
+			component.pop();
+			return {
+				reaches: true,
+				low: Infinity
+			};
+		}
+		if (low >= depth) {
+			for (let i = parked; i < component.length; i++) this.#reach_memo.set(component[i], false);
+			component.length = parked;
+			return {
+				reaches: false,
+				low: Infinity
+			};
+		}
+		return {
+			reaches: false,
+			low
+		};
+	}
+	/** A module's static script specifiers, read and parsed once per build. */
+	#script_specs(key, file) {
+		let specs = this.#specs_memo.get(key);
+		if (specs === void 0) {
+			const src = this.#ctx.read_file(file);
+			specs = src == null ? [] : static_script_specs(src, file) ?? [];
+			this.#specs_memo.set(key, specs);
+		}
+		return specs;
+	}
+	/** The client-leg registry source (link/registry-stub.ts): marks blanked, plain imports kept. A
+	*  registry that does not parse falls back to the names-only stub. */
+	#registry_client_emit(file) {
+		const ctx = this.#ctx;
+		const src = ctx.read_file(file);
+		if (src == null) return null;
+		const keys = ctx.import_keys;
+		const region_keys = /* @__PURE__ */ new Set([
+			keys.wake,
+			keys.render,
+			keys.preset,
+			keys.region
+		]);
+		return registry_client_source(src, file, region_keys) ?? registry_stub_source([...export_names(src)]);
+	}
+	/**
+	* The per-file transform pass: content-preset tagging ▸ `import.meta.og.*` macros ▸ the host-island
+	* transform (`.svelte`) ▸ ts/js region minting (`.ts/.js`) ▸ the client `$app/*` shim. Registers the
+	* discovered descriptors into the `Program`, and (client build only) emits the deterministic chunk for
+	* any hydrate island a library component declares that the prescan couldn't see — via the `emitFile`
+	* callback (the one Vite primitive threaded in). Returns the Vite transform result, or `null` if the
+	* module was untouched. `prescan()` runs first so `island_graph` is complete before any module lowers.
+	*/
+	async transform_module(code, id, { ssr, emitFile }) {
+		const ctx = this.#ctx;
+		const program = this.program;
+		const { registry, island_graph, emitted_island_chunks } = program;
+		const root = ctx.root;
+		code = strip_bom(code);
+		this.prescan();
+		if (registry_client_path(id) != null) return null;
+		const id_n = strip_id(id);
+		if (ssr && ctx.is_build) program.ssr_transformed.add(host_key(id_n));
+		if (ctx.is_build && mentions_page_store(code)) {
+			const clean = id.split("?")[0].split("\\").join("/");
+			const kind = clean.endsWith(".svelte") ? "svelte" : SCRIPT_MODULE_RE.test(clean) ? "script" : null;
+			if (kind) {
+				const { keys, reason, pending } = page_data_keys_answer(code, clean, kind);
+				if (keys !== null) program.page_keys.set(clean, keys);
+				if (reason) program.page_key_reasons.set(clean, reason);
+				if (pending.length) program.page_pending.set(clean, pending);
+				else program.page_pending.delete(clean);
+			}
+		}
+		let out = code;
+		let map = null;
+		let touched = false;
+		const macroed = await this.macros(out, id_n);
+		if (macroed.touched) {
+			out = macroed.code;
+			map = null;
+			touched = true;
+		}
+		const in_node_modules = id_n.includes("/node_modules/");
+		const bare_v = id_n.startsWith("/@id/") ? id_n.slice(5) : id_n;
+		const portable_entry = id_n.endsWith(".svelte") && is_island_path(bare_v) && registry.get(bare_v)?.portable === true;
+		if (id_n.endsWith(".svelte") && is_script_request(id) && (!is_island_path(bare_v) || portable_entry) && (!in_node_modules || ctx.in_declared_pkg(bare_v) || ctx.has_island_hint(code))) {
+			const result = this.transform(out, id_n, { ssr });
+			if (result) {
+				program.register(result, id_n);
+				this.#mark_registered_closures(result);
+				out = result.code;
+				map = result.map;
+				touched = true;
+				if (ctx.is_build && !ssr) for (const isl of result.islands ?? []) {
+					if ((isl.kind ?? (isl.server ? "defer" : "hydrate")) !== "hydrate" || !isl.virtualPath || emitted_island_chunks.has(isl.id)) continue;
+					this.emit_island_entry(emitFile, isl.id, isl.virtualPath);
+				}
+			}
+			if (!id_n.startsWith(ctx.pkg_root)) {
+				const withReg = appendSvelteModuleRegistrations(out, id_n, root, path);
+				if (withReg !== null) {
+					out = withReg;
+					map = null;
+					touched = true;
+				}
+			}
+		}
+		const nm_ts = id_n.endsWith(".ts") || id_n.endsWith(".js") || id_n.endsWith(".mjs") ? id_n.includes("/node_modules/") : null;
+		if (nm_ts === true && !id_n.startsWith(ctx.pkg_root) && !ctx.in_declared_pkg(id_n) && ctx.has_island_hint(out)) warn_undeclared_pkg_marks(id_n);
+		if (nm_ts !== null && (nm_ts === false || ctx.in_declared_pkg(id_n)) && !is_island_path(id_n)) {
+			const result = this.ts_regions(out, id_n);
+			if (result) {
+				program.register(result, id_n);
+				this.#mark_registered_closures(result);
+				out = result.code;
+				map = result.map;
+				touched = true;
+			}
+			if (!id_n.startsWith(ctx.pkg_root)) {
+				const registered = appendTransportRegistrations(out, id_n, root, path);
+				if (registered !== null) {
+					out = registered;
+					touched = true;
+				}
+			}
+		}
+		if (!ssr && island_graph.has(id_n) && (id_n.endsWith(".svelte") || SCRIPT_MODULE_RE.test(id_n))) {
+			const rewritten = out.replace(APP_SHIM_IMPORT, (_m, _q, name) => JSON.stringify(ctx.app_shims["$app/" + name]));
+			if (rewritten !== out) {
+				out = rewritten;
+				map = null;
+				touched = true;
+			}
+		}
+		if (ssr && !id.includes("?") && id_n.endsWith(".svelte") && !is_island_path(bare_v) && (!in_node_modules || ctx.in_declared_pkg(id_n))) {
+			const stamped = stamp_opaque(out, id_n);
+			if (stamped !== null) {
+				out = stamped;
+				map = null;
+				touched = true;
+			}
+		}
+		return touched ? {
+			code: out,
+			map
+		} : null;
+	}
+	/**
+	* Patch the fn-manifest placeholder in a finished chunk with the collected `og.$` factory
+	* registrations — every transform has run by renderChunk, so `dollar_hoists` is complete. Registrations
+	* go through the globalThis bridge the placeholder module installed (rename-proof under minification).
+	* Returns the patched chunk, or `null` if this chunk carries no placeholder.
+	*/
+	patch_fn_manifest(code) {
+		if (!code.includes("/*__OGYGIA_FN_MANIFEST__*/")) return null;
+		const regs = [...this.dollar_hoists.entries()].map(([tag, src]) => `globalThis.__og_reg_fn(${JSON.stringify(tag)}, (${src}));`).join("\n");
+		return {
+			code: code.replace("/*__OGYGIA_FN_MANIFEST__*/", () => regs),
+			map: null
+		};
+	}
+	/**
+	* Patch the server manifest's page-data placeholder: per server island (a hole), does its SERVER
+	* tree — the component and everything it imports, statically or dynamically (a registry's blocks)
+	* — read `page.data`? The transform recorded each module's reads (`page_keys`, seed shaping); by
+	* renderChunk the graph is complete. A hole that never reads it never pays the page lookup
+	* (server/render-page.ts). One walk per hole, sharing what earlier walks proved: a walk that ends
+	* with no reader proves every module it visited reads nothing. `graph` is the bundler's module info.
+	*/
+	patch_page_data_reads(code, graph, module_ids) {
+		const at = code.indexOf(PAGE_DATA_READS_TOKEN);
+		if (at === -1) return null;
+		const { page_keys, page_pending, by_id, registry } = this.program;
+		const clean = (id) => id.split("?")[0].split("\\").join("/");
+		const reads_itself = (id) => {
+			const c = clean(id);
+			const k = page_keys.get(c);
+			return k !== void 0 && (k === "all" || k.size > 0) || page_pending.has(c);
+		};
+		const ids_by_path = /* @__PURE__ */ new Map();
+		for (const id of module_ids()) if (!id.startsWith("\0")) ids_by_path.set(clean(id), id);
+		const proven_clean = /* @__PURE__ */ new Set();
+		const reads = (root) => {
+			const seen = /* @__PURE__ */ new Set([root]);
+			const queue = [root];
+			for (let i = 0; i < queue.length; i++) {
+				const id = queue[i];
+				if (proven_clean.has(id)) continue;
+				if (reads_itself(id)) return true;
+				const info = graph(id);
+				if (!info) continue;
+				for (const next of info.importedIds) if (!seen.has(next)) {
+					seen.add(next);
+					queue.push(next);
+				}
+				for (const next of info.dynamicallyImportedIds) if (!seen.has(next)) {
+					seen.add(next);
+					queue.push(next);
+				}
+			}
+			for (const id of seen) proven_clean.add(id);
+			return false;
+		};
+		const out = {};
+		for (const [iid, virtual_path] of by_id) {
+			const reg = registry.get(virtual_path);
+			if (!reg?.server) continue;
+			const root = reg.componentPath ? ids_by_path.get(clean(reg.componentPath)) : void 0;
+			out[iid] = root === void 0 ? true : reads(root);
+		}
+		const json = JSON.stringify(out);
+		const literal = code[at - 1] === "\"" ? json.split("\"").join("\\\"") : json;
+		return {
+			code: code.slice(0, at) + literal + code.slice(at + PAGE_DATA_READS_TOKEN.length),
+			map: null
+		};
+	}
+	/** True when `file` is a registered island HOST (a component that declares islands). */
+	is_registered_host(file) {
+		const { host_index, registry } = this.program;
+		return host_index.has(host_key(file)) || [...registry.values()].some((e) => same_module_path(e.hostPath, file));
+	}
+	/**
+	* Drop the cached virtual island modules + the registry rows for `file` — call when a HOST changes
+	* (an import-target rename keeps the same island id) or an ENTRY component is deleted (NOT on ordinary
+	* entry-component content edits — those are soft HMR). Mutates the Program; `invalidate` is the
+	* bundler's module-invalidation (Vite's moduleGraph), threaded in. Returns whether anything changed.
+	*/
+	invalidate_for_file(file, { deleted = false, invalidate }) {
+		const { registry, island_graph, by_id, region_kinds, host_index } = this.program;
+		const affected = /* @__PURE__ */ new Set();
+		if (this.is_registered_host(file)) {
+			for (const vpath of island_vpaths_affected_by_file(file, registry.entries())) affected.add(vpath);
+			const prev = host_index.get(host_key(file));
+			if (prev) for (const vpath of prev.vpaths) affected.add(vpath);
+			this.program.unregister_host(file);
+		}
+		if (deleted) for (const [vpath, entry] of Array.from(registry.entries())) {
+			if (!same_module_path(entry.componentPath, file)) continue;
+			affected.add(vpath);
+			registry.delete(vpath);
+			island_graph.delete(vpath);
+			by_id.delete(entry.id);
+			region_kinds.delete(entry.id);
+			const idx = host_index.get(host_key(entry.hostPath ?? ""));
+			if (idx) {
+				idx.vpaths.delete(vpath);
+				idx.ids.delete(entry.id);
+			}
+		}
+		if (affected.size === 0) return false;
+		for (const vpath of affected) invalidate(vpath);
+		invalidate(RESOLVED(V_SERVER_MANIFEST));
+		invalidate(RESOLVED(V_SERVER_ISLANDS));
+		invalidate(RESOLVED(V_MANIFEST));
+		return true;
+	}
+};
+export { Compiler, app_shim_for };