@ogygia/core 0.0.0 → 0.11.1

package/dist/current-region.js

@@ -0,0 +1,36 @@
+// src/current-region.ts
+/**
+* The region the runtime is currently hydrating — the DOM anchor cross-island `context.get()` walks
+* up from. It lives ALONE, with zero heavy imports, on purpose: `core` needs only to SET it while
+* hydrating, and pulling it from `context-bridge` used to drag the whole codec + `svelte/server`
+* graph into every client bundle. Kept on `globalThis` under a `Symbol.for` key so the runtime and
+* the (separately-bundled) context feature agree on one slot. See INVARIANTS · CONTEXT-CURSOR.
+*/
+const CURRENT_REGION = Symbol.for("ogygia.context.current-region");
+const g = globalThis;
+/** Runtime sets the region it is about to hydrate so a nested `get()` knows where to start walking. */
+function set_current_region(el) {
+	g[CURRENT_REGION] = el;
+}
+/** The region currently being hydrated (or null) — read by the context feature's client DOM walk. */
+function current_region() {
+	return g[CURRENT_REGION] ?? null;
+}
+/**
+* Fragment federation: the FOREIGN island (another build's entry, delegated to its own
+* `__og_hydrate`) the runtime is hydrating right now — or null. The `$app/state` / `$app/stores`
+* shims read this (dev) to warn on a page read: inside a mounted MFE island the page store is the
+* SHELL's document singleton, never the MFE's (its own seed stops at the fragment boundary), so
+* `page.data` there is a repaint mismatch waiting to happen. Same slot discipline as the cursor
+* above — the shell runtime SETS it, the foreign build's shim READS it, one `Symbol.for` slot.
+*/
+const FOREIGN_HYDRATE = Symbol.for("ogygia.context.foreign-hydrate");
+/** Runtime marks the foreign island it is about to delegate-hydrate (null when done). */
+function set_foreign_hydrate(info) {
+	g[FOREIGN_HYDRATE] = info;
+}
+/** The foreign island currently hydrating (or null) — read by the page shims' dev warning. */
+function foreign_hydrate() {
+	return g[FOREIGN_HYDRATE] ?? null;
+}
+export { current_region, foreign_hydrate, set_current_region, set_foreign_hydrate };

package/dist/document.d.ts

@@ -0,0 +1,41 @@
+import { RegionValue } from "./region.js";
+export interface DocumentOptions {
+  /** `<title>` — used only when no component set one via `<svelte:head>` (the component wins). */
+  title?: string;
+  /** Raw extra head HTML (meta tags, fonts, …), appended after the rendered head. */
+  head?: string;
+  /** HTTP status (default 200). */
+  status?: number;
+  /** Extra/override response headers. `content-type` and `cache-control: no-store` are the defaults
+   *  (under an eligible FREEZE request the cache-control default is left to the verdict). */
+  headers?: HeadersInit;
+  /** `<html lang>` (default 'en'). */
+  lang?: string;
+  /** Seed for `$app/state` inside islands (`page.data`/`params`/`url`, `route.id`, `form`). The router
+   *  passes it so islands on a rendered page read `$page` just like on a Kit-served page. Promises in
+   *  `data`/`form` aren't streamed here — a non-serializable leaf drops that one field. */
+  pageState?: {
+    url?: {
+      href?: string;
+    };
+    params?: Record<string, string | undefined>;
+    route?: {
+      id: string | null;
+    };
+    status?: number;
+    data?: unknown;
+    form?: unknown;
+    error?: unknown;
+  };
+}
+/**
+ * Render a region into a complete ogygia document and return it as a `Response`.
+ *
+ * ```ts
+ * import { document } from 'ogygia/server';
+ * import { region } from 'ogygia';
+ *
+ * return document(region(Dashboard, { stats }), { title: 'ogygia profiler' });
+ * ```
+ */
+export declare function document(of: RegionValue | PromiseLike<RegionValue>, options?: DocumentOptions): Promise<Response>;

package/dist/document.js

@@ -0,0 +1,125 @@
+import { PageSeed } from "./server/page-seed.js";
+import { page_seed_reducers } from "./server/page-stream.js";
+import { analyze } from "./seed-refs.js";
+import { WIRE_FORMAT_ATTR, WIRE_FORMAT_JSON } from "./server/props-wire.js";
+import { runtime_bootstrap } from "./server/entry-location.js";
+import { current_facts } from "./plugin/facts.js";
+import { kit_render_context } from "./server/kit-context.js";
+import { open_ask_scope, read_seed_ask, record_page } from "./page-seed-registry.js";
+import { shape_page_data } from "./server/seed-shape.js";
+import { escape_text } from "./escape.js";
+import { page_declares_dev_hmr_script, page_declares_router_meta, page_declares_runtime_script, runtime_first } from "./server/head-presence.js";
+import { render } from "svelte/server";
+import { stringify } from "devalue";
+import Region from "./Region.svelte";
+import runtime_url from "virtual:ogygia/runtime-url";
+import { try_get_request_store } from "@sveltejs/kit/internal/server";
+import dev_hmr_url from "virtual:ogygia/dev-hmr-url";
+import { enabled, viewTransitions } from "virtual:ogygia/router-config";
+// src/document.ts
+/**
+* `document()` — the document a region stands in.
+*
+* ogygia's one primitive is the region: component + props with rendering and waking rules. Every
+* region so far has lived inside a document that Kit happened to serve. `document()` is the other
+* half: given a region value, mint the COMPLETE ogygia document around it — doctype, head
+* (`<svelte:head>` content, scoped-CSS links, the runtime bootstrap), body (the region's HTML,
+* `<ogygia-region>` shells, props sidecars) — returned as a `Response` you can serve from anywhere:
+* a `handle` in hooks, a `+server.ts` endpoint, the profiler. No URL, no routing, no "page"
+* semantics — where it's served is the caller's business.
+*
+* It renders through `<Region of={…}>` inside the live request (Kit's `getRequestEvent()` ALS), so
+* ALL the per-request machinery regions already have simply applies: `claim_region_css` links each
+* scoped stylesheet once, props sidecars ride next to their shells, islands inside wake on their own
+* schedules, and the emitted markup is a standard ogygia page — the SPA router body-swaps into and
+* out of it like any Kit-served page.
+*
+* Deliberately NOT the app's `app.html`: that template belongs to Kit's build and does not exist at
+* runtime. The shell here is ogygia's own, minimal one — extra head content goes through
+* `<svelte:head>` in the components or the `head` option.
+*
+* Server-only (it renders): call it from a handle / endpoint / server module.
+*/
+const TITLE_TAG_RE = /<title[\s>]/i;
+/** The `page` object Kit's server `$app/state` answers from (Kit's `props.page` shape), built from
+*  the caller's seed when the router passed one, else from the live request (URL, status) with
+*  empty data — so `page.url`/`page.status` are always true and `page.data` never throws on any
+*  ogygia-rendered document. Also RECORDED into the request's page snapshot, so the nested island
+*  renders under this document rebuild the same context (see server/kit-context.ts). */
+function kit_page_context(options) {
+	const s = options.pageState;
+	const store = try_get_request_store();
+	const href = s?.url?.href ?? store?.event?.url?.href;
+	const page = {
+		url: href ? new URL(href) : void 0,
+		params: s?.params ?? {},
+		route: s?.route ?? { id: null },
+		status: s?.status ?? options.status ?? 200,
+		data: s?.data ?? {},
+		form: s?.form ?? null,
+		error: s?.error ?? null,
+		state: {}
+	};
+	record_page({
+		url: href ? { href } : void 0,
+		params: page.params,
+		route: page.route,
+		status: page.status,
+		data: page.data,
+		form: page.form,
+		error: page.error
+	}, false, []);
+	return page;
+}
+/**
+* Render a region into a complete ogygia document and return it as a `Response`.
+*
+* ```ts
+* import { document } from 'ogygia/server';
+* import { region } from 'ogygia';
+*
+* return document(region(Dashboard, { stats }), { title: 'ogygia profiler' });
+* ```
+*/
+async function document(of, options = {}) {
+	open_ask_scope();
+	const r = await render(Region, {
+		props: { of: await of },
+		context: kit_render_context(kit_page_context(options))
+	});
+	const head = [];
+	head.push(r.head);
+	if (options.head) head.push(options.head);
+	const head_so_far = () => head.join("");
+	if (options.title && !TITLE_TAG_RE.test(head_so_far())) head.push(`<title>${escape_text(options.title)}</title>`);
+	if (enabled && !page_declares_router_meta(head_so_far())) head.push(`<meta name="ogygia-router" content="${viewTransitions ? "vt" : "plain"}">`);
+	if (runtime_url && !page_declares_runtime_script(head_so_far())) head.push(runtime_bootstrap());
+	if (dev_hmr_url && !page_declares_dev_hmr_script(head_so_far())) head.push(`<script type="module" data-ogygia-dev-hmr src="${dev_hmr_url}"><\/script>`);
+	const ask = options.pageState ? read_seed_ask() : void 0;
+	if (options.pageState && (!ask || ask.wanted)) {
+		const s = options.pageState;
+		const data = ask ? shape_page_data(s.data, ask.keys) : s.data;
+		const payload = PageSeed.serialize({
+			url: s.url,
+			params: s.params,
+			route: s.route,
+			status: s.status,
+			data,
+			form: s.form,
+			error: s.error
+		}, (v) => stringify(v, page_seed_reducers), analyze(data).json && analyze(s.form ?? null).json && analyze(s.error ?? null).json);
+		if (payload) {
+			const format = payload.json ? ` ${WIRE_FORMAT_ATTR}="${WIRE_FORMAT_JSON}"` : "";
+			head.push(`<script type="application/ogygia-page" data-ogygia-page${format}>${payload.text}<\/script>`);
+		}
+	}
+	const html = `<!doctype html>\n<html lang="${escape_text(options.lang ?? "en")}"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width, initial-scale=1">` + runtime_first(head.join(""), null) + `</head><body>${r.body}</body></html>`;
+	const headers = new Headers({ "content-type": "text/html; charset=utf-8" });
+	if (!current_facts()?.storable) headers.set("cache-control", "no-store");
+	if (options.headers) for (const [k, v] of new Headers(options.headers)) headers.set(k, v);
+	return new Response(html, {
+		status: options.status ?? 200,
+		headers
+	});
+}
+export { document };

package/dist/entry-hydrate.d.ts

@@ -0,0 +1,5 @@
+import { Component } from "svelte";
+export declare function og_entry_hydrate(component: Component<Record<string, unknown>>, target: Element, props: Record<string, unknown>, options?: {
+  recover?: boolean;
+}): unknown;
+export declare function og_entry_unmount(app: Record<string, unknown>): unknown;

package/dist/entry-hydrate.js

@@ -0,0 +1,42 @@
+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
+* entry may be woken by ANOTHER app's runtime. Svelte's hydrate/unmount carry module-level state
+* (hydration cursor, effect context), so the call must run against THIS build's svelte instance —
+* the consuming runtime only schedules and delegates. The hydration ENVELOPE is prepared here too:
+* anchor conventions belong to the svelte that compiled the entry, so the consumer never shapes them.
+* Same-origin wakes never call these.
+*
+* Every island entry of an app that federates re-exports these through `__og_hydrate` /
+* `__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.
+*/
+function og_entry_hydrate(component, target, props, options) {
+	const first = target.firstChild;
+	if (!(first && first.nodeType === 8 && first.data === "[")) {
+		target.insertBefore(document.createComment("["), target.firstChild);
+		target.appendChild(document.createComment("]"));
+	}
+	const recovery = options && options.recover === false ? { recover: false } : {};
+	return hydrate(NestedProvider, {
+		target,
+		props: {
+			component,
+			props
+		},
+		...recovery
+	});
+}
+function og_entry_unmount(app) {
+	return unmount(app);
+}
+export { og_entry_hydrate, og_entry_unmount };

package/dist/escape.d.ts

@@ -0,0 +1,18 @@
+/**
+ * The ONE canonical side-channel escape. A devalue/JSON payload emitted inside a `<script>` must not
+ * be able to break out of it — escaping `<` neutralizes `<\/script>`, `<script`, and `<!--`. Every seed
+ * / marker serializer (page seed, remote seed, context markers, streamed resolve scripts) routes its
+ * payload through here, so the escape lives in exactly one auditable place.
+ */
+export declare function escape_script_text(s: string): string;
+/**
+ * An attribute value for a double-quoted attribute: `&`, `"`, `<` escaped. One pass; a value with
+ * none of them (nearly every href) comes back as itself, no copy.
+ */
+export declare function escape_attr(s: string): string;
+/** `&` only (a URL into an attribute: its query's separators). No copy without one. */
+export declare function escape_amp(s: string): string;
+/** `&` and `"` only (a value re-emitted into a double-quoted attribute exactly as it was, `<` kept). */
+export declare function escape_amp_quot(s: string): string;
+/** Text content: `&`, `<`, `>` escaped. Text with none of them comes back as itself, no copy. */
+export declare function escape_text(s: string): string;

package/dist/escape.js

@@ -0,0 +1,37 @@
+// src/escape.ts
+/**
+* The ONE canonical side-channel escape. A devalue/JSON payload emitted inside a `<script>` must not
+* be able to break out of it — escaping `<` neutralizes `<\/script>`, `<script`, and `<!--`. Every seed
+* / marker serializer (page seed, remote seed, context markers, streamed resolve scripts) routes its
+* payload through here, so the escape lives in exactly one auditable place.
+*/
+function escape_script_text(s) {
+	return s.replaceAll("<", "\\u003C");
+}
+/**
+* An attribute value for a double-quoted attribute: `&`, `"`, `<` escaped. One pass; a value with
+* none of them (nearly every href) comes back as itself, no copy.
+*/
+function escape_attr(s) {
+	if (s.indexOf("&") === -1 && s.indexOf("\"") === -1 && s.indexOf("<") === -1) return s;
+	return s.replace(AMP_G, "&amp;").replace(QUOT_G, "&quot;").replace(LT_G, "&lt;");
+}
+/** `&` only (a URL into an attribute: its query's separators). No copy without one. */
+function escape_amp(s) {
+	return s.indexOf("&") === -1 ? s : s.replaceAll("&", "&amp;");
+}
+/** `&` and `"` only (a value re-emitted into a double-quoted attribute exactly as it was, `<` kept). */
+function escape_amp_quot(s) {
+	if (s.indexOf("&") === -1 && s.indexOf("\"") === -1) return s;
+	return s.replace(AMP_G, "&amp;").replace(QUOT_G, "&quot;");
+}
+/** Text content: `&`, `<`, `>` escaped. Text with none of them comes back as itself, no copy. */
+function escape_text(s) {
+	if (s.indexOf("&") === -1 && s.indexOf("<") === -1 && s.indexOf(">") === -1) return s;
+	return s.replace(AMP_G, "&amp;").replace(LT_G, "&lt;").replace(GT_G, "&gt;");
+}
+const AMP_G = /&/g;
+const QUOT_G = /"/g;
+const LT_G = /</g;
+const GT_G = />/g;
+export { escape_amp, escape_amp_quot, escape_attr, escape_script_text, escape_text };

package/dist/events/bus.d.ts

@@ -0,0 +1,33 @@
+import { DevtoolsEvent, DevtoolsEventInput } from "./schema.js";
+/** Compile-time gate (Vite `define`). Exported for the public surface + tests; seam modules declare
+ *  their OWN local `const DEVTOOLS` from the same token so DCE never depends on cross-module folding. */
+export declare const DEVTOOLS: boolean;
+/** A sink is any consumer of stamped events. Throwing is contained — one bad sink never starves the
+ *  others, and never breaks the framework path that emitted the event. */
+export type DevtoolsSink = (event: DevtoolsEvent) => void;
+/**
+ * THE emit entry point. Stamps the envelope (v / seq / t / realm), rings the buffer, fans to sinks.
+ * A no-op when the bus is inactive. Guard the CALL with a module-local `if (DEVTOOLS)` so the event
+ * literal compiles out entirely when off — this internal guard only protects direct/dynamic callers.
+ */
+export declare function emit(input: DevtoolsEventInput): void;
+/**
+ * Push ALREADY-STAMPED events into the buffer + sinks WITHOUT re-stamping — the ingest path for the
+ * server realm's events, which arrive from the `application/ogygia-devtools` side-channel carrying
+ * their own envelope (v / seq / t / realm:'server'). This is what unifies the server render stream
+ * and the client wake stream into ONE `window.__ogygia_devtools` timeline, correlated by fingerprint.
+ */
+export declare function ingest(events: DevtoolsEvent[]): void;
+/** Buffered events in emission order (oldest → newest). Copies out — safe to hold/serialize. */
+export declare function snapshot(): DevtoolsEvent[];
+/** Drop every buffered event (the sinks are left registered). Used between e2e scenarios + traces. */
+export declare function clear(): void;
+/** Register a sink; returns an unregister fn. A sink sees events from registration onward — to also
+ *  replay what's buffered, iterate {@link snapshot} first. */
+export declare function add_sink(sink: DevtoolsSink): () => void;
+/** Runtime configuration — pause/resume, resize the ring, set per-name sampling. */
+export declare function configure(opts: {
+  active?: boolean;
+  cap?: number;
+  sample?: Record<string, number>;
+}): void;

package/dist/events/bus.js

@@ -0,0 +1,153 @@
+import "./schema.js";
+// src/events/bus.ts
+/**
+* The devtools EVENT BUS — the whole product's spine (internal/notes/devtools.md, Rung 0).
+*
+* `emit()` is the one entry point. Behind it: a capped RING BUFFER (so a long-lived tab / server
+* can't grow it unbounded) plus a set of pluggable SINKS (postMessage for the REPL, a window hook
+* for e2e, console for debugging, buffer→JSON for traces). Nothing here has a UI opinion — every
+* product (our own e2e, the REPL, the future Vite plugin) is a listener over this.
+*
+* ZERO-COST WHEN OFF. `DEVTOOLS` is a compile-time constant from the `__OGYGIA_DEVTOOLS__` Vite
+* `define` (typeof-guarded exactly like `__OGYGIA_SERVER_DELTA__`, so a plain `node` import of
+* `dist/` without the define falls back to `false`). Call sites guard with a MODULE-LOCAL
+* `const DEVTOOLS = …` (the proven DCE pattern — see runtime/form-continuity.ts): when off, the
+* whole `if (DEVTOOLS) emit({…})` — object literal included — folds to `if (false)` and is dropped,
+* and this module, now unreferenced, tree-shakes out of the app's runtime chunk entirely.
+*
+* STATE IS GLOBAL-PINNED. The island runtime chunk, each island entry, and the transport-hook graph
+* are SEPARATE bundles that each carry their own copy of this module — but hub mints (ref.ts) and
+* region wakes (core.ts) emit from whichever copy runs. Pinning the buffer to `globalThis` (like the
+* hub registry and the frame store) keeps every copy writing into the ONE buffer a sink exposes.
+* No top-level side effect: the global is created lazily on first `emit`/`configure`, so an unused
+* import is fully shakeable.
+*/
+/** Compile-time gate (Vite `define`). Exported for the public surface + tests; seam modules declare
+*  their OWN local `const DEVTOOLS` from the same token so DCE never depends on cross-module folding. */
+const DEVTOOLS = typeof __OGYGIA_DEVTOOLS__ !== "undefined" ? __OGYGIA_DEVTOOLS__ : false;
+/** Which half of the framework this bundle is running in (a trace merges both streams). */
+const REALM = typeof window !== "undefined" ? "client" : "server";
+/** Default ring-buffer capacity (events). Small — instruments read live; a trace drains on demand. */
+const DEFAULT_CAP = 4096;
+const BUS_KEY = Symbol.for("ogygia.devtools.bus");
+/** `cap` empty ring slots (`undefined` until written; the readers skip empty slots). */
+function empty_ring(cap) {
+	return Array.from({ length: cap });
+}
+function bus() {
+	const g = globalThis;
+	return g[BUS_KEY] ??= {
+		active: DEVTOOLS,
+		seq: 0,
+		cap: DEFAULT_CAP,
+		ring: empty_ring(DEFAULT_CAP),
+		write: 0,
+		count: 0,
+		sinks: /* @__PURE__ */ new Set(),
+		sample: /* @__PURE__ */ new Map(),
+		sample_n: /* @__PURE__ */ new Map()
+	};
+}
+/** High-resolution monotonic clock where available; wall-clock otherwise. */
+function now() {
+	if (typeof performance !== "undefined" && typeof performance.now === "function") return performance.now();
+	return Date.now();
+}
+/** Sampling gate: keep 1-in-N for a name that opted in, else keep all. */
+function passes_sample(b, name) {
+	const n = b.sample.get(name);
+	if (n === void 0 || n <= 1) return true;
+	const c = (b.sample_n.get(name) ?? 0) + 1;
+	b.sample_n.set(name, c % n);
+	return c % n === 0;
+}
+/**
+* THE emit entry point. Stamps the envelope (v / seq / t / realm), rings the buffer, fans to sinks.
+* A no-op when the bus is inactive. Guard the CALL with a module-local `if (DEVTOOLS)` so the event
+* literal compiles out entirely when off — this internal guard only protects direct/dynamic callers.
+*/
+function emit(input) {
+	if (!DEVTOOLS) return;
+	const b = bus();
+	if (!b.active) return;
+	if (!passes_sample(b, input.name)) return;
+	const event = {
+		...input,
+		v: 1,
+		seq: b.seq++,
+		t: now(),
+		realm: REALM
+	};
+	b.ring[b.write] = event;
+	b.write = (b.write + 1) % b.cap;
+	if (b.count < b.cap) b.count++;
+	if (b.sinks.size) for (const sink of b.sinks) try {
+		sink(event);
+	} catch {}
+}
+/**
+* Push ALREADY-STAMPED events into the buffer + sinks WITHOUT re-stamping — the ingest path for the
+* server realm's events, which arrive from the `application/ogygia-devtools` side-channel carrying
+* their own envelope (v / seq / t / realm:'server'). This is what unifies the server render stream
+* and the client wake stream into ONE `window.__ogygia_devtools` timeline, correlated by fingerprint.
+*/
+function ingest(events) {
+	if (!DEVTOOLS) return;
+	const b = bus();
+	if (!b.active) return;
+	for (const event of events) {
+		b.ring[b.write] = event;
+		b.write = (b.write + 1) % b.cap;
+		if (b.count < b.cap) b.count++;
+		if (b.sinks.size) for (const sink of b.sinks) try {
+			sink(event);
+		} catch {}
+	}
+}
+/** Buffered events in emission order (oldest → newest). Copies out — safe to hold/serialize. */
+function snapshot() {
+	const b = bus();
+	const out = [];
+	if (b.count === b.cap) for (let i = 0; i < b.cap; i++) {
+		const ev = b.ring[(b.write + i) % b.cap];
+		if (ev) out.push(ev);
+	}
+	else for (let i = 0; i < b.count; i++) {
+		const ev = b.ring[i];
+		if (ev) out.push(ev);
+	}
+	return out;
+}
+/** Drop every buffered event (the sinks are left registered). Used between e2e scenarios + traces. */
+function clear() {
+	const b = bus();
+	b.ring = empty_ring(b.cap);
+	b.write = 0;
+	b.count = 0;
+}
+/** Register a sink; returns an unregister fn. A sink sees events from registration onward — to also
+*  replay what's buffered, iterate {@link snapshot} first. */
+function add_sink(sink) {
+	const b = bus();
+	b.sinks.add(sink);
+	return () => b.sinks.delete(sink);
+}
+/** Runtime configuration — pause/resume, resize the ring, set per-name sampling. */
+function configure(opts) {
+	const b = bus();
+	if (typeof opts.active === "boolean") b.active = opts.active;
+	if (typeof opts.cap === "number" && opts.cap > 0 && opts.cap !== b.cap) {
+		const kept = snapshot().slice(-opts.cap);
+		b.cap = opts.cap;
+		b.ring = empty_ring(opts.cap);
+		b.write = 0;
+		b.count = 0;
+		for (const ev of kept) {
+			b.ring[b.write] = ev;
+			b.write = (b.write + 1) % b.cap;
+			if (b.count < b.cap) b.count++;
+		}
+	}
+	if (opts.sample) for (const [name, n] of Object.entries(opts.sample)) b.sample.set(name, n);
+}
+export { DEVTOOLS, add_sink, clear, configure, emit, ingest, snapshot };

package/dist/events/index.d.ts

@@ -0,0 +1,4 @@
+import { DEVTOOLS, DevtoolsSink, add_sink, clear, configure, emit, ingest, snapshot } from "./bus.js";
+import { DevtoolsTrace, DevtoolsWindowHook, ingest_server_events, install_console_sink, install_postmessage_sink, install_window_sink, to_trace } from "./sinks.js";
+import { CompileEventInput, DEVTOOLS_SCHEMA_VERSION, DevtoolsDomain, DevtoolsEnvelope, DevtoolsEvent, DevtoolsEventInput, HubEventInput, NavEventInput, RuntimeEventInput, ServerEventInput, WireEventInput } from "./schema.js";
+export { type CompileEventInput, DEVTOOLS, DEVTOOLS_SCHEMA_VERSION, type DevtoolsDomain, type DevtoolsEnvelope, type DevtoolsEvent, type DevtoolsEventInput, type DevtoolsSink, type DevtoolsTrace, type DevtoolsWindowHook, type HubEventInput, type NavEventInput, type RuntimeEventInput, type ServerEventInput, type WireEventInput, add_sink, clear, configure, emit, ingest, ingest_server_events, install_console_sink, install_postmessage_sink, install_window_sink, snapshot, to_trace };

package/dist/events/index.js

@@ -0,0 +1,4 @@
+import { DEVTOOLS, add_sink, clear, configure, emit, ingest, snapshot } from "./bus.js";
+import { ingest_server_events, install_console_sink, install_postmessage_sink, install_window_sink, to_trace } from "./sinks.js";
+import { DEVTOOLS_SCHEMA_VERSION } from "./schema.js";
+export { DEVTOOLS, DEVTOOLS_SCHEMA_VERSION, add_sink, clear, configure, emit, ingest, ingest_server_events, install_console_sink, install_postmessage_sink, install_window_sink, snapshot, to_trace };