@ogygia/core 0.0.0 → 0.11.0

package/dist/compiler/script-request.d.ts

@@ -0,0 +1 @@
+export declare function is_script_request(id: string): boolean;

package/dist/compiler/script-request.js

@@ -0,0 +1,43 @@
+// src/compiler/script-request.ts
+/**
+* Is this module id a request for the module's SCRIPT? The query decides. vite-plugin-svelte serves
+* a component's extracted CSS as `Foo.svelte?svelte&type=style&lang.css`, and Vite's `?raw`, `?url`,
+* `?inline`, `?worker` are not the module's code either. Passes that strip the query before an
+* extension test took those for the component: the barrel rewrite ran the Svelte parser over plain
+* CSS, threw, and reported every component with a `<style>` as skipped (3,233 false warnings in one
+* production build, burying the real ones). A cache query (`?v=123`, `?t=…`) or ogygia's own
+* (`?og-region`) is still the script. String scanning, no regex: it runs for every module.
+*/
+/** Vite's query flags whose payload is not the module's script */
+const NON_SCRIPT_FLAGS = /* @__PURE__ */ new Set([
+	"raw",
+	"url",
+	"inline",
+	"worker",
+	"sharedworker",
+	"direct"
+]);
+const SCRIPT_LANGS = /* @__PURE__ */ new Set([
+	"js",
+	"ts",
+	"jsx",
+	"tsx",
+	"mjs",
+	"cjs",
+	"mts",
+	"cts"
+]);
+function is_script_request(id) {
+	const q = id.indexOf("?");
+	if (q === -1) return true;
+	const end = id.indexOf("#", q);
+	for (const part of id.slice(q + 1, end === -1 ? void 0 : end).split("&")) {
+		const eq = part.indexOf("=");
+		const key = eq === -1 ? part : part.slice(0, eq);
+		if (NON_SCRIPT_FLAGS.has(key)) return false;
+		if (key === "type" && part.slice(eq + 1) !== "script") return false;
+		if (key.startsWith("lang.") && !SCRIPT_LANGS.has(key.slice(5))) return false;
+	}
+	return true;
+}
+export { is_script_request };

package/dist/context-bridge.d.ts

@@ -0,0 +1,65 @@
+import { SetContextOptions } from "./context-registry.js";
+/** Serialize a context value for the DOM — same codec as island props (one hub key). */
+export declare function serialize_context(value: unknown): string;
+export declare function serialize_provided_context(map: Map<string, unknown>): string | null;
+/**
+ * Walk up from an island being hydrated, collecting every `<ogygia-provide>` above it (nearest wins)
+ * into one Map, then fold in the single page-level `<script data-ogygia-provide-page>` marker as the
+ * ROOT (lowest priority). ogygia seeds `hydrate(…, { context })` with the Map, so a child island's own
+ * `getContext('key')` — unchanged — reads a layout's context across the island-root split on a
+ * csr=false page.
+ *
+ * Two providers feed it: a `<Provide>` component (scoped, walked up — nesting/shadowing correct), and
+ * the drop-in `setContext` (page marker — one flat root the whole page shares, for existing layouts
+ * that just import `setContext` from `ogygia`). Scoped beats root on the same key. Undefined when
+ * neither exists (the common case: nothing to seed, no cost). Same decode codec as island props (a
+ * `[ogygia.wire]` value revives to its one live instance).
+ */
+export declare function collect_provided_context(start: Element | null): Map<string, unknown> | undefined;
+/** A typed context handle: callable to make a `<Provide>` entry, `.get()` to read (typed). */
+export interface Context<T> {
+  /** `theme('dark')` → `{ theme: 'dark' }` — an entry for `<Provide values={[ … ]}>`. */
+  (value: T): Record<string, unknown>;
+  /** Typed read — plain `getContext(key)` under the hood (seeded across islands), or the default. */
+  get(): T | undefined;
+  /** The underlying string key, for `getContext(theme.key)` interop. */
+  readonly key: string;
+}
+/**
+ * Typed sugar over a string context key, shared with plain `getContext`. Callable to produce a
+ * `<Provide>` entry, `.get()` to read (typed). The key is the same string plain `getContext` uses, so
+ * typed and untyped code read the same context. An optional default is returned when nothing is
+ * provided above.
+ *
+ * ```ts
+ * export const theme = createContext<'light' | 'dark'>('theme', 'light');
+ * // provide: <Provide values={[ theme('dark') ]}>…</Provide>
+ * // read:    theme.get()          // typed
+ * //          getContext('theme')  // untyped — same key, same value
+ * ```
+ */
+export declare function createContext<T>(key: string, defaultValue?: T): Context<T>;
+/**
+ * Drop-in `setContext` — swap `import { setContext } from 'svelte'` for `from 'ogygia'` and an
+ * existing csr=false layout's context reaches child islands with NO other change.
+ *
+ * It does exactly what Svelte's does (sets context for same-root descendants + the SSR-nested tree),
+ * AND on the server records the value so the handle can emit one page-level marker every island seeds
+ * from — closing the gap where a plain `setContext` shows up on the server but is gone on the client
+ * (child islands are separate hydration roots). Only string keys bridge (they must serialize and be
+ * read by `getContext('key')`); a symbol key is Svelte-only, same-root, no bridge.
+ *
+ * GRANULARITY: the optional third argument is the explicit marker — `{ islands: false }` keeps a key
+ * host-native (same-root context works, nothing serializes). The default bridges: a missing key in an
+ * island is a broken app, extra bytes are not. Ogygia never infers readership from `getContext` call
+ * sites (aliased imports and wrapper modules would make any scan miss reads — the fatal direction).
+ *
+ * This is the FLAT page root: every island on the page inherits it. For scoped/shadowed context use
+ * `<Provide>`, which wraps its subtree and beats the root on the same key.
+ */
+export declare function setContext<T>(key: unknown, value: T, opts?: SetContextOptions): T;
+/**
+ * Kept for ABI: the build still emits a registration call for each `createContext(...)` export (that
+ * used to tag keyless handles by `module#export`). Keys are explicit now, so this is a no-op.
+ */
+export declare function __tag_context(): void;

package/dist/context-bridge.js

@@ -0,0 +1,217 @@
+import { batch } from "./ref-watch.js";
+import { REF_WIRE_KEY, ref_reducer, ref_reviver } from "./ref.js";
+import { register_wire_kind } from "./live-transport.js";
+import { register_derived_kind, register_store_kind } from "./store-transport.js";
+import { register_snippet_kind } from "./region-snippet.js";
+import { is_branded_fn, register_fn_kind } from "./fn-transport.js";
+import { boundary_problems, format_boundary_finding } from "./boundary.js";
+import { PAGE_CTX_MARKER, record_ctx } from "./context-registry.js";
+import { escape_script_text } from "./escape.js";
+import { getContext, setContext as setContext$1 } from "svelte";
+import { DEV } from "esm-env";
+import { parse, stringify } from "devalue";
+// src/context-bridge.ts
+/**
+* Cross-island context — one bridge, plain `getContext`.
+*
+* Component trees break at every island boundary; the DOM tree does not. A `<Provide values={…}>`
+* writes its values into the DOM (serialized with the SAME codec as island props), and ogygia seeds
+* each island's `hydrate({ context })` from the providers above it — so a child island's own
+* `getContext('key')`, unchanged, reads a (csr=false) layout's context across the island-root split.
+* A `[ogygia.wire]` value resolves to the one live instance (shared + reactive); a plain value is a
+* per-consumer snapshot.
+*
+* `createContext(key)` is optional TYPED sugar over the same string key — callable to make a
+* `<Provide>` entry, `.get()` to read (typed). Nothing DOM-specific on the consumer side.
+*/
+function ensure_ctx_kinds() {
+	register_wire_kind();
+	register_store_kind();
+	register_snippet_kind();
+	register_fn_kind();
+	register_derived_kind();
+}
+/** The `<Provide>` seam carries classes, stores AND snippets (a snippet freezes/travels live). */
+const PROVIDE_FAMILIES = /* @__PURE__ */ new Set([
+	"wire",
+	"store",
+	"snippet",
+	"fn",
+	"derived"
+]);
+/** The drop-in page-marker seam deliberately EXCLUDES snippets: there, a bare function must
+*  THROW (and be dropped with a dev explanation) rather than be silently frozen as one. */
+const BRIDGE_FAMILIES = /* @__PURE__ */ new Set([
+	"wire",
+	"store",
+	"fn",
+	"derived"
+]);
+/** Serialize a context value for the DOM — same codec as island props (one hub key). */
+function serialize_context(value) {
+	ensure_ctx_kinds();
+	return escape_script_text(stringify(value, { [REF_WIRE_KEY]: ref_reducer(PROVIDE_FAMILIES) }));
+}
+/**
+* Serialize for the drop-in `setContext` page marker WITHOUT the region-snippet reducer. That reducer
+* treats every function as a snippet (snippets are unbranded functions), which would silently turn a
+* `setContext('trackPageView', fn)` — or a class method — into a bogus snippet instead of failing.
+* Here a function must THROW so the offending value gets dropped (see below). Transportables
+* (`[ogygia.wire]`) and stores (auto-wired: value crosses, islands reunite to one live instance)
+* cross. A snippet in context is a `<Provide>` concern, not this drop-in path.
+*/
+function stringify_bridgeable(value) {
+	ensure_ctx_kinds();
+	return escape_script_text(stringify(value, { [REF_WIRE_KEY]: ref_reducer(BRIDGE_FAMILIES) }));
+}
+/**
+* Serialize the drop-in `setContext` page-root bag for the DOM marker. A layout may `setContext` a
+* FUNCTION (e.g. `trackPageView`) or a DOM-holding object — values that genuinely can't cross an
+* island boundary. Rather than crash the page (or bridge a broken value), drop the offenders
+* key-by-key and bridge the rest; in DEV each drop is explained by the boundary classifier (key +
+* path + what to do), so a missing context inside an island is never a mystery. Returns null if
+* nothing serializable remains. The happy path (all serializable) is a single `stringify`.
+*/
+/** DEV threshold for the page-marker payload — islands ship context into every page's HTML. */
+const CTX_SIZE_WARN_BYTES = 32768;
+function serialize_provided_context(map) {
+	const obj = {};
+	for (const [k, v] of map) obj[k] = v;
+	try {
+		const payload = stringify_bridgeable(obj);
+		if (DEV && payload.length > CTX_SIZE_WARN_BYTES) warn_ctx_size(map, payload.length);
+		return payload;
+	} catch {
+		const safe = {};
+		for (const k in obj) try {
+			stringify_bridgeable({ [k]: obj[k] });
+			safe[k] = obj[k];
+			if (DEV) warn_boundary(k, obj[k], false);
+		} catch {
+			if (DEV) warn_boundary(k, obj[k], true);
+		}
+		return Object.keys(safe).length ? stringify_bridgeable(safe) : null;
+	}
+}
+/** DEV: the page marker is heavy — name the biggest keys so the fix is obvious (mark them
+*  { islands: false }, or slim the value). Sizes are per-key serialized lengths. */
+function warn_ctx_size(map, total) {
+	const sizes = [];
+	for (const [k, v] of map) try {
+		sizes.push([k, stringify_bridgeable({ [k]: v }).length]);
+	} catch {}
+	sizes.sort((a, b) => b[1] - a[1]);
+	const top = sizes.slice(0, 3).map(([k, n]) => `'${k}' ~${(n / 1024).toFixed(1)}kB`).join(", ");
+	console.warn(`[ogygia] the island context marker is ${(total / 1024).toFixed(1)}kB — it ships in every page's HTML. Biggest keys: ${top}. Slim the values, or mark host-only keys with setContext(key, value, { islands: false }).`);
+}
+/** DEV: explain a dropped (or degraded-but-bridged) context key via the classifier. */
+function warn_boundary(key, value, dropped) {
+	const problems = boundary_problems(value, key);
+	if (dropped && problems.length === 0) {
+		console.warn(`[ogygia] context '${key}' could not be serialized for islands and was dropped.`);
+		return;
+	}
+	for (const f of problems) if (dropped || f.kind === "warn") console.warn(format_boundary_finding(key, f));
+}
+/** Decode one serialized provider payload; a corrupt payload yields nothing (never breaks hydration). */
+function parse_ctx(text) {
+	if (!text) return void 0;
+	ensure_ctx_kinds();
+	try {
+		return batch(() => parse(text, { [REF_WIRE_KEY]: ref_reviver(true) }));
+	} catch {
+		return;
+	}
+}
+/**
+* Walk up from an island being hydrated, collecting every `<ogygia-provide>` above it (nearest wins)
+* into one Map, then fold in the single page-level `<script data-ogygia-provide-page>` marker as the
+* ROOT (lowest priority). ogygia seeds `hydrate(…, { context })` with the Map, so a child island's own
+* `getContext('key')` — unchanged — reads a layout's context across the island-root split on a
+* csr=false page.
+*
+* Two providers feed it: a `<Provide>` component (scoped, walked up — nesting/shadowing correct), and
+* the drop-in `setContext` (page marker — one flat root the whole page shares, for existing layouts
+* that just import `setContext` from `ogygia`). Scoped beats root on the same key. Undefined when
+* neither exists (the common case: nothing to seed, no cost). Same decode codec as island props (a
+* `[ogygia.wire]` value revives to its one live instance).
+*/
+function collect_provided_context(start) {
+	let el = start;
+	let map;
+	const fold = (values) => {
+		if (!values) return;
+		map ??= /* @__PURE__ */ new Map();
+		for (const k in values) if (!map.has(k)) map.set(k, values[k]);
+	};
+	while (el) {
+		if (el.tagName === "OGYGIA-PROVIDE") fold(parse_ctx(el.querySelector(":scope > script[data-ogygia-provide]")?.textContent));
+		el = el.parentElement;
+	}
+	if (typeof document !== "undefined") fold(page_ctx());
+	return map;
+}
+/** The page's context root, found and parsed ONCE per document (every island's hydrate asks; a
+*  search of the whole DOM each time grew with the page). A router swap brings the next page's. */
+let page_ctx_cache = null;
+let page_ctx_reset = false;
+function page_ctx() {
+	if (!page_ctx_reset) {
+		page_ctx_reset = true;
+		document.addEventListener("og:after-swap", () => page_ctx_cache = null);
+	}
+	return (page_ctx_cache ??= { value: parse_ctx(document.querySelector(`script[${PAGE_CTX_MARKER}]`)?.textContent) }).value;
+}
+/**
+* Typed sugar over a string context key, shared with plain `getContext`. Callable to produce a
+* `<Provide>` entry, `.get()` to read (typed). The key is the same string plain `getContext` uses, so
+* typed and untyped code read the same context. An optional default is returned when nothing is
+* provided above.
+*
+* ```ts
+* export const theme = createContext<'light' | 'dark'>('theme', 'light');
+* // provide: <Provide values={[ theme('dark') ]}>…</Provide>
+* // read:    theme.get()          // typed
+* //          getContext('theme')  // untyped — same key, same value
+* ```
+*/
+function createContext(key, defaultValue) {
+	const ctx = ((value) => ({ [key]: value }));
+	Object.defineProperty(ctx, "key", {
+		value: key,
+		enumerable: true
+	});
+	ctx.get = () => {
+		const v = getContext(key);
+		return v !== void 0 ? v : defaultValue;
+	};
+	return ctx;
+}
+/**
+* Drop-in `setContext` — swap `import { setContext } from 'svelte'` for `from 'ogygia'` and an
+* existing csr=false layout's context reaches child islands with NO other change.
+*
+* It does exactly what Svelte's does (sets context for same-root descendants + the SSR-nested tree),
+* AND on the server records the value so the handle can emit one page-level marker every island seeds
+* from — closing the gap where a plain `setContext` shows up on the server but is gone on the client
+* (child islands are separate hydration roots). Only string keys bridge (they must serialize and be
+* read by `getContext('key')`); a symbol key is Svelte-only, same-root, no bridge.
+*
+* GRANULARITY: the optional third argument is the explicit marker — `{ islands: false }` keeps a key
+* host-native (same-root context works, nothing serializes). The default bridges: a missing key in an
+* island is a broken app, extra bytes are not. Ogygia never infers readership from `getContext` call
+* sites (aliased imports and wrapper modules would make any scan miss reads — the fatal direction).
+*
+* This is the FLAT page root: every island on the page inherits it. For scoped/shadowed context use
+* `<Provide>`, which wraps its subtree and beats the root on the same key.
+*/
+function setContext(key, value, opts) {
+	if (typeof key === "string" && (typeof value !== "function" || is_branded_fn(value))) record_ctx(key, value, opts);
+	return setContext$1(key, value);
+}
+/**
+* Kept for ABI: the build still emits a registration call for each `createContext(...)` export (that
+* used to tag keyless handles by `module#export`). Keys are explicit now, so this is a no-op.
+*/
+function __tag_context() {}
+export { __tag_context, collect_provided_context, createContext, serialize_context, serialize_provided_context, setContext };

package/dist/context-registry.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Server-side capture for ogygia's drop-in `setContext` (see `./set-context.ts`). A layout that calls
+ * `setContext('key', value)` (import swapped from `svelte` to `ogygia`) records the value HERE during
+ * SSR; the server handle reads the per-request bag and emits ONE page-level `<script
+ * data-ogygia-provide-page>` marker, which every island seeds its own `getContext('key')` from at
+ * hydrate. That's how a plain `setContext` in a csr=false layout reaches child islands (separate
+ * hydration roots) without a `<Provide>` in the template.
+ *
+ * Universal-safe by design: the recorder is a slot the SERVER installs (backed by an
+ * `AsyncLocalStorage` in `hooks.ts`), so `node:async_hooks` never enters the client bundle — on the
+ * client `record_ctx` is a no-op.
+ */
+type Recorder = (key: string, value: unknown) => void;
+/** Server (`hooks.ts`) installs a request-scoped recorder. */
+export declare function set_ctx_recorder(fn: Recorder | null): void;
+/**
+ * Options a drop-in `setContext` may carry as its third argument. Svelte's own signature is
+ * two-arg, so existing code is untouched — the marker is strictly additive.
+ */
+export interface SetContextOptions {
+  /**
+   * GRANULARITY MARKER. `false` = this key is host-native: serve it to the same-root tree
+   * (Svelte context, unchanged) but never serialize it into the island page marker. Use it
+   * for values islands never read — a DOM-ref bag, a host-only callback, a large config
+   * object — so they cost nothing on the wire.
+   *
+   * DEFAULT is `true` (bridge): the safe direction. A missing key inside an island is a
+   * broken app; an extra bridged key is just bytes. Ogygia deliberately does NOT infer this
+   * from `getContext` call-sites — import aliasing (`import { getContext as x }`), wrapper
+   * modules, and custom context layers make any scan under-inclusive, and under-inclusion
+   * is the fatal direction. You mark; ogygia never guesses.
+   */
+  islands?: boolean;
+}
+/** The drop-in `setContext` calls this — server records for the page bridge, client is a no-op.
+ *  `opts.islands === false` skips recording: the key stays native-only (never serialized). */
+export declare function record_ctx(key: string, value: unknown, opts?: SetContextOptions): void;
+/** DOM marker the server emits (before `</body>`) and `collect_provided_context` reads. */
+export declare const PAGE_CTX_MARKER = "data-ogygia-provide-page";
+export {};

package/dist/context-registry.js

@@ -0,0 +1,15 @@
+// src/context-registry.ts
+let recorder = null;
+/** Server (`hooks.ts`) installs a request-scoped recorder. */
+function set_ctx_recorder(fn) {
+	recorder = fn;
+}
+/** The drop-in `setContext` calls this — server records for the page bridge, client is a no-op.
+*  `opts.islands === false` skips recording: the key stays native-only (never serialized). */
+function record_ctx(key, value, opts) {
+	if (opts?.islands === false) return;
+	recorder?.(key, value);
+}
+/** DOM marker the server emits (before `</body>`) and `collect_provided_context` reads. */
+const PAGE_CTX_MARKER = "data-ogygia-provide-page";
+export { PAGE_CTX_MARKER, record_ctx, set_ctx_recorder };

package/dist/context.d.ts

@@ -0,0 +1,72 @@
+/**
+ * Mark the current subtree's hydration state. `true` = inside a hydrated island (nested islands
+ * degrade). `false` = a LAKE resets its subtree to "dead", so an island inside the lake self-
+ * hydrates again (the nearest-boundary rule — DESIGN.md).
+ */
+export declare function setNested(value?: boolean): void;
+/**
+ * True when an ancestor island wrapper already marked the subtree. `getContext` returns `undefined`
+ * when no ancestor set it (a top-level island) — that absence is exactly "not nested".
+ */
+export declare function isNested(): boolean;
+/** Mark the current subtree as opaque to Kit — a lake's inside (LakeBoundary). */
+export declare function setInLake(): void;
+/** True when the subtree is opaque to Kit (a lake's inside, or a held region's render). */
+export declare function isInLake(): boolean;
+/** Reset the live-snippet mark for the current subtree (an inline island inside a snippet). */
+export declare function setInLiveSnippet(value: boolean): void;
+/** True inside a live snippet's body (and not under an island it renders inline). */
+export declare function isInLiveSnippet(): boolean;
+/** Region.svelte marks the subtree of a server island it is rendering inline (nested). */
+export declare function setHoleInline(): void;
+/** Is this render a server island's component rendering INLINE (nested in an island)? */
+export declare function isHoleInline(): boolean;
+/**
+ * Does Kit hydrate THIS WHOLE DOCUMENT? The leaf page's effective csr is the single fact that decides
+ * it, so a `<Region>` reads it directly — no per-host context cascade. When true, every island (a
+ * csr=true page's own, a csr=false layout's chrome, a shared component's) degrades to a plain inline
+ * component that Kit hydrates. Server: the route is in the build-time csr=true set. Client: Kit
+ * shipped its bootstrap. Same fact on both legs → the inline/island choice can never desync at
+ * hydrate. (Replaces the old `CSR_TRUE_KEY` marker + `csr=false` reset, which only re-derived this
+ * number indirectly through the context cascade.)
+ */
+export declare function documentIsCsrTrue(error_render?: boolean): boolean;
+/**
+ * PUBLIC: is the current page an ogygia page (csr=false), as opposed to a csr=true page Kit hydrates
+ * whole? The inverse of {@link documentIsCsrTrue}, so it answers on BOTH legs with no requestEvent
+ * handling on the caller's side — server reads the request's route against the build-time csr set,
+ * client reads Kit's bootstrap. Meant for shared code (a store, a helper) that must branch on which
+ * world it runs in. Off-request on the server (a module init, a prerender helper with no page) there
+ * is no document to speak of, so it returns `false`.
+ */
+export declare function isOgygiaPage(): boolean;
+/** The same fact from a route id in hand (the handle has the event): is this route's leaf page
+ *  csr=true? A build-time answer — never a scan of the rendered document. */
+export declare function route_is_csr_true(id: string | null | undefined): boolean;
+/** The ERROR-page twin: does Kit hydrate this route's `+error.svelte`? Kit renders an error page
+ *  with the layout branch only (the page node — and its `csr = false` — is dropped), so this reads
+ *  the layouts' answer; a routeless response (no route matched) is the root layout's. */
+export declare function error_route_is_csr_true(id: string | null | undefined): boolean;
+/**
+ * Claim an INLINE-rendered island's entry for this SSR request — true the first time, so the page
+ * stamps one `<meta name="ogygia-kit-island" content="<entry>">` per rendered island, however many
+ * instances render. The client wrapper's lazy component module reads the stamp before Kit hydrates
+ * (emit.ts `lazy_entry_source`): a stamped island's entry is imported, an unstamped one costs
+ * nothing. Client / no-request → false (nothing to stamp there).
+ */
+export declare function claim_kit_island(entry: string): boolean;
+/**
+ * Claim stylesheet hrefs for this SSR request, returning only the not-yet-claimed ones. A held
+ * region's component is server-picked, so its CSS is on no page stylesheet (Kit links CSS from the
+ * route's STATIC import graph — it never reads the rendered page). The region wrapper links it from
+ * the render pass instead, via `<svelte:head>`; claiming here dedupes so five `Feature` blocks on a
+ * page link their shared sheet once. Client / no-request → [] (SSR already linked them).
+ */
+export declare function claim_region_css(hrefs: string[]): string[];
+/**
+ * Claim the single runtime-script slot for this SSR request. An island/server placement emits the
+ * runtime bootstrap so it hydrates even with the router off; when the router is on, the handle
+ * injects the same script into `<head>` (presence-checked) on pages that have no island to emit it.
+ * Client / no-request → false (SSR already emitted).
+ */
+export declare function claimRuntimeEmit(): boolean;

package/dist/context.js

@@ -0,0 +1,158 @@
+import { kit_hydrates_page } from "./runtime/kit-boot.js";
+import { getContext, setContext } from "svelte";
+import { BROWSER } from "esm-env";
+import { getRequestEvent } from "virtual:ogygia/request-event";
+import { csr_true_routes, error_csr_true_routes, root_layout_csr_true } from "virtual:ogygia/route-csr";
+// src/context.ts
+const NESTED_KEY = Symbol.for("ogygia.nested-island");
+/**
+* Mark the current subtree's hydration state. `true` = inside a hydrated island (nested islands
+* degrade). `false` = a LAKE resets its subtree to "dead", so an island inside the lake self-
+* hydrates again (the nearest-boundary rule — DESIGN.md).
+*/
+function setNested(value = true) {
+	setContext(NESTED_KEY, value);
+}
+/**
+* True when an ancestor island wrapper already marked the subtree. `getContext` returns `undefined`
+* when no ancestor set it (a top-level island) — that absence is exactly "not nested".
+*/
+function isNested() {
+	return getContext(NESTED_KEY) === true;
+}
+const LAKE_KEY = Symbol.for("ogygia.lake-subtree");
+/** Mark the current subtree as opaque to Kit — a lake's inside (LakeBoundary). */
+function setInLake() {
+	setContext(LAKE_KEY, true);
+}
+/** True when the subtree is opaque to Kit (a lake's inside, or a held region's render). */
+function isInLake() {
+	return getContext(LAKE_KEY) === true;
+}
+const LIVE_SNIPPET_KEY = Symbol.for("ogygia.live-snippet");
+/** Reset the live-snippet mark for the current subtree (an inline island inside a snippet). */
+function setInLiveSnippet(value) {
+	setContext(LIVE_SNIPPET_KEY, value);
+}
+/** True inside a live snippet's body (and not under an island it renders inline). */
+function isInLiveSnippet() {
+	return getContext(LIVE_SNIPPET_KEY) === true;
+}
+const HOLE_INLINE_KEY = Symbol.for("ogygia.hole-inline");
+/** Region.svelte marks the subtree of a server island it is rendering inline (nested). */
+function setHoleInline() {
+	setContext(HOLE_INLINE_KEY, true);
+}
+/** Is this render a server island's component rendering INLINE (nested in an island)? */
+function isHoleInline() {
+	return getContext(HOLE_INLINE_KEY) === true;
+}
+/** Kit `route.id`, GROUP segments (`(app)`) stripped — mirrors the compiler's `normalize_route_id`
+*  so both sides match whether or not Kit keeps groups in `route.id`. Root → `/`. */
+function normalize_route_id(id) {
+	return "/" + id.split("/").filter(Boolean).filter((s) => !(s.startsWith("(") && s.endsWith(")"))).join("/");
+}
+/**
+* Does Kit hydrate THIS WHOLE DOCUMENT? The leaf page's effective csr is the single fact that decides
+* it, so a `<Region>` reads it directly — no per-host context cascade. When true, every island (a
+* csr=true page's own, a csr=false layout's chrome, a shared component's) degrades to a plain inline
+* component that Kit hydrates. Server: the route is in the build-time csr=true set. Client: Kit
+* shipped its bootstrap. Same fact on both legs → the inline/island choice can never desync at
+* hydrate. (Replaces the old `CSR_TRUE_KEY` marker + `csr=false` reset, which only re-derived this
+* number indirectly through the context cascade.)
+*/
+function documentIsCsrTrue(error_render = false) {
+	if (BROWSER) return kit_hydrates_page();
+	try {
+		const event = getRequestEvent();
+		return error_render ? error_route_is_csr_true(event.route?.id) : route_is_csr_true(event.route?.id);
+	} catch {
+		return false;
+	}
+}
+/**
+* PUBLIC: is the current page an ogygia page (csr=false), as opposed to a csr=true page Kit hydrates
+* whole? The inverse of {@link documentIsCsrTrue}, so it answers on BOTH legs with no requestEvent
+* handling on the caller's side — server reads the request's route against the build-time csr set,
+* client reads Kit's bootstrap. Meant for shared code (a store, a helper) that must branch on which
+* world it runs in. Off-request on the server (a module init, a prerender helper with no page) there
+* is no document to speak of, so it returns `false`.
+*/
+function isOgygiaPage() {
+	return !documentIsCsrTrue();
+}
+/** The same fact from a route id in hand (the handle has the event): is this route's leaf page
+*  csr=true? A build-time answer — never a scan of the rendered document. */
+function route_is_csr_true(id) {
+	return id != null && csr_true_routes.has(normalize_route_id(id));
+}
+/** The ERROR-page twin: does Kit hydrate this route's `+error.svelte`? Kit renders an error page
+*  with the layout branch only (the page node — and its `csr = false` — is dropped), so this reads
+*  the layouts' answer; a routeless response (no route matched) is the root layout's. */
+function error_route_is_csr_true(id) {
+	if (id == null) return root_layout_csr_true;
+	return error_csr_true_routes.has(normalize_route_id(id));
+}
+/** Per-request: only one `data-ogygia-runtime` script should be emitted (the first island). */
+const runtime_claimed = /* @__PURE__ */ new WeakMap();
+/** Per-request: stylesheet hrefs already linked for held regions rendered in this SSR pass. */
+const region_css_claimed = /* @__PURE__ */ new WeakMap();
+/** Per-request: island entries already stamped `<meta name="ogygia-kit-island">` in this pass. */
+const kit_island_claimed = /* @__PURE__ */ new WeakMap();
+/**
+* Claim an INLINE-rendered island's entry for this SSR request — true the first time, so the page
+* stamps one `<meta name="ogygia-kit-island" content="<entry>">` per rendered island, however many
+* instances render. The client wrapper's lazy component module reads the stamp before Kit hydrates
+* (emit.ts `lazy_entry_source`): a stamped island's entry is imported, an unstamped one costs
+* nothing. Client / no-request → false (nothing to stamp there).
+*/
+function claim_kit_island(entry) {
+	if (!entry) return false;
+	try {
+		const event = getRequestEvent();
+		let seen = kit_island_claimed.get(event);
+		if (!seen) kit_island_claimed.set(event, seen = /* @__PURE__ */ new Set());
+		if (seen.has(entry)) return false;
+		seen.add(entry);
+		return true;
+	} catch {
+		return false;
+	}
+}
+/**
+* Claim stylesheet hrefs for this SSR request, returning only the not-yet-claimed ones. A held
+* region's component is server-picked, so its CSS is on no page stylesheet (Kit links CSS from the
+* route's STATIC import graph — it never reads the rendered page). The region wrapper links it from
+* the render pass instead, via `<svelte:head>`; claiming here dedupes so five `Feature` blocks on a
+* page link their shared sheet once. Client / no-request → [] (SSR already linked them).
+*/
+function claim_region_css(hrefs) {
+	if (!hrefs.length) return [];
+	try {
+		const event = getRequestEvent();
+		let seen = region_css_claimed.get(event);
+		if (!seen) region_css_claimed.set(event, seen = /* @__PURE__ */ new Set());
+		const fresh = hrefs.filter((h) => !seen.has(h));
+		for (const h of fresh) seen.add(h);
+		return fresh;
+	} catch {
+		return [];
+	}
+}
+/**
+* Claim the single runtime-script slot for this SSR request. An island/server placement emits the
+* runtime bootstrap so it hydrates even with the router off; when the router is on, the handle
+* injects the same script into `<head>` (presence-checked) on pages that have no island to emit it.
+* Client / no-request → false (SSR already emitted).
+*/
+function claimRuntimeEmit() {
+	try {
+		const event = getRequestEvent();
+		if (runtime_claimed.has(event)) return false;
+		runtime_claimed.set(event, true);
+		return true;
+	} catch {
+		return false;
+	}
+}
+export { claimRuntimeEmit, claim_kit_island, claim_region_css, documentIsCsrTrue, error_route_is_csr_true, isHoleInline, isInLake, isInLiveSnippet, isNested, isOgygiaPage, route_is_csr_true, setHoleInline, setInLake, setInLiveSnippet, setNested };

package/dist/current-region.d.ts

@@ -0,0 +1,14 @@
+/** Runtime sets the region it is about to hydrate so a nested `get()` knows where to start walking. */
+export declare function set_current_region(el: Element | null): void;
+/** The region currently being hydrated (or null) — read by the context feature's client DOM walk. */
+export declare function current_region(): Element | null;
+export interface ForeignHydrate {
+  /** The MFE origin the island's entry was loaded from. */
+  origin: string;
+  /** The absolute entry URL — the island's identity for once-per-island warnings. */
+  entry: string;
+}
+/** Runtime marks the foreign island it is about to delegate-hydrate (null when done). */
+export declare function set_foreign_hydrate(info: ForeignHydrate | null): void;
+/** The foreign island currently hydrating (or null) — read by the page shims' dev warning. */
+export declare function foreign_hydrate(): ForeignHydrate | null;