@ogygia/core 0.0.0 → 0.11.0

package/dist/seed-refs.js

@@ -0,0 +1,487 @@
+import { fnv1a } from "./runtime/hash.js";
+// src/seed-refs.ts
+/**
+* SEED REFERENCES — island props that point into the page seed instead of copying it.
+*
+* THE DUPLICATION: on a csr=false page the handle ships `page.data` once as the page seed (so
+* islands can read `$page`), and every island ships its props as its own sidecar. A CMS page hands
+* each block island its slice of the same `page.data` tree, so the same JSON crosses twice —
+* measured on one landing page: 674 KB of seed and 481 KB of props, of which 94% were verbatim
+* seed subtrees. Twice the bytes, and twice the server-side serialization (the larger part of that
+* page's remaining TTFB gap to a plain Kit render).
+*
+* THE CODEC: when the seed ships, an island's props are serialized RELATIVE to it. Any plain
+* object / array in the props that is also a node of `page.data` — by IDENTITY (the app passed the
+* same object) or by STRUCTURE (the app cloned it: a JSON round-trip, a spread — CMS SDKs do) — is
+* written as `["OgygiaSeedRef", <path>]`, a path from `page.data` to that node. The client revives
+* the reference against the ONE parsed seed of its document (the same graph `page.data` reads —
+* `runtime/seeds.ts`) and hands the island the seed's own node, by reference: island props are a
+* snapshot either way, and the DEV mutation guard warns on a write into them. Largest matching
+* ancestor wins, so a block whose whole props object is one seed node becomes one short reference.
+*
+* WHAT MATCHES: plain objects and arrays whose subtree holds only plain objects, arrays, primitives
+* and Dates — no class instances (wired values, stores, snippets keep their own codec), no Maps or
+* Sets, no cycles. Small nodes are skipped (`min_bytes`): a reference costs ~30 bytes, so it must
+* save more than that.
+*
+* WHEN: only inside Kit's page pass of THIS document, and only when the seed ships — a reference
+* into a seed that never arrives would be a hole in the island's props. The decision is made ONCE
+* per request, when the document tail renders (server/props-wire.ts): every island on the page
+* gets references then, whichever rendered first. Every other render root (a hole endpoint, a
+* baked ticket, a foreign fragment) never references: its props must be self-contained wherever
+* the HTML is spliced.
+*
+* ONE WALK PER NODE PER REQUEST: `measure` visits a node once and remembers what it learned —
+* byte estimate, referenceability, JSON-exactness, a streamed promise inside — as ONE NUMBER in a
+* memo shared by every root measured in the same request (`set_measure_memo_reader`; the handle
+* hands out its request's memo). The seed's `page.data` is walked once; the twenty block islands
+* whose props ARE seed nodes cost a lookup each, not a walk each; the shaped seed, the props plans
+* and the handle's lane / streaming decisions all read the same memo. Nothing is allocated per
+* node beyond the memo entry: no measure object, no cycle stack (the memo's in-progress mark is
+* the cycle detector), no path array until a node is actually referenced.
+*
+* Universal module (no Node imports): the index + reducer run on the server, the resolver on the
+* client, and the unit tests exercise both ends against a real devalue round trip.
+*/
+/** The devalue type tag. */
+const SEED_REF_KEY = "OgygiaSeedRef";
+/** A node the codec may reference: a plain object or an array (own prototype only). */
+function is_plain(v) {
+	if (v === null || typeof v !== "object") return false;
+	if (Array.isArray(v)) return true;
+	const proto = Object.getPrototypeOf(v);
+	return proto === Object.prototype || proto === null;
+}
+const is_thenable = (v) => typeof v?.then === "function";
+/** Leaves that a plain deep copy reproduces exactly. */
+function is_leaf(v) {
+	return v === null || v === void 0 || typeof v === "string" || typeof v === "number" || typeof v === "boolean" || typeof v === "bigint" || v instanceof Date;
+}
+const leaf_text = (v) => v === void 0 ? "u" : v === null ? "n" : v instanceof Date ? "d" + v.getTime() : typeof v + ":" + String(v);
+/**
+* Post-order structural hash + byte estimate of a plain subtree. `null` when the subtree is not
+* referenceable (a non-plain value inside, or a cycle). Visits each node once per walk; results
+* are memoised in `memo` so a graph with shared nodes stays linear.
+*/
+function hash_subtree(v, memo, on_stack) {
+	if (is_leaf(v)) {
+		const t = leaf_text(v);
+		return {
+			hash: t,
+			bytes: t.length
+		};
+	}
+	if (!is_plain(v)) return null;
+	const cached = memo.get(v);
+	if (cached !== void 0) return cached;
+	if (on_stack.has(v)) return null;
+	on_stack.add(v);
+	let bytes = 0;
+	let acc = Array.isArray(v) ? "A" : "O";
+	let ok = true;
+	if (Array.isArray(v)) for (const item of v) {
+		const h = hash_subtree(item, memo, on_stack);
+		if (!h) {
+			ok = false;
+			break;
+		}
+		acc += "|" + h.hash;
+		bytes += h.bytes + 1;
+	}
+	else for (const key of Object.keys(v).sort()) {
+		const h = hash_subtree(v[key], memo, on_stack);
+		if (!h) {
+			ok = false;
+			break;
+		}
+		acc += "|" + key + "=" + h.hash;
+		bytes += key.length + h.bytes + 3;
+	}
+	on_stack.delete(v);
+	const result = ok ? {
+		hash: fnv1a(acc),
+		bytes
+	} : null;
+	memo.set(v, result);
+	return result;
+}
+/** Exact structural equality for the shapes `hash_subtree` accepts — the check behind a hash hit. */
+function deep_equal_plain(a, b) {
+	if (a === b) return true;
+	if (a instanceof Date || b instanceof Date) return a instanceof Date && b instanceof Date && a.getTime() === b.getTime();
+	if (is_leaf(a) || is_leaf(b)) return false;
+	if (!is_plain(a) || !is_plain(b)) return false;
+	if (Array.isArray(a) !== Array.isArray(b)) return false;
+	if (Array.isArray(a) && Array.isArray(b)) {
+		if (a.length !== b.length) return false;
+		for (let i = 0; i < a.length; i++) if (!deep_equal_plain(a[i], b[i])) return false;
+		return true;
+	}
+	const ka = Object.keys(a);
+	const kb = Object.keys(b);
+	if (ka.length !== kb.length) return false;
+	for (const k of ka) {
+		if (!Object.prototype.hasOwnProperty.call(b, k)) return false;
+		if (!deep_equal_plain(a[k], b[k])) return false;
+	}
+	return true;
+}
+const F_REF = 1;
+const F_JSON = 2;
+const F_THENABLE = 4;
+const P_OPAQUE = 0;
+const P_THENABLE = F_THENABLE;
+const P_NULLISH_JSON = 35;
+const P_UNDEFINED = 33;
+const P_NUMBER = 67;
+const P_NUMBER_NOJSON = 65;
+const P_BIGINT = 65;
+const P_DATE = 193;
+/** The memo mark of a node whose walk has not finished: meeting it again is a cycle. */
+const IN_PROGRESS = -1;
+const bytes_of = (p) => (p - (p & 7)) / 8;
+function unpack(p) {
+	return {
+		bytes: bytes_of(p),
+		ref: (p & F_REF) !== 0,
+		json: (p & F_JSON) !== 0,
+		thenable: (p & F_THENABLE) !== 0
+	};
+}
+/**
+* The one walk: measure a value (post-order, memoised per plain node in `memo`). Every child is
+* measured even after one disqualifies the parent: a clean sibling deeper in the tree must still
+* get its own entry (the index walk reads the memo). Strings never enter the memo. A node already
+* in the memo — from this root or from any other root measured with the same memo — is a lookup.
+*/
+function measure(v, memo) {
+	switch (typeof v) {
+		case "string": return (v.length + 2) * 8 + F_REF + F_JSON;
+		case "number": return Number.isFinite(v) && !Object.is(v, -0) ? P_NUMBER : P_NUMBER_NOJSON;
+		case "boolean": return P_NULLISH_JSON;
+		case "undefined": return P_UNDEFINED;
+		case "bigint": return P_BIGINT;
+		case "object": break;
+		default: return P_OPAQUE;
+	}
+	if (v === null) return P_NULLISH_JSON;
+	if (v instanceof Date) return P_DATE;
+	if (!is_plain(v)) return is_thenable(v) ? P_THENABLE : P_OPAQUE;
+	const cached = memo.get(v);
+	if (cached !== void 0) return cached === IN_PROGRESS ? P_OPAQUE : cached;
+	if (!Array.isArray(v) && Object.getOwnPropertySymbols(v).length > 0) {
+		memo.set(v, P_OPAQUE);
+		return P_OPAQUE;
+	}
+	let bytes = 0;
+	let lanes = 3;
+	let thenable = 0;
+	let marked = false;
+	if (Array.isArray(v)) for (let i = 0; i < v.length; i++) {
+		const c = v[i];
+		if (typeof c === "string") {
+			bytes += c.length + 3;
+			continue;
+		}
+		if (!marked && typeof c === "object" && c !== null) {
+			memo.set(v, IN_PROGRESS);
+			marked = true;
+		}
+		const p = measure(c, memo);
+		bytes += bytes_of(p) + 1;
+		lanes &= p;
+		thenable |= p & F_THENABLE;
+	}
+	else for (const key in v) {
+		const c = v[key];
+		if (typeof c === "string") {
+			bytes += c.length + key.length + 5;
+			continue;
+		}
+		if (c === void 0) {
+			bytes += key.length + 4;
+			continue;
+		}
+		if (!marked && typeof c === "object" && c !== null) {
+			memo.set(v, IN_PROGRESS);
+			marked = true;
+		}
+		const p = measure(c, memo);
+		bytes += bytes_of(p) + key.length + 3;
+		lanes &= p;
+		thenable |= p & F_THENABLE;
+	}
+	const result = bytes * 8 + (lanes & 3) + thenable;
+	memo.set(v, result);
+	return result;
+}
+let memo_reader = null;
+/** Server (`hooks.ts`) installs a request-scoped reader: every root measured during one request
+*  shares one memo, so a subtree reached from two roots (the seed and an island's props) is walked
+*  once. `null` uninstalls; off-request (a hole endpoint, a test) each root gets its own memo. */
+function set_measure_memo_reader(fn) {
+	memo_reader = fn;
+}
+const analysis_cache = /* @__PURE__ */ new WeakMap();
+/** The walk, cached per plain root object: the seed's `page.data` is measured once per request
+*  however many islands, lanes and decisions ask; a props object once per island — and against
+*  the request's shared memo, so a props object that is a seed node costs a lookup. */
+function analysis(value) {
+	if (!is_plain(value)) {
+		const memo = /* @__PURE__ */ new Map();
+		return {
+			root: unpack(measure(value, memo)),
+			memo
+		};
+	}
+	const hit = analysis_cache.get(value);
+	if (hit) return hit;
+	const memo = memo_reader?.() ?? /* @__PURE__ */ new Map();
+	const a = {
+		root: unpack(measure(value, memo)),
+		memo
+	};
+	analysis_cache.set(value, a);
+	return a;
+}
+/** What one walk says about a value (see {@link Measure}). */
+function analyze(value) {
+	return analysis(value).root;
+}
+/**
+* WHY a tree is not JSON-exact: the path of the first leaf that disqualifies it, with what it
+* is — `config.updated (Date)`, `rows[3].price (NaN)`, `facets (Map)`, `meta (class Foo)`. A
+* separate walk on purpose (the measuring walk carries no paths); the handle runs it only for a
+* tree that left the JSON lane and only while the profiler records. `null` for a JSON tree.
+*/
+function json_culprit(value, max_depth = 64) {
+	const seen = /* @__PURE__ */ new Set();
+	const why = (v) => {
+		switch (typeof v) {
+			case "string":
+			case "boolean": return null;
+			case "number": return Number.isFinite(v) ? Object.is(v, -0) ? "-0" : null : Number.isNaN(v) ? "NaN" : "Infinity";
+			case "undefined": return "undefined";
+			case "bigint": return "bigint";
+			case "function": return "function";
+			case "symbol": return "symbol";
+			default: return null;
+		}
+	};
+	const walk = (v, path, depth) => {
+		const leaf = why(v);
+		if (leaf) return `${path || "(root)"} (${leaf})`;
+		if (v === null || typeof v !== "object") return null;
+		if (v instanceof Date) return `${path || "(root)"} (Date)`;
+		if (v instanceof Map) return `${path || "(root)"} (Map)`;
+		if (v instanceof Set) return `${path || "(root)"} (Set)`;
+		if (typeof v.then === "function") return `${path || "(root)"} (Promise)`;
+		if (!is_plain(v)) {
+			const name = Object.getPrototypeOf(v)?.constructor?.name;
+			return `${path || "(root)"} (class ${name || "instance"})`;
+		}
+		if (seen.has(v)) return `${path || "(root)"} (cycle)`;
+		if (depth > max_depth) return null;
+		seen.add(v);
+		if (Array.isArray(v)) for (let i = 0; i < v.length; i++) {
+			if (v[i] === void 0) return `${path}[${i}] (undefined in array)`;
+			const r = walk(v[i], `${path}[${i}]`, depth + 1);
+			if (r) return r;
+		}
+		else {
+			if (Object.getOwnPropertySymbols(v).length > 0) return `${path || "(root)"} (symbol-branded)`;
+			for (const key in v) {
+				const c = v[key];
+				if (c === void 0) continue;
+				const r = walk(c, path ? `${path}.${key}` : key, depth + 1);
+				if (r) return r;
+			}
+		}
+		seen.delete(v);
+		return null;
+	};
+	return walk(value, "", 0);
+}
+function path_of(at) {
+	if (at.path !== null) return at.path;
+	const path = at.parent === null ? [] : [...path_of(at.parent), at.key];
+	at.path = path;
+	return path;
+}
+const EMPTY_NODES = [];
+const EMPTY_INDEX = {
+	by_identity: {
+		get: () => void 0,
+		has: () => false
+	},
+	candidates: () => EMPTY_NODES,
+	hash_of: () => null,
+	size: 0,
+	touched: /* @__PURE__ */ new Set()
+};
+const index_cache = /* @__PURE__ */ new WeakMap();
+/**
+* Index the seed's `data` for referencing: every referenceable node at or above `min_bytes`, by
+* identity now and by structural hash on demand (first occurrence wins — the shortest path is not
+* guaranteed, the first in key order is, which is deterministic). Cached per `data` object: one
+* index per request, however many islands ask. It reads the one measuring walk (`analyze`) and
+* prunes: a node below `min_bytes` cannot hold a child at or above it (a child is never larger
+* than its parent), so its subtree is skipped BEFORE anything is materialised — on a CMS tree that
+* is most of the nodes.
+*/
+function index_seed(data, min_bytes = 96) {
+	if (!is_plain(data)) return {
+		...EMPTY_INDEX,
+		touched: /* @__PURE__ */ new Set()
+	};
+	const hit = index_cache.get(data);
+	if (hit) return hit;
+	const memo = analysis(data).memo;
+	const at = /* @__PURE__ */ new WeakMap();
+	const nodes = [];
+	const seen = /* @__PURE__ */ new Set();
+	const enter = (c) => {
+		if (!is_plain(c) || seen.has(c)) return false;
+		const p = memo.get(c);
+		return p !== void 0 && bytes_of(p) >= min_bytes;
+	};
+	const visit = (v, here) => {
+		seen.add(v);
+		if (memo.get(v) & F_REF) {
+			at.set(v, here);
+			nodes.push(v);
+		}
+		if (Array.isArray(v)) for (let i = 0; i < v.length; i++) {
+			const c = v[i];
+			if (enter(c)) visit(c, {
+				parent: here,
+				key: i,
+				path: null
+			});
+		}
+		else for (const key in v) {
+			const c = v[key];
+			if (enter(c)) visit(c, {
+				parent: here,
+				key,
+				path: null
+			});
+		}
+	};
+	if (enter(data)) visit(data, {
+		parent: null,
+		key: "",
+		path: []
+	});
+	let by_bytes = null;
+	const buckets = () => {
+		if (by_bytes === null) {
+			by_bytes = /* @__PURE__ */ new Map();
+			for (const n of nodes) {
+				const b = bytes_of(memo.get(n));
+				const bucket = by_bytes.get(b);
+				if (bucket) bucket.push(n);
+				else by_bytes.set(b, [n]);
+			}
+		}
+		return by_bytes;
+	};
+	const hash_memo = /* @__PURE__ */ new Map();
+	const index = {
+		by_identity: {
+			get: (node) => {
+				const here = at.get(node);
+				return here === void 0 ? void 0 : path_of(here);
+			},
+			has: (node) => at.has(node)
+		},
+		candidates: (b) => buckets().get(b) ?? EMPTY_NODES,
+		hash_of: (node) => hash_subtree(node, hash_memo, /* @__PURE__ */ new Set())?.hash ?? null,
+		size: nodes.length,
+		touched: /* @__PURE__ */ new Set()
+	};
+	index_cache.set(data, index);
+	return index;
+}
+/**
+* Plan one island's references: walk the props once, top-down, largest matching ancestor first —
+* identity first (a pointer lookup per node, no hashing), then structure (hash + exact comparison,
+* only for a large plain node the seed does not own, and only against the seed nodes of exactly the
+* same byte size — usually none, or one). Nodes under a matched ancestor are never visited (they
+* ride inside the reference), and neither is anything under a node below `min_bytes` (no child
+* of it can be referenced). The props' own measures come from the request memo, so the plan adds
+* no walk of its own beyond the pointer lookups.
+*/
+function plan_seed_refs(index, props, min_bytes = 96) {
+	const matched = /* @__PURE__ */ new WeakMap();
+	const keys = /* @__PURE__ */ new Set();
+	let count = 0;
+	if (index.size > 0) {
+		const memo = analysis(props).memo;
+		const hashed = /* @__PURE__ */ new Map();
+		const seen = /* @__PURE__ */ new Set();
+		const hit = (v, path) => {
+			matched.set(v, path);
+			index.touched.add(String(path[0]));
+			keys.add(String(path[0]));
+			count++;
+		};
+		const visit = (v) => {
+			if (!is_plain(v) || seen.has(v)) return;
+			seen.add(v);
+			const by_id = index.by_identity.get(v);
+			if (by_id) return hit(v, by_id);
+			const p = memo.get(v) ?? measure(v, memo);
+			const bytes = bytes_of(p);
+			if (bytes < min_bytes) return;
+			if (p & F_REF) {
+				const cands = index.candidates(bytes);
+				if (cands.length) {
+					const h = hash_subtree(v, hashed, /* @__PURE__ */ new Set())?.hash ?? null;
+					const cand = h ? cands.find((c) => index.hash_of(c) === h) : void 0;
+					if (cand && deep_equal_plain(cand, v)) return hit(v, index.by_identity.get(cand));
+				}
+			}
+			if (Array.isArray(v)) for (const item of v) visit(item);
+			else for (const key in v) visit(v[key]);
+		};
+		visit(props);
+	}
+	return {
+		reducer: (value) => value === null || typeof value !== "object" ? void 0 : matched.get(value),
+		count,
+		keys
+	};
+}
+/** Client: the node a path points at, or `undefined` when the seed does not have it. */
+function resolve_seed_ref(data, path) {
+	let cur = data;
+	for (const key of path) {
+		if (cur === null || typeof cur !== "object") return void 0;
+		cur = cur[key];
+	}
+	return cur;
+}
+/**
+* Client reviver for the devalue type: resolve BY REFERENCE. The island receives the seed's own
+* node — the same object its `page.data` read would hand it, shared exactly the way `page.data`
+* already is between islands. A deep copy per reference (129 of them on a measured page) bought
+* nothing: island props are a snapshot either way, and the DEV mutation guard the runtime wraps
+* every island's props in (`PropMutationGuard`) already warns on a write into them. `get_data` is
+* called lazily, once per reviver — the first reference resolves the seed. A dangling path (no seed,
+* or a seed that does not carry the node) revives to `undefined` and, in dev, says why.
+*/
+function seed_ref_reviver(get_data) {
+	let data;
+	let resolved = false;
+	return (path) => {
+		if (!resolved) {
+			data = get_data();
+			resolved = true;
+		}
+		const node = resolve_seed_ref(data, path);
+		if (node === void 0 && typeof console !== "undefined" && import.meta.env?.DEV) console.warn(`[ogygia] island props reference page.data at ${JSON.stringify(path)} but the page seed does not carry it — the island receives undefined there.`);
+		return node;
+	};
+}
+export { SEED_REF_KEY, analyze, deep_equal_plain, index_seed, json_culprit, plan_seed_refs, resolve_seed_ref, seed_ref_reviver, set_measure_memo_reader };

package/dist/server/capability-lifetime.d.ts

@@ -0,0 +1,28 @@
+/** The app's settings the rule reads. */
+export interface LifetimeSettings {
+  /** prerendering (Kit's `building`) */
+  building: boolean;
+  /** `ogygia({ ttl })`, seconds */
+  region_ttl: number;
+  /** `ogygia({ maxPageAge })`, seconds */
+  renew_window: number;
+  /** the request being rendered (null off-request: prerender, a test) */
+  request(): Request | null;
+}
+export interface CapabilityLifetime {
+  /**
+   * The `exp` (unix seconds) of a capability minted now, in the render running now. Prerendered
+   * (real PPR) or a render a plugin may store (`facts.storable`): prerender-grade, since the stored
+   * HTML outlives any `ttl` (a stored page must never carry expired hole URLs). An anonymous hole on
+   * a document the app marked shared-cacheable (a load's `cache-control`) outlives that cache life
+   * (server/shared-cache.ts). Everything else, and anything sealed to a `session`, keeps the short
+   * `ttl` window so harvested URLs age out.
+   */
+  mint_expiry(session: string): number;
+  /** The `exp` of a capability RENEWED now (an expired one re-signed at hole time): the short `ttl`
+   *  window — its document is already old, and the runtime adopts the fresh URL for later fetches. */
+  renewed_expiry(): number;
+  /** Seconds after expiry a capability still renews (`0` renews nothing). */
+  readonly renew_window: number;
+}
+export declare function capability_lifetime(app: LifetimeSettings): CapabilityLifetime;

package/dist/server/capability-lifetime.js

@@ -0,0 +1,31 @@
+import { current_facts } from "../plugin/facts.js";
+import { capability_expiry } from "./endpoint.js";
+import { document_shared_lifetime, mint_ttl_sec } from "./shared-cache.js";
+// src/server/capability-lifetime.ts
+/**
+* THE CAPABILITY LIFETIME — when a signed hole URL minted now expires, and when a renewed one does.
+* One rule for every capability the app signs: core's region holes (server/region-endpoint.ts) and a
+* plugin's own (`app.capability`, plugin/capability.ts — a remote region's hole). Expiry is unix
+* SECONDS everywhere: the runtime reads it from the URL to tell an expired capability
+* (runtime/region-endpoint-url.ts `capability_expired`) and retries it once with `&renew=1`.
+*
+* Pure: the app's settings come in (server/region-endpoint.ts binds them from the virtuals), so the
+* plugin test harness (plugin/testing.ts) runs the same rule without a Kit app.
+*/
+function capability_lifetime(app) {
+	const now_sec = () => Math.floor(Date.now() / 1e3);
+	return {
+		mint_expiry(session) {
+			const stored = app.building || current_facts()?.storable === true;
+			return capability_expiry(now_sec(), mint_ttl_sec({
+				stored,
+				session,
+				shared: stored || session !== "" ? 0 : document_shared_lifetime(app.request()),
+				region_ttl: app.region_ttl
+			}));
+		},
+		renewed_expiry: () => capability_expiry(now_sec(), app.region_ttl),
+		renew_window: app.renew_window
+	};
+}
+export { capability_lifetime };

package/dist/server/dead-kit-resolves.d.ts

@@ -0,0 +1 @@
+export declare function drop_dead_kit_resolves(response: Response): Response;

package/dist/server/dead-kit-resolves.js

@@ -0,0 +1,39 @@
+// src/server/dead-kit-resolves.ts
+/**
+* Drop Kit's streamed resolve scripts from a document with no Kit client (csr=false). A load that
+* returns promises makes Kit stream `<script>__sveltekit_x.resolve(…)<\/script>` chunks after the
+* document; they call a global only Kit's client bootstrap defines, so on a csr=false page each one
+* throws. (When an island reads the page, `stream_page_deferred` replaces the whole tail instead.)
+*
+* Only a chunk that STARTS with `<script` is decoded and looked at — the document and every other
+* chunk (late regions included) pass untouched: no copy, no scan of a big page.
+*/
+const SCRIPT_BYTES = [
+	60,
+	115,
+	99,
+	114,
+	105,
+	112,
+	116
+];
+function drop_dead_kit_resolves(response) {
+	const body = response.body;
+	if (!body) return response;
+	const decoder = new TextDecoder();
+	const out = body.pipeThrough(new TransformStream({ transform(chunk, controller) {
+		let starts = chunk.length >= SCRIPT_BYTES.length;
+		for (let i = 0; starts && i < SCRIPT_BYTES.length; i++) if (chunk[i] !== SCRIPT_BYTES[i]) starts = false;
+		if (starts && chunk.length < 1 << 20) {
+			const text = decoder.decode(chunk);
+			if (text.includes("__sveltekit_") && text.includes(".resolve(")) return;
+		}
+		controller.enqueue(chunk);
+	} }));
+	return new Response(out, {
+		status: response.status,
+		statusText: response.statusText,
+		headers: new Headers(response.headers)
+	});
+}
+export { drop_dead_kit_resolves };

package/dist/server/document-assembly.d.ts

@@ -0,0 +1,30 @@
+/**
+ * DOCUMENT ASSEMBLY — how the handle puts its head and body injections into Kit's page HTML.
+ *
+ * Kit hands `transformPageChunk` the whole document as one string on a non-streamed page (2.6 MB on
+ * a large CMS page). Everything ogygia adds goes to exactly two places: just before `</head>` and
+ * just before `</body>`. So the document is located ONCE — `</head>` from the front (it sits within
+ * the first few KB), `</body>` from the back (the last few bytes) — and assembled ONCE from slices:
+ * `head + head_inject + middle + body_inject + rest`. V8 keeps `slice` results and `+` chains as
+ * views and ropes, so the body bytes are never copied here; Kit flattens the result once when it
+ * encodes the response. Before this, the transform ran eight to nine whole-document regex/replace
+ * passes and made four to five full copies per request (~13 MB of transient garbage on that page).
+ *
+ * Every presence check and dedupe the handle still does runs on the HEAD SLICE alone (see
+ * head-presence.ts); the csr fact is a build-time route fact (context.ts), not a scan.
+ */
+export interface DocumentSpans {
+  /** Index of `</head>` (-1 when this chunk has none — a streamed body chunk). */
+  head_end: number;
+  /** Index of the LAST `</body>` (-1 when this chunk has none — a streamed head/middle chunk). */
+  body_end: number;
+}
+/** The two injection points, each found with one bounded scan. */
+export declare function locate(html: string): DocumentSpans;
+/**
+ * Put `head_inject` before `</head>` and `body_inject` before `</body>`, replacing the head slice
+ * with `head` when the caller rewrote it (the deduped head; `null` = unchanged). A missing
+ * injection point drops that injection (a streamed chunk without `</body>` gets no body work).
+ * Returns `html` itself when there is nothing to do.
+ */
+export declare function assemble(html: string, { head_end, body_end }: DocumentSpans, head: string | null, head_inject: string, body_inject: string): string;

package/dist/server/document-assembly.js

@@ -0,0 +1,26 @@
+// src/server/document-assembly.ts
+const HEAD_CLOSE = "</head>";
+const BODY_CLOSE = "</body>";
+/** The two injection points, each found with one bounded scan. */
+function locate(html) {
+	return {
+		head_end: html.indexOf(HEAD_CLOSE),
+		body_end: html.lastIndexOf(BODY_CLOSE)
+	};
+}
+/**
+* Put `head_inject` before `</head>` and `body_inject` before `</body>`, replacing the head slice
+* with `head` when the caller rewrote it (the deduped head; `null` = unchanged). A missing
+* injection point drops that injection (a streamed chunk without `</body>` gets no body work).
+* Returns `html` itself when there is nothing to do.
+*/
+function assemble(html, { head_end, body_end }, head, head_inject, body_inject) {
+	const has_head = head_end !== -1 && (head !== null || head_inject !== "");
+	const has_body = body_end !== -1 && body_inject !== "";
+	if (!has_head && !has_body) return html;
+	if (!has_head) return html.slice(0, body_end) + body_inject + html.slice(body_end);
+	const front = (head ?? html.slice(0, head_end)) + head_inject;
+	if (!has_body) return front + html.slice(head_end);
+	return front + html.slice(head_end, body_end) + body_inject + html.slice(body_end);
+}
+export { assemble, locate };