@ogygia/core 0.0.0 → 0.11.1

package/dist/compiler/free-vars.js

@@ -0,0 +1,327 @@
+import { walk } from "estree-walker";
+// src/compiler/free-vars.ts
+/**
+* Free-variable analysis over a Svelte 5 template subtree.
+*
+* Given an array of top-level template nodes (a hoisted island subtree), returns
+* the set of identifier names that are referenced inside the subtree but bound
+* OUTSIDE it (host `<script>` vars, outer `{#each}` locals, component imports,
+* globals...), PLUS the set of those free names that are the TARGET of a mutation
+* (assignment / update / compound-assign / destructuring-assignment / `bind:`).
+* Identifiers bound *within* the subtree (snippet params, each locals, `{@const}`,
+* `{#await}` value/error, `let:` directives, and JS-level function params) are
+* excluded from both sets.
+*
+* The mutation set powers a build-time guard: captured host state crosses the
+* boundary as a serialized SNAPSHOT, so writing to it inside an island updates
+* nothing. The transform turns a mutated capture into a precise error.
+*/
+const FUNCTION_TYPES = /* @__PURE__ */ new Set([
+	"FunctionDeclaration",
+	"FunctionExpression",
+	"ArrowFunctionExpression"
+]);
+/** Collect bound names from an estree binding pattern. */
+function collect_pattern_names(node, out) {
+	if (!node) return;
+	switch (node.type) {
+		case "Identifier":
+			out.add(node.name);
+			break;
+		case "ObjectPattern":
+			for (const prop of node.properties) if (prop.type === "RestElement") collect_pattern_names(prop.argument, out);
+			else collect_pattern_names(prop.value, out);
+			break;
+		case "ArrayPattern":
+			for (const el of node.elements) collect_pattern_names(el, out);
+			break;
+		case "AssignmentPattern":
+			collect_pattern_names(node.left, out);
+			break;
+		case "RestElement": collect_pattern_names(node.argument, out);
+	}
+}
+/** The leftmost identifier name of a member chain (`a.b.c` -> `a`), or null. */
+function member_root(node) {
+	let cur = node;
+	while (cur && cur.type === "MemberExpression") cur = cur.object;
+	return cur && cur.type === "Identifier" ? cur.name : null;
+}
+/**
+* Collect the ROOT identifier names written by an assignment/update target — an
+* Identifier (`x = …`), a MemberExpression (`x.a = …` -> `x`), or a destructuring
+* pattern (`[x] = …`, `({ x } = …)`, defaults, rests, nested member targets).
+*/
+function collect_write_roots(target, roots) {
+	if (!target) return;
+	switch (target.type) {
+		case "Identifier":
+			roots.add(target.name);
+			break;
+		case "MemberExpression": {
+			const r = member_root(target);
+			if (r) roots.add(r);
+			break;
+		}
+		case "ObjectPattern":
+			for (const prop of target.properties) if (prop.type === "RestElement") collect_write_roots(prop.argument, roots);
+			else collect_write_roots(prop.value, roots);
+			break;
+		case "ArrayPattern":
+			for (const el of target.elements) if (el) collect_write_roots(el, roots);
+			break;
+		case "AssignmentPattern":
+			collect_write_roots(target.left, roots);
+			break;
+		case "RestElement": collect_write_roots(target.argument, roots);
+	}
+}
+/** Is this Identifier node a *reference* (a read) rather than a binding/property name? */
+function is_reference(node, parent, key) {
+	if (!parent) return true;
+	switch (parent.type) {
+		case "MemberExpression":
+			if (key === "property" && !parent.computed) return false;
+			return true;
+		case "Property":
+			if (key === "key" && !parent.computed) return parent.shorthand;
+			return true;
+		case "VariableDeclarator": return key !== "id";
+		case "FunctionDeclaration":
+		case "FunctionExpression":
+		case "ArrowFunctionExpression": return key !== "id" && key !== "params";
+		case "ImportSpecifier":
+		case "ImportDefaultSpecifier":
+		case "ImportNamespaceSpecifier": return false;
+		case "LabeledStatement":
+		case "BreakStatement":
+		case "ContinueStatement": return key !== "label";
+		case "CatchClause": return key !== "param";
+		default: return true;
+	}
+}
+/**
+* Walk one estree expression, adding any free references (not bound by inner
+* JS function scopes and not in `svelte_bound`) into `sink.refs`, and any free
+* assignment/update targets into `sink.mutated`.
+*/
+function add_expression_refs(expr, svelte_bound, sink) {
+	if (!expr) return;
+	const scopes = [/* @__PURE__ */ new Set()];
+	const has = (name) => {
+		if (svelte_bound.has(name)) return true;
+		for (let i = scopes.length - 1; i >= 0; i--) if (scopes[i].has(name)) return true;
+		return false;
+	};
+	const record_writes = (target) => {
+		const roots = /* @__PURE__ */ new Set();
+		collect_write_roots(target, roots);
+		for (const r of roots) if (!has(r)) sink.mutated.add(r);
+	};
+	walk(expr, {
+		enter(node, parent, key) {
+			if (FUNCTION_TYPES.has(node.type)) {
+				const s = /* @__PURE__ */ new Set();
+				const fn = node;
+				if (fn.id && node.type !== "ArrowFunctionExpression") s.add(fn.id.name);
+				for (const p of fn.params) collect_pattern_names(p, s);
+				scopes.push(s);
+			} else if (node.type === "BlockStatement" && !FUNCTION_TYPES.has(parent?.type ?? "")) scopes.push(/* @__PURE__ */ new Set());
+			else if (node.type === "VariableDeclarator") collect_pattern_names(node.id, scopes[scopes.length - 1]);
+			else if (node.type === "CatchClause" && node.param) collect_pattern_names(node.param, scopes[scopes.length - 1]);
+			else if (node.type === "AssignmentExpression") record_writes(node.left);
+			else if (node.type === "UpdateExpression") record_writes(node.argument);
+			else if (node.type === "Identifier" && is_reference(node, parent, key)) {
+				if (!has(node.name)) {
+					sink.refs.add(node.name);
+					const at = node;
+					if (node.name.startsWith("$") && at.start != null && at.end != null) {
+						let sites = sink.stores.get(node.name);
+						if (!sites) sink.stores.set(node.name, sites = []);
+						sites.push({
+							start: at.start,
+							end: at.end
+						});
+					}
+				}
+			}
+		},
+		leave(node, parent) {
+			if (FUNCTION_TYPES.has(node.type)) scopes.pop();
+			else if (node.type === "BlockStatement" && !FUNCTION_TYPES.has(parent?.type ?? "")) scopes.pop();
+		}
+	});
+}
+/** Names introduced by `let:` directives on an element/component. */
+function let_directive_names(node) {
+	const names = /* @__PURE__ */ new Set();
+	for (const attr of node.attributes ?? []) if (attr.type === "LetDirective") {
+		if (attr.expression) collect_pattern_names(attr.expression, names);
+		else names.add(attr.name);
+	}
+	return names;
+}
+/** Walk attribute expressions of an element/component (not `let:`, which binds). */
+function add_attribute_refs(node, bound, sink) {
+	for (const attr of node.attributes ?? []) switch (attr.type) {
+		case "Attribute":
+			if (attr.value === true) break;
+			if (Array.isArray(attr.value)) {
+				for (const part of attr.value) if (part.type === "ExpressionTag") add_expression_refs(part.expression, bound, sink);
+			} else if (attr.value?.type === "ExpressionTag") add_expression_refs(attr.value.expression, bound, sink);
+			break;
+		case "SpreadAttribute":
+			add_expression_refs(attr.expression, bound, sink);
+			break;
+		case "LetDirective": break;
+		case "BindDirective":
+			if (attr.expression) {
+				add_expression_refs(attr.expression, bound, sink);
+				const root = attr.expression.type === "Identifier" ? attr.expression.name : member_root(attr.expression);
+				if (root && !bound.has(root)) sink.mutated.add(root);
+			}
+			break;
+		default: if (attr.expression) add_expression_refs(attr.expression, bound, sink);
+	}
+}
+/** Collect snippet names + const-declared names defined at this fragment level. */
+function sibling_bindings(nodes) {
+	const names = /* @__PURE__ */ new Set();
+	for (const n of nodes) if (n.type === "SnippetBlock" && n.expression) names.add(n.expression.name);
+	else if (n.type === "ConstTag") for (const d of n.declaration.declarations) collect_pattern_names(d.id, names);
+	return names;
+}
+function fragment_nodes(fragment) {
+	return fragment?.nodes ?? [];
+}
+/**
+* @param nodes top-level nodes of the subtree
+* @param outer_bound names bound outside (usually empty at entry)
+* @param sink accumulates free references + mutations
+*/
+function walk_template(nodes, outer_bound, sink) {
+	const bound = new Set(outer_bound);
+	for (const name of sibling_bindings(nodes)) bound.add(name);
+	for (const node of nodes) switch (node.type) {
+		case "Text":
+		case "Comment": break;
+		case "ExpressionTag":
+		case "HtmlTag":
+		case "RenderTag":
+			add_expression_refs(node.expression, bound, sink);
+			break;
+		case "ConstTag":
+			for (const d of node.declaration.declarations) add_expression_refs(d.init, bound, sink);
+			break;
+		case "IfBlock":
+			add_expression_refs(node.test, bound, sink);
+			walk_template(fragment_nodes(node.consequent), bound, sink);
+			if (node.alternate) walk_template(fragment_nodes(node.alternate), bound, sink);
+			break;
+		case "EachBlock": {
+			add_expression_refs(node.expression, bound, sink);
+			const each_bound = new Set(bound);
+			collect_pattern_names(node.context, each_bound);
+			if (node.index) each_bound.add(node.index);
+			if (node.key) add_expression_refs(node.key, each_bound, sink);
+			walk_template(fragment_nodes(node.body), each_bound, sink);
+			if (node.fallback) walk_template(fragment_nodes(node.fallback), bound, sink);
+			break;
+		}
+		case "AwaitBlock":
+			add_expression_refs(node.expression, bound, sink);
+			if (node.pending) walk_template(fragment_nodes(node.pending), bound, sink);
+			if (node.then) {
+				const then_bound = new Set(bound);
+				if (node.value) collect_pattern_names(node.value, then_bound);
+				walk_template(fragment_nodes(node.then), then_bound, sink);
+			}
+			if (node.catch) {
+				const catch_bound = new Set(bound);
+				if (node.error) collect_pattern_names(node.error, catch_bound);
+				walk_template(fragment_nodes(node.catch), catch_bound, sink);
+			}
+			break;
+		case "KeyBlock":
+			add_expression_refs(node.expression, bound, sink);
+			walk_template(fragment_nodes(node.fragment), bound, sink);
+			break;
+		case "SnippetBlock": {
+			const snip_bound = new Set(bound);
+			for (const p of node.parameters ?? []) collect_pattern_names(p, snip_bound);
+			walk_template(fragment_nodes(node.body), snip_bound, sink);
+			break;
+		}
+		case "Component":
+		case "SvelteComponent": {
+			const root = String(node.name || "").split(".")[0];
+			if (root && !bound.has(root)) sink.refs.add(root);
+			add_attribute_refs(node, bound, sink);
+			const el_bound1 = new Set(bound);
+			for (const name of let_directive_names(node)) el_bound1.add(name);
+			if (node.fragment) walk_template(fragment_nodes(node.fragment), el_bound1, sink);
+			break;
+		}
+		case "RegularElement":
+		case "SvelteElement":
+		case "SvelteSelf":
+		case "SvelteFragment":
+		case "SvelteBoundary":
+		case "SlotElement":
+		case "TitleElement": {
+			if (node.tag) add_expression_refs(node.tag, bound, sink);
+			add_attribute_refs(node, bound, sink);
+			const el_bound = new Set(bound);
+			for (const name of let_directive_names(node)) el_bound.add(name);
+			if (node.fragment) walk_template(fragment_nodes(node.fragment), el_bound, sink);
+			break;
+		}
+		default: if (node.fragment) walk_template(fragment_nodes(node.fragment), bound, sink);
+	}
+}
+/** Collect all snippet names defined anywhere in a subtree (for cross-boundary error detection). */
+function collectSnippetNames(nodes) {
+	const out = /* @__PURE__ */ new Set();
+	const visit = (list) => {
+		for (const n of list ?? []) {
+			if (n.type === "SnippetBlock" && n.expression) out.add(n.expression.name);
+			for (const k of [
+				"consequent",
+				"alternate",
+				"body",
+				"fallback",
+				"pending",
+				"then",
+				"catch",
+				"fragment"
+			]) if (n[k]?.nodes) visit(n[k].nodes);
+		}
+	};
+	visit(nodes);
+	return out;
+}
+/**
+* @param nodes hoisted subtree top-level nodes
+* @returns free identifier names + free mutation targets + `$store` read sites
+*/
+function collectCaptureInfo(nodes) {
+	const sink = {
+		refs: /* @__PURE__ */ new Set(),
+		mutated: /* @__PURE__ */ new Set(),
+		stores: /* @__PURE__ */ new Map()
+	};
+	walk_template(nodes, /* @__PURE__ */ new Set(), sink);
+	return {
+		free: sink.refs,
+		mutated: sink.mutated,
+		stores: sink.stores
+	};
+}
+/**
+* @param nodes hoisted subtree top-level nodes
+* @returns free identifier names
+*/
+function collectFreeIdentifiers(nodes) {
+	return collectCaptureInfo(nodes).free;
+}
+export { collectCaptureInfo, collectFreeIdentifiers, collectSnippetNames };

package/dist/compiler/host.d.ts

@@ -0,0 +1,65 @@
+/** Directory entry (a `readdirSync(dir, { withFileTypes: true })` element). */
+export interface HostDirent {
+  name: string;
+  isDirectory(): boolean;
+  isFile(): boolean;
+}
+/** File stats (`statSync`) — only the members the compiler reads. */
+export interface HostStats {
+  isDirectory(): boolean;
+  isFile(): boolean;
+  mtimeMs?: number;
+  size?: number;
+}
+/** The filesystem surface the compiler uses. Reads must be real (the driver resolves the module graph
+ *  through them); writes are the build's on-disk emits — a browser host keeps them in memory or no-ops. */
+export interface HostFs {
+  /** `enc`: the text encoding (the compiler always reads `'utf8'`) */
+  readFileSync(p: string, enc?: string): string;
+  existsSync(p: string): boolean;
+  /** names (`string`s) normally, {@link HostDirent}s with `{ withFileTypes: true }`: read entries
+   *  through {@link dir_entries}, which says which */
+  readdirSync(p: string, opts?: {
+    withFileTypes?: boolean;
+  }): unknown[];
+  statSync(p: string): HostStats;
+  globSync(pattern: string | string[], opts?: Record<string, unknown>): string[];
+  writeFileSync(p: string, data: string): void;
+  mkdirSync(p: string, opts?: {
+    recursive?: boolean;
+  }): void;
+  rmSync(p: string, opts?: {
+    recursive?: boolean;
+    force?: boolean;
+  }): void;
+  renameSync(from: string, to: string): void;
+}
+/** The `path` surface (node's `path` and `path`-browserify both satisfy this). */
+export type HostPath = typeof import("node:path");
+/** The one hash the compiler needs — `createHash(algo).update(s).digest('hex')` (md5 ids, sha256 hashes). */
+export interface HostHasher {
+  update(data: string): HostHasher;
+  digest(enc: "hex"): string;
+}
+export interface HostCrypto {
+  createHash(algo: string): HostHasher;
+}
+/** A complete host environment. Install one in a non-Node realm via {@link set_host}. */
+export interface CompilerHost {
+  fs: HostFs;
+  path: HostPath;
+  crypto: HostCrypto;
+}
+/**
+ * Install a browser (or test) host. No-arg resets to the Node default. Call once, before the first
+ * compile: the browser worker builds a virtual host over its workspace file-map and installs it here.
+ */
+export declare function set_host(h?: CompilerHost): void;
+/** The current host's `fs` — read `fs.readFileSync(…)` exactly as with `node:fs`. */
+export declare const fs: HostFs;
+/** The entries of `dir` on the current host (`readdirSync(dir, { withFileTypes: true })`). */
+export declare function dir_entries(dir: string): HostDirent[];
+/** The current host's `path` — `path.join(…)` / `path.sep` exactly as with `node:path`. */
+export declare const path: HostPath;
+/** The current host's `createHash` — `createHash('md5').update(s).digest('hex')`. */
+export declare function createHash(algo: string): HostHasher;

package/dist/compiler/host.js

@@ -0,0 +1,51 @@
+import { createRequire } from "node:module";
+// src/compiler/host.ts
+/**
+* The compiler's HOST environment — the filesystem, path, and hash primitives it reaches for. Node is
+* the default (the shipped Vite plugin uses real `node:fs` / `node:path` / `node:crypto`, unchanged and
+* at full speed); a BROWSER build (the Observatory REPL / `compiler/browser`) installs a virtual host via
+* {@link set_host} — an in-memory filesystem over the workspace file-map, `path`-browserify, and a small
+* md5/sha implementation — so the SAME compiler runs in-browser with no bundler shims.
+*
+* This is the same seam as {@link ./parse/oxc.ts set_parser}: a settable singleton, defaulting to Node,
+* that keeps the driver bundler- and platform-agnostic. `fs` and `path` are exposed as thin proxies over
+* the current host so call-sites read exactly as before (`fs.readFileSync(…)`, `path.join(…)`) — the get
+* indirection is off the token-hot path (the transform's own reads go through the injected `HostCtx`, not
+* this), so it costs the Node build nothing measurable.
+*/
+let node_host;
+function node_default() {
+	if (!node_host) {
+		const require = createRequire(import.meta.url);
+		node_host = {
+			fs: require("node:fs"),
+			path: require("node:path"),
+			crypto: require("node:crypto")
+		};
+	}
+	return node_host;
+}
+let current = null;
+function host() {
+	return current ?? node_default();
+}
+/**
+* Install a browser (or test) host. No-arg resets to the Node default. Call once, before the first
+* compile: the browser worker builds a virtual host over its workspace file-map and installs it here.
+*/
+function set_host(h) {
+	current = h ?? null;
+}
+/** The current host's `fs` — read `fs.readFileSync(…)` exactly as with `node:fs`. */
+const fs = new Proxy({}, { get: (_t, key) => host().fs[key] });
+/** The entries of `dir` on the current host (`readdirSync(dir, { withFileTypes: true })`). */
+function dir_entries(dir) {
+	return fs.readdirSync(dir, { withFileTypes: true });
+}
+/** The current host's `path` — `path.join(…)` / `path.sep` exactly as with `node:path`. */
+const path = new Proxy({}, { get: (_t, key) => host().path[key] });
+/** The current host's `createHash` — `createHash('md5').update(s).digest('hex')`. */
+function createHash(algo) {
+	return host().crypto.createHash(algo);
+}
+export { createHash, dir_entries, fs, path, set_host };

package/dist/compiler/ids.d.ts

@@ -0,0 +1,84 @@
+/**
+ * The `virtual:ogygia/*` id vocabulary — every virtual module id the compiler mints or serves, the
+ * `\0`-prefix resolver, and the per-island entry-id naming. Pure string constants + naming functions,
+ * no state: the shared vocabulary the driver's resolve/emit dispatch and the linker key on.
+ */
+export declare const V_RUNTIME_URL = "virtual:ogygia/runtime-url";
+export declare const V_MANIFEST = "virtual:ogygia/manifest";
+export declare const V_RUNTIME = "virtual:ogygia-runtime";
+/** Generated sticky entry — static-imports only the features selected from build marks. */
+export declare const V_RUNTIME_ENTRY = "virtual:ogygia/runtime-entry";
+/** Generated hydrate-phase feature module — imported statically by the hydrate core (link/runtime-entry.ts). */
+export declare const V_HYDRATE_FEATURES = "virtual:ogygia/hydrate-features";
+export declare const V_DEV_HMR = "virtual:ogygia/dev-hmr";
+export declare const V_DEV_HMR_URL = "virtual:ogygia/dev-hmr-url";
+export declare const V_DEVTOOLS_BOOT = "virtual:ogygia/devtools-boot";
+export declare const V_DEVTOOLS_BOOT_URL = "virtual:ogygia/devtools-boot-url";
+export declare const V_DEVTOOLS_META = "virtual:ogygia/devtools-meta";
+export declare const V_ISLAND_DEPS = "virtual:ogygia/island-deps";
+export declare const V_FN_MANIFEST = "virtual:ogygia/fn-manifest";
+export declare const V_SECRET = "virtual:ogygia/secret";
+export declare const V_SIGN = "virtual:ogygia/sign";
+export declare const V_RATE_LIMIT = "virtual:ogygia/rate-limit";
+/** The app's plugins' SERVER halves, statically imported in plugin order.
+ *  SERVER only; the client gets an empty list. */
+export declare const V_SERVER_PLUGINS = "virtual:ogygia/server-plugins";
+/** THE PROFILER'S MAPS, carried as code: the server build's module map and every server chunk's
+ *  sourcemap, written into this module's chunk after the build (a file read by path does not survive
+ *  an adapter that traces imports or re-bundles; an import does). Imported only by the profiler, only
+ *  when it resolves a frame. Build + SSR + profiler on: the placeholder below, filled in closeBundle */
+export declare const V_PROFILER_MAPS = "virtual:ogygia/profiler-maps";
+/** the string the maps module exports until the build fills it (build-time only: never in runtime code,
+ *  so the one literal in the output is the one to replace) */
+export declare const PROFILER_MAPS_PLACEHOLDER = "__ogygia_profiler_maps_placeholder__";
+/** the filled maps payload's mark: gzipped JSON, base64 (vite/profiler-maps.ts writes it, the
+ *  profiler's embedded-maps reads it) */
+export declare const PROFILER_MAPS_GZ_PREFIX = "gz:";
+export declare const V_SESSION_COOKIE = "virtual:ogygia/session-cookie";
+export declare const V_REGION_TTL = "virtual:ogygia/region-ttl";
+export declare const V_ROUTER_CONFIG = "virtual:ogygia/router-config";
+/** Generated component→CSS registrations for the SERVER router — the module that makes a router
+ *  page's `<style>` reach the document (see link/router-css.ts). SSR-only, imported by `ogygia/plugin/css`. */
+export declare const V_ROUTER_CSS = "virtual:ogygia/router-css";
+export declare const V_SERVER_MANIFEST = "virtual:ogygia/server-manifest";
+/** The server islands' loaders (`id → () => import(entry)`), reached only through the manifest's
+ *  `load_islands()` — see link/server-manifest.ts for why they live one dynamic import away. */
+export declare const V_SERVER_ISLANDS = "virtual:ogygia/server-islands";
+export declare const V_REQUEST_EVENT = "virtual:ogygia/request-event";
+/** SSR-only map of csr=true route ids — lets Region degrade a csr=false layout's islands to inline
+ *  when the LEAF page is csr=true (Kit hydrates the whole document). Client leg is an empty set;
+ *  the client uses `kit_hydrates_page()` for the identical signal. */
+export declare const V_ROUTE_CSR = "virtual:ogygia/route-csr";
+export declare const V_REGION_ENDPOINT = "virtual:ogygia/region-endpoint";
+export declare const V_KIT_WIRE = "virtual:ogygia/kit-wire";
+export declare const V_TRANSPORT = "virtual:ogygia/transport";
+/** The app's Kit `transport` hook (`ogygia.transport`), generated per-app: the codec cluster when the
+ *  app crosses regions/wired-values over the wire, an empty map for a pure-island app (no dead codecs). */
+export declare const V_KIT_TRANSPORT = "virtual:ogygia/kit-transport";
+export declare const V_TRANSPORTABLES = "virtual:ogygia/transportables";
+/** What an island entry imports for the transportable codecs: the SERVER's eager registration (the
+ *  region endpoint decodes signed props of any island); empty in the browser, where the runtime
+ *  loads an island's classes from `V_TRANSPORTABLES`' lazy map. */
+export declare const V_TRANSPORTABLES_EAGER = "virtual:ogygia/transportables-eager";
+/** Every Kit page route id → the keys plugins claim inside Kit's `config` page option, merged
+ *  (`b.routeConfig`). SERVER only (empty on the client; the route list never ships to the browser). */
+export declare const V_ROUTE_CONFIG = "virtual:ogygia/route-config";
+/** Resolve a virtual id to its `\0`-prefixed resolved form (Vite/rollup convention). */
+export declare const RESOLVED: (id: string) => string;
+/** Virtual island ENTRY module id — JS re-export of the real component (not a thin .svelte). */
+export declare const islandVirtualId: (iid: string) => string;
+/**
+ * Region-binding module id. A `with { region: 'raw' }` import is rewritten to import this JS
+ * module, whose source is leg-split by the plugin `load` hook: the SSR leg carries the server
+ * signer (so `region()` can mint a capability), the client leg is metadata-only (no server
+ * code crosses into the browser bundle).
+ */
+export declare const regionBindingVirtualId: (iid: string) => string;
+/**
+ * The wake island wrapper's CLIENT-leg component source — the leg-split twin of the wrapper: the SSR
+ * wrapper imports the island entry (it must render), the client wrapper imports THIS, a module that
+ * imports the entry only when the document rendered the island (emit.ts `lazy_entry_source`). It is
+ * how a csr=true host's page graph stops at the wrapper, the same rule the csr=false registry stub
+ * applies one level up: what a page ships is decided by what it RENDERED, never by its import graph.
+ */
+export declare const lazyEntryVirtualId: (iid: string) => string;

package/dist/compiler/ids.js

@@ -0,0 +1,86 @@
+// src/compiler/ids.ts
+/**
+* The `virtual:ogygia/*` id vocabulary — every virtual module id the compiler mints or serves, the
+* `\0`-prefix resolver, and the per-island entry-id naming. Pure string constants + naming functions,
+* no state: the shared vocabulary the driver's resolve/emit dispatch and the linker key on.
+*/
+const V_RUNTIME_URL = "virtual:ogygia/runtime-url";
+const V_MANIFEST = "virtual:ogygia/manifest";
+const V_RUNTIME = "virtual:ogygia-runtime";
+/** Generated sticky entry — static-imports only the features selected from build marks. */
+const V_RUNTIME_ENTRY = "virtual:ogygia/runtime-entry";
+/** Generated hydrate-phase feature module — imported statically by the hydrate core (link/runtime-entry.ts). */
+const V_HYDRATE_FEATURES = "virtual:ogygia/hydrate-features";
+const V_DEV_HMR = "virtual:ogygia/dev-hmr";
+const V_DEV_HMR_URL = "virtual:ogygia/dev-hmr-url";
+const V_DEVTOOLS_BOOT = "virtual:ogygia/devtools-boot";
+const V_DEVTOOLS_BOOT_URL = "virtual:ogygia/devtools-boot-url";
+const V_DEVTOOLS_META = "virtual:ogygia/devtools-meta";
+const V_ISLAND_DEPS = "virtual:ogygia/island-deps";
+const V_FN_MANIFEST = "virtual:ogygia/fn-manifest";
+const V_SECRET = "virtual:ogygia/secret";
+const V_SIGN = "virtual:ogygia/sign";
+const V_RATE_LIMIT = "virtual:ogygia/rate-limit";
+/** The app's plugins' SERVER halves, statically imported in plugin order.
+*  SERVER only; the client gets an empty list. */
+const V_SERVER_PLUGINS = "virtual:ogygia/server-plugins";
+/** THE PROFILER'S MAPS, carried as code: the server build's module map and every server chunk's
+*  sourcemap, written into this module's chunk after the build (a file read by path does not survive
+*  an adapter that traces imports or re-bundles; an import does). Imported only by the profiler, only
+*  when it resolves a frame. Build + SSR + profiler on: the placeholder below, filled in closeBundle */
+const V_PROFILER_MAPS = "virtual:ogygia/profiler-maps";
+/** the string the maps module exports until the build fills it (build-time only: never in runtime code,
+*  so the one literal in the output is the one to replace) */
+const PROFILER_MAPS_PLACEHOLDER = "__ogygia_profiler_maps_placeholder__";
+/** the filled maps payload's mark: gzipped JSON, base64 (vite/profiler-maps.ts writes it, the
+*  profiler's embedded-maps reads it) */
+const PROFILER_MAPS_GZ_PREFIX = "gz:";
+const V_SESSION_COOKIE = "virtual:ogygia/session-cookie";
+const V_REGION_TTL = "virtual:ogygia/region-ttl";
+const V_ROUTER_CONFIG = "virtual:ogygia/router-config";
+/** Generated component→CSS registrations for the SERVER router — the module that makes a router
+*  page's `<style>` reach the document (see link/router-css.ts). SSR-only, imported by `ogygia/plugin/css`. */
+const V_ROUTER_CSS = "virtual:ogygia/router-css";
+const V_SERVER_MANIFEST = "virtual:ogygia/server-manifest";
+/** The server islands' loaders (`id → () => import(entry)`), reached only through the manifest's
+*  `load_islands()` — see link/server-manifest.ts for why they live one dynamic import away. */
+const V_SERVER_ISLANDS = "virtual:ogygia/server-islands";
+const V_REQUEST_EVENT = "virtual:ogygia/request-event";
+/** SSR-only map of csr=true route ids — lets Region degrade a csr=false layout's islands to inline
+*  when the LEAF page is csr=true (Kit hydrates the whole document). Client leg is an empty set;
+*  the client uses `kit_hydrates_page()` for the identical signal. */
+const V_ROUTE_CSR = "virtual:ogygia/route-csr";
+const V_REGION_ENDPOINT = "virtual:ogygia/region-endpoint";
+const V_KIT_WIRE = "virtual:ogygia/kit-wire";
+const V_TRANSPORT = "virtual:ogygia/transport";
+/** The app's Kit `transport` hook (`ogygia.transport`), generated per-app: the codec cluster when the
+*  app crosses regions/wired-values over the wire, an empty map for a pure-island app (no dead codecs). */
+const V_KIT_TRANSPORT = "virtual:ogygia/kit-transport";
+const V_TRANSPORTABLES = "virtual:ogygia/transportables";
+/** What an island entry imports for the transportable codecs: the SERVER's eager registration (the
+*  region endpoint decodes signed props of any island); empty in the browser, where the runtime
+*  loads an island's classes from `V_TRANSPORTABLES`' lazy map. */
+const V_TRANSPORTABLES_EAGER = "virtual:ogygia/transportables-eager";
+/** Every Kit page route id → the keys plugins claim inside Kit's `config` page option, merged
+*  (`b.routeConfig`). SERVER only (empty on the client; the route list never ships to the browser). */
+const V_ROUTE_CONFIG = "virtual:ogygia/route-config";
+/** Resolve a virtual id to its `\0`-prefixed resolved form (Vite/rollup convention). */
+const RESOLVED = (id) => "\0" + id;
+/** Virtual island ENTRY module id — JS re-export of the real component (not a thin .svelte). */
+const islandVirtualId = (iid) => `virtual:ogygia/island/${iid}.js`;
+/**
+* Region-binding module id. A `with { region: 'raw' }` import is rewritten to import this JS
+* module, whose source is leg-split by the plugin `load` hook: the SSR leg carries the server
+* signer (so `region()` can mint a capability), the client leg is metadata-only (no server
+* code crosses into the browser bundle).
+*/
+const regionBindingVirtualId = (iid) => `virtual:ogygia/region/${iid}.js`;
+/**
+* The wake island wrapper's CLIENT-leg component source — the leg-split twin of the wrapper: the SSR
+* wrapper imports the island entry (it must render), the client wrapper imports THIS, a module that
+* imports the entry only when the document rendered the island (emit.ts `lazy_entry_source`). It is
+* how a csr=true host's page graph stops at the wrapper, the same rule the csr=false registry stub
+* applies one level up: what a page ships is decided by what it RENDERED, never by its import graph.
+*/
+const lazyEntryVirtualId = (iid) => `virtual:ogygia/lazy/${iid}.js`;
+export { PROFILER_MAPS_GZ_PREFIX, 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_KIT_WIRE, 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, islandVirtualId, lazyEntryVirtualId, regionBindingVirtualId };

package/dist/compiler/index.d.ts

@@ -0,0 +1,11 @@
+import { CLIENT_BINDING_STUB, DEFAULT_IMPORT_KEYS, ISLAND_DIR, ImportKeys, asRegionLocals, import_keys_hint, is_island_path, islandChunkFileName, islandId, islandPublicUrl, normalize_hydrate_value, normalize_import_keys, normalize_region_value, transformHost, transformTsRegions, wrapperVirtualId } from "./region/transform.js";
+import { RawParse, set_parser } from "./parse/oxc.js";
+import { CssReachOptions, FOUC_CSS_PREFIX, FOUC_SCOPED_PREFIX, FoucAlias, buildFoucCssModuleSource, collectFoucCssReachable, compileFoucScopedCss, foucCssVirtualId, foucRelFromId, foucScopedVirtualId, isFoucCssId, isFoucScopedId, listStaticImports, resolveFoucImportSpec, svelteHasStyle } from "./fouc-css.js";
+import { regionId, regionIdentity, strategyKey } from "./region/identity.js";
+import { collectCaptureInfo, collectFreeIdentifiers, collectSnippetNames } from "./free-vars.js";
+import { Compiler, Profiler } from "./driver.js";
+import { Program, host_key, strip_id } from "./program.js";
+import { CompileCtx, CompileCtxInit } from "./ctx.js";
+import { PROFILER_MAPS_GZ_PREFIX, 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_KIT_WIRE, 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, islandVirtualId, lazyEntryVirtualId, regionBindingVirtualId } from "./ids.js";
+import { FLAGS_SPEC, FlagSite, collect_flag_sites, flags_manifest } from "./flags.js";
+export { CLIENT_BINDING_STUB, CompileCtx, type CompileCtxInit, Compiler, CssReachOptions, DEFAULT_IMPORT_KEYS, FLAGS_SPEC, FOUC_CSS_PREFIX, FOUC_SCOPED_PREFIX, type FlagSite, FoucAlias, ISLAND_DIR, ImportKeys, PROFILER_MAPS_GZ_PREFIX, PROFILER_MAPS_PLACEHOLDER, type Profiler, Program, RESOLVED, type RawParse, 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_KIT_WIRE, 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, asRegionLocals, buildFoucCssModuleSource, collectCaptureInfo, collectFoucCssReachable, collectFreeIdentifiers, collectSnippetNames, collect_flag_sites, compileFoucScopedCss, flags_manifest, foucCssVirtualId, foucRelFromId, foucScopedVirtualId, host_key, import_keys_hint, isFoucCssId, isFoucScopedId, is_island_path, islandChunkFileName, islandId, islandPublicUrl, islandVirtualId, lazyEntryVirtualId, listStaticImports, normalize_hydrate_value, normalize_import_keys, normalize_region_value, regionBindingVirtualId, regionId, regionIdentity, resolveFoucImportSpec, set_parser, strategyKey, strip_id, svelteHasStyle, transformHost, transformTsRegions, wrapperVirtualId };

package/dist/compiler/index.js

@@ -0,0 +1,11 @@
+import { CLIENT_BINDING_STUB, DEFAULT_IMPORT_KEYS, ISLAND_DIR, asRegionLocals, import_keys_hint, is_island_path, islandChunkFileName, islandId, islandPublicUrl, normalize_hydrate_value, normalize_import_keys, normalize_region_value, transformHost, transformTsRegions, wrapperVirtualId } from "./region/transform.js";
+import { set_parser } from "./parse/oxc.js";
+import { FOUC_CSS_PREFIX, FOUC_SCOPED_PREFIX, buildFoucCssModuleSource, collectFoucCssReachable, compileFoucScopedCss, foucCssVirtualId, foucRelFromId, foucScopedVirtualId, isFoucCssId, isFoucScopedId, listStaticImports, resolveFoucImportSpec, svelteHasStyle } from "./fouc-css.js";
+import { regionId, regionIdentity, strategyKey } from "./region/identity.js";
+import { collectCaptureInfo, collectFreeIdentifiers, collectSnippetNames } from "./free-vars.js";
+import { Compiler } from "./driver.js";
+import { Program, host_key, strip_id } from "./program.js";
+import { CompileCtx } from "./ctx.js";
+import { PROFILER_MAPS_GZ_PREFIX, 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_KIT_WIRE, 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, islandVirtualId, lazyEntryVirtualId, regionBindingVirtualId } from "./ids.js";
+import { FLAGS_SPEC, collect_flag_sites, flags_manifest } from "./flags.js";
+export { CLIENT_BINDING_STUB, CompileCtx, Compiler, DEFAULT_IMPORT_KEYS, FLAGS_SPEC, FOUC_CSS_PREFIX, FOUC_SCOPED_PREFIX, ISLAND_DIR, PROFILER_MAPS_GZ_PREFIX, PROFILER_MAPS_PLACEHOLDER, Program, 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_KIT_WIRE, 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, asRegionLocals, buildFoucCssModuleSource, collectCaptureInfo, collectFoucCssReachable, collectFreeIdentifiers, collectSnippetNames, collect_flag_sites, compileFoucScopedCss, flags_manifest, foucCssVirtualId, foucRelFromId, foucScopedVirtualId, host_key, import_keys_hint, isFoucCssId, isFoucScopedId, is_island_path, islandChunkFileName, islandId, islandPublicUrl, islandVirtualId, lazyEntryVirtualId, listStaticImports, normalize_hydrate_value, normalize_import_keys, normalize_region_value, regionBindingVirtualId, regionId, regionIdentity, resolveFoucImportSpec, set_parser, strategyKey, strip_id, svelteHasStyle, transformHost, transformTsRegions, wrapperVirtualId };