@ogygia/core 0.0.0 → 0.11.1

package/dist/runtime/boot-link.d.ts

@@ -0,0 +1 @@
+export declare function link_boot(): void;

package/dist/runtime/boot-link.js

@@ -0,0 +1,44 @@
+import { slots } from "./slots.js";
+import { KitBoot, kit_hydrates_page } from "./kit-boot.js";
+import { ABSOLUTE_URL_SCHEME, is_warmed_module, warm_island_module } from "./region-endpoint-url.js";
+import { note_entry_location } from "./entry-locations.js";
+import { register_island_graph } from "./island-graph-preload.js";
+import { props_sidecar_of } from "./sidecar.js";
+import { parse_region_html } from "./parse-html.js";
+import { runtime_session } from "./session.js";
+import { regions_in_shadow } from "./connected.js";
+import { yield_task } from "./schedule.js";
+import { beacon_nav } from "./beacon.js";
+import { is_self_owned, walk_enters } from "./ownership.js";
+import { load_slot } from "./load-scheduler.js";
+// src/runtime/boot-link.ts
+/**
+* Fill `slots.boot` — the boot helpers and session state the runtime's lazy chunks (the hydrate
+* core, the router's navigation) use. They read them from the registry and never import these
+* modules, so each stays in the runtime chunk alone instead of being split into a shared file
+* (./slots.ts `BootLink` explains why). Core calls this at boot, before any lazy chunk can load; a
+* test that imports a lazy module without booting calls it too. Idempotent.
+*/
+const BEACON = typeof __OGYGIA_BEACON__ !== "undefined" ? __OGYGIA_BEACON__ : true;
+const no_beacon_nav = () => {};
+function link_boot() {
+	slots.boot ??= {
+		kit_hydrates_page,
+		KitBoot,
+		ABSOLUTE_URL_SCHEME,
+		register_island_graph,
+		is_warmed_module,
+		warm_island_module,
+		note_entry_location,
+		props_sidecar_of,
+		parse_region_html,
+		runtime_session,
+		regions_in_shadow,
+		yield_task,
+		beacon_nav: BEACON ? beacon_nav : no_beacon_nav,
+		walk_enters,
+		is_self_owned,
+		load_slot
+	};
+}
+export { link_boot };

package/dist/runtime/client-hooks.d.ts

@@ -0,0 +1,5 @@
+type ClientHooksModule = {
+  init?: (input?: unknown) => unknown;
+};
+export declare function run_app_client_hooks(loader: () => Promise<ClientHooksModule>): void;
+export {};

package/dist/runtime/client-hooks.js

@@ -0,0 +1,22 @@
+import { kit_hydrates_page } from "./kit-boot.js";
+// src/runtime/client-hooks.ts
+/**
+* Run the app's `hooks.client.ts` `init()` on a csr=false page.
+*
+* SvelteKit runs `hooks.client.ts` (its top-level code and the `init` hook) only when its own client
+* app boots. A `csr = false` page never boots that app — ogygia hydrates islands directly — so
+* anything that file starts (a monitoring/RUM agent, a third-party component bootstrap) would silently
+* never load, and the page behaves differently with ogygia than without. ogygia IS the client
+* bootstrap on those pages, so it runs the hook itself, giving `hooks.client.ts` the same effect it has
+* on a csr=true page.
+*
+* On a Kit (csr=true) document Kit already ran the file — this SKIPS, so `init` never double-fires.
+* Fire-and-forget and after paint: a failing `init` warns but never blocks island hydration, and the
+* dynamic import means the file (and its deps) load only where Kit didn't — never on a csr=true page.
+*/
+function run_app_client_hooks(loader) {
+	if (typeof document === "undefined") return;
+	if (kit_hydrates_page()) return;
+	Promise.resolve().then(loader).then((m) => m.init?.()).catch((e) => console.error("[ogygia] hooks.client init failed:", e));
+}
+export { run_app_client_hooks };

package/dist/runtime/client-plugins.d.ts

@@ -0,0 +1,8 @@
+import { ClientPlugin } from "../plugin/client.js";
+export declare const CLIENT_PLUGINS: boolean;
+/** Boot each plugin's browser half (the runtime's boot, or a Kit-owned page's). */
+export declare function boot_client_plugins(list: readonly ClientPlugin[], kit_page: boolean): void;
+/** A region's component started in the browser: its entry, and the files it runs from. */
+export declare function client_region_mount(el: Element): void;
+/** A region's component left the page. */
+export declare function client_region_unmount(el: Element, entry: string): void;

package/dist/runtime/client-plugins.js

@@ -0,0 +1,34 @@
+// src/runtime/client-plugins.ts
+const CLIENT_PLUGINS = typeof __OGYGIA_CLIENT_PLUGINS__ !== "undefined" ? __OGYGIA_CLIENT_PLUGINS__ : false;
+let plugins = [];
+/** Boot each plugin's browser half (the runtime's boot, or a Kit-owned page's). */
+function boot_client_plugins(list, kit_page) {
+	plugins = list;
+	for (const p of list) p.boot?.({ kitPage: kit_page });
+}
+/** A region's component started in the browser: its entry, and the files it runs from. */
+function client_region_mount(el) {
+	const entry = el.getAttribute("entry");
+	if (!entry) return;
+	let urls;
+	for (const p of plugins) {
+		if (!p.regionMount) continue;
+		urls ??= region_urls(el, entry);
+		p.regionMount(el, {
+			entry,
+			urls
+		});
+	}
+}
+/** A region's component left the page. */
+function client_region_unmount(el, entry) {
+	for (const p of plugins) p.regionUnmount?.(el, { entry });
+}
+function region_urls(el, entry) {
+	const urls = [];
+	for (const u of [entry, el.getAttribute("src")]) try {
+		if (u) urls.push(new URL(u, document.baseURI).href);
+	} catch {}
+	return urls;
+}
+export { CLIENT_PLUGINS, boot_client_plugins, client_region_mount, client_region_unmount };

package/dist/runtime/concurrency.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Shared concurrency gate — client region fetches (SI-STORM) and server region SSR (M1).
+ * Caps in-flight work; waiters queue FIFO. Does not cancel running work (see INVARIANTS.md).
+ */
+export declare class ConcurrencyGate {
+  #private;
+  constructor(max: number);
+  run<T>(fn: () => Promise<T>): Promise<T>;
+  get active(): number;
+}
+/** Max concurrent region SSR renders per process (CPU amp under valid MAC). */
+export declare const REGION_RENDER_CONCURRENCY = 4;

package/dist/runtime/concurrency.js

@@ -0,0 +1,29 @@
+// src/runtime/concurrency.ts
+/**
+* Shared concurrency gate — client region fetches (SI-STORM) and server region SSR (M1).
+* Caps in-flight work; waiters queue FIFO. Does not cancel running work (see INVARIANTS.md).
+*/
+var ConcurrencyGate = class {
+	#limit;
+	#active = 0;
+	#wait = [];
+	constructor(max) {
+		this.#limit = Math.max(1, max);
+	}
+	async run(fn) {
+		if (this.#active >= this.#limit) await new Promise((resolve) => this.#wait.push(resolve));
+		this.#active++;
+		try {
+			return await fn();
+		} finally {
+			this.#active--;
+			this.#wait.shift()?.();
+		}
+	}
+	get active() {
+		return this.#active;
+	}
+};
+/** Max concurrent region SSR renders per process (CPU amp under valid MAC). */
+const REGION_RENDER_CONCURRENCY = 4;
+export { ConcurrencyGate, REGION_RENDER_CONCURRENCY };

package/dist/runtime/connected.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Every region currently CONNECTED to the live document (added at connect, removed at disconnect —
+ * shadow-rooted ones included, a custom element connects wherever it is). The navigation compares
+ * its size to the light DOM's region count: a mismatch means a region lives inside a shadow root,
+ * where a body morph cannot reach it, and the navigation takes the full-swap path. A count, not
+ * the `'*'` walk over every element the old shadow-root probe made on each navigation. Its own
+ * module: the element (core) writes it, the lazily loaded navigation reads it, and neither needs
+ * the other's imports for that.
+ */
+export declare const connected_regions: Set<Element>;
+/** Is any connected region inside a shadow root (so a body morph would miss it)? */
+export declare function regions_in_shadow(): boolean;

package/dist/runtime/connected.js

@@ -0,0 +1,16 @@
+// src/runtime/connected.ts
+/**
+* Every region currently CONNECTED to the live document (added at connect, removed at disconnect —
+* shadow-rooted ones included, a custom element connects wherever it is). The navigation compares
+* its size to the light DOM's region count: a mismatch means a region lives inside a shadow root,
+* where a body morph cannot reach it, and the navigation takes the full-swap path. A count, not
+* the `'*'` walk over every element the old shadow-root probe made on each navigation. Its own
+* module: the element (core) writes it, the lazily loaded navigation reads it, and neither needs
+* the other's imports for that.
+*/
+const connected_regions = /* @__PURE__ */ new Set();
+/** Is any connected region inside a shadow root (so a body morph would miss it)? */
+function regions_in_shadow() {
+	return connected_regions.size !== document.body.querySelectorAll("ogygia-region").length;
+}
+export { connected_regions, regions_in_shadow };

package/dist/runtime/context.d.ts

@@ -0,0 +1 @@
+export declare function install(): void;

package/dist/runtime/context.js

@@ -0,0 +1,19 @@
+import { collect_provided_context } from "../context-bridge.js";
+import { slots } from "./slots.js";
+// src/runtime/context.ts
+/**
+* `context` feature — the cross-island context bridge.
+*
+* Fills {@link ./slots.js slots.context} with the DOM walk that seeds each island's `getContext`
+* from a `<Provide>` / drop-in-`setContext` marker above it (see `../context-bridge.js`). Included
+* only when the build detects an ogygia context provider — `Provide`, `setContext`, or
+* `createContext` imported from `'ogygia'` (see the driver's `source_uses_ogygia_context`). A plain
+* app that never bridges context tree-shakes the ~4.7 kB bridge away; core reads the slot with
+* optional chaining, so its absence is just "no provider above" — the common, already-handled case.
+*
+* A HYDRATE-phase feature (link/runtime-entry.ts): installed by the hydrate core, never the boot.
+*/
+function install() {
+	slots.context = collect_provided_context;
+}
+export { install };

package/dist/runtime/core.d.ts

@@ -0,0 +1,15 @@
+import { ClientPlugin } from "../plugin/client.js";
+/**
+ * Parse a fetched region's HTML into a fragment, HOISTING any `<link data-ogygia-region-css>` (or
+ * inlined `<style data-ogygia-region-css="href">`) it carries into `<head>` (deduped by href). A held / server-picked region's component was never
+ * imported by the page, so its scoped CSS is in no stylesheet the page loaded; the region response
+ * ships the links and the runtime lifts them to the head — where they load once and stick. (A link
+ * left in the body would also fail to load inside a `<template>` batch parcel.)
+ */
+export declare function region_fragment(html: string): {
+  frag: DocumentFragment;
+  ready: Promise<void>;
+};
+/** TEST: the pristine server markup {@link region_fragment} stashed on a nested island, if any. */
+export declare function pristine_ssr_of(el: Element): string | undefined;
+export declare function boot(installers?: Array<() => void>, client_plugins?: readonly ClientPlugin[]): void;