@ogygia/core 0.0.0 → 0.11.1

package/dist/insights/testing-version.d.ts

@@ -0,0 +1,19 @@
+/**
+ * The report shape the page's testing engine answers (`window.__ogygia_testing.version`). The engine
+ * ships with the SITE's build and `@ogygia/testing` with the TEST's package, so the two can differ: the
+ * test side reads this from the page, fills in what it can for an older engine, and warns once.
+ *
+ * Each version, and what it DETECTS differently (results across two versions compare only where
+ * nothing below changed):
+ *
+ * 1 — 0.8.2.
+ * 2 — hydration `key`, session `navigations` (with what started each), finding `names`, `counts.cls`,
+ *     `engine` on every report, hydration `t0` / `done`. Detection: a router navigation that never
+ *     swapped the page no longer starts a new page for `page()`. Hydration status: unchanged from 1 (an
+ *     island that reads `clean` on one and `changed` on the other differed in that run — input landing
+ *     while it hydrated is the usual cause; 3 flags it as `input`).
+ * 3 — hydration `change` (`attributes` / `markup`), `attributes`, `input`, `ignoreAttributes`; page
+ *     `ogygia` (what measuring cost). Detection: unchanged — `changed` means what it meant in 2; the new
+ *     fields only say what kind of change it was.
+ */
+export declare const TESTING_ENGINE_VERSION = 3;

package/dist/insights/testing-version.js

@@ -0,0 +1,21 @@
+// src/insights/testing-version.ts
+/**
+* The report shape the page's testing engine answers (`window.__ogygia_testing.version`). The engine
+* ships with the SITE's build and `@ogygia/testing` with the TEST's package, so the two can differ: the
+* test side reads this from the page, fills in what it can for an older engine, and warns once.
+*
+* Each version, and what it DETECTS differently (results across two versions compare only where
+* nothing below changed):
+*
+* 1 — 0.8.2.
+* 2 — hydration `key`, session `navigations` (with what started each), finding `names`, `counts.cls`,
+*     `engine` on every report, hydration `t0` / `done`. Detection: a router navigation that never
+*     swapped the page no longer starts a new page for `page()`. Hydration status: unchanged from 1 (an
+*     island that reads `clean` on one and `changed` on the other differed in that run — input landing
+*     while it hydrated is the usual cause; 3 flags it as `input`).
+* 3 — hydration `change` (`attributes` / `markup`), `attributes`, `input`, `ignoreAttributes`; page
+*     `ogygia` (what measuring cost). Detection: unchanged — `changed` means what it meant in 2; the new
+*     fields only say what kind of change it was.
+*/
+const TESTING_ENGINE_VERSION = 3;
+export { TESTING_ENGINE_VERSION };

package/dist/insights/third-party.d.ts

@@ -0,0 +1,75 @@
+/**
+ * THIRD PARTIES — what other origins cost this page, from what the browser measured: their files and
+ * bytes (resource timing), the ones that held the first paint, the scripts that loaded more scripts
+ * at runtime (a tag manager's shape), and their main-thread time when there is a CPU trace. Pure, so
+ * the devtools Page tab and the profiler report run the same analysis on the same visit.
+ *
+ * Detection is by behavior (another origin; blocking; CPU; a script whose arrival is followed by
+ * scripts nothing in the page names). The host table only puts a readable label on well-known
+ * public services — a host it does not know is still measured, as "other".
+ */
+export type ThirdPartyKind = "tag manager" | "analytics" | "ads" | "session replay" | "chat" | "a/b testing" | "consent" | "fonts" | "library cdn" | "other";
+export declare function kind_of_host(host: string): ThirdPartyKind;
+export interface ThirdPartyOrigin {
+  host: string;
+  kind: ThirdPartyKind;
+  files: number;
+  scripts: number;
+  /** decoded bytes of its scripts */
+  script_bytes: number;
+  /** its scripts the browser gave no size for (some engines hide every other origin's sizes,
+   *  even with Timing-Allow-Origin): `script_bytes` leaves them out */
+  unsized: number;
+  /** every byte on the wire */
+  wire: number;
+  /** files that held the first paint */
+  blocking: number;
+  /** when its first file started (ms from navigation) */
+  first: number;
+  /** main-thread ms in its scripts (a CPU trace), else null */
+  cpu_ms: number | null;
+}
+export interface ThirdParty {
+  origins: ThirdPartyOrigin[];
+  script_bytes: number;
+  unsized: number;
+  /** scripts whose size the browser hid and that were weighed apart from the visit */
+  weighed: number;
+  wire: number;
+  blocking: number;
+  cpu_ms: number | null;
+  /** third-party scripts that started after another third-party script arrived and that no
+   *  document ref names: loaded at runtime (by a tag manager, a loader) */
+  runtime_loaded: number;
+}
+interface Res {
+  url: string;
+  type: string;
+  start: number;
+  end: number;
+  transfer?: number;
+  size?: number;
+  blocking?: boolean;
+  /** a size the browser hid, weighed apart from the visit */
+  weighed?: true;
+}
+/** `named`: URLs the server's HTML references (its scripts, preloads, their imports) — another
+ *  origin's script not among them came at runtime. Without it (the live page already holds the
+ *  injected script elements), `parsed`: when the HTML was parsed (domInteractive) — a script that
+ *  starts after that and after another origin's script ran was loaded by a script. `in_page`: the
+ *  URLs the live document holds — a script no element names came by an import or a fetch (a
+ *  self-loading library's parts), whenever it started. */
+export declare function third_party(resources: readonly Res[], page_origin: string, cpu_by_host: ReadonlyMap<string, number> | null, named?: ReadonlySet<string>, parsed?: number, in_page?: ReadonlySet<string>): ThirdParty | null;
+export interface ThirdPartyFinding {
+  code: string;
+  severity: "warn" | "info";
+  message: string;
+  fix?: string;
+}
+/** `edited`: islands that did not wake from the server's markup on this visit (changed, recovered,
+ *  healed, failed), with when they woke (ms; Infinity when unknown or never). */
+export declare function third_party_findings(tp: ThirdParty | null, edited?: readonly {
+  name: string;
+  done: number;
+}[]): ThirdPartyFinding[];
+export {};

package/dist/insights/third-party.js

@@ -0,0 +1,160 @@
+// src/insights/third-party.ts
+/** host suffix → what that kind of service is (labels only; detection does not need them) */
+const KNOWN = [
+	["googletagmanager.com", "tag manager"],
+	["tiqcdn.com", "tag manager"],
+	["tealiumiq.com", "tag manager"],
+	["adobedtm.com", "tag manager"],
+	["segment.com", "tag manager"],
+	["google-analytics.com", "analytics"],
+	["analytics.google.com", "analytics"],
+	["plausible.io", "analytics"],
+	["mxpnl.com", "analytics"],
+	["amplitude.com", "analytics"],
+	["heapanalytics.com", "analytics"],
+	["hotjar.com", "session replay"],
+	["fullstory.com", "session replay"],
+	["clarity.ms", "session replay"],
+	["mouseflow.com", "session replay"],
+	["doubleclick.net", "ads"],
+	["googlesyndication.com", "ads"],
+	["googleadservices.com", "ads"],
+	["facebook.net", "ads"],
+	["licdn.com", "ads"],
+	["bing.com", "ads"],
+	["ads-twitter.com", "ads"],
+	["intercom.io", "chat"],
+	["intercomcdn.com", "chat"],
+	["zdassets.com", "chat"],
+	["crisp.chat", "chat"],
+	["optimizely.com", "a/b testing"],
+	["visualwebsiteoptimizer.com", "a/b testing"],
+	["abtasty.com", "a/b testing"],
+	["cookielaw.org", "consent"],
+	["onetrust.com", "consent"],
+	["cookiebot.com", "consent"],
+	["usercentrics.eu", "consent"],
+	["fonts.googleapis.com", "fonts"],
+	["fonts.gstatic.com", "fonts"],
+	["typekit.net", "fonts"],
+	["jsdelivr.net", "library cdn"],
+	["unpkg.com", "library cdn"],
+	["cdnjs.cloudflare.com", "library cdn"],
+	["esm.sh", "library cdn"]
+];
+function kind_of_host(host) {
+	for (const [suffix, kind] of KNOWN) if (host === suffix || host.endsWith("." + suffix)) return kind;
+	return "other";
+}
+function host_of(url) {
+	try {
+		return new URL(url).host;
+	} catch {
+		return "";
+	}
+}
+/** `named`: URLs the server's HTML references (its scripts, preloads, their imports) — another
+*  origin's script not among them came at runtime. Without it (the live page already holds the
+*  injected script elements), `parsed`: when the HTML was parsed (domInteractive) — a script that
+*  starts after that and after another origin's script ran was loaded by a script. `in_page`: the
+*  URLs the live document holds — a script no element names came by an import or a fetch (a
+*  self-loading library's parts), whenever it started. */
+function third_party(resources, page_origin, cpu_by_host, named, parsed, in_page) {
+	const page_host = host_of(page_origin);
+	const by = /* @__PURE__ */ new Map();
+	let first_third_script_end = Infinity;
+	let runtime_loaded = 0;
+	let weighed = 0;
+	const sorted = [...resources].sort((a, b) => a.start - b.start);
+	for (const r of sorted) {
+		const host = host_of(r.url);
+		if (!host || host === page_host) continue;
+		const o = by.get(host) ?? {
+			host,
+			kind: kind_of_host(host),
+			files: 0,
+			scripts: 0,
+			script_bytes: 0,
+			unsized: 0,
+			wire: 0,
+			blocking: 0,
+			first: r.start,
+			cpu_ms: cpu_by_host ? cpu_by_host.get(host) ?? 0 : null
+		};
+		o.files++;
+		o.wire += r.transfer ?? 0;
+		if (r.blocking) o.blocking++;
+		if (r.type === "script") {
+			o.scripts++;
+			o.script_bytes += r.size ?? 0;
+			if (!r.size) o.unsized++;
+			else if (r.weighed) weighed++;
+			if (r.start >= first_third_script_end && (named ? !named.has(r.url) : in_page !== void 0 && !in_page.has(r.url) || parsed !== void 0 && r.start > parsed)) runtime_loaded++;
+			first_third_script_end = Math.min(first_third_script_end, r.end);
+		}
+		by.set(host, o);
+	}
+	if (!by.size) return null;
+	const origins = [...by.values()].sort((a, b) => (b.cpu_ms ?? 0) - (a.cpu_ms ?? 0) || b.script_bytes - a.script_bytes || b.wire - a.wire);
+	const sum = (k) => origins.reduce((s, o) => s + o[k], 0);
+	return {
+		origins,
+		script_bytes: sum("script_bytes"),
+		unsized: sum("unsized"),
+		weighed,
+		wire: sum("wire"),
+		blocking: sum("blocking"),
+		cpu_ms: cpu_by_host ? origins.reduce((s, o) => s + (o.cpu_ms ?? 0), 0) : null,
+		runtime_loaded
+	};
+}
+/** What to do about each kind, in one line (Partytown only where it tends to work). */
+const ADVICE = {
+	"tag manager": "audit its tags (each one is a script it adds at runtime), fire them after the page is interactive or on consent, or move them to server-side tagging",
+	analytics: "load it after the page is interactive (idle or first interaction); a pure beacon tag is the kind that runs well off the main thread in a worker (Partytown), worth trying there",
+	ads: "reserve the slots at their final size and load the ad code after the main content; conversion pixels can wait for idle",
+	"session replay": "start it after the first interaction, or sample it (record a share of visits): it watches every DOM change",
+	chat: "show a plain button that looks like the widget and load the widget on its first click (a facade)",
+	"a/b testing": "it edits the page before or as islands wake: run the experiment on the server (render the variant) so islands hydrate clean",
+	consent: "keep it small and async, and let it gate the other tags rather than load beside them",
+	fonts: "self-host the fonts (one origin fewer on the critical path) and preload the one the first screen uses",
+	"library cdn": "bundle the library with the app (one origin fewer, cached with your code, no runtime fetches of its parts)",
+	other: "load it async, after the first paint, or where it is used"
+};
+const kb = (n) => n >= 1048576 ? `${(n / 1048576).toFixed(1)} MB` : n > 0 && n < 1024 ? `${n} B` : `${Math.round(n / 1024)} KB`;
+/** `edited`: islands that did not wake from the server's markup on this visit (changed, recovered,
+*  healed, failed), with when they woke (ms; Infinity when unknown or never). */
+function third_party_findings(tp, edited = []) {
+	if (!tp) return [];
+	const out = [];
+	const MANY = 5;
+	const heavy = tp.origins.filter((o) => (o.cpu_ms ?? 0) >= 50 || o.script_bytes >= 51200 || o.unsized >= MANY || o.blocking);
+	const size = (bytes, scripts, unsized) => !unsized ? kb(bytes) : unsized === scripts ? `${scripts} script${scripts === 1 ? "" : "s"}, sizes hidden` : `at least ${kb(bytes)}`;
+	const label = (o) => `${o.host}${o.kind !== "other" ? ` (${o.kind})` : ""} ${size(o.script_bytes, o.scripts, o.unsized)}${o.cpu_ms ? `, ${Math.round(o.cpu_ms)} ms CPU` : ""}${o.blocking ? `, ${o.blocking} blocking` : ""}`;
+	const scripts = tp.origins.reduce((s, o) => s + o.scripts, 0);
+	const weighed = tp.weighed ? ` (this browser hid the size of ${tp.weighed === scripts ? scripts === 1 ? "it" : "each" : `${tp.weighed} of them`}; weighed from the files themselves)` : "";
+	const served = !tp.unsized ? `${kb(tp.script_bytes)} of JS${weighed}` : tp.unsized === scripts ? `${scripts} script${scripts === 1 ? "" : "s"} (this browser hides other origins' file sizes; a Chromium visit shows them)` : `at least ${kb(tp.script_bytes)} of JS (${tp.unsized} of the ${scripts} scripts had their size hidden by this browser${tp.weighed ? `; ${tp.weighed} more it hid were weighed from the files themselves` : ""})`;
+	if (tp.script_bytes >= 30720 || tp.unsized >= MANY || (tp.cpu_ms ?? 0) >= 50 || tp.blocking > 0) out.push({
+		code: "third-party",
+		severity: (tp.cpu_ms ?? 0) >= 200 || tp.blocking > 0 || tp.script_bytes >= 204800 ? "warn" : "info",
+		message: `${tp.origins.length} other origin${tp.origins.length === 1 ? "" : "s"} served ${served}${tp.cpu_ms !== null ? ` and ran ${Math.round(tp.cpu_ms)} ms on the main thread` : ""}${tp.runtime_loaded ? `; ${tp.runtime_loaded} of their scripts the page never names, loaded by other scripts (how a tag manager or a self-loading library adds code)` : ""}. The heaviest: ${(heavy.length ? heavy : tp.origins).slice(0, 3).map(label).join("; ")}.`,
+		fix: [...new Set((heavy.length ? heavy : tp.origins).slice(0, 3).map((o) => `${o.kind === "other" ? o.host : o.kind}: ${ADVICE[o.kind]}`))].join(" · ")
+	});
+	const blocking = tp.origins.filter((o) => o.blocking);
+	if (blocking.length) out.push({
+		code: "third-party-blocking",
+		severity: "warn",
+		message: `${blocking.map((o) => o.host).join(", ")} held the first paint: the page waited on another origin's server before showing anything.`,
+		fix: "Load its scripts with async or defer, self-host a stylesheet or font it serves, or at least preconnect to it."
+	});
+	const last_woke = edited.reduce((m, e) => Math.max(m, e.done), -Infinity);
+	const editors = tp.origins.filter((o) => o.scripts > 0 && o.first < last_woke && o.kind !== "fonts" && o.kind !== "library cdn");
+	if (edited.length && editors.length) out.push({
+		code: "third-party-edits",
+		severity: "warn",
+		message: `${[...new Set(edited.map((e) => e.name))].slice(0, 3).join(", ")} did not wake from the server's markup, and ${editors.slice(0, 3).map((o) => `${o.host}${o.kind !== "other" ? ` (${o.kind})` : ""}`).join(", ")} ran scripts before ${edited.length === 1 ? "it" : "they"} woke: a script from another origin that edits the DOM is the usual cause.`,
+		fix: "Keep third-party edits out of island subtrees (target the markup around them), or render the variant on the server so the island hydrates what it was sent."
+	});
+	return out;
+}
+export { kind_of_host, third_party, third_party_findings };

package/dist/internal-instruments.d.ts

@@ -0,0 +1,13 @@
+import { AttrChange, BeaconPage, beacon_page, beacon_record_cpu, hole_request_times, is_headless } from "./runtime/beacon.js";
+import { props_sidecar_of } from "./runtime/sidecar.js";
+import { PAGE_SEED_SELECTOR } from "./runtime/seeds.js";
+import { paint_blocker } from "./runtime/render-blocking.js";
+import { RegionRefusal } from "./runtime/region-endpoint-url.js";
+import { charge, own_cost } from "./runtime/own-cost.js";
+import { nearest_attr } from "./runtime/nearest-attr.js";
+import { REGION_RENDER_CONCURRENCY } from "./runtime/concurrency.js";
+import { tool_fetch, tool_made } from "./tool-fetches.js";
+import { PAGE_DEFER_GLOBAL, PAGE_DEFER_KEY, PAGE_DEFER_REGISTRY_KEY } from "./page-defer.js";
+import { ISLAND_GRAPH_ATTR, decode_island_graph } from "./island-graph.js";
+import { UnscopedStyles, find_unscoped, unscoped_finding, unscoped_marker } from "./unscoped-css.js";
+export { type AttrChange, type BeaconPage, ISLAND_GRAPH_ATTR, PAGE_DEFER_GLOBAL, PAGE_DEFER_KEY, PAGE_DEFER_REGISTRY_KEY, PAGE_SEED_SELECTOR, REGION_RENDER_CONCURRENCY, type RegionRefusal, type UnscopedStyles, beacon_page, beacon_record_cpu, charge, decode_island_graph, find_unscoped, hole_request_times, is_headless, nearest_attr, own_cost, paint_blocker, props_sidecar_of, tool_fetch, tool_made, unscoped_finding, unscoped_marker };

package/dist/internal-instruments.js

@@ -0,0 +1,12 @@
+import { beacon_page, beacon_record_cpu, hole_request_times, is_headless } from "./runtime/beacon.js";
+import { props_sidecar_of } from "./runtime/sidecar.js";
+import { PAGE_SEED_SELECTOR } from "./runtime/seeds.js";
+import { paint_blocker } from "./runtime/render-blocking.js";
+import { charge, own_cost } from "./runtime/own-cost.js";
+import { nearest_attr } from "./runtime/nearest-attr.js";
+import { REGION_RENDER_CONCURRENCY } from "./runtime/concurrency.js";
+import { tool_fetch, tool_made } from "./tool-fetches.js";
+import { PAGE_DEFER_GLOBAL, PAGE_DEFER_KEY, PAGE_DEFER_REGISTRY_KEY } from "./page-defer.js";
+import { ISLAND_GRAPH_ATTR, decode_island_graph } from "./island-graph.js";
+import { find_unscoped, unscoped_finding, unscoped_marker } from "./unscoped-css.js";
+export { ISLAND_GRAPH_ATTR, PAGE_DEFER_GLOBAL, PAGE_DEFER_KEY, PAGE_DEFER_REGISTRY_KEY, PAGE_SEED_SELECTOR, REGION_RENDER_CONCURRENCY, beacon_page, beacon_record_cpu, charge, decode_island_graph, find_unscoped, hole_request_times, is_headless, nearest_attr, own_cost, paint_blocker, props_sidecar_of, tool_fetch, tool_made, unscoped_finding, unscoped_marker };

package/dist/internal-reconcile.d.ts

@@ -0,0 +1,3 @@
+import { reconcile_body } from "./runtime/reconcile.js";
+import { morph_children } from "./runtime/morph.js";
+export { morph_children, reconcile_body };

package/dist/internal-reconcile.js

@@ -0,0 +1,3 @@
+import { reconcile_body } from "./runtime/reconcile.js";
+import { morph_children } from "./runtime/morph.js";
+export { morph_children, reconcile_body };

package/dist/internal-register.d.ts

@@ -0,0 +1,7 @@
+import { __register_transportable } from "./live-transport.js";
+import { __tag_context } from "./context-bridge.js";
+import { register_router_css, register_router_css_paths } from "./router-css.js";
+import { __og_$ } from "./fn-transport.js";
+import { __og_store } from "./store-transport.js";
+import { __og_boundary } from "./boundary.js";
+export { __og_$, __og_boundary, __og_store, __register_transportable, __tag_context, register_router_css, register_router_css_paths };

package/dist/internal-register.js

@@ -0,0 +1,7 @@
+import { __register_transportable } from "./live-transport.js";
+import { __tag_context } from "./context-bridge.js";
+import { register_router_css, register_router_css_paths } from "./router-css.js";
+import { __og_$ } from "./fn-transport.js";
+import { __og_store } from "./store-transport.js";
+import { __og_boundary } from "./boundary.js";
+export { __og_$, __og_boundary, __og_store, __register_transportable, __tag_context, register_router_css, register_router_css_paths };

package/dist/internal-server.d.ts

@@ -0,0 +1,7 @@
+import { makeRegionEndpoint } from "./server/region-endpoint.js";
+import { render_region_html } from "./server/render-region-html.js";
+import { BatchHoleStats, HoleRequestStats, HoleStat, IslandInteractivity, IslandStat, OgygiaRequestStats, SeedKeyStat, hole_stats_of, record_request_stats, request_stats_of, set_batch_hole_listener, set_request_stats_detail, want_request_stats } from "./server/request-stats.js";
+import { mark_personal } from "./server/personal-response.js";
+import { islands_endpoint } from "./server/endpoint.js";
+import { scanRegions } from "./server/split-regions.js";
+export { type BatchHoleStats, type HoleRequestStats, type HoleStat, type IslandInteractivity, type IslandStat, type OgygiaRequestStats, type SeedKeyStat, hole_stats_of, islands_endpoint, makeRegionEndpoint, mark_personal, record_request_stats, render_region_html, request_stats_of, scanRegions, set_batch_hole_listener, set_request_stats_detail, want_request_stats };

package/dist/internal-server.js

@@ -0,0 +1,7 @@
+import { makeRegionEndpoint } from "./server/region-endpoint.js";
+import { render_region_html } from "./server/render-region-html.js";
+import { hole_stats_of, record_request_stats, request_stats_of, set_batch_hole_listener, set_request_stats_detail, want_request_stats } from "./server/request-stats.js";
+import { mark_personal } from "./server/personal-response.js";
+import { islands_endpoint } from "./server/endpoint.js";
+import { scanRegions } from "./server/split-regions.js";
+export { hole_stats_of, islands_endpoint, makeRegionEndpoint, mark_personal, record_request_stats, render_region_html, request_stats_of, scanRegions, set_batch_hole_listener, set_request_stats_detail, want_request_stats };

package/dist/internal.d.ts

@@ -0,0 +1,13 @@
+import { og_entry_hydrate, og_entry_unmount } from "./entry-hydrate.js";
+import { documentIsCsrTrue, isNested, setNested } from "./context.js";
+import { __register_transportable } from "./live-transport.js";
+import { __og_$, __register_fn } from "./fn-transport.js";
+import { __og_store, __register_store_factory, mark_store } from "./store-transport.js";
+import { __og_boundary, configure_boundary } from "./boundary.js";
+import { __og_source } from "./source.js";
+import { __tag_context } from "./context-bridge.js";
+import { og_portable } from "./region-snippet.js";
+import { og_html_region, prebaked_region } from "./region.js";
+import Region from "./Region.svelte";
+import NestedProvider from "./NestedProvider.svelte";
+export { NestedProvider, Region, __og_$, __og_boundary, __og_source, __og_store, __register_fn, __register_store_factory, __register_transportable, __tag_context, configure_boundary, documentIsCsrTrue, isNested, mark_store, og_entry_hydrate, og_entry_unmount, og_html_region, og_portable, prebaked_region, setNested };

package/dist/internal.js

@@ -0,0 +1,13 @@
+import { og_entry_hydrate, og_entry_unmount } from "./entry-hydrate.js";
+import { documentIsCsrTrue, isNested, setNested } from "./context.js";
+import { __register_transportable } from "./live-transport.js";
+import { __og_$, __register_fn } from "./fn-transport.js";
+import { __og_store, __register_store_factory, mark_store } from "./store-transport.js";
+import { __og_boundary, configure_boundary } from "./boundary.js";
+import { __og_source } from "./source.js";
+import { __tag_context } from "./context-bridge.js";
+import { og_portable } from "./region-snippet.js";
+import { og_html_region, prebaked_region } from "./region.js";
+import Region from "./Region.svelte";
+import NestedProvider from "./NestedProvider.svelte";
+export { NestedProvider, Region, __og_$, __og_boundary, __og_source, __og_store, __register_fn, __register_store_factory, __register_transportable, __tag_context, configure_boundary, documentIsCsrTrue, isNested, mark_store, og_entry_hydrate, og_entry_unmount, og_html_region, og_portable, prebaked_region, setNested };

package/dist/island-graph.d.ts

@@ -0,0 +1,36 @@
+/**
+ * THE ISLAND GRAPH — which chunks each island's code needs, as DATA the page carries, never as
+ * `<link rel="modulepreload">` tags.
+ *
+ * An island entry's own `import()` finds its chunks only after it downloads and parses: a waterfall.
+ * A modulepreload per chunk removes the waterfall, but a hint in the HTML fetches the moment the
+ * parser meets it — before the page has painted, and for islands that may never wake. So the server
+ * writes the graph as data (this format), and the runtime inserts the preload links itself when an
+ * island WAKES (runtime/island-graph-preload.ts): after the wake gate, for exactly that island, beside
+ * its `import()`. Its whole graph downloads in parallel the moment it may start; nothing lands in
+ * the paint window; an island that never wakes downloads nothing.
+ *
+ * Wire shape (one inert JSON script): `{"h":[href,…],"e":{"<entry>":[i,…]},"s":{"<entry>":src}}` —
+ * every chunk href once, each entry (the region's `entry` attribute, as emitted: its IDENTITY)
+ * listing the indexes of the chunks it needs. Twenty islands sharing Svelte's client runtime name
+ * its chunk once. `s` (optional): the LOCATION of an entry no element on the page carries — a
+ * portable snippet's live entry, imported by its identity — so the runtime loads the content-hashed
+ * file (runtime/region-endpoint-url.ts `note_entry_location`); an element carries its own (`src`).
+ *
+ * Universal leaf: the server encodes (server/document-tail.ts), the boot decodes.
+ */
+/** The attribute that marks a graph script (the runtime finds every one on the page by it). */
+export declare const ISLAND_GRAPH_ATTR = "data-ogygia-graph";
+/** The JSON shape a graph script carries. */
+export interface IslandGraphWire {
+  h: string[];
+  e: Record<string, number[]>;
+  s?: Record<string, string>;
+}
+/** Encode entry → chunk hrefs (and identity → location, when any) as the wire shape (JSON text,
+ *  not yet script-escaped). */
+export declare function encode_island_graph(graph: ReadonlyMap<string, readonly string[]>, locations?: ReadonlyMap<string, string>): string;
+/** Decode a graph script's `s`: entry identity → location, as written (unresolved). */
+export declare function decode_island_locations(text: string): Map<string, string>;
+/** Decode a graph script's text: entry → chunk hrefs, as written (unresolved). Malformed → empty. */
+export declare function decode_island_graph(text: string): Map<string, string[]>;

package/dist/island-graph.js

@@ -0,0 +1,89 @@
+// src/island-graph.ts
+/**
+* THE ISLAND GRAPH — which chunks each island's code needs, as DATA the page carries, never as
+* `<link rel="modulepreload">` tags.
+*
+* An island entry's own `import()` finds its chunks only after it downloads and parses: a waterfall.
+* A modulepreload per chunk removes the waterfall, but a hint in the HTML fetches the moment the
+* parser meets it — before the page has painted, and for islands that may never wake. So the server
+* writes the graph as data (this format), and the runtime inserts the preload links itself when an
+* island WAKES (runtime/island-graph-preload.ts): after the wake gate, for exactly that island, beside
+* its `import()`. Its whole graph downloads in parallel the moment it may start; nothing lands in
+* the paint window; an island that never wakes downloads nothing.
+*
+* Wire shape (one inert JSON script): `{"h":[href,…],"e":{"<entry>":[i,…]},"s":{"<entry>":src}}` —
+* every chunk href once, each entry (the region's `entry` attribute, as emitted: its IDENTITY)
+* listing the indexes of the chunks it needs. Twenty islands sharing Svelte's client runtime name
+* its chunk once. `s` (optional): the LOCATION of an entry no element on the page carries — a
+* portable snippet's live entry, imported by its identity — so the runtime loads the content-hashed
+* file (runtime/region-endpoint-url.ts `note_entry_location`); an element carries its own (`src`).
+*
+* Universal leaf: the server encodes (server/document-tail.ts), the boot decodes.
+*/
+/** The attribute that marks a graph script (the runtime finds every one on the page by it). */
+const ISLAND_GRAPH_ATTR = "data-ogygia-graph";
+/** Encode entry → chunk hrefs (and identity → location, when any) as the wire shape (JSON text,
+*  not yet script-escaped). */
+function encode_island_graph(graph, locations) {
+	const h = [];
+	const index = /* @__PURE__ */ new Map();
+	const e = {};
+	for (const [entry, hrefs] of graph) {
+		const ids = [];
+		for (const href of hrefs) {
+			let i = index.get(href);
+			if (i === void 0) {
+				i = h.length;
+				h.push(href);
+				index.set(href, i);
+			}
+			ids.push(i);
+		}
+		e[entry] = ids;
+	}
+	if (!locations?.size) return JSON.stringify({
+		h,
+		e
+	});
+	return JSON.stringify({
+		h,
+		e,
+		s: Object.fromEntries(locations)
+	});
+}
+/** Decode a graph script's `s`: entry identity → location, as written (unresolved). */
+function decode_island_locations(text) {
+	const out = /* @__PURE__ */ new Map();
+	let wire;
+	try {
+		wire = JSON.parse(text);
+	} catch {
+		return out;
+	}
+	if (!wire || !wire.s || typeof wire.s !== "object") return out;
+	for (const [entry, src] of Object.entries(wire.s)) if (typeof src === "string") out.set(entry, src);
+	return out;
+}
+/** Decode a graph script's text: entry → chunk hrefs, as written (unresolved). Malformed → empty. */
+function decode_island_graph(text) {
+	const out = /* @__PURE__ */ new Map();
+	let wire;
+	try {
+		wire = JSON.parse(text);
+	} catch {
+		return out;
+	}
+	if (!wire || !Array.isArray(wire.h) || !wire.e || typeof wire.e !== "object") return out;
+	for (const entry of Object.keys(wire.e)) {
+		const ids = wire.e[entry];
+		if (!Array.isArray(ids)) continue;
+		const hrefs = [];
+		for (const i of ids) {
+			const href = wire.h[i];
+			if (typeof href === "string") hrefs.push(href);
+		}
+		out.set(entry, hrefs);
+	}
+	return out;
+}
+export { ISLAND_GRAPH_ATTR, decode_island_graph, decode_island_locations, encode_island_graph };

package/dist/keep-fallback-marker.d.ts

@@ -0,0 +1,7 @@
+/**
+ * The parcel/store stand-in for "keep the fallback" (see ./keep-fallback.ts) — never applied to the
+ * DOM. A dependency-free leaf: the browser runtime's boot compares a hole's answer against it, and
+ * `keep-fallback.ts` itself imports the server-side context module (which reaches Svelte), which must
+ * never enter the boot's static graph.
+ */
+export declare const KEEP_FALLBACK_HTML = "<!--ogygia:keep-fallback-->";

package/dist/keep-fallback-marker.js

@@ -0,0 +1,9 @@
+// src/keep-fallback-marker.ts
+/**
+* The parcel/store stand-in for "keep the fallback" (see ./keep-fallback.ts) — never applied to the
+* DOM. A dependency-free leaf: the browser runtime's boot compares a hole's answer against it, and
+* `keep-fallback.ts` itself imports the server-side context module (which reaches Svelte), which must
+* never enter the boot's static graph.
+*/
+const KEEP_FALLBACK_HTML = "<!--ogygia:keep-fallback-->";
+export { KEEP_FALLBACK_HTML };

package/dist/keep-fallback.d.ts

@@ -0,0 +1,13 @@
+import { KEEP_FALLBACK_HTML } from "./keep-fallback-marker.js";
+/** The message a misplaced `keepFallback()` fails with (a real error, not the signal). */
+export declare const KEEP_FALLBACK_INLINE_MESSAGE: string;
+export declare class KeepFallbackSignal extends Error {
+  constructor();
+}
+/** End this server island's render: the page's fallback is the right content for this visitor.
+ *  Called from a server island rendering INLINE (nested in an island — the deferred mark is
+ *  ignored there), the signal would escape to Kit's error page: fail with the reason instead. */
+export declare function keepFallback(): never;
+/** Did a hole render end with {@link keepFallback}? (the handle's catch reads this) */
+export declare function is_keep_fallback(e: unknown): boolean;
+export { KEEP_FALLBACK_HTML };

package/dist/keep-fallback.js

@@ -0,0 +1,39 @@
+import { isHoleInline } from "./context.js";
+import { KEEP_FALLBACK_HTML } from "./keep-fallback-marker.js";
+// src/keep-fallback.ts
+/**
+* `keepFallback()` — a server island's way to say "what the page already shows is right".
+*
+* A hole's `ogygiaFallback` is often the common case rendered in the page (an anonymous visitor's
+* actions slot, an eyebrow with no session); the hole exists for the other visitors. Calling
+* `keepFallback()` during the hole's server render ends it with no HTML: the endpoint answers
+* `204 No Content` (a batch parcel carries {@link KEEP_FALLBACK_HTML}), the runtime keeps the
+* fallback DOM as it is and marks the region done — no swap, no stylesheet wait, no bytes. Server
+* only: it throws a branded signal the handle recognises; in the browser a hole never renders.
+*/
+const KEEP = Symbol.for("ogygia.keep-fallback");
+/** The message a misplaced `keepFallback()` fails with (a real error, not the signal). */
+const KEEP_FALLBACK_INLINE_MESSAGE = "[ogygia] keepFallback() ran inside the PAGE render: this server island is nested inside a `wake` island, where `render: \"deferred\"` is ignored and its component renders inline — nothing catches the signal there and its fallback never shows. Move the island out of the enclosing island (into the page, a layout, or a lake), or drop keepFallback() from a component that can render inline.";
+var KeepFallbackSignal = class extends Error {
+	constructor() {
+		super("[ogygia] keepFallback(): the page fallback stands");
+		this.name = "KeepFallback";
+		Object.defineProperty(this, KEEP, { value: true });
+	}
+};
+/** End this server island's render: the page's fallback is the right content for this visitor.
+*  Called from a server island rendering INLINE (nested in an island — the deferred mark is
+*  ignored there), the signal would escape to Kit's error page: fail with the reason instead. */
+function keepFallback() {
+	let inline = false;
+	try {
+		inline = isHoleInline();
+	} catch {}
+	if (inline) throw new Error(KEEP_FALLBACK_INLINE_MESSAGE);
+	throw new KeepFallbackSignal();
+}
+/** Did a hole render end with {@link keepFallback}? (the handle's catch reads this) */
+function is_keep_fallback(e) {
+	return !!e && typeof e === "object" && e[KEEP] === true;
+}
+export { KEEP_FALLBACK_HTML, KEEP_FALLBACK_INLINE_MESSAGE, KeepFallbackSignal, is_keep_fallback, keepFallback };

package/dist/kit-paths.d.ts

@@ -0,0 +1,2 @@
+/** Kit's `asset()` for a base-less URL ogygia baked (`/_app/immutable/x.js`). */
+export declare function kit_asset(file: string): string;

package/dist/kit-paths.js

@@ -0,0 +1,39 @@
+import { asset } from "$app/paths";
+// src/kit-paths.ts
+/**
+* KIT'S `asset()` FOR OGYGIA'S URLS. ogygia bakes every URL base-less with a leading slash
+* (`/_app/immutable/…`, `/@id/…`) and runs it through Kit's `asset()` at render — the one authority on
+* the base, the assets CDN and page-relative paths. Kit 2 takes the path with its leading slash; Kit 3
+* takes it without (and warns on every call with it, in dev — one warning per island render).
+*
+* WHICH KIT is a build-time fact: the plugin reads the app's Kit and defines `__OGYGIA_KIT_MAJOR__`. It
+* used to be probed (try the path without its slash; a refusal means Kit 2) — but Kit 2 refuses only in
+* DEV: in a build it accepted the slash-less path and returned it page-relative (`_app/immutable/x.js`),
+* so on a page below the root every island entry resolved against the page (`/account/_app/…`) and 404'd.
+* Without the define (a plain node import of dist/), the probe stands in, its answer checked: a result
+* that is neither root-absolute, page-relative with a dot, nor a full URL is Kit 2's slash-less mistake.
+*/
+const KIT_MAJOR = typeof __OGYGIA_KIT_MAJOR__ !== "undefined" ? __OGYGIA_KIT_MAJOR__ : null;
+/** this Kit wants the leading slash (it refused the path without one); null until the first call */
+let wants_slash = KIT_MAJOR === null ? null : KIT_MAJOR < 3;
+/** A URL `asset()` may legitimately return: root-absolute, `./` / `../` relative, or a full URL. */
+function well_formed(url) {
+	return url.startsWith("/") || url.startsWith(".") || url.includes("://");
+}
+/** Kit's `asset()` for a base-less URL ogygia baked (`/_app/immutable/x.js`). */
+function kit_asset(file) {
+	const call = asset;
+	if (!file.startsWith("/")) return call(file);
+	if (wants_slash === null) {
+		try {
+			const out = call(file.slice(1));
+			if (well_formed(out)) {
+				wants_slash = false;
+				return out;
+			}
+		} catch {}
+		wants_slash = true;
+	}
+	return call(wants_slash ? file : file.slice(1));
+}
+export { kit_asset };