@ogygia/core 0.0.0 → 0.11.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Puru Vijayvargia
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,9 @@
 # @ogygia/core
 
-Reserved for [ogygia](https://ogygia.puruvj.dev). The first release is on its way.
+The core of [ogygia](https://ogygiajs.dev): SSR islands for SvelteKit, no Kit patches.
+
+Apps install [`ogygia`](https://www.npmjs.com/package/ogygia), which re-exports this package subpath for
+subpath. Plugin packages (`@ogygia/flags`, `@ogygia/devtools`, …) build on `@ogygia/core` and its
+`@ogygia/core/plugin` door.
+
+Docs: [ogygiajs.dev](https://ogygiajs.dev)

package/ambient.d.ts

@@ -0,0 +1,194 @@
+// Ambient types for ogygia's build-time virtual modules. The library ships `.svelte`/`.ts` source
+// (Region, OgygiaRouter, …) that import these; the ogygia vite plugin provides them at build time,
+// but a consumer's `svelte-check`/`tsc` needs the declarations to type-check the imports. Keep in sync
+// with packages/core/src/types.d.ts (the library's own build copy). Apps reach this file through
+// `ogygia/types` (the `ogygia` package's ambient.d.ts references it).
+declare module 'virtual:ogygia/runtime-url' {
+	const url: string;
+	export default url;
+}
+declare module 'virtual:ogygia/runtime-entry' {
+	export const __features: string[];
+}
+declare module 'virtual:ogygia/dev-hmr' {
+	/* side-effect only — CSS HMR bridge under csr=false */
+}
+declare module 'virtual:ogygia/dev-hmr-url' {
+	const url: string;
+	export default url;
+}
+declare module 'virtual:ogygia/island-deps' {
+	export function islandDeps(entry: string): string[];
+	/** Public URLs of the CSS assets an island entry (+ its dep chunks) owns — carried with a
+	 *  region response so a server-picked component styles a page that never imported it. */
+	export function islandCss(entry: string): string[];
+	/** og.$ hoisted factories (tag → self-contained source) for the page-inline registration
+	 *  script — prod SSR only; null in dev/client (dev uses the fn-manifest virtual). */
+	export function fnManifest(): Record<string, string> | null;
+	/** An entry's identity (its stable URL) → the content-hashed file it is served from; `null`: none known. */
+	export function entryLocation(identity: string): string | null;
+}
+declare module 'virtual:ogygia/manifest' {
+	export const dev: boolean;
+	export const regions: Record<
+		string,
+		{ kind: 'hydrate' | 'defer' | 'lake'; load?: () => Promise<{ default: unknown }> }
+	>;
+}
+declare module 'virtual:ogygia/server-manifest' {
+	/** The server islands' loaders, one dynamic import away. */
+	export function load_islands(): Promise<typeof import('virtual:ogygia/server-islands')>;
+	/** Server-island id → its built client-chunk URL (the key `islandCss()` is keyed by). */
+	export const island_url: Record<string, string>;
+	/** Server-island id → its component name (`SlowHole`), where the component file is known. */
+	export const island_name: Record<string, string>;
+	export const island_render: Record<string, string>;
+	export const render_island: Record<string, string>;
+}
+declare module 'virtual:ogygia/server-islands' {
+	export const islands: Record<string, () => Promise<{ default: unknown }>>;
+}
+declare module 'virtual:ogygia/region-endpoint' {
+	export function makeRegionEndpoint(entry: string, props?: Record<string, unknown>): string;
+	export function mintServerIsland(
+		entry: string,
+		props: Record<string, unknown>,
+		ttl?: number
+	): string;
+}
+declare module 'virtual:ogygia/secret' {
+	export const buildKey: string;
+	export const buildHadSecret: boolean;
+}
+declare module 'virtual:ogygia/sign' {
+	export function sign(secret: string, message: string): string;
+	export function verify(secret: string, message: string, sig: string): boolean;
+	export function region_mac_message(
+		id: string,
+		exp: number | string,
+		props: string,
+		session?: string,
+		ttl?: number | string,
+		render?: string
+	): string;
+}
+declare module 'virtual:ogygia/request-event' {
+	export function getRequestEvent(): {
+		cookies: { get: (name: string) => string | undefined };
+		[key: string]: unknown;
+	};
+}
+declare module 'virtual:ogygia/rate-limit' {
+	export const rateLimit: { max: number; windowMs: number };
+}
+declare module 'virtual:ogygia/router-config' {
+	export const enabled: boolean;
+	export const viewTransitions: boolean;
+}
+declare module 'virtual:ogygia/session-cookie' {
+	export const sessionCookie: string;
+}
+declare module 'virtual:ogygia/region-ttl' {
+	export const regionTtl: number;
+	export const renewWindow: number;
+}
+declare module 'virtual:ogygia/transport' {
+	export const transport: Record<
+		string,
+		{ encode: (v: unknown) => unknown; decode: (v: unknown) => unknown }
+	>;
+}
+declare module 'virtual:ogygia/kit-wire' {
+	export function stringify_remote_arg(value: unknown, transport: unknown): string;
+	export function stringify_command_arg(value: unknown, transport: unknown): Promise<string>;
+	export function create_remote_key(id: string, payload: string): string;
+}
+
+// ── the `import.meta.og` compile surface ─────────────────────────────────────────────
+// ogygia's build-time constructs, under ONE short key — platform-feeling like `import.meta.glob`,
+// collision-proof by ownership, one autocomplete entry for the whole family. They are not runtime
+// calls: the ogygia vite plugin rewrites each at transform time; these declarations are only types.
+// The rule for what belongs here: literal inputs + a build-determined result.
+interface ImportMeta {
+	readonly og: ImportMetaOg;
+}
+
+/**
+ * The `import.meta.og.*` constructs: core's below, plus each plugin's — a plugin package's own
+ * types (`/// <reference types="@ogygia/content/types" />`) merge its macros into this interface.
+ */
+interface ImportMetaOg {
+	/**
+	 * The transportable mark — `static wire = import.meta.og.wire({ encode, decode })` on a
+	 * class lets its instances cross island boundaries as props. A compile construct: the
+	 * plugin CONSUMES the member and mints the symbol key (`static [Symbol.for('ogygia.wire')]
+	 * = codec`), so the key never exists in source. STRICT: that member shape is the only
+	 * legal position — any other use is a build error. ONE contract, always explicit:
+	 * `{ encode, decode }` (+ optional `id`/`merge` for session continuity — see
+	 * `TransportCodec` in `ogygia`).
+	 */
+	wire<T = unknown, D = unknown>(
+		codec: import('@ogygia/core').TransportCodec<T, D>
+	): import('@ogygia/core').TransportCodec<T, D>;
+	/**
+	 * Run `fn` at BUILD, serialize its result, and inline it as a constant — "run at build, ship
+	 * the answer." `fn` may use this module's IMPORTS and literals and `await` freely, but must be
+	 * self-contained (no closing over the module's other locals). Its result must be
+	 * devalue-serializable (JSON + Date/Map/Set/RegExp/BigInt) — a function, Promise, or class
+	 * instance in the result is a build error. At runtime there is no function and no work, even in
+	 * client code.
+	 */
+	bake<T>(fn: () => T | Promise<T>): T;
+	/**
+	 * Brand a value as TRANSPORTABLE so it crosses an island boundary LIVE — most often a closure
+	 * (the wire's fn kind: the plugin hoists it to a self-contained factory, its captured locals
+	 * becoming bound params), but also a store or an `og.wire` class instance the drop-in
+	 * `setContext`/`og_derived` should carry live rather than freeze. Returns the SAME value (and
+	 * type) — at the call site it reads as identity; the transform does the branding/hoisting. A
+	 * branded closure must be self-contained (only its own captured locals + module imports, no
+	 * `$app/*`).
+	 */
+	$<T>(value: T): T;
+	/**
+	 * Mark an imported component as a region — the macro alternative to `import X from '…' with
+	 * { … }`, and the escape hatch for BARRELS. The import-attribute form only reaches a DEFAULT
+	 * import of one file; `asRegion` marks ANY imported component, including a NAMED export from a
+	 * barrel (`import { Header } from '@design/system'`). It is a transparent escape hatch: the
+	 * `options` accept EXACTLY what an import attribute accepts — no more, no less — and the output
+	 * is identical, only importing the component by its export name. Every mode works: a placed
+	 * island (`wake`), a deferred/live server hole (`render`), a lake (`wake: 'none'`), a held
+	 * region (`region: 'raw'`), or a named `preset`.
+	 *
+	 * `component` must be a bare identifier bound to a top-level import, and the call must be a
+	 * TOP-LEVEL `const Name = import.meta.og.asRegion(Comp, …)` in the instance `<script>`. Returns
+	 * a component with the SAME props. Compile construct — rewritten to a hoisted binding import;
+	 * there is no runtime `asRegion`.
+	 */
+	asRegion<C>(
+		component: C,
+		options: {
+			/** hydrate schedule (placed island / lake at `'none'`); the fetch schedule for `render`. */
+			wake?: 'load' | 'idle' | 'visible' | 'interaction' | 'none' | (string & {});
+			/** delivery mode: a static island (default), or a `'deferred'` / `'live'` server hole. */
+			render?: 'static' | 'deferred' | 'live';
+			/** a held region handed to `region()` — must be the ONLY option (`'raw'`). */
+			region?: 'raw';
+			/** a named preset from `ogygia({ presets })` — must be the ONLY option. */
+			preset?: string;
+			/** keep the live island (DOM + state) across SPA navigations. */
+			keep?: string;
+		}
+	): C;
+	/**
+	 * Declare a data source: `export const loadContent = import.meta.og.source(async (…) => …)`.
+	 * Each call during a server render files a receipt (the source's `file#export` id plus a
+	 * fingerprint of its arguments), so an invalidation names the function and its arguments
+	 * instead of URL strings. Returns the SAME function. `opts.key` canonicalizes exotic
+	 * arguments yourself (the default fingerprint is structural). Legal only as a top-level
+	 * `export const`; anything else is a build error.
+	 */
+	source<A extends unknown[], R>(
+		fn: (...args: A) => R,
+		opts?: { key?: (...args: A) => string }
+	): (...args: A) => R;
+}

package/dist/ClientBindingStub.svelte

@@ -0,0 +1,6 @@
+<script>
+	// csr=false CLIENT host stand-in for a portable island binding.
+	// SSR / csr=true keep the real wrapper; hydrate loads via import(entry) only.
+	// Beside this stub the transform emits `import 'virtual:ogygia/fouc-css/…'` so Kit still
+	// collects island CSS into the page stylesheet graph — without dual-owning component JS.
+</script>

package/dist/ClientBindingStub.svelte.d.ts

@@ -0,0 +1,26 @@
+export default ClientBindingStub;
+type ClientBindingStub = SvelteComponent<{
+    [x: string]: never;
+}, {
+    [evt: string]: CustomEvent<any>;
+}, {}> & {
+    $$bindings?: string | undefined;
+};
+declare const ClientBindingStub: $$__sveltets_2_IsomorphicComponent<{
+    [x: string]: never;
+}, {
+    [evt: string]: CustomEvent<any>;
+}, {}, {}, string>;
+interface $$__sveltets_2_IsomorphicComponent<Props extends Record<string, any> = any, Events extends Record<string, any> = any, Slots extends Record<string, any> = any, Exports = {}, Bindings = string> {
+    new (options: import("svelte").ComponentConstructorOptions<Props>): import("svelte").SvelteComponent<Props, Events, Slots> & {
+        $$bindings?: Bindings;
+    } & Exports;
+    (internal: unknown, props: {
+        $$events?: Events;
+        $$slots?: Slots;
+    }): Exports & {
+        $set?: any;
+        $on?: any;
+    };
+    z_$$bindings?: Bindings;
+}

package/dist/KeepHost.svelte

@@ -0,0 +1,19 @@
+<script>// Keep-alive host for a KEPT island (`keep:`): LiveHost's props-pushable host — the "inside an
+// island" context, `$state` props, `setProps` so the next page's props reach the relocated island —
+// in the SSR shape of a placed island (Region.svelte's `{#if Component}<Component {...props} />{/if}`,
+// as NestedProvider mirrors it). LiveHost has no `{#if}`: it hydrates a live region's render()
+// output, and a kept island hydrated through it met the server's `[0` branch marker where it
+// expected the component's own, discarding the server DOM on every load. NOT part of the public API.
+import { setNested } from "./context.js";
+let { component: Component, initialProps } = $props();
+// Seed once from the incoming prop; later pages replace it via setProps(). Intentional initial read.
+// svelte-ignore state_referenced_locally
+let current = $state(initialProps);
+/** Called by the runtime when the island crosses to the next page — reactive prop push. */
+export function setProps(next) {
+	current = next;
+}
+setNested();
+</script>
+
+{#if Component}<Component {...current} />{/if}

package/dist/KeepHost.svelte.d.ts

@@ -0,0 +1,10 @@
+import { SvelteComponent } from "svelte";
+type $$ComponentProps = {
+    component: SvelteComponent<Record<string, unknown>>;
+    initialProps: Record<string, unknown>;
+};
+declare const KeepHost: import("svelte").Component<$$ComponentProps, {
+    setProps: (next: Record<string, unknown>) => void;
+}, "">;
+type KeepHost = ReturnType<typeof KeepHost>;
+export default KeepHost;

package/dist/LakeBoundary.svelte

@@ -0,0 +1,16 @@
+<script>
+	// Wraps a frozen region's content to RESET the "inside an awake region" context to false. A
+	// `hydrate="none"` boundary makes its subtree dead again (DESIGN.md), so a waking region authored
+	// inside it sees `isNested() === false` during SSR and emits its own `<ogygia-region hydrate>` —
+	// it then self-runs when the runtime restores the frozen DOM (its region reconnects). Renders
+	// nothing of its own, so the lift/restore DOM is unchanged.
+	// It also MARKS the subtree as a lake's inside: on a Kit-hydrated (csr=true) document the lake is
+	// adopted as opaque DOM, so a waking region inside it must still emit its real `<ogygia-region>`
+	// (Region reads `isInLake()` to skip its csr=true inline degradation there).
+	import { setNested, setInLake } from './context.js';
+	let { children } = $props();
+	setNested(false);
+	setInLake();
+</script>
+
+{@render children?.()}

package/dist/LakeBoundary.svelte.d.ts

@@ -0,0 +1,11 @@
+export default LakeBoundary;
+type LakeBoundary = {
+    $on?(type: string, callback: (e: any) => void): () => void;
+    $set?(props: Partial<$$ComponentProps>): void;
+};
+declare const LakeBoundary: import("svelte").Component<{
+    children: any;
+}, {}, "">;
+type $$ComponentProps = {
+    children: any;
+};

package/dist/LateIsland.svelte

@@ -0,0 +1,22 @@
+<script>
+	/**
+	 * AN INLINE ISLAND A CLIENT NAVIGATION CREATED — Kit made its wrapper in the browser, with no
+	 * rendered stamp, so its component was not loaded yet. Load it, and render it when it lands: the
+	 * navigation shows an empty place first, then the island. A client render, nothing to mismatch.
+	 *
+	 * Where the app runs Svelte's async mode, the build imports LateIslandAwait.svelte in this one's
+	 * place, which holds the navigation until the code is in (vite/late-island.ts).
+	 */
+	/** @type {{ load: () => Promise<import('svelte').Component>, props: Record<string, unknown>, children?: import('svelte').Snippet }} */
+	let { load, props, children } = $props();
+	/** @type {import('svelte').Component | undefined} */
+	let Component = $state(undefined);
+	// (a failed load renders nothing)
+	// svelte-ignore state_referenced_locally
+	load().then(
+		(c) => (Component = c),
+		() => {}
+	);
+</script>
+
+{#if Component}<Component {...props}>{@render children?.()}</Component>{/if}

package/dist/LateIsland.svelte.d.ts

@@ -0,0 +1,15 @@
+export default LateIsland;
+type LateIsland = {
+    $on?(type: string, callback: (e: any) => void): () => void;
+    $set?(props: Partial<$$ComponentProps>): void;
+};
+declare const LateIsland: import("svelte").Component<{
+    load: () => Promise<import("svelte").Component>;
+    props: Record<string, unknown>;
+    children?: import("svelte").Snippet;
+}, {}, "">;
+type $$ComponentProps = {
+    load: () => Promise<import("svelte").Component>;
+    props: Record<string, unknown>;
+    children?: import("svelte").Snippet;
+};

package/dist/LateIslandAwait.svelte

@@ -0,0 +1,17 @@
+<script>
+	/**
+	 * LateIsland.svelte, for an app that runs Svelte's async mode: the build imports this one in its
+	 * place (vite/late-island.ts). The load is awaited, so the navigation's update batch waits for it
+	 * and Kit keeps the old page until the island's code is in — then swaps the whole new page at once
+	 * (an island nested in it awaits in the same batch). Without async mode this file does not compile,
+	 * which is why it is never the default.
+	 */
+	/** @type {{ load: () => Promise<import('svelte').Component>, props: Record<string, unknown>, children?: import('svelte').Snippet }} */
+	let { load, props, children } = $props();
+	// (a failed load renders nothing)
+	// one load per island, read once on purpose (as in LateIsland.svelte)
+	// svelte-ignore state_referenced_locally
+	const Component = await load().catch(() => undefined);
+</script>
+
+{#if Component}<Component {...props}>{@render children?.()}</Component>{/if}

package/dist/LateIslandAwait.svelte.d.ts

@@ -0,0 +1,15 @@
+export default LateIslandAwait;
+type LateIslandAwait = {
+    $on?(type: string, callback: (e: any) => void): () => void;
+    $set?(props: Partial<$$ComponentProps>): void;
+};
+declare const LateIslandAwait: import("svelte").Component<{
+    load: () => Promise<import("svelte").Component>;
+    props: Record<string, unknown>;
+    children?: import("svelte").Snippet;
+}, {}, "">;
+type $$ComponentProps = {
+    load: () => Promise<import("svelte").Component>;
+    props: Record<string, unknown>;
+    children?: import("svelte").Snippet;
+};

package/dist/LiveHost.svelte

@@ -0,0 +1,19 @@
+<script>// Keep-alive host for an INTERACTIVE live region (`query.live` yielding `region(C, props)`
+// with a wake schedule). Like NestedProvider, it sets the "inside an island" context and renders
+// the component with no DOM of its own (so it hydrates the server render() output cleanly). Unlike
+// NestedProvider, its props are `$state` and it exposes `setProps` — so a live tick updates the
+// MOUNTED component reactively instead of tearing it down and re-hydrating. Focus and local island
+// state survive; Svelte reconciles the view. NOT part of the public API.
+import { setNested } from "./context.js";
+let { component: Component, initialProps } = $props();
+// Seed once from the incoming prop; later ticks replace it via setProps(). Intentional initial read.
+// svelte-ignore state_referenced_locally
+let current = $state(initialProps);
+/** Called by the runtime on each live tick with the same component — reactive prop push. */
+export function setProps(next) {
+	current = next;
+}
+setNested();
+</script>
+
+<Component {...current} />

package/dist/LiveHost.svelte.d.ts

@@ -0,0 +1,10 @@
+import { SvelteComponent } from "svelte";
+type $$ComponentProps = {
+    component: SvelteComponent<Record<string, unknown>>;
+    initialProps: Record<string, unknown>;
+};
+declare const LiveHost: import("svelte").Component<$$ComponentProps, {
+    setProps: (next: Record<string, unknown>) => void;
+}, "">;
+type LiveHost = ReturnType<typeof LiveHost>;
+export default LiveHost;

package/dist/NestedProvider.svelte

@@ -0,0 +1,13 @@
+<script>// Passthrough the runtime hydrates a top-level island into, so descendants see the
+// "inside an island" context. Mirrors Region.svelte's island SSR shape EXACTLY
+// (`{#if Component}<Component {...props} />{/if}`) so Svelte adopts the SSR nodes in place instead
+// of discarding and re-creating the island root (a re-created root is class-less for a tick → a
+// `class:`-driven `position: fixed` drops to `static` for a frame). SELF-CLOSING on purpose: any
+// slot content here would pass an implicit `children` snippet that OVERRIDES the decoded
+// `props.children` (the revived slot/region snippet) and desyncs hydration with an extra anchor.
+import { setNested } from "./context.js";
+let { component: Component, props } = $props();
+setNested();
+</script>
+
+{#if Component}<Component {...props} />{/if}

package/dist/NestedProvider.svelte.d.ts

@@ -0,0 +1,8 @@
+import { SvelteComponent } from "svelte";
+type $$ComponentProps = {
+    component: SvelteComponent<Record<string, unknown>>;
+    props: Record<string, unknown>;
+};
+declare const NestedProvider: import("svelte").Component<$$ComponentProps, {}, "">;
+type NestedProvider = ReturnType<typeof NestedProvider>;
+export default NestedProvider;

package/dist/OgygiaBoundary.svelte

@@ -0,0 +1,5 @@
+<script>let { children } = $props();
+export {};
+</script>
+
+{@render children?.()}

package/dist/OgygiaBoundary.svelte.d.ts

@@ -0,0 +1,17 @@
+/**
+     * Optional public annotation wrapper around a region usage.
+     *
+     * Renders {@linkcode children} only — no extra DOM, no nested-island context, and no
+     * `hydrate` / `render` attributes. Use it when you want to mark an island in source for
+     * humans (or a future hook). It is **not** `<svelte:boundary>` and **not** the internal
+     * lake context reset (`LakeBoundary`).
+     *
+     * @component
+     */
+import type { Snippet } from 'svelte';
+type $$ComponentProps = {
+    children?: Snippet;
+};
+declare const OgygiaBoundary: import("svelte").Component<$$ComponentProps, {}, "">;
+type OgygiaBoundary = ReturnType<typeof OgygiaBoundary>;
+export default OgygiaBoundary;

package/dist/PromiseRegion.svelte

@@ -0,0 +1,40 @@
+<script>
+	/**
+	 * A `<Region of={promise}>` (Region.svelte hands the promise here): the region owns the whole wait.
+	 * This one works anywhere — the server cannot wait without Svelte's async mode, so it renders the
+	 * placeholder and the browser resolves the promise after hydration (where the app runs async mode,
+	 * PromiseRegionAwait.svelte awaits it in the render instead: vite/late-island.ts).
+	 *
+	 * LATE SLOT: inside a document that delivers late chunks (the server router's streamed document
+	 * opens that scope), the placeholder is wrapped in an `og-late-slot` the response fills when the
+	 * promise settles. Nowhere else: a slot nothing fills stays empty forever.
+	 *
+	 * LAG, don't clear: a NEW promise (a re-search) keeps the previous value on screen until it lands,
+	 * so the old content morphs instead of flashing through empty.
+	 */
+	import Region from './Region.svelte';
+	import { register_late_region } from './late-region-registry.js';
+
+	/** @type {{ of: Promise<import('./region.js').RegionValue>, placeholder?: import('svelte').Snippet, children?: import('svelte').Snippet }} */
+	let { of, placeholder, children } = $props();
+
+	// svelte-ignore state_referenced_locally
+	const late_slot = typeof window === 'undefined' ? register_late_region(of) : null;
+	/** @type {import('./region.js').RegionValue | undefined} */
+	let awaited = $state(undefined);
+	$effect(() => {
+		const p = of;
+		let live = true;
+		Promise.resolve(p).then((r) => {
+			if (live) awaited = r;
+		});
+		return () => {
+			live = false;
+		};
+	});
+</script>
+
+{#if awaited}<Region of={awaited} {placeholder} {children} />{:else if late_slot}<og-late-slot
+		data-og-slot={late_slot}
+		style="display:contents">{@render placeholder?.()}</og-late-slot
+	>{:else}{@render placeholder?.()}{/if}

package/dist/PromiseRegion.svelte.d.ts

@@ -0,0 +1,15 @@
+export default PromiseRegion;
+type PromiseRegion = {
+    $on?(type: string, callback: (e: any) => void): () => void;
+    $set?(props: Partial<$$ComponentProps>): void;
+};
+declare const PromiseRegion: import("svelte").Component<{
+    of: Promise<import("./region.js").RegionValue>;
+    placeholder?: import("svelte").Snippet;
+    children?: import("svelte").Snippet;
+}, {}, "">;
+type $$ComponentProps = {
+    of: Promise<import("./region.js").RegionValue>;
+    placeholder?: import("svelte").Snippet;
+    children?: import("svelte").Snippet;
+};

package/dist/PromiseRegionAwait.svelte

@@ -0,0 +1,27 @@
+<script>
+	/**
+	 * PromiseRegion.svelte, for an app that runs Svelte's async mode: the build imports this one in its
+	 * place (vite/late-island.ts). The promise is AWAITED IN THE RENDER: the server render waits for it
+	 * (Kit seeds a remote query's result into the page), hydration awaits the same value, and the page
+	 * arrives with the region in it — no placeholder flash, no client fetch. The value renders in its
+	 * WIRE form on both sides (`wire_form`: what crossed, as the browser has it), baked: its first HTML
+	 * is in the page, and every later value (a refresh) morphs in.
+	 *
+	 * Inside a document that delivers late chunks (the server router's streamed document), the late
+	 * slot still wins: the document streams instead of waiting. Without async mode this file does not
+	 * compile, which is why it is never the default.
+	 */
+	import Region from './Region.svelte';
+	import { register_late_region } from './late-region-registry.js';
+	import { wire_form } from './transport.js';
+
+	/** @type {{ of: Promise<import('./region.js').RegionValue>, placeholder?: import('svelte').Snippet, children?: import('svelte').Snippet }} */
+	let { of, placeholder, children } = $props();
+
+	// svelte-ignore state_referenced_locally
+	const late_slot = typeof window === 'undefined' ? register_late_region(of) : null;
+</script>
+
+{#if late_slot}<og-late-slot data-og-slot={late_slot} style="display:contents"
+		>{@render placeholder?.()}</og-late-slot
+	>{:else}<Region of={wire_form(await of)} {placeholder} {children} __baked />{/if}

package/dist/PromiseRegionAwait.svelte.d.ts

@@ -0,0 +1,15 @@
+export default PromiseRegionAwait;
+type PromiseRegionAwait = {
+    $on?(type: string, callback: (e: any) => void): () => void;
+    $set?(props: Partial<$$ComponentProps>): void;
+};
+declare const PromiseRegionAwait: import("svelte").Component<{
+    of: Promise<import("./region.js").RegionValue>;
+    placeholder?: import("svelte").Snippet;
+    children?: import("svelte").Snippet;
+}, {}, "">;
+type $$ComponentProps = {
+    of: Promise<import("./region.js").RegionValue>;
+    placeholder?: import("svelte").Snippet;
+    children?: import("svelte").Snippet;
+};

package/dist/Provide.svelte

@@ -0,0 +1,27 @@
+<script>// Cross-island context provider for PLAIN `getContext(key)` — no `createContext` handle needed, no
+// change to the consumer islands. Writes `values` into the DOM once (so islands below, which
+// hydrate as separate roots on a csr=false page, get them seeded into their own context at hydrate)
+// AND sets Svelte's native context (so the SSR-nested tree + any non-island descendants read the
+// same values in the server pass). Values must be SERIALIZABLE (devalue + ogygia codecs): plain
+// data, `[ogygia.wire]` live values, region snippets — never a function or a live store.
+import { setContext } from "svelte";
+import { serialize_context } from "./context-bridge.js";
+let { values, children } = $props();
+// clsx-like: an object is used as-is; an array is flattened + merged left→right (falsy entries
+// skipped, later keys win). A typed `createContext('k')('v')` returns `{ k: 'v' }`, so typed and
+// raw entries mix freely: `values={[ { locale }, theme('dark'), cond && { x: 1 } ]}`.
+// A provider's values are fixed for its lifetime — resolved once (server pass).
+// svelte-ignore state_referenced_locally
+const resolved = Array.isArray(values) ? Object.assign({}, ...values.filter(Boolean)) : values;
+// svelte-ignore state_referenced_locally
+for (const k in resolved) setContext(k, resolved[k]);
+// Angle brackets built without literals so Svelte's raw-text lexer never sees a stray tag.
+const LT = String.fromCharCode(60);
+const GT = String.fromCharCode(62);
+// Serialize on the SERVER only — a csr=false provider never runs on the client; the payload is
+// already in the SSR HTML for islands to read at hydrate.
+// svelte-ignore state_referenced_locally
+const script = typeof window === "undefined" ? LT + "script data-ogygia-provide" + GT + serialize_context(resolved) + LT + "/script" + GT : "";
+</script>
+
+<ogygia-provide style="display:contents">{@html script}{@render children?.()}</ogygia-provide>

package/dist/Provide.svelte.d.ts

@@ -0,0 +1,8 @@
+import type { Snippet } from 'svelte';
+type $$ComponentProps = {
+    values: Record<string, unknown> | Array<Record<string, unknown> | false | null | undefined>;
+    children?: Snippet;
+};
+declare const Provide: import("svelte").Component<$$ComponentProps, {}, "">;
+type Provide = ReturnType<typeof Provide>;
+export default Provide;

package/dist/RawHtml.svelte

@@ -0,0 +1,9 @@
+<script>/**
+* The component behind a pure-HTML region — what `import.meta.og.code()` / `.md()` render. The
+* html is baked at build (Shiki / markdown); this just drops it in. Static: ships as HTML, no
+* client JS of its own beyond the region wrapper.
+*/
+let { html } = $props();
+</script>
+
+{@html html}

package/dist/RawHtml.svelte.d.ts

@@ -0,0 +1,6 @@
+type $$ComponentProps = {
+    html: string;
+};
+declare const RawHtml: import("svelte").Component<$$ComponentProps, {}, "">;
+type RawHtml = ReturnType<typeof RawHtml>;
+export default RawHtml;