@ogygia/core 0.0.0 → 0.11.0

package/dist/runtime/morph.js

@@ -0,0 +1,671 @@
+import { slots } from "./slots.js";
+import { REGION_RENDER_ATTRS, attributes_writer, is_declared_foreign, is_region_owned, is_self_owned, mark_render_made, order_owner, owner_of, render_made, slots_light_dom } from "./ownership.js";
+// src/runtime/morph.ts
+/**
+* # DOM morphing — reconcile a live element toward a freshly rendered region IN PLACE
+*
+* Live/held regions (`<ogygia-region live>`, `query.live` ticks, single-flight mutations) push new
+* server-rendered HTML every frame. Instead of tearing the old subtree down and rebuilding it, this
+* walks the OLD DOM and the NEW nodes together in a single pass and mutates the old tree the minimum
+* amount to reach the new shape. Nodes that can be reused keep their identity, so the browser keeps
+* focus, text selection, scroll position, typed-in form state, and running CSS transitions — the
+* LiveView "the page breathes" property.
+*
+* Inspired by natemoo-re/micromorph and idiomorph, trimmed to what ogygia needs and hardened with
+* real **keyed** matching (micromorph is index-aligned for body children).
+*
+* ## Algorithm (one pass, minimal allocations)
+* `morph_children(parent, new_nodes)` reconciles `parent`'s existing children toward `new_nodes`:
+*  1. Index the old children that carry a **key** (`data-key`, else `id`) into a map.
+*  2. Walk `new_nodes` left-to-right against a cursor over the old children:
+*     - **Keyed hit** — a new node's key matches an old node anywhere: move that old node into
+*       position and morph it. Reorders / inserts / removals morph in place instead of cascading
+*       replacements down the list.
+*     - **Id-set hit** — a key-less new element wants keys that a key-less old sibling holds (see
+*       "Wrapper matching" below): move that old sibling into position and morph it.
+*     - **Positional hit** — cursor node is compatible (same node kind + tag, both key-less): morph
+*       it and advance. Old keyed nodes reserved for a later key are skipped, never consumed here.
+*     - **Miss** — insert a fresh copy of the new node before the cursor.
+*  3. Remove every old node left unclaimed (trailing key-less nodes + unmatched keyed nodes).
+*
+* `morph_node(from, to)` reconciles one node against one node:
+*  - Text / comment: copy `nodeValue` in place.
+*  - Element, different tag or namespace: **replace** (`from` cannot become `to`).
+*  - Element, same tag: sync attributes, sync form DOM properties, recurse into children.
+*
+* ## State-preservation guarantees
+*  - **Identity** — a node that can be morphed is never replaced, so focus / selection / scroll /
+*    transitions on it and its subtree survive.
+*  - **Form state follows the server only when the server changed its mind** — the `value` /
+*    `checked` / `selected` PROPERTIES move only when the matching ATTRIBUTE differs between the
+*    previous render and the incoming one. A tick that re-sends the same default leaves what the
+*    user typed or toggled alone, focused or not (the browser's own dirty-value rule; htmx 4's morph
+*    rule). The control that currently holds focus is never touched at all, so mid-edit text and its
+*    selection survive even a changed default.
+*  - **Preserved subtrees** — an element marked `data-persist`, or a hydrated island root
+*    (`data-hydrated`), is kept exactly as-is: matched by key/position but never re-synced or
+*    recursed into. Islands own their DOM through Svelte reactivity (props push), not morphing, so
+*    this stops a live tick from re-creating a hydrated island root (the "hero bounce" reflow).
+*
+* ## Wrapper matching (id sets)
+* A key-less wrapper is matched by the keys INSIDE it (idiomorph's "id sets"). Before a pass, every
+* keyed descendant registers its key on each ancestor up to the morph root, on both trees. Two
+* key-less same-tag siblings then stay in lockstep only when their sets agree: both empty, or they
+* share a key (the same wrapper, re-rendered). Otherwise the remainder goes to the keyed phase, which
+* MOVES the old sibling holding the wanted keys into place — a banner appearing above an island's
+* wrapper no longer re-mounts the island — and refuses to consume an old wrapper a LATER new sibling
+* wants. When nothing better exists the match is positional, exactly as before; a tree with no keys
+* at all skips the whole mechanism.
+*
+* ## Namespaces
+* Clones are made with `importNode`, which carries the source namespace, so SVG / `foreignObject`
+* subtrees are created with the correct namespace. The morph-vs-replace test compares `namespaceURI`
+* as well as `tagName`, so an HTML `<a>` is never morphed into an SVG `<a>`.
+*/
+const ELEMENT = 1;
+const TEXT = 3;
+const COMMENT = 8;
+const FOLLOWING = 4;
+/** Feature entry: fill the `morph` slot (live static-region ticks morph in place). */
+function install() {
+	slots.morph = morph_children;
+	slots.sync_attributes = sync_attributes;
+}
+/**
+* Reconcile `parent`'s children toward `new_nodes` (a freshly parsed, detached region). Public slot
+* shape: `(parent: Element, nodes: Node[]) => void` — a drop-in for the previous implementation.
+*
+* `new_nodes` is read but never mutated, so the recursion passes the incoming element's live
+* `childNodes` straight through (see {@link morph_node}) — no per-level array snapshot. Accessed by
+* index, so both a real `Array` (the top-level region) and a live `NodeList` (recursion) fit.
+*
+* Two phases:
+*  1. **Lockstep** — walk old and new in parallel while their keys agree (both `null` and compatible,
+*     or the same non-null key), morphing in place. This is the dominant tick (same structure, values
+*     changed) and it allocates NOTHING — no key map, no cursor bookkeeping. Reorders/inserts/removals
+*     break the lockstep at the first divergence and hand the REMAINDER to phase 2.
+*  2. **Keyed reconcile** — the general move/insert/remove algorithm, run only on the still-unmatched
+*     tail. The key map indexes just the remaining old children, so a change late in a long list still
+*     skips indexing the aligned prefix.
+*/
+function morph_children(parent, new_nodes, options) {
+	const walk = options?.target === "walk";
+	if (is_declared_foreign(parent)) return;
+	if (walk) {
+		const owner = owner_of(parent);
+		if (owner !== "walk" && owner !== "region") return;
+	}
+	reconcile(parent, new_nodes, build_id_sets(parent, new_nodes), walk);
+	clear_aria_hidden_over_focus(parent);
+}
+/**
+* WAI-ARIA safety net, run once after a morph settles: `aria-hidden="true"` must never sit on an
+* ancestor of the focused element — the browser blocks it and the interaction dies (an on-demand
+* dropdown, focused by the waking click, never opens because the morph stamped the region's fetched
+* closed state onto its container). aria-hidden reaches the focused subtree two ways: an in-place
+* attribute sync (guarded in {@link sync_attributes}) OR a freshly cloned/inserted subtree — importNode
+* copies attributes wholesale, with no guard, which is the path a REPLACED container takes. So the guard
+* alone was not enough. This sweep strips `aria-hidden="true"` from the focused element's ancestor chain
+* up to (and including) the morph root, covering both paths. A no-op unless focus lives inside `parent`.
+*/
+function clear_aria_hidden_over_focus(parent) {
+	const doc = owner_document(parent);
+	const active = doc.activeElement;
+	if (active == null || active === doc.body || !parent.contains(active)) return;
+	let n = active;
+	while (n) {
+		if (n.getAttribute("aria-hidden") === "true") n.removeAttribute("aria-hidden");
+		if (n === parent) break;
+		n = n.parentElement;
+	}
+}
+const KEYED_SELECTOR = "[data-key],[id]";
+function build_id_sets(parent, new_nodes) {
+	let sets = null;
+	const register = (key, start, stop) => {
+		for (let a = start; a !== null && a !== stop && a.nodeType === ELEMENT; a = a.parentNode) {
+			let set = (sets ??= /* @__PURE__ */ new WeakMap()).get(a);
+			if (set === void 0) sets.set(a, set = /* @__PURE__ */ new Set());
+			set.add(key);
+		}
+	};
+	for (const el of parent.querySelectorAll(KEYED_SELECTOR)) {
+		const k = key_of(el);
+		if (k !== null) register(k, el.parentNode, parent);
+	}
+	const count = new_nodes.length;
+	for (let i = 0; i < count; i++) {
+		const root = new_nodes[i];
+		if (root.nodeType !== ELEMENT) continue;
+		for (const el of root.querySelectorAll(KEYED_SELECTOR)) {
+			const k = key_of(el);
+			if (k !== null) register(k, el.parentNode, root.parentNode);
+		}
+	}
+	return sets;
+}
+/** Lockstep test for two key-less siblings: neither holds a key (nothing to protect), or they share
+*  one (the same wrapper, re-rendered). Anything else breaks lockstep so phase 2 can look around. */
+function id_sets_agree(sets, a, b) {
+	if (a.nodeType !== ELEMENT) return true;
+	const sa = sets.get(a);
+	const sb = sets.get(b);
+	if (sa === void 0) return sb === void 0;
+	if (sb === void 0) return false;
+	return intersects(sa, sb);
+}
+function intersects(a, b) {
+	if (a.size > b.size) [a, b] = [b, a];
+	for (const k of a) if (b.has(k)) return true;
+	return false;
+}
+/** The first remaining key-less old sibling that holds one of `wanted` and can become `next`. */
+function find_holder(old_inner, wanted, next) {
+	for (const key of wanted) {
+		const holder = old_inner.get(key);
+		if (holder !== void 0 && same_node(holder, next)) return holder;
+	}
+	return null;
+}
+/** `el` is consumed: it no longer holds anything for a later new sibling. */
+function release_holder(old_inner, sets, el) {
+	const held = sets.get(el);
+	if (held === void 0) return;
+	for (const key of held) if (old_inner.get(key) === el) old_inner.delete(key);
+}
+/** Does a new sibling AFTER `idx` want a key that `cursor` holds? Then `cursor` is spoken for. */
+function reserved_for_later(sets, new_inner, cursor, idx) {
+	if (new_inner === null) return false;
+	const held = sets.get(cursor);
+	if (held === void 0) return false;
+	for (const key of held) {
+		const wanter = new_inner.get(key);
+		if (wanter !== void 0 && wanter > idx) return true;
+	}
+	return false;
+}
+/**
+* Reconcile `parent`'s children toward `new_nodes`, by whoever ORDERS them (ownership.ts
+* `order_owner`): the render's sequence by position ({@link reconcile_children}), or — under a
+* self-owned element whose own runtime arranges its light DOM — by identity
+* ({@link reconcile_by_identity}). Toward Svelte's walk, positions are always the render's (the walk
+* binds by position).
+*/
+function reconcile(parent, new_nodes, sets, walk) {
+	if (!walk && order_owner(parent) === "element") reconcile_by_identity(parent, new_nodes, sets);
+	else reconcile_children(parent, new_nodes, sets, walk);
+}
+/**
+* The render's sequence, by position.
+* @param walk the {@link MorphOptions.target} is Svelte's walk (the repair), threaded unchanged down
+* the recursion — a subtree the walk never enters is skipped.
+*/
+function reconcile_children(parent, new_nodes, sets, walk = false) {
+	const count = new_nodes.length;
+	let cursor = parent.firstChild;
+	let idx = 0;
+	while (idx < count && cursor) {
+		const next = new_nodes[idx];
+		const ck = key_of(cursor);
+		const nk = key_of(next);
+		if (ck !== nk) break;
+		if (nk === null) {
+			if (!same_node(cursor, next)) break;
+			if (sets !== null && !id_sets_agree(sets, cursor, next)) break;
+			const here = cursor;
+			cursor = cursor.nextSibling;
+			morph_same(here, next, sets, walk);
+		} else {
+			const here = cursor;
+			cursor = cursor.nextSibling;
+			morph_node(here, next, sets, walk);
+		}
+		idx++;
+	}
+	if (idx >= count) {
+		while (cursor) {
+			const gone = cursor;
+			cursor = cursor.nextSibling;
+			parent.removeChild(gone);
+		}
+		return;
+	}
+	if (cursor === null) {
+		for (; idx < count; idx++) parent.insertBefore(clone(new_nodes[idx]), null);
+		return;
+	}
+	let old_keys = null;
+	let old_inner = null;
+	for (let n = cursor; n; n = n.nextSibling) {
+		const k = key_of(n);
+		if (k !== null) (old_keys ??= /* @__PURE__ */ new Map()).set(k, n);
+		else if (sets !== null && n.nodeType === ELEMENT) {
+			const held = sets.get(n);
+			if (held !== void 0) {
+				old_inner ??= /* @__PURE__ */ new Map();
+				for (const key of held) if (!old_inner.has(key)) old_inner.set(key, n);
+			}
+		}
+	}
+	let new_inner = null;
+	if (old_inner !== null) for (let i = idx; i < count; i++) {
+		const n = new_nodes[i];
+		if (n.nodeType !== ELEMENT || key_of(n) !== null) continue;
+		const wanted = sets.get(n);
+		if (wanted === void 0) continue;
+		new_inner ??= /* @__PURE__ */ new Map();
+		for (const key of wanted) if (!new_inner.has(key)) new_inner.set(key, i);
+	}
+	if (old_keys === null && old_inner === null) for (; idx < count; idx++) {
+		const next = new_nodes[idx];
+		if (cursor && key_of(next) === null && same_node(cursor, next)) {
+			const here = cursor;
+			cursor = cursor.nextSibling;
+			morph_same(here, next, sets, walk);
+		} else parent.insertBefore(clone(next), cursor);
+	}
+	else for (; idx < count; idx++) {
+		const next = new_nodes[idx];
+		const next_key = key_of(next);
+		if (next_key !== null) {
+			const matched = old_keys?.get(next_key);
+			if (matched !== void 0) {
+				old_keys.delete(next_key);
+				if (matched === cursor) cursor = cursor.nextSibling;
+				else parent.insertBefore(matched, cursor);
+				morph_node(matched, next, sets, walk);
+				continue;
+			}
+		} else if (old_inner !== null && next.nodeType === ELEMENT) {
+			const wanted = sets.get(next);
+			const holder = wanted === void 0 ? null : find_holder(old_inner, wanted, next);
+			if (holder !== null) {
+				release_holder(old_inner, sets, holder);
+				if (holder === cursor) cursor = cursor.nextSibling;
+				else parent.insertBefore(holder, cursor);
+				morph_same(holder, next, sets, walk);
+				continue;
+			}
+		}
+		let cur_key = null;
+		while (cursor) {
+			cur_key = key_of(cursor);
+			if (cur_key === null || old_keys === null || !old_keys.has(cur_key)) break;
+			cursor = cursor.nextSibling;
+		}
+		if (cursor && next_key === null && cur_key === null && same_node(cursor, next) && (old_inner === null || !reserved_for_later(sets, new_inner, cursor, idx))) {
+			const here = cursor;
+			cursor = cursor.nextSibling;
+			if (old_inner !== null) release_holder(old_inner, sets, here);
+			morph_same(here, next, sets, walk);
+			continue;
+		}
+		parent.insertBefore(clone(next), cursor);
+	}
+	while (cursor) {
+		const gone = cursor;
+		cursor = cursor.nextSibling;
+		parent.removeChild(gone);
+	}
+	if (old_keys) {
+		for (const node of old_keys.values()) if (node.parentNode === parent) parent.removeChild(node);
+	}
+}
+/**
+* THE ELEMENT ORDERS ITS CHILDREN (ownership.ts §11): a self-owned element's runtime relocates and
+* wraps its light DOM, so positions are not the render's and never decide a match. Each new node
+* finds its old counterpart by identity — key, then the id-set holder, then the next render-made
+* sibling of the same tag — and is morphed IN PLACE (the element's arrangement stands; nothing
+* re-upgrades: a byte-identical answer moves no node). A new node with no counterpart goes in after the
+* last placed render node. Then EXISTENCE decides the leftovers: one the render made and no longer
+* produces is removed (a stale fallback panel beside the answer's, painting over it); one the element
+* made is never matched and never removed.
+* An element that SLOTS its light DOM (ownership.ts `slots_light_dom`) arranges nothing: the render's
+* nodes then end in the answer's order — the fewest moves, its own nodes untouched — and the render's
+* leftover block markers go (a tab the CMS moved kept its old place; one the answer added landed
+* among the wrong siblings).
+*/
+function reconcile_by_identity(parent, new_nodes, sets) {
+	const count = new_nodes.length;
+	const slotted = slots_light_dom(parent);
+	const placed_in_order = [];
+	const render_tags = /* @__PURE__ */ new Set();
+	for (let i = 0; i < count; i++) if (new_nodes[i].nodeType === ELEMENT) render_tags.add(new_nodes[i].localName);
+	let by_key = null;
+	const by_tag = /* @__PURE__ */ new Map();
+	const others = [];
+	let old_inner = null;
+	for (let n = parent.firstChild; n; n = n.nextSibling) {
+		const k = key_of(n);
+		if (k !== null) (by_key ??= /* @__PURE__ */ new Map()).set(k, n);
+		else if (n.nodeType === ELEMENT) {
+			if (!render_made(n, render_tags)) continue;
+			const el = n;
+			let list = by_tag.get(el.localName);
+			if (!list) by_tag.set(el.localName, list = []);
+			list.push(el);
+			const held = sets?.get(el);
+			if (held !== void 0) {
+				old_inner ??= /* @__PURE__ */ new Map();
+				for (const key of held) if (!old_inner.has(key)) old_inner.set(key, el);
+			}
+		} else others.push(n);
+	}
+	const claimed = /* @__PURE__ */ new Set();
+	let anchor = null;
+	let other_at = 0;
+	for (let i = 0; i < count; i++) {
+		const next = new_nodes[i];
+		let match = null;
+		if (next.nodeType === ELEMENT) {
+			const k = key_of(next);
+			if (k !== null) {
+				const keyed = by_key?.get(k);
+				if (keyed !== void 0) {
+					by_key.delete(k);
+					match = keyed;
+				}
+			} else {
+				const wanted = old_inner !== null ? sets.get(next) : void 0;
+				const holder = wanted === void 0 ? null : find_holder(old_inner, wanted, next);
+				if (holder !== null && !claimed.has(holder)) match = holder;
+				else {
+					const queue = by_tag.get(next.localName);
+					while (queue?.length && claimed.has(queue[0])) queue.shift();
+					match = queue?.shift() ?? null;
+				}
+				if (match !== null && old_inner !== null) release_holder(old_inner, sets, match);
+			}
+		} else if (next.nodeType === COMMENT) {
+			let first = null;
+			for (let j = 0; j < others.length; j++) {
+				const o = others[j];
+				if (o.nodeType !== COMMENT || claimed.has(o) || o.data !== next.data) continue;
+				if (!slotted || anchor === null || anchor.compareDocumentPosition(o) & FOLLOWING) {
+					match = o;
+					break;
+				}
+				first ??= o;
+			}
+			match ??= first;
+		} else {
+			while (other_at < others.length && (others[other_at].nodeType !== next.nodeType || claimed.has(others[other_at]))) other_at++;
+			if (other_at < others.length) match = others[other_at++];
+		}
+		if (match !== null && !claimed.has(match)) {
+			claimed.add(match);
+			const before = match.previousSibling;
+			morph_node(match, next, sets, false);
+			const placed = match.parentNode === parent ? match : before ? before.nextSibling : parent.firstChild;
+			if (placed) {
+				mark_render_made(placed);
+				anchor = placed;
+				placed_in_order.push(placed);
+			}
+			continue;
+		}
+		const copy = clone(next);
+		parent.insertBefore(copy, anchor ? anchor.nextSibling : parent.firstChild);
+		mark_render_made(copy);
+		anchor = copy;
+		placed_in_order.push(copy);
+	}
+	for (const list of by_tag.values()) for (const el of list) if (!claimed.has(el) && el.parentNode === parent) parent.removeChild(el);
+	if (by_key) {
+		for (const n of by_key.values()) if (n.parentNode === parent && render_made(n, render_tags)) parent.removeChild(n);
+	}
+	if (slotted) {
+		for (const o of others) if (!claimed.has(o) && o.parentNode === parent && is_block_marker(o)) parent.removeChild(o);
+		order_render_nodes(parent, placed_in_order);
+	}
+}
+/** Svelte's block markers: `''`, or `[`-opened (`[`, `[!`, `[0`, `[-1`, …), or `]`. */
+function is_block_marker(n) {
+	if (n.nodeType !== COMMENT) return false;
+	const d = n.data;
+	return d === "" || d === "]" || d.charCodeAt(0) === 91;
+}
+/**
+* Put the render's placed nodes (`nodes`, in the answer's order) in that order among `parent`'s
+* children, moving the fewest: the longest run already in order (longest increasing subsequence of
+* their positions) stays, every other node goes right after its predecessor in the answer. Nodes not
+* in the list — the element's own — are never moved. An answer already in order moves nothing.
+*/
+function order_render_nodes(parent, nodes) {
+	const count = nodes.length;
+	if (count < 2) return;
+	const at = /* @__PURE__ */ new Map();
+	let index = 0;
+	for (let n = parent.firstChild; n; n = n.nextSibling) at.set(n, index++);
+	const tails = [];
+	const prev = new Int32Array(count).fill(-1);
+	for (let k = 0; k < count; k++) {
+		const p = at.get(nodes[k]);
+		let lo = 0;
+		let hi = tails.length;
+		while (lo < hi) {
+			const mid = lo + hi >> 1;
+			if (at.get(nodes[tails[mid]]) < p) lo = mid + 1;
+			else hi = mid;
+		}
+		if (lo > 0) prev[k] = tails[lo - 1];
+		tails[lo] = k;
+	}
+	if (tails.length === count) return;
+	const stay = new Uint8Array(count);
+	for (let k = tails[tails.length - 1]; k >= 0; k = prev[k]) stay[k] = 1;
+	let first_stay = null;
+	for (let k = 0; k < count && first_stay === null; k++) if (stay[k]) first_stay = nodes[k];
+	let last = null;
+	for (let k = 0; k < count; k++) {
+		const n = nodes[k];
+		if (!stay[k]) {
+			const ref = last ? last.nextSibling : first_stay;
+			if (ref !== n) parent.insertBefore(n, ref);
+		}
+		last = n;
+	}
+}
+/** A kept region root's ADDRESS is the render's that minted it ({@link REGION_RENDER_ATTRS}); the rest
+*  of its attributes and all its content are the runtime's / its answer's. A re-minted hole gets its
+*  new `endpoint` and fetches there (core.ts `#renew`), its current answer on screen until then. */
+function sync_render_attributes(from, to, walk) {
+	if (walk || from.localName !== to.localName) return;
+	for (const name of REGION_RENDER_ATTRS) {
+		const next = to.getAttribute(name);
+		if (next !== null && next !== from.getAttribute(name)) from.setAttribute(name, next);
+	}
+}
+/** The attributes of `from` toward `to`, by who writes them (ownership.ts `attributes_writer`). */
+function sync_by_writer(from, to, walk) {
+	const writer = attributes_writer(from);
+	if (writer === "render") sync_attributes(from, to, is_self_owned(from));
+	else if (writer === "region") sync_render_attributes(from, to, walk);
+}
+/**
+* The morph key of a node: `data-key` (explicit), else `id`, else `null` (unkeyed → positional).
+* Uses the reflected `.id` property (a direct field read) instead of `getAttribute('id')`, and only
+* probes `data-key` — so the overwhelmingly common key-less element costs one attribute lookup.
+*/
+function key_of(node) {
+	if (node.nodeType !== ELEMENT) return null;
+	const el = node;
+	const dk = el.getAttribute("data-key");
+	if (dk !== null) return dk;
+	const id = el.id;
+	return id !== "" ? id : null;
+}
+/** Same slot for positional reuse: same node kind, and (for elements) same tag + namespace. */
+function same_node(a, b) {
+	if (a.nodeType !== b.nodeType) return false;
+	if (a.nodeType === ELEMENT) return a.tagName === b.tagName && a.namespaceURI === b.namespaceURI;
+	return true;
+}
+/**
+* May the morph ENTER `el`? (runtime/ownership.ts.) Never a declared-foreign subtree (the app's
+* `data-ogygia-keep` / `data-persist`) nor a hydrated / kept region (Svelte's reactivity owns it); and
+* toward Svelte's walk, never a subtree the walk does not read (`data-og-opaque`, a slot). Such an
+* element is matched — kept in place, identity intact — but neither synced nor recursed into.
+*
+* Upgraded custom elements (ownership.ts `is_upgraded_ce`) are entered, but their host ATTRIBUTES are
+* their runtime's (`attributes_writer`): re-asserting a fresh render's stale markers (a per-render id,
+* a scope class) over a live host made it lose its hydrated shadow and duplicate its content. Their
+* children are reconciled by identity (`order_owner`, {@link reconcile_by_identity}): the children the
+* element made are kept toward a live answer, removed toward Svelte's walk where the walk reads that
+* position.
+*/
+function off_limits(el, walk) {
+	if (is_declared_foreign(el) || is_region_owned(el)) return true;
+	return walk && owner_of(el) !== "walk";
+}
+/**
+* Reconcile a single old node toward a single new node, replacing only when it cannot be morphed.
+* Used by keyed matches, where `from` and `to` may be different tags (the reason the tag/namespace
+* replace check lives here). Positional/lockstep callers have already proven compatibility via
+* {@link same_node} and go through {@link morph_same}, skipping that recheck.
+*/
+function morph_node(from, to, sets, walk) {
+	const kind = from.nodeType;
+	if (kind === TEXT || kind === COMMENT) {
+		if (from.nodeValue !== to.nodeValue) from.nodeValue = to.nodeValue;
+		return;
+	}
+	if (kind !== ELEMENT) return;
+	const ef = from;
+	const et = to;
+	if (off_limits(ef, walk)) {
+		if (attributes_writer(ef) === "region") sync_render_attributes(ef, et, walk);
+		return;
+	}
+	if (ef.tagName !== et.tagName || ef.namespaceURI !== et.namespaceURI) {
+		ef.parentNode?.replaceChild(clone(to), ef);
+		return;
+	}
+	sync_form_props(ef, et);
+	sync_by_writer(ef, et, walk);
+	reconcile(ef, et.childNodes, sets, walk);
+}
+/**
+* Reconcile two nodes already known to be the same kind + (for elements) same tag + namespace — the
+* positional/lockstep path. Skips the morph-vs-replace decision {@link morph_node} makes; the element
+* body is inlined (not shared via a helper) to keep this leaf call one frame deep on the hot path.
+*/
+function morph_same(from, to, sets, walk) {
+	const kind = from.nodeType;
+	if (kind === TEXT || kind === COMMENT) {
+		if (from.nodeValue !== to.nodeValue) from.nodeValue = to.nodeValue;
+		return;
+	}
+	if (kind !== ELEMENT) return;
+	const ef = from;
+	const et = to;
+	if (off_limits(ef, walk)) {
+		if (attributes_writer(ef) === "region") sync_render_attributes(ef, et, walk);
+		return;
+	}
+	sync_form_props(ef, et);
+	sync_by_writer(ef, et, walk);
+	reconcile(ef, et.childNodes, sets, walk);
+}
+/** Add + update + remove attributes so `from` matches `to` exactly. Boolean attrs are attr presence.
+*  `keep_extra` (a self-owned element, {@link is_self_owned}): add + update only — an attribute the
+*  element gave itself is not the render's to take away. */
+function sync_attributes(from, to, keep_extra = false) {
+	const to_attrs = to.attributes;
+	const to_len = to_attrs.length;
+	for (let i = 0; i < to_len; i++) {
+		const attr = to_attrs[i];
+		if (from.getAttribute(attr.name) === attr.value) continue;
+		if (attr.name === "aria-hidden" && attr.value === "true" && subtree_has_focus(from)) continue;
+		from.setAttribute(attr.name, attr.value);
+	}
+	if (keep_extra) return;
+	const from_attrs = from.attributes;
+	if (from_attrs.length > to_len) for (let i = from_attrs.length - 1; i >= 0; i--) {
+		const name = from_attrs[i].name;
+		if (!to.hasAttribute(name)) from.removeAttribute(name);
+	}
+}
+/**
+* Sync live form DOM *properties* (`value` / `checked` / `selected`) — attributes alone don't move
+* these once a control is dirty. Runs BEFORE {@link sync_attributes}, because the rule is "follow
+* the server only when the server changed its default": a property moves only when its attribute
+* differs between the PREVIOUS render (still on `from`) and the incoming one (on `to`). A tick that
+* re-sends the same default never clobbers what the user typed or toggled in a field they have since
+* left — the browser's own dirty-value rule, and htmx 4's morph rule. The focused control is skipped
+* outright so a live tick never touches what the user is typing (its selection is left alone too).
+*/
+function sync_form_props(from, to) {
+	const tag = from.tagName;
+	if (tag !== "INPUT" && tag !== "TEXTAREA" && tag !== "SELECT" && tag !== "OPTION") return;
+	if (owner_document(from)?.activeElement === from) return;
+	const ff = from;
+	if (tag === "INPUT" || tag === "TEXTAREA" || tag === "SELECT") {
+		const next = to.getAttribute("value");
+		if (next !== null && next !== from.getAttribute("value") && ff.value !== next) ff.value = next;
+	}
+	if (tag === "INPUT") {
+		const next = to.hasAttribute("checked");
+		if (next !== from.hasAttribute("checked") && ff.checked !== next) ff.checked = next;
+	}
+	if (tag === "OPTION") {
+		const of = from;
+		const next = to.hasAttribute("selected");
+		if (next !== from.hasAttribute("selected") && of.selected !== next) of.selected = next;
+	}
+}
+/** `importNode(node, true)` — a deep copy owned by this document, carrying the source namespace. */
+function clone(node) {
+	const copy = owner_document(node).importNode(node, true);
+	if (node.nodeType === ELEMENT && globalThis.__og_restore) carry_shadows(node, copy);
+	return copy;
+}
+/**
+* `importNode` never copies a shadow root (unless it was made clonable), so a host restored in an
+* answer's fragment would arrive with its rendered tree gone. Walk the source and the copy in lockstep
+* (a deep copy has the same elements in the same order) and carry each open root across: its children
+* copied the same way, its adopted sheets, and sheets still waiting for the host to be in the page
+* (the restorer adopts those right after the insertion).
+*/
+function carry_shadows(src, dst) {
+	const a = owner_document(src).createTreeWalker(src, 1);
+	const b = owner_document(dst).createTreeWalker(dst, 1);
+	for (let s = src, d = dst; s && d; s = a.nextNode(), d = b.nextNode()) {
+		const root = s.shadowRoot;
+		if (!root || root.mode !== "open" || d.shadowRoot) continue;
+		const copy = d.attachShadow({
+			mode: "open",
+			delegatesFocus: root.delegatesFocus
+		});
+		if (copy.customElementRegistry === null) {
+			const w = globalThis;
+			(w.__og_init ??= []).push(copy);
+		}
+		for (const c of Array.from(root.childNodes)) copy.appendChild(clone(c));
+		try {
+			if (root.adoptedStyleSheets.length) copy.adoptedStyleSheets = [...root.adoptedStyleSheets];
+		} catch {}
+		const pending = root.__og_pending;
+		if (pending) {
+			copy.__og_pending = pending;
+			const w = globalThis;
+			(w.__og_adopt ??= []).push({
+				shadow: copy,
+				sheets: pending
+			});
+		}
+	}
+}
+/** The owning document, falling back to the ambient `document` for detached nodes. */
+function owner_document(node) {
+	return node.ownerDocument ?? document;
+}
+/** True when the currently focused element lives inside `el` — so putting `aria-hidden="true"` on `el`
+*  would hide the focused subtree (a WAI-ARIA violation the browser blocks). `activeElement` is `<body>`
+*  when nothing has focus, which no morphed subtree contains, so that reads as false. */
+function subtree_has_focus(el) {
+	const doc = owner_document(el);
+	const active = doc.activeElement;
+	return active != null && active !== doc.body && el.contains(active);
+}
+export { install, morph_children, sync_attributes };