@ogygia/core 0.0.0 → 0.11.0

package/dist/vite/index.js

@@ -0,0 +1,820 @@
+import { configure_build_cache } from "../build-cache.js";
+import { contentCssKey as content_css_key } from "../plugin/utils.js";
+import { island_sourcemaps_plugin } from "./sourcemaps.js";
+import { server_sourcemaps_plugin } from "./server-sourcemaps.js";
+import { install_dev_client_maps, install_dev_maps, install_dev_page_keys } from "./dev-maps.js";
+import { CLIENT_BINDING_STUB, DEFAULT_IMPORT_KEYS, asRegionLocals, import_keys_hint, is_island_path, islandChunkFileName, islandId, islandPublicUrl, normalize_import_keys, wrapperVirtualId } from "../compiler/region/transform.js";
+import { regionId, regionIdentity, strategyKey } from "../compiler/region/identity.js";
+import { rewrite_lake_import_to_placeholder } from "../compiler/region/emit.js";
+import { debarrel } from "../compiler/debarrel/plugin.js";
+import { definePlugin, find_plugins, resolve_plugins } from "./plugin-api.js";
+import { assert_no_legacy_options, resolve_options, validate_region_presets } from "./options.js";
+import { clear_route_csr_cache, clientBuildWillSkip, hasAnyCsrFalseRoute, inject_keep_client_route, keep_client_dir, kit_dirs, kit_inline_style_threshold, kit_major, resolve_kit_paths } from "../compiler/kit.js";
+import { load_kit_dirs } from "./kit-dirs.js";
+import { write_module_map } from "./module-map.js";
+import { fill_profiler_maps } from "./profiler-maps.js";
+import { DEFAULT_REGION_TTL_SEC } from "../server/endpoint.js";
+import { RENEW_WINDOW_SEC } from "../server/shared-cache.js";
+import { derive_id_salt, secret_has_min_entropy } from "../server/hmac.js";
+import { buildFoucCssModuleSource, collectFoucCssReachable, compileFoucScopedCss, foucRelFromId, isFoucCssId, isFoucScopedId } from "../compiler/fouc-css.js";
+import { preprocess_component_for_css } from "./style-preprocess.js";
+import { needs_csr_false_full_reload, needs_island_entry_full_reload } from "../compiler/dev/hmr.js";
+import { derive_css_scope_owners } from "../compiler/dev/css-scope.js";
+import { island_subgraph_bytes } from "../compiler/dev/region-bytes.js";
+import { collectIslandDepModulepreloads, collect_inline_css, remote_hash_of, summarize_chunk_contents } from "../compiler/link/island-deps.js";
+import { emit_island_deps_handoff, report_seed_shaping, warn_content_leaks } from "../compiler/link/build-output.js";
+import { follow_pending_page_calls } from "../compiler/link/page-keys.js";
+import { parse_ssr_hosts, ssr_hosts_handoff_path } from "../compiler/link/emit-gate.js";
+import { router_css_key } from "../compiler/link/router-css.js";
+import { Program, strip_id } from "../compiler/program.js";
+import { Compiler } from "../compiler/driver.js";
+import { CompileCtx } from "../compiler/ctx.js";
+import { discover_package_files } from "./package-files.js";
+import { async_twin_redirect, svelte_async_enabled } from "./late-island.js";
+import { flags_manifest } from "../compiler/flags.js";
+import { RESOLVED, V_ROUTER_CSS, V_ROUTE_CONFIG, V_ROUTE_CSR, V_SERVER_ISLANDS, V_SERVER_MANIFEST } from "../compiler/ids.js";
+import { OWN_PACKAGE_NAMES, is_own_specifier } from "../own-package.js";
+import { APP_SHIMS, CLIENT_BINDING_STUB_FILE, HMAC_MODULE, KIT_REMOTE_CLIENT, KIT_REMOTE_STATE, OGYGIA_INJECTED_FILES, OGYGIA_INJECTED_IMPORTS, OGYGIA_REGION_MODULES, PKG_ROOT, PKG_ROOT_ID, REGION_ENDPOINT_MODULE, RUNTIME_DIR, RUNTIME_HASH, STUB_CLIENT, STUB_PATHS, STUB_STATE, real_posix, scan_entry_pattern } from "./paths.js";
+import crypto from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+import { isMainThread } from "node:worker_threads";
+import { loadEnv } from "vite";
+// src/vite/index.ts
+const KIT_CLIENT_APP_RE = /\/generated\/(?:build\/|dev\/)?client(-optimized)?\/app\.js$/;
+const ROUTE_HOST_OR_OPTION_RE = /[\\/]\+(page|layout)(\.server)?\.(svelte|js|ts)$/;
+const KIT_PAGE_THREAD = "\nimport { page as __og_kit_page, navigating as __og_kit_nav } from '$app/state';\nimport * as __og_kit_navigation from '$app/navigation';\nglobalThis[Symbol.for('ogygia.kit-page')] = { page: __og_kit_page, navigating: __og_kit_nav, navigation: __og_kit_navigation };\n";
+/** css-ish file the dev bridge manages (mirrors the bridge's glob). */
+const DEV_CSS_FILE_RE = /\.(css|scss|sass|less|styl)$/;
+const CSS_EXT_RE = /\.css$/;
+const STYLE_BEARING_FILE_RE = /\.(svelte|css|scss|sass|less|styl)$/;
+/** The bundler's resolver as the CSS walk's (compiler/fouc-css.ts `collectFoucCssReachable`): what
+*  the build resolves, the walk reaches — a package's `exports`, a workspace link, an alias. */
+function bundler_resolve(ctx) {
+	return async (spec, importer) => {
+		try {
+			const r = await ctx.resolve(spec, importer, { skipSelf: true });
+			return r && !r.external ? r.id : null;
+		} catch {
+			return null;
+		}
+	};
+}
+/**
+* Vite plugin: transforms `with { hydrate | defer | preset }` imports into islands,
+* serves virtual island modules, and wires signed region endpoints for deferred HTML.
+*
+* Place **before** `sveltekit()` in `vite.config`.
+*
+* @param options - Plugin configuration. See {@link OgygiaOptions}.
+* @returns Vite plugins (`ogygia` pre + island sourcemap fix post). Vite flattens the array.
+*/
+function ogygia(options = {}) {
+	const standalone = options.standalone === true;
+	assert_no_legacy_options(options);
+	const visibleMargin = options.visible?.margin;
+	const presets = options.presets || {};
+	validate_region_presets(presets);
+	let app_plugins = [];
+	let server_plugins = [];
+	let client_plugins = [];
+	let route_config = [];
+	let foreign_hydrate = false;
+	let macros = [];
+	let markup = [];
+	const import_keys = normalize_import_keys(options.importKeys);
+	let measure = false;
+	const pkg_scan = [];
+	/** the roots of plugins' own pages (`b.files()`), as module-id prefixes */
+	const plugin_file_roots = [];
+	let declared_scanned = false;
+	let page_importers = [];
+	let page_files = [];
+	const { rate_limit, session_cookie, region_ttl, renew_window, router_enabled, router_view_transitions, continuity_forms, server_delta } = resolve_options(options, DEFAULT_REGION_TTL_SEC, RENEW_WINDOW_SEC);
+	let devtools_effective = false;
+	let devtools_lazy = false;
+	const program = new Program({
+		forms: continuity_forms,
+		router: router_enabled
+	});
+	const { registry } = program;
+	const build_secret = crypto.randomBytes(32).toString("hex");
+	/** Salt for region ids — HKDF from stable env only (never per-build random, or SSR/client
+	*  builds would disagree). Empty when unset (dev + default per-build signing). */
+	let id_salt = "";
+	/** content_css_key → emitted CSS asset referenceId (client leg). Resolved to hrefs in writeBundle. */
+	const content_css_refs = /* @__PURE__ */ new Map();
+	/** router-css `rcss:<rel>` key → emitted CSS asset referenceId (client leg). A server router page
+	*  component's whole-tree scoped CSS, compiled + emitted as a dedicated asset (link/router-css.ts). */
+	const router_css_refs = /* @__PURE__ */ new Map();
+	/** server-island id → emitted tree-CSS asset referenceId (client leg). Resolved in writeBundle. */
+	const hole_css_refs = /* @__PURE__ */ new Map();
+	let root;
+	let base = "";
+	/** SvelteKit `config.kit.appDir` (default `_app`) — read from Kit's `__SVELTEKIT_APP_DIR__` define. */
+	let app_dir = "_app";
+	let libDir;
+	let is_dev = false;
+	/** the app compiles with Svelte's async mode (vite-plugin-svelte's resolved options): Region
+	*  imports the awaiting LateIsland (late-island.ts) */
+	let svelte_async = false;
+	/** Resolved `resolve.alias` entries — passed to bake()'s rolldown eval so `$lib` etc. resolve. */
+	let resolve_alias = [];
+	let is_build = false;
+	let is_ssr = false;
+	/** The leg a build hook runs in: the hook's ENVIRONMENT — Vite's environment API builds `ssr` and
+	*  `client` in one app build (Kit 3), where `config.build.ssr` is false for both, so the client's
+	*  work (the runtime chunk, the islands, their names) ran in the server leg too and landed in the
+	*  server output — every island 404'd. Else the build's own flag (one build per leg). The last
+	*  environment `buildStart` saw stands in for a hook the bundler calls without one. */
+	let last_leg_server = null;
+	const server_leg_of = (ctx) => {
+		const env = ctx?.environment;
+		if (env) return env.name === "ssr" || env.config?.consumer === "server";
+		return last_leg_server ?? is_ssr;
+	};
+	let content_scanned = false;
+	/** the server build's output, waiting for closeBundle to fill the profiler's maps module */
+	let maps_pending = null;
+	let vite_server = null;
+	/** absolute path to Kit's internal wire-protocol module (deep import) */
+	let kit_wire_path = null;
+	/** absolute path to Kit's client remote-functions entry (Plan A reuse) */
+	let kit_remote_index = null;
+	/** absolute path to the app's universal hooks (for `transport`), if present */
+	let universal_hooks = null;
+	/** absolute path to the app's client hooks (src/hooks.client.*), if present — its `init` runs on
+	*  boot for csr=false pages (Kit never runs it there). */
+	let client_hooks = null;
+	/** absolute path to Kit 3's client codec module (`#app/internal/transport`); null on Kit 2 */
+	let kit_transport_init = null;
+	/** true once the process-exit cleanup for the injected keep-client route is registered */
+	let keep_client_cleanup_armed = false;
+	const readFile = (abs) => {
+		try {
+			return fs.readFileSync(abs, "utf-8");
+		} catch {
+			return null;
+		}
+	};
+	const __prof = {
+		transformMs: 0,
+		transformN: 0,
+		transformHit: 0,
+		prescanMs: 0,
+		bakeMs: 0,
+		bakeN: 0,
+		resolveMs: 0,
+		loadMs: 0
+	};
+	const __P = !!process.env.OGYGIA_PROFILE;
+	const __outHash = /* @__PURE__ */ new Map();
+	const compiler = new Compiler(program, {
+		prof: __prof,
+		P: __P,
+		outHash: __outHash
+	});
+	/** Register the one-time process-exit cleanup (main thread only). */
+	const arm_keep_client_cleanup = (r) => {
+		if (keep_client_cleanup_armed) return;
+		keep_client_cleanup_armed = true;
+		process.on("exit", () => {
+			try {
+				fs.rmSync(keep_client_dir(r), {
+					recursive: true,
+					force: true
+				});
+			} catch {}
+		});
+	};
+	const invalidate_module_id = (server, id) => {
+		const mod = server.moduleGraph.getModuleById(id);
+		if (mod) server.moduleGraph.invalidateModule(mod);
+	};
+	const invalidate_islands_for_file = (file, { deleted = false, server = vite_server } = {}) => {
+		if (!server) return false;
+		return compiler.invalidate_for_file(file, {
+			deleted,
+			invalidate: (id) => invalidate_module_id(server, id)
+		});
+	};
+	return [
+		...options.barrels ? [debarrel(options.barrels, {
+			skip_attribute_keys: Object.values(import_keys),
+			skip_locals: asRegionLocals
+		})] : [],
+		{
+			name: "ogygia",
+			enforce: "pre",
+			config: {
+				order: "pre",
+				async handler(userConfig, env) {
+					await load_kit_dirs(path.resolve(userConfig.root ?? "."), userConfig.plugins);
+					app_plugins = standalone ? [] : await find_plugins(userConfig.plugins);
+					const resolved = resolve_plugins(app_plugins, path.resolve(userConfig.root ?? "."), env.command === "serve", (source, filename) => compiler.transform_content_island(source, filename));
+					({servers: server_plugins, clients: client_plugins, route_config, foreign_hydrate, macros, markup} = resolved);
+					measure = resolved.measure;
+					devtools_effective = resolved.events !== false;
+					devtools_lazy = resolved.events !== false && resolved.events.lazy;
+					page_importers = resolved.page_modules.importers;
+					page_files = resolved.page_modules.files.map(real_posix);
+					for (const p of resolved.files) if (!pkg_scan.some((s) => s.name === p.name)) {
+						plugin_file_roots.push(real_posix(p.root) + "/");
+						pkg_scan.push({
+							name: p.name,
+							root: real_posix(p.root),
+							dirs: p.dirs.map(real_posix),
+							files: p.files.map(real_posix)
+						});
+					}
+					if (env.command === "build" && !standalone && isMainThread) {
+						const r = path.resolve(userConfig.root ?? ".");
+						const routes = kit_dirs(r).routes_dir;
+						if (clientBuildWillSkip(routes)) {
+							inject_keep_client_route(r);
+							arm_keep_client_cleanup(r);
+						} else fs.rmSync(keep_client_dir(r), {
+							recursive: true,
+							force: true
+						});
+					}
+					if (!standalone && !declared_scanned) {
+						declared_scanned = true;
+						for (const p of discover_package_files(path.resolve(userConfig.root ?? "."))) if (!pkg_scan.some((s) => s.name === p.name)) pkg_scan.push(p);
+					}
+					const declared_pkg_names = [.../* @__PURE__ */ new Set([...pkg_scan.map((p) => p.name), ...app_plugins.map((p) => p.name)])];
+					const dev_island_deps = env.command === "serve" ? [
+						"svelte",
+						"svelte/internal/client",
+						"svelte/server",
+						"ogygia > @ogygia/core > devalue"
+					] : [];
+					return {
+						resolve: { dedupe: ["@sveltejs/kit"] },
+						ssr: { noExternal: [
+							"esm-env",
+							...OWN_PACKAGE_NAMES,
+							...declared_pkg_names
+						] },
+						optimizeDeps: {
+							exclude: [...OWN_PACKAGE_NAMES, ...declared_pkg_names],
+							include: dev_island_deps
+						},
+						define: {
+							__OGYGIA_CONTINUITY_FORMS__: JSON.stringify(continuity_forms),
+							__OGYGIA_SERVER_DELTA__: JSON.stringify(server_delta),
+							__OGYGIA_DEVTOOLS__: JSON.stringify(devtools_effective),
+							__OGYGIA_DEVTOOLS_LAZY__: JSON.stringify(devtools_lazy),
+							__OGYGIA_BEACON__: JSON.stringify(measure || devtools_effective),
+							__OGYGIA_CLIENT_PLUGINS__: JSON.stringify(client_plugins.length > 0),
+							__OGYGIA_KIT_MAJOR__: JSON.stringify(kit_major(path.resolve(userConfig.root ?? ".")))
+						},
+						server: { fs: { allow: [PKG_ROOT] } },
+						build: { rolldownOptions: { preserveEntrySignatures: "exports-only" } }
+					};
+				}
+			},
+			configResolved(config) {
+				root = config.root;
+				base = config.base || "";
+				svelte_async = svelte_async_enabled(config.plugins);
+				if (config.command === "serve") {
+					const own = (config.optimizeDeps?.include ?? []).filter((d) => is_own_specifier(d));
+					if (own.length) config.logger.warn(`[ogygia] optimizeDeps.include lists ${own.join(", ")}: ogygia must not be pre-bundled in dev (the page would run two copies of its runtime, and islands with snippet props fail to hydrate). Remove ${own.length === 1 ? "it" : "them"}.`);
+				}
+				const app_dir_define = config.define?.["__SVELTEKIT_APP_DIR__"];
+				if (typeof app_dir_define === "string") try {
+					const v = JSON.parse(app_dir_define);
+					if (typeof v === "string" && v) app_dir = v;
+				} catch {}
+				const ra = config.resolve?.alias ?? [];
+				resolve_alias = Array.isArray(ra) ? ra.map((a) => ({
+					find: a.find,
+					replacement: a.replacement
+				})) : Object.entries(ra).map(([find, replacement]) => ({
+					find,
+					replacement
+				}));
+				configure_build_cache(root);
+				libDir = path.join(root, "src", "lib");
+				is_dev = config.command === "serve";
+				is_build = config.command === "build";
+				is_ssr = !!config.build?.ssr;
+				if (is_dev) fs.rmSync(keep_client_dir(root), {
+					recursive: true,
+					force: true
+				});
+				if (!process.env.OGYGIA_SECRET?.trim()) {
+					const env_dir = config.envDir === false ? false : config.envDir ? path.resolve(root, config.envDir) : root;
+					if (env_dir !== false) {
+						const from_file = loadEnv(config.mode, env_dir, "").OGYGIA_SECRET?.trim();
+						if (from_file) process.env.OGYGIA_SECRET = from_file;
+					}
+				}
+				const env_secret = process.env.OGYGIA_SECRET?.trim() || "";
+				if (env_secret) {
+					if (is_build && !secret_has_min_entropy(env_secret)) throw new Error(`[ogygia] OGYGIA_SECRET is too short for production builds (need ≥16 UTF-8 bytes).`);
+					id_salt = derive_id_salt(env_secret);
+				} else id_salt = "";
+				({kit_wire_path, kit_remote_index, universal_hooks, client_hooks, kit_transport_init} = resolve_kit_paths(root));
+				compiler.configure(new CompileCtx({
+					root,
+					base,
+					app_dir,
+					libDir,
+					pkg_scan,
+					page_importers,
+					page_files,
+					measure,
+					server_plugins,
+					client_plugins,
+					route_config,
+					foreign_hydrate,
+					is_dev,
+					id_salt,
+					visibleMargin,
+					presets,
+					import_keys,
+					resolve_alias,
+					macros,
+					pkg_root: PKG_ROOT_ID,
+					build_secret,
+					rate_limit,
+					session_cookie,
+					region_ttl,
+					renew_window,
+					router_enabled,
+					router_view_transitions,
+					client_hooks,
+					runtime_dir: RUNTIME_DIR,
+					runtime_hash: RUNTIME_HASH,
+					hmac_module: HMAC_MODULE,
+					region_endpoint_module: REGION_ENDPOINT_MODULE,
+					client_binding_stub_file: CLIENT_BINDING_STUB_FILE,
+					app_shims: APP_SHIMS,
+					is_build,
+					devtools: devtools_effective
+				}));
+				if (is_dev) {
+					compiler.prescan();
+					const opt = config.optimizeDeps ??= {};
+					const entries = Array.isArray(opt.entries) ? opt.entries : opt.entries ? [opt.entries] : [];
+					opt.entries = entries;
+					const have = new Set(entries);
+					for (const abs of compiler.island_scan_entries()) {
+						const posix = real_posix(abs);
+						const pattern = plugin_file_roots.some((r) => posix.startsWith(r)) ? null : scan_entry_pattern(abs);
+						if (pattern !== null && !have.has(pattern)) {
+							have.add(pattern);
+							entries.push(pattern);
+						}
+					}
+				}
+			},
+			async buildStart() {
+				const server_leg = server_leg_of(this);
+				last_leg_server = server_leg;
+				if (is_build && server_leg) fs.rmSync(ssr_hosts_handoff_path(kit_dirs(root).out_dir), { force: true });
+				if (!content_scanned) {
+					content_scanned = true;
+					compiler.prescan();
+					for (const source of markup) await source.scan?.({
+						root,
+						readFile
+					});
+				}
+				if (is_build && !server_leg) {
+					const emit_runtime = !standalone && (hasAnyCsrFalseRoute(kit_dirs(root).routes_dir) || compiler.has_hydrate_regions());
+					let loaded = null;
+					try {
+						loaded = parse_ssr_hosts(fs.readFileSync(ssr_hosts_handoff_path(kit_dirs(root).out_dir), "utf8"));
+					} catch {}
+					const skipped = compiler.emit_build_chunks((chunk) => this.emitFile(chunk), {
+						emitRuntime: emit_runtime,
+						loaded
+					});
+					if (skipped && isMainThread) console.log(`[ogygia] ${skipped} island chunk(s) not emitted: their host modules are not in the server bundle (unreachable from this build's routes).`);
+					router_css_refs.clear();
+					const walk_resolve = bundler_resolve(this);
+					for (const abs of compiler.router_css_roots()) {
+						const parts = [];
+						for (const e of await collectFoucCssReachable(abs, {
+							root,
+							libDir,
+							readFile,
+							alias: resolve_alias,
+							resolve: walk_resolve
+						})) if (e.kind === "scoped") {
+							const src = readFile(e.abs);
+							if (src == null) continue;
+							const css = compileFoucScopedCss(e.abs, await preprocess_component_for_css(src, e.abs, root), { keepScript: true });
+							if (css) parts.push(css);
+						} else if (CSS_EXT_RE.test(e.abs)) {
+							const css = readFile(e.abs);
+							if (css) parts.push(css);
+						}
+						if (!parts.length) continue;
+						const ref = this.emitFile({
+							type: "asset",
+							name: "og-rcss.css",
+							source: parts.join("\n")
+						});
+						router_css_refs.set(router_css_key(root, abs), ref);
+					}
+					hole_css_refs.clear();
+					const hole_css_by_abs = /* @__PURE__ */ new Map();
+					for (const { iid, abs } of compiler.server_island_css_roots()) {
+						let ref = hole_css_by_abs.get(abs);
+						if (ref === void 0) {
+							const parts = [];
+							for (const e of await collectFoucCssReachable(abs, {
+								root,
+								libDir,
+								readFile,
+								alias: resolve_alias,
+								resolve: walk_resolve
+							})) if (e.kind === "scoped") {
+								const src = readFile(e.abs);
+								if (src == null) continue;
+								const css = compileFoucScopedCss(e.abs, await preprocess_component_for_css(src, e.abs, root), { keepScript: true });
+								if (css) parts.push(css);
+							} else if (CSS_EXT_RE.test(e.abs)) {
+								const css = readFile(e.abs);
+								if (css) parts.push(css);
+							}
+							ref = parts.length ? this.emitFile({
+								type: "asset",
+								name: "og-hole.css",
+								source: parts.join("\n")
+							}) : "";
+							hole_css_by_abs.set(abs, ref);
+						}
+						if (ref) hole_css_refs.set(iid, ref);
+					}
+					content_css_refs.clear();
+					const styles = markup.flatMap((m) => m.styles ? [...m.styles] : []);
+					if (styles.length) {
+						const { compile } = await import("svelte/compiler");
+						for (const [abs, source] of styles) try {
+							const { css } = compile(source, {
+								filename: abs,
+								css: "external",
+								dev: false,
+								generate: "client",
+								experimental: { async: true }
+							});
+							if (css?.code) {
+								const ref = this.emitFile({
+									type: "asset",
+									name: "og-content.css",
+									source: css.code
+								});
+								content_css_refs.set(content_css_key(abs), ref);
+							}
+						} catch {}
+					}
+				}
+			},
+			configureServer(server) {
+				vite_server = server;
+				if (measure) {
+					install_dev_maps(server);
+					install_dev_client_maps(server);
+					install_dev_page_keys(server, (iid) => program.registry.get(program.by_id.get(iid) ?? "")?.componentPath, root);
+				}
+				if (!devtools_effective) return;
+				server.middlewares.use((_req, res, next) => {
+					res.setHeader("document-policy", "js-profiling");
+					next();
+				});
+				server.middlewares.use((req, res, next) => {
+					if ((req.url || "").split("?")[0] !== "/__ogygia_devtools_meta") return next();
+					const client_modules = server.environments?.client?.moduleGraph?.idToModuleMap?.values();
+					const sources = /* @__PURE__ */ new Map();
+					const read = (file) => {
+						if (!sources.has(file)) try {
+							sources.set(file, fs.readFileSync(file, "utf8"));
+						} catch {
+							sources.set(file, void 0);
+						}
+						return sources.get(file);
+					};
+					const bytes = client_modules ? island_subgraph_bytes(client_modules, read) : {};
+					res.setHeader("content-type", "application/json");
+					res.end(JSON.stringify({
+						names: compiler.region_names(),
+						bytes
+					}));
+				});
+			},
+			watchChange(id, change) {
+				if (is_dev && ROUTE_HOST_OR_OPTION_RE.test(id)) {
+					clear_route_csr_cache();
+					if (vite_server) {
+						invalidate_module_id(vite_server, RESOLVED(V_ROUTE_CSR));
+						invalidate_module_id(vite_server, RESOLVED(V_ROUTE_CONFIG));
+					}
+				}
+				if (!is_dev || change.event !== "delete" || !vite_server) return;
+				if (!invalidate_islands_for_file(id, {
+					deleted: true,
+					server: vite_server
+				})) return;
+				vite_server.ws.send({
+					type: "full-reload",
+					path: "*"
+				});
+			},
+			buildEnd() {
+				const server_leg = server_leg_of(this);
+				if (is_build && server_leg && !standalone) try {
+					const handoff = ssr_hosts_handoff_path(kit_dirs(root).out_dir);
+					fs.mkdirSync(path.dirname(handoff), { recursive: true });
+					fs.writeFileSync(handoff, JSON.stringify(compiler.ssr_transformed_hosts()));
+				} catch (e) {
+					if (isMainThread) console.warn("[ogygia] could not write the server-leg island handoff:", e);
+				}
+				if (__P) {
+					const keys = [...__outHash.keys()].sort();
+					let d = 2166136261;
+					for (const k of keys) {
+						d ^= __outHash.get(k);
+						d = Math.imul(d, 16777619) >>> 0;
+					}
+					console.error("\n[ogygia-prof] " + JSON.stringify({
+						...__prof,
+						transformDigest: (d >>> 0).toString(16),
+						transformFiles: keys.length
+					}));
+				}
+			},
+			handleHotUpdate({ file, server }) {
+				if (!is_dev) return;
+				vite_server = server;
+				if (STYLE_BEARING_FILE_RE.test(file)) {
+					const mod = server.moduleGraph.getModuleById("\0" + V_ROUTER_CSS);
+					if (mod) server.moduleGraph.invalidateModule(mod);
+				}
+				if (DEV_CSS_FILE_RE.test(file) && !file.includes("/node_modules/")) {
+					const src_prefix = path.join(root, "src") + path.sep;
+					if (path.normalize(file).startsWith(src_prefix)) {
+						const envs = server.environments;
+						const client_graph = envs?.client?.moduleGraph;
+						if (!(client_graph?.getModulesByFile?.(file)?.size ?? 0)) {
+							const owners = derive_css_scope_owners(file, root, [envs?.ssr?.moduleGraph, client_graph]);
+							const web_path = "/" + path.relative(root, file).split(path.sep).join("/");
+							server.ws.send({
+								type: "custom",
+								event: "ogygia:css",
+								data: {
+									path: web_path,
+									owners
+								}
+							});
+							return [];
+						}
+						return;
+					}
+				}
+				const deleted = !fs.existsSync(strip_id(file));
+				const host_changed = !deleted && compiler.is_registered_host(file);
+				const entry_changed = !deleted && needs_island_entry_full_reload(file, registry.values());
+				if (host_changed || deleted) invalidate_islands_for_file(file, {
+					deleted,
+					server
+				});
+				if (!needs_csr_false_full_reload(file) && !deleted && !host_changed && !entry_changed) return;
+				server.ws.send({
+					type: "full-reload",
+					path: "*"
+				});
+				return [];
+			},
+			async resolveId(source, importer, options) {
+				if (source === "virtual:ogygia/kit-wire" && kit_wire_path) return kit_wire_path;
+				if (OGYGIA_INJECTED_IMPORTS.has(source)) return OGYGIA_INJECTED_FILES[source];
+				if (svelte_async) {
+					const awaiting = async_twin_redirect(source, importer, OGYGIA_REGION_MODULES);
+					if (awaiting) return awaiting;
+				}
+				const ssr = options?.ssr === true;
+				if (!ssr && source === "__sveltekit/remote") {
+					if (!kit_remote_index) throw new Error("[ogygia] could not locate Kit's client remote-functions (src). Use an @sveltejs/kit that publishes its `src/` (2.70.2 or later, or 3.x).");
+					return kit_remote_index;
+				}
+				if (!ssr && importer && importer.includes("/remote-functions/")) {
+					if (KIT_REMOTE_CLIENT.test(source)) return STUB_CLIENT;
+					if (KIT_REMOTE_STATE.test(source)) return STUB_STATE;
+					if (source === "#app/paths") return STUB_PATHS;
+					if (source === "#app/state/client") return STUB_STATE;
+				}
+				if (!ssr && source === "$app/paths/internal/client") return STUB_PATHS;
+				return compiler.resolve_id(source, importer, {
+					ssr,
+					resolve: (s, i, o) => this.resolve(s, i, o)
+				});
+			},
+			async load(id, options) {
+				const ssr = options?.ssr === true;
+				const fouc_bare = id.startsWith("\0") ? id.slice(1) : id;
+				if (isFoucCssId(fouc_bare)) {
+					const rel = foucRelFromId(fouc_bare);
+					if (!rel) return {
+						code: "export {}",
+						moduleSideEffects: false
+					};
+					const abs = path.join(root, rel);
+					return {
+						code: await buildFoucCssModuleSource(abs, {
+							root,
+							libDir,
+							readFile: (p) => {
+								try {
+									return fs.readFileSync(p, "utf8");
+								} catch {
+									return null;
+								}
+							}
+						}),
+						moduleSideEffects: true
+					};
+				}
+				if (isFoucScopedId(fouc_bare)) {
+					const rel = foucRelFromId(fouc_bare);
+					if (!rel) return {
+						code: "",
+						moduleType: "css"
+					};
+					const abs = path.join(root, rel);
+					let source = "";
+					try {
+						source = fs.readFileSync(abs, "utf8");
+					} catch {
+						return {
+							code: "",
+							moduleType: "css"
+						};
+					}
+					return {
+						code: compileFoucScopedCss(abs, await preprocess_component_for_css(source, abs, root), { keepScript: true }),
+						moduleType: "css"
+					};
+				}
+				return compiler.emit(id, {
+					ssr,
+					universalHooks: universal_hooks,
+					resolve: bundler_resolve(this),
+					kitCodec: kit_transport_init
+				});
+			},
+			async transform(code, id, options) {
+				let source = code;
+				if (!options?.ssr && KIT_CLIENT_APP_RE.test(id)) source += KIT_PAGE_THREAD;
+				const result = await compiler.transform_module(source, id, {
+					ssr: options?.ssr === true,
+					emitFile: (chunk) => this.emitFile(chunk)
+				});
+				if (is_dev && vite_server && compiler.server_manifest_stale()) {
+					invalidate_module_id(vite_server, RESOLVED(V_SERVER_MANIFEST));
+					invalidate_module_id(vite_server, RESOLVED(V_SERVER_ISLANDS));
+				}
+				if (is_dev && vite_server) for (const marked of compiler.drain_closure_marks()) invalidate_module_id(vite_server, marked);
+				if (result) return result;
+				return source === code ? null : {
+					code: source,
+					map: null
+				};
+			},
+			renderChunk(code) {
+				const fn = compiler.patch_fn_manifest(code);
+				if (!server_leg_of(this)) return fn;
+				return compiler.patch_page_data_reads(fn?.code ?? code, (id) => this.getModuleInfo(id), () => this.getModuleIds()) ?? fn;
+			},
+			outputOptions(output) {
+				if (!is_build || server_leg_of(this)) return null;
+				const ours = (fallback, dflt) => (info) => compiler.entry_file_pattern(info.name) ?? (typeof fallback === "function" ? fallback(info) : fallback ?? dflt);
+				return {
+					...output,
+					entryFileNames: ours(output.entryFileNames, "[name].js"),
+					chunkFileNames: ours(output.chunkFileNames, "[name]-[hash].js")
+				};
+			},
+			generateBundle() {
+				if (!is_build || server_leg_of(this)) return;
+				for (const shim of compiler.entry_shims((ref) => this.getFileName(ref))) this.emitFile({
+					type: "asset",
+					fileName: shim.fileName,
+					source: shim.source
+				});
+			},
+			closeBundle: {
+				order: "pre",
+				sequential: true,
+				handler() {
+					if (!maps_pending) return;
+					const { dir, bundle } = maps_pending;
+					maps_pending = null;
+					try {
+						fill_profiler_maps(dir, bundle, root);
+					} catch {}
+				}
+			},
+			async writeBundle(_options, bundle) {
+				const server_leg = server_leg_of(this);
+				if (is_build && server_leg && measure && _options.dir) {
+					try {
+						write_module_map(_options.dir, bundle, root);
+					} catch {}
+					maps_pending = {
+						dir: _options.dir,
+						bundle
+					};
+				}
+				if (!is_build || server_leg) return;
+				warn_content_leaks(bundle, root, is_island_path);
+				if (program.flag_sites.length && isMainThread) try {
+					const dir = path.join(root, "node_modules", ".ogygia");
+					fs.mkdirSync(dir, { recursive: true });
+					const manifest = flags_manifest(program.flag_sites);
+					fs.writeFileSync(path.join(dir, "flags-manifest.json"), JSON.stringify(manifest, null, "	") + "\n");
+					console.log(`[ogygia] flags manifest: ${manifest.names.length} flag(s) → node_modules/.ogygia/flags-manifest.json`);
+				} catch {}
+				await follow_pending_page_calls(program, (s, importer) => this.resolve(s, importer));
+				const remote_hash = (id) => remote_hash_of(id, process.cwd());
+				const entries = compiler.entry_locations((ref) => this.getFileName(ref));
+				const map = collectIslandDepModulepreloads(bundle, [APP_SHIMS["$app/state"], APP_SHIMS["$app/stores"]], remote_hash, (module_id) => program.page_keys.get(module_id) ?? null, (id) => {
+					try {
+						return fs.readFileSync(id, "utf8");
+					} catch {
+						return null;
+					}
+				}, entries.runtime_file, {
+					islands: entries.islands,
+					runtime: entries.runtime
+				});
+				const page_why = report_seed_shaping(map, bundle, program, root, (identity) => entries.locations[identity] ?? identity);
+				for (const [key, ref] of router_css_refs) try {
+					const file = this.getFileName(ref);
+					map.css[key] = [file.startsWith("/") ? file : "/" + file];
+				} catch {}
+				for (const [iid, ref] of hole_css_refs) try {
+					const file = this.getFileName(ref);
+					const key = compiler.island_public_url(iid);
+					(map.css[key] ??= []).push(file.startsWith("/") ? file : "/" + file);
+				} catch {}
+				const content_css = {};
+				for (const [key, ref] of content_css_refs) try {
+					const file = this.getFileName(ref);
+					content_css[key] = [file.startsWith("/") ? file : "/" + file];
+				} catch {}
+				const css_inline = collect_inline_css(bundle, [...Object.values(map.css).flat(), ...Object.values(content_css).flat()], kit_inline_style_threshold(root));
+				if (!measure) {
+					map.contents = {};
+					map.heavy = {};
+					map.hazards = {};
+					map.dupes = [];
+				}
+				const barrels = {};
+				if (measure) for (const [key, chunk] of Object.entries(bundle)) {
+					if (chunk.type !== "chunk") continue;
+					const found = [];
+					for (const id of chunk.moduleIds ?? []) {
+						if (id.startsWith("\0")) continue;
+						const q = id.indexOf("?");
+						if ((q === -1 ? id : id.slice(0, q)).endsWith(".svelte")) continue;
+						const info = this.getModuleInfo(id);
+						if (!info) continue;
+						const fanout = info.importedIds.filter((d) => !d.startsWith("\0")).length;
+						const own = info.code?.length ?? Infinity;
+						if (fanout >= 6 && own <= fanout * 160) {
+							const name = summarize_chunk_contents([id], 1, 1)[0];
+							if (name) found.push({
+								name,
+								fanout
+							});
+						}
+					}
+					if (found.length) barrels["/" + (chunk.fileName || key)] = found.sort((a, b) => b.fanout - a.fanout).slice(0, 3);
+				}
+				const json = JSON.stringify({
+					...map,
+					...measure ? {
+						page_why,
+						barrels
+					} : {},
+					content_css,
+					css_inline,
+					fn_manifest: Object.fromEntries(compiler.dollar_hoists),
+					entries: entries.locations
+				});
+				emit_island_deps_handoff(root, json, kit_dirs(root).out_dir);
+			}
+		},
+		island_sourcemaps_plugin({
+			program,
+			is_island_path
+		}),
+		server_sourcemaps_plugin(() => measure)
+	];
+}
+export { CLIENT_BINDING_STUB, DEFAULT_IMPORT_KEYS, debarrel, definePlugin, import_keys_hint, islandChunkFileName, islandId, islandPublicUrl, normalize_import_keys, ogygia, regionId, regionIdentity, rewrite_lake_import_to_placeholder, strategyKey, wrapperVirtualId };