@ogygia/core 0.0.0 → 0.11.1

package/dist/shims/page-store.svelte.js

@@ -0,0 +1,77 @@
+import { foreign_hydrate } from "../current-region.js";
+// src/shims/page-store.svelte.ts
+const FALLBACK = {
+	url: typeof location !== "undefined" ? new URL(location.href) : new URL("http://localhost/"),
+	params: {},
+	route: { id: null },
+	status: 200,
+	data: {},
+	form: null,
+	error: null,
+	state: {}
+};
+var PageState = class {
+	url = $state.raw(FALLBACK.url);
+	params = $state.raw(FALLBACK.params);
+	route = $state.raw(FALLBACK.route);
+	status = $state.raw(FALLBACK.status);
+	data = $state.raw(FALLBACK.data);
+	form = $state.raw(FALLBACK.form);
+	error = $state.raw(FALLBACK.error);
+	state = $state.raw(FALLBACK.state);
+	#subscribers = /* @__PURE__ */ new Set();
+	set(snap) {
+		const s = snap || FALLBACK;
+		this.url = s.url instanceof URL ? s.url : FALLBACK.url;
+		this.params = s.params ?? {};
+		this.route = s.route ?? { id: null };
+		this.status = s.status ?? 200;
+		this.data = s.data ?? {};
+		this.form = s.form ?? null;
+		this.error = s.error ?? null;
+		this.state = s.state ?? {};
+		for (const fn of this.#subscribers) try {
+			fn();
+		} catch {}
+	}
+	reset() {
+		this.set({
+			url: typeof location !== "undefined" ? new URL(location.href) : FALLBACK.url,
+			params: {},
+			route: { id: null },
+			status: 200,
+			data: {},
+			form: null,
+			error: null,
+			state: {}
+		});
+	}
+	subscribe(fn) {
+		this.#subscribers.add(fn);
+		return () => this.#subscribers.delete(fn);
+	}
+};
+const PAGE_STATE_KEY = Symbol.for("ogygia.page-state");
+const global_scope = globalThis;
+const page_state = global_scope[PAGE_STATE_KEY] ??= new PageState();
+/** Seed from an island's SSR snapshot (pre-hydration / SPA remount). */
+function set_page(snap) {
+	page_state.set(snap);
+}
+/** Reset to location-based fallback between SPA body swaps (clears stale route data). */
+function reset_page() {
+	page_state.reset();
+}
+function subscribe_page(fn) {
+	return page_state.subscribe(fn);
+}
+const WARNED_FOREIGN_KEY = Symbol.for("ogygia.foreign-page-warned");
+const warned_foreign_entries = globalThis[WARNED_FOREIGN_KEY] ??= /* @__PURE__ */ new Set();
+function warn_foreign_page_read(expr) {
+	if (!import.meta.env.DEV) return;
+	const f = foreign_hydrate();
+	if (!f || warned_foreign_entries.has(f.entry)) return;
+	warned_foreign_entries.add(f.entry);
+	console.warn(`[ogygia] ${expr} was read inside a mounted MFE island (${f.entry}, from ${f.origin}).\nIn the browser this is the SHELL's page, not the MFE's. The HTML you see was rendered with the MFE's own load data, so this island will repaint with different values after hydrate.\nPass the value as a prop, or read it with a remote function.`);
+}
+export { PageState, page_state, reset_page, set_page, subscribe_page, warn_foreign_page_read };

package/dist/source.d.ts

@@ -0,0 +1,29 @@
+/** hooks.ts installs this once — files a receipt with the current request's facts. */
+export declare function set_source_recorder(fn: ((tag: string) => void) | null): void;
+/** federate() installs this once — every receipt tag. */
+export declare function set_source_observer(fn: ((tag: string) => void) | null): void;
+/** Called by the `__og_source` wrapper on every invocation (and by a peer handle for the tags it
+ *  ADOPTS from a remote fragment). Neither seam may fail the app's own call. */
+export declare function record_source_read(tag: string): void;
+/** The identity stamp — read by `postrender.invalidate(fn, args)`. */
+export declare const SOURCE_ID: unique symbol;
+/** The optional `{ key }` canonicalizer stamp (exotic signatures). */
+export declare const SOURCE_KEY: unique symbol;
+export interface SourceOptions<A extends unknown[]> {
+  /** Canonicalize exotic args to a stable string yourself; default = structural fingerprint. */
+  key?: (...args: A) => string;
+}
+/** The structural fingerprint of a call's args — stable across processes and time. */
+export declare function fingerprint_args(args: unknown[]): string;
+/** `s:<id>:<fp>` — the receipt/eviction tag for one (source, args) pair. */
+export declare function source_tag(id: string, fingerprint: string): string;
+/** The compiled form of `export const X = import.meta.og.source(fn, opts?)`. */
+export declare function __og_source<A extends unknown[], R>(id: string, fn: (...args: A) => R, opts?: SourceOptions<A>): (...args: A) => R;
+/** A function stamped by the macro. */
+type SourceFn = ((...args: never[]) => unknown) & {
+  [SOURCE_ID]?: string;
+  [SOURCE_KEY]?: (...args: unknown[]) => string;
+};
+/** The receipt tag one `(source, args)` call files, or null when `fn` is not a declared source. */
+export declare function source_tag_of(fn: SourceFn, args?: unknown[]): string | null;
+export {};

package/dist/source.js

@@ -0,0 +1,87 @@
+import { fnv1a } from "./runtime/hash.js";
+// src/source.ts
+/**
+* DATA SOURCES — `import.meta.og.source(fn)`, the RUNTIME half (the compiler rewrites the macro to
+* `__og_source('<file#export>', fn, opts?)`, injecting the import from `ogygia/internal`).
+* Isomorphic + tiny: on the server, each call records a receipt tag (`s:<id>:<fingerprint(args)>`)
+* — kept with the request's facts while its render may be stored (the invalidation reverse
+* index), and shown to an observer (a federated fragment reporting what its render read);
+* everywhere else it is a pure pass-through. `sourceTag(fn, args)` (the plugin door) reads the
+* stamped id back off the function — one side, no strings, typos are type errors.
+*
+* The recorder and observer ride ONE `globalThis` slot: several module instances (dist entries,
+* a plugin package beside core) must share the seam.
+*/
+const slots = globalThis[Symbol.for("ogygia.sources")] ??= {
+	recorder: null,
+	observer: null
+};
+/** hooks.ts installs this once — files a receipt with the current request's facts. */
+function set_source_recorder(fn) {
+	slots.recorder = fn;
+}
+/** federate() installs this once — every receipt tag. */
+function set_source_observer(fn) {
+	slots.observer = fn;
+}
+/** Called by the `__og_source` wrapper on every invocation (and by a peer handle for the tags it
+*  ADOPTS from a remote fragment). Neither seam may fail the app's own call. */
+function record_source_read(tag) {
+	try {
+		slots.recorder?.(tag);
+	} catch {}
+	try {
+		slots.observer?.(tag);
+	} catch {}
+}
+/** The identity stamp — read by `postrender.invalidate(fn, args)`. */
+const SOURCE_ID = Symbol.for("ogygia.source.id");
+/** The optional `{ key }` canonicalizer stamp (exotic signatures). */
+const SOURCE_KEY = Symbol.for("ogygia.source.key");
+/** Canonicalize one argument: event-ish shapes collapse to their route identity (a whole
+*  RequestEvent can never ride a fingerprint), URLs to pathnames, functions to a marker. */
+function canonical(value, depth = 0) {
+	if (value === null || typeof value !== "object") return typeof value === "function" ? "[fn]" : value;
+	if (depth > 4) return "[deep]";
+	if (value instanceof URL) return value.pathname;
+	const v = value;
+	if (v.url instanceof URL && ("request" in v || "cookies" in v)) return {
+		__route: v.route?.id ?? null,
+		__path: v.url.pathname
+	};
+	if (typeof Request !== "undefined" && value instanceof Request) return "[request]";
+	if (Array.isArray(value)) return value.map((x) => canonical(x, depth + 1));
+	const out = {};
+	for (const key of Object.keys(v).sort()) out[key] = canonical(v[key], depth + 1);
+	return out;
+}
+/** The structural fingerprint of a call's args — stable across processes and time. */
+function fingerprint_args(args) {
+	try {
+		return fnv1a(JSON.stringify(canonical(args)));
+	} catch {
+		return "opaque";
+	}
+}
+/** `s:<id>:<fp>` — the receipt/eviction tag for one (source, args) pair. */
+function source_tag(id, fingerprint) {
+	return `s:${id}:${fingerprint}`;
+}
+/** The compiled form of `export const X = import.meta.og.source(fn, opts?)`. */
+function __og_source(id, fn, opts) {
+	const wrapped = (...args) => {
+		record_source_read(source_tag(id, opts?.key ? opts.key(...args) : fingerprint_args(args)));
+		return fn(...args);
+	};
+	Object.defineProperty(wrapped, SOURCE_ID, { value: id });
+	if (opts?.key) Object.defineProperty(wrapped, SOURCE_KEY, { value: opts.key });
+	return wrapped;
+}
+/** The receipt tag one `(source, args)` call files, or null when `fn` is not a declared source. */
+function source_tag_of(fn, args = []) {
+	const id = fn[SOURCE_ID];
+	if (!id) return null;
+	const key_fn = fn[SOURCE_KEY];
+	return source_tag(id, key_fn ? key_fn(...args) : fingerprint_args(args));
+}
+export { SOURCE_ID, SOURCE_KEY, __og_source, fingerprint_args, record_source_read, set_source_observer, set_source_recorder, source_tag, source_tag_of };

package/dist/store-transport.d.ts

@@ -0,0 +1,86 @@
+/** Devalue custom-type name for store payloads on the wire. */
+export declare const STORE_WIRE_KEY = "OgygiaW";
+/** Brand carrying a factory tag on a store object (non-enumerable, set by `mark_store`). */
+declare const STORE_TAG: unique symbol;
+interface StoreLike {
+  subscribe: (run: (value: unknown) => void) => unknown;
+  set?: (value: unknown) => void;
+  update?: (fn: (value: unknown) => unknown) => void;
+  [STORE_TAG]?: string;
+}
+/** Legacy wire shape (`t` factory tag, `i` id, `d` current value) — a hub Ref minus its kind. */
+interface StorePayload {
+  t: string;
+  i: string;
+  d: unknown;
+}
+/** Subscribe-shaped, NOT a `[ogygia.wire]` class instance (wire kind), and NOT an `og_derived`
+ *  (the derived kind carries its recipe — the store kind would freeze it to a seed). */
+export declare function is_store(value: unknown): value is StoreLike;
+/** A readable with no way back in — seeding it loses the derivation (classifier warns). */
+export declare function is_derived_like(value: StoreLike): boolean;
+/**
+ * Register a store factory under a stable tag (root-relative module path + export name, same
+ * scheme as transportable classes). Decode calls `factory(seed)`, so the rebuilt store keeps
+ * every method the factory grafts on. Over-registration is harmless.
+ */
+export declare function __register_store_factory(tag: string, factory: unknown): void;
+/**
+ * Brand a store with its factory tag so encode ships the tag instead of the generic one.
+ * Returns the store (chainable at a return site). Hand-written today; the auto-wire compiler
+ * pass will emit this into provably store-returning factories.
+ *
+ * THE FLOOR: never detonate on a product that can't carry a brand. A factory may legitimately
+ * return undefined/a primitive on one side (SSR-guard pattern) — that passes through unbranded
+ * (the `__og_store` wrapper owns the warning, so hand callers stay silent-by-contract). A
+ * frozen/sealed store can't take the stamp either — it degrades to the generic tier (value
+ * still crosses; only factory-grafted methods are lost), with a warning naming the tag.
+ */
+export declare function mark_store<T extends object>(store: T, tag: string): T;
+/** The hub kind: subscribe-shaped values. The moment of crossing is the value snapshot. */
+export declare function register_store_kind(): void;
+/**
+ * Devalue reducer: encode a store, or return undefined to fall through. Reads the store's
+ * CURRENT value with `get()` — the moment of crossing is the snapshot. Same instance → same
+ * wire id (hub-memoized), which is what lets the client reunite every copy into one live store.
+ */
+export declare function reduce_store(value: unknown): StorePayload | undefined;
+/**
+ * Devalue reviver: rebuild a live store via the hub. `remember: true` (browser) memoizes by
+ * wire id — every island decoding this handle gets the SAME store, which is the liveness
+ * mechanism. `remember: false` (server) always builds fresh: per-request isolation.
+ */
+export declare function revive_store(payload: StorePayload, remember: boolean): unknown;
+export declare function __og_store<F extends (...args: never[]) => object>(tag: string, factory: F): F;
+type AnyStore = {
+  subscribe: (run: (v: unknown) => void) => unknown;
+};
+/**
+ * A `derived` that CROSSES boundaries ALIVE — resumability for the reactive graph.
+ *
+ * Svelte's `derived` is a live computation: sources + a formula. The value can serialize; the
+ * computation can't — so a plain derived crosses as a FROZEN seed (the classifier warns). This
+ * primitive remembers its RECIPE, and the recipe is made of exactly the two things the seam
+ * already carries: sources are STORES (they reunify to one live instance per island page) and
+ * the formula is a FUNCTION (mark it with `import.meta.og.$` so it travels as a fn ref).
+ *
+ * ```ts
+ * const doubled = og_derived(tally, import.meta.og.$((n) => n * 2));
+ * ```
+ *
+ * Locally it IS `svelte/store`'s derived — same laziness, same semantics. At a boundary the
+ * derived kind ships `{ sources, formula, seed }`; the island decodes by re-deriving against
+ * the REUNIFIED sources with the REBOUND formula: bump the source in any island and every
+ * island's derived follows. The seed rides along only for exactness of the first paint.
+ *
+ * An UNMARKED formula still works same-tree, but the derived then can't cross (the fn ref
+ * can't be built) — the boundary explains this at the seam rather than freezing silently.
+ */
+export declare function og_derived<T>(sources: AnyStore | AnyStore[], fn: (...vals: never[]) => T, initial?: T): {
+  subscribe: (run: (v: T) => void) => () => void;
+};
+/** The hub kind: an `og_derived` recipe. Sources and formula are shipped as NESTED refs (devalue
+ *  recursion runs the reducer over `d`'s contents), so by decode time they are already LIVE —
+ *  sources reunified, formula rebound — and re-deriving is one call. */
+export declare function register_derived_kind(): void;
+export {};

package/dist/store-transport.js

@@ -0,0 +1,229 @@
+import { wire } from "./live-transport.js";
+import { mint, register_kind, resolve } from "./ref.js";
+import { derived, get, writable } from "svelte/store";
+// src/store-transport.ts
+/**
+* Transportable stores — the hub's STORE kind.
+*
+* A Svelte store is a live object (closure + methods), so devalue rejects it and a
+* `setContext('cart', store)` silently died at the island boundary. This kind lets a
+* subscribe-shaped value cross the same way `[import.meta.og.wire]` classes do: the CURRENT
+* VALUE travels as data, the CODE comes from a module on the other side, and hub identity
+* makes it live — every encode of one store mints ONE id, and the browser resolves by id,
+* so five islands reading the same context key share one client store. `set` in island A
+* repaints `$store` in island B.
+*
+* Two tiers:
+*  - REGISTERED FACTORY (`__register_store_factory(tag, factory)`): decode calls
+*    `factory(seed)` from the registered module, so custom methods (`add`, `reset`,
+*    `useLocalStorage`, …) are REBUILT, not serialized. A store is branded with its factory
+*    tag via `mark_store` (hand-written today, compiler-emitted later).
+*  - GENERIC (`svelte:writable`): any unbranded subscribe-shaped value. Decode is a plain
+*    `writable(seed)` — value + set/update/subscribe survive; bespoke methods do not (the
+*    boundary classifier warns, naming them).
+*
+* Identity, reunification, per-request server isolation: the hub's (see ref.ts).
+*/
+/** Brand on an `og_derived` store: the RECIPE (sources + formula) it was made from. */
+const DERIVED_BRAND = Symbol.for("ogygia.derived");
+/** Devalue custom-type name for store payloads on the wire. */
+const STORE_WIRE_KEY = "OgygiaW";
+/** Generic tag: decode with a bare `writable(seed)`. */
+const GENERIC_TAG = "svelte:writable";
+/** Brand carrying a factory tag on a store object (non-enumerable, set by `mark_store`). */
+const STORE_TAG = Symbol.for("ogygia.store.tag");
+const REGISTRY_KEY = Symbol.for("ogygia.stores");
+function store_registry() {
+	const g = globalThis;
+	return g[REGISTRY_KEY] ??= { factories: /* @__PURE__ */ new Map() };
+}
+/** Subscribe-shaped, NOT a `[ogygia.wire]` class instance (wire kind), and NOT an `og_derived`
+*  (the derived kind carries its recipe — the store kind would freeze it to a seed). */
+function is_store(value) {
+	if (value === null || typeof value !== "object") return false;
+	if (typeof value.subscribe !== "function") return false;
+	if (value[DERIVED_BRAND] !== void 0) return false;
+	const cls = value.constructor;
+	if (typeof cls === "function" && cls[wire]) return false;
+	return true;
+}
+/** A readable with no way back in — seeding it loses the derivation (classifier warns). */
+function is_derived_like(value) {
+	return typeof value.set !== "function" && typeof value.update !== "function";
+}
+/**
+* Register a store factory under a stable tag (root-relative module path + export name, same
+* scheme as transportable classes). Decode calls `factory(seed)`, so the rebuilt store keeps
+* every method the factory grafts on. Over-registration is harmless.
+*/
+function __register_store_factory(tag, factory) {
+	if (typeof factory !== "function") return;
+	store_registry().factories.set(tag, factory);
+}
+/** For warnings: `null` is an object to typeof, and the distinction matters at this seam. */
+const type_of = (v) => v === null ? "null" : typeof v;
+/**
+* Brand a store with its factory tag so encode ships the tag instead of the generic one.
+* Returns the store (chainable at a return site). Hand-written today; the auto-wire compiler
+* pass will emit this into provably store-returning factories.
+*
+* THE FLOOR: never detonate on a product that can't carry a brand. A factory may legitimately
+* return undefined/a primitive on one side (SSR-guard pattern) — that passes through unbranded
+* (the `__og_store` wrapper owns the warning, so hand callers stay silent-by-contract). A
+* frozen/sealed store can't take the stamp either — it degrades to the generic tier (value
+* still crosses; only factory-grafted methods are lost), with a warning naming the tag.
+*/
+function mark_store(store, tag) {
+	if (store === null || typeof store !== "object" && typeof store !== "function") return store;
+	try {
+		Object.defineProperty(store, STORE_TAG, {
+			value: tag,
+			enumerable: false
+		});
+	} catch {
+		if (typeof console !== "undefined") console.warn(`[ogygia] store "${tag}": the store object is not extensible (frozen/sealed), so it cannot carry its factory brand — it will cross boundaries as a plain writable (custom methods unavailable). Brand before freezing, or leave the store extensible.`);
+	}
+	return store;
+}
+/** The hub kind: subscribe-shaped values. The moment of crossing is the value snapshot. */
+function register_store_kind() {
+	register_kind({
+		k: "store",
+		match: is_store,
+		encode(value) {
+			return {
+				t: value[STORE_TAG] ?? GENERIC_TAG,
+				d: get(value)
+			};
+		},
+		decode(ref) {
+			const t = ref.t ?? GENERIC_TAG;
+			const factory = t === GENERIC_TAG ? void 0 : store_registry().factories.get(t);
+			if (t !== GENERIC_TAG && factory === void 0) {
+				if (typeof console !== "undefined") console.warn(`[ogygia] store "${t}": factory not loaded in this bundle — degraded to a plain writable (custom methods unavailable). Import the factory's module in the island (or its graph) so \`__register_store_factory\` runs there.`);
+				return writable(ref.d);
+			}
+			const built = factory ? factory(ref.d) : writable(ref.d);
+			if (built === null || typeof built !== "object") {
+				if (typeof console !== "undefined") console.warn(`[ogygia] store "${t}": factory returned ${type_of(built)} while rebuilding — degraded to a plain writable (custom methods unavailable). A store factory must return a store on every call; move environment guards inside the factory body.`);
+				return writable(ref.d);
+			}
+			return built;
+		}
+	});
+}
+const STORE_ONLY = /* @__PURE__ */ new Set(["store"]);
+/**
+* Devalue reducer: encode a store, or return undefined to fall through. Reads the store's
+* CURRENT value with `get()` — the moment of crossing is the snapshot. Same instance → same
+* wire id (hub-memoized), which is what lets the client reunite every copy into one live store.
+*/
+function reduce_store(value) {
+	register_store_kind();
+	const ref = mint(value, STORE_ONLY);
+	if (ref === void 0) return void 0;
+	return {
+		t: ref.t,
+		i: ref.i,
+		d: ref.d
+	};
+}
+/**
+* Devalue reviver: rebuild a live store via the hub. `remember: true` (browser) memoizes by
+* wire id — every island decoding this handle gets the SAME store, which is the liveness
+* mechanism. `remember: false` (server) always builds fresh: per-request isolation.
+*/
+function revive_store(payload, remember) {
+	register_store_kind();
+	const ref = {
+		k: "store",
+		i: payload.i,
+		t: payload.t,
+		d: payload.d
+	};
+	return resolve(ref, remember);
+}
+/**
+* The `import.meta.og.store` rewrite target: register the factory under its build tag (module
+* load IS the moment decode needs the registry filled — an island imports the factory module,
+* registration rides that import) and return a wrapper whose every product is BRANDED with the
+* tag, so encode ships the tag instead of the generic one and decode rebuilds THROUGH the
+* factory — custom methods survive the wire.
+*/
+/** Tags already warned about non-store products — once per tag, not once per call (a hot
+*  SSR path would otherwise warn on every request). */
+const warned_unbranded = /* @__PURE__ */ new Set();
+function __og_store(tag, factory) {
+	__register_store_factory(tag, (seed) => mark_store(factory(seed), tag));
+	return ((...args) => {
+		const product = factory(...args);
+		if (product === null || typeof product !== "object") {
+			if (!warned_unbranded.has(tag) && typeof console !== "undefined") {
+				warned_unbranded.add(tag);
+				console.warn(`[ogygia] store "${tag}": factory returned ${type_of(product)} — nothing to brand, value passed through as-is. Fine for a client-only store; a store that must cross an island boundary has to exist on the server too — return e.g. writable(seed) under your guard and gate the side effects inside the factory instead.`);
+			}
+			return product;
+		}
+		return mark_store(product, tag);
+	});
+}
+/**
+* A `derived` that CROSSES boundaries ALIVE — resumability for the reactive graph.
+*
+* Svelte's `derived` is a live computation: sources + a formula. The value can serialize; the
+* computation can't — so a plain derived crosses as a FROZEN seed (the classifier warns). This
+* primitive remembers its RECIPE, and the recipe is made of exactly the two things the seam
+* already carries: sources are STORES (they reunify to one live instance per island page) and
+* the formula is a FUNCTION (mark it with `import.meta.og.$` so it travels as a fn ref).
+*
+* ```ts
+* const doubled = og_derived(tally, import.meta.og.$((n) => n * 2));
+* ```
+*
+* Locally it IS `svelte/store`'s derived — same laziness, same semantics. At a boundary the
+* derived kind ships `{ sources, formula, seed }`; the island decodes by re-deriving against
+* the REUNIFIED sources with the REBOUND formula: bump the source in any island and every
+* island's derived follows. The seed rides along only for exactness of the first paint.
+*
+* An UNMARKED formula still works same-tree, but the derived then can't cross (the fn ref
+* can't be built) — the boundary explains this at the seam rather than freezing silently.
+*/
+function og_derived(sources, fn, initial) {
+	const single = !Array.isArray(sources);
+	const store = derived(sources, fn, initial);
+	Object.defineProperty(store, DERIVED_BRAND, {
+		value: {
+			s: single ? [sources] : sources,
+			f: fn,
+			single
+		},
+		enumerable: false
+	});
+	return store;
+}
+/** The hub kind: an `og_derived` recipe. Sources and formula are shipped as NESTED refs (devalue
+*  recursion runs the reducer over `d`'s contents), so by decode time they are already LIVE —
+*  sources reunified, formula rebound — and re-deriving is one call. */
+function register_derived_kind() {
+	register_kind({
+		k: "derived",
+		match(value) {
+			return value !== null && typeof value === "object" && value[DERIVED_BRAND] !== void 0;
+		},
+		encode(value) {
+			const r = value[DERIVED_BRAND];
+			return { d: {
+				s: r.s,
+				f: r.f,
+				single: r.single,
+				seed: get(value)
+			} };
+		},
+		decode(ref) {
+			const d = ref.d;
+			if (typeof d.f !== "function") throw new Error("[ogygia] cannot resume og_derived: its formula did not cross — mark it with import.meta.og.$ at the og_derived call site so it travels as a fn ref.");
+			return og_derived(d.single ? d.s[0] : d.s, d.f, d.seed);
+		}
+	});
+}
+export { STORE_WIRE_KEY, __og_store, __register_store_factory, is_derived_like, is_store, mark_store, og_derived, reduce_store, register_derived_kind, register_store_kind, revive_store };

package/dist/tool-fetches.d.ts

@@ -0,0 +1,5 @@
+/** `fetch`, noted as the tools' own: the page's file lists leave its Resource Timing entry out. */
+export declare function tool_fetch(url: string, init?: RequestInit): Promise<Response>;
+/** Whether this Resource Timing entry is one of the tools' own requests (a `fetch` of a noted
+ *  address that started when the tools asked), not the page's. */
+export declare function tool_made(e: PerformanceResourceTiming): boolean;

package/dist/tool-fetches.js

@@ -0,0 +1,41 @@
+// src/tool-fetches.ts
+/**
+* THE TOOLS' OWN REQUESTS — the devtools read the page's files too: a chunk's text to find the
+* runtime's parts, a stylesheet's rules, a HEAD to ask how a file is cached. The browser lists each
+* of those in its Resource Timing beside the page's own loads, and a reader of that list then counts
+* a file the page never loaded as loaded, takes a HEAD's empty body for a file's size, and sees the
+* page "fetch again" what it fetched once.
+*
+* So the tools ask through `tool_fetch`, which notes the address and the moment, and every reader of
+* the list (the byte ledger, an island's sizes, the beacon's files) leaves out what `tool_made` says
+* the tools caused. The notes live on a global: the runtime's beacon and the devtools are separate
+* bundles, and a page can carry two copies of either.
+*
+* Universal leaf: no imports.
+*/
+const KEY = Symbol.for("ogygia.tool-fetches");
+function notes() {
+	return globalThis[KEY];
+}
+/** `fetch`, noted as the tools' own: the page's file lists leave its Resource Timing entry out. */
+function tool_fetch(url, init) {
+	let href = url;
+	try {
+		href = new URL(url, location.href).href;
+		const all = globalThis[KEY] ??= /* @__PURE__ */ new Map();
+		const at = all.get(href);
+		if (at) at.push(performance.now());
+		else all.set(href, [performance.now()]);
+	} catch {}
+	return fetch(href, init);
+}
+/** Whether this Resource Timing entry is one of the tools' own requests (a `fetch` of a noted
+*  address that started when the tools asked), not the page's. */
+function tool_made(e) {
+	if (e.initiatorType !== "fetch") return false;
+	const at = notes()?.get(e.name);
+	if (!at) return false;
+	for (const t of at) if (e.startTime >= t - 1 && e.startTime - t < 1e3) return true;
+	return false;
+}
+export { tool_fetch, tool_made };

package/dist/transport.d.ts

@@ -0,0 +1,48 @@
+import { REF_WIRE_KEY, Ref } from "./ref.js";
+type EncodedRegion = {
+  i: string;
+  p: Record<string, unknown>;
+  u: string;
+  m: string;
+  h?: string;
+  g?: string;
+  x?: string;
+  /** HUB IDENTITY — minted per live region instance (one id however many payloads carry it).
+   *  The browser memoizes decode by it, so every consumer of one region value shares one
+   *  descriptor, and the future reconciler diffs by it. Absent on legacy payloads. */
+  hi?: string;
+};
+/**
+ * A region value AS THE BROWSER RECEIVES IT: through the crossing (encode, then decode) on the server,
+ * itself in the browser (it already crossed). A promise `of` resolves to a wire value — a remote's
+ * answer — so a server render that awaits one renders this form, the same shape the browser hydrates
+ * against (PromiseRegionAwait.svelte). Not a region: unchanged. A plain inline region nothing awaited
+ * throws, exactly as the crossing would.
+ */
+export declare function wire_form<T>(value: T): T;
+/** The hub kind: a held/dual/awaited region — the RENDERABLE Ref. `d` is the EncodedRegion.
+ *  Decode is deliberately un-memoized at the legacy seam (the wrapper below passes ids through
+ *  raw); hub-memoized region identity arrives with the one-key collapse, where it becomes the
+ *  foundation for persistent regions (the reconciler resolves by id). */
+export declare function register_region_kind(): void;
+/**
+ * The SvelteKit `transport` entry (install once in universal hooks). TWO entries, ONE codec
+ * underneath (hub v2 phase Y): `Region` preserves the legacy region wire shape/tag for
+ * compatibility; `OgygiaRef` carries EVERY OTHER hub kind through the same `ref_reducer` /
+ * `ref_reviver` the island seams use — so a universal `load` can put a store, wire class, fn or
+ * resumable derived in `page.data`, and a remote function can take/return one, all by identity.
+ * Kit routes remote args + load data through this same `transport`, so the symmetry is total.
+ * Decode is REQUEST-scoped on the server (no `document`) — client-sent identity never memoizes
+ * across requests — and PAGE-scoped in the browser (reunification).
+ */
+export declare const ogygiaTransport: {
+  Region: {
+    encode(value: unknown): false | EncodedRegion;
+    decode(raw: EncodedRegion): unknown;
+  };
+  [REF_WIRE_KEY]: {
+    encode(value: unknown): Ref | false;
+    decode(ref: Ref): unknown;
+  };
+};
+export {};