@askrjs/askr 0.0.28 → 0.0.29

package/dist/renderer/fastpath.js

@@ -1 +1,145 @@
-import{createDOMNode as S}from"./dom.js";import{_reconcilerRecordedParents as P}from"./keyed.js";import{logger as v}from"../dev/logger.js";import{removeAllListeners as y,cleanupInstanceIfPresent as D}from"./cleanup.js";import{incDevCounter as E,setDevValue as p}from"../runtime/dev-namespace.js";import{isSchedulerExecuting as F}from"../runtime/scheduler.js";import{isBulkCommitActive as k,markFastPathApplied as w}from"../runtime/fastlane.js";var C={};const x=typeof document<"u";function I(l,a,h,f){if(typeof document>"u")return null;const A=a.length;if(A===0&&(!f||f.length===0))return null;F()||v.warn("[Askr][FASTPATH][DEV] Fast-path reconciliation invoked outside scheduler execution");let c,m;if(A<=20)try{const e=l.children;c=new Array(e.length);for(let n=0;n<e.length;n++)c[n]=e[n]}catch(e){c=void 0}else if(!h||h.size===0){m=new Map;try{for(let e=l.firstElementChild;e;e=e.nextElementSibling){const n=e.getAttribute("data-key");if(n!==null){m.set(n,e);const o=Number(n);Number.isNaN(o)||m.set(o,e)}}}catch(e){m=void 0}}const s=[];let T=0,_=0,d=0;for(let e=0;e<a.length;e++){const{key:n,vnode:o}=a[e];T++;let r;if(A<=20&&c){const t=String(n);for(let i=0;i<c.length;i++){const u=c[i],g=u.getAttribute("data-key");if(g!==null&&(g===t||Number(g)===n)){r=u;break}}r||(r=h?.get(n))}else r=m?.get(n)??h?.get(n);if(r)s.push(r),d++;else{const t=S(o);t&&(s.push(t),_++)}}if(f&&f.length)for(const e of f){const n=S(e);n&&(s.push(n),_++)}try{const e=Date.now(),n=document.createDocumentFragment();let o=0;for(let t=0;t<s.length;t++)n.appendChild(s[t]),o++;try{for(let t=l.firstChild;t;){const i=t.nextSibling;t instanceof Element&&y(t),D(t),t=i}}catch(t){}try{E("__DOM_REPLACE_COUNT"),p("__LAST_DOM_REPLACE_STACK_FASTPATH",new Error().stack)}catch(t){}l.replaceChildren(n);try{p("__LAST_FASTPATH_COMMIT_COUNT",1)}catch(t){}try{k()&&w(l)}catch(t){}const r=new Map;for(let t=0;t<a.length;t++){const i=a[t].key,u=s[t];u instanceof Element&&r.set(i,u)}try{const t={n:A,moves:0,lisLen:0,t_lookup:0,t_fragment:Date.now()-e,t_commit:0,t_bookkeeping:0,fragmentAppendCount:o,mapLookups:T,createdNodes:_,reusedCount:d};typeof globalThis<"u"&&(p("__LAST_FASTPATH_STATS",t),p("__LAST_FASTPATH_REUSED",d>0),E("fastpathHistoryPush")),(C.ASKR_FASTPATH_DEBUG==="1"||C.ASKR_FASTPATH_DEBUG==="true")&&v.warn("[Askr][FASTPATH]",JSON.stringify({n:A,createdNodes:_,reusedCount:d}))}catch(t){}try{P.add(l)}catch(t){}return r}catch(e){return null}}export{x as IS_DOM_AVAILABLE,I as applyRendererFastPath};
+import { getRuntimeEnv } from "../common/env.js";
+import { logger } from "../dev/logger.js";
+import { isSchedulerExecuting } from "../runtime/scheduler.js";
+import { incDevCounter, setDevValue } from "../runtime/dev-namespace.js";
+import "./env.js";
+import { _reconcilerRecordedParents } from "./keyed.js";
+import { isBulkCommitActive, markFastPathApplied } from "../runtime/fastlane.js";
+import { cleanupInstanceIfPresent, removeAllListeners } from "./cleanup.js";
+import { createDOMNode } from "./dom.js";
+function applyRendererFastPath(parent, keyedVnodes, oldKeyMap, unkeyedVnodes) {
+	if (typeof document === "undefined") return null;
+	const totalKeyed = keyedVnodes.length;
+	if (totalKeyed === 0 && (!unkeyedVnodes || unkeyedVnodes.length === 0)) return null;
+	if (!isSchedulerExecuting()) logger.warn("[Askr][FASTPATH][DEV] Fast-path reconciliation invoked outside scheduler execution");
+	let parentChildrenArr;
+	let localOldKeyMap;
+	if (totalKeyed <= 20) try {
+		parentChildrenArr = Array.from(parent.children, (child) => child);
+	} catch (e) {
+		parentChildrenArr = void 0;
+	}
+	else if (!oldKeyMap || oldKeyMap.size === 0) {
+		localOldKeyMap = /* @__PURE__ */ new Map();
+		try {
+			for (let ch = parent.firstElementChild; ch; ch = ch.nextElementSibling) {
+				const k = ch.getAttribute("data-key");
+				if (k !== null) {
+					localOldKeyMap.set(k, ch);
+					const n = Number(k);
+					if (!Number.isNaN(n)) localOldKeyMap.set(n, ch);
+				}
+			}
+		} catch (e) {
+			localOldKeyMap = void 0;
+		}
+	}
+	const finalNodes = [];
+	let mapLookups = 0;
+	let createdNodes = 0;
+	let reusedCount = 0;
+	for (let i = 0; i < keyedVnodes.length; i++) {
+		const { key, vnode } = keyedVnodes[i];
+		mapLookups++;
+		let el;
+		if (totalKeyed <= 20 && parentChildrenArr) {
+			const ks = String(key);
+			for (let j = 0; j < parentChildrenArr.length; j++) {
+				const ch = parentChildrenArr[j];
+				const k = ch.getAttribute("data-key");
+				if (k !== null && (k === ks || Number(k) === key)) {
+					el = ch;
+					break;
+				}
+			}
+			if (!el) el = oldKeyMap?.get(key);
+		} else el = localOldKeyMap?.get(key) ?? oldKeyMap?.get(key);
+		if (el) {
+			finalNodes.push(el);
+			reusedCount++;
+		} else {
+			const newEl = createDOMNode(vnode);
+			if (newEl) {
+				finalNodes.push(newEl);
+				createdNodes++;
+			}
+		}
+	}
+	if (unkeyedVnodes && unkeyedVnodes.length) for (const vnode of unkeyedVnodes) {
+		const newEl = createDOMNode(vnode);
+		if (newEl) {
+			finalNodes.push(newEl);
+			createdNodes++;
+		}
+	}
+	try {
+		const tFragmentStart = Date.now();
+		const fragment = document.createDocumentFragment();
+		let fragmentAppendCount = 0;
+		for (let i = 0; i < finalNodes.length; i++) {
+			fragment.appendChild(finalNodes[i]);
+			fragmentAppendCount++;
+		}
+		try {
+			for (let n = parent.firstChild; n;) {
+				const next = n.nextSibling;
+				if (n instanceof Element) removeAllListeners(n);
+				cleanupInstanceIfPresent(n);
+				n = next;
+			}
+		} catch (e) {}
+		try {
+			incDevCounter("__DOM_REPLACE_COUNT");
+			setDevValue("__LAST_DOM_REPLACE_STACK_FASTPATH", (/* @__PURE__ */ new Error()).stack);
+		} catch (e) {}
+		parent.replaceChildren(fragment);
+		try {
+			setDevValue("__LAST_FASTPATH_COMMIT_COUNT", 1);
+		} catch (e) {}
+		try {
+			if (isBulkCommitActive()) markFastPathApplied(parent);
+		} catch (e) {}
+		const newKeyMap = /* @__PURE__ */ new Map();
+		for (let i = 0; i < keyedVnodes.length; i++) {
+			const key = keyedVnodes[i].key;
+			const node = finalNodes[i];
+			if (node instanceof Element) newKeyMap.set(key, node);
+		}
+		try {
+			const stats = {
+				n: totalKeyed,
+				moves: 0,
+				lisLen: 0,
+				t_lookup: 0,
+				t_fragment: Date.now() - tFragmentStart,
+				t_commit: 0,
+				t_bookkeeping: 0,
+				fragmentAppendCount,
+				mapLookups,
+				createdNodes,
+				reusedCount
+			};
+			if (typeof globalThis !== "undefined") {
+				setDevValue("__LAST_FASTPATH_STATS", stats);
+				setDevValue("__LAST_FASTPATH_REUSED", reusedCount > 0);
+				incDevCounter("fastpathHistoryPush");
+			}
+			const env = getRuntimeEnv();
+			if (env.ASKR_FASTPATH_DEBUG === "1" || env.ASKR_FASTPATH_DEBUG === "true") logger.warn("[Askr][FASTPATH]", JSON.stringify({
+				n: totalKeyed,
+				createdNodes,
+				reusedCount
+			}));
+		} catch (e) {}
+		try {
+			_reconcilerRecordedParents.add(parent);
+		} catch (e) {}
+		return newKeyMap;
+	} catch (e) {
+		return null;
+	}
+}
+//#endregion
+export { applyRendererFastPath };
+
+//# sourceMappingURL=fastpath.js.map

package/dist/renderer/fastpath.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fastpath.js","names":[],"sources":["../../src/renderer/fastpath.ts"],"sourcesContent":["import type { VNode } from './types';\nimport { createDOMNode } from './dom';\nimport { _reconcilerRecordedParents } from './keyed';\nimport { logger } from '../dev/logger';\nimport { getRuntimeEnv } from './env';\nimport { cleanupInstanceIfPresent, removeAllListeners } from './cleanup';\nimport { setDevValue, incDevCounter } from '../runtime/dev-namespace';\nimport { isSchedulerExecuting } from '../runtime/scheduler';\nimport { isBulkCommitActive, markFastPathApplied } from '../runtime/fastlane';\n\nexport const IS_DOM_AVAILABLE = typeof document !== 'undefined';\n\n// Apply the \"renderer\" fast-path: build final node list reusing existing\n// elements by key when possible, then perform a single atomic replaceChildren\n// commit. Returns a new key map when the fast-path is applied, otherwise\n// returns null to indicate the caller should continue with fallback paths.\nexport function applyRendererFastPath(\n  parent: Element,\n  keyedVnodes: Array<{ key: string | number; vnode: VNode }>,\n  oldKeyMap?: Map<string | number, Element>,\n  unkeyedVnodes?: VNode[]\n): Map<string | number, Element> | null {\n  // SSR guard: fast-path is DOM-specific\n  if (typeof document === 'undefined') return null;\n\n  const totalKeyed = keyedVnodes.length;\n  if (totalKeyed === 0 && (!unkeyedVnodes || unkeyedVnodes.length === 0))\n    return null;\n\n  // Dev invariant: ensure we are executing inside the scheduler/commit flush\n  if (!isSchedulerExecuting()) {\n    logger.warn(\n      '[Askr][FASTPATH][DEV] Fast-path reconciliation invoked outside scheduler execution'\n    );\n  }\n\n  // Choose lookup strategy depending on size (linear scan for small lists)\n  let parentChildrenArr: Element[] | undefined;\n  let localOldKeyMap: Map<string | number, Element> | undefined;\n\n  if (totalKeyed <= 20) {\n    // Small lists: use array scan (faster than Map overhead for ≤20 items)\n    try {\n      parentChildrenArr = Array.from(\n        parent.children,\n        (child) => child as Element\n      );\n    } catch (e) {\n      parentChildrenArr = undefined;\n      void e;\n    }\n  } else if (!oldKeyMap || oldKeyMap.size === 0) {\n    // Medium/large lists without existing key map: build from DOM\n    localOldKeyMap = new Map<string | number, Element>();\n    try {\n      for (let ch = parent.firstElementChild; ch; ch = ch.nextElementSibling) {\n        const k = ch.getAttribute('data-key');\n        if (k !== null) {\n          localOldKeyMap.set(k, ch);\n          const n = Number(k);\n          if (!Number.isNaN(n)) localOldKeyMap.set(n, ch);\n        }\n      }\n    } catch (e) {\n      localOldKeyMap = undefined;\n      void e;\n    }\n  }\n  // else: reuse oldKeyMap directly (most common case for repeat renders)\n\n  const finalNodes: Node[] = [];\n  let mapLookups = 0;\n  let createdNodes = 0;\n  let reusedCount = 0;\n\n  for (let i = 0; i < keyedVnodes.length; i++) {\n    const { key, vnode } = keyedVnodes[i];\n    mapLookups++;\n\n    let el: Element | undefined;\n    if (totalKeyed <= 20 && parentChildrenArr) {\n      const ks = String(key);\n      for (let j = 0; j < parentChildrenArr.length; j++) {\n        const ch = parentChildrenArr[j];\n        const k = ch.getAttribute('data-key');\n        if (k !== null && (k === ks || Number(k) === (key as number))) {\n          el = ch;\n          break;\n        }\n      }\n      if (!el) el = oldKeyMap?.get(key);\n    } else {\n      el = localOldKeyMap?.get(key as string | number) ?? oldKeyMap?.get(key);\n    }\n\n    if (el) {\n      finalNodes.push(el);\n      reusedCount++;\n    } else {\n      const newEl = createDOMNode(vnode);\n      if (newEl) {\n        finalNodes.push(newEl);\n        createdNodes++;\n      }\n    }\n  }\n\n  // Add unkeyed nodes (detached as well)\n  if (unkeyedVnodes && unkeyedVnodes.length) {\n    for (const vnode of unkeyedVnodes) {\n      const newEl = createDOMNode(vnode);\n      if (newEl) {\n        finalNodes.push(newEl);\n        createdNodes++;\n      }\n    }\n  }\n\n  // Atomic commit\n  try {\n    const tFragmentStart = Date.now();\n    const fragment = document.createDocumentFragment();\n    let fragmentAppendCount = 0;\n    for (let i = 0; i < finalNodes.length; i++) {\n      fragment.appendChild(finalNodes[i]);\n      fragmentAppendCount++;\n    }\n\n    // Pre-cleanup: remove component instances that will be removed by replaceChildren\n    try {\n      // At this point, any reused nodes have been moved into the fragment,\n      // so whatever remains under parent will be removed by replaceChildren.\n      for (let n = parent.firstChild; n; ) {\n        const next = n.nextSibling;\n        if (n instanceof Element) removeAllListeners(n);\n        cleanupInstanceIfPresent(n);\n        n = next;\n      }\n    } catch (e) {\n      void e;\n    }\n\n    try {\n      incDevCounter('__DOM_REPLACE_COUNT');\n      setDevValue('__LAST_DOM_REPLACE_STACK_FASTPATH', new Error().stack);\n    } catch (e) {\n      void e;\n    }\n\n    parent.replaceChildren(fragment);\n\n    // Record that we performed exactly one DOM commit.\n    try {\n      setDevValue('__LAST_FASTPATH_COMMIT_COUNT', 1);\n    } catch (e) {\n      void e;\n    }\n\n    // If a runtime bulk commit is active, mark this parent as fast-path applied.\n    try {\n      if (isBulkCommitActive()) markFastPathApplied(parent);\n    } catch (e) {\n      void e;\n    }\n\n    // Phase: bookkeeping - populate newKeyMap\n    const newKeyMap = new Map<string | number, Element>();\n    for (let i = 0; i < keyedVnodes.length; i++) {\n      const key = keyedVnodes[i].key;\n      const node = finalNodes[i];\n      if (node instanceof Element) newKeyMap.set(key, node as Element);\n    }\n\n    // Dev tracing\n    try {\n      const stats = {\n        n: totalKeyed,\n        moves: 0,\n        lisLen: 0,\n        t_lookup: 0,\n        t_fragment: Date.now() - tFragmentStart,\n        t_commit: 0,\n        t_bookkeeping: 0,\n        fragmentAppendCount,\n        mapLookups,\n        createdNodes,\n        reusedCount,\n      } as const;\n      if (typeof globalThis !== 'undefined') {\n        setDevValue('__LAST_FASTPATH_STATS', stats);\n        setDevValue('__LAST_FASTPATH_REUSED', reusedCount > 0);\n        incDevCounter('fastpathHistoryPush');\n      }\n      const env = getRuntimeEnv();\n      if (\n        env.ASKR_FASTPATH_DEBUG === '1' ||\n        env.ASKR_FASTPATH_DEBUG === 'true'\n      ) {\n        logger.warn(\n          '[Askr][FASTPATH]',\n          JSON.stringify({ n: totalKeyed, createdNodes, reusedCount })\n        );\n      }\n    } catch (e) {\n      void e;\n    }\n\n    // Record that reconciler recorded stats for this parent in this pass\n    try {\n      _reconcilerRecordedParents.add(parent);\n    } catch (e) {\n      void e;\n    }\n\n    return newKeyMap;\n  } catch (e) {\n    void e;\n    return null;\n  }\n}\n"],"mappings":";;;;;;;;;AAgBA,SAAgB,sBACd,QACA,aACA,WACA,eACsC;AAEtC,KAAI,OAAO,aAAa,YAAa,QAAO;CAE5C,MAAM,aAAa,YAAY;AAC/B,KAAI,eAAe,MAAM,CAAC,iBAAiB,cAAc,WAAW,GAClE,QAAO;AAGT,KAAI,CAAC,sBAAsB,CACzB,QAAO,KACL,qFACD;CAIH,IAAI;CACJ,IAAI;AAEJ,KAAI,cAAc,GAEhB,KAAI;AACF,sBAAoB,MAAM,KACxB,OAAO,WACN,UAAU,MACZ;UACM,GAAG;AACV,sBAAoB;;UAGb,CAAC,aAAa,UAAU,SAAS,GAAG;AAE7C,mCAAiB,IAAI,KAA+B;AACpD,MAAI;AACF,QAAK,IAAI,KAAK,OAAO,mBAAmB,IAAI,KAAK,GAAG,oBAAoB;IACtE,MAAM,IAAI,GAAG,aAAa,WAAW;AACrC,QAAI,MAAM,MAAM;AACd,oBAAe,IAAI,GAAG,GAAG;KACzB,MAAM,IAAI,OAAO,EAAE;AACnB,SAAI,CAAC,OAAO,MAAM,EAAE,CAAE,gBAAe,IAAI,GAAG,GAAG;;;WAG5C,GAAG;AACV,oBAAiB;;;CAMrB,MAAM,aAAqB,EAAE;CAC7B,IAAI,aAAa;CACjB,IAAI,eAAe;CACnB,IAAI,cAAc;AAElB,MAAK,IAAI,IAAI,GAAG,IAAI,YAAY,QAAQ,KAAK;EAC3C,MAAM,EAAE,KAAK,UAAU,YAAY;AACnC;EAEA,IAAI;AACJ,MAAI,cAAc,MAAM,mBAAmB;GACzC,MAAM,KAAK,OAAO,IAAI;AACtB,QAAK,IAAI,IAAI,GAAG,IAAI,kBAAkB,QAAQ,KAAK;IACjD,MAAM,KAAK,kBAAkB;IAC7B,MAAM,IAAI,GAAG,aAAa,WAAW;AACrC,QAAI,MAAM,SAAS,MAAM,MAAM,OAAO,EAAE,KAAM,MAAiB;AAC7D,UAAK;AACL;;;AAGJ,OAAI,CAAC,GAAI,MAAK,WAAW,IAAI,IAAI;QAEjC,MAAK,gBAAgB,IAAI,IAAuB,IAAI,WAAW,IAAI,IAAI;AAGzE,MAAI,IAAI;AACN,cAAW,KAAK,GAAG;AACnB;SACK;GACL,MAAM,QAAQ,cAAc,MAAM;AAClC,OAAI,OAAO;AACT,eAAW,KAAK,MAAM;AACtB;;;;AAMN,KAAI,iBAAiB,cAAc,OACjC,MAAK,MAAM,SAAS,eAAe;EACjC,MAAM,QAAQ,cAAc,MAAM;AAClC,MAAI,OAAO;AACT,cAAW,KAAK,MAAM;AACtB;;;AAMN,KAAI;EACF,MAAM,iBAAiB,KAAK,KAAK;EACjC,MAAM,WAAW,SAAS,wBAAwB;EAClD,IAAI,sBAAsB;AAC1B,OAAK,IAAI,IAAI,GAAG,IAAI,WAAW,QAAQ,KAAK;AAC1C,YAAS,YAAY,WAAW,GAAG;AACnC;;AAIF,MAAI;AAGF,QAAK,IAAI,IAAI,OAAO,YAAY,IAAK;IACnC,MAAM,OAAO,EAAE;AACf,QAAI,aAAa,QAAS,oBAAmB,EAAE;AAC/C,6BAAyB,EAAE;AAC3B,QAAI;;WAEC,GAAG;AAIZ,MAAI;AACF,iBAAc,sBAAsB;AACpC,eAAY,sDAAqC,IAAI,OAAO,EAAC,MAAM;WAC5D,GAAG;AAIZ,SAAO,gBAAgB,SAAS;AAGhC,MAAI;AACF,eAAY,gCAAgC,EAAE;WACvC,GAAG;AAKZ,MAAI;AACF,OAAI,oBAAoB,CAAE,qBAAoB,OAAO;WAC9C,GAAG;EAKZ,MAAM,4BAAY,IAAI,KAA+B;AACrD,OAAK,IAAI,IAAI,GAAG,IAAI,YAAY,QAAQ,KAAK;GAC3C,MAAM,MAAM,YAAY,GAAG;GAC3B,MAAM,OAAO,WAAW;AACxB,OAAI,gBAAgB,QAAS,WAAU,IAAI,KAAK,KAAgB;;AAIlE,MAAI;GACF,MAAM,QAAQ;IACZ,GAAG;IACH,OAAO;IACP,QAAQ;IACR,UAAU;IACV,YAAY,KAAK,KAAK,GAAG;IACzB,UAAU;IACV,eAAe;IACf;IACA;IACA;IACA;IACD;AACD,OAAI,OAAO,eAAe,aAAa;AACrC,gBAAY,yBAAyB,MAAM;AAC3C,gBAAY,0BAA0B,cAAc,EAAE;AACtD,kBAAc,sBAAsB;;GAEtC,MAAM,MAAM,eAAe;AAC3B,OACE,IAAI,wBAAwB,OAC5B,IAAI,wBAAwB,OAE5B,QAAO,KACL,oBACA,KAAK,UAAU;IAAE,GAAG;IAAY;IAAc;IAAa,CAAC,CAC7D;WAEI,GAAG;AAKZ,MAAI;AACF,8BAA2B,IAAI,OAAO;WAC/B,GAAG;AAIZ,SAAO;UACA,GAAG;AAEV,SAAO"}

package/dist/renderer/index.js

@@ -1 +1,24 @@
-import"./types.js";import{cleanupInstanceIfPresent as d,cleanupInstancesUnder as c,elementListeners as u,elementReactivePropsCleanup as f,removeAllListeners as E,removeElementListeners as R,removeElementReactiveProps as y,teardownNodeSubtree as v}from"./cleanup.js";import{getKeyMapForElement as r,isKeyedReorderFastPathEligible as t}from"./keyed.js";import{_reconcilerRecordedParents as x,keyedElements as g,populateKeyMapForElement as k}from"./keyed.js";import{markReactivePropsDirtySource as o}from"./dom.js";import{IS_DOM_AVAILABLE as h,createDOMNode as D,createForBoundary as F,isBulkTextFastPathEligible as b,performBulkPositionalKeyedTextUpdate as A,performBulkTextReplace as B,updateElementChildren as I,updateElementFromVnode as K,updateUnkeyedChildren as L}from"./dom.js";import{evaluate as a}from"./evaluate.js";import{clearDOMRange as S}from"./evaluate.js";if(typeof globalThis<"u"){const e=globalThis;e.__ASKR_RENDERER={evaluate:a,isKeyedReorderFastPathEligible:t,getKeyMapForElement:r,markReactivePropsDirtySource:o}}export{h as IS_DOM_AVAILABLE,x as _reconcilerRecordedParents,d as cleanupInstanceIfPresent,c as cleanupInstancesUnder,S as clearDOMRange,D as createDOMNode,F as createForBoundary,u as elementListeners,f as elementReactivePropsCleanup,a as evaluate,r as getKeyMapForElement,b as isBulkTextFastPathEligible,t as isKeyedReorderFastPathEligible,g as keyedElements,o as markReactivePropsDirtySource,A as performBulkPositionalKeyedTextUpdate,B as performBulkTextReplace,k as populateKeyMapForElement,E as removeAllListeners,R as removeElementListeners,y as removeElementReactiveProps,v as teardownNodeSubtree,I as updateElementChildren,K as updateElementFromVnode,L as updateUnkeyedChildren};
+import "../common/vnode.js";
+import "./types.js";
+import { getKeyMapForElement, isKeyedReorderFastPathEligible } from "./keyed.js";
+import "./cleanup.js";
+import "./children.js";
+import { markReactivePropsDirtySource } from "./dom.js";
+import { evaluate } from "./evaluate.js";
+//#region src/renderer/index.ts
+function installRendererBridge() {
+	if (typeof globalThis !== "undefined") {
+		const _g = globalThis;
+		_g.__ASKR_RENDERER = {
+			evaluate,
+			isKeyedReorderFastPathEligible,
+			getKeyMapForElement,
+			markReactivePropsDirtySource
+		};
+	}
+	return true;
+}
+//#endregion
+export { installRendererBridge };
+
+//# sourceMappingURL=index.js.map

package/dist/renderer/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":["_evaluate","_markReactivePropsDirtySource"],"sources":["../../src/renderer/index.ts"],"sourcesContent":["// Renderer barrel entrypoint.\n// Keep this file small: re-export the public surface and attach the runtime\n// fast-lane bridge on import.\n\nexport * from './types';\nexport * from './cleanup';\nexport * from './keyed';\nexport * from './dom';\nexport { evaluate, clearDOMRange } from './evaluate';\n\nimport { evaluate as _evaluate } from './evaluate';\nimport { isKeyedReorderFastPathEligible, getKeyMapForElement } from './keyed';\nimport { markReactivePropsDirtySource as _markReactivePropsDirtySource } from './dom';\n\nexport function installRendererBridge(): true {\n  if (typeof globalThis !== 'undefined') {\n    const _g = globalThis as Record<string, unknown>;\n    _g.__ASKR_RENDERER = {\n      evaluate: _evaluate,\n      isKeyedReorderFastPathEligible,\n      getKeyMapForElement,\n      markReactivePropsDirtySource: _markReactivePropsDirtySource,\n    };\n  }\n  return true;\n}\n"],"mappings":";;;;;;;;AAcA,SAAgB,wBAA8B;AAC5C,KAAI,OAAO,eAAe,aAAa;EACrC,MAAM,KAAK;AACX,KAAG,kBAAkB;GACTA;GACV;GACA;GAC8BC;GAC/B;;AAEH,QAAO"}

package/dist/renderer/keyed.js

@@ -1 +1,119 @@
-import{buildKeyMapFromChildren as E,extractKey as O,isIgnoredForPropChanges as _,hasPropChanged as S}from"./utils.js";const h=new WeakMap;function R(r){return h.get(r)}function b(r){try{if(h.has(r))return;let t=E(r);if(t.size===0){t=new Map;const n=Array.from(r.children);for(const e of n){const o=(e.textContent||"").trim();if(o){t.set(o,e);const s=Number(o);Number.isNaN(s)||t.set(s,e)}}}t.size>0&&h.set(r,t)}catch{}}const C=new WeakSet,p=64;function k(r){const t=[];for(const n of r){const e=O(n);e!==void 0&&t.push({key:e,vnode:n})}return t}function F(r){const t=[];for(const n of r){if(n===-1)continue;let e=0,o=t.length;for(;e<o;){const s=e+o>>1;t[s]<n?e=s+1:o=s}e===t.length?t.push(n):t[e]=n}return t.length}function L(r,t){for(const{key:n,vnode:e}of r){const o=t?.get(n);if(!o||typeof e!="object"||e===null)continue;const l=e.props||{};for(const i of Object.keys(l))if(!_(i)&&S(o,i,l[i]))return!0}return!1}function P(r,t,n){const e=k(t),o=e.length,s=e.map(c=>c.key),l=n?Array.from(n.keys()):[];let i=0;for(let c=0;c<s.length;c++){const f=s[c];(c>=l.length||l[c]!==f||!n?.has(f))&&i++}const m=o>=p&&l.length>0&&i>Math.max(64,Math.floor(o*.1));let u=!1,a=0;if(o>=p){const c=Array.from(r.children),f=e.map(({key:y})=>{const g=n?.get(y);return g?.parentElement===r?c.indexOf(g):-1});a=F(f),u=a<Math.floor(o*.5)}const d=L(e,n);return{useFastPath:(m||u)&&!d,totalKeyed:o,moveCount:i,lisLen:a,hasPropChanges:d}}export{C as _reconcilerRecordedParents,R as getKeyMapForElement,P as isKeyedReorderFastPathEligible,h as keyedElements,b as populateKeyMapForElement};
+import { buildKeyMapFromChildren, extractKey, hasPropChanged, isIgnoredForPropChanges } from "./utils.js";
+//#region src/renderer/keyed.ts
+const keyedElements = /* @__PURE__ */ new WeakMap();
+/**
+* Retrieve existing keyed map for a parent element (runtime use)
+*/
+function getKeyMapForElement(el) {
+	return keyedElements.get(el);
+}
+/**
+* Populate a keyed map for an element by scanning its immediate children
+* for `data-key` attributes. Proactive initialization for runtime layers.
+*/
+function populateKeyMapForElement(parent) {
+	try {
+		if (keyedElements.has(parent)) return;
+		let domMap = buildKeyMapFromChildren(parent);
+		if (domMap.size === 0) {
+			domMap = /* @__PURE__ */ new Map();
+			const children = Array.from(parent.children);
+			for (const ch of children) {
+				const text = (ch.textContent || "").trim();
+				if (text) {
+					domMap.set(text, ch);
+					const n = Number(text);
+					if (!Number.isNaN(n)) domMap.set(n, ch);
+				}
+			}
+		}
+		if (domMap.size > 0) keyedElements.set(parent, domMap);
+	} catch {}
+}
+const _reconcilerRecordedParents = /* @__PURE__ */ new WeakSet();
+const LIS_THRESHOLD_MIN = 64;
+/**
+* Extract keyed vnodes from children array
+*/
+function extractKeyedVnodes(newChildren) {
+	const result = [];
+	for (const child of newChildren) {
+		const key = extractKey(child);
+		if (key !== void 0) result.push({
+			key,
+			vnode: child
+		});
+	}
+	return result;
+}
+/**
+* Compute LIS (Longest Increasing Subsequence) length for positions
+*/
+function computeLISLength(positions) {
+	const tails = [];
+	for (const pos of positions) {
+		if (pos === -1) continue;
+		let lo = 0;
+		let hi = tails.length;
+		while (lo < hi) {
+			const mid = lo + hi >> 1;
+			if (tails[mid] < pos) lo = mid + 1;
+			else hi = mid;
+		}
+		if (lo === tails.length) tails.push(pos);
+		else tails[lo] = pos;
+	}
+	return tails.length;
+}
+/**
+* Check for prop changes between vnodes and existing elements
+*/
+function checkVnodePropChanges(keyedVnodes, oldKeyMap) {
+	for (const { key, vnode } of keyedVnodes) {
+		const el = oldKeyMap?.get(key);
+		if (!el || typeof vnode !== "object" || vnode === null) continue;
+		const props = vnode.props || {};
+		for (const k of Object.keys(props)) {
+			if (isIgnoredForPropChanges(k)) continue;
+			if (hasPropChanged(el, k, props[k])) return true;
+		}
+	}
+	return false;
+}
+/**
+* Determine if keyed reorder fast-path should be used
+*/
+function isKeyedReorderFastPathEligible(parent, newChildren, oldKeyMap) {
+	const keyedVnodes = extractKeyedVnodes(newChildren);
+	const totalKeyed = keyedVnodes.length;
+	const newKeyOrder = keyedVnodes.map((kv) => kv.key);
+	const oldKeyOrder = oldKeyMap ? Array.from(oldKeyMap.keys()) : [];
+	let moveCount = 0;
+	for (let i = 0; i < newKeyOrder.length; i++) {
+		const k = newKeyOrder[i];
+		if (i >= oldKeyOrder.length || oldKeyOrder[i] !== k || !oldKeyMap?.has(k)) moveCount++;
+	}
+	const cheapMoveTrigger = totalKeyed >= LIS_THRESHOLD_MIN && oldKeyOrder.length > 0 && moveCount > Math.max(64, Math.floor(totalKeyed * .1));
+	let lisTrigger = false;
+	let lisLen = 0;
+	if (totalKeyed >= LIS_THRESHOLD_MIN) {
+		const parentChildren = Array.from(parent.children);
+		lisLen = computeLISLength(keyedVnodes.map(({ key }) => {
+			const el = oldKeyMap?.get(key);
+			return el?.parentElement === parent ? parentChildren.indexOf(el) : -1;
+		}));
+		lisTrigger = lisLen < Math.floor(totalKeyed * .5);
+	}
+	const hasPropChanges = checkVnodePropChanges(keyedVnodes, oldKeyMap);
+	return {
+		useFastPath: (cheapMoveTrigger || lisTrigger) && !hasPropChanges,
+		totalKeyed,
+		moveCount,
+		lisLen,
+		hasPropChanges
+	};
+}
+//#endregion
+export { _reconcilerRecordedParents, getKeyMapForElement, isKeyedReorderFastPathEligible, keyedElements, populateKeyMapForElement };
+
+//# sourceMappingURL=keyed.js.map

package/dist/renderer/keyed.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"keyed.js","names":[],"sources":["../../src/renderer/keyed.ts"],"sourcesContent":["import type { VNode } from './types';\nimport {\n  extractKey,\n  buildKeyMapFromChildren,\n  isIgnoredForPropChanges,\n  hasPropChanged,\n} from './utils';\n\n// ─────────────────────────────────────────────────────────────────────────────\n// Key Map Registry\n// ─────────────────────────────────────────────────────────────────────────────\n\nexport const keyedElements = new WeakMap<\n  Element,\n  Map<string | number, Element>\n>();\n\n/**\n * Retrieve existing keyed map for a parent element (runtime use)\n */\nexport function getKeyMapForElement(el: Element) {\n  return keyedElements.get(el);\n}\n\n/**\n * Populate a keyed map for an element by scanning its immediate children\n * for `data-key` attributes. Proactive initialization for runtime layers.\n */\nexport function populateKeyMapForElement(parent: Element): void {\n  try {\n    if (keyedElements.has(parent)) return;\n\n    let domMap = buildKeyMapFromChildren(parent);\n\n    // Fallback: map by textContent when keys are not materialized as attrs\n    if (domMap.size === 0) {\n      domMap = new Map();\n      const children = Array.from(parent.children);\n      for (const ch of children) {\n        const text = (ch.textContent || '').trim();\n        if (text) {\n          domMap.set(text, ch);\n          const n = Number(text);\n          if (!Number.isNaN(n)) domMap.set(n, ch);\n        }\n      }\n    }\n\n    if (domMap.size > 0) keyedElements.set(parent, domMap);\n  } catch {\n    // ignore\n  }\n}\n\n// Track which parents had the reconciler record fast-path stats during the\n// current evaluation, so we can preserve diagnostics across additional\n// reconciliations within the same render pass without leaking between runs.\nexport const _reconcilerRecordedParents = new WeakSet<Element>();\n\n// ─────────────────────────────────────────────────────────────────────────────\n// Fast-Path Eligibility\n// ─────────────────────────────────────────────────────────────────────────────\n\n// Configuration: LIS fast-path thresholds\nconst LIS_THRESHOLD_MIN = 64; // Minimum list size for LIS optimization\n\ninterface KeyedVnode {\n  key: string | number;\n  vnode: VNode;\n}\n\n/**\n * Extract keyed vnodes from children array\n */\nfunction extractKeyedVnodes(newChildren: VNode[]): KeyedVnode[] {\n  const result: KeyedVnode[] = [];\n  for (const child of newChildren) {\n    const key = extractKey(child);\n    if (key !== undefined) {\n      result.push({ key, vnode: child });\n    }\n  }\n  return result;\n}\n\n/**\n * Compute LIS (Longest Increasing Subsequence) length for positions\n */\nfunction computeLISLength(positions: number[]): number {\n  const tails: number[] = [];\n  for (const pos of positions) {\n    if (pos === -1) continue;\n    let lo = 0;\n    let hi = tails.length;\n    while (lo < hi) {\n      const mid = (lo + hi) >> 1;\n      if (tails[mid] < pos) lo = mid + 1;\n      else hi = mid;\n    }\n    if (lo === tails.length) tails.push(pos);\n    else tails[lo] = pos;\n  }\n  return tails.length;\n}\n\n/**\n * Check for prop changes between vnodes and existing elements\n */\nfunction checkVnodePropChanges(\n  keyedVnodes: KeyedVnode[],\n  oldKeyMap: Map<string | number, Element> | undefined\n): boolean {\n  for (const { key, vnode } of keyedVnodes) {\n    const el = oldKeyMap?.get(key);\n    if (!el || typeof vnode !== 'object' || vnode === null) continue;\n    const vnodeObj = vnode as unknown as { props?: Record<string, unknown> };\n    const props = vnodeObj.props || {};\n    for (const k of Object.keys(props)) {\n      if (isIgnoredForPropChanges(k)) continue;\n      if (hasPropChanged(el, k, props[k])) {\n        return true;\n      }\n    }\n  }\n  return false;\n}\n\n/**\n * Determine if keyed reorder fast-path should be used\n */\nexport function isKeyedReorderFastPathEligible(\n  parent: Element,\n  newChildren: VNode[],\n  oldKeyMap: Map<string | number, Element> | undefined\n) {\n  const keyedVnodes = extractKeyedVnodes(newChildren);\n  const totalKeyed = keyedVnodes.length;\n  const newKeyOrder = keyedVnodes.map((kv) => kv.key);\n  const oldKeyOrder = oldKeyMap ? Array.from(oldKeyMap.keys()) : [];\n\n  // Count moves needed\n  let moveCount = 0;\n  for (let i = 0; i < newKeyOrder.length; i++) {\n    const k = newKeyOrder[i];\n    if (i >= oldKeyOrder.length || oldKeyOrder[i] !== k || !oldKeyMap?.has(k)) {\n      moveCount++;\n    }\n  }\n\n  // Check move threshold triggers\n  const FAST_MOVE_THRESHOLD_ABS = 64;\n  const FAST_MOVE_THRESHOLD_REL = 0.1;\n  const cheapMoveTrigger =\n    totalKeyed >= LIS_THRESHOLD_MIN &&\n    oldKeyOrder.length > 0 &&\n    moveCount >\n      Math.max(\n        FAST_MOVE_THRESHOLD_ABS,\n        Math.floor(totalKeyed * FAST_MOVE_THRESHOLD_REL)\n      );\n\n  // Compute LIS trigger for large lists\n  let lisTrigger = false;\n  let lisLen = 0;\n  if (totalKeyed >= LIS_THRESHOLD_MIN) {\n    const parentChildren = Array.from(parent.children);\n    const positions = keyedVnodes.map(({ key }) => {\n      const el = oldKeyMap?.get(key);\n      return el?.parentElement === parent ? parentChildren.indexOf(el) : -1;\n    });\n    lisLen = computeLISLength(positions);\n    lisTrigger = lisLen < Math.floor(totalKeyed * 0.5);\n  }\n\n  // Check for props that would prevent fast-path\n  // Only block if props have CHANGED, not just if props exist\n  const hasPropChanges = checkVnodePropChanges(keyedVnodes, oldKeyMap);\n\n  // Allow fastpath even with props present, as long as props haven't changed\n  // This enables fast-path for common patterns like <Row item={item} onClick={...} />\n  const useFastPath = (cheapMoveTrigger || lisTrigger) && !hasPropChanges;\n\n  return {\n    useFastPath,\n    totalKeyed,\n    moveCount,\n    lisLen,\n    hasPropChanges,\n  } as const;\n}\n"],"mappings":"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"}