@ogygia/core 0.12.3 → 0.13.0

package/dist/early-holes.d.ts

@@ -0,0 +1,34 @@
+/**
+ * THE EARLY START OF A HOLE THAT LOADS AT ONCE. A `defer: 'load'` hole's request starts during the
+ * HTML parse, before the runtime is in, so its answer is on its way when the hole wakes. The page's
+ * head carries one data block (the endpoints, JSON: no CSP allowance needed) and one inline script
+ * that is the same bytes on every page ({@link start_early_holes}): it starts each `fetch` as the
+ * runtime's hole fetch would (./runtime/hole-fetch.ts) and parks the requests by resolved URL on one
+ * global. The runtime takes them over as the frame store's flights (./runtime/early-holes.ts), so
+ * each hole is asked for once. (A `<link rel="preload" as="fetch">` did the early start before:
+ * WebKit never hands one to a later `fetch()`, and every hole was asked for, and rendered, twice
+ * there: #404.)
+ *
+ * The script never changes, so its hash is a constant: a policy that would block it gets that hash
+ * (./server/early-holes-csp.ts, computed from the text ./early-holes-head.ts writes). Universal and
+ * import-free: the runtime reads the global through it.
+ */
+/** The id of the head's data block: the `load` holes' endpoints, as rendered. */
+export declare const EARLY_HOLES_ID = "ogygia-early-holes";
+/** The `Symbol.for` name of the global the script parks its requests on (a list of
+ *  {@link EarlyHole}), until the runtime takes them over. */
+export declare const EARLY_HOLES_KEY = "ogygia.early-holes";
+/** One request the head started: the hole's endpoint, resolved, the `fetch` that asks for it, and
+ *  the controller that cancels it (the flight that takes it over owns it). */
+export type EarlyHole = {
+  url: string;
+  response: Promise<Response>;
+  controller: AbortController;
+};
+/**
+ * The early start, run inline in the head (`script()` writes its source: self-contained, browser
+ * globals only). Each endpoint in the data block is resolved against the document's base, as the
+ * runtime resolves it, and asked for once. A request that fails is the runtime's to say when it
+ * takes it over: the park only keeps its rejection from reading as unhandled.
+ */
+export declare function start_early_holes(id: string, key: string): void;

package/dist/early-holes.js

@@ -0,0 +1,51 @@
+// src/early-holes.ts
+/**
+* THE EARLY START OF A HOLE THAT LOADS AT ONCE. A `defer: 'load'` hole's request starts during the
+* HTML parse, before the runtime is in, so its answer is on its way when the hole wakes. The page's
+* head carries one data block (the endpoints, JSON: no CSP allowance needed) and one inline script
+* that is the same bytes on every page ({@link start_early_holes}): it starts each `fetch` as the
+* runtime's hole fetch would (./runtime/hole-fetch.ts) and parks the requests by resolved URL on one
+* global. The runtime takes them over as the frame store's flights (./runtime/early-holes.ts), so
+* each hole is asked for once. (A `<link rel="preload" as="fetch">` did the early start before:
+* WebKit never hands one to a later `fetch()`, and every hole was asked for, and rendered, twice
+* there: #404.)
+*
+* The script never changes, so its hash is a constant: a policy that would block it gets that hash
+* (./server/early-holes-csp.ts, computed from the text ./early-holes-head.ts writes). Universal and
+* import-free: the runtime reads the global through it.
+*/
+/** The id of the head's data block: the `load` holes' endpoints, as rendered. */
+const EARLY_HOLES_ID = "ogygia-early-holes";
+/** The `Symbol.for` name of the global the script parks its requests on (a list of
+*  {@link EarlyHole}), until the runtime takes them over. */
+const EARLY_HOLES_KEY = "ogygia.early-holes";
+/**
+* The early start, run inline in the head (`script()` writes its source: self-contained, browser
+* globals only). Each endpoint in the data block is resolved against the document's base, as the
+* runtime resolves it, and asked for once. A request that fails is the runtime's to say when it
+* takes it over: the park only keeps its rejection from reading as unhandled.
+*/
+function start_early_holes(id, key) {
+	const data = document.getElementById(id);
+	if (!data) return;
+	const parked = [];
+	const asked = /* @__PURE__ */ new Set();
+	for (const endpoint of JSON.parse(data.textContent || "[]")) {
+		const url = new URL(endpoint, document.baseURI).href;
+		if (asked.has(url)) continue;
+		asked.add(url);
+		const controller = new AbortController();
+		const response = fetch(url, {
+			credentials: "same-origin",
+			signal: controller.signal
+		});
+		response.catch(() => {});
+		parked.push({
+			url,
+			response,
+			controller
+		});
+	}
+	globalThis[Symbol.for(key)] = parked;
+}
+export { EARLY_HOLES_ID, EARLY_HOLES_KEY, start_early_holes };

package/dist/entry-hydrate.js

@@ -1,5 +1,5 @@
+import { nested_context } from "./nested.js";
 import { hydrate, unmount } from "svelte";
-import NestedProvider from "./NestedProvider.svelte";
 // src/entry-hydrate.ts
 /**
 * THE FOREIGN-HYDRATE CONTRACT (fragment federation), in one place. A stitched fragment's island
@@ -13,12 +13,11 @@ import NestedProvider from "./NestedProvider.svelte";
 * `__og_unmount` (compiler/region/emit.ts); an app that does not federate ships neither. This module
 * sits in the producer's own build, so its `svelte` is the producer's.
 *
-* Hydrate through THIS build's NestedProvider, mirroring the local runtime's call shape: the SSR
-* children were rendered through the provider's dynamic-component branch (the `<!--[0-->` marker), so
-* a bare-component hydrate walks one marker layer short — svelte aborts mid-walk and client-re-renders.
-* `options.recover === false`: the consumer's self-heal (hydrate-core.ts) asks THIS svelte to throw on
-* a mismatch instead of re-rendering; the envelope is re-checked per call because a restore from the
-* server markup drops it.
+* The component itself is hydrated, as the local runtime does (runtime/hydrate-core.ts), marked
+* "inside an island" through its context: the SSR children are its nodes in one anchor pair (the
+* placed island's dynamic-component pair). `options.recover === false`: the consumer's self-heal
+* asks THIS svelte to throw on a mismatch instead of re-rendering; the envelope is re-checked per
+* call because a restore from the server markup drops it.
 */
 function og_entry_hydrate(component, target, props, options) {
 	const first = target.firstChild;
@@ -27,12 +26,10 @@ function og_entry_hydrate(component, target, props, options) {
 		target.appendChild(document.createComment("]"));
 	}
 	const recovery = options && options.recover === false ? { recover: false } : {};
-	return hydrate(NestedProvider, {
+	return hydrate(component, {
 		target,
-		props: {
-			component,
-			props
-		},
+		props,
+		context: nested_context(),
 		...recovery
 	});
 }

package/dist/events/bus.js

@@ -1,4 +1,5 @@
 import "./schema.js";
+import { report_thrown } from "../report-thrown.js";
 // src/events/bus.ts
 /**
 * The devtools EVENT BUS — the whole product's spine (internal/notes/devtools.md, Rung 0).
@@ -83,7 +84,9 @@ function emit(input) {
 	if (b.count < b.cap) b.count++;
 	if (b.sinks.size) for (const sink of b.sinks) try {
 		sink(event);
-	} catch {}
+	} catch (error) {
+		report_thrown(error);
+	}
 }
 /**
 * Push ALREADY-STAMPED events into the buffer + sinks WITHOUT re-stamping — the ingest path for the
@@ -101,7 +104,9 @@ function ingest(events) {
 		if (b.count < b.cap) b.count++;
 		if (b.sinks.size) for (const sink of b.sinks) try {
 			sink(event);
-		} catch {}
+		} catch (error) {
+			report_thrown(error);
+		}
 	}
 }
 /** Buffered events in emission order (oldest → newest). Copies out — safe to hold/serialize. */

package/dist/events/schema.d.ts

@@ -223,8 +223,8 @@ export type RuntimeEventInput = {
   domain: "runtime";
   /** Two owners wanted the same nodes (runtime/ownership.ts): a web component changed its own
    *  children in a position Svelte's hydration reads, and the repair removed what it added so
-   *  the island could hydrate. `reason` names the element and the way out ({@html} / static
-   *  markup / a lake / data-ogygia-keep). */
+   *  the island could hydrate. `reason` names the element (the message `ownership_conflict`
+   *  says the way out). */
   name: "region.hydrate.conflict";
   entry?: string;
   fp?: string;

package/dist/fn-transport.js

@@ -1,4 +1,5 @@
 import { mint, register_kind, resolve } from "./ref.js";
+import { OgygiaError } from "./messages/island.js";
 // src/fn-transport.ts
 /**
 * Transportable functions — the hub's FN kind (the runtime half of `import.meta.og.$`).
@@ -52,9 +53,9 @@ function is_branded_fn(value) {
 function fn_handle(tag, bound) {
 	register_fn_kind();
 	const factory = fn_registry().factories.get(tag);
-	if (factory === void 0) throw new Error(`[ogygia] fn_handle("${tag}"): its factory is not registered on this side. The generated module must be imported as a VALUE at the call site (the compiler emits this import).`);
+	if (factory === void 0) throw new OgygiaError("fn_factory_missing", { tag });
 	const live = factory(...bound);
-	if (typeof live !== "function") throw new Error(`[ogygia] fn factory "${tag}" did not return a function.`);
+	if (typeof live !== "function") throw new OgygiaError("fn_factory_not_function", { tag });
 	live[FN_BRAND] = {
 		t: tag,
 		d: bound,
@@ -94,7 +95,7 @@ function register_fn_kind() {
 				factory = (0, eval)(`(${payload.s})`);
 				fn_registry().factories.set(ref.t, factory);
 			}
-			if (factory === void 0) throw new Error(`[ogygia] cannot revive fn "${ref.t}": its factory is not loaded on this side and the payload carries no source. The island must import the generated module as a VALUE so \`__register_fn\` runs in its bundle (or the fn manifest must be in the runtime).`);
+			if (factory === void 0) throw new OgygiaError("fn_revive_missing", { tag: String(ref.t) });
 			const bound = Array.isArray(payload.b) ? payload.b : [];
 			const live = factory(...bound);
 			live[FN_BRAND] = {