@askrjs/askr 0.0.28 → 0.0.30

package/dist/renderer/reconcile.js

@@ -1 +1,359 @@
-import{performBulkPositionalKeyedTextUpdate as d,updateElementFromVnode as a,createDOMNode as y}from"./dom.js";import{isKeyedReorderFastPathEligible as p,keyedElements as s}from"./keyed.js";import{teardownNodeSubtree as b}from"./cleanup.js";import{isBulkCommitActive as N}from"../runtime/fastlane.js";import{applyRendererFastPath as C}from"./fastpath.js";import{extractKey as h,recordFastPathStats as k,checkPropChanges as S,recordDOMReplace as A}from"./utils.js";const Q=typeof document<"u";function l(e,n){if(e===n)return!0;if(e.length!==n.length)return!1;for(let t=0;t<e.length;t++){const r=e.charCodeAt(t),o=n.charCodeAt(t);if(r===o)continue;const i=r>=65&&r<=90?r+32:r,c=o>=65&&o<=90?o+32:o;if(i!==c)return!1}return!0}function X(e,n,t){const{keyedVnodes:r,unkeyedVnodes:o}=R(n),i=t||P(e),c=F(e,n,r,o,i);return c||j(e,n,r,i)}function P(e){const n=new Map;try{for(let t=e.firstElementChild;t;t=t.nextElementSibling){const r=t.getAttribute("data-key");if(r!==null){n.set(r,t);const o=Number(r);Number.isNaN(o)||n.set(o,t)}}}catch{}return n}function R(e){const n=[],t=[];for(let r=0;r<e.length;r++){const o=e[r],i=h(o);i!==void 0?n.push({key:i,vnode:o}):t.push(o)}return{keyedVnodes:n,unkeyedVnodes:t}}function F(e,n,t,r,o){try{const i=x(e,n,t,r,o);if(i)return i;const c=E(e,t);if(c)return c}catch{}return null}function x(e,n,t,r,o){if(p(e,n,o).useFastPath&&t.length>=64||N())try{const c=C(e,t,o,r);if(c)return s.set(e,c),c}catch{}return null}function E(e,n){const t=n.length;if(t<10||e.children.length!==t)return null;const r=K(e,n),o=r/t;if(n.length>0){if(r!==t&&o>=.1)return null}else if(o<.9)return null;if(v(e,n))return null;try{const i=d(e,n);return k(i,"bulkKeyedPositionalHits"),M(e),s.get(e)}catch{return null}}function K(e,n){let t=0;try{for(let r=0;r<n.length;r++){const o=n[r].vnode,i=n[r].key;if(!o||typeof o!="object"||typeof o.type!="string")continue;const c=e.children[r];if(c&&l(c.tagName,o.type)){const u=c.getAttribute("data-key");(u===String(i)||u!==null&&!Number.isNaN(Number(u))&&Number(u)===i)&&t++}}}catch{}return t}function v(e,n){try{for(let t=0;t<n.length;t++){const r=n[t].vnode,o=e.children[t];if(!(!o||!r||typeof r!="object")&&S(o,r.props||{}))return!0}}catch{return!0}return!1}function M(e){try{const n=new Map;for(let t=e.firstElementChild;t;t=t.nextElementSibling){const r=t.getAttribute("data-key");if(r!==null){n.set(r,t);const o=Number(r);Number.isNaN(o)||n.set(o,t)}}s.set(e,n)}catch{}}function j(e,n,t,r){const o=new Map,i=[],c=new WeakSet,u=B(e,r,c);for(let f=0;f<n.length;f++){const g=n[f],m=U(g,f,e,u,c,o);m&&i.push(m)}return typeof document>"u"||(w(e,i),s.delete(e)),o}function B(e,n,t){return r=>{if(!n)return;const o=n.get(r);if(o&&!t.has(o))return t.add(o),o;const i=String(r),c=n.get(i);if(c&&!t.has(c))return t.add(c),c;const u=Number(i);if(!Number.isNaN(u)){const f=n.get(u);if(f&&!t.has(f))return t.add(f),f}return D(e,r,i,t)}}function D(e,n,t,r){try{for(let o=e.firstElementChild;o;o=o.nextElementSibling){if(r.has(o))continue;const i=o.getAttribute("data-key");if(i===t)return r.add(o),o;if(i!==null){const c=Number(i);if(!Number.isNaN(c)&&c===n)return r.add(o),o}}}catch{}}function U(e,n,t,r,o,i){const c=h(e);return c!==void 0?I(e,c,t,r,i):L(e,n,t,o)}function I(e,n,t,r,o){const i=r(n);if(i&&i.parentElement===t)try{const u=e;if(u&&typeof u=="object"&&typeof u.type=="string"&&l(i.tagName,u.type))return a(i,e),o.set(n,i),i}catch{}const c=y(e);return c?(c instanceof Element&&o.set(n,c),c):null}function L(e,n,t,r){try{const i=t.childNodes[n];if((typeof e=="string"||typeof e=="number")&&i&&i.nodeType===3)return i.data=String(e),r.add(i),i;if(i instanceof Element&&T(i,e))return a(i,e),r.add(i),i;const c=_(t,r);if(c){const u=q(c,e,r);if(u)return u}}catch{}return y(e)}function T(e,n){if(!e||typeof n!="object"||n===null||!("type"in n))return!1;const t=n,r=e.getAttribute("data-key");return r==null&&typeof t.type=="string"&&l(e.tagName,t.type)}function _(e,n){for(let t=e.firstElementChild;t;t=t.nextElementSibling)if(!n.has(t)&&t.getAttribute("data-key")===null)return t}function q(e,n,t){if(typeof n=="string"||typeof n=="number")return e.textContent=String(n),t.add(e),e;if(typeof n=="object"&&n!==null&&"type"in n){const r=n;if(typeof r.type=="string"&&l(e.tagName,r.type))return a(e,n),t.add(e),e}return null}function w(e,n){const t=document.createDocumentFragment();for(let r=0;r<n.length;r++)t.appendChild(n[r]);try{for(let r=e.firstChild;r;){const o=r.nextSibling;b(r),r=o}}catch{}A("reconcile"),e.replaceChildren(t)}export{Q as IS_DOM_AVAILABLE,X as reconcileKeyedChildren};
+import { getRuntimeEnv } from "../common/env.js";
+import "./env.js";
+import { checkPropChanges, extractKey, recordDOMReplace, recordFastPathStats, tagNamesEqualIgnoreCase } from "./utils.js";
+import { isKeyedReorderFastPathEligible, keyedElements } from "./keyed.js";
+import { teardownNodeSubtree } from "./cleanup.js";
+import { applyRendererFastPath } from "./fastpath.js";
+import { performBulkPositionalKeyedTextUpdate } from "./children.js";
+import { createDOMNode, syncComponentElement, updateElementFromVnode } from "./dom.js";
+function reconcileKeyedChildren(parent, newChildren, oldKeyMap) {
+	const { keyedVnodes, unkeyedVnodes } = partitionChildren(newChildren);
+	const ensuredOldKeyMap = oldKeyMap || buildKeyMapFromDOM(parent);
+	const fastPathResult = tryFastPaths(parent, newChildren, keyedVnodes, unkeyedVnodes, ensuredOldKeyMap);
+	if (fastPathResult) return fastPathResult;
+	return performFullReconciliation(parent, newChildren, keyedVnodes, ensuredOldKeyMap);
+}
+/** Build key map from DOM children */
+function buildKeyMapFromDOM(parent) {
+	const keyMap = /* @__PURE__ */ new Map();
+	try {
+		for (let el = parent.firstElementChild; el; el = el.nextElementSibling) {
+			const k = el.getAttribute("data-key");
+			if (k !== null) {
+				keyMap.set(k, el);
+				const n = Number(k);
+				if (!Number.isNaN(n)) keyMap.set(n, el);
+			}
+		}
+	} catch {}
+	return keyMap;
+}
+/** Partition children into keyed and unkeyed */
+function partitionChildren(newChildren) {
+	const keyedVnodes = [];
+	const unkeyedVnodes = [];
+	for (let i = 0; i < newChildren.length; i++) {
+		const child = newChildren[i];
+		const key = extractKey(child);
+		if (key !== void 0) keyedVnodes.push({
+			key,
+			vnode: child
+		});
+		else unkeyedVnodes.push(child);
+	}
+	return {
+		keyedVnodes,
+		unkeyedVnodes
+	};
+}
+/** Try fast paths before full reconciliation */
+function tryFastPaths(parent, newChildren, keyedVnodes, unkeyedVnodes, oldKeyMap) {
+	try {
+		const forcedResult = tryForcedPositionalBulkUpdate(parent, newChildren, keyedVnodes);
+		if (forcedResult) return forcedResult;
+		const rendererResult = tryRendererFastPath(parent, newChildren, keyedVnodes, unkeyedVnodes, oldKeyMap);
+		if (rendererResult) return rendererResult;
+		const positionalResult = tryPositionalBulkUpdate(parent, keyedVnodes);
+		if (positionalResult) return positionalResult;
+	} catch {}
+	return null;
+}
+/** Try renderer fast-path */
+function tryRendererFastPath(parent, newChildren, keyedVnodes, unkeyedVnodes, oldKeyMap) {
+	const decision = isKeyedReorderFastPathEligible(parent, newChildren, oldKeyMap);
+	const isWholeKeyedList = keyedVnodes.length === newChildren.length && unkeyedVnodes.length === 0;
+	if (decision.useFastPath && keyedVnodes.length >= 64 && isWholeKeyedList) try {
+		const map = applyRendererFastPath(parent, keyedVnodes, oldKeyMap, unkeyedVnodes);
+		if (map) {
+			keyedElements.set(parent, map);
+			return map;
+		}
+	} catch {}
+	return null;
+}
+/** Try the explicit test/bench forced positional keyed path. */
+function tryForcedPositionalBulkUpdate(parent, newChildren, keyedVnodes) {
+	if (getRuntimeEnv().ASKR_FORCE_BULK_POSREUSE !== "1") return null;
+	if (keyedVnodes.length === 0 || keyedVnodes.length !== newChildren.length) return null;
+	try {
+		recordFastPathStats(performBulkPositionalKeyedTextUpdate(parent, keyedVnodes), "bulkKeyedPositionalForced");
+		rebuildKeyedMap(parent);
+		return keyedElements.get(parent);
+	} catch {
+		return null;
+	}
+}
+/** Try positional bulk update for medium-sized lists */
+function tryPositionalBulkUpdate(parent, keyedVnodes) {
+	const total = keyedVnodes.length;
+	if (total < 10) return null;
+	if (parent.children.length !== total) return null;
+	const matchCount = countPositionalMatches(parent, keyedVnodes);
+	const matchFraction = matchCount / total;
+	if (keyedVnodes.length > 0) {
+		if (matchCount !== total && matchFraction >= .1) return null;
+	} else if (matchFraction < .9) return null;
+	if (hasPositionalPropChanges(parent, keyedVnodes)) return null;
+	try {
+		recordFastPathStats(performBulkPositionalKeyedTextUpdate(parent, keyedVnodes), "bulkKeyedPositionalHits");
+		rebuildKeyedMap(parent);
+		return keyedElements.get(parent);
+	} catch {
+		return null;
+	}
+}
+/** Count how many vnodes match parent children by position and tag */
+function countPositionalMatches(parent, keyedVnodes) {
+	let matchCount = 0;
+	try {
+		for (let i = 0; i < keyedVnodes.length; i++) {
+			const vnode = keyedVnodes[i].vnode;
+			const expectedKey = keyedVnodes[i].key;
+			if (!vnode || typeof vnode !== "object" || typeof vnode.type !== "string") continue;
+			const el = parent.children[i];
+			if (!el) continue;
+			if (tagNamesEqualIgnoreCase(el.tagName, vnode.type)) {
+				const actualKey = el.getAttribute("data-key");
+				if (actualKey === String(expectedKey) || actualKey !== null && !Number.isNaN(Number(actualKey)) && Number(actualKey) === expectedKey) matchCount++;
+			}
+		}
+	} catch {}
+	return matchCount;
+}
+/** Check if positional prop changes would prevent bulk update */
+function hasPositionalPropChanges(parent, keyedVnodes) {
+	try {
+		for (let i = 0; i < keyedVnodes.length; i++) {
+			const vnode = keyedVnodes[i].vnode;
+			const el = parent.children[i];
+			if (!el || !vnode || typeof vnode !== "object") continue;
+			if (checkPropChanges(el, vnode.props || {})) return true;
+		}
+	} catch {
+		return true;
+	}
+	return false;
+}
+/** Rebuild keyed map from parent children */
+function rebuildKeyedMap(parent) {
+	try {
+		const map = /* @__PURE__ */ new Map();
+		for (let el = parent.firstElementChild; el; el = el.nextElementSibling) {
+			const k = el.getAttribute("data-key");
+			if (k !== null) {
+				map.set(k, el);
+				const n = Number(k);
+				if (!Number.isNaN(n)) map.set(n, el);
+			}
+		}
+		keyedElements.set(parent, map);
+	} catch {}
+}
+/** Perform full reconciliation when fast paths don't apply */
+function performFullReconciliation(parent, newChildren, keyedVnodes, oldKeyMap) {
+	const newKeyMap = /* @__PURE__ */ new Map();
+	const finalNodes = [];
+	const usedOldEls = /* @__PURE__ */ new WeakSet();
+	const resolveOldElOnce = createOldElResolver(parent, oldKeyMap, usedOldEls);
+	const unkeyedEls = collectUnkeyedElements(parent);
+	let unkeyedIndex = 0;
+	const resolveUnkeyedOnce = () => {
+		while (unkeyedIndex < unkeyedEls.length) {
+			const candidate = unkeyedEls[unkeyedIndex++];
+			if (!usedOldEls.has(candidate)) return candidate;
+		}
+	};
+	for (let i = 0; i < newChildren.length; i++) {
+		const child = newChildren[i];
+		const node = reconcileSingleChild(child, i, parent, resolveOldElOnce, resolveUnkeyedOnce, usedOldEls, newKeyMap);
+		if (node) finalNodes.push(node);
+	}
+	if (typeof document === "undefined") return newKeyMap;
+	commitReconciliation(parent, finalNodes);
+	keyedElements.delete(parent);
+	return newKeyMap;
+}
+/** Create resolver for finding old elements by key */
+function createOldElResolver(parent, oldKeyMap, usedOldEls) {
+	return (k) => {
+		if (!oldKeyMap) return void 0;
+		const direct = oldKeyMap.get(k);
+		if (direct && !usedOldEls.has(direct)) {
+			usedOldEls.add(direct);
+			return direct;
+		}
+		const s = String(k);
+		const byString = oldKeyMap.get(s);
+		if (byString && !usedOldEls.has(byString)) {
+			usedOldEls.add(byString);
+			return byString;
+		}
+		const n = Number(s);
+		if (!Number.isNaN(n)) {
+			const byNum = oldKeyMap.get(n);
+			if (byNum && !usedOldEls.has(byNum)) {
+				usedOldEls.add(byNum);
+				return byNum;
+			}
+		}
+		return scanForElementByKey(parent, k, s, usedOldEls);
+	};
+}
+/** Scan parent children for element with matching key */
+function scanForElementByKey(parent, k, keyStr, usedOldEls) {
+	try {
+		for (let ch = parent.firstElementChild; ch; ch = ch.nextElementSibling) {
+			if (usedOldEls.has(ch)) continue;
+			const attr = ch.getAttribute("data-key");
+			if (attr === keyStr) {
+				usedOldEls.add(ch);
+				return ch;
+			}
+			if (attr !== null) {
+				const numAttr = Number(attr);
+				if (!Number.isNaN(numAttr) && numAttr === k) {
+					usedOldEls.add(ch);
+					return ch;
+				}
+			}
+		}
+	} catch {}
+}
+/** Reconcile a single child */
+function reconcileSingleChild(child, index, parent, resolveOldElOnce, resolveUnkeyedOnce, usedOldEls, newKeyMap) {
+	const key = extractKey(child);
+	if (key !== void 0) return reconcileKeyedChild(child, key, parent, resolveOldElOnce, newKeyMap);
+	return reconcileUnkeyedChild(child, index, parent, resolveUnkeyedOnce, usedOldEls);
+}
+/** Reconcile a keyed child */
+function reconcileKeyedChild(child, key, parent, resolveOldElOnce, newKeyMap) {
+	const el = resolveOldElOnce(key);
+	if (el && el.parentElement === parent) try {
+		const childObj = child;
+		if (childObj && typeof childObj === "object" && typeof childObj.type === "string") {
+			if (tagNamesEqualIgnoreCase(el.tagName, childObj.type)) {
+				updateElementFromVnode(el, child);
+				newKeyMap.set(key, el);
+				return el;
+			}
+		}
+		if (isComponentVNode(child)) {
+			const synced = syncComponentElement(el, child, child.type, (child.props ?? {}) || {});
+			if (synced) {
+				if (synced instanceof Element) newKeyMap.set(key, synced);
+				return synced;
+			}
+		}
+	} catch {}
+	const dom = createDOMNode(child);
+	if (dom) {
+		if (dom instanceof Element) newKeyMap.set(key, dom);
+		return dom;
+	}
+	return null;
+}
+/** Reconcile an unkeyed or primitive child */
+function reconcileUnkeyedChild(child, index, parent, resolveUnkeyedOnce, usedOldEls) {
+	try {
+		const existing = parent.childNodes[index];
+		if (typeof child === "string" || typeof child === "number") {
+			if (existing && existing.nodeType === 3) {
+				existing.data = String(child);
+				usedOldEls.add(existing);
+				return existing;
+			}
+			return createDOMNode(child);
+		}
+		if (existing instanceof Element) {
+			const synced = trySyncComponentChild(existing, child, usedOldEls);
+			if (synced) return synced;
+		}
+		if (existing instanceof Element && canReuseElement(existing, child)) {
+			updateElementFromVnode(existing, child);
+			usedOldEls.add(existing);
+			return existing;
+		}
+		const avail = resolveUnkeyedOnce();
+		if (avail) {
+			const reuseResult = tryReuseElement(avail, child, usedOldEls);
+			if (reuseResult) return reuseResult;
+		}
+	} catch {}
+	return createDOMNode(child);
+}
+function isComponentVNode(child) {
+	return typeof child === "object" && child !== null && "type" in child && typeof child.type === "function";
+}
+function trySyncComponentChild(existing, child, usedOldEls) {
+	if (!isComponentVNode(child)) return null;
+	const synced = syncComponentElement(existing, child, child.type, (child.props ?? {}) || {});
+	if (!synced) return null;
+	usedOldEls.add(existing);
+	usedOldEls.add(synced);
+	return synced;
+}
+/** Check if existing element can be reused for child */
+function canReuseElement(existing, child) {
+	if (!existing) return false;
+	if (typeof child !== "object" || child === null || !("type" in child)) return false;
+	const childObj = child;
+	const existingKey = existing.getAttribute("data-key");
+	return (existingKey === null || existingKey === void 0) && typeof childObj.type === "string" && tagNamesEqualIgnoreCase(existing.tagName, childObj.type);
+}
+/** Collect unkeyed element children in DOM order. */
+function collectUnkeyedElements(parent) {
+	const elements = [];
+	for (let ch = parent.firstElementChild; ch; ch = ch.nextElementSibling) if (ch.getAttribute("data-key") === null) elements.push(ch);
+	return elements;
+}
+/** Try to reuse available element for child */
+function tryReuseElement(avail, child, usedOldEls) {
+	if (typeof child === "string" || typeof child === "number") return null;
+	const synced = trySyncComponentChild(avail, child, usedOldEls);
+	if (synced) return synced;
+	if (typeof child === "object" && child !== null && "type" in child) {
+		const childObj = child;
+		if (typeof childObj.type === "string" && tagNamesEqualIgnoreCase(avail.tagName, childObj.type)) {
+			updateElementFromVnode(avail, child);
+			usedOldEls.add(avail);
+			return avail;
+		}
+	}
+	return null;
+}
+/** Commit reconciliation by replacing parent children */
+function commitReconciliation(parent, finalNodes) {
+	try {
+		const finalSet = new Set(finalNodes);
+		for (let n = parent.firstChild; n;) {
+			const next = n.nextSibling;
+			if (!finalSet.has(n)) {
+				teardownNodeSubtree(n);
+				parent.removeChild(n);
+			}
+			n = next;
+		}
+		for (let i = 0; i < finalNodes.length; i++) {
+			const desiredNode = finalNodes[i];
+			const anchor = parent.childNodes[i] ?? null;
+			if (desiredNode !== anchor) parent.insertBefore(desiredNode, anchor);
+		}
+	} catch {
+		const fragment = document.createDocumentFragment();
+		for (let i = 0; i < finalNodes.length; i++) fragment.appendChild(finalNodes[i]);
+		try {
+			for (let n = parent.firstChild; n;) {
+				const next = n.nextSibling;
+				teardownNodeSubtree(n);
+				n = next;
+			}
+		} catch {}
+		recordDOMReplace("reconcile");
+		parent.replaceChildren(fragment);
+		return;
+	}
+}
+//#endregion
+export { reconcileKeyedChildren };
+
+//# sourceMappingURL=reconcile.js.map

package/dist/renderer/reconcile.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"reconcile.js","names":[],"sources":["../../src/renderer/reconcile.ts"],"sourcesContent":["/**\n * ─────────────────────────────────────────────────────────────────────────────\n * RENDERER & RECONCILIATION INVARIANTS (LOCKED)\n * ─────────────────────────────────────────────────────────────────────────────\n *\n * These invariants are NON-NEGOTIABLE. Any optimization or fast-path MUST\n * preserve them. Violations WILL produce incorrect DOM.\n *\n * 1. DOM ORDER DERIVES ONLY FROM CURRENT VNODE ORDER\n * --------------------------------------------------\n * - Final DOM child order MUST be reconstructed from the current vnode list.\n * - Reusing an existing DOM node does NOT imply it stays in the same position.\n * - Appending an existing Node to a DocumentFragment is the ONLY valid way\n *   to express reordering (it moves the node).\n *\n * ❌ NEVER skip fragment insertion because a node already has a parent.\n * ✅ ALWAYS append reused nodes into the fragment to establish order.\n *\n *\n * 2. VNODE IDENTITY ≠ VNODE STABILITY\n * ----------------------------------\n * - VNodes are mutable.\n * - `vnodeA === vnodeB` does NOT imply semantic equality.\n * - DOM reuse MUST NOT be gated on vnode identity alone.\n *\n * DOM reuse is allowed ONLY when:\n *   - element type is unchanged\n *   - structural shape is compatible\n *   - updates are applied explicitly via updateElementFromVnode\n *\n * ❌ NEVER assume \"same object\" means \"no changes\".\n *\n *\n * 3. KEYED RECONCILIATION IS ELEMENT-ONLY\n * --------------------------------------\n * - Keyed reconciliation assumes ELEMENT nodes, not Text or Comment nodes.\n * - Any fast-path using `parent.children[i]` MUST prove:\n *     - all children are elements\n *     - no text nodes are present\n *\n * ❌ NEVER index `parent.children` when text nodes may exist.\n * ✅ Use `parent.childNodes` or bail out to full reconciliation.\n *\n *\n * 4. PRIMITIVES MAP TO TEXT NODES\n * -------------------------------\n * - string/number children represent Text nodes, not Elements.\n * - Reconciliation MUST attempt Text-to-Text reuse before replacement.\n *\n * ❌ NEVER update element.textContent as a substitute for text reconciliation\n *    unless the shape is explicitly guaranteed.\n *\n *\n * 5. FAST-PATHS MUST BE STRICTLY SAFE\n * ----------------------------------\n * - Fast-paths are OPTIONAL.\n * - Correctness always beats performance.\n *\n * A fast-path MUST:\n *   - prove its eligibility\n *   - fall back cleanly on ANY ambiguity\n *   - never partially apply\n *\n *\n * 6. CLEANUP IS POSITION-INDEPENDENT\n * ---------------------------------\n * - Cleanup is based on removal from the DOM, not vnode position.\n * - Any node removed or replaced MUST:\n *     - remove listeners\n *     - cleanup component instances\n *\n *\n * 7. FOR-BOUNDARY & KEYED LISTS OBEY THE SAME RULES\n * ------------------------------------------------\n * - For-boundaries are NOT special in ordering semantics.\n * - Cached DOM nodes MUST still be reordered via fragment insertion.\n * - Cache is an optimization, not an ownership claim.\n *\n *\n * If you are unsure whether an optimization preserves these invariants:\n * DO NOT APPLY IT.\n *\n * ─────────────────────────────────────────────────────────────────────────────\n */\n\nimport type { DOMElement, VNode } from './types';\nimport {\n  createDOMNode,\n  syncComponentElement,\n  updateElementFromVnode,\n  performBulkPositionalKeyedTextUpdate,\n} from './dom';\nimport type { Props } from '../common/props';\nimport {\n  keyedElements,\n  _reconcilerRecordedParents,\n  isKeyedReorderFastPathEligible,\n} from './keyed';\nimport { teardownNodeSubtree } from './cleanup';\nimport { applyRendererFastPath } from './fastpath';\nimport { getRuntimeEnv } from './env';\nimport {\n  extractKey,\n  checkPropChanges,\n  recordFastPathStats,\n  recordDOMReplace,\n  tagNamesEqualIgnoreCase,\n} from './utils';\n\nexport const IS_DOM_AVAILABLE = typeof document !== 'undefined';\n\n// Helper type for narrowings\ntype VnodeObj = VNode & { type?: unknown; props?: Record<string, unknown> };\ntype ComponentVNode = DOMElement & { type: (props: Props) => unknown };\n\nexport function reconcileKeyedChildren(\n  parent: Element,\n  newChildren: VNode[],\n  oldKeyMap: Map<string | number, Element> | undefined\n): Map<string | number, Element> {\n  const { keyedVnodes, unkeyedVnodes } = partitionChildren(newChildren);\n\n  // Ensure we have a key map before reconciliation to avoid O(n) DOM scans\n  // during O(n) reconciliation loop (which would be O(n²))\n  const ensuredOldKeyMap = oldKeyMap || buildKeyMapFromDOM(parent);\n\n  // Try fast paths first\n  const fastPathResult = tryFastPaths(\n    parent,\n    newChildren,\n    keyedVnodes,\n    unkeyedVnodes,\n    ensuredOldKeyMap\n  );\n  if (fastPathResult) {\n    return fastPathResult;\n  }\n\n  // Full reconciliation\n  return performFullReconciliation(\n    parent,\n    newChildren,\n    keyedVnodes,\n    ensuredOldKeyMap\n  );\n}\n\n/** Build key map from DOM children */\nfunction buildKeyMapFromDOM(parent: Element): Map<string | number, Element> {\n  const keyMap = new Map<string | number, Element>();\n  try {\n    for (let el = parent.firstElementChild; el; el = el.nextElementSibling) {\n      const k = el.getAttribute('data-key');\n      if (k !== null) {\n        keyMap.set(k, el);\n        const n = Number(k);\n        if (!Number.isNaN(n)) keyMap.set(n, el);\n      }\n    }\n  } catch {\n    // Ignore\n  }\n  return keyMap;\n}\n\n/** Partition children into keyed and unkeyed */\nfunction partitionChildren(newChildren: VNode[]): {\n  keyedVnodes: Array<{ key: string | number; vnode: VNode }>;\n  unkeyedVnodes: VNode[];\n} {\n  const keyedVnodes: Array<{ key: string | number; vnode: VNode }> = [];\n  const unkeyedVnodes: VNode[] = [];\n\n  for (let i = 0; i < newChildren.length; i++) {\n    const child = newChildren[i];\n    const key = extractKey(child);\n    if (key !== undefined) {\n      keyedVnodes.push({ key, vnode: child });\n    } else {\n      unkeyedVnodes.push(child);\n    }\n  }\n\n  return { keyedVnodes, unkeyedVnodes };\n}\n\n/** Try fast paths before full reconciliation */\nfunction tryFastPaths(\n  parent: Element,\n  newChildren: VNode[],\n  keyedVnodes: Array<{ key: string | number; vnode: VNode }>,\n  unkeyedVnodes: VNode[],\n  oldKeyMap: Map<string | number, Element> | undefined\n): Map<string | number, Element> | null {\n  try {\n    const forcedResult = tryForcedPositionalBulkUpdate(\n      parent,\n      newChildren,\n      keyedVnodes\n    );\n    if (forcedResult) {\n      return forcedResult;\n    }\n\n    // Try renderer fast-path for large keyed reorder-only updates\n    const rendererResult = tryRendererFastPath(\n      parent,\n      newChildren,\n      keyedVnodes,\n      unkeyedVnodes,\n      oldKeyMap\n    );\n    if (rendererResult) {\n      return rendererResult;\n    }\n\n    // Try positional bulk update for medium-sized lists\n    const positionalResult = tryPositionalBulkUpdate(parent, keyedVnodes);\n    if (positionalResult) {\n      return positionalResult;\n    }\n  } catch {\n    // Fall through to full reconciliation\n  }\n\n  return null;\n}\n\n/** Try renderer fast-path */\nfunction tryRendererFastPath(\n  parent: Element,\n  newChildren: VNode[],\n  keyedVnodes: Array<{ key: string | number; vnode: VNode }>,\n  unkeyedVnodes: VNode[],\n  oldKeyMap: Map<string | number, Element> | undefined\n): Map<string | number, Element> | null {\n  const decision = isKeyedReorderFastPathEligible(\n    parent,\n    newChildren,\n    oldKeyMap\n  );\n  const isWholeKeyedList =\n    keyedVnodes.length === newChildren.length && unkeyedVnodes.length === 0;\n  const canUseFastPath =\n    decision.useFastPath && keyedVnodes.length >= 64 && isWholeKeyedList;\n\n  // Apply fast-path only for a whole keyed list. Mixed root fragments may\n  // contain a keyed portal sibling, but they are not reorder-only lists.\n  if (canUseFastPath) {\n    try {\n      const map = applyRendererFastPath(\n        parent,\n        keyedVnodes,\n        oldKeyMap,\n        unkeyedVnodes\n      );\n      if (map) {\n        keyedElements.set(parent, map);\n        return map;\n      }\n    } catch {\n      // Fall through\n    }\n  }\n\n  return null;\n}\n\n/** Try the explicit test/bench forced positional keyed path. */\nfunction tryForcedPositionalBulkUpdate(\n  parent: Element,\n  newChildren: VNode[],\n  keyedVnodes: Array<{ key: string | number; vnode: VNode }>\n): Map<string | number, Element> | null {\n  if (getRuntimeEnv().ASKR_FORCE_BULK_POSREUSE !== '1') return null;\n  if (keyedVnodes.length === 0 || keyedVnodes.length !== newChildren.length) {\n    return null;\n  }\n\n  try {\n    const stats = performBulkPositionalKeyedTextUpdate(parent, keyedVnodes);\n    recordFastPathStats(stats, 'bulkKeyedPositionalForced');\n\n    rebuildKeyedMap(parent);\n    return keyedElements.get(parent) as Map<string | number, Element>;\n  } catch {\n    return null;\n  }\n}\n\n/** Try positional bulk update for medium-sized lists */\nfunction tryPositionalBulkUpdate(\n  parent: Element,\n  keyedVnodes: Array<{ key: string | number; vnode: VNode }>\n): Map<string | number, Element> | null {\n  const total = keyedVnodes.length;\n  if (total < 10) return null;\n\n  // CRITICAL INVARIANT: Only use children[] indexing if element-only is guaranteed\n  // If parent has text nodes or comment nodes, bail to full reconciliation\n  if (parent.children.length !== total) {\n    return null;\n  }\n\n  const matchCount = countPositionalMatches(parent, keyedVnodes);\n\n  // For keyed lists, the positional bulk update path makes sense in two cases:\n  // 1. Perfect match (100%): All keys are in the right positions, just update text\n  // 2. Very low match (<10%): Keys changed en-masse, treat as bulk re-key, reuse nodes by position\n  // ANY mismatch at all means we have a reorder and need full reconciliation\n  // to preserve DOM node identity correctly.\n  const matchFraction = matchCount / total;\n\n  if (keyedVnodes.length > 0) {\n    // For keyed lists: require perfect match or very low match\n    // matchCount !== total catches ANY reordering, even just 2 swapped elements\n    if (matchCount !== total && matchFraction >= 0.1) {\n      return null;\n    }\n  } else {\n    // For unkeyed lists: use original threshold\n    if (matchFraction < 0.9) {\n      return null;\n    }\n  }\n\n  // Check for prop changes that would prevent positional update\n  if (hasPositionalPropChanges(parent, keyedVnodes)) {\n    return null;\n  }\n\n  // Perform positional update\n  try {\n    const stats = performBulkPositionalKeyedTextUpdate(parent, keyedVnodes);\n    recordFastPathStats(stats, 'bulkKeyedPositionalHits');\n\n    rebuildKeyedMap(parent);\n    return keyedElements.get(parent) as Map<string | number, Element>;\n  } catch {\n    return null;\n  }\n}\n\n/** Count how many vnodes match parent children by position and tag */\nfunction countPositionalMatches(\n  parent: Element,\n  keyedVnodes: Array<{ key: string | number; vnode: VNode }>\n): number {\n  let matchCount = 0;\n\n  try {\n    // For keyed children, use children (elements only) since keyed nodes are elements\n    for (let i = 0; i < keyedVnodes.length; i++) {\n      const vnode = keyedVnodes[i].vnode as VnodeObj;\n      const expectedKey = keyedVnodes[i].key;\n\n      if (!vnode || typeof vnode !== 'object' || typeof vnode.type !== 'string')\n        continue;\n\n      const el = parent.children[i] as Element | undefined;\n      if (!el) continue;\n\n      // For keyed lists, check BOTH tag name AND key match\n      if (tagNamesEqualIgnoreCase(el.tagName, vnode.type)) {\n        // Check if the element at this position has the expected key\n        const actualKey = el.getAttribute('data-key');\n        const keyMatches =\n          actualKey === String(expectedKey) ||\n          (actualKey !== null &&\n            !Number.isNaN(Number(actualKey)) &&\n            Number(actualKey) === expectedKey);\n\n        if (keyMatches) {\n          matchCount++;\n        }\n      }\n    }\n  } catch {\n    // Ignore\n  }\n\n  return matchCount;\n}\n\n/** Check if positional prop changes would prevent bulk update */\nfunction hasPositionalPropChanges(\n  parent: Element,\n  keyedVnodes: Array<{ key: string | number; vnode: VNode }>\n): boolean {\n  try {\n    // For keyed children, use children (elements only) since keyed nodes are elements\n    for (let i = 0; i < keyedVnodes.length; i++) {\n      const vnode = keyedVnodes[i].vnode as VnodeObj;\n      const el = parent.children[i] as Element | undefined;\n      if (!el || !vnode || typeof vnode !== 'object') continue;\n\n      if (checkPropChanges(el, vnode.props || {})) {\n        return true;\n      }\n    }\n  } catch {\n    return true;\n  }\n\n  return false;\n}\n\n/** Rebuild keyed map from parent children */\nfunction rebuildKeyedMap(parent: Element): void {\n  try {\n    const map = new Map<string | number, Element>();\n    for (let el = parent.firstElementChild; el; el = el.nextElementSibling) {\n      const k = el.getAttribute('data-key');\n      if (k !== null) {\n        map.set(k, el);\n        const n = Number(k);\n        if (!Number.isNaN(n)) map.set(n, el);\n      }\n    }\n    keyedElements.set(parent, map);\n  } catch {\n    // Ignore\n  }\n}\n\n/** Perform full reconciliation when fast paths don't apply */\nfunction performFullReconciliation(\n  parent: Element,\n  newChildren: VNode[],\n  keyedVnodes: Array<{ key: string | number; vnode: VNode }>,\n  oldKeyMap: Map<string | number, Element> | undefined\n): Map<string | number, Element> {\n  const newKeyMap = new Map<string | number, Element>();\n  const finalNodes: Node[] = [];\n  const usedOldEls = new WeakSet<Node>();\n\n  const resolveOldElOnce = createOldElResolver(parent, oldKeyMap, usedOldEls);\n  const unkeyedEls = collectUnkeyedElements(parent);\n  let unkeyedIndex = 0;\n  const resolveUnkeyedOnce = (): Element | undefined => {\n    while (unkeyedIndex < unkeyedEls.length) {\n      const candidate = unkeyedEls[unkeyedIndex++];\n      if (!usedOldEls.has(candidate)) return candidate;\n    }\n    return undefined;\n  };\n\n  // Positional reconciliation\n  for (let i = 0; i < newChildren.length; i++) {\n    const child = newChildren[i];\n    const node = reconcileSingleChild(\n      child,\n      i,\n      parent,\n      resolveOldElOnce,\n      resolveUnkeyedOnce,\n      usedOldEls,\n      newKeyMap\n    );\n    if (node) finalNodes.push(node);\n  }\n\n  // SSR guard\n  if (typeof document === 'undefined') return newKeyMap;\n\n  commitReconciliation(parent, finalNodes);\n  keyedElements.delete(parent);\n\n  return newKeyMap;\n}\n\n/** Create resolver for finding old elements by key */\nfunction createOldElResolver(\n  parent: Element,\n  oldKeyMap: Map<string | number, Element> | undefined,\n  usedOldEls: WeakSet<Node>\n): (k: string | number) => Element | undefined {\n  return (k: string | number) => {\n    if (!oldKeyMap) return undefined;\n\n    // Fast-path: directly from oldKeyMap\n    const direct = oldKeyMap.get(k);\n    if (direct && !usedOldEls.has(direct)) {\n      usedOldEls.add(direct);\n      return direct;\n    }\n\n    // Try string form\n    const s = String(k);\n    const byString = oldKeyMap.get(s);\n    if (byString && !usedOldEls.has(byString)) {\n      usedOldEls.add(byString);\n      return byString;\n    }\n\n    // Try numeric form\n    const n = Number(s);\n    if (!Number.isNaN(n)) {\n      const byNum = oldKeyMap.get(n);\n      if (byNum && !usedOldEls.has(byNum)) {\n        usedOldEls.add(byNum);\n        return byNum;\n      }\n    }\n\n    // Fallback: scan parent children\n    return scanForElementByKey(parent, k, s, usedOldEls);\n  };\n}\n\n/** Scan parent children for element with matching key */\nfunction scanForElementByKey(\n  parent: Element,\n  k: string | number,\n  keyStr: string,\n  usedOldEls: WeakSet<Node>\n): Element | undefined {\n  try {\n    for (let ch = parent.firstElementChild; ch; ch = ch.nextElementSibling) {\n      if (usedOldEls.has(ch)) continue;\n      const attr = ch.getAttribute('data-key');\n      if (attr === keyStr) {\n        usedOldEls.add(ch);\n        return ch;\n      }\n      if (attr !== null) {\n        const numAttr = Number(attr);\n        if (!Number.isNaN(numAttr) && numAttr === (k as number)) {\n          usedOldEls.add(ch);\n          return ch;\n        }\n      }\n    }\n  } catch {\n    // Ignore\n  }\n  return undefined;\n}\n\n/** Reconcile a single child */\nfunction reconcileSingleChild(\n  child: VNode,\n  index: number,\n  parent: Element,\n  resolveOldElOnce: (k: string | number) => Element | undefined,\n  resolveUnkeyedOnce: () => Element | undefined,\n  usedOldEls: WeakSet<Node>,\n  newKeyMap: Map<string | number, Element>\n): Node | null {\n  // Keyed child\n  const key = extractKey(child);\n\n  if (key !== undefined) {\n    return reconcileKeyedChild(child, key, parent, resolveOldElOnce, newKeyMap);\n  }\n\n  // Unkeyed or primitive child\n  return reconcileUnkeyedChild(\n    child,\n    index,\n    parent,\n    resolveUnkeyedOnce,\n    usedOldEls\n  );\n}\n\n/** Reconcile a keyed child */\nfunction reconcileKeyedChild(\n  child: VNode,\n  key: string | number,\n  parent: Element,\n  resolveOldElOnce: (k: string | number) => Element | undefined,\n  newKeyMap: Map<string | number, Element>\n): Node | null {\n  const el = resolveOldElOnce(key);\n\n  if (el && el.parentElement === parent) {\n    // Strict keyed guarantee: if the element tag changes for an existing key,\n    // replace the DOM node rather than mutating in place.\n    try {\n      const childObj = child as VnodeObj;\n      if (\n        childObj &&\n        typeof childObj === 'object' &&\n        typeof childObj.type === 'string'\n      ) {\n        if (tagNamesEqualIgnoreCase(el.tagName, childObj.type)) {\n          updateElementFromVnode(el, child);\n          newKeyMap.set(key, el);\n          return el;\n        }\n      }\n      if (isComponentVNode(child)) {\n        const synced = syncComponentElement(\n          el,\n          child,\n          child.type,\n          ((child.props ?? {}) as Props) || {}\n        );\n        if (synced) {\n          if (synced instanceof Element) newKeyMap.set(key, synced);\n          return synced;\n        }\n      }\n    } catch {\n      // Fall through to replacement\n    }\n  }\n\n  const dom = createDOMNode(child);\n  if (dom) {\n    if (dom instanceof Element) newKeyMap.set(key, dom);\n    return dom;\n  }\n\n  return null;\n}\n\n/** Reconcile an unkeyed or primitive child */\nfunction reconcileUnkeyedChild(\n  child: VNode,\n  index: number,\n  parent: Element,\n  resolveUnkeyedOnce: () => Element | undefined,\n  usedOldEls: WeakSet<Node>\n): Node | null {\n  try {\n    // Use childNodes (includes Text nodes) instead of children (elements only)\n    const existing = parent.childNodes[index] as Node | undefined;\n\n    // Primitive child: try to reuse Text node if available\n    if (typeof child === 'string' || typeof child === 'number') {\n      if (existing && existing.nodeType === 3) {\n        // Text node: reuse in-place\n        (existing as Text).data = String(child);\n        usedOldEls.add(existing);\n        return existing;\n      }\n      return createDOMNode(child);\n    }\n\n    if (existing instanceof Element) {\n      const synced = trySyncComponentChild(existing, child, usedOldEls);\n      if (synced) return synced;\n    }\n\n    // Element child matching existing unkeyed element\n    if (existing instanceof Element && canReuseElement(existing, child)) {\n      updateElementFromVnode(existing, child);\n      usedOldEls.add(existing);\n      return existing;\n    }\n\n    // Try to find available unkeyed element elsewhere\n    const avail = resolveUnkeyedOnce();\n    if (avail) {\n      const reuseResult = tryReuseElement(avail, child, usedOldEls);\n      if (reuseResult) return reuseResult;\n    }\n  } catch {\n    // Fall through to create new\n  }\n\n  const dom = createDOMNode(child);\n  return dom;\n}\n\nfunction isComponentVNode(child: VNode): child is ComponentVNode {\n  return (\n    typeof child === 'object' &&\n    child !== null &&\n    'type' in child &&\n    typeof (child as VnodeObj).type === 'function'\n  );\n}\n\nfunction trySyncComponentChild(\n  existing: Element,\n  child: VNode,\n  usedOldEls: WeakSet<Node>\n): Node | null {\n  if (!isComponentVNode(child)) return null;\n\n  const synced = syncComponentElement(\n    existing,\n    child,\n    child.type,\n    ((child.props ?? {}) as Props) || {}\n  );\n  if (!synced) return null;\n\n  usedOldEls.add(existing);\n  usedOldEls.add(synced);\n  return synced;\n}\n\n/** Check if existing element can be reused for child */\nfunction canReuseElement(existing: Element | undefined, child: VNode): boolean {\n  if (!existing) return false;\n  if (typeof child !== 'object' || child === null || !('type' in child))\n    return false;\n\n  const childObj = child as VnodeObj;\n  const existingKey = existing.getAttribute('data-key');\n  const hasNoKey = existingKey === null || existingKey === undefined;\n\n  return (\n    hasNoKey &&\n    typeof childObj.type === 'string' &&\n    tagNamesEqualIgnoreCase(existing.tagName, childObj.type)\n  );\n}\n\n/** Collect unkeyed element children in DOM order. */\nfunction collectUnkeyedElements(parent: Element): Element[] {\n  const elements: Element[] = [];\n  for (let ch = parent.firstElementChild; ch; ch = ch.nextElementSibling) {\n    if (ch.getAttribute('data-key') === null) elements.push(ch);\n  }\n  return elements;\n}\n\n/** Try to reuse available element for child */\nfunction tryReuseElement(\n  avail: Element,\n  child: VNode,\n  usedOldEls: WeakSet<Node>\n): Node | null {\n  if (typeof child === 'string' || typeof child === 'number') {\n    return null;\n  }\n\n  const synced = trySyncComponentChild(avail, child, usedOldEls);\n  if (synced) {\n    return synced;\n  }\n\n  if (typeof child === 'object' && child !== null && 'type' in child) {\n    const childObj = child as VnodeObj;\n    if (\n      typeof childObj.type === 'string' &&\n      tagNamesEqualIgnoreCase(avail.tagName, childObj.type)\n    ) {\n      updateElementFromVnode(avail, child);\n      usedOldEls.add(avail);\n      return avail;\n    }\n  }\n\n  return null;\n}\n\n/** Commit reconciliation by replacing parent children */\nfunction commitReconciliation(parent: Element, finalNodes: Node[]): void {\n  try {\n    const finalSet = new Set<Node>(finalNodes);\n\n    for (let n = parent.firstChild; n; ) {\n      const next = n.nextSibling;\n      if (!finalSet.has(n)) {\n        teardownNodeSubtree(n);\n        parent.removeChild(n);\n      }\n      n = next;\n    }\n\n    for (let i = 0; i < finalNodes.length; i++) {\n      const desiredNode = finalNodes[i];\n      const anchor = parent.childNodes[i] ?? null;\n      if (desiredNode !== anchor) {\n        parent.insertBefore(desiredNode, anchor);\n      }\n    }\n  } catch {\n    const fragment = document.createDocumentFragment();\n    for (let i = 0; i < finalNodes.length; i++) {\n      fragment.appendChild(finalNodes[i]);\n    }\n\n    try {\n      for (let n = parent.firstChild; n; ) {\n        const next = n.nextSibling;\n        teardownNodeSubtree(n);\n        n = next;\n      }\n    } catch {\n      // Ignore fallback cleanup failures.\n    }\n\n    recordDOMReplace('reconcile');\n    parent.replaceChildren(fragment);\n    return;\n  }\n}\n"],"mappings":"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"}

package/dist/renderer/types.js

@@ -1 +1 @@
-import{_isDOMElement as o}from"../common/vnode.js";export{o as _isDOMElement};
+import "../common/vnode.js";

package/dist/renderer/utils.js

@@ -1 +1,220 @@
-import{globalScheduler as A}from"../runtime/scheduler.js";import{logger as i}from"../dev/logger.js";import{incDevCounter as l,setDevValue as u}from"../runtime/dev-namespace.js";var a={};const s=new WeakMap;let f=0;const _=1e3;function g(r){return!r.startsWith("on")||r.length<=2?null:r.slice(2).charAt(0).toLowerCase()+r.slice(3).toLowerCase()}function w(r){if(r==="wheel"||r==="scroll"||r.startsWith("touch"))return{passive:!0}}function C(r,t=!1){const e=s.get(r);if(e){const o=e.get(t);if(o)return o}const n=o=>{try{A.runInHandlerScope(()=>{try{r(o)}catch(c){i.error("[Askr] Event handler error:",c)}},t?"sync":"defer")}catch(c){t?queueMicrotask(()=>{throw c}):i.error("[Askr] Event handler error:",c)}};try{s.has(r)||f>=_||(f++,s.set(r,new Map)),s.get(r)?.set(t,n)}catch{}return n}function P(r){return r==="children"||r==="key"||r==="ref"}function h(r){return!!(r==="children"||r==="key"||r.startsWith("on")&&r.length>2||r.startsWith("data-"))}function d(r,t,e){try{if(t==="class"||t==="className")return r.className!==String(e);if(t==="value"||t==="checked")return r[t]!==e;const n=r.getAttribute(t);return e==null||e===!1?n!==null:String(e)!==n}catch{return!0}}function E(r){for(const t of Object.keys(r))if(!h(t))return!0;return!1}function b(r,t){for(const e of Object.keys(t))if(!h(e)&&d(r,e,t[e]))return!0;return!1}function F(r){if(typeof r!="object"||r===null)return;const t=r,e=t.key??t.props?.key;if(e!==void 0)return typeof e=="symbol"?String(e):e}function m(r){const t=new Map;for(let e=r.firstElementChild;e;e=e.nextElementSibling){const n=e.getAttribute("data-key");if(n!==null){t.set(n,e);const o=Number(n);Number.isNaN(o)||t.set(o,e)}}return t}function y(r){try{l("__DOM_REPLACE_COUNT"),u(`__LAST_DOM_REPLACE_STACK_${r}`,new Error().stack)}catch{}}function M(r,t){try{u("__LAST_FASTPATH_STATS",r),u("__LAST_FASTPATH_COMMIT_COUNT",1),t&&l(t)}catch{}}function k(r,t,e){(a.ASKR_FASTPATH_DEBUG==="1"||a.ASKR_FASTPATH_DEBUG==="true")&&(e!==void 0?i.warn(`[Askr][FASTPATH] ${r}`,t,e):t!==void 0?i.warn(`[Askr][FASTPATH] ${r}`,t):i.warn(`[Askr][FASTPATH] ${r}`))}function H(){return typeof performance<"u"&&performance.now?performance.now():Date.now()}export{m as buildKeyMapFromChildren,b as checkPropChanges,C as createWrappedHandler,F as extractKey,w as getPassiveOptions,E as hasNonTrivialProps,d as hasPropChanged,h as isIgnoredForPropChanges,P as isSkippedProp,k as logFastPathDebug,H as now,g as parseEventName,y as recordDOMReplace,M as recordFastPathStats};
+import { getRuntimeEnv } from "../common/env.js";
+import { logger } from "../dev/logger.js";
+import { globalScheduler } from "../runtime/scheduler.js";
+import { incDevCounter, setDevValue } from "../runtime/dev-namespace.js";
+import "./env.js";
+//#region src/renderer/utils.ts
+/**
+* Shared utilities for the renderer module.
+* Consolidates common patterns to reduce code duplication.
+*/
+const handlerCache = /* @__PURE__ */ new WeakMap();
+let cacheSize = 0;
+const MAX_CACHE_SIZE = 1e3;
+/**
+* Parse an event prop name (e.g., 'onClick') to its DOM event name (e.g., 'click')
+*/
+function parseEventName(propName) {
+	if (!propName.startsWith("on") || propName.length <= 2) return null;
+	return propName.slice(2).charAt(0).toLowerCase() + propName.slice(3).toLowerCase();
+}
+/**
+* Get default event listener options for passive events
+*/
+function getPassiveOptions(eventName) {
+	if (eventName === "wheel" || eventName === "scroll" || eventName.startsWith("touch")) return { passive: true };
+}
+/**
+* Create a wrapped event handler that integrates with the scheduler
+* Uses caching to avoid recreating wrappers for the same handler
+*/
+function createWrappedHandler(handler, flushAfter = false) {
+	const cachedByFlush = handlerCache.get(handler);
+	if (cachedByFlush) {
+		const cached = cachedByFlush.get(flushAfter);
+		if (cached) return cached;
+	}
+	const wrapped = (event) => {
+		try {
+			globalScheduler.runInHandlerScope(() => {
+				try {
+					handler(event);
+				} catch (error) {
+					logger.error("[Askr] Event handler error:", error);
+				}
+			}, flushAfter ? "sync" : "defer");
+		} catch (err) {
+			if (flushAfter) queueMicrotask(() => {
+				throw err;
+			});
+			else logger.error("[Askr] Event handler error:", err);
+		}
+	};
+	try {
+		if (!handlerCache.has(handler)) if (cacheSize >= MAX_CACHE_SIZE) {} else {
+			cacheSize++;
+			handlerCache.set(handler, /* @__PURE__ */ new Map());
+		}
+		handlerCache.get(handler)?.set(flushAfter, wrapped);
+	} catch {}
+	return wrapped;
+}
+function createMutableWrappedHandler(handler, flushAfter = false) {
+	let currentHandler = handler;
+	const wrapped = (event) => {
+		try {
+			globalScheduler.runInHandlerScope(() => {
+				try {
+					currentHandler(event);
+				} catch (error) {
+					logger.error("[Askr] Event handler error:", error);
+				}
+			}, flushAfter ? "sync" : "defer");
+		} catch (err) {
+			if (flushAfter) queueMicrotask(() => {
+				throw err;
+			});
+			else logger.error("[Askr] Event handler error:", err);
+		}
+	};
+	return {
+		handler: wrapped,
+		updateHandler(nextHandler) {
+			currentHandler = nextHandler;
+		}
+	};
+}
+/** Props that should be skipped during attribute processing */
+function isSkippedProp(key) {
+	return key === "children" || key === "key" || key === "ref";
+}
+/** Check if prop should be ignored for prop-change detection */
+function isIgnoredForPropChanges(key) {
+	if (key === "children" || key === "key") return true;
+	if (key.startsWith("on") && key.length > 2) return true;
+	if (key.startsWith("data-")) return true;
+	return false;
+}
+/**
+* Check if an element's current attribute value differs from vnode value
+*/
+function hasPropChanged(el, key, value) {
+	try {
+		if (key === "class" || key === "className") return readElementClassName(el) !== String(value);
+		if (key === "value" || key === "checked") return el[key] !== value;
+		const attr = el.getAttribute(key);
+		if (value === void 0 || value === null || value === false) return attr !== null;
+		return String(value) !== attr;
+	} catch {
+		return true;
+	}
+}
+function isSVGDomElement(el) {
+	return typeof SVGElement !== "undefined" && el instanceof SVGElement;
+}
+function readElementClassName(el) {
+	if (isSVGDomElement(el)) return el.getAttribute("class") ?? "";
+	return el.className;
+}
+function writeElementClassName(el, value) {
+	if (isSVGDomElement(el)) {
+		if (value.length > 0) el.setAttribute("class", value);
+		else el.removeAttribute("class");
+		return;
+	}
+	el.className = value;
+}
+function tagNamesEqualIgnoreCase(a, b) {
+	if (a === b) return true;
+	if (a.length !== b.length) return false;
+	for (let index = 0; index < a.length; index += 1) {
+		const aCode = a.charCodeAt(index);
+		const bCode = b.charCodeAt(index);
+		if (aCode === bCode) continue;
+		if ((aCode >= 65 && aCode <= 90 ? aCode + 32 : aCode) !== (bCode >= 65 && bCode <= 90 ? bCode + 32 : bCode)) return false;
+	}
+	return true;
+}
+/**
+* Check if a vnode has non-trivial props (excluding events and data-*)
+*/
+function hasNonTrivialProps(props) {
+	for (const k of Object.keys(props)) {
+		if (isIgnoredForPropChanges(k)) continue;
+		return true;
+	}
+	return false;
+}
+/**
+* Check for prop changes between vnode and existing element
+*/
+function checkPropChanges(el, props) {
+	for (const k of Object.keys(props)) {
+		if (isIgnoredForPropChanges(k)) continue;
+		if (hasPropChanged(el, k, props[k])) return true;
+	}
+	return false;
+}
+/**
+* Extract key from a vnode object
+*/
+function extractKey(vnode) {
+	if (typeof vnode !== "object" || vnode === null) return void 0;
+	const obj = vnode;
+	const rawKey = obj.key ?? obj.props?.key;
+	if (rawKey === void 0 || rawKey === null) return void 0;
+	return typeof rawKey === "symbol" ? String(rawKey) : rawKey;
+}
+/**
+* Build a key map from element's children
+*/
+function buildKeyMapFromChildren(parent) {
+	const map = /* @__PURE__ */ new Map();
+	for (let ch = parent.firstElementChild; ch; ch = ch.nextElementSibling) {
+		const k = ch.getAttribute("data-key");
+		if (k !== null) {
+			map.set(k, ch);
+			const n = Number(k);
+			if (!Number.isNaN(n)) map.set(n, ch);
+		}
+	}
+	return map;
+}
+/**
+* Record DOM replace operation for diagnostics
+*/
+function recordDOMReplace(source) {
+	try {
+		incDevCounter("__DOM_REPLACE_COUNT");
+		setDevValue(`__LAST_DOM_REPLACE_STACK_${source}`, (/* @__PURE__ */ new Error()).stack);
+	} catch {}
+}
+/**
+* Record fast-path stats for diagnostics
+*/
+function recordFastPathStats(stats, counterName) {
+	try {
+		setDevValue("__LAST_FASTPATH_STATS", stats);
+		setDevValue("__LAST_FASTPATH_COMMIT_COUNT", 1);
+		if (counterName) incDevCounter(counterName);
+	} catch {}
+}
+/**
+* Conditionally log debug info for fast-path operations
+*/
+function logFastPathDebug(message, indexOrData, data) {
+	const env = getRuntimeEnv();
+	if (env.ASKR_FASTPATH_DEBUG === "1" || env.ASKR_FASTPATH_DEBUG === "true") if (data !== void 0) logger.warn(`[Askr][FASTPATH] ${message}`, indexOrData, data);
+	else if (indexOrData !== void 0) logger.warn(`[Askr][FASTPATH] ${message}`, indexOrData);
+	else logger.warn(`[Askr][FASTPATH] ${message}`);
+}
+/**
+* Get current high-resolution timestamp
+*/
+function now() {
+	return typeof performance !== "undefined" && performance.now ? performance.now() : Date.now();
+}
+//#endregion
+export { buildKeyMapFromChildren, checkPropChanges, createMutableWrappedHandler, createWrappedHandler, extractKey, getPassiveOptions, hasNonTrivialProps, hasPropChanged, isIgnoredForPropChanges, isSkippedProp, logFastPathDebug, now, parseEventName, readElementClassName, recordDOMReplace, recordFastPathStats, tagNamesEqualIgnoreCase, writeElementClassName };
+
+//# sourceMappingURL=utils.js.map