@ogygia/core 0.12.2 → 0.13.0

package/dist/runtime/parse-html.js

@@ -14,21 +14,40 @@
 * swap-then-blank-then-paint flicker). "Unsafe" means only "no sanitizer"; a region body is our own
 * signed, same-origin SSR (HOLE-TRUST), so it is exactly as trusted as the page itself.
 *
-* NOTE the parse happens in a `<template>`'s inert content, so custom elements do NOT upgrade here
-* (no `connectedCallback`) — attaching a declarative shadow root is a parse step, not an upgrade. That
-* is what `repair_if_drifted` needs: the server copy stays inert, but its light-DOM sequence is now
-* DSD-consistent with a live region whose hosts already carry shadow roots.
+* INERT BY CONSTRUCTION (#382). The parse runs in a document with no browsing context (one per
+* runtime, made on first use): it has no custom element registry, so nothing in the answer is built
+* by a component's constructor before the restore (./restore.ts) puts it in shape, in any engine.
+* A page-owned `<template>` was inert by a browser detail only: Firefox 159 (scoped registries)
+* builds custom elements while one parses with `setHTMLUnsafe`, so a host had its constructor's
+* root before the restore reached it. Attaching a declarative shadow root is a parse step, not an
+* upgrade: it still happens here. The fragment's nodes belong to that document until they are
+* inserted (insertion adopts them; they upgrade at connect, constructor then `connectedCallback`,
+* a declarative root kept). `repair_if_drifted` needs this too: the server copy stays inert, and its
+* light-DOM sequence is DSD-consistent with a live region whose hosts already carry shadow roots.
+*
+* (`Document.parseHTMLUnsafe` would also parse without a registry, but makes a whole document per
+* call; one shared document and its template is the cheaper of the two.)
+*
+* In dev and e2e every parse is checked (`rule_parse_upgraded`, ./rules.ts): nothing built.
 */
 function parse_region_html(html) {
-	const tpl = document.createElement("template");
+	const tpl = inert_document().createElement("template");
 	const set_html_unsafe = tpl.setHTMLUnsafe;
 	if (typeof set_html_unsafe === "function") set_html_unsafe.call(tpl, html);
 	else {
 		tpl.innerHTML = html;
 		attach_declarative_shadows(tpl.content);
 	}
+	globalThis.__og_parsed?.(tpl.content);
 	return tpl.content;
 }
+let inert = null;
+/** The runtime's one document with no browsing context, made on first use. (A DOM with no
+*  `document.implementation`, a server-side DOM a bench runs on, parses in the page's own: it has
+*  no custom elements to build.) */
+function inert_document() {
+	return inert ??= typeof document.implementation?.createHTMLDocument === "function" ? document.implementation.createHTMLDocument("") : document;
+}
 /** The spec's declarative-shadow-DOM attach step, for engines that render DSD on first parse but predate
 *  `setHTMLUnsafe`. Recurse into each shadow we attach: `querySelectorAll` stops at shadow boundaries,
 *  and a `<template shadowrootmode>` can nest inside another. First template per host wins (a host already

package/dist/runtime/pushable-props.svelte.d.ts

@@ -0,0 +1,21 @@
+/**
+ * PUSHABLE PROPS: the props a mounted island reads reactively, so the next value reaches it in
+ * place instead of a re-hydrate — a live region's next tick, a kept island's next page. The island
+ * is hydrated with `props` itself (Svelte's documented reactive-props form for `hydrate`), so
+ * focus and local state survive and Svelte reconciles the view. Filled into the `Pushable` slot by
+ * the live feature (./live.ts); a page with neither live nor kept regions never loads it.
+ *
+ * The props are a snapshot of data, as every island's are: held RAW (`$state.raw`), never deep-proxied
+ * — the island reads the very values pushed (a large nav tree pays no proxy on each read, identity
+ * holds, `structuredClone` works), and mutating one is no more reactive than in any other island. A
+ * push replaces the whole snapshot; `props` is a plain reader over the current one, so each prop read
+ * tracks it.
+ */
+export declare class PushableProps {
+  #private;
+  /** What the island is hydrated with: the current snapshot's props, read live. */
+  readonly props: Record<string, unknown>;
+  constructor(initial: Record<string, unknown>);
+  /** The next snapshot (a live tick, the next page's props): replaces the current one whole. */
+  push(next: Record<string, unknown>): void;
+}

package/dist/runtime/pushable-props.svelte.js

@@ -0,0 +1,37 @@
+// src/runtime/pushable-props.svelte.ts
+/**
+* PUSHABLE PROPS: the props a mounted island reads reactively, so the next value reaches it in
+* place instead of a re-hydrate — a live region's next tick, a kept island's next page. The island
+* is hydrated with `props` itself (Svelte's documented reactive-props form for `hydrate`), so
+* focus and local state survive and Svelte reconciles the view. Filled into the `Pushable` slot by
+* the live feature (./live.ts); a page with neither live nor kept regions never loads it.
+*
+* The props are a snapshot of data, as every island's are: held RAW (`$state.raw`), never deep-proxied
+* — the island reads the very values pushed (a large nav tree pays no proxy on each read, identity
+* holds, `structuredClone` works), and mutating one is no more reactive than in any other island. A
+* push replaces the whole snapshot; `props` is a plain reader over the current one, so each prop read
+* tracks it.
+*/
+var PushableProps = class {
+	#current = $state.raw({});
+	/** What the island is hydrated with: the current snapshot's props, read live. */
+	props;
+	constructor(initial) {
+		this.#current = initial;
+		this.props = new Proxy({}, {
+			get: (_, key) => typeof key === "string" ? this.#current[key] : void 0,
+			has: (_, key) => key in this.#current,
+			ownKeys: () => Reflect.ownKeys(this.#current),
+			getOwnPropertyDescriptor: (_, key) => key in this.#current ? {
+				enumerable: true,
+				configurable: true,
+				value: this.#current[key]
+			} : void 0
+		});
+	}
+	/** The next snapshot (a live tick, the next page's props): replaces the current one whole. */
+	push(next) {
+		this.#current = next;
+	}
+};
+export { PushableProps };

package/dist/runtime/region-endpoint-url.js

@@ -1,6 +1,7 @@
 import { preload_island_graph } from "./island-graph-preload.js";
-import { fetch_priority_of, load_slot } from "./load-scheduler.js";
+import { LoadSlot, fetch_priority_of } from "./load-scheduler.js";
 import { entry_location } from "./entry-locations.js";
+import { import_file } from "./import-again.js";
 // src/runtime/region-endpoint-url.ts
 /** Hoisted (hot paths — connectedCallback/hydrate run per region); shared with core's
 *  foreign-origin checks. */
@@ -147,16 +148,13 @@ function warm_island_module(entry, base, cls = "speculative") {
 	const key = warm_key(url);
 	if (warmed_modules.has(key)) return;
 	warmed_modules.add(key);
-	load_slot({
+	new LoadSlot({
 		kind: "code",
 		cls,
 		label: entry
 	}).ready.then((release) => {
 		preload_island_graph(entry, base, fetch_priority_of(cls));
-		import(
-			/* @vite-ignore */
-			url
-).catch(() => {
+		import_file(url).catch(() => {
 			warmed_modules.delete(key);
 		}).finally(release);
 	});

package/dist/runtime/region-machines.d.ts

@@ -0,0 +1,111 @@
+import { IslandHandle } from "./hydrate-core.js";
+import { Machine } from "@ogygia/machine";
+type HoleStates = {
+  /** Not asked yet, or its fetch ended (answered, or torn down). */
+  idle: {};
+  /** Its `when` (and `prefetch`) schedule is armed. `attempts`: the fetches that failed before. */
+  armed: {
+    attempts: number;
+  };
+  /** Its own fetch is in flight. `revalidate`: past the browser cache (a refresh). */
+  fetching: {
+    attempts: number;
+    revalidate: boolean;
+  };
+  /** A fetch failed, and it waits to try again. */
+  retrying: {
+    attempts: number;
+    revalidate: boolean;
+  };
+  /** It gave up: refused, or out of tries. The fallback (or the answer before) stands. */
+  failed: {};
+};
+declare const hole_steps: {
+  readonly idle: readonly ["armed", "fetching"];
+  readonly armed: readonly ["idle", "fetching"];
+  readonly fetching: readonly ["idle", "retrying", "failed"];
+  readonly retrying: readonly ["idle", "armed", "fetching", "failed"];
+  readonly failed: readonly ["idle", "armed", "fetching"];
+};
+export type Hole = Machine<HoleStates, typeof hole_steps>;
+/** A hole's fetch machine, idle. */
+export declare function create_hole(): Hole;
+type AnswerStates = {
+  /** Nothing from the hole is on screen: its fallback. */
+  none: {};
+  /** An answer is swapped in. */
+  answered: {};
+  /** It answered `keepFallback()`: the fallback stands as its answer. */
+  kept: {};
+};
+declare const answer_steps: {
+  readonly none: readonly ["answered", "kept"];
+  readonly answered: readonly ["kept"];
+  readonly kept: readonly ["answered"];
+};
+export type Answer = Machine<AnswerStates, typeof answer_steps>;
+/** A hole's answer machine: nothing on screen yet. */
+export declare function create_answer(): Answer;
+type WakeStates = {
+  /** Asleep, nothing armed. */
+  cold: {};
+  /** Its schedule (and the capture of early input) is armed. */
+  armed: {};
+  /** Its module and the hydrate core load; then its hydrate step. */
+  waking: {};
+  /** Hydrated: the island is live. */
+  awake: {};
+  /** Hydrating threw: its server markup stays as it is. */
+  failed: {
+    error: unknown;
+  };
+};
+declare const wake_steps: {
+  readonly cold: readonly ["armed", "waking"];
+  readonly armed: readonly ["cold", "waking"];
+  readonly waking: readonly ["cold", "awake", "failed"];
+  readonly awake: readonly ["cold"];
+  readonly failed: readonly ["cold"];
+};
+export type Wake = Machine<WakeStates, typeof wake_steps>;
+/** An island's wake machine, cold. */
+export declare function create_wake(): Wake;
+type LiveStates = {
+  /** No tick yet, or its island could not hydrate (the next tick starts over). */
+  idle: {};
+  /** A static region: the frame store's frames morph into it (it is subscribed while here). */
+  static: {};
+  /** An interactive tick's HTML is in; its island loads and hydrates. */
+  hydrating: {
+    module: string;
+  };
+  /** Its island is live: a tick of the same module pushes props. Leaving disposes it. */
+  live: {
+    module: string;
+    app: IslandHandle;
+  };
+};
+declare const live_steps: {
+  readonly idle: readonly ["static", "hydrating"];
+  readonly static: readonly ["idle", "hydrating"];
+  readonly hydrating: readonly ["idle", "static", "hydrating", "live"];
+  readonly live: readonly ["idle", "static", "hydrating"];
+};
+export type Live = Machine<LiveStates, typeof live_steps>;
+/** A live region's machine, before its first tick. */
+export declare function create_live(): Live;
+type PaintStates = {
+  /** No frame is waiting to paint. */
+  idle: {};
+  /** A frame waits for its stylesheets, then paints. A newer frame is a new visit: the older one's
+   *  wait ends with nothing painted. */
+  painting: {};
+};
+declare const paint_steps: {
+  readonly idle: readonly ["painting"];
+  readonly painting: readonly ["painting", "idle"];
+};
+export type Paint = Machine<PaintStates, typeof paint_steps>;
+/** A region's paint machine: which frame (a hole's answer, a static live tick) paints next. */
+export declare function create_paint(): Paint;
+export {};

package/dist/runtime/region-machines.js

@@ -0,0 +1,97 @@
+import { machine } from "@ogygia/machine";
+const hole_definition = machine()({
+	name: "hole",
+	initial: "idle",
+	steps: {
+		idle: ["armed", "fetching"],
+		armed: ["idle", "fetching"],
+		fetching: [
+			"idle",
+			"retrying",
+			"failed"
+		],
+		retrying: [
+			"idle",
+			"armed",
+			"fetching",
+			"failed"
+		],
+		failed: [
+			"idle",
+			"armed",
+			"fetching"
+		]
+	}
+});
+/** A hole's fetch machine, idle. */
+function create_hole() {
+	return hole_definition.create();
+}
+const answer_definition = machine()({
+	name: "hole-answer",
+	initial: "none",
+	steps: {
+		none: ["answered", "kept"],
+		answered: ["kept"],
+		kept: ["answered"]
+	}
+});
+/** A hole's answer machine: nothing on screen yet. */
+function create_answer() {
+	return answer_definition.create();
+}
+const wake_definition = machine()({
+	name: "wake",
+	initial: "cold",
+	steps: {
+		cold: ["armed", "waking"],
+		armed: ["cold", "waking"],
+		waking: [
+			"cold",
+			"awake",
+			"failed"
+		],
+		awake: ["cold"],
+		failed: ["cold"]
+	}
+});
+/** An island's wake machine, cold. */
+function create_wake() {
+	return wake_definition.create();
+}
+const live_definition = machine()({
+	name: "live-region",
+	initial: "idle",
+	steps: {
+		idle: ["static", "hydrating"],
+		static: ["idle", "hydrating"],
+		hydrating: [
+			"idle",
+			"static",
+			"hydrating",
+			"live"
+		],
+		live: [
+			"idle",
+			"static",
+			"hydrating"
+		]
+	}
+});
+/** A live region's machine, before its first tick. */
+function create_live() {
+	return live_definition.create();
+}
+const paint_definition = machine()({
+	name: "region-paint",
+	initial: "idle",
+	steps: {
+		idle: ["painting"],
+		painting: ["painting", "idle"]
+	}
+});
+/** A region's paint machine: which frame (a hole's answer, a static live tick) paints next. */
+function create_paint() {
+	return paint_definition.create();
+}
+export { create_answer, create_hole, create_live, create_paint, create_wake };

package/dist/runtime/region-sheets.d.ts

@@ -0,0 +1,31 @@
+import { Machine } from "@ogygia/machine";
+type SheetStates = {
+  /** Its download is in flight. */
+  loading: {};
+  /** In, and styling the page. */
+  loaded: {};
+  /** Its download failed. It stays failed: a fresh link asks again. */
+  failed: {};
+};
+declare const sheet_steps: {
+  readonly loading: readonly ["loaded", "failed"];
+  readonly loaded: readonly [];
+  readonly failed: readonly [];
+};
+export type RegionSheet = Machine<SheetStates, typeof sheet_steps>;
+/**
+ * The download of a stylesheet link, watched from the first time an answer looks at it. A link made
+ * here is watched before it goes into the head, so it never misses its `load` or `error`. One that was
+ * there first (the server's) counts as loaded once it has a `sheet`; one with no `sheet` yet is still
+ * loading. (Chromium gives a failed link an empty sheet, so a server link that failed before anyone
+ * looked counts as loaded: the page's own sheets are the page's.)
+ */
+export declare function sheet_of(link: HTMLLinkElement): RegionSheet;
+/** `region` painted an answer that uses `sheets` (in place of the ones its answer before used). */
+export declare function use_sheets(region: Element, sheets: readonly Element[]): void;
+/**
+ * After a navigation's swap: of the region sheets the new page's head does not list (`unlisted`),
+ * take out each one no region on the page uses any more.
+ */
+export declare function release_sheets(unlisted: readonly Element[]): void;
+export {};

package/dist/runtime/region-sheets.js

@@ -0,0 +1,49 @@
+import { connected_regions } from "./connected.js";
+import { machine } from "@ogygia/machine";
+const sheet_definition = machine()({
+	name: "region-sheet",
+	initial: "loading",
+	steps: {
+		loading: ["loaded", "failed"],
+		loaded: [],
+		failed: []
+	}
+});
+const sheets = /* @__PURE__ */ new WeakMap();
+/**
+* The download of a stylesheet link, watched from the first time an answer looks at it. A link made
+* here is watched before it goes into the head, so it never misses its `load` or `error`. One that was
+* there first (the server's) counts as loaded once it has a `sheet`; one with no `sheet` yet is still
+* loading. (Chromium gives a failed link an empty sheet, so a server link that failed before anyone
+* looked counts as loaded: the page's own sheets are the page's.)
+*/
+function sheet_of(link) {
+	const known = sheets.get(link);
+	if (known !== void 0) return known;
+	const s = sheet_definition.create();
+	sheets.set(link, s);
+	s.scope.on(link, "load", () => s.go("loaded"));
+	s.scope.on(link, "error", () => s.go("failed"));
+	if (link.sheet !== null) s.go("loaded");
+	return s;
+}
+/** The sheets in the head each region's answer on screen uses, by region. */
+const used_by = /* @__PURE__ */ new WeakMap();
+/** `region` painted an answer that uses `sheets` (in place of the ones its answer before used). */
+function use_sheets(region, sheets) {
+	used_by.set(region, sheets);
+}
+/**
+* After a navigation's swap: of the region sheets the new page's head does not list (`unlisted`),
+* take out each one no region on the page uses any more.
+*/
+function release_sheets(unlisted) {
+	if (unlisted.length === 0) return;
+	const used = /* @__PURE__ */ new Set();
+	for (const region of connected_regions) {
+		const sheets = used_by.get(region);
+		if (sheets !== void 0) for (const s of sheets) used.add(s);
+	}
+	for (const s of unlisted) if (!used.has(s)) s.remove();
+}
+export { release_sheets, sheet_of, use_sheets };

package/dist/runtime/restore-report.d.ts

@@ -0,0 +1 @@
+export declare function report_restores(): void;

package/dist/runtime/restore-report.js

@@ -0,0 +1,36 @@
+import { OgygiaError, warn } from "../messages/core.js";
+// src/runtime/restore-report.ts
+/**
+* SAY WHAT THE RESTORER RECORDED. The restorer (./restore.ts) runs inlined as text, self-contained,
+* so it prints nothing itself: it records each mismatch on `window.__og_restore_log` (the devtools
+* and the beacon read it too). The boot reports what the document's own run recorded, and wraps
+* `window.__og_restore` so every later run — a hole answer, a router swap — reports its own.
+*/
+let reported = 0;
+/** The element names a late restore was said for on this page (once each). */
+const late_said = /* @__PURE__ */ new Set();
+function report() {
+	const log = window.__og_restore_log;
+	if (!log) return;
+	if (reported > log.length) reported = 0;
+	for (; reported < log.length; reported++) {
+		const entry = log[reported];
+		if (entry.kind === "mismatch" && entry.diff) console.error(new OgygiaError("restore_markup_broken", { diff: entry.diff }));
+		else if (entry.kind === "late" && entry.host && !late_said.has(entry.host)) {
+			late_said.add(entry.host);
+			warn("restore_late", { host: entry.host });
+		}
+	}
+}
+function report_restores() {
+	if (typeof window === "undefined") return;
+	const w = window;
+	const run = w.__og_restore;
+	if (run) w.__og_restore = (root) => {
+		const restored = run(root);
+		report();
+		return restored;
+	};
+	report();
+}
+export { report_restores };

package/dist/runtime/restore.d.ts

@@ -19,8 +19,11 @@
  * insertion and on an incoming page before a router swap.
  *
  * A host that already has a shadow root when it is reached was upgraded first — the restore came
- * too late. It is left as served and reported (`ogygia:restore-late` on the host), never restored into
- * a root the component's own constructor made (that tree would render twice).
+ * too late. The root is the component's own and is left to it; the light DOM still goes back to
+ * Svelte's form, and the server's rendered copy is dropped (slotted beside the component's own
+ * render it would show twice). It is reported (`ogygia:restore-late` on the host, the log, and
+ * `restore_late` in every build). Answers are parsed inert (./parse-html.ts, #382), so this is the
+ * page-load case: a component runtime that upgraded first.
  */
 export declare function restore(root: Document | DocumentFragment | Element): number;
 /** Adopt the sheets of roots restored outside the page, now that their hosts are in it (after a hole

package/dist/runtime/restore.js

@@ -20,8 +20,11 @@
 * insertion and on an incoming page before a router swap.
 *
 * A host that already has a shadow root when it is reached was upgraded first — the restore came
-* too late. It is left as served and reported (`ogygia:restore-late` on the host), never restored into
-* a root the component's own constructor made (that tree would render twice).
+* too late. The root is the component's own and is left to it; the light DOM still goes back to
+* Svelte's form, and the server's rendered copy is dropped (slotted beside the component's own
+* render it would show twice). It is reported (`ogygia:restore-late` on the host, the log, and
+* `restore_late` in every build). Answers are parsed inert (./parse-html.ts, #382), so this is the
+* page-load case: a component runtime that upgraded first.
 */
 function restore(root) {
 	const doc = root.ownerDocument ?? root;
@@ -39,7 +42,9 @@ function restore(root) {
 	* every token it dropped (the component's, the render's `sc-*`), read from the value just before
 	* that write. A component only ever adds and removes its own tokens, so no later state of the
 	* host equals Svelte's alone. One observer for all of them; a host leaves the watch at that
-	* write, and the observer goes when the last one has.
+	* write, or when it leaves the document (Kit dropped it and mounted another: no write is coming;
+	* a host moved in one task is back in by the time the observer hears of it), and the observer
+	* goes when the last one has.
 	*/
 	const watch_classes = live && document.querySelector("meta[name=\"ogygia-csr\"][content=\"true\"]") !== null;
 	const watch = (el) => {
@@ -47,22 +52,34 @@ function restore(root) {
 		if (!w) {
 			const hosts = /* @__PURE__ */ new Set();
 			const mo = new MutationObserver((records) => {
+				let removed = false;
 				for (let i = 0; i < records.length; i++) {
+					if (records[i].type === "childList") {
+						if (records[i].removedNodes.length) removed = true;
+						continue;
+					}
 					const host = records[i].target;
 					if (!hosts.has(host)) continue;
 					let now;
-					for (let j = i + 1; j < records.length && now === void 0; j++) if (records[j].target === host) now = records[j].oldValue;
+					for (let j = i + 1; j < records.length && now === void 0; j++) if (records[j].target === host && records[j].type === "attributes") now = records[j].oldValue;
 					if (now === void 0) now = host.getAttribute("class");
 					if ((now ?? "") !== host.__og_svelte_class) continue;
 					hosts.delete(host);
 					const own = new Set((now ?? "").split(" "));
 					for (const t of (records[i].oldValue ?? "").split(" ")) if (t && !own.has(t)) host.classList.add(t);
 				}
+				if (removed) {
+					for (const host of hosts) if (!host.isConnected) hosts.delete(host);
+				}
 				if (hosts.size === 0) {
 					mo.disconnect();
 					W.__og_class_watch = void 0;
 				}
 			});
+			mo.observe(document, {
+				childList: true,
+				subtree: true
+			});
 			w = W.__og_class_watch = {
 				mo,
 				hosts
@@ -237,7 +254,6 @@ function restore(root) {
 		tpl.innerHTML = want;
 		const diff = differ(tpl.content, host, `<${host.localName}>`);
 		if (!diff) return;
-		console.error(`[ogygia] the transform broke hydration markup: ${diff}`);
 		host.dispatchEvent(new CustomEvent("ogygia:restore-mismatch", {
 			bubbles: true,
 			detail: {
@@ -276,19 +292,19 @@ function restore(root) {
 		const host = hosts[x];
 		const k = host.getAttribute("og-h");
 		const keys = (host.getAttribute("og-shadow") ?? "").split(" ").filter(Boolean);
-		if (host.shadowRoot) {
+		const late = host.shadowRoot !== null;
+		const shadow = late ? null : host.attachShadow({ mode: "open" });
+		if (late) {
 			host.dispatchEvent(new CustomEvent("ogygia:restore-late", {
 				bubbles: true,
 				detail: { host: k }
 			}));
 			log("late", host);
-			continue;
 		}
-		const shadow = host.attachShadow({ mode: "open" });
-		if (!live) (W.__og_init ??= []).push(shadow);
+		if (shadow && !live) (W.__og_init ??= []).push(shadow);
 		const own = [];
-		const adoptable = Array.isArray(shadow.adoptedStyleSheets);
-		for (const key of keys) {
+		const adoptable = shadow !== null && Array.isArray(shadow.adoptedStyleSheets);
+		if (shadow) for (const key of keys) {
 			const s = sheet_for(key);
 			if (!s) continue;
 			if (s.sheet && adoptable) own.push(s.sheet);
@@ -298,7 +314,7 @@ function restore(root) {
 				shadow.appendChild(style);
 			}
 		}
-		if (own.length) {
+		if (shadow && own.length) {
 			if (live) shadow.adoptedStyleSheets = [...shadow.adoptedStyleSheets, ...own];
 			else {
 				shadow.__og_pending = own;
@@ -330,7 +346,10 @@ function restore(root) {
 		}
 		children.sort((a, b) => a.i - b.i);
 		const mine = new Set(children.map((c) => c.node));
-		for (const n of Array.from(host.childNodes)) if (!mine.has(n)) shadow.appendChild(n);
+		for (const n of Array.from(host.childNodes)) if (!mine.has(n)) {
+			if (shadow) shadow.appendChild(n);
+			else n.remove();
+		}
 		const made = W.__og_rendered ??= /* @__PURE__ */ new WeakSet();
 		for (const c of children) {
 			host.appendChild(c.node);
@@ -347,7 +366,7 @@ function restore(root) {
 		host.removeAttribute("og-shadow");
 		host.removeAttribute("og-keep");
 		verify(host, k);
-		restored++;
+		if (!late) restored++;
 	}
 	return restored;
 }