@ogygia/core 0.0.0 → 0.11.1

package/dist/compiler/content/transportables.js

@@ -0,0 +1,219 @@
+import { parse_module } from "../parse/oxc.js";
+// src/compiler/content/transportables.ts
+/**
+* Registration for transportable classes (`static [import.meta.og.wire]` codecs).
+*
+* Registers ONLY exported classes that actually carry a wire codec — NOT every exported class.
+* A plain `export class Foo {}` must never be registered, because the registration appends an
+* `import … from 'ogygia/internal/register'`, and dragging that into an unrelated module (or a
+* workspace package that doesn't even depend on ogygia) breaks its resolution for nothing.
+* Detection is exact, not heuristic: by the time this runs the wire macro has already normalized
+* `static wire = import.meta.og.wire(…)` into `static [Symbol.for('ogygia.wire')] = …`, so a class
+* is transportable iff it has that member (the pre-rewrite call form is matched too, defensively).
+* The macro is name-locked to `static wire`, so there is exactly one shape to find — no aliasing.
+*
+* Tags are root-relative module path + export name: identical in the server build and every
+* island bundle with zero coordination. Registrations import from `ogygia/internal` — a
+* re-export barrel, so tree-shaking keeps island component code out of a tagged `.svelte.ts`
+* state chunk.
+*
+* Constraint: a top-level `export class X` (declaration or `export { X }`). Default exports
+* and class expressions have no stable name to tag by.
+*/
+const CLASS_KW = /\bclass\b/;
+const WIRE_STATIC_MEMBER = /\bstatic\s+#?\w+\s*=\s*import\.meta\.og\.wire\b/;
+const MODULE_KW = /\bmodule\b/;
+const CONTEXT_MODULE_ATTR = /context\s*=\s*["']module["']/;
+const SVELTE_EXT = /\.svelte$/;
+/** Every `<script …>…<\/script>` block (shared `g` regex — reset `lastIndex` per scan). */
+const SCRIPT_BLOCK_G = /<script\b([^>]*)>([\s\S]*?)<\/script>/g;
+/** Marker that a module already carries generated registrations (idempotence). */
+const GENERATED_MARK = "// ogygia: generated registration (transportable codecs + createContext tags)";
+/** Parse a module to its top-level statements once (TS/JS inferred from `id_n`); null on error. */
+function parse_body(code, id_n) {
+	try {
+		const result = parse_module(code, id_n);
+		if (!result.ok || !result.program) return null;
+		return result.program.body ?? [];
+	} catch {
+		return null;
+	}
+}
+/** Collect names of top-level exported classes that carry a wire codec (and only those). */
+function exportedWireClassNames(code, id_n) {
+	const body = parse_body(code, id_n);
+	return body ? exportedWireClassNamesFromBody(body) : [];
+}
+function exportedWireClassNamesFromBody(body) {
+	const classNodes = /* @__PURE__ */ new Map();
+	const exported = /* @__PURE__ */ new Set();
+	for (const node of body) if (node.type === "ClassDeclaration" && node.id) classNodes.set(node.id.name, node);
+	else if (node.type === "ExportNamedDeclaration") {
+		if (node.declaration?.type === "ClassDeclaration" && node.declaration.id?.name) {
+			classNodes.set(node.declaration.id.name, node.declaration);
+			exported.add(node.declaration.id.name);
+		}
+		if (!node.source) {
+			for (const spec of node.specifiers ?? []) if (spec.local?.type === "Identifier") exported.add(spec.local.name);
+		}
+	}
+	return [...exported].filter((name) => {
+		const cls = classNodes.get(name);
+		return !!cls && classHasWireMember(cls);
+	});
+}
+/**
+* A class carrying a wire codec. Post-macro (the usual case here — macros run before this pass):
+* `static [Symbol.for('ogygia.wire')] = …`. Pre-macro, defensively: `static <name> =
+* import.meta.og.wire(…)`. Anything else is a plain class and must NOT be registered.
+*/
+function classHasWireMember(cls) {
+	return (cls.body?.body ?? []).some((m) => {
+		if (m.static !== true) return false;
+		if (m.computed === true && isWireSymbolKey(m.key)) return true;
+		return isWireMacroCall(m.value);
+	});
+}
+/** `Symbol.for('ogygia.wire')` — the computed key the wire macro emits. */
+function isWireSymbolKey(key) {
+	const k = key;
+	if (k?.type !== "CallExpression") return false;
+	const callee = k.callee;
+	if (callee?.type !== "MemberExpression" || callee.object?.name !== "Symbol" || callee.property?.name !== "for") return false;
+	const arg = k.arguments?.[0];
+	return !!arg && (arg.type === "StringLiteral" || arg.type === "Literal") && arg.value === "ogygia.wire";
+}
+/** `import.meta.og.wire(…)` — the raw construct, before the macro rewrites it to the symbol key. */
+function isWireMacroCall(value) {
+	const v = value;
+	if (v?.type !== "CallExpression") return false;
+	const callee = v.callee;
+	if (callee?.type !== "MemberExpression" || callee.computed || callee.property?.name !== "wire") return false;
+	const og = callee.object;
+	if (og?.type !== "MemberExpression" || og.computed || og.property?.name !== "og") return false;
+	const meta = og.object;
+	return meta?.type === "MetaProperty" && meta.meta?.name === "import" && meta.property?.name === "meta";
+}
+/**
+* Exported consts whose initializer is a `createContext(...)` call — `export const cart =
+* createContext<Cart>()`. Tagged by `module#export` so a provider and every consumer island agree
+* on the context identity (same alias-proof scheme as `wire`). Covers `createContext(...)` and
+* `<ns>.createContext(...)`.
+*/
+function contextExportNamesFromBody(body) {
+	const names = [];
+	for (const node of body) {
+		if (node.type !== "ExportNamedDeclaration") continue;
+		const decl = node.declaration;
+		if (!decl || decl.type !== "VariableDeclaration") continue;
+		for (const d of decl.declarations ?? []) {
+			const init = d.init;
+			if (d.id?.type !== "Identifier" || !d.id.name || init?.type !== "CallExpression") continue;
+			const callee = init.callee;
+			if (callee?.type === "Identifier" && callee.name === "createContext" || callee?.type === "MemberExpression" && callee.property?.name === "createContext") names.push(d.id.name);
+		}
+	}
+	return names;
+}
+/**
+* Does this module define an exported class carrying a transportable codec? Used to build
+* the eager-registration manifest so islands never need a manual `import` of the class.
+*
+* Signal: an exported class with a `static` member whose key is COMPUTED (`static [x] = …` /
+* `static [x]() {}`) — every rewritten wire member is exactly that — OR, pre-rewrite, the
+* `import.meta.og.wire` construct marker (prescan reads RAW source, where the blessed spelling
+* `static wire = import.meta.og.wire()` is not yet a computed member). A false positive (an
+* unrelated computed static, the marker in a comment) only eagerly loads one extra module; a
+* transportable class is never missed.
+*/
+function moduleHasTransportable(code, id_n) {
+	if (!CLASS_KW.test(code) || !code.includes("static")) return false;
+	if (WIRE_STATIC_MEMBER.test(code)) return true;
+	let body;
+	try {
+		const result = parse_module(code, id_n);
+		if (!result.ok || !result.program) return false;
+		body = result.program.body ?? [];
+	} catch {
+		return false;
+	}
+	const isTransportableClass = (cls) => {
+		return ((cls?.body)?.body ?? []).some((m) => m.static === true && m.computed === true);
+	};
+	for (const node of body) {
+		if (node.type === "ClassDeclaration" && isTransportableClass(node)) return true;
+		if (node.type === "ExportNamedDeclaration" && node.declaration?.type === "ClassDeclaration" && isTransportableClass(node.declaration)) return true;
+	}
+	return false;
+}
+/**
+* Append `__register_transportable` calls for every exported class in this module. Returns
+* the augmented code, or null when there is no exported class. Append-only — the module's
+* existing sourcemap stays valid.
+*/
+function appendTransportRegistrations(code, id_n, root, pathModule) {
+	if (code.includes(GENERATED_MARK)) return null;
+	const maybeClass = CLASS_KW.test(code);
+	const maybeCtx = code.includes("createContext");
+	if (!maybeClass && !maybeCtx) return null;
+	const body = parse_body(code, id_n);
+	if (!body) return null;
+	const classes = maybeClass ? exportedWireClassNamesFromBody(body) : [];
+	const contexts = maybeCtx ? contextExportNamesFromBody(body) : [];
+	if (classes.length === 0 && contexts.length === 0) return null;
+	return code + registrationBlock(pathModule.relative(root, id_n).split("\\").join("/"), classes, contexts) + "\n";
+}
+function registrationBlock(rel, classes, contexts) {
+	const imports = [];
+	if (classes.length) imports.push("__register_transportable as __OGT");
+	if (contexts.length) imports.push("__tag_context as __OGC");
+	const lines = [
+		"",
+		"// ogygia: generated registration (transportable codecs + createContext tags)",
+		`import { ${imports.join(", ")} } from 'ogygia/internal/register';`
+	];
+	for (const name of classes) lines.push(`__OGT(${JSON.stringify(rel + "#" + name)}, ${name});`);
+	for (const name of contexts) lines.push(`__OGC(${JSON.stringify(rel + "#" + name)}, ${name});`);
+	return lines.join("\n");
+}
+/**
+* A `.svelte` component can `export class X` from its `<script module>` (instance-`<script>`
+* classes can't be exported, so they never travel). Find the module script and treat its
+* body like any other module: same detection, same registration, injected before the block's
+* closing tag. The class is tagged by the `.svelte` path, and the manifest side-effect-imports
+* the component to run that registration on the client.
+*/
+function moduleScriptOf(code) {
+	SCRIPT_BLOCK_G.lastIndex = 0;
+	let m;
+	while ((m = SCRIPT_BLOCK_G.exec(code)) !== null) {
+		const attrs = m[1];
+		if (MODULE_KW.test(attrs) || CONTEXT_MODULE_ATTR.test(attrs)) {
+			const bodyStart = m.index + m[0].indexOf(">", 0) + 1;
+			const bodyEnd = SCRIPT_BLOCK_G.lastIndex - 9;
+			return {
+				body: code.slice(bodyStart, bodyEnd),
+				injectAt: bodyEnd
+			};
+		}
+	}
+	return null;
+}
+/** True if a `.svelte` file's `<script module>` exports a transportable class. */
+function svelteModuleHasTransportable(code, id_n) {
+	if (!code.includes("module") || !CLASS_KW.test(code)) return false;
+	const mod = moduleScriptOf(code);
+	if (!mod) return false;
+	return moduleHasTransportable(mod.body, id_n.replace(SVELTE_EXT, ".svelte.ts"));
+}
+/** Inject registration for a `.svelte` module script's exported transportable classes. */
+function appendSvelteModuleRegistrations(code, id_n, root, pathModule) {
+	if (code.includes(GENERATED_MARK) || !CLASS_KW.test(code)) return null;
+	const mod = moduleScriptOf(code);
+	if (!mod) return null;
+	const exported = exportedWireClassNames(mod.body, id_n.replace(SVELTE_EXT, ".svelte.ts"));
+	if (exported.length === 0) return null;
+	const block = "\n" + registrationBlock(pathModule.relative(root, id_n).split("\\").join("/"), exported, []) + "\n";
+	return code.slice(0, mod.injectAt) + block + code.slice(mod.injectAt);
+}
+export { appendSvelteModuleRegistrations, appendTransportRegistrations, moduleHasTransportable, svelteModuleHasTransportable };

package/dist/compiler/ctx.d.ts

@@ -0,0 +1,185 @@
+import { ServerRealm } from "./link/caps.js";
+import { PluginMacro } from "./macros/pipeline.js";
+import { ImportKeys } from "./region/transform.js";
+/** One dependency package's declared compile surface (`"ogygia": { "files": […] }` in ITS
+ *  package.json) — produced by the plugin's discovery (`vite/package-files.ts`), consumed here
+ *  type-only: the compiler stays browser-host-clean, so the node:fs/glob work lives plugin-side.
+ *  All paths are posix REALPATHS — Vite resolves ids through symlinks (pnpm), so gate matching
+ *  must speak real paths or every check silently misses. */
+export interface PackageScan {
+  /** The package's published name — the stable identity prefix for its regions. */
+  name: string;
+  /** realpath of the package root. */
+  root: string;
+  /** Declared bare directories (prefix-matched, so files added mid-dev still count). */
+  dirs: string[];
+  /** Individually declared / glob-expanded files. */
+  files: string[];
+}
+export interface CompileCtxInit {
+  root: string;
+  base: string;
+  /** SvelteKit `config.kit.appDir` (default `_app`) — the dir Kit emits AND serves its immutable
+   *  assets under. ogygia's runtime + island chunks MUST land here too: a custom appDir otherwise
+   *  404s them (Kit's adapter only maps `<appDir>/immutable/*` to the immutable-cache route). Read
+   *  from Kit's `__SVELTEKIT_APP_DIR__` build define; `_app` when Kit isn't present (standalone).
+   *  NOTE: only the app-internal PATH lives here. `base` / `paths.assets` (CDN) resolution is Kit's
+   *  `asset()`'s job — `Region.svelte` runs every baked entry / runtime URL through it at SSR — so
+   *  ogygia never bakes a base into these URLs (doing so double-applies it). */
+  app_dir: string;
+  libDir: string;
+  /** A plugin asked for the build's measurement data (`b.measure()`: the profiler) — embedded maps,
+   *  per-island detail. */
+  measure: boolean;
+  /** The server halves of the app's plugins (module path + options), in app order — baked into
+   *  `virtual:ogygia/server-plugins`. Optional (default none). */
+  server_plugins?: readonly ServerRealm[];
+  /** The browser halves of the app's plugins (absolute module paths), in app order —
+   *  imported by the runtime's boot. Optional (default none). */
+  client_plugins?: readonly string[];
+  /** The keys the plugins claim inside Kit's `config` page option (`b.routeConfig`) — read from the
+   *  route files and baked into `virtual:ogygia/route-config`. Optional (default none). */
+  route_config?: readonly string[];
+  /** A plugin asked island entries to keep their foreign-hydrate exports (`b.foreignHydrate()`:
+   *  another app's runtime wakes this app's islands). Optional (default off). */
+  foreign_hydrate?: boolean;
+  /** Dependency packages that DECLARED their ogygia compile surface (`"ogygia": { "files": […] }`
+   *  in THEIR package.json) — prescanned + transformed like app source, node_modules gates lifted
+   *  for exactly these paths. Optional (default none): standalone/browser hosts have no
+   *  node_modules to declare from. */
+  pkg_scan?: PackageScan[];
+  /** PAGE MODULES (`b.pageModules()`): modules that render pages outside Kit's routes, whose reachable
+   *  components get router-css. `page_importers`: a compiled module importing one of these specifiers
+   *  is one; `page_files`: absolute paths that are page modules themselves. Optional (default none). */
+  page_importers?: readonly string[];
+  page_files?: readonly string[];
+  is_dev: boolean;
+  id_salt: string;
+  visibleMargin: string | undefined;
+  presets: Record<string, unknown>;
+  import_keys: ImportKeys;
+  /** Resolved Vite aliases (used by the `bake` macro to bundle the imports a baked fn touches). */
+  resolve_alias: unknown[];
+  /** The plugins' `import.meta.og.*` macros (`b.macro`), in plugin order. Optional (default none). */
+  macros?: readonly PluginMacro[];
+  /** ogygia's own package root — the `auto_brand` macro skips ogygia source (it can't self-register). */
+  pkg_root: string;
+  /** Per-build HMAC material baked into the SSR-only `virtual:ogygia/secret`. */
+  build_secret: string;
+  /** Region-endpoint rate limit (SSR-only), `{ max: 0 }` when disabled. */
+  rate_limit: {
+    max: number;
+    windowMs: number;
+  };
+  /** Cookie name sealed into the region MAC, or '' when unbound. */
+  session_cookie: string;
+  /** Capability-URL TTL in seconds. */
+  region_ttl: number;
+  /** How long after expiry an anonymous capability still renews, in seconds (`0` = never). */
+  renew_window: number;
+  /** Router on (app-wide). `false` tree-shakes the feature out. */
+  router_enabled: boolean;
+  /** View Transitions on for SPA navs. */
+  router_view_transitions: boolean;
+  /** The app's `src/hooks.client.{ts,js}` absolute path, or null — its `init` runs on boot for
+   *  csr=false pages (see runtime/client-hooks.ts). */
+  client_hooks?: string | null;
+  /** Package-internal absolute paths the emit inlines into generated virtual sources. */
+  runtime_dir: string;
+  runtime_hash: string;
+  hmac_module: string;
+  region_endpoint_module: string;
+  client_binding_stub_file: string;
+  /** `$app/*` → on-disk client-shim path map (island modules under csr=false). */
+  app_shims: Record<string, string>;
+  /** `command === 'build'` — gates the transform-time deterministic island-chunk emit. */
+  is_build: boolean;
+  /** Core's event emits compiled in (a plugin's `b.events()`: devtools). Bakes the standalone dock
+   *  boot for csr=true pages into `virtual:ogygia/devtools-boot-url`. */
+  devtools: boolean;
+}
+export declare class CompileCtx {
+  #private;
+  readonly root: string;
+  readonly base: string;
+  readonly app_dir: string;
+  readonly libDir: string;
+  readonly pkg_scan: PackageScan[];
+  readonly page_importers: readonly string[];
+  readonly page_files: readonly string[];
+  readonly measure: boolean;
+  readonly server_plugins: readonly ServerRealm[];
+  readonly client_plugins: readonly string[];
+  readonly route_config: readonly string[];
+  readonly foreign_hydrate: boolean;
+  readonly is_dev: boolean;
+  readonly id_salt: string;
+  readonly visibleMargin: string | undefined;
+  readonly presets: Record<string, unknown>;
+  readonly import_keys: ImportKeys;
+  readonly resolve_alias: unknown[];
+  readonly macros: readonly PluginMacro[];
+  readonly pkg_root: string;
+  readonly build_secret: string;
+  readonly rate_limit: {
+    max: number;
+    windowMs: number;
+  };
+  readonly session_cookie: string;
+  readonly region_ttl: number;
+  readonly renew_window: number;
+  readonly router_enabled: boolean;
+  readonly router_view_transitions: boolean;
+  readonly client_hooks: string | null;
+  readonly runtime_dir: string;
+  readonly runtime_hash: string;
+  readonly hmac_module: string;
+  readonly region_endpoint_module: string;
+  readonly client_binding_stub_file: string;
+  readonly app_shims: Record<string, string>;
+  readonly is_build: boolean;
+  readonly devtools: boolean;
+  constructor(init: CompileCtxInit);
+  /** True when `code` carries an ogygia `with { … }` island hint (gates node_modules `.svelte`). */
+  has_island_hint(code: string): boolean;
+  /** True when a JS module has a real `import … with { <mark key>: … }` declaration. The hint
+   *  above is a text sniff, so it also matches a comment, a string or generated code that merely
+   *  mentions `with { wake }`; this parses. A module that does not parse counts as marked, so a
+   *  warning that depends on it errs toward speaking. */
+  has_marked_import(code: string, id: string): boolean;
+  /** True when `id` is inside a dependency's DECLARED `ogygia.files` surface — those files are
+   *  prescanned + transformed exactly like app source (the node_modules gates lift for them). */
+  in_declared_pkg(id: string): boolean;
+  /** Install-independent region identity for a file under a declared package: `<name>/<rel>`.
+   *  Store paths carry version + peer-resolution hashes (`node_modules/.pnpm/pkg@1.2.3(...)`),
+   *  so a root-relative identity would change per install/machine and prod HTML would stop
+   *  matching its chunks. Returns `null` for anything not under a declared package root. */
+  pkg_identity(abs: string): string | null;
+  /** The runtime's feature set, as a name segment: the prescan's feature hash, and a trailing `h` when
+   *  the app has `hooks.client.ts` (the runtime entry then dynamic-imports it). Empty until prescan
+   *  runs. Both the stable name and the content-hashed file carry it, so a name says which runtime. */
+  runtime_features(program_feature_hash: string): string;
+  /** The runtime's STABLE name (`RUNTIME_HASH` ⊕ its features): its identity — the key the handoff
+   *  maps to the content-hashed file the page loads — and the name of that file's shim. Computed here
+   *  (not the caller) so both build legs name it identically. `program_feature_hash` is
+   *  `Program.runtime_feature_hash`, threaded in by the caller so this stays a pure naming function. */
+  runtime_chunk_filename(program_feature_hash: string): string;
+  /** App-internal URL of the runtime chunk (leading slash + appDir; NO base). SSR bakes it as the
+   *  `<script src>`, then `asset()` prepends base / the assets CDN at render time. */
+  runtime_chunk_url(program_feature_hash: string): string;
+  /** Output filename for a hydrate island chunk (under the app dir; an on-disk build path). */
+  island_chunk_filename(iid: string): string;
+  /** App-internal URL of a hydrate island chunk (leading slash + appDir; NO base — `asset()` adds it). */
+  island_public_url(iid: string): string;
+  /** Read a file as UTF-8, or `null` if it can't be read (the transform tolerates missing deps). */
+  read_file(abs: string): string | null;
+  /** Virtual island ENTRY module id for an island id. */
+  island_virtual_id(iid: string): string;
+  /** Virtual wrapper `.svelte` module id for an island id. */
+  wrapper_virtual_id(iid: string): string;
+  /** Dev URL for a dynamic `import(entry)` of a virtual island module. Base-LESS, exactly like the
+   *  prod island/runtime URLs and the dev runtime URL: `Region.svelte` runs it through Kit's `asset()`
+   *  at SSR, which is the sole base authority. Baking `base` here would double it (Vite dev serves
+   *  `/@id/…` UNDER base, and `asset()` already adds that prefix). */
+  dev_url_for(virtualPath: string): string;
+}

package/dist/compiler/ctx.js

@@ -0,0 +1,203 @@
+import { fs } from "./host.js";
+import { strip_bom } from "./bom.js";
+import { islandVirtualId } from "./ids.js";
+import { parse_module } from "./parse/oxc.js";
+import { islandChunkFileName, islandPublicUrl, wrapperVirtualId } from "./region/transform.js";
+// src/compiler/ctx.ts
+/**
+* `CompileCtx` — the resolved compile context: the config the transform phase reads, plus its
+* derived naming accessors. A plain data holder constructed once the bundler has resolved the build
+* (root / dev / …) and the options are normalized (importKeys / presets / …). It is the config half
+* of the driver's session; the `Compiler` carries it into `transform()` so that phase never reaches
+* back into the Vite adapter — which is what keeps the driver bundler-agnostic (a future REPL feeds
+* a `CompileCtx` + source and gets the same lowering, no Vite in sight).
+*/
+/** Windows separators → posix, for id matching against the (posix) declared-path index. */
+const BACKSLASH_SEP = /\\/;
+/** Matches nothing — the island-hint probe when no import keys are configured. */
+const NEVER_MATCH_RE = /$^/;
+var CompileCtx = class {
+	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;
+	build_secret;
+	rate_limit;
+	session_cookie;
+	region_ttl;
+	renew_window;
+	router_enabled;
+	router_view_transitions;
+	client_hooks;
+	runtime_dir;
+	runtime_hash;
+	hmac_module;
+	region_endpoint_module;
+	client_binding_stub_file;
+	app_shims;
+	is_build;
+	devtools;
+	/** `with { … }` hint matcher — a node_modules `.svelte` is only transformed when it carries one
+	*  (so a library can declare its own islands). Built once from the resolved import keys. */
+	#island_hint_re;
+	/** The resolved import-attribute keys that make a mark (`wake`, `render`, …). */
+	#mark_keys;
+	/** Declared package files (exact) + dirs (prefix) — the transform-gate membership index. */
+	#pkg_files;
+	#pkg_dirs;
+	/** Package roots, longest first, for stable-identity mapping (root → published name). */
+	#pkg_roots;
+	constructor(init) {
+		this.root = init.root;
+		this.base = init.base;
+		this.app_dir = init.app_dir;
+		this.libDir = init.libDir;
+		this.pkg_scan = init.pkg_scan ?? [];
+		this.page_importers = init.page_importers ?? [];
+		this.page_files = init.page_files ?? [];
+		this.measure = init.measure;
+		this.server_plugins = init.server_plugins ?? [];
+		this.client_plugins = init.client_plugins ?? [];
+		this.route_config = init.route_config ?? [];
+		this.foreign_hydrate = init.foreign_hydrate ?? false;
+		this.is_dev = init.is_dev;
+		this.id_salt = init.id_salt;
+		this.visibleMargin = init.visibleMargin;
+		this.presets = init.presets;
+		this.import_keys = init.import_keys;
+		this.resolve_alias = init.resolve_alias;
+		this.macros = init.macros ?? [];
+		this.pkg_root = init.pkg_root;
+		this.build_secret = init.build_secret;
+		this.rate_limit = init.rate_limit;
+		this.session_cookie = init.session_cookie;
+		this.region_ttl = init.region_ttl;
+		this.renew_window = init.renew_window;
+		this.router_enabled = init.router_enabled;
+		this.router_view_transitions = init.router_view_transitions;
+		this.client_hooks = init.client_hooks ?? null;
+		this.runtime_dir = init.runtime_dir;
+		this.runtime_hash = init.runtime_hash;
+		this.hmac_module = init.hmac_module;
+		this.region_endpoint_module = init.region_endpoint_module;
+		this.client_binding_stub_file = init.client_binding_stub_file;
+		this.app_shims = init.app_shims;
+		this.is_build = init.is_build;
+		this.devtools = init.devtools;
+		const hint_keys = Object.values(init.import_keys).filter((v) => typeof v === "string");
+		this.#island_hint_re = hint_keys.length ? new RegExp(`\\bwith\\s*\\{[^}]*\\b(?:${hint_keys.join("|")})\\b`) : NEVER_MATCH_RE;
+		this.#mark_keys = new Set(hint_keys);
+		this.#pkg_files = new Set(this.pkg_scan.flatMap((p) => p.files));
+		this.#pkg_dirs = this.pkg_scan.flatMap((p) => p.dirs);
+		this.#pkg_roots = this.pkg_scan.map((p) => ({
+			root: p.root,
+			name: p.name
+		})).sort((a, b) => b.root.length - a.root.length);
+	}
+	/** True when `code` carries an ogygia `with { … }` island hint (gates node_modules `.svelte`). */
+	has_island_hint(code) {
+		return this.#island_hint_re.test(code);
+	}
+	/** True when a JS module has a real `import … with { <mark key>: … }` declaration. The hint
+	*  above is a text sniff, so it also matches a comment, a string or generated code that merely
+	*  mentions `with { wake }`; this parses. A module that does not parse counts as marked, so a
+	*  warning that depends on it errs toward speaking. */
+	has_marked_import(code, id) {
+		const { program, ok } = parse_module(code, id);
+		if (!ok || !program) return true;
+		for (const node of program.body) {
+			if (node.type !== "ImportDeclaration") continue;
+			for (const attr of node.attributes ?? []) {
+				const key = attr.key?.type === "Identifier" ? attr.key.name : attr.key?.value;
+				if (typeof key === "string" && this.#mark_keys.has(key)) return true;
+			}
+		}
+		return false;
+	}
+	/** True when `id` is inside a dependency's DECLARED `ogygia.files` surface — those files are
+	*  prescanned + transformed exactly like app source (the node_modules gates lift for them). */
+	in_declared_pkg(id) {
+		if (this.#pkg_files.size === 0 && this.#pkg_dirs.length === 0) return false;
+		const p = id.split(BACKSLASH_SEP).join("/");
+		if (this.#pkg_files.has(p)) return true;
+		for (const dir of this.#pkg_dirs) if (p.startsWith(dir + "/")) return true;
+		return false;
+	}
+	/** Install-independent region identity for a file under a declared package: `<name>/<rel>`.
+	*  Store paths carry version + peer-resolution hashes (`node_modules/.pnpm/pkg@1.2.3(...)`),
+	*  so a root-relative identity would change per install/machine and prod HTML would stop
+	*  matching its chunks. Returns `null` for anything not under a declared package root. */
+	pkg_identity(abs) {
+		if (this.#pkg_roots.length === 0) return null;
+		const p = abs.split(BACKSLASH_SEP).join("/");
+		for (const { root, name } of this.#pkg_roots) if (p.startsWith(root + "/")) return name + p.slice(root.length);
+		return null;
+	}
+	/** The runtime's feature set, as a name segment: the prescan's feature hash, and a trailing `h` when
+	*  the app has `hooks.client.ts` (the runtime entry then dynamic-imports it). Empty until prescan
+	*  runs. Both the stable name and the content-hashed file carry it, so a name says which runtime. */
+	runtime_features(program_feature_hash) {
+		return `${program_feature_hash}${this.client_hooks ? "h" : ""}`;
+	}
+	/** The runtime's STABLE name (`RUNTIME_HASH` ⊕ its features): its identity — the key the handoff
+	*  maps to the content-hashed file the page loads — and the name of that file's shim. Computed here
+	*  (not the caller) so both build legs name it identically. `program_feature_hash` is
+	*  `Program.runtime_feature_hash`, threaded in by the caller so this stays a pure naming function. */
+	runtime_chunk_filename(program_feature_hash) {
+		const feat = this.runtime_features(program_feature_hash);
+		return `${this.app_dir}/immutable/og-runtime.${this.runtime_hash}${feat ? "-" + feat : ""}.js`;
+	}
+	/** App-internal URL of the runtime chunk (leading slash + appDir; NO base). SSR bakes it as the
+	*  `<script src>`, then `asset()` prepends base / the assets CDN at render time. */
+	runtime_chunk_url(program_feature_hash) {
+		return "/" + this.runtime_chunk_filename(program_feature_hash);
+	}
+	/** Output filename for a hydrate island chunk (under the app dir; an on-disk build path). */
+	island_chunk_filename(iid) {
+		return islandChunkFileName(iid, this.app_dir);
+	}
+	/** App-internal URL of a hydrate island chunk (leading slash + appDir; NO base — `asset()` adds it). */
+	island_public_url(iid) {
+		return islandPublicUrl(iid, this.app_dir);
+	}
+	/** Read a file as UTF-8, or `null` if it can't be read (the transform tolerates missing deps). */
+	read_file(abs) {
+		try {
+			return strip_bom(fs.readFileSync(abs, "utf-8"));
+		} catch {
+			return null;
+		}
+	}
+	/** Virtual island ENTRY module id for an island id. */
+	island_virtual_id(iid) {
+		return islandVirtualId(iid);
+	}
+	/** Virtual wrapper `.svelte` module id for an island id. */
+	wrapper_virtual_id(iid) {
+		return wrapperVirtualId(iid);
+	}
+	/** Dev URL for a dynamic `import(entry)` of a virtual island module. Base-LESS, exactly like the
+	*  prod island/runtime URLs and the dev runtime URL: `Region.svelte` runs it through Kit's `asset()`
+	*  at SSR, which is the sole base authority. Baking `base` here would double it (Vite dev serves
+	*  `/@id/…` UNDER base, and `asset()` already adds that prefix). */
+	dev_url_for(virtualPath) {
+		return "/@id/" + virtualPath;
+	}
+};
+export { CompileCtx };

package/dist/compiler/debarrel/barrel.d.ts

@@ -0,0 +1,55 @@
+import { ModuleShape } from "./parse.js";
+export interface Host {
+  /** The module's source, or null when it cannot be read (virtual, binary, missing). */
+  read(id: string): string | null;
+  /** Resolve `spec` from `importer` to a file id; null when Vite cannot. */
+  resolve(spec: string, importer: string): Promise<string | null>;
+  /** May this resolved module be treated as a barrel at all? (matchers + node_modules policy) */
+  candidate(id: string, spec: string): boolean;
+  /** Is this module forced even though impure? */
+  forced(id: string, spec: string): boolean;
+  /** Is this module kept whatever it looks like? */
+  kept(id: string, spec: string): boolean;
+  /** Follow a star into node_modules? */
+  follow_packages: boolean;
+}
+export type Leaf = {
+  id: string;
+  name: string;
+} | {
+  id: string;
+  namespace: true;
+};
+export type Entry = Leaf | "own" | "ambiguous";
+export interface ExportMap {
+  id: string;
+  /** the barrel's usable names */
+  entries: Map<string, Entry>;
+  /** pure barrel → the import can be dropped once every name moved; impure → kept for effects */
+  pure: boolean;
+  /** rewriting allowed at all (candidate, and pure or forced, and not kept) */
+  rewritable: boolean;
+  /** some names could not be seen (a star into the unparsable): unknown names stay on the barrel */
+  opaque: boolean;
+  /** every module this map depends on — a change to any of them invalidates the map */
+  deps: Set<string>;
+  /** built while a neighbour was still being built by another walk: served, not cached */
+  provisional: boolean;
+  /** ids on the walk stack this build ran into (a cycle): the map lacks THEIR names, so it is
+   *  cached only once the walk that owns them has closed the ring (the set is empty there) */
+  cycles: Set<string>;
+}
+export declare class BarrelIndex {
+  #private;
+  constructor(host: Host);
+  /** Drop every cached map/shape that depends on `id` (the file changed). */
+  invalidate(id: string): void;
+  /** The parsed shape of a module (cached), or null when it cannot be read/parsed. */
+  shape(id: string): ModuleShape | null;
+  /**
+   * The export map of a barrel, or null when the module is not a barrel the plugin may rewrite
+   * (not a candidate, impure and not forced, kept, unreadable). `spec` is the specifier the
+   * importer wrote — matchers see both. Concurrent callers share one build.
+   */
+  map(id: string, spec: string): Promise<ExportMap | null>;
+}