@ogygia/core 0.0.0 → 0.11.0

package/dist/compiler/region/transform.js

@@ -0,0 +1,1933 @@
+import { createHash } from "../host.js";
+import { foucCssVirtualId } from "../fouc-css.js";
+import { collectCaptureInfo } from "../free-vars.js";
+import { parse_module } from "../parse/oxc.js";
+import { regionId, regionIdentity, strategyKey } from "./identity.js";
+import { regionBindingVirtualId } from "../ids.js";
+import { island_entry_source, lake_wrapper_source, make_region_binding, make_wake_island, server_wrapper_source } from "./emit.js";
+import { blank_styles } from "../blank-styles.js";
+import { parse } from "svelte/compiler";
+import MagicString from "magic-string";
+// src/compiler/region/transform.ts
+/** A host the parser still cannot read keeps its region imports as plain imports (no island):
+*  said once per file, never skipped in silence. The Svelte compiler reports the error itself. */
+const warned_unparsed = /* @__PURE__ */ new Set();
+function warn_unparsed(id, err) {
+	if (warned_unparsed.has(id)) return;
+	warned_unparsed.add(id);
+	const e = err;
+	console.warn(`[ogygia] regions: skipped ${id}: ${e.code ?? (e.message ?? "parse error").split("\n")[0].slice(0, 80)}${e.start?.line ? ` at ${e.start.line}:${(e.start.column ?? 0) + 1}` : ""} — its region imports stay plain imports`);
+}
+const REGEXP_META = /[.*+?^${}()|[\]\\]/g;
+const PATH_SEP = /[/\\]/;
+const DURATION = /^(\d+(?:\.\d+)?)\s*(ms|s|m|h)?$/i;
+const JS_EXT = /\.js$/;
+/** A generated module id (`virtual:ogygia/…`, optionally `\0`-resolved) — it has no directory. */
+const VIRTUAL_HOST_RE = /^\0?virtual:/;
+const WRAP_QUOTES = /^['"]|['"]$/g;
+/** One `key: 'value'` pair of an import-attributes clause (shared `g` regex — reset `lastIndex`
+*  before each scan). */
+const IMPORT_ATTR_PAIR_G = /([A-Za-z_$][\w$]*|'[^']*'|"[^"]*")\s*:\s*('[^']*'|"[^"]*")/g;
+/** `import X from '…' with { … }` — the one held-region import form in a `.ts`/`.js` module
+*  (shared `g` regex — reset `lastIndex` before each scan). */
+const HELD_IMPORT_G = /import\s+([A-Za-z_$][\w$]*)\s+from\s+(['"])([^'"]+)\2\s+with\s*\{([^}]*)\}\s*;?/g;
+const ISLAND_DIR = ".ogygia";
+/** True for a GENERATED island glue id (virtual island entry / wrapper / region binding, or the legacy
+*  on-disk `.ogygia/` shape) — the ids that are ogygia's own emit, not authored app/component source. */
+function is_island_path(id) {
+	const bare = id.split("?")[0];
+	return bare.startsWith("virtual:ogygia/island/") && (bare.endsWith(".js") || bare.endsWith(".svelte")) || bare.startsWith("virtual:ogygia/wrapper/") && bare.endsWith(".svelte") || bare.startsWith("virtual:ogygia/region/") && bare.endsWith(".js") || bare.startsWith("virtual:ogygia/lazy/") && bare.endsWith(".js") || bare.includes("/.ogygia/") && bare.endsWith(".svelte");
+}
+/**
+* Default import-attribute keys — the two-dial grammar. Internal role names stay `hydrate`/`defer`
+* (the wire format + runtime keep those anchors); the user-facing ATTRIBUTE names are the values.
+* Override via `ogygia({ importKeys })`.
+* - `render` attribute → the MODE: `static` (inline HTML) | `deferred` (a hole, fetched) | `live`
+*   (a hole that revalidates). Defaults to `static`.
+* - `fetch` attribute → a `deferred` hole's TIMING, when its HTML arrives (default `load`):
+*   `with { render: 'deferred', fetch: 'visible' }`.
+* - `wake` attribute → when an island's JS runs (`none`: a lake). Never a hole's timing.
+*/
+const DEFAULT_IMPORT_KEYS = {
+	wake: "wake",
+	fetch: "fetch",
+	render: "render",
+	preset: "preset",
+	region: "region"
+};
+/** The three delivery modes the `render` attribute accepts. */
+const RENDER_MODES = /* @__PURE__ */ new Set([
+	"static",
+	"deferred",
+	"live"
+]);
+const JS_IDENT = /^[A-Za-z_$][\w$]*$/;
+/** Store constructor callees marking a host declaration as store-like (best-effort signal). */
+const STORE_CTORS = /* @__PURE__ */ new Set([
+	"writable",
+	"readable",
+	"derived",
+	"toStore",
+	"fromStore"
+]);
+/** `$name` subscription reads anywhere in a file (heuristic store signal; runes filtered out). */
+const STORE_SUB_RE = /\$([A-Za-z_][\w$]*)/g;
+const RUNE_NAMES = /* @__PURE__ */ new Set([
+	"state",
+	"derived",
+	"effect",
+	"props",
+	"bindable",
+	"inspect",
+	"host"
+]);
+/** 1-based `line:col` for an offset — trace addresses in store-crossing warnings (cold path). */
+function line_col(src, offset) {
+	let line = 1;
+	let last = -1;
+	for (let i = 0; i < offset; i++) if (src.charCodeAt(i) === 10) {
+		line++;
+		last = i;
+	}
+	return `${line}:${offset - last}`;
+}
+/** Once per key for the process — the ssr AND client passes both transform the same host. */
+const store_warned = /* @__PURE__ */ new Set();
+function warn_once(key, msg) {
+	if (store_warned.has(key)) return;
+	store_warned.add(key);
+	console.warn(msg);
+}
+const KNOWN_STRATEGIES = /* @__PURE__ */ new Set([
+	"load",
+	"idle",
+	"visible"
+]);
+const HYDRATE_STRATEGIES = /* @__PURE__ */ new Set([...KNOWN_STRATEGIES, "interaction"]);
+const DEFER_STRATEGIES = HYDRATE_STRATEGIES;
+/** Inline attribute keys accepted after normalization (canonical internal names). */
+const ATTR_SCHEMA = /* @__PURE__ */ new Set([
+	"hydrate",
+	"defer",
+	"margin",
+	"keep",
+	"stitch",
+	"prefetch"
+]);
+/** A deferred hole's `prefetch` schedule: the warm happens on one of these (never `interaction`,
+*  which is the swap — `wake`'s job — and never `none`, which is no schedule). */
+const PREFETCH_STRATEGIES = KNOWN_STRATEGIES;
+/** AST fragment child-key names walked when descending the template. */
+const CHILD_KEYS = [
+	"consequent",
+	"alternate",
+	"body",
+	"fallback",
+	"pending",
+	"then",
+	"catch",
+	"fragment"
+];
+/**
+* Merge partial `importKeys` with {@link DEFAULT_IMPORT_KEYS}.
+* Rejects empty strings, non-identifiers, and colliding role names.
+*
+* @param overrides - Optional overrides for one or more roles.
+* @returns Fully resolved key map used by the transform.
+* @throws If a value is not a JS identifier or two roles share the same name.
+*/
+const NORMALIZED_CACHE = /* @__PURE__ */ new WeakMap();
+let DEFAULT_NORMALIZED = null;
+function normalize_import_keys(overrides) {
+	if (overrides == null) return DEFAULT_NORMALIZED ??= normalize_import_keys_uncached(null);
+	const hit = NORMALIZED_CACHE.get(overrides);
+	if (hit) return hit;
+	const result = normalize_import_keys_uncached(overrides);
+	NORMALIZED_CACHE.set(overrides, result);
+	return result;
+}
+function normalize_import_keys_uncached(overrides) {
+	const wake = (overrides?.wake ?? DEFAULT_IMPORT_KEYS.wake).trim();
+	const fetch = (overrides?.fetch ?? DEFAULT_IMPORT_KEYS.fetch).trim();
+	const render = (overrides?.render ?? DEFAULT_IMPORT_KEYS.render).trim();
+	const preset = (overrides?.preset ?? DEFAULT_IMPORT_KEYS.preset).trim();
+	const region = (overrides?.region ?? DEFAULT_IMPORT_KEYS.region).trim();
+	for (const [role, name] of [
+		["wake", wake],
+		["fetch", fetch],
+		["render", render],
+		["preset", preset],
+		["region", region]
+	]) if (!name || !JS_IDENT.test(name)) throw new Error(`[ogygia] importKeys.${role} must be a non-empty JS identifier (got ${JSON.stringify(overrides?.[role])}).`);
+	if ((/* @__PURE__ */ new Set([
+		wake,
+		fetch,
+		render,
+		preset,
+		region
+	])).size !== 5) throw new Error("[ogygia] importKeys.wake, importKeys.fetch, importKeys.render, importKeys.preset, and importKeys.region must be distinct.");
+	return {
+		wake,
+		fetch,
+		render,
+		preset,
+		region
+	};
+}
+/**
+* Cheap source-scan regex matching any of the configured import-attribute key names.
+* Used to skip AST work on hosts that cannot contain region imports.
+*
+* @param import_keys - Resolved key map from {@link normalize_import_keys}.
+*/
+/** Memoized hint regex per resolved key map — `import_keys` is build-invariant, so the RegExp is
+* compiled once instead of on every `transformHost` call (per module, per leg). */
+const HINT_CACHE = /* @__PURE__ */ new WeakMap();
+function import_keys_hint(import_keys) {
+	let re = HINT_CACHE.get(import_keys);
+	if (re) return re;
+	const esc = (s) => s.replace(REGEXP_META, "\\$&");
+	re = new RegExp(`${esc(import_keys.wake)}|${esc(import_keys.fetch)}|${esc(import_keys.render)}|${esc(import_keys.preset)}|${esc(import_keys.region)}`);
+	HINT_CACHE.set(import_keys, re);
+	return re;
+}
+/** Deterministic short id for a region (stable across dev + build).
+* When `salt` is set (production `OGYGIA_SECRET`), ids are not offline-computable (P1-ID).
+* Paths are always posix so SSR/client builds agree across OS path separators. */
+function islandId(relHostPath, index, salt = "") {
+	const rel = String(relHostPath).split(PATH_SEP).join("/");
+	const msg = salt ? `${salt}\0${rel}::${index}` : `${rel}::${index}`;
+	return createHash("md5").update(msg).digest("hex").slice(0, 12);
+}
+/**
+* Deterministic client chunk path for a hydrate island (mirrors `og-runtime.<hash>.js`).
+* SSR bakes this into `<ogygia-region entry>` so the sticky runtime can `import(entry)` with no
+* app-wide regions map — Kit builds server before client, so content-hashed Vite names can't hand off.
+*/
+function islandChunkFileName(iid, appDir = "_app") {
+	return `${appDir}/immutable/og-region.${iid}.js`;
+}
+/** App-internal URL for {@link islandChunkFileName}: `/<appDir>/immutable/…` (leading slash, appDir,
+*  NO base). It is what SSR bakes onto `<ogygia-region entry>`; `Region.svelte` runs it through Kit's
+*  `asset()` at render time, which is the sole authority on `base` / the assets CDN / relative paths —
+*  so a base is never baked here (that would double-apply it). NOT the on-disk output filename. */
+function islandPublicUrl(iid, appDir = "_app") {
+	return "/" + islandChunkFileName(iid, appDir);
+}
+/** Portable wrapper module id — SSR / csr=true host binding (Island/ServerIsland/Lake shell). */
+function wrapperVirtualId(iid) {
+	return `virtual:ogygia/wrapper/${iid}.svelte`;
+}
+const AS_REGION_ARG_G = /import\.meta\.og\.asRegion\(\s*([A-Za-z_$][\w$]*)/g;
+/**
+* The local bindings a file hands to `import.meta.og.asRegion(X)`. An island's identity is keyed on
+* the import that binds `X` (`'<specifier>#<export>'`), and the prescan derives it from the raw
+* source on disk — so no pass that runs before the transform may rewrite that import (the debarrel
+* pass leaves declarations binding these names alone, as it does marked imports). A textual scan on
+* purpose: it runs before any parse, on every transformed file.
+*/
+function asRegionLocals(code) {
+	const out = /* @__PURE__ */ new Set();
+	if (!code.includes("asRegion(")) return out;
+	AS_REGION_ARG_G.lastIndex = 0;
+	let m;
+	while (m = AS_REGION_ARG_G.exec(code)) out.add(m[1]);
+	return out;
+}
+/**
+* csr=false CLIENT host binding target. Kit still emits those page nodes; pointing marked
+* imports here (instead of wrappers) keeps N island wrappers/entries out of the page graph so
+* `emitFile` owns hydrate modules and Rolldown does not thin-facade them. Hydration uses
+* `import(entry)` only — this stub is never loaded for island JS.
+*
+* Beside the stub the transform emits `import 'virtual:ogygia/fouc-css/<entry>'` so Kit still
+* links stylesheets (FOUC) via CSS-only side effects. Importing the full `.svelte` JS module
+* dual-owns it with the emitFile island entry and Rolldown thin-facades `og-region.*`.
+* Omitting CSS entirely orphans rules (scoped class hashes, no stylesheet).
+*/
+const CLIENT_BINDING_STUB = "virtual:ogygia/client-binding-stub";
+/** True if `val` looks like a CSS media query (must contain a balanced-ish `(…)`). */
+function is_media_query(val) {
+	const open = val.indexOf("(");
+	return open !== -1 && val.indexOf(")", open) !== -1;
+}
+/**
+* Is `node` the member expression `import.meta.og.<prop>` (the macro namespace head)? Used to spot an
+* `import.meta.og.asRegion(…)` call — the macro alternative to a `with { wake }` region import.
+*/
+function is_import_meta_og(node, prop) {
+	return node?.type === "MemberExpression" && node.property?.type === "Identifier" && node.property.name === prop && node.object?.type === "MemberExpression" && node.object.property?.type === "Identifier" && node.object.property.name === "og" && node.object.object?.type === "MetaProperty" && node.object.object.meta?.name === "import" && node.object.object.property?.name === "meta";
+}
+/**
+* Resolve a local name back to its import binding — the module specifier plus the EXPORT NAME it
+* imports (`'default'` for `import X`, the imported name for `import { X }` / `import { A as X }`).
+* Feeds asRegion: the island entry re-imports the component by this export name (barrel-friendly), and
+* region identity keys on `source#exportName`. Namespace imports (`import * as X`) return `{ namespace }`.
+*/
+function import_binding_of(node, localName) {
+	for (const spec of node.specifiers ?? []) {
+		if (spec.local?.name !== localName) continue;
+		if (spec.type === "ImportDefaultSpecifier") return {
+			source: node.source.value,
+			exportName: "default"
+		};
+		if (spec.type === "ImportSpecifier") {
+			const imported = spec.imported;
+			const name = imported?.type === "Literal" ? String(imported.value) : imported?.name;
+			return {
+				source: node.source.value,
+				exportName: name
+			};
+		}
+		if (spec.type === "ImportNamespaceSpecifier") return { namespace: true };
+	}
+	return null;
+}
+/**
+* Parse an `asRegion` options object in a `.ts`/`.js` file into a `.ts` region marker — `{ wake }` or
+* `{ region }`, the same option surface a `with { … }` import attribute has there. `fail(msg)` throws
+* the caller's contextual error.
+*/
+function parse_ts_as_region_options(arg, fail, regionKey, wakeKey, renderKey, fetchKey = "fetch") {
+	if (!arg || arg.type !== "ObjectExpression") throw fail(`needs an options object — e.g. \`import.meta.og.asRegion(Comp, { wake: 'load' })\`.`);
+	let region;
+	let wake;
+	let render;
+	let fetch;
+	for (const p of arg.properties ?? []) {
+		if (p.type !== "Property" || p.computed) throw fail("options must be a plain object of string-valued keys.");
+		const key = p.key?.name ?? p.key?.value;
+		if (p.value?.type !== "Literal" || typeof p.value.value !== "string") throw fail(`option \`${key}\` must be a string literal.`);
+		const val = String(p.value.value);
+		if (key === regionKey || key === "region") region = val;
+		else if (key === wakeKey || key === "wake") wake = val;
+		else if (key === fetchKey || key === "fetch") fetch = val;
+		else if (key === renderKey || key === "render") render = val;
+		else throw fail(`unknown option \`${key}\` — a .ts region takes \`wake: '…'\`, \`region: 'raw'\`, or \`render: 'deferred'\` (with \`fetch\` as its timing).`);
+	}
+	if (render != null || fetch != null) {
+		if (region != null) throw fail("`render` and `region` are different markers — use one.");
+		return {
+			render,
+			wake,
+			fetch
+		};
+	}
+	if (region != null && wake != null) throw fail("takes exactly one of `wake` or `region`.");
+	if (region != null) return { region };
+	if (wake != null) return { wake };
+	throw fail("needs a `wake`, `region`, or `render` option.");
+}
+/**
+* The `with { region: … }` marker has ONE value — `'raw'` (an adjective: "a raw/held region"). It
+* carries NO schedule: the wake timing is set at the `region()` call (`region(C, props, { wake })`)
+* or, in a block tree, per node. This is the only surviving import-attribute marker for a component
+* a registry hands to `region()` where the transform can't see the call site.
+*
+* @param raw the marker value
+* @param where host label for error messages
+* @param regionKey configured `region` attribute name (for the message)
+*/
+function normalize_region_value(raw, where, regionKey = "region") {
+	if ((raw ?? "").trim() === "raw") return;
+	throw new Error(`[ogygia] ${where}: \`${regionKey}\` only takes the value 'raw' (a held region with no baked schedule). To bake a schedule use a \`wake:\` mark, or set it at the \`region()\` call.`);
+}
+/**
+* Validate a `wake:` schedule value on a held import (a `.ts` registry / remote). Accepts the wake
+* strategies (`load` / `idle` / `visible` / `interaction`) or a media query — the same vocabulary as
+* a placed island's `wake:`. Returns the value unchanged (it becomes the baked `__hydrate`).
+*/
+function normalize_hydrate_value(raw, where, wakeKey = "wake") {
+	const v = (raw ?? "").trim();
+	if (HYDRATE_STRATEGIES.has(v) || is_media_query(v)) return v;
+	throw new Error(`[ogygia] ${where}: unknown \`${wakeKey}\` strategy '${v}'. Use 'load' | 'idle' | 'visible' | 'interaction' | a media query.`);
+}
+/** Reconstruct an import declaration without its `with { ... }` attributes clause. */
+function clean_import_text(source, node) {
+	return source.slice(node.start, node.source.end) + ";";
+}
+/**
+* Region keys (`hydrate` / `defer` / `preset` under configured names) on a dynamic
+* `import(spec, { with: { … } })` / `{ assert: { … } }` options object.
+* Returns `[]` when the call has no options or no claimed region keys.
+*
+* @param node
+* @param import_keys
+* @returns
+*/
+function region_keys_on_dynamic_import(node, import_keys) {
+	const opts = node.options;
+	if (!opts || opts.type !== "ObjectExpression") return [];
+	const claimed = /* @__PURE__ */ new Set([
+		import_keys.wake,
+		import_keys.fetch,
+		import_keys.render,
+		import_keys.preset
+	]);
+	const found = [];
+	for (const prop of opts.properties) {
+		if (prop.type !== "Property" || prop.computed) continue;
+		const bag_key = prop.key.type === "Identifier" ? prop.key.name : prop.key.type === "Literal" ? String(prop.key.value) : null;
+		if (bag_key !== "with" && bag_key !== "assert") continue;
+		if (prop.value.type !== "ObjectExpression") continue;
+		for (const atr of prop.value.properties) {
+			if (atr.type !== "Property" || atr.computed) continue;
+			const ak = atr.key.type === "Identifier" ? atr.key.name : atr.key.type === "Literal" ? String(atr.key.value) : null;
+			if (ak && claimed.has(ak) && !found.includes(ak)) found.push(ak);
+		}
+	}
+	return found;
+}
+/**
+* Walk a script Program body for `ImportExpression` nodes carrying ogygia region keys.
+* Dynamic `import()` cannot author islands — SSR shells need a static marked import binding.
+*
+* @param body
+* @param import_keys
+* @param fail
+*/
+function reject_dynamic_region_imports(body, import_keys, fail) {
+	const walk = (node) => {
+		if (!node || typeof node !== "object") return;
+		if (node.type === "ImportExpression") {
+			const keys = region_keys_on_dynamic_import(node, import_keys);
+			if (keys.length) fail(keys);
+		}
+		for (const k of Object.keys(node)) {
+			if (k === "start" || k === "end" || k === "loc") continue;
+			const v = node[k];
+			if (Array.isArray(v)) for (const c of v) walk(c);
+			else if (v && typeof v === "object" && typeof v.type === "string") walk(v);
+		}
+	};
+	for (const n of body ?? []) walk(n);
+}
+function script_lang_attr(scriptNode) {
+	if (!scriptNode) return "";
+	for (const attr of scriptNode.attributes ?? []) if (attr.name === "lang" && Array.isArray(attr.value) && attr.value[0]?.data) return ` lang="${attr.value[0].data}"`;
+	return "";
+}
+const REMOUNT_SHORTHANDS = /* @__PURE__ */ new Set([
+	"cache",
+	"empty",
+	"swr"
+]);
+const REMOUNT_ON_EXPIRE = /* @__PURE__ */ new Set(["empty", "fetch"]);
+/** Schedule keywords shared by `hydrate`, `defer` and `remount.revalidate`. */
+const SCHEDULE_KEYWORDS = /* @__PURE__ */ new Set([
+	"load",
+	"idle",
+	"visible"
+]);
+/**
+* Parse `remount.maxAge` — number (ms) or duration string (`30s` / `5m` / `1h` / `500ms`).
+* @returns milliseconds
+*/
+function parse_max_age(raw, err, names) {
+	if (raw == null) return void 0;
+	if (typeof raw === "number") {
+		if (!Number.isFinite(raw) || raw < 0) throw err(names, `\`remount.maxAge\` must be a non-negative number (ms), got ${raw}.`);
+		return Math.floor(raw);
+	}
+	if (typeof raw === "string") {
+		const m = raw.trim().match(DURATION);
+		if (!m) throw err(names, `unknown remount.maxAge '${raw}'. Use a number (ms) or a duration like '30s' | '5m' | '1h'.`);
+		const n = Number(m[1]);
+		const unit = (m[2] || "ms").toLowerCase();
+		return Math.floor(n * (unit === "ms" ? 1 : unit === "s" ? 1e3 : unit === "m" ? 6e4 : 36e5));
+	}
+	throw err(names, `\`remount.maxAge\` must be a number (ms) or duration string.`);
+}
+/**
+* Parse a deferred hole's `maxAge` → response cache max-age in **seconds**. Unlike `remount.maxAge`
+* (client staleness, ms), this is an HTTP header value, so a bare number is SECONDS; duration units
+* (`'30s'` / `'5m'` / `'1h'`, or `'500ms'` rounded down) are converted to seconds. `0` = no-store.
+* @returns seconds
+*/
+function parse_cache_ttl_sec(raw, err, names) {
+	if (raw == null) return void 0;
+	if (typeof raw === "number") {
+		if (!Number.isFinite(raw) || raw < 0) throw err(names, `\`maxAge\` must be a non-negative number of seconds, got ${raw}.`);
+		return Math.floor(raw);
+	}
+	if (typeof raw === "string") {
+		const m = raw.trim().match(DURATION);
+		if (!m) throw err(names, `unknown \`maxAge\` '${raw}'. Use seconds (a number) or a duration like '30s' | '5m' | '1h'.`);
+		const n = Number(m[1]);
+		const unit = (m[2] || "s").toLowerCase();
+		const secs = unit === "ms" ? n / 1e3 : unit === "s" ? n : unit === "m" ? n * 60 : n * 3600;
+		return Math.floor(secs);
+	}
+	throw err(names, `\`maxAge\` must be a number of seconds or a duration string.`);
+}
+/**
+* Normalize preset `remount`.
+*
+* Shorthands: `'cache'` | `'empty'` | `'swr'` (`swr` ≡ `{ revalidate: 'load' }`).
+* Object: `{ revalidate?: false | schedule, maxAge?, onExpire?: 'empty' | 'fetch' }`.
+*
+* @returns
+*/
+function parse_remount(raw, err, names) {
+	if (raw == null) return void 0;
+	if (typeof raw === "string") {
+		if (!REMOUNT_SHORTHANDS.has(raw)) throw err(names, `unknown remount '${raw}'. Use 'cache' | 'empty' | 'swr'.`);
+		if (raw === "swr") return {
+			policy: "swr",
+			when: "load"
+		};
+		return { policy: raw };
+	}
+	if (typeof raw !== "object" || raw === null) throw err(names, `\`remount\` must be 'cache' | 'empty' | 'swr' or \`{ revalidate?, maxAge?, onExpire? }\`.`);
+	if ("strategy" in raw || "when" in raw) throw err(names, "`remount` object uses `revalidate` (false | 'load' | 'idle' | 'visible' | media), not `strategy`/`when`. Examples: { revalidate: false, maxAge: '5m' } or { revalidate: 'idle' }. Shorthands: 'cache' | 'empty' | 'swr'.");
+	for (const k of Object.keys(raw)) if (k !== "revalidate" && k !== "maxAge" && k !== "onExpire") throw err(names, `unknown remount key '${k}'. Use revalidate, maxAge, onExpire.`);
+	const ro = raw;
+	if (ro.revalidate == null && ro.maxAge == null && ro.onExpire == null) throw err(names, `\`remount\` object needs revalidate, maxAge, and/or onExpire — or use the 'cache' | 'empty' | 'swr' shorthand.`);
+	const out = { policy: "cache" };
+	if (ro.revalidate === false || ro.revalidate == null) out.policy = "cache";
+	else if (ro.revalidate === true) throw err(names, `\`remount.revalidate: true\` is invalid — use 'load' (or 'idle' | 'visible' | a media query).`);
+	else {
+		const rev = String(ro.revalidate);
+		if (!SCHEDULE_KEYWORDS.has(rev) && !is_media_query(rev)) throw err(names, `unknown remount.revalidate '${rev}'. Use false | 'load' | 'idle' | 'visible' | a media query.`);
+		out.policy = "swr";
+		out.when = rev;
+	}
+	if (ro.onExpire != null) {
+		const oe = String(ro.onExpire);
+		if (!REMOUNT_ON_EXPIRE.has(oe)) throw err(names, `unknown remount.onExpire '${oe}'. Use 'empty' | 'fetch'.`);
+		if (out.policy === "cache" && oe === "fetch") throw err(names, "`onExpire: 'fetch'` requires `revalidate` (a schedule). Pure cache expires to empty — use { revalidate: 'load', maxAge, onExpire: 'fetch' } for SWR past maxAge.");
+		out.onExpire = oe;
+	}
+	if (ro.maxAge != null) out.maxAgeMs = parse_max_age(ro.maxAge, err, names);
+	return out;
+}
+/**
+* Svelte 5 event attributes (`onclick`, …) that cannot cross devalue for remount:swr.
+* Deliberately NOT `/^on[a-z]+$/` — that falsely rejects data props like `online={x}`.
+*/
+const SWR_EVENT_ATTR = /* @__PURE__ */ new Set([
+	"onclick",
+	"ondblclick",
+	"oncontextmenu",
+	"onauxclick",
+	"onpointerdown",
+	"onpointerup",
+	"onpointermove",
+	"onpointerenter",
+	"onpointerleave",
+	"onpointercancel",
+	"onpointerover",
+	"onpointerout",
+	"onmousedown",
+	"onmouseup",
+	"onmousemove",
+	"onmouseenter",
+	"onmouseleave",
+	"onmouseover",
+	"onmouseout",
+	"onkeydown",
+	"onkeyup",
+	"onkeypress",
+	"onfocus",
+	"onblur",
+	"onfocusin",
+	"onfocusout",
+	"oninput",
+	"onbeforeinput",
+	"onchange",
+	"onsubmit",
+	"onreset",
+	"onscroll",
+	"onwheel",
+	"ontouchstart",
+	"ontouchend",
+	"ontouchmove",
+	"ontouchcancel",
+	"ondrag",
+	"ondragstart",
+	"ondragend",
+	"ondragenter",
+	"ondragleave",
+	"ondragover",
+	"ondrop",
+	"oncopy",
+	"oncut",
+	"onpaste",
+	"onanimationstart",
+	"onanimationend",
+	"onanimationiteration",
+	"ontransitionend",
+	"ontransitionrun",
+	"ontransitionstart",
+	"ontransitioncancel",
+	"onload",
+	"onerror",
+	"ontoggle",
+	"onselect",
+	"oninvalid",
+	"onformdata"
+]);
+/** A template `<Component>` node, which the parser gives its name and offsets. */
+function is_component_node(n) {
+	return n.type === "Component";
+}
+/**
+* Everything a `render: 'live'` region needs must survive the wire: the endpoint re-renders the
+* component from devalue'd PROPS alone. Children (snippets) and `bind:` targets cannot cross, and
+* silently losing them on revalidate would be worse than refusing the build.
+*/
+function assert_swr_lake_crossable(node, err) {
+	if ((node.fragment?.nodes ?? []).filter((n) => !(n.type === "Text" && !String(n.data ?? "").trim())).length) throw err(node.name, `\`render: 'live'\` region <${node.name}> cannot have children — the revalidate endpoint re-renders it from serialized props only, so snippets cannot cross. Move the content inside the component, or make it a static lake with \`wake: 'none'\`.`);
+	for (const attr of node.attributes ?? []) {
+		if (attr.type === "SpreadAttribute") continue;
+		if (attr.type !== "Attribute") throw err(node.name, `\`render: 'live'\` region <${node.name}> cannot use \`${attr.type === "BindDirective" ? "bind:" + attr.name : attr.name || attr.type}\` — only plain attributes and spreads can be serialized for the revalidate endpoint.`);
+		const name = attr.name;
+		if (typeof name === "string" && SWR_EVENT_ATTR.has(name)) throw err(node.name, `\`render: 'live'\` region <${node.name}> cannot use \`${name}\` — event/callback attributes cannot be serialized for the revalidate endpoint. Pass serializable data props instead.`);
+		const val = attr.value;
+		const chunk_list = Array.isArray(val) ? val : val != null && val !== true ? [val] : [];
+		for (const chunk of chunk_list) {
+			const t = chunk?.expression?.type;
+			if (t === "ArrowFunctionExpression" || t === "FunctionExpression") throw err(node.name, `\`render: 'live'\` region <${node.name}> cannot use a function value for \`${name}\` — functions cannot be serialized for the revalidate endpoint.`);
+		}
+	}
+}
+/**
+* Resolve a marked import specifier to the component path baked into generated modules.
+*
+* `$lib` + relative specifiers resolve to ABSOLUTE file paths (build machinery — emitFile prescan,
+* HMR invalidation, fouc-css — keys on them). Anything else (a PACKAGE specifier like
+* `'ogygia/content/tab-group'`, or a Vite alias) is kept VERBATIM: every generated virtual module
+* (island entry, wrapper, child synth, region binding) re-emits the original specifier and Vite's
+* resolver handles it — exports map, workspace link, or alias — so both a node_modules install and
+* a monorepo workspace link work without this transform ever touching the filesystem. A marked
+* specifier Vite cannot resolve fails loudly at resolve time (see the plugin's resolveId hook).
+*/
+function resolve_component_path(spec, host_id, ctx) {
+	if (typeof spec !== "string" || !spec.trim()) return null;
+	if (spec.startsWith(".") && VIRTUAL_HOST_RE.test(host_id)) throw new Error(`[ogygia] ${host_id}: cannot resolve the relative import '${spec}' from a generated module — it has no directory. Its real origin must be threaded (HostCtx.originOf); this is an ogygia bug, please report it.`);
+	if (spec === "$lib" || spec.startsWith("$lib/")) return ctx.pathModule.join(ctx.libDir, spec === "$lib" ? "" : spec.slice(5));
+	if (spec.startsWith(".")) return ctx.pathModule.resolve(ctx.pathModule.dirname(host_id), spec);
+	return spec;
+}
+/**
+* @typedef {Object} TransformResult
+* @property code rewritten host source
+* @property map source map
+* @property islands
+*/
+/**
+* @param source
+* @param id absolute host path
+* @param ctx
+* @param ctx.root project root (abs)
+* @param ctx.libDir abs path for `$lib`
+* @param ctx.readFile sync file reader for filename-strategy lookup
+* @param ctx.virtualPathFor virtual module id for an island
+* @returns
+*/
+/**
+* csr=true route host: strip its OWN island directives to plain imports (Kit compiles + hydrates them
+* inline) and degrade any `asRegion` to the plain component. No context marker is emitted — the
+* inline-vs-island choice is now a single runtime fact (`documentIsCsrTrue`, context.ts), read the same
+* on both legs, which replaced the old per-host `CSR_TRUE_KEY` marker + `csr=false` reset cascade.
+* @param source @param id @param has_island_hint @param import_keys
+* @returns
+*/
+function transform_csr_true_host(source, id, has_island_hint, import_keys) {
+	let ast;
+	try {
+		ast = parse(blank_styles(source), {
+			modern: true,
+			filename: id
+		});
+	} catch (err) {
+		warn_unparsed(id, err);
+		return null;
+	}
+	const ms = new MagicString(source);
+	if (has_island_hint) {
+		const region_keys = /* @__PURE__ */ new Set([
+			import_keys.wake,
+			import_keys.fetch,
+			import_keys.render,
+			import_keys.preset,
+			import_keys.region
+		]);
+		for (const node of ast.instance?.content?.body ?? []) {
+			if (node.type !== "ImportDeclaration") continue;
+			if (!(node.attributes ?? []).filter((a) => a.type === "ImportAttribute").some((a) => region_keys.has(a.key.name ?? a.key.value))) continue;
+			ms.overwrite(node.start, node.end, clean_import_text(source, node));
+		}
+	}
+	for (const node of ast.instance?.content?.body ?? []) {
+		if (node.type !== "VariableDeclaration") continue;
+		for (const decl of node.declarations) {
+			const call = decl.init;
+			if (call?.type === "CallExpression" && is_import_meta_og(call.callee, "asRegion")) {
+				const comp = call.arguments?.[0];
+				if (comp?.type === "Identifier") ms.overwrite(call.start, call.end, comp.name);
+			}
+		}
+	}
+	return {
+		code: ms.toString(),
+		map: ms.generateMap({
+			hires: true,
+			source: id,
+			includeContent: true
+		}),
+		islands: []
+	};
+}
+function transformHost(source, id, ctx) {
+	return new FileCompilation(source, id, ctx).run();
+}
+/**
+* `FileCompilation` — the per-file compilation unit for a `.svelte` host, and the biggest win of the
+* rewrite. The ephemeral state the fused pass threaded through ~30 nested closures (the AST, the marks
+* map, the free-var sets, …) lives here as `#fields`; the phases are methods over shared `this`:
+* `#analyze()` reads the AST into the fields (the {@link FileIR} shape), `#lower()` rewrites from them.
+* A fresh instance per file, discarded after — it organizes EPHEMERAL state, never cross-file state
+* (that is the Program's job), so it stays pure per file.
+*/
+var FileCompilation = class {
+	#source;
+	#id;
+	#ctx;
+	#ast;
+	#instance_body;
+	#module_body;
+	#lang;
+	#rel_host;
+	#import_keys;
+	#imports;
+	#marked_components;
+	#imports_to_strip;
+	#as_regions;
+	#as_region_nodes;
+	#synthetic_export;
+	#has_island_children;
+	/** Hydrate bindings PLACED as a static `<Tag>` in this host — the complement (a marked hydrate
+	*  binding with NO static placement) is a dynamically-used island: a registry value, an each/
+	*  `{@const}`/`svelte:component` use, a prop hand-off. Its call sites are compile-invisible, so
+	*  children CAN cross at runtime and the app must carry the wire revivers (see program.register —
+	*  a field regression: a registry-placed carousel's slot pointers hydrated against a runtime
+	*  without the hub → "Unknown type OgygiaRef", every island dead). */
+	#static_placed;
+	#has_island_hint;
+	constructor(source, id, ctx) {
+		this.#source = source;
+		this.#id = id;
+		this.#ctx = ctx;
+		this.#import_keys = normalize_import_keys(ctx.importKeys);
+	}
+	/** Compile the host: analyze ▸ (early-out) ▸ lower. */
+	run() {
+		const early = this.#analyze();
+		if (early) return early.done;
+		return this.#lower();
+	}
+	/** Walk an AST subtree for an Identifier / Component reference to `local`. Pure over the AST. */
+	#ast_refs_local(root, local) {
+		let found = false;
+		const walk = (node) => {
+			if (found || !node || typeof node !== "object") return;
+			if (node.type === "Identifier" && node.name === local) {
+				found = true;
+				return;
+			}
+			if (node.type === "Component") {
+				const n = node.name || "";
+				if (n === local || n.startsWith(local + ".")) {
+					found = true;
+					return;
+				}
+			}
+			for (const k of Object.keys(node)) {
+				if (k === "start" || k === "end" || k === "loc") continue;
+				const v = node[k];
+				if (Array.isArray(v)) for (const c of v) walk(c);
+				else if (v && typeof v === "object" && typeof v.type === "string") walk(v);
+			}
+		};
+		if (Array.isArray(root)) for (const n of root) walk(n);
+		else walk(root);
+		return found;
+	}
+	/** Is a marked import's `local` used anywhere but its own import (else it is dead, strip it)? */
+	#marked_import_referenced(local) {
+		for (const n of this.#instance_body) {
+			if (n.type === "ImportDeclaration") continue;
+			if (this.#ast_refs_local(n, local)) return true;
+		}
+		for (const n of this.#module_body) {
+			if (n.type === "ImportDeclaration") continue;
+			if (this.#ast_refs_local(n, local)) return true;
+		}
+		return this.#ast_refs_local(this.#ast.fragment?.nodes ?? [], local);
+	}
+	#resolve_region_mark(inline, fail) {
+		const import_keys = this.#import_keys;
+		const ctx = this.#ctx;
+		const rel_host = this.#rel_host;
+		const REGION_KEYS = [
+			import_keys.wake,
+			import_keys.fetch,
+			import_keys.render,
+			import_keys.preset,
+			import_keys.region
+		];
+		const err_shim = (_names, msg) => fail(msg);
+		if (inline.has("partial") && !REGION_KEYS.includes("partial")) throw fail(`the \`partial\` import attribute was retired. Mark a held-across-a-boundary component with \`${import_keys.region}: 'raw'\` (schedule set at the \`region()\` call), or bake a schedule with a \`${import_keys.wake}:\` mark.`);
+		if (!REGION_KEYS.some((k) => inline.has(k))) return null;
+		if (inline.has(import_keys.region)) {
+			if (inline.size > 1) throw fail(`\`${import_keys.region}\` must be the only import attribute — it only marks a held region ('raw'); set the wake schedule at the \`region()\` call.`);
+			normalize_region_value(inline.get(import_keys.region), rel_host, import_keys.region);
+			return {
+				strategy: "held",
+				options: {}
+			};
+		}
+		const attrs = /* @__PURE__ */ new Map();
+		let remount_opt;
+		let from_preset = null;
+		let render_mode;
+		let wake_val;
+		let fetch_val;
+		const live_opts = {};
+		if (inline.has(import_keys.preset)) {
+			if (inline.size > 1) throw fail(`\`${import_keys.preset}\` must be the only import attribute — put its options (margin, maxAge, …) in the preset definition (ogygia({ presets })).`);
+			from_preset = inline.get(import_keys.preset);
+			const preset = ctx.presets && ctx.presets[from_preset];
+			if (!preset) {
+				const avail = Object.keys(ctx.presets || {});
+				throw fail(`unknown ${import_keys.preset} '${from_preset}'. Available: ${avail.length ? avail.join(", ") : "(none)"}.`);
+			}
+			for (const [k, v] of Object.entries(preset)) {
+				if (v == null) continue;
+				if (k === import_keys.render) render_mode = String(v);
+				else if (k === import_keys.wake) wake_val = String(v);
+				else if (k === import_keys.fetch) fetch_val = String(v);
+				else if (k === "maxAge" || k === "onExpire" || k === "revalidate") live_opts[k] = v;
+				else if (k === "margin" || k === "keep" || k === "prefetch") attrs.set(k, String(v));
+				else if (k === "stitch") {
+					if (v !== true && v !== "serve" && v !== "edge") throw fail(`preset '${from_preset}': \`stitch\` takes \`true\` / 'serve' (the hole fills at ORIGIN on every serve) or 'edge' (an ESI include the CDN fills — the shell stays edge-cached).`);
+					attrs.set("stitch", v === "edge" ? "edge" : "serve");
+				} else throw fail(`unknown key \`${k}\` in preset '${from_preset}'. Use \`${import_keys.wake}\`, \`${import_keys.fetch}\`, \`${import_keys.render}\`, \`margin\`, \`maxAge\`, \`onExpire\`, \`revalidate\`, \`stitch\`, \`prefetch\`.`);
+			}
+		} else {
+			for (const k of inline.keys()) if (k !== import_keys.wake && k !== import_keys.fetch && k !== import_keys.render && k !== "keep" && k !== "stitch" && k !== "prefetch") throw fail(`\`${k}\` is not allowed inline. Use \`${import_keys.wake}\`, \`${import_keys.fetch}\`, \`${import_keys.render}\`, \`keep\`, \`stitch\`, \`prefetch\`, or a named \`${import_keys.preset}\` — options like \`margin\` / \`maxAge\` belong in plugin config (ogygia({ presets })).`);
+			if (inline.has(import_keys.render)) render_mode = inline.get(import_keys.render);
+			if (inline.has(import_keys.wake)) wake_val = inline.get(import_keys.wake);
+			if (inline.has(import_keys.fetch)) fetch_val = inline.get(import_keys.fetch);
+			if (inline.has("keep")) attrs.set("keep", inline.get("keep"));
+			if (inline.has("prefetch")) attrs.set("prefetch", inline.get("prefetch"));
+			if (inline.has("stitch")) {
+				const mode = inline.get("stitch");
+				if (mode !== "serve" && mode !== "edge") throw fail(`\`stitch: '${mode}'\` — the inline values are \`stitch: 'serve'\` (the hole fills at ORIGIN on every serve) or \`stitch: 'edge'\` (an ESI include the CDN fills — the shell stays edge-cached).`);
+				attrs.set("stitch", mode);
+			}
+		}
+		if (render_mode != null && !RENDER_MODES.has(render_mode)) throw fail(`unknown ${import_keys.render} '${render_mode}'. Use 'static' (inline HTML) | 'deferred' (a hole, fetched) | 'live' (a hole that revalidates).`);
+		const said = from_preset ? `preset '${from_preset}'` : "this import";
+		if (render_mode === "deferred" && wake_val != null) throw fail(`${said} times a \`${import_keys.render}: 'deferred'\` hole with \`${import_keys.wake}: '${wake_val}'\` — that spelling is gone. Write \`${import_keys.render}: 'deferred', ${import_keys.fetch}: '${wake_val}'\` instead: \`${import_keys.fetch}\` says when a hole's HTML arrives. (\`${import_keys.wake}\` is when an island's JS runs; a hole ships no JS.)`);
+		if (fetch_val != null && render_mode !== "deferred") throw fail(`${said} sets \`${import_keys.fetch}: '${fetch_val}'\` without \`${import_keys.render}: 'deferred'\` — \`${import_keys.fetch}\` is a hole's timing. Write \`${import_keys.render}: 'deferred', ${import_keys.fetch}: '${fetch_val}'\` for a hole` + (render_mode == null ? `, or \`${import_keys.wake}: '${fetch_val}'\` for an island.` : "."));
+		if (render_mode === "deferred") attrs.set("defer", fetch_val ?? "load");
+		else if (render_mode === "live") {
+			attrs.set("hydrate", "none");
+			remount_opt = parse_remount({
+				revalidate: wake_val ?? live_opts.revalidate ?? "load",
+				...live_opts.maxAge != null ? { maxAge: live_opts.maxAge } : {},
+				...live_opts.onExpire != null ? { onExpire: live_opts.onExpire } : {}
+			}, err_shim, "");
+		} else if (wake_val != null) attrs.set("hydrate", wake_val);
+		if (attrs.has("stitch") && !attrs.has("defer")) throw fail(`\`stitch\` is only valid with \`${import_keys.render}: 'deferred'\` — it says WHERE a hole fills on artifact serves; there is no hole without 'deferred'.`);
+		if (attrs.has("prefetch") && !attrs.has("defer")) throw fail(`\`prefetch\` is only valid with \`${import_keys.render}: 'deferred'\` — it warms a hole's HTML ahead of its \`${import_keys.fetch}\` timing; an island's JS is preloaded by the runtime when it wakes, not by \`prefetch\`.`);
+		if (from_preset && !attrs.has("hydrate") && !attrs.has("defer")) throw fail(`${import_keys.preset} '${from_preset}' must set \`${import_keys.render}\` or \`${import_keys.wake}\` — a margin-only (or empty) preset is a no-op.`);
+		for (const k of attrs.keys()) if (!ATTR_SCHEMA.has(k)) throw fail(from_preset ? `unknown key \`${k}\` in preset '${from_preset}'.` : `unknown import attribute \`${k}\`.`);
+		if (remount_opt && attrs.get("hydrate") !== "none") throw fail(`\`remount\` is only valid with \`${import_keys.wake}: 'none'\`.`);
+		if (attrs.has("defer")) {
+			const dval = attrs.get("defer");
+			let when;
+			if (DEFER_STRATEGIES.has(dval)) when = dval;
+			else if (is_media_query(dval)) when = dval;
+			else throw fail(`\`${import_keys.render}: 'deferred'\` fetches on its \`${import_keys.fetch}\` timing, but '${dval}' is not one. Use \`${import_keys.fetch}: 'load' | 'idle' | 'visible' | 'interaction'\` or a media query (not 'none' — a hole must fetch).`);
+			const options = { when };
+			if (attrs.has("prefetch")) {
+				const p = attrs.get("prefetch");
+				if (p === "interaction" || !(PREFETCH_STRATEGIES.has(p) || is_media_query(p))) throw fail(`\`prefetch: '${p}'\` — a hole prefetches its HTML on 'load' | 'idle' | 'visible' | a media query. Never 'interaction': that is the SWAP, \`${import_keys.fetch}\`'s job; prefetch only warms the bytes ahead of it.`);
+				if (p === when) throw fail(`\`prefetch: '${p}'\` is this hole's own \`${import_keys.fetch}\` schedule — it adds nothing. Prefetch EARLIER than the swap ('load' | 'idle' | 'visible' for an 'interaction' hole), or drop it.`);
+				options.prefetch = p;
+			}
+			if (when === "visible" || options.prefetch === "visible") options.margin = attrs.get("margin") ?? ctx.visibleMargin ?? void 0;
+			if (live_opts.maxAge != null) {
+				const ttl = parse_cache_ttl_sec(live_opts.maxAge, err_shim, "");
+				if (ttl != null && ttl > 0) options.cacheTtlSec = ttl;
+			}
+			if (attrs.has("stitch")) options.stitch = attrs.get("stitch");
+			return {
+				strategy: "server",
+				options
+			};
+		}
+		if (attrs.has("hydrate")) {
+			const val = attrs.get("hydrate");
+			if (val === "none") {
+				const lake_opts = {};
+				if (remount_opt) {
+					lake_opts.remount = remount_opt.policy;
+					if (remount_opt.when) lake_opts.when = remount_opt.when;
+					if (remount_opt.maxAgeMs != null) lake_opts.maxAgeMs = remount_opt.maxAgeMs;
+					if (remount_opt.onExpire) lake_opts.onExpire = remount_opt.onExpire;
+					if (remount_opt.policy === "swr" && remount_opt.when === "visible") lake_opts.margin = attrs.get("margin") ?? ctx.visibleMargin ?? void 0;
+				}
+				return {
+					strategy: "lake",
+					options: lake_opts
+				};
+			}
+			if (val === "false") throw fail(`\`${import_keys.wake}: 'false'\` is not valid — use \`${import_keys.wake}: 'none'\` for a lake (a frozen region inside a hydrated island). See DESIGN.md.`);
+			let strategy;
+			if (HYDRATE_STRATEGIES.has(val)) strategy = val;
+			else if (is_media_query(val)) strategy = val;
+			else throw fail(`unknown ${import_keys.wake} strategy '${val}'. Use 'load' | 'idle' | 'visible' | 'interaction' | a media query.`);
+			const options = {};
+			if (strategy === "visible") options.margin = attrs.get("margin") ?? ctx.visibleMargin ?? void 0;
+			if (attrs.has("keep")) {
+				const p = String(attrs.get("keep")).trim();
+				if (!p) throw fail(`\`keep\` needs a non-empty name (e.g. keep: 'player').`);
+				options.keep = p;
+			}
+			return {
+				strategy,
+				options
+			};
+		}
+		return null;
+	}
+	/** Depth-first: the first `import.meta.og.asRegion(…)` CallExpression in a subtree (a STRAY use). */
+	#find_stray_as_region(node) {
+		if (!node || typeof node !== "object") return null;
+		if (Array.isArray(node)) {
+			for (const n of node) {
+				const hit = this.#find_stray_as_region(n);
+				if (hit) return hit;
+			}
+			return null;
+		}
+		if (node.type === "CallExpression" && is_import_meta_og(node.callee, "asRegion")) return node;
+		for (const k in node) {
+			if (k === "type" || k === "start" || k === "end" || k === "loc" || k === "parent") continue;
+			const v = node[k];
+			if (v && typeof v === "object") {
+				const hit = this.#find_stray_as_region(v);
+				if (hit) return hit;
+			}
+		}
+		return null;
+	}
+	/** Non-fallback children on a hydrate/defer call site cannot cross devalue — reject. */
+	#assert_portable_children(node, local, is_server) {
+		const kids = (node.fragment?.nodes ?? []).filter((n) => !(n.type === "Text" && !String(n.data ?? "").trim()));
+		if (kids.length === 0) return;
+		if (is_server && kids.length === 1 && kids[0].type === "SnippetBlock" && kids[0].expression?.name === "ogygiaFallback") return;
+		throw new Error(`[ogygia] ${this.#rel_host}: <${local}> has host children/snippets that cannot cross the island boundary. Under portable bindings, pass serializable props and put UI inside the island component` + (is_server ? ` (only the reserved \`{#snippet ogygiaFallback()}\` may appear at the call site).` : `.`));
+	}
+	/** Walk the markup: enforce region-usage rules + surface whether a hydrate island has real
+	*  children (the app then needs the wire slot revivers). Mutates #has_island_children. */
+	#visit_usages(nodes) {
+		for (const node of nodes ?? []) {
+			if (node.type === "Component") {
+				const name = node.name || "";
+				if (name.includes(".")) {
+					const root = name.split(".")[0];
+					if (this.#marked_components.has(root) && this.#marked_components.get(root).strategy !== "lake") throw new Error(`[ogygia] ${this.#rel_host}: dotted tag \`<${name}>\` is not supported for region import '${root}'. Import the leaf component with \`with { hydrate|defer }\` instead.`);
+				} else if (this.#marked_components.has(name)) {
+					this.#static_placed.add(name);
+					const mark = this.#marked_components.get(name);
+					if (mark.strategy === "lake") {
+						if (mark.options?.remount === "swr") assert_swr_lake_crossable(node, (specifiers, msg) => this.#err(specifiers, msg));
+					} else if (mark.strategy === "server" || mark.strategy === "held") this.#assert_portable_children(node, name, mark.strategy === "server");
+					else if ((node.fragment?.nodes ?? []).filter((n) => !(n.type === "Text" && !String(n.data ?? "").trim())).length) this.#has_island_children = true;
+				}
+			}
+			for (const k of CHILD_KEYS) if (node[k]?.nodes) this.#visit_usages(node[k].nodes);
+		}
+	}
+	/** Root-relative posix path — island ids must not drift across Windows/POSIX build legs. */
+	#posix_rel(abs) {
+		return this.#ctx.pathModule.relative(this.#ctx.root, abs).split(PATH_SEP).join("/");
+	}
+	/**
+	* Region-identity path for a component: filesystem components key on their root-relative posix
+	* path; a package specifier IS its own identity (already stable + posix, and identical across
+	* hosts — so two hosts marking the same package import share one region id). A file under a
+	* DECLARED `ogygia.files` package keys as `<pkg-name>/<rel>` instead of root-relative: pnpm
+	* store paths carry version+peer hashes, so a root-relative key would change per install and
+	* prod HTML would stop matching its chunks.
+	*/
+	#component_identity(p) {
+		if (!this.#ctx.pathModule.isAbsolute(p)) return p;
+		return (typeof this.#ctx.pkg_identity === "function" ? this.#ctx.pkg_identity(p) : null) ?? this.#posix_rel(p);
+	}
+	/** `[ogygia] host: import { … } — msg` — the region-import error formatter. */
+	#err(specifiers, msg) {
+		return /* @__PURE__ */ new Error(`[ogygia] ${this.#rel_host}: import { ${specifiers} } — ${msg}`);
+	}
+	/** `[ogygia] host: import.meta.og.asRegion (local) — msg` — the asRegion error formatter. */
+	#as_err(local, msg) {
+		return /* @__PURE__ */ new Error(`[ogygia] ${this.#rel_host}: import.meta.og.asRegion (${local}) — ${msg}`);
+	}
+	/** Read asRegion's options object into the same key→value map an import attribute produces, so the
+	*  SHARED parser gives asRegion EXACTLY the import-attribute option surface. Object-only and
+	*  string-valued — the same shape as a `with { … }` clause. */
+	#as_region_inline(arg, local) {
+		if (!arg || arg.type !== "ObjectExpression") throw this.#as_err(local, `needs an options object — \`import.meta.og.asRegion(Comp, { wake: 'load' })\`, the same shape as \`with { … }\`.`);
+		const inline = /* @__PURE__ */ new Map();
+		for (const p of arg.properties ?? []) {
+			if (p.type !== "Property" || p.computed) throw this.#as_err(local, "options must be a plain object of string-valued keys.");
+			const key = p.key?.name ?? p.key?.value;
+			if (p.value?.type !== "Literal" || typeof p.value.value !== "string") throw this.#as_err(local, `option \`${key}\` must be a string literal (region options are string-valued, exactly like an import attribute).`);
+			inline.set(String(key), String(p.value.value));
+		}
+		return inline;
+	}
+	/**
+	* Analyze — read the host's AST into the compilation's fields: its imports, region marks (import
+	* attributes + `asRegion` call sites), the usage findings, and the csr tri-state. No MagicString,
+	* no rewriting — a pure "what does this file declare" pass. Returns `{ done }` for an early exit (a
+	* csr=true route host, the cheap island-hint bailout, a snippet-less file with no islands), or
+	* `null` once the fields are populated and `#lower()` should run.
+	*/
+	#analyze() {
+		const source = this.#source;
+		const id = this.#id;
+		const ctx = this.#ctx;
+		const import_keys = this.#import_keys;
+		const has_island_hint = import_keys_hint(import_keys).test(source);
+		if (ctx.routeCsr === true) return { done: has_island_hint || source.includes("asRegion") ? transform_csr_true_host(source, id, has_island_hint, import_keys) : null };
+		if (!has_island_hint && !source.includes("{#snippet") && !source.includes("asRegion")) return { done: null };
+		let ast;
+		try {
+			ast = parse(blank_styles(source), {
+				modern: true,
+				filename: id
+			});
+		} catch (err) {
+			warn_unparsed(id, err);
+			return { done: null };
+		}
+		const instance_body = ast.instance?.content?.body ?? [];
+		const module_body = ast.module?.content?.body ?? [];
+		const lang = script_lang_attr(ast.instance) || script_lang_attr(ast.module);
+		const path = ctx.pathModule;
+		const rel_host = this.#rel_host = path.relative(ctx.root, id).split(PATH_SEP).join("/");
+		reject_dynamic_region_imports(instance_body, import_keys, (keys) => {
+			throw new Error(`[ogygia] ${rel_host}: dynamic import() with { with: { ${keys.join(", ")} } } is not supported. Mark islands with a static \`import X from '…' with { ${import_keys.wake}: '…' }\` (or \`${import_keys.render}\` / \`${import_keys.preset}\`) — the binding becomes a portable island component. For a click-loaded chunk that is not an island, use plain \`await import('./Comp.svelte')\` (no region attributes) inside a host island. To delay a real island until click, gate a static region import with \`{#if}\`.`);
+		});
+		reject_dynamic_region_imports(module_body, import_keys, (keys) => {
+			throw new Error(`[ogygia] ${rel_host}: dynamic import() with { with: { ${keys.join(", ")} } } is not supported. Mark islands with a static \`import X from '…' with { ${import_keys.wake}: '…' }\` (or \`${import_keys.render}\` / \`${import_keys.preset}\`) — the binding becomes a portable island component. For a click-loaded chunk that is not an island, use plain \`await import('./Comp.svelte')\` (no region attributes) inside a host island. To delay a real island until click, gate a static region import with \`{#if}\`.`);
+		});
+		/** localName -> { node, cleaned } */
+		const imports = /* @__PURE__ */ new Map();
+		/** localName -> { strategy, options } */
+		const marked_components = this.#marked_components = /* @__PURE__ */ new Map();
+		const imports_to_strip = /* @__PURE__ */ new Set();
+		for (const node of instance_body) {
+			if (node.type !== "ImportDeclaration") continue;
+			const cleaned = clean_import_text(source, node);
+			for (const spec of node.specifiers) imports.set(spec.local.name, {
+				node,
+				cleaned
+			});
+			const attr_list = (node.attributes ?? []).filter((a) => a.type === "ImportAttribute");
+			if (attr_list.length === 0) continue;
+			const inline = /* @__PURE__ */ new Map();
+			for (const a of attr_list) inline.set(a.key.name ?? a.key.value, String(a.value.value));
+			const names = node.specifiers.map((sp) => sp.local.name).join(", ");
+			const mark = this.#resolve_region_mark(inline, (m) => this.#err(names, m));
+			if (!mark) continue;
+			for (const spec of node.specifiers) marked_components.set(spec.local.name, mark);
+		}
+		const synthetic_export = /* @__PURE__ */ new Map();
+		const as_regions = [];
+		const as_region_nodes = /* @__PURE__ */ new Set();
+		for (const node of instance_body) {
+			if (node.type !== "VariableDeclaration") continue;
+			if (node.declarations.filter((d) => d.init?.type === "CallExpression" && is_import_meta_og(d.init.callee, "asRegion")).length === 0) continue;
+			if (node.kind !== "const") throw this.#as_err(node.declarations[0]?.id?.name ?? "?", `asRegion must be bound with \`const\` (not \`${node.kind}\`) — it compiles to an import binding.`);
+			if (node.declarations.length !== 1) throw this.#as_err(node.declarations[0]?.id?.name ?? "?", "declare one asRegion per `const X = import.meta.og.asRegion(…)` statement.");
+			const decl = node.declarations[0];
+			if (decl.id?.type !== "Identifier") throw this.#as_err("?", "must bind to a plain `const Name = …`.");
+			const local = decl.id.name;
+			const call_args = decl.init.arguments ?? [];
+			const comp_arg = call_args[0];
+			if (!comp_arg || comp_arg.type !== "Identifier") throw this.#as_err(local, "the first argument must be a component you imported (a bare identifier).");
+			if (marked_components.has(comp_arg.name)) throw this.#as_err(local, `'${comp_arg.name}' is already marked an island with an import attribute (\`with { … }\`). Use the import attribute OR asRegion, not both.`);
+			const info = imports.get(comp_arg.name);
+			if (!info) throw this.#as_err(local, `'${comp_arg.name}' is not an imported component — import it first (e.g. \`import { ${comp_arg.name} } from './…'\`).`);
+			const binding = import_binding_of(info.node, comp_arg.name);
+			if (!binding || "namespace" in binding) throw this.#as_err(local, `'${comp_arg.name}' must be a default or named import, not a namespace import.`);
+			const mark = this.#resolve_region_mark(this.#as_region_inline(call_args[1], local), (m) => this.#as_err(local, m));
+			if (!mark) throw this.#as_err(local, "needs a `wake`, `render`, `region`, or `preset` option.");
+			imports.set(local, {
+				node: {
+					start: node.start,
+					end: node.end,
+					type: "ImportDeclaration",
+					source: { value: binding.source },
+					specifiers: [{
+						type: "ImportDefaultSpecifier",
+						local: { name: local }
+					}],
+					attributes: []
+				},
+				cleaned: ""
+			});
+			marked_components.set(local, mark);
+			synthetic_export.set(local, binding.exportName);
+			as_regions.push({
+				local,
+				compLocal: comp_arg.name,
+				node
+			});
+			as_region_nodes.add(node);
+		}
+		for (const place of [
+			...instance_body.filter((n) => !as_region_nodes.has(n)),
+			...module_body,
+			...ast.fragment?.nodes ?? []
+		]) {
+			const stray = this.#find_stray_as_region(place);
+			if (stray) {
+				const arg = stray.arguments?.[0];
+				throw this.#as_err(arg?.type === "Identifier" ? arg.name : "?", "must be a top-level `const Name = import.meta.og.asRegion(Comp, timing)` in the instance <script> — it compiles to a hoisted import, so it can never sit inside a loop, function, block, larger expression, `<script module>`, or markup.");
+			}
+		}
+		if (marked_components.size === 0 && as_regions.length === 0 && !source.includes("{#snippet")) return { done: null };
+		/** Non-fallback children on a hydrate/defer call site cannot cross devalue — reject. */
+		this.#has_island_children = false;
+		this.#static_placed = /* @__PURE__ */ new Set();
+		this.#visit_usages(ast.fragment?.nodes ?? []);
+		this.#ast = ast;
+		this.#instance_body = instance_body;
+		this.#module_body = module_body;
+		this.#lang = lang;
+		this.#rel_host = rel_host;
+		this.#import_keys = import_keys;
+		this.#imports = imports;
+		this.#imports_to_strip = imports_to_strip;
+		this.#as_regions = as_regions;
+		this.#as_region_nodes = as_region_nodes;
+		this.#synthetic_export = synthetic_export;
+		this.#has_island_hint = has_island_hint;
+		return null;
+	}
+	/**
+	* Lower — the compilation's fields → rewritten source + `IslandDescriptor[]`. Consumes ONLY the
+	* analyze pass's fields (it never re-reads the file): creates the MagicString, rewrites each marked
+	* import to its wrapper / binding / stub, mints the island records, and brands portable snippets.
+	* `err` / `ast_refs_local` / `marked_import_referenced` are rebuilt here from those fields — pure
+	* over the AST + host path.
+	*/
+	#lower() {
+		const source = this.#source;
+		const id = this.#id;
+		const ctx = this.#ctx;
+		const ast = this.#ast;
+		const instance_body = this.#instance_body;
+		const module_body = this.#module_body;
+		const lang = this.#lang;
+		const rel_host = this.#rel_host;
+		const import_keys = this.#import_keys;
+		const imports = this.#imports;
+		const marked_components = this.#marked_components;
+		const imports_to_strip = this.#imports_to_strip;
+		const as_regions = this.#as_regions;
+		const as_region_nodes = this.#as_region_nodes;
+		const synthetic_export = this.#synthetic_export;
+		const has_island_children = this.#has_island_children;
+		const has_island_hint = this.#has_island_hint;
+		const path = ctx.pathModule;
+		const s = new MagicString(source);
+		const origin = typeof ctx.originOf === "function" ? ctx.originOf(id) || id : id;
+		const islands_by_id = /* @__PURE__ */ new Map();
+		const salt = ctx.idSalt || "";
+		const wrapperPathFor = typeof ctx.wrapperPathFor === "function" ? ctx.wrapperPathFor : (_host, iid) => wrapperVirtualId(iid);
+		const link_virtual = ctx.linkVirtualIsland !== false;
+		const binding_stub = typeof ctx.clientBindingStub === "string" && ctx.clientBindingStub ? ctx.clientBindingStub : CLIENT_BINDING_STUB;
+		const rewritten_import_nodes = /* @__PURE__ */ new Set();
+		/** Entry module specs already emitted as side-effect CSS imports on this host. */
+		const fouc_css_specs = /* @__PURE__ */ new Set();
+		/**
+		* Kit links CSS only from the *client* page graph, so a marked component whose scoped CSS is
+		* NOT in that graph must side-effect-import `virtual:ogygia/fouc-css/<entry>` (the CSS graph
+		* only — not the component JS) to ship its stylesheet without dual-owning the module emitFile
+		* registers as `og-region.*`. When the CSS *is* absent from the client graph depends on the
+		* binding, not on `link_virtual` alone:
+		*   - island STUB leg (`!link_virtual`), DEV only: no component in the graph → needs the link
+		*     (Vite serves component CSS as modules; the graph is the only way it reaches the page).
+		*     In a BUILD the link is dropped: Kit would link the CSS of every marked import the host
+		*     declares, rendered or not, while Region.svelte already links exactly the islands that
+		*     render (`island_css_html`, from the chunk closure `islandCss()` records) — the render
+		*     pass decides, not the import list. See link/registry-stub.ts for the same rule applied
+		*     to a `.ts` registry the host imports.
+		*   - island real-wrapper leg (`link_virtual`, a csr=true-capable page/layout): the wrapper
+		*     pulls the hydrate entry, which carries the CSS → no link needed.
+		*   - LAKE (`always_link_css`): its inner is client-stubbed to render-nothing on EVERY client
+		*     leg — including the real-wrapper leg a csr=true-capable layout takes — so its CSS never
+		*     reaches the client graph on its own and it always needs the link on a client build.
+		* `ctx.ssr` guards the server build (it renders the real component and collects CSS directly).
+		*/
+		const binding_rewrite = (local, bindingPath, componentPathAbs, always_link_css = false) => {
+			let text = `import ${local} from ${JSON.stringify(bindingPath)};`;
+			if (!ctx.ssr && (always_link_css || !link_virtual && ctx.dev) && typeof componentPathAbs === "string" && componentPathAbs && path.isAbsolute(componentPathAbs) && !fouc_css_specs.has(componentPathAbs)) {
+				fouc_css_specs.add(componentPathAbs);
+				const rel = this.#posix_rel(componentPathAbs);
+				text += `\nimport ${JSON.stringify(foucCssVirtualId(rel))};`;
+			}
+			return text;
+		};
+		const host_declared = /* @__PURE__ */ new Set();
+		const collect_pattern_names = (pat) => {
+			if (!pat) return;
+			if (pat.type === "Identifier") host_declared.add(pat.name);
+			else if (pat.type === "ObjectPattern") for (const p of pat.properties ?? []) collect_pattern_names(p.value ?? p.argument);
+			else if (pat.type === "ArrayPattern") for (const e of pat.elements ?? []) collect_pattern_names(e);
+			else if (pat.type === "RestElement") collect_pattern_names(pat.argument);
+			else if (pat.type === "AssignmentPattern") collect_pattern_names(pat.left);
+		};
+		const declare = (node) => {
+			if (node?.type === "VariableDeclaration") for (const d of node.declarations) collect_pattern_names(d.id);
+			else if (node?.type === "FunctionDeclaration" || node?.type === "ClassDeclaration") {
+				if (node.id?.name) host_declared.add(node.id.name);
+			} else if (node?.type === "ExportNamedDeclaration") declare(node.declaration);
+			else if (node?.type === "LabeledStatement" && node.label?.name === "$") {
+				const e = node.body?.type === "ExpressionStatement" ? node.body.expression : null;
+				if (e?.type === "AssignmentExpression") collect_pattern_names(e.left);
+			}
+		};
+		for (const node of instance_body) declare(node);
+		for (const node of module_body) declare(node);
+		const module_imports = /* @__PURE__ */ new Map();
+		for (const node of module_body) {
+			if (node.type !== "ImportDeclaration") continue;
+			const cleaned = clean_import_text(source, node);
+			for (const spec of node.specifiers) module_imports.set(spec.local.name, cleaned);
+		}
+		const store_like = /* @__PURE__ */ new Set();
+		for (const node of instance_body) {
+			if (node.type !== "VariableDeclaration") continue;
+			for (const d of node.declarations) {
+				const callee = d.init?.type === "CallExpression" ? d.init.callee : null;
+				const cname = callee?.type === "Identifier" ? callee.name : null;
+				if (cname && STORE_CTORS.has(cname) && d.id?.type === "Identifier") store_like.add(d.id.name);
+			}
+		}
+		STORE_SUB_RE.lastIndex = 0;
+		for (let m; m = STORE_SUB_RE.exec(source);) {
+			if (source.charCodeAt(m.index - 1) === 36) continue;
+			if (!RUNE_NAMES.has(m[1])) store_like.add(m[1]);
+		}
+		for (const [local, mark] of marked_components) {
+			const info = imports.get(local);
+			if (!info) continue;
+			if (!this.#marked_import_referenced(local)) {
+				if (!rewritten_import_nodes.has(info.node)) imports_to_strip.add(info.node);
+				continue;
+			}
+			const entry_spec = info.node.source?.value;
+			const componentPath = resolve_component_path(entry_spec, origin, ctx);
+			if (!componentPath) throw new Error(`[ogygia] ${rel_host}: region import '${local}' needs a module specifier ($lib/…, relative, or a package specifier like 'pkg/component').`);
+			const exportName = synthetic_export.get(local);
+			const comp_rel = this.#component_identity(componentPath);
+			const id_base = exportName && exportName !== "default" ? `${comp_rel}#${exportName}` : comp_rel;
+			const identity = regionIdentity(id_base, mark);
+			const iid = regionId(identity, salt);
+			const entryPath = ctx.virtualPathFor(id, iid);
+			const wrapPath = wrapperPathFor(id, iid);
+			const bindingPath = link_virtual ? wrapPath : binding_stub;
+			if (mark.strategy === "lake") {
+				if (!islands_by_id.has(iid)) {
+					const swr = (mark.options?.remount || "cache") === "swr";
+					islands_by_id.set(iid, {
+						id: iid,
+						virtualPath: swr ? entryPath : void 0,
+						source: swr ? island_entry_source(componentPath, iid, exportName) : void 0,
+						wrapperPath: wrapPath,
+						wrapperSource: lake_wrapper_source(iid, componentPath, mark.options, exportName, lang),
+						hostPath: origin,
+						componentPath,
+						server: swr,
+						kind: "lake",
+						lakes: ["OgygiaLakeInner"],
+						identity
+					});
+				}
+				if (!rewritten_import_nodes.has(info.node)) {
+					s.overwrite(info.node.start, info.node.end, binding_rewrite(local, bindingPath, componentPath, true));
+					rewritten_import_nodes.add(info.node);
+				}
+				continue;
+			}
+			if (mark.strategy === "held") {
+				if (!islands_by_id.has(iid)) islands_by_id.set(iid, make_region_binding({
+					iid,
+					componentPath,
+					entryPath,
+					hostPath: origin,
+					moduleUrl: ctx.dev ? ctx.devUrlFor(entryPath) : islandPublicUrl(iid, ctx.appDir),
+					exportName,
+					identity
+				}));
+				if (!rewritten_import_nodes.has(info.node)) {
+					const specs = info.node.specifiers ?? [];
+					if (specs.length !== 1 || specs[0].type !== "ImportDefaultSpecifier") throw this.#err(local, `held-region imports must be a default import (\`import X from '…' with { ${import_keys.region}: 'raw' } \`).`);
+					s.overwrite(info.node.start, info.node.end, `import ${local} from ${JSON.stringify(regionBindingVirtualId(iid))};`);
+					rewritten_import_nodes.add(info.node);
+				}
+				continue;
+			}
+			const is_server = mark.strategy === "server";
+			const deferred_hydrate = is_server && !!mark.options?.hydrate;
+			const wants_attach = !is_server;
+			if (!islands_by_id.has(iid)) islands_by_id.set(iid, is_server ? {
+				id: iid,
+				virtualPath: entryPath,
+				wrapperPath: wrapPath,
+				wrapperSource: server_wrapper_source(iid, componentPath, entryPath, mark.options, exportName, ctx.dev ? ctx.devUrlFor(entryPath) : islandPublicUrl(iid, ctx.appDir), lang),
+				wrapperClientSource: server_wrapper_source(iid, componentPath, entryPath, mark.options, exportName, ctx.dev ? ctx.devUrlFor(entryPath) : islandPublicUrl(iid, ctx.appDir), lang, false),
+				source: island_entry_source(componentPath, iid, exportName),
+				hostPath: origin,
+				componentPath,
+				server: true,
+				kind: deferred_hydrate ? "hydrate" : "defer",
+				lakes: [],
+				identity,
+				strategy: mark.strategy,
+				fetchWhen: mark.options?.when,
+				wakeAfter: deferred_hydrate ? mark.options?.hydrate : void 0,
+				keep: mark.options?.keep
+			} : make_wake_island({
+				iid,
+				componentPath,
+				entryPath,
+				wrapperPath: wrapPath,
+				moduleUrl: ctx.dev ? ctx.devUrlFor(entryPath) : islandPublicUrl(iid, ctx.appDir),
+				strategy: mark.strategy,
+				options: mark.options,
+				exportName,
+				hostPath: origin,
+				identity,
+				lang
+			}));
+			if (!rewritten_import_nodes.has(info.node)) {
+				const specs = info.node.specifiers ?? [];
+				if (specs.length !== 1 || specs[0].type !== "ImportDefaultSpecifier") throw this.#err(local, `region imports must be a default import (\`import X from '…' with { … }\`).`);
+				const rewrite_path = wants_attach && link_virtual ? regionBindingVirtualId(iid) : bindingPath;
+				s.overwrite(info.node.start, info.node.end, binding_rewrite(local, rewrite_path, componentPath));
+				rewritten_import_nodes.add(info.node);
+			}
+		}
+		const as_region_locals = new Set(as_regions.map((r) => r.compLocal));
+		if (as_region_locals.size) {
+			const referenced_outside = (local) => {
+				for (const n of instance_body) {
+					if (n.type === "ImportDeclaration" || as_region_nodes.has(n)) continue;
+					if (this.#ast_refs_local(n, local)) return true;
+				}
+				for (const n of module_body) {
+					if (n.type === "ImportDeclaration") continue;
+					if (this.#ast_refs_local(n, local)) return true;
+				}
+				return this.#ast_refs_local(ast.fragment?.nodes ?? [], local);
+			};
+			const seen = /* @__PURE__ */ new Set();
+			for (const compLocal of as_region_locals) {
+				const info = imports.get(compLocal);
+				if (!info || seen.has(info.node)) continue;
+				seen.add(info.node);
+				if ((info.node.specifiers ?? []).every((sp) => as_region_locals.has(sp.local.name) && !referenced_outside(sp.local.name)) && !rewritten_import_nodes.has(info.node)) imports_to_strip.add(info.node);
+			}
+		}
+		for (const node of imports_to_strip) {
+			if (rewritten_import_nodes.has(node)) continue;
+			s.remove(node.start, node.end);
+		}
+		const OG_PORTABLE = "__og_portable";
+		const portable_candidates = [];
+		const portable_allowed = !id.includes("node_modules");
+		const walk_portable = (nodes) => {
+			for (const node of nodes ?? []) {
+				if (is_component_node(node)) {
+					const base_name = String(node.name || "").split(".")[0];
+					const mark = marked_components.get(base_name);
+					const island_site = !!mark && ![
+						"lake",
+						"server",
+						"held"
+					].includes(mark.strategy);
+					const from_generated = String(imports.get(base_name)?.node?.source?.value ?? "").startsWith("virtual:ogygia/");
+					for (const child of node.fragment?.nodes ?? []) {
+						if (child.type !== "SnippetBlock" || !child.expression?.name) continue;
+						const zero_arg = (child.parameters?.length ?? 0) === 0;
+						if (island_site || !mark && zero_arg && !from_generated) portable_candidates.push({
+							comp: node,
+							snip: child
+						});
+					}
+				}
+				for (const k of CHILD_KEYS) if (node[k]?.nodes) walk_portable(node[k].nodes);
+			}
+		};
+		if (portable_allowed) walk_portable(ast.fragment?.nodes ?? []);
+		const outer_candidates = portable_candidates.filter((c) => !portable_candidates.some((o) => o !== c && c.snip.start >= o.snip.start && c.snip.end <= o.snip.end));
+		const block_bound = /* @__PURE__ */ new Set();
+		const bind_pattern = (n) => {
+			if (!n || typeof n !== "object") return;
+			if (Array.isArray(n)) return n.forEach(bind_pattern);
+			if (n.type === "Identifier" && n.name) block_bound.add(n.name);
+			for (const k in n) {
+				if (k === "type" || k === "start" || k === "end" || k === "loc") continue;
+				const v = n[k];
+				if (v && typeof v === "object") bind_pattern(v);
+			}
+		};
+		const walk_bound = (nodes, root) => {
+			for (const node of nodes ?? []) {
+				if (node.type === "EachBlock") {
+					bind_pattern(node.context);
+					if (node.index) block_bound.add(node.index);
+				} else if (node.type === "AwaitBlock") {
+					bind_pattern(node.value);
+					bind_pattern(node.error);
+				} else if (node.type === "ConstTag") bind_pattern(node.declaration?.declarations?.map((d) => d.id));
+				else if (node.type === "SnippetBlock") {
+					bind_pattern(node.parameters);
+					if (!root && node.expression?.name) block_bound.add(node.expression.name);
+				}
+				for (const a of node.attributes ?? []) {
+					if (a.type !== "LetDirective") continue;
+					if (a.expression) bind_pattern(a.expression);
+					else if (a.name) block_bound.add(a.name);
+				}
+				for (const k of CHILD_KEYS) if (node[k]?.nodes) walk_bound(node[k].nodes, false);
+			}
+		};
+		walk_bound(ast.fragment?.nodes ?? [], true);
+		const root_snippets = /* @__PURE__ */ new Map();
+		for (const n of ast.fragment?.nodes ?? []) if (n.type === "SnippetBlock" && n.expression?.name) root_snippets.set(n.expression.name, n);
+		let portable_emitted = false;
+		const portable_imports = [];
+		const portable_seen = /* @__PURE__ */ new Set();
+		let native_seq = 0;
+		const host_style_src = ast.css ? source.slice(ast.css.start, ast.css.end) : "";
+		for (const { comp, snip } of outer_candidates) {
+			const name = snip.expression.name;
+			const body = snip.body?.nodes ?? [];
+			if (!body.length) continue;
+			const snip_params = snip.parameters ?? [];
+			const params_src = snip_params.length ? source.slice(snip_params[0].start, snip_params[snip_params.length - 1].end) : "";
+			const param_names = /* @__PURE__ */ new Set();
+			const collect_param_names = (n) => {
+				if (!n || typeof n !== "object") return;
+				if (Array.isArray(n)) return n.forEach(collect_param_names);
+				if (n.type === "Identifier" && n.name) param_names.add(n.name);
+				for (const k in n) {
+					if (k === "type" || k === "start" || k === "end") continue;
+					const v = n[k];
+					if (v && typeof v === "object") collect_param_names(v);
+				}
+			};
+			collect_param_names(snip_params);
+			const { free, mutated, stores } = collectCaptureInfo(body);
+			if ([...free].some((nm) => block_bound.has(nm) && !param_names.has(nm))) continue;
+			if ([...mutated].some((m) => !param_names.has(m))) continue;
+			const carried = [];
+			const pending = [...free].filter((nm) => root_snippets.has(nm) && !param_names.has(nm));
+			const carried_names = /* @__PURE__ */ new Set();
+			let carry_blocked = false;
+			while (pending.length && !carry_blocked) {
+				const nm = pending.pop();
+				if (carried_names.has(nm)) continue;
+				carried_names.add(nm);
+				const node = root_snippets.get(nm);
+				const info = collectCaptureInfo([node]);
+				if (info.mutated.size || info.stores.size) carry_blocked = true;
+				carried.push(node);
+				for (const f of info.free) if (root_snippets.has(f)) pending.push(f);
+				else free.add(f);
+			}
+			if (carry_blocked) continue;
+			for (const nm of carried_names) free.delete(nm);
+			const store_captures = [];
+			const store_rewrites = [];
+			for (const [nm, sites] of stores) {
+				if (nm.startsWith("$$")) throw new Error(`[ogygia] ${rel_host}: {#snippet ${name}} crosses an island boundary but reads \`${nm}\` — the host's $$-props cannot cross. Read the value into a plain host variable outside the snippet and use that instead.`);
+				const base = nm.slice(1);
+				const prop = `__og_sub_${base}`;
+				store_captures.push({
+					prop,
+					expr: nm
+				});
+				for (const p of sites) store_rewrites.push({
+					start: p.start,
+					end: p.end,
+					prop
+				});
+				const trace = sites.map((p) => `${rel_host}:${line_col(source, p.start)}`).join(", ");
+				if (host_declared.has(base) || imports.has(base)) warn_once(`${id}\0${name}\0${nm}\0frozen`, `[ogygia] ${rel_host}: {#snippet ${name}} crosses an island boundary and reads \`${nm}\` (at ${trace}) — captured as a FROZEN snapshot of the store's value at render time; later store updates never reach the island. To make the snapshot explicit (and silence this), read it at host scope outside the snippet — e.g. \`const ${base}_value = ${nm};\` — and use that.`);
+				else warn_once(`${id}\0${name}\0${nm}\0unresolved`, `[ogygia] ${rel_host}: {#snippet ${name}} reads \`${nm}\` (at ${trace}), but \`${base}\` is not a host declaration or import, so ogygia cannot verify it is a store. Its value is captured at the host anyway — if the build now errors in ${rel_host}, start there.`);
+			}
+			const cleaned_imports = [];
+			const seen_imports = /* @__PURE__ */ new Set();
+			const captures = [];
+			for (const nm of free) {
+				if (nm.startsWith("$")) continue;
+				if (param_names.has(nm)) continue;
+				if (imports.has(nm)) {
+					const info = imports.get(nm);
+					const text = marked_components.has(nm) ? source.slice(info.node.start, info.node.end).trim() : info.cleaned.trim();
+					if (!seen_imports.has(text)) {
+						seen_imports.add(text);
+						cleaned_imports.push(text);
+					}
+				} else if (host_declared.has(nm)) {
+					if (store_like.has(nm)) warn_once(`${id}\0${name}\0${nm}\0object`, `[ogygia] ${rel_host}: {#snippet ${name}} crosses an island boundary and captures the store \`${nm}\` as an OBJECT — a host-declared store cannot cross (its functions don't serialize). Use its value (\`$${nm}\`) inside the snippet, or share live state with a wired class instead.`);
+					captures.push(nm);
+				} else if (module_imports.has(nm)) {
+					const text = module_imports.get(nm).trim();
+					if (!seen_imports.has(text)) {
+						seen_imports.add(text);
+						cleaned_imports.push(text);
+					}
+				}
+			}
+			const body_start = body[0].start;
+			const body_end = body[body.length - 1].end;
+			let markup;
+			if (store_rewrites.length) {
+				store_rewrites.sort((a, b) => a.start - b.start);
+				let out = "";
+				let cursor = body_start;
+				for (const r of store_rewrites) {
+					out += source.slice(cursor, r.start) + r.prop;
+					cursor = r.end;
+				}
+				markup = out + source.slice(cursor, body_end);
+			} else markup = source.slice(body_start, body_end);
+			const carried_src = carried.map((n) => source.slice(n.start, n.end)).join("\n");
+			const hash = createHash("md5").update(`${markup}\0${captures.join(",")}\0${cleaned_imports.join("\n")}\0${params_src}\0${carried_src}`).digest("hex").slice(0, 12);
+			const identity = regionIdentity(`${this.#component_identity(this.#id)}\0psnip:${hash}`, { strategy: "hydrate" });
+			const iid = regionId(identity, salt);
+			const entryPath = ctx.virtualPathFor(id, iid).replace(JS_EXT, ".svelte");
+			if (!islands_by_id.has(iid)) {
+				const store_props = store_captures.map((c) => c.prop);
+				const prop_names = snip_params.length ? [
+					"__ogArgs = []",
+					...captures,
+					...store_props
+				] : [...captures, ...store_props];
+				const wrapped = body.some((n) => n.type === "ConstTag");
+				const template = (carried_src ? carried_src + "\n" : "") + (wrapped ? `{#snippet __og_body()}\n${markup}\n{/snippet}\n{@render __og_body()}` : markup);
+				const synth = `<script${lang}>\n\timport 'virtual:ogygia/transportables-eager';\n` + cleaned_imports.map((imp) => `\t${imp}\n`).join("") + (prop_names.length ? `\t// svelte-ignore state_referenced_locally\n\tlet { ${prop_names.join(", ")} } = $props();\n` : "") + (snip_params.length ? `\t// svelte-ignore state_referenced_locally\n\tconst [${params_src}] = __ogArgs;\n` : "") + `<\/script>\n` + template + "\n" + (host_style_src ? host_style_src + "\n" : "");
+				islands_by_id.set(iid, {
+					id: iid,
+					virtualPath: entryPath,
+					wrapperPath: wrapperPathFor(id, iid),
+					wrapperSource: "",
+					source: synth,
+					hostPath: origin,
+					componentPath: entryPath,
+					server: false,
+					kind: "hydrate",
+					lakes: [],
+					identity,
+					strategy: "hydrate",
+					portable: true
+				});
+			}
+			const url = ctx.dev ? ctx.devUrlFor(entryPath) : islandPublicUrl(iid, ctx.appDir);
+			const cap_entries = [...captures, ...store_captures.map((c) => `${c.prop}: ${c.expr}`)];
+			const cap_obj = cap_entries.length ? `{ ${cap_entries.join(", ")} }` : "{}";
+			const entry_ref = ctx.ssr ? `__OgPS_${iid}` : "null";
+			if (!portable_seen.has(iid)) {
+				portable_seen.add(iid);
+				if (ctx.ssr) portable_imports.push(`import __OgPS_${iid} from ${JSON.stringify(entryPath)};`);
+			}
+			const native_name = `__og_native_${name}_${native_seq++}`;
+			s.move(snip.start, snip.end, source.length);
+			s.overwrite(snip.expression.start, snip.expression.end, native_name);
+			const insert_at = comp.start + 1 + String(comp.name).length;
+			s.appendLeft(insert_at, ` ${name}={${OG_PORTABLE}(${native_name}, ${entry_ref}, ${cap_obj}, ${JSON.stringify(url)})}`);
+			portable_emitted = true;
+		}
+		{
+			let head = "";
+			if (portable_emitted) head += `import { og_portable as ${OG_PORTABLE} } from 'ogygia/internal';\n` + portable_imports.join("\n") + "\n";
+			if (head) {
+				if (ast.instance) s.appendLeft(ast.instance.content.start, `\n${head}`);
+				else s.prepend(`<script${lang}>\n${head}<\/script>\n`);
+			}
+		}
+		if (!has_island_hint && !portable_emitted && islands_by_id.size === 0) return null;
+		const has_dynamic_island_use = [...marked_components].some(([name, m]) => m.strategy !== "server" && m.strategy !== "held" && m.strategy !== "lake" && !this.#static_placed.has(name));
+		return {
+			code: s.toString(),
+			map: s.generateMap({
+				hires: true,
+				source: id,
+				includeContent: true
+			}),
+			islands: [...islands_by_id.values()],
+			hasWireCrossing: has_island_children || has_dynamic_island_use || portable_emitted
+		};
+	}
+};
+/** Parse a flat import-attributes clause body (`a: 'x', b: "y"`) into a key→value map. */
+/**
+* Parse the flat body of an import-attributes clause (`with { a: 'x', b: "y" }`) into a map.
+* Values must be string literals (the only form ogygia marks use).
+* @param raw the text between the `with {` and `}`
+* @returns
+*/
+function parse_import_attrs(raw) {
+	const attrs = /* @__PURE__ */ new Map();
+	IMPORT_ATTR_PAIR_G.lastIndex = 0;
+	let m;
+	while (m = IMPORT_ATTR_PAIR_G.exec(raw)) {
+		const key = m[1].replace(WRAP_QUOTES, "");
+		const val = m[2].slice(1, -1);
+		attrs.set(key, val);
+	}
+	return attrs;
+}
+/**
+* Rewrite held-region imports in a `.ts` / `.js` module (a load or remote function, where held
+* regions are minted and handed to `region()`). Svelte's `parse()` can't read these files, so this is
+* a targeted regex pass over the (only supported) default-import form. A `.ts` module has no template,
+* so every marked import here is HELD → a descriptor. Two markers:
+*   - `region: 'raw'` → bakes no schedule (set at the `region()` call).
+*   - `wake: 'x'`     → bakes that schedule (the `region()` call can still override).
+* Each registers a server-manifest entry + client chunk and is rewritten to import the leg-split
+* descriptor module. Returns the same `{code, map, islands}` shape, or `null` when nothing matched.
+*
+* @param source
+* @param id absolute module path
+* @param ctx same context fields as {@link transformHost} (root, libDir, dev, devUrlFor,
+*   virtualPathFor, importKeys, idSalt, pathModule)
+* @returns
+*/
+/** Byte ranges of every template/string literal AND comment in a `.ts`/`.js` source, or `null` if it
+*  doesn't parse. Used to tell a REAL held-region import from one that is only TEXT inside a code
+*  sample — whether that sample sits in a template/string literal or a JSDoc `@example` comment. */
+function ts_literal_ranges(source, id) {
+	const { program, ok, comments } = parse_module(source, id);
+	if (!ok || !program) return null;
+	const ranges = [];
+	const walk = (n) => {
+		if (!n || typeof n !== "object") return;
+		if (Array.isArray(n)) return void n.forEach(walk);
+		const node = n;
+		const t = node.type;
+		const is_str = (t === "Literal" || t === "StringLiteral") && typeof node.value === "string";
+		if ((t === "TemplateLiteral" || is_str) && typeof node.start === "number" && typeof node.end === "number") ranges.push([node.start, node.end]);
+		for (const k in node) {
+			if (k === "type" || k === "start" || k === "end") continue;
+			const v = node[k];
+			if (v && typeof v === "object") walk(v);
+		}
+	};
+	walk(program);
+	for (const c of comments) if (typeof c.start === "number" && typeof c.end === "number") ranges.push([c.start, c.end]);
+	return ranges;
+}
+/** Fallback for {@link ts_literal_ranges} when the file doesn't parse: is `pos` preceded by an odd
+*  number of unescaped backticks (i.e. inside an unterminated template literal)? */
+function odd_unescaped_backticks_before(source, pos) {
+	let backticks = 0;
+	for (let i = 0; i < pos; i++) if (source[i] === "`" && source[i - 1] !== "\\") backticks++;
+	return backticks % 2 === 1;
+}
+function transformTsRegions(source, id, ctx) {
+	return new TsRegionCompilation(source, id, ctx).run();
+}
+/**
+* `TsRegionCompilation` — the per-file compilation unit for a `.ts`/`.js` region module (a held
+* registry / remote). A `.ts` module has no template, so every mark mints a HELD binding (mountable +
+* crossable) through the SAME emitters the `.svelte` host uses. Ephemeral state lives on `this`;
+* `run()` is the single pass — scan `with { … }` imports + `asRegion` call sites and rewrite each to
+* its binding import. A fresh instance per file, like {@link FileCompilation}.
+*/
+var TsRegionCompilation = class {
+	#source;
+	#id;
+	#ctx;
+	#import_keys;
+	#regionKey;
+	#wakeKey;
+	#path;
+	#root;
+	#salt;
+	#rel_host;
+	constructor(source, id, ctx) {
+		this.#source = source;
+		this.#id = id;
+		this.#ctx = ctx;
+		this.#import_keys = normalize_import_keys(ctx.importKeys);
+		this.#regionKey = this.#import_keys.region;
+		this.#wakeKey = this.#import_keys.wake;
+		this.#path = ctx.pathModule;
+		this.#root = ctx.root;
+		this.#salt = ctx.idSalt || "";
+		this.#rel_host = this.#path.relative(this.#root, id).split(PATH_SEP).join("/");
+	}
+	/** Root-relative posix path (see FileCompilation#posix_rel). */
+	#posix_rel(abs) {
+		return this.#path.relative(this.#root, abs).split(PATH_SEP).join("/");
+	}
+	/** `[ogygia] host: import.meta.og.asRegion (local) — msg`. */
+	#as_err(local, msg) {
+		return /* @__PURE__ */ new Error(`[ogygia] ${this.#rel_host}: import.meta.og.asRegion (${local}) — ${msg}`);
+	}
+	/**
+	* Same policy as transformHost's resolve_component_path: $lib/relative → absolute file path,
+	* anything else (package specifier / alias) is kept verbatim and re-emitted for Vite to resolve.
+	*/
+	#resolve_spec(spec) {
+		const ctx = this.#ctx;
+		const path = this.#path;
+		if (typeof spec !== "string" || !spec.trim()) return null;
+		if (spec === "$lib" || spec.startsWith("$lib/")) return path.join(ctx.libDir, spec === "$lib" ? "" : spec.slice(5));
+		if (spec.startsWith(".")) return path.resolve(path.dirname(this.#id), spec);
+		return spec;
+	}
+	/** Region-identity path — filesystem components key on their posix path; a package spec is its
+	*  own. Declared-package files key `<pkg-name>/<rel>` (install-independent — see
+	*  FileCompilation#component_identity); duck-typed like wrapperPathFor, host ctxs may lack it. */
+	#component_identity(p) {
+		if (!this.#path.isAbsolute(p)) return p;
+		const ctx = this.#ctx;
+		return (typeof ctx.pkg_identity === "function" ? ctx.pkg_identity(p) : null) ?? this.#posix_rel(p);
+	}
+	#wrapper_path_for(wid) {
+		const ctx = this.#ctx;
+		return typeof ctx.wrapperPathFor === "function" ? ctx.wrapperPathFor(this.#id, wid) : wrapperVirtualId(wid);
+	}
+	#emit_ts_region(componentPath, marker, exportName) {
+		const comp_rel = this.#component_identity(componentPath);
+		const id_base = exportName && exportName !== "default" ? `${comp_rel}#${exportName}` : comp_rel;
+		const fetchKey = this.#import_keys.fetch;
+		const renderKey = this.#import_keys.render;
+		if (marker.fetch != null && marker.render == null) throw new Error(`[ogygia] ${this.#rel_host}: \`${fetchKey}: '${marker.fetch}'\` without \`${renderKey}: 'deferred'\` — \`${fetchKey}\` is a hole's timing. Write \`${renderKey}: 'deferred', ${fetchKey}: '${marker.fetch}'\` for a hole, or \`${this.#wakeKey}: '${marker.fetch}'\` for an island.`);
+		if (marker.render != null) {
+			if (marker.render !== "deferred") throw new Error(marker.render === "live" ? `[ogygia] ${this.#rel_host}: \`${renderKey}: 'live'\` is not supported on a .ts import — use it in a .svelte file.` : `[ogygia] ${this.#rel_host}: unknown \`${renderKey}\` '${marker.render}'. Use 'deferred'.`);
+			if (marker.wake != null) throw new Error(`[ogygia] ${this.#rel_host}: a \`${renderKey}: 'deferred'\` hole timed with \`${this.#wakeKey}: '${marker.wake}'\` — that spelling is gone. Write \`${renderKey}: 'deferred', ${fetchKey}: '${marker.wake}'\` instead: \`${fetchKey}\` says when a hole's HTML arrives. (\`${this.#wakeKey}\` is when an island's JS runs; a hole ships no JS.)`);
+			const dval = marker.fetch ?? "load";
+			let when;
+			if (DEFER_STRATEGIES.has(dval)) when = dval;
+			else if (is_media_query(dval)) when = dval;
+			else throw new Error(`[ogygia] ${this.#rel_host}: \`${fetchKey}: '${dval}'\` is not a timing. Use \`${fetchKey}: 'load' | 'idle' | 'visible' | 'interaction'\` or a media query (a hole must fetch — not 'none').`);
+			const options = { when };
+			if (when === "visible" && this.#ctx.visibleMargin != null) options.margin = this.#ctx.visibleMargin;
+			const identity = regionIdentity(id_base, {
+				strategy: "server",
+				options
+			});
+			const iid = regionId(identity, this.#salt);
+			const entryPath = this.#ctx.virtualPathFor(this.#id, iid);
+			const wrapPath = this.#wrapper_path_for(iid);
+			return {
+				iid,
+				importFrom: wrapPath,
+				record: {
+					id: iid,
+					virtualPath: entryPath,
+					wrapperPath: wrapPath,
+					wrapperSource: server_wrapper_source(iid, componentPath, entryPath, options, exportName, this.#ctx.dev ? this.#ctx.devUrlFor(entryPath) : islandPublicUrl(iid, this.#ctx.appDir), ""),
+					wrapperClientSource: server_wrapper_source(iid, componentPath, entryPath, options, exportName, this.#ctx.dev ? this.#ctx.devUrlFor(entryPath) : islandPublicUrl(iid, this.#ctx.appDir), "", false),
+					source: island_entry_source(componentPath, iid, exportName),
+					hostPath: this.#id,
+					componentPath,
+					server: true,
+					kind: "defer",
+					lakes: [],
+					identity,
+					strategy: "server",
+					fetchWhen: options.when
+				}
+			};
+		}
+		if (marker.region != null) {
+			normalize_region_value(marker.region, this.#rel_host, this.#regionKey);
+			const identity = regionIdentity(id_base, {
+				strategy: "held",
+				options: {}
+			});
+			const iid = regionId(identity, this.#salt);
+			const entryPath = this.#ctx.virtualPathFor(this.#id, iid);
+			return {
+				iid,
+				importFrom: regionBindingVirtualId(iid),
+				record: make_region_binding({
+					iid,
+					componentPath,
+					entryPath,
+					hostPath: this.#id,
+					moduleUrl: this.#ctx.dev ? this.#ctx.devUrlFor(entryPath) : islandPublicUrl(iid, this.#ctx.appDir),
+					exportName,
+					identity
+				})
+			};
+		}
+		const strategy = normalize_hydrate_value(marker.wake, this.#rel_host, this.#wakeKey);
+		const hydrateMargin = strategy === "visible" && this.#ctx.visibleMargin != null ? this.#ctx.visibleMargin : void 0;
+		const identity = regionIdentity(id_base, {
+			strategy: "held",
+			options: hydrateMargin ? {
+				hydrate: strategy,
+				hydrateMargin
+			} : { hydrate: strategy }
+		});
+		const iid = regionId(identity, this.#salt);
+		const entryPath = this.#ctx.virtualPathFor(this.#id, iid);
+		return {
+			iid,
+			importFrom: regionBindingVirtualId(iid),
+			record: make_wake_island({
+				iid,
+				componentPath,
+				entryPath,
+				wrapperPath: this.#wrapper_path_for(iid),
+				moduleUrl: this.#ctx.dev ? this.#ctx.devUrlFor(entryPath) : islandPublicUrl(iid, this.#ctx.appDir),
+				strategy,
+				options: hydrateMargin ? { margin: hydrateMargin } : {},
+				hostPath: this.#id,
+				identity,
+				lang: "",
+				held: true,
+				exportName
+			})
+		};
+	}
+	run() {
+		const source = this.#source;
+		const id = this.#id;
+		const import_keys = this.#import_keys;
+		const regionKey = this.#regionKey;
+		const wakeKey = this.#wakeKey;
+		const renderKey = import_keys.render;
+		const fetchKey = import_keys.fetch;
+		const has_as_region = source.includes("asRegion");
+		if (!has_as_region && (!source.includes(regionKey) && !source.includes(wakeKey) && !source.includes(fetchKey) && !source.includes(renderKey) || !source.includes("with"))) return null;
+		const rel_host = this.#rel_host;
+		const s = new MagicString(source);
+		const islands_by_id = /* @__PURE__ */ new Map();
+		let matched = false;
+		const literal_ranges = ts_literal_ranges(source, id);
+		const inside_literal = (pos) => literal_ranges ? literal_ranges.some(([a, b]) => pos >= a && pos < b) : odd_unescaped_backticks_before(source, pos);
+		HELD_IMPORT_G.lastIndex = 0;
+		let m;
+		while (m = HELD_IMPORT_G.exec(source)) {
+			const [full, local, , spec, attrsRaw] = m;
+			const attrs = parse_import_attrs(attrsRaw);
+			const has_render = attrs.has(renderKey);
+			const has_region = attrs.has(regionKey);
+			const has_wake = attrs.has(wakeKey);
+			const has_fetch = attrs.has(fetchKey);
+			if (!has_render && !has_region && !has_wake && !has_fetch) continue;
+			if (inside_literal(m.index)) continue;
+			if (has_region && attrs.size > 1 || has_render && [...attrs.keys()].some((k) => k !== renderKey && k !== wakeKey && k !== fetchKey) || !has_render && has_wake && attrs.size > 1) throw new Error(`[ogygia] ${rel_host}: a held-region import on '${local}' takes ONE marker — \`${regionKey}: 'raw'\`, \`${wakeKey}: '…'\`, or \`${renderKey}: 'deferred'\` (with \`${fetchKey}\` as its timing).`);
+			const componentPath = this.#resolve_spec(spec);
+			if (!componentPath) throw new Error(`[ogygia] ${rel_host}: held-region import '${local}' needs a module specifier ($lib/…, relative, or a package specifier like 'pkg/component').`);
+			const marker = has_render ? {
+				render: attrs.get(renderKey),
+				wake: attrs.get(wakeKey),
+				fetch: attrs.get(fetchKey)
+			} : has_region ? { region: attrs.get(regionKey) } : has_fetch ? { fetch: attrs.get(fetchKey) } : { wake: attrs.get(wakeKey) };
+			const { iid, record, importFrom } = this.#emit_ts_region(componentPath, marker);
+			if (!islands_by_id.has(iid)) islands_by_id.set(iid, record);
+			s.overwrite(m.index, m.index + full.length, `import ${local} from ${JSON.stringify(importFrom)};`);
+			matched = true;
+		}
+		if (has_as_region) {
+			const { program: as_program } = parse_module(source, id);
+			if (as_program) {
+				const body = as_program.body ?? [];
+				const import_of = /* @__PURE__ */ new Map();
+				for (const node of body) {
+					if (node.type !== "ImportDeclaration") continue;
+					for (const spec of node.specifiers ?? []) if (spec.local?.name) import_of.set(spec.local.name, node);
+				}
+				const legal_nodes = /* @__PURE__ */ new Set();
+				for (const node of body) {
+					if (node.type !== "VariableDeclaration") continue;
+					if (node.declarations.some((d) => d.init?.type === "CallExpression" && is_import_meta_og(d.init.callee, "asRegion"))) legal_nodes.add(node);
+				}
+				const find_stray = (n) => {
+					if (!n || typeof n !== "object") return null;
+					if (Array.isArray(n)) {
+						for (const x of n) {
+							const hit = find_stray(x);
+							if (hit) return hit;
+						}
+						return null;
+					}
+					if (n.type === "CallExpression" && is_import_meta_og(n.callee, "asRegion")) return n;
+					for (const k in n) {
+						if (k === "type" || k === "start" || k === "end" || k === "loc" || k === "parent") continue;
+						const v = n[k];
+						if (v && typeof v === "object") {
+							const hit = find_stray(v);
+							if (hit) return hit;
+						}
+					}
+					return null;
+				};
+				for (const node of body) {
+					if (legal_nodes.has(node)) continue;
+					const stray = find_stray(node);
+					if (stray) {
+						const a = stray.arguments?.[0];
+						throw this.#as_err(a?.type === "Identifier" ? a.name : "?", "must be a top-level `const Name = import.meta.og.asRegion(Comp, options)` — it compiles to a hoisted import, so it can never sit in a loop, function, block, or larger expression.");
+					}
+				}
+				for (const node of body) {
+					if (!legal_nodes.has(node)) continue;
+					if (node.kind !== "const") throw this.#as_err(node.declarations[0]?.id?.name ?? "?", `must be bound with \`const\` (not \`${node.kind}\`).`);
+					if (node.declarations.length !== 1) throw this.#as_err(node.declarations[0]?.id?.name ?? "?", "declare one asRegion per `const` statement.");
+					const decl = node.declarations[0];
+					if (decl.id?.type !== "Identifier") throw this.#as_err("?", "must bind to a plain `const Name = …`.");
+					const local = decl.id.name;
+					const call_args = decl.init.arguments ?? [];
+					const comp_arg = call_args[0];
+					if (!comp_arg || comp_arg.type !== "Identifier") throw this.#as_err(local, "the first argument must be a component you imported (a bare identifier).");
+					const imp = import_of.get(comp_arg.name);
+					if (!imp) throw this.#as_err(local, `'${comp_arg.name}' is not an imported component — import it first (e.g. \`import { ${comp_arg.name} } from './…'\`).`);
+					const binding = import_binding_of(imp, comp_arg.name);
+					if (!binding || "namespace" in binding) throw this.#as_err(local, `'${comp_arg.name}' must be a default or named import, not a namespace import.`);
+					const componentPath = this.#resolve_spec(binding.source);
+					if (!componentPath) throw this.#as_err(local, `could not resolve '${binding.source}'.`);
+					const marker = parse_ts_as_region_options(call_args[1], (msg) => this.#as_err(local, msg), regionKey, wakeKey, renderKey, fetchKey);
+					const { iid, record, importFrom } = this.#emit_ts_region(componentPath, marker, binding.exportName);
+					if (!islands_by_id.has(iid)) islands_by_id.set(iid, record);
+					s.overwrite(node.start, node.end, `import ${local} from ${JSON.stringify(importFrom)};`);
+					matched = true;
+				}
+			}
+		}
+		if (!matched) return null;
+		const islands = [...islands_by_id.values()];
+		return {
+			code: s.toString(),
+			map: s.generateMap({
+				hires: true,
+				source: id,
+				includeContent: true
+			}),
+			islands,
+			hasWireCrossing: islands.some((i) => typeof i.strategy === "string" && i.strategy !== "server" && i.strategy !== "none")
+		};
+	}
+};
+export { CLIENT_BINDING_STUB, DEFAULT_IMPORT_KEYS, ISLAND_DIR, asRegionLocals, foucCssVirtualId, import_keys_hint, is_island_path, islandChunkFileName, islandId, islandPublicUrl, normalize_hydrate_value, normalize_import_keys, normalize_region_value, regionBindingVirtualId, regionId, regionIdentity, strategyKey, transformHost, transformTsRegions, wrapperVirtualId };