@ogygia/core 0.0.0 → 0.11.0

package/dist/shims/app-navigation.js

@@ -0,0 +1,119 @@
+import { kit_bridge } from "./kit-bridge.js";
+import { refresh_remote_instances } from "./kit-remote/remote-cache.js";
+import { bind_to_component } from "../runtime/nav-hooks.js";
+// src/shims/app-navigation.ts
+const kit = () => kit_bridge()?.navigation ?? null;
+const og = () => globalThis[Symbol.for("ogygia.nav")] ?? null;
+/** No runtime on this document at all (neither Kit's nor ogygia's): the browser navigates. */
+function browser_goto(url, opts = {}) {
+	const target = new URL(url, location.href);
+	if (target.protocol !== "http:" && target.protocol !== "https:") throw new Error("[ogygia] goto() only supports http(s) URLs");
+	if (target.origin !== location.origin && !opts.external) throw new Error("[ogygia] goto() only supports same-origin URLs (pass { external: true } to leave)");
+	if (opts.replaceState) location.replace(target.href);
+	else location.assign(target.href);
+	return Promise.resolve();
+}
+const NO_UNSUBSCRIBE = () => {};
+function goto(url, opts) {
+	const k = kit();
+	if (k) return k.goto(url, opts);
+	const o = og();
+	return o ? o.goto(url, opts) : browser_goto(url, opts);
+}
+function invalidate(resource) {
+	const k = kit();
+	if (k) return k.invalidate(resource);
+	const o = og();
+	if (o) return o.invalidate();
+	location.reload();
+	return Promise.resolve();
+}
+function invalidateAll() {
+	const k = kit();
+	if (k) return k.invalidateAll();
+	const o = og();
+	if (o) return o.invalidateAll();
+	location.reload();
+	return Promise.resolve();
+}
+/**
+* Kit's `refreshAll` (Kit 2.7x, Kit 3), which Kit 3's remote `form()` also calls after a successful
+* submit (through the remote client stub). Island queries live in ogygia's remote cache, not Kit's,
+* so they refresh here on every document; the page's data then refreshes through whoever owns the
+* document. With neither runtime, the queries alone refresh: never a reload.
+*/
+function refreshAll() {
+	const queries = refresh_remote_instances();
+	const k = kit();
+	const page = k ? (k.refreshAll ?? k.invalidateAll)() : og()?.invalidateAll();
+	return Promise.all([queries, page]).then(() => {});
+}
+function preloadData(url) {
+	const k = kit();
+	if (k) return k.preloadData(url);
+	const o = og();
+	return o ? o.preloadData(url) : Promise.resolve({
+		type: "loaded",
+		status: 200,
+		data: {}
+	});
+}
+function preloadCode(url) {
+	const k = kit();
+	if (k) return k.preloadCode(url);
+	const o = og();
+	return o ? o.preloadCode(url) : Promise.resolve();
+}
+function pushState(url, state) {
+	const k = kit();
+	if (k) k.pushState(url, state);
+	else og()?.pushState();
+}
+function replaceState(url, state) {
+	const k = kit();
+	if (k) k.replaceState(url, state);
+	else og()?.replaceState();
+}
+function disableScrollHandling() {
+	const k = kit();
+	if (k) k.disableScrollHandling();
+	else og()?.disableScrollHandling();
+}
+function beforeNavigate(fn) {
+	const k = kit();
+	if (k) {
+		k.beforeNavigate(fn);
+		return NO_UNSUBSCRIBE;
+	}
+	return bind_to_component(og()?.beforeNavigate(fn) ?? NO_UNSUBSCRIBE);
+}
+function afterNavigate(fn) {
+	const k = kit();
+	if (k) {
+		k.afterNavigate(fn);
+		return NO_UNSUBSCRIBE;
+	}
+	return bind_to_component(og()?.afterNavigate(fn) ?? NO_UNSUBSCRIBE);
+}
+function onNavigate(fn) {
+	const k = kit();
+	if (k) k.onNavigate(fn);
+	return NO_UNSUBSCRIBE;
+}
+const VITE_QUERY = /\?[^)\s]*(?=:\d+:\d+\)?$)/;
+function snapshot(options) {
+	const k = kit();
+	if (!k?.snapshot) return;
+	if (options.id !== void 0) return k.snapshot(options);
+	const frame = (/* @__PURE__ */ new Error()).stack?.split("\n")[2]?.replace(VITE_QUERY, "").trim();
+	k.snapshot({
+		...options,
+		id: frame || "island"
+	});
+}
+/** `ogygia/app`'s `bust_page_cache`: drop the SPA router's warmed page HTML (after mutations / auth
+*  changes). A no-op without the router — there is no page cache. */
+function bust_page_cache() {
+	og()?.bust_page_cache();
+}
+export { afterNavigate, beforeNavigate, bust_page_cache, disableScrollHandling, goto, invalidate, invalidateAll, onNavigate, preloadCode, preloadData, pushState, refreshAll, replaceState, snapshot };

package/dist/shims/app-paths.d.ts

@@ -0,0 +1,6 @@
+export declare const base = "";
+export declare const assets = "";
+/** Base-prefix a pathname, or populate a route id's dynamic segments. */
+export declare function resolve(id: string, params?: Record<string, string>): string;
+/** Resolve an asset URL in the static dir — `'x'` (Kit 3's form) or `'/x'` (Kit 2's). */
+export declare function asset(file: string): string;

package/dist/shims/app-paths.js

@@ -0,0 +1,18 @@
+// src/shims/app-paths.ts
+const base = "";
+const assets = "";
+const ROUTE_PARAM = /\[(\.\.\.)?([^\]]+)\]/g;
+function substitute(id, params = {}) {
+	return id.replace(ROUTE_PARAM, (_, _spread, name) => {
+		return params[name.split("=")[0]] ?? "";
+	});
+}
+/** Base-prefix a pathname, or populate a route id's dynamic segments. */
+function resolve(id, params = {}) {
+	return "" + substitute(id, params);
+}
+/** Resolve an asset URL in the static dir — `'x'` (Kit 3's form) or `'/x'` (Kit 2's). */
+function asset(file) {
+	return "" + (file.startsWith("/") ? file : "/" + file);
+}
+export { asset, assets, base, resolve };

package/dist/shims/app-state.svelte.d.ts

@@ -0,0 +1,23 @@
+import { PageSnapshot } from "./page-store.svelte.js";
+export declare const page: {
+  url: URL;
+  params: Record<string, string>;
+  route: {
+    id: string | null;
+  };
+  status: number;
+  data: Record<string, unknown>;
+  form: {} | null;
+  error: {
+    message: string;
+  } | null;
+  state: Record<string, unknown>;
+};
+export declare const navigating: {
+  current: {} | null;
+};
+export declare const updated: {
+  current: boolean;
+  check: () => Promise<boolean>;
+};
+export type { PageSnapshot };

package/dist/shims/app-state.svelte.js

@@ -0,0 +1,50 @@
+import { page_state, warn_foreign_page_read } from "./page-store.svelte.js";
+import { kit_bridge } from "./kit-bridge.js";
+// src/shims/app-state.svelte.ts
+const page = {
+	get url() {
+		return kit_bridge()?.page.url ?? page_state.url;
+	},
+	get params() {
+		warn_foreign_page_read("page.params");
+		return kit_bridge()?.page.params ?? page_state.params;
+	},
+	get route() {
+		warn_foreign_page_read("page.route");
+		return kit_bridge()?.page.route ?? page_state.route;
+	},
+	get status() {
+		return kit_bridge()?.page.status ?? page_state.status;
+	},
+	get data() {
+		warn_foreign_page_read("page.data");
+		return kit_bridge()?.page.data ?? page_state.data;
+	},
+	get form() {
+		warn_foreign_page_read("page.form");
+		const b = kit_bridge();
+		if (b) return b.page.form ?? null;
+		return page_state.form ?? null;
+	},
+	get error() {
+		warn_foreign_page_read("page.error");
+		const b = kit_bridge();
+		if (b) return b.page.error ?? null;
+		return page_state.error ?? null;
+	},
+	get state() {
+		const b = kit_bridge();
+		if (b) return b.page.state ?? {};
+		return page_state.state ?? {};
+	}
+};
+const navigating = { get current() {
+	return kit_bridge()?.navigating.current ?? null;
+} };
+const updated = {
+	get current() {
+		return false;
+	},
+	check: async () => false
+};
+export { navigating, page, updated };

package/dist/shims/app-stores.d.ts

@@ -0,0 +1,21 @@
+import { PageSnapshot } from "./page-store.svelte.js";
+import { Unsubscriber } from "svelte/store";
+declare function snapshot(): PageSnapshot;
+type Snapshot = ReturnType<typeof snapshot>;
+export declare const page: {
+  subscribe(run: (value: Snapshot) => void): () => void;
+};
+export declare const navigating: {
+  subscribe(run: (value: unknown) => void): Unsubscriber;
+};
+export declare const updated: {
+  subscribe(run: (value: boolean) => void): () => void;
+  check: () => Promise<boolean>;
+};
+/** Kit's `getStores()` (Kit 3 removed it; an island importing it still builds, and reads these). */
+export declare const getStores: () => {
+  page: typeof page;
+  navigating: typeof navigating;
+  updated: typeof updated;
+};
+export {};

package/dist/shims/app-stores.js

@@ -0,0 +1,54 @@
+import { page_state, subscribe_page, warn_foreign_page_read } from "./page-store.svelte.js";
+import { kit_bridge } from "./kit-bridge.js";
+import { toStore } from "svelte/store";
+// src/shims/app-stores.ts
+function snapshot() {
+	warn_foreign_page_read("$page");
+	const bridged = kit_bridge()?.page ?? page_state;
+	return {
+		url: bridged.url,
+		params: bridged.params,
+		route: bridged.route,
+		status: bridged.status,
+		data: bridged.data,
+		form: bridged.form,
+		error: bridged.error,
+		state: bridged.state
+	};
+}
+function same(a, b) {
+	for (const k in a) if (a[k] !== b[k]) return false;
+	return true;
+}
+const page = { subscribe(run) {
+	if (kit_bridge()) {
+		let last = null;
+		return toStore(snapshot).subscribe((value) => {
+			if (last && same(last, value)) return;
+			last = value;
+			run(value);
+		});
+	}
+	run(snapshot());
+	return subscribe_page(() => run(snapshot()));
+} };
+const navigating = { subscribe(run) {
+	const kit = kit_bridge();
+	if (kit) return toStore(() => kit.navigating.current ?? null).subscribe(run);
+	run(null);
+	return () => {};
+} };
+const updated = {
+	subscribe(run) {
+		run(false);
+		return () => {};
+	},
+	check: async () => false
+};
+/** Kit's `getStores()` (Kit 3 removed it; an island importing it still builds, and reads these). */
+const getStores = () => ({
+	page,
+	navigating,
+	updated
+});
+export { getStores, navigating, page, updated };

package/dist/shims/kit-bridge.d.ts

@@ -0,0 +1,29 @@
+import { PageSnapshot } from "./page-store.svelte.js";
+/** Kit's real `$app/navigation`, as published by the thread — the `$app/navigation` shim (and
+ *  `ogygia/app`) delegate every call here on a Kit-booted document. Typed loosely on purpose: the
+ *  shim forwards arguments as given; Kit's own types apply at the call site. */
+export interface KitNavigation {
+  goto(url: string | URL, opts?: unknown): Promise<void>;
+  invalidate(resource?: unknown): Promise<void>;
+  invalidateAll(): Promise<void>;
+  /** Kit 2.7x and Kit 3; absent on older Kit. */
+  refreshAll?(): Promise<void>;
+  preloadData(url: string | URL): Promise<unknown>;
+  preloadCode(url?: string): Promise<void>;
+  pushState(url: string | URL, state: unknown): void;
+  replaceState(url: string | URL, state: unknown): void;
+  disableScrollHandling(): void;
+  beforeNavigate(callback: (navigation: unknown) => void): void;
+  afterNavigate(callback: (navigation: unknown) => void): void;
+  onNavigate(callback: (navigation: unknown) => unknown): void;
+}
+export interface KitPageBridge {
+  page: PageSnapshot;
+  navigating: {
+    current: unknown;
+  };
+  /** Kit's real navigation module (see {@link KitNavigation}). Absent on an older thread. */
+  navigation?: KitNavigation;
+}
+/** The thread Kit published on this document, or null (a csr=false document, or before Kit boots). */
+export declare function kit_bridge(): KitPageBridge | null;

package/dist/shims/kit-bridge.js

@@ -0,0 +1,7 @@
+// src/shims/kit-bridge.ts
+const KIT_PAGE_KEY = Symbol.for("ogygia.kit-page");
+/** The thread Kit published on this document, or null (a csr=false document, or before Kit boots). */
+function kit_bridge() {
+	return globalThis[KIT_PAGE_KEY] ?? null;
+}
+export { kit_bridge };

package/dist/shims/kit-remote/client-stub.d.ts

@@ -0,0 +1,27 @@
+import { live_query_map, prerender_responses, query_map, query_responses } from "./remote-cache.js";
+import { goto, invalidateAll, refreshAll } from "../app-navigation.js";
+import { decoders, encoders, transport } from "virtual:ogygia/transport";
+export declare const app: {
+  hooks: {
+    transport: typeof transport;
+  };
+  decoders: typeof decoders;
+  encoders: typeof encoders;
+};
+export declare function set_nearest_error_page(): void;
+/** Kit 3: a remote call's error, as the page shows it — an `error()`'s own body, else a 500. There
+ *  are no client hooks to consult (the island world has no Kit client). */
+export declare function handle_error(error: unknown): Promise<{
+  status?: number;
+  message: string;
+}>;
+/**
+ * Seed `query_responses` from the `<script type="application/ogygia-remote">` the server emits on
+ * csr=false pages (see `ogygiaHandle`). Mirrors Kit's own `start()` boot-seed, but sourced from a
+ * side-channel because Kit only serializes remote data when csr===true. Parsed with the app's
+ * transport decoders so custom types round-trip. Called ONCE by the runtime before the first
+ * island hydrates, so every reused `Query` constructor finds its SSR value and never re-fetches.
+ * @param text devalue-stringified `{ q?, l?, f? }` payload
+ */
+export declare function seed_query_responses(text: string): void;
+export { goto as _goto, goto, invalidateAll, live_query_map, prerender_responses, query_map, query_responses, refreshAll };

package/dist/shims/kit-remote/client-stub.js

@@ -0,0 +1,43 @@
+import { live_query_map, prerender_responses, query_map, query_responses } from "./remote-cache.js";
+import { goto, invalidateAll, refreshAll } from "../app-navigation.js";
+import { parse } from "devalue";
+import { decoders, encoders, transport } from "virtual:ogygia/transport";
+// src/shims/kit-remote/client-stub.ts
+const app = {
+	hooks: { transport },
+	decoders,
+	encoders
+};
+function set_nearest_error_page() {}
+/** Kit 3: a remote call's error, as the page shows it — an `error()`'s own body, else a 500. There
+*  are no client hooks to consult (the island world has no Kit client). */
+async function handle_error(error) {
+	const body = error?.body;
+	return body && typeof body.message === "string" ? body : {
+		status: 500,
+		message: "Internal Error"
+	};
+}
+/**
+* Seed `query_responses` from the `<script type="application/ogygia-remote">` the server emits on
+* csr=false pages (see `ogygiaHandle`). Mirrors Kit's own `start()` boot-seed, but sourced from a
+* side-channel because Kit only serializes remote data when csr===true. Parsed with the app's
+* transport decoders so custom types round-trip. Called ONCE by the runtime before the first
+* island hydrates, so every reused `Query` constructor finds its SSR value and never re-fetches.
+* @param text devalue-stringified `{ q?, l?, f? }` payload
+*/
+function seed_query_responses(text) {
+	let data;
+	try {
+		data = parse(text, app.decoders);
+	} catch {
+		return;
+	}
+	if (!data) return;
+	const { q = {}, p = {}, l = {}, f = {} } = data;
+	for (const k in q) query_responses[k] = q[k];
+	for (const k in l) query_responses[k] = l[k];
+	for (const k in f) query_responses[k] = f[k];
+	for (const k in p) prerender_responses[k] = p[k];
+}
+export { goto as _goto, app, goto, handle_error, invalidateAll, live_query_map, prerender_responses, query_map, query_responses, refreshAll, seed_query_responses, set_nearest_error_page };

package/dist/shims/kit-remote/paths-internal-stub.d.ts

@@ -0,0 +1,3 @@
+export declare const base: string;
+export declare const assets: string;
+export declare const app_dir: string;

package/dist/shims/kit-remote/paths-internal-stub.js

@@ -0,0 +1,5 @@
+// src/shims/kit-remote/paths-internal-stub.ts
+const base = typeof __SVELTEKIT_PATHS_BASE__ !== "undefined" ? __SVELTEKIT_PATHS_BASE__ : "";
+const assets = typeof __SVELTEKIT_PATHS_ASSETS__ !== "undefined" && __SVELTEKIT_PATHS_ASSETS__ ? __SVELTEKIT_PATHS_ASSETS__ : base;
+const app_dir = typeof __SVELTEKIT_APP_DIR__ !== "undefined" ? __SVELTEKIT_APP_DIR__ : "_app";
+export { app_dir, assets, base };

package/dist/shims/kit-remote/remote-cache.d.ts

@@ -0,0 +1,49 @@
+/** SSR-resolved remote response maps shared by Kit remote-functions + ogygia SPA reset. */
+type RemoteNode = {
+  v?: unknown;
+  e?: [number, unknown];
+};
+type RemoteResource = {
+  destroy?: () => void;
+  refresh?: () => Promise<unknown>;
+  reconnect?: () => Promise<unknown>;
+};
+type RemoteEntry = {
+  resource?: RemoteResource;
+};
+/**
+ * Kit remote-function response + instance cache.
+ *
+ * SSR seeds (`query_responses`) are cleared in `prepare_spa_document` (before
+ * replaceWith). Instance maps are cleared in `finish_spa_document` (after
+ * replaceWith, before async island hydrate) so a new page never reuses a
+ * LiveQuery whose `#start` is already spent — Kit's `once()` wrapper would
+ * never open SSE again, leaving `query.live` on "connecting…".
+ */
+export declare class RemoteCache {
+  readonly query_responses: Record<string, RemoteNode>;
+  readonly prerender_responses: Record<string, RemoteNode>;
+  readonly query_map: Map<string, Map<string, RemoteEntry>>;
+  readonly live_query_map: Map<string, Map<string, RemoteEntry>>;
+  /** Drop SSR seed bags only (safe while old islands are still connected). */
+  clear_seeds(): void;
+  /**
+   * Destroy leftover query/live instances and clear the maps.
+   * Call only after the previous body has disconnected.
+   */
+  clear_instances(): void;
+  /**
+   * Re-fetch every live query instance in place (Kit's `refreshAll` does the same to its own maps):
+   * queries refresh, live queries reconnect. Settles when all of them have.
+   */
+  refresh_instances(): Promise<void>;
+}
+export declare const remote_cache: RemoteCache;
+export declare const query_responses: RemoteCache["query_responses"];
+export declare const prerender_responses: RemoteCache["prerender_responses"];
+export declare const query_map: RemoteCache["query_map"];
+export declare const live_query_map: RemoteCache["live_query_map"];
+export declare function clear_remote_seeds(): void;
+export declare function clear_remote_instances(): void;
+export declare function refresh_remote_instances(): Promise<void>;
+export {};

package/dist/shims/kit-remote/remote-cache.js

@@ -0,0 +1,73 @@
+// src/shims/kit-remote/remote-cache.ts
+/**
+* Kit remote-function response + instance cache.
+*
+* SSR seeds (`query_responses`) are cleared in `prepare_spa_document` (before
+* replaceWith). Instance maps are cleared in `finish_spa_document` (after
+* replaceWith, before async island hydrate) so a new page never reuses a
+* LiveQuery whose `#start` is already spent — Kit's `once()` wrapper would
+* never open SSE again, leaving `query.live` on "connecting…".
+*/
+var RemoteCache = class {
+	query_responses = {};
+	prerender_responses = {};
+	query_map = /* @__PURE__ */ new Map();
+	live_query_map = /* @__PURE__ */ new Map();
+	/** Drop SSR seed bags only (safe while old islands are still connected). */
+	clear_seeds() {
+		for (const k of Object.keys(this.query_responses)) delete this.query_responses[k];
+		for (const k of Object.keys(this.prerender_responses)) delete this.prerender_responses[k];
+	}
+	/**
+	* Destroy leftover query/live instances and clear the maps.
+	* Call only after the previous body has disconnected.
+	*/
+	clear_instances() {
+		destroy_map(this.query_map);
+		destroy_map(this.live_query_map);
+		this.query_map.clear();
+		this.live_query_map.clear();
+	}
+	/**
+	* Re-fetch every live query instance in place (Kit's `refreshAll` does the same to its own maps):
+	* queries refresh, live queries reconnect. Settles when all of them have.
+	*/
+	refresh_instances() {
+		const pending = [];
+		for (const entries of this.query_map.values()) for (const { resource } of entries.values()) if (resource?.refresh) pending.push(resource.refresh());
+		for (const entries of this.live_query_map.values()) for (const { resource } of entries.values()) if (resource?.reconnect) pending.push(resource.reconnect());
+		return Promise.allSettled(pending).then(() => {});
+	}
+};
+function destroy_map(map) {
+	for (const entries of map.values()) for (const entry of entries.values()) try {
+		entry.resource?.destroy?.();
+	} catch {}
+}
+const GLOBAL_KEY = "__ogygia_remote_cache__";
+/**
+* Process-wide singleton on `globalThis`.
+* Vite can load this file under multiple resolved ids (`/@fs/…` vs absolute, runtime
+* chunk vs island graph); module-level `new RemoteCache()` would then create separate
+* maps, so SPA `clear_*` would miss the maps Kit's LiveQuery actually uses.
+*/
+function get_remote_cache() {
+	const g = globalThis;
+	if (!g[GLOBAL_KEY]) g[GLOBAL_KEY] = new RemoteCache();
+	return g[GLOBAL_KEY];
+}
+const remote_cache = get_remote_cache();
+const query_responses = remote_cache.query_responses;
+const prerender_responses = remote_cache.prerender_responses;
+const query_map = remote_cache.query_map;
+const live_query_map = remote_cache.live_query_map;
+function clear_remote_seeds() {
+	remote_cache.clear_seeds();
+}
+function clear_remote_instances() {
+	remote_cache.clear_instances();
+}
+function refresh_remote_instances() {
+	return remote_cache.refresh_instances();
+}
+export { RemoteCache, clear_remote_instances, clear_remote_seeds, live_query_map, prerender_responses, query_map, query_responses, refresh_remote_instances, remote_cache };

package/dist/shims/kit-remote/state-stub.d.ts

@@ -0,0 +1,8 @@
+export declare const page: {
+  url: URL;
+};
+export declare const navigating: {
+  current: null;
+};
+/** Kit 3: a remote response's app version, for Kit's update check — no Kit client here to update. */
+export declare function notify_version(_version: string): void;

package/dist/shims/kit-remote/state-stub.js

@@ -0,0 +1,8 @@
+// src/shims/kit-remote/state-stub.ts
+const page = { get url() {
+	return typeof location !== "undefined" ? new URL(location.href) : new URL("http://localhost/");
+} };
+const navigating = { current: null };
+/** Kit 3: a remote response's app version, for Kit's update check — no Kit client here to update. */
+function notify_version(_version) {}
+export { navigating, notify_version, page };

package/dist/shims/page-store.svelte.d.ts

@@ -0,0 +1,39 @@
+export interface PageSnapshot {
+  url: URL;
+  params: Record<string, string>;
+  route: {
+    id: string | null;
+  };
+  status: number;
+  data: Record<string, unknown>;
+  form: unknown;
+  error: {
+    message: string;
+  } | null;
+  state: Record<string, unknown>;
+}
+export declare class PageState {
+  #private;
+  url: URL;
+  params: Record<string, string>;
+  route: {
+    id: string | null;
+  };
+  status: number;
+  data: Record<string, unknown>;
+  form: unknown;
+  error: {
+    message: string;
+  } | null;
+  state: Record<string, unknown>;
+  set(snap: Partial<PageSnapshot> | undefined | null): void;
+  reset(): void;
+  subscribe(fn: () => void): () => void;
+}
+export declare const page_state: PageState;
+/** Seed from an island's SSR snapshot (pre-hydration / SPA remount). */
+export declare function set_page(snap: Partial<PageSnapshot> | undefined | null): void;
+/** Reset to location-based fallback between SPA body swaps (clears stale route data). */
+export declare function reset_page(): void;
+export declare function subscribe_page(fn: () => void): () => void;
+export declare function warn_foreign_page_read(expr: string): void;