@fictjs/runtime 0.5.0 → 0.5.1

package/dist/internal.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/reconcile.ts","../src/list-helpers.ts"],"sourcesContent":["/**\n * Fict DOM Reconciliation\n *\n * Efficient array reconciliation algorithm based on udomdiff.\n * https://github.com/WebReflection/udomdiff\n *\n * This algorithm uses a 5-step strategy:\n * 1. Common prefix - skip matching nodes at start\n * 2. Common suffix - skip matching nodes at end\n * 3. Append - insert remaining new nodes\n * 4. Remove - remove remaining old nodes\n * 5. Swap/Map fallback - handle complex rearrangements\n *\n * Most real-world updates (95%+) use fast paths without building a Map.\n */\n\n/**\n * Reconcile two arrays of DOM nodes, efficiently updating the DOM.\n *\n * @param parentNode - The parent element containing the nodes\n * @param a - The old array of nodes (currently in DOM)\n * @param b - The new array of nodes (target state)\n *\n * **Note:** This function may mutate the input array `a` during the swap\n * optimization (step 5a). If you need to preserve the original array,\n * pass a shallow copy: `reconcileArrays(parent, [...oldNodes], newNodes)`.\n *\n * @example\n * ```ts\n * const oldNodes = [node1, node2, node3]\n * const newNodes = [node1, node4, node3]  // node2 replaced with node4\n * reconcileArrays(parent, oldNodes, newNodes)\n * ```\n */\nexport default function reconcileArrays(parentNode: ParentNode, a: Node[], b: Node[]): void {\n  const bLength = b.length\n  let aEnd = a.length\n  let bEnd = bLength\n  let aStart = 0\n  let bStart = 0\n  const after = aEnd > 0 ? a[aEnd - 1]!.nextSibling : null\n  let map: Map<Node, number> | null = null\n\n  while (aStart < aEnd || bStart < bEnd) {\n    // 1. Common prefix - nodes match at start\n    if (a[aStart] === b[bStart]) {\n      aStart++\n      bStart++\n      continue\n    }\n\n    // 2. Common suffix - nodes match at end\n    while (a[aEnd - 1] === b[bEnd - 1]) {\n      aEnd--\n      bEnd--\n    }\n\n    // 3. Append - old array exhausted, insert remaining new nodes\n    if (aEnd === aStart) {\n      const node: Node | null =\n        bEnd < bLength ? (bStart ? b[bStart - 1]!.nextSibling : (b[bEnd - bStart] ?? null)) : after\n\n      const count = bEnd - bStart\n      const doc = (parentNode as Node).ownerDocument\n      if (count > 1 && doc) {\n        const frag = doc.createDocumentFragment()\n        for (let i = bStart; i < bEnd; i++) {\n          frag.appendChild(b[i]!)\n        }\n        parentNode.insertBefore(frag, node)\n        bStart = bEnd\n      } else {\n        while (bStart < bEnd) {\n          parentNode.insertBefore(b[bStart++]!, node)\n        }\n      }\n    }\n    // 4. Remove - new array exhausted, remove remaining old nodes\n    else if (bEnd === bStart) {\n      while (aStart < aEnd) {\n        const nodeToRemove = a[aStart]!\n        if (!map || !map.has(nodeToRemove)) {\n          nodeToRemove.parentNode?.removeChild(nodeToRemove)\n        }\n        aStart++\n      }\n    }\n    // 5a. Swap backward - detect backward swap pattern\n    else if (a[aStart] === b[bEnd - 1] && b[bStart] === a[aEnd - 1]) {\n      const node = a[--aEnd]!.nextSibling\n      parentNode.insertBefore(b[bStart++]!, a[aStart++]!.nextSibling)\n      parentNode.insertBefore(b[--bEnd]!, node)\n      // Update reference in old array for potential future matches\n      a[aEnd] = b[bEnd]!\n    }\n    // 5b. Map fallback - use Map for complex rearrangements\n    else {\n      // Build map on first use (lazy initialization)\n      if (!map) {\n        map = new Map()\n        let i = bStart\n        while (i < bEnd) {\n          map.set(b[i]!, i++)\n        }\n      }\n\n      const index = map.get(a[aStart]!)\n\n      if (index != null) {\n        if (bStart < index && index < bEnd) {\n          // Check for longest increasing subsequence\n          let i = aStart\n          let sequence = 1\n          let t: number | undefined\n\n          while (++i < aEnd && i < bEnd) {\n            t = map.get(a[i]!)\n            if (t == null || t !== index + sequence) break\n            sequence++\n          }\n\n          // Use optimal strategy based on sequence length\n          if (sequence > index - bStart) {\n            // Sequence is long enough - insert nodes before current\n            const node = a[aStart]!\n            while (bStart < index) {\n              parentNode.insertBefore(b[bStart++]!, node)\n            }\n          } else {\n            // Short sequence - replace\n            parentNode.replaceChild(b[bStart++]!, a[aStart++]!)\n          }\n        } else {\n          aStart++\n        }\n      } else {\n        // Node not in new array - remove it\n        const nodeToRemove = a[aStart++]!\n        nodeToRemove.parentNode?.removeChild(nodeToRemove)\n      }\n    }\n  }\n}\n\n/**\n * Simple reconciliation for keyed lists.\n * Uses the same algorithm but works with keyed blocks.\n *\n * @param parentNode - The parent element\n * @param oldNodes - Old nodes in DOM order\n * @param newNodes - New nodes in target order\n */\nexport function reconcileNodes(parentNode: ParentNode, oldNodes: Node[], newNodes: Node[]): void {\n  reconcileArrays(parentNode, oldNodes, newNodes)\n}\n","/**\n * List Helpers for Compiler-Generated Fine-Grained Updates\n *\n * These helpers are used by the compiler to generate efficient keyed list rendering.\n * They provide low-level primitives for DOM node manipulation without rebuilding.\n */\n\nimport { createElement } from './dom'\nimport { createRenderEffect } from './effect'\nimport { isHydratingActive, withHydrationRange } from './hydration'\nimport {\n  createRootContext,\n  destroyRoot,\n  flushOnMount,\n  getCurrentRoot,\n  popRoot,\n  pushRoot,\n  type RootContext,\n} from './lifecycle'\nimport { insertNodesBefore, removeNodes, toNodeArray } from './node-ops'\nimport reconcileArrays from './reconcile'\nimport { __fictIsHydrating, __fictIsSSR } from './resume'\nimport { batch } from './scheduler'\nimport { createSignal, effectScope, flush, setActiveSub, type Signal } from './signal'\nimport type { FictNode } from './types'\n\n// Re-export shared DOM helpers for compiler-generated code\nexport { insertNodesBefore, removeNodes, toNodeArray }\n\nconst isDev =\n  typeof __DEV__ !== 'undefined'\n    ? __DEV__\n    : typeof process === 'undefined' || process.env?.NODE_ENV !== 'production'\n\n// ============================================================================\n// Types\n// ============================================================================\n\n/**\n * A keyed block represents a single item in a list with its associated DOM nodes and state\n */\ninterface KeyedBlock<T = unknown> {\n  /** Unique key for this block */\n  key: string | number\n  /** DOM nodes belonging to this block */\n  nodes: Node[]\n  /** Root context for lifecycle management */\n  root: RootContext\n  /** Signal containing the current item value */\n  item: Signal<T>\n  /** Signal containing the current index */\n  index: Signal<number>\n  /** Last raw item value assigned to this block */\n  rawItem: T\n  /** Last raw index value assigned to this block */\n  rawIndex: number\n}\n\n/**\n * Container for managing keyed list blocks\n */\ninterface KeyedListContainer<T = unknown> {\n  /** Start marker comment node */\n  startMarker: Comment\n  /** End marker comment node */\n  endMarker: Comment\n  /** Map of key to block */\n  blocks: Map<string | number, KeyedBlock<T>>\n  /** Scratch map reused for the next render */\n  nextBlocks: Map<string | number, KeyedBlock<T>>\n  /** Current nodes in DOM order (including markers) */\n  currentNodes: Node[]\n  /** Next-frame node buffer to avoid reallocations */\n  nextNodes: Node[]\n  /** Ordered blocks in current DOM order */\n  orderedBlocks: KeyedBlock<T>[]\n  /** Next-frame ordered block buffer to avoid reallocations */\n  nextOrderedBlocks: KeyedBlock<T>[]\n  /** Track position of keys in the ordered buffer to handle duplicates */\n  orderedIndexByKey: Map<string | number, number>\n  /** Cleanup function */\n  dispose: () => void\n}\n\n/**\n * Binding handle returned by createKeyedList for compiler-generated code\n */\nexport interface KeyedListBinding {\n  /** Document fragment placeholder inserted by the compiler/runtime */\n  marker: Comment | DocumentFragment\n  /** Start marker comment node */\n  startMarker: Comment\n  /** End marker comment node */\n  endMarker: Comment\n  /** Flush pending items - call after markers are inserted into DOM */\n  flush?: () => void\n  /** Cleanup function */\n  dispose: () => void\n}\n\ntype FineGrainedRenderItem<T> = (\n  itemSig: Signal<T>,\n  indexSig: Signal<number>,\n  key: string | number,\n) => Node[]\n\n// ============================================================================\n// DOM Manipulation Primitives\n// ============================================================================\n\n/**\n * Move nodes to a position before the anchor node.\n * This is optimized to avoid unnecessary DOM operations.\n *\n * @param parent - Parent node to move nodes within\n * @param nodes - Array of nodes to move\n * @param anchor - Node to insert before (or null for end)\n */\nexport function moveNodesBefore(parent: Node, nodes: Node[], anchor: Node | null): void {\n  // Insert in reverse order to maintain correct sequence\n  // This way each node becomes the new anchor for the next\n  for (let i = nodes.length - 1; i >= 0; i--) {\n    const node = nodes[i]!\n    if (!node || !(node instanceof Node)) {\n      const message = isDev ? 'Invalid node in moveNodesBefore' : 'FICT:E_NODE'\n      throw new Error(message)\n    }\n    // Only move if not already in correct position\n    if (node.nextSibling !== anchor) {\n      if (node.ownerDocument !== parent.ownerDocument && parent.ownerDocument) {\n        parent.ownerDocument.adoptNode(node)\n      }\n      try {\n        parent.insertBefore(node, anchor)\n      } catch (e: any) {\n        if (parent.ownerDocument) {\n          try {\n            const clone = parent.ownerDocument.importNode(node, true)\n            parent.insertBefore(clone, anchor)\n            // Update the nodes array with the clone to maintain correct references.\n            // This ensures future operations (like removal or reordering) work correctly.\n            nodes[i] = clone\n            if (isDev) {\n              console.warn(\n                `[fict] Node cloning fallback triggered during list reordering. ` +\n                  `This may indicate cross-document node insertion. ` +\n                  `The node reference has been updated to the clone.`,\n              )\n            }\n            anchor = clone\n            continue\n          } catch {\n            // Clone fallback failed\n          }\n        }\n        throw e\n      }\n    }\n    anchor = node\n  }\n}\n\n/**\n * Remove an array of nodes from the DOM\n *\n * @param nodes - Array of nodes to remove\n */\n// Number.MAX_SAFE_INTEGER is 2^53 - 1, but we reset earlier to avoid any precision issues\nconst MAX_SAFE_VERSION = 0x1fffffffffffff // 2^53 - 1\n\nexport function createVersionedSignalAccessor<T>(initialValue: T): Signal<T> {\n  let current = initialValue\n  let version = 0\n  const track = createSignal(version)\n\n  function accessor(value?: T): T | void {\n    if (arguments.length === 0) {\n      track()\n      return current\n    }\n    current = value as T\n    // This is safe because we only care about version changes, not absolute values\n    version = version >= MAX_SAFE_VERSION ? 1 : version + 1\n    track(version)\n  }\n\n  return accessor as Signal<T>\n}\n\n// ============================================================================\n// Keyed List Container\n// ============================================================================\n\n/**\n * Create a container for managing a keyed list.\n * This sets up the marker nodes and provides cleanup.\n *\n * @returns Container object with markers, blocks map, and dispose function\n */\nfunction createKeyedListContainer<T = unknown>(\n  startOverride?: Comment,\n  endOverride?: Comment,\n): KeyedListContainer<T> {\n  const startMarker = startOverride ?? document.createComment('fict:list:start')\n  const endMarker = endOverride ?? document.createComment('fict:list:end')\n\n  const dispose = () => {\n    // Clean up all blocks\n    for (const block of container.blocks.values()) {\n      destroyRoot(block.root)\n      // Nodes are removed by parent disposal or specific cleanup if needed\n      // But for list disposal, we just clear the container\n    }\n    container.blocks.clear()\n    container.nextBlocks.clear()\n\n    // Remove nodes (including markers)\n    // Check if markers are still in DOM before using Range\n    if (!startMarker.parentNode || !endMarker.parentNode) {\n      // Markers already removed, nothing to do\n      container.currentNodes = []\n      container.nextNodes = []\n      container.orderedBlocks.length = 0\n      container.nextOrderedBlocks.length = 0\n      container.orderedIndexByKey.clear()\n      return\n    }\n    const range = document.createRange()\n    range.setStartBefore(startMarker)\n    range.setEndAfter(endMarker)\n    range.deleteContents()\n\n    // Clear cache\n    container.currentNodes = []\n    container.nextNodes = []\n    container.nextBlocks.clear()\n    container.orderedBlocks.length = 0\n    container.nextOrderedBlocks.length = 0\n    container.orderedIndexByKey.clear()\n  }\n\n  const container: KeyedListContainer<T> = {\n    startMarker,\n    endMarker,\n    blocks: new Map<string | number, KeyedBlock<T>>(),\n    nextBlocks: new Map<string | number, KeyedBlock<T>>(),\n    currentNodes: [startMarker, endMarker],\n    nextNodes: [],\n    orderedBlocks: [],\n    nextOrderedBlocks: [],\n    orderedIndexByKey: new Map<string | number, number>(),\n    dispose,\n  }\n\n  return container\n}\n\n// ============================================================================\n// Block Creation Helpers\n// ============================================================================\n\n/**\n * Create a new keyed block with the given render function\n *\n * @param key - Unique key for this block\n * @param item - Initial item value\n * @param index - Initial index\n * @param render - Function that creates the DOM nodes and sets up bindings\n * @returns New KeyedBlock\n */\nfunction createKeyedBlock<T>(\n  key: string | number,\n  item: T,\n  index: number,\n  render: (item: Signal<T>, index: Signal<number>, key: string | number) => Node[],\n  needsIndex = true,\n  hostRoot?: RootContext,\n): KeyedBlock<T> {\n  // Use versioned signal for all item types; avoid diffing proxy overhead for objects\n  const itemSig = createVersionedSignalAccessor(item)\n\n  const indexSig = needsIndex\n    ? createSignal<number>(index)\n    : (((next?: number) => {\n        if (arguments.length === 0) return index\n        index = next as number\n        return index\n      }) as Signal<number>)\n  const root = createRootContext(hostRoot)\n  const prevRoot = pushRoot(root)\n  // maintaining proper cleanup chain. The scope will be disposed when\n  // the root is destroyed, ensuring nested effects are properly cleaned up.\n  let nodes: Node[] = []\n  let scopeDispose: (() => void) | undefined\n\n  // First, isolate from parent effect to prevent child effects from being\n  // purged when the outer effect (e.g., performDiff) re-runs\n  const prevSub = setActiveSub(undefined)\n\n  try {\n    // Create an effectScope that will track all effects created during render\n    scopeDispose = effectScope(() => {\n      const rendered = render(itemSig, indexSig, key)\n      // If render returns real DOM nodes/arrays, preserve them to avoid\n      // reparenting side-effects (tests may pre-insert them).\n      if (\n        rendered instanceof Node ||\n        (Array.isArray(rendered) && rendered.every(n => n instanceof Node))\n      ) {\n        nodes = toNodeArray(rendered)\n      } else {\n        const element = createElement(rendered as unknown as FictNode)\n        nodes = toNodeArray(element)\n      }\n    })\n\n    // Register the scope cleanup with the root so effects are cleaned up\n    // when the block is destroyed\n    if (scopeDispose) {\n      root.cleanups.push(scopeDispose)\n    }\n  } finally {\n    setActiveSub(prevSub)\n    popRoot(prevRoot)\n  }\n\n  return {\n    key,\n    nodes,\n    root,\n    item: itemSig,\n    index: indexSig,\n    rawItem: item,\n    rawIndex: index,\n  }\n}\n\n// ============================================================================\n// Utilities\n// ============================================================================\n\n/**\n * Check if a node is between two markers\n */\nexport function isNodeBetweenMarkers(\n  node: Node,\n  startMarker: Comment,\n  endMarker: Comment,\n): boolean {\n  let current: Node | null = startMarker.nextSibling\n  while (current && current !== endMarker) {\n    if (current === node) return true\n    current = current.nextSibling\n  }\n  return false\n}\n\nfunction reorderBySwap<T>(\n  parent: ParentNode & Node,\n  first: KeyedBlock<T>,\n  second: KeyedBlock<T>,\n): boolean {\n  if (first === second) return false\n  const firstNodes = first.nodes\n  const secondNodes = second.nodes\n  if (firstNodes.length === 0 || secondNodes.length === 0) return false\n  const lastFirst = firstNodes[firstNodes.length - 1]!\n  const lastSecond = secondNodes[secondNodes.length - 1]!\n  const afterFirst = lastFirst.nextSibling\n  const afterSecond = lastSecond.nextSibling\n  moveNodesBefore(parent, firstNodes, afterSecond)\n  moveNodesBefore(parent, secondNodes, afterFirst)\n  return true\n}\n\nfunction getLISIndices(sequence: number[]): number[] {\n  const predecessors = new Array<number>(sequence.length)\n  const result: number[] = []\n\n  for (let i = 0; i < sequence.length; i++) {\n    const value = sequence[i]!\n    if (value < 0) {\n      predecessors[i] = -1\n      continue\n    }\n\n    let low = 0\n    let high = result.length\n    while (low < high) {\n      const mid = (low + high) >> 1\n      if (sequence[result[mid]!]! < value) {\n        low = mid + 1\n      } else {\n        high = mid\n      }\n    }\n\n    predecessors[i] = low > 0 ? result[low - 1]! : -1\n    if (low === result.length) {\n      result.push(i)\n    } else {\n      result[low] = i\n    }\n  }\n\n  const lis: number[] = new Array(result.length)\n  let k = result.length > 0 ? result[result.length - 1]! : -1\n  for (let i = result.length - 1; i >= 0; i--) {\n    lis[i] = k\n    k = predecessors[k]!\n  }\n  return lis\n}\n\nfunction reorderByLIS<T>(\n  parent: ParentNode & Node,\n  endMarker: Comment,\n  prev: KeyedBlock<T>[],\n  next: KeyedBlock<T>[],\n): boolean {\n  const positions = new Map<KeyedBlock<T>, number>()\n  for (let i = 0; i < prev.length; i++) {\n    positions.set(prev[i]!, i)\n  }\n\n  const sequence = new Array<number>(next.length)\n  for (let i = 0; i < next.length; i++) {\n    const position = positions.get(next[i]!)\n    if (position === undefined) return false\n    sequence[i] = position\n  }\n\n  const lisIndices = getLISIndices(sequence)\n  if (lisIndices.length === sequence.length) return true\n\n  const inLIS = new Array<boolean>(sequence.length).fill(false)\n  for (let i = 0; i < lisIndices.length; i++) {\n    inLIS[lisIndices[i]!] = true\n  }\n\n  let anchor: Node | null = endMarker\n  let moved = false\n  for (let i = next.length - 1; i >= 0; i--) {\n    const block = next[i]!\n    const nodes = block.nodes\n    if (nodes.length === 0) continue\n    if (inLIS[i]) {\n      anchor = nodes[0]!\n      continue\n    }\n    moveNodesBefore(parent, nodes, anchor)\n    anchor = nodes[0]!\n    moved = true\n  }\n\n  return moved\n}\n\n// ============================================================================\n// High-Level List Binding (for compiler-generated code)\n// ============================================================================\n\n/**\n * Create a keyed list binding with automatic diffing and DOM updates.\n * This is used by compiler-generated code for efficient list rendering.\n *\n * @param getItems - Function that returns the current array of items\n * @param keyFn - Function to extract unique key from each item\n * @param renderItem - Function that creates DOM nodes for each item\n * @returns Binding handle with markers and dispose function\n */\nexport function createKeyedList<T extends object>(\n  getItems: () => T[],\n  keyFn: (item: T, index: number) => string | number,\n  renderItem: FineGrainedRenderItem<T>,\n  needsIndex?: boolean,\n  startMarker?: Comment,\n  endMarker?: Comment,\n): KeyedListBinding {\n  const resolvedNeedsIndex =\n    arguments.length >= 4 ? !!needsIndex : renderItem.length > 1 /* has index param */\n  return createFineGrainedKeyedList(\n    getItems,\n    keyFn,\n    renderItem,\n    resolvedNeedsIndex,\n    startMarker,\n    endMarker,\n  )\n}\n\nfunction createFineGrainedKeyedList<T extends object>(\n  getItems: () => T[],\n  keyFn: (item: T, index: number) => string | number,\n  renderItem: FineGrainedRenderItem<T>,\n  needsIndex: boolean,\n  startOverride?: Comment,\n  endOverride?: Comment,\n): KeyedListBinding {\n  const container = createKeyedListContainer<T>(startOverride, endOverride)\n  const hostRoot = getCurrentRoot()\n  const useProvided = !!(startOverride && endOverride)\n  const fragment = useProvided ? container.startMarker : document.createDocumentFragment()\n  if (!useProvided) {\n    ;(fragment as DocumentFragment).append(container.startMarker, container.endMarker)\n  }\n  let disposed = false\n  let effectDispose: (() => void) | undefined\n  let connectObserver: MutationObserver | null = null\n  let effectStarted = false\n  let startScheduled = false\n  let initialHydrating = __fictIsHydrating()\n\n  const collectBetween = (): Node[] => {\n    const nodes: Node[] = []\n    let cursor = container.startMarker.nextSibling\n    while (cursor && cursor !== container.endMarker) {\n      nodes.push(cursor)\n      cursor = cursor.nextSibling\n    }\n    return nodes\n  }\n\n  const getConnectedParent = (): (ParentNode & Node) | null => {\n    const endParent = container.endMarker.parentNode\n    const startParent = container.startMarker.parentNode\n    if (\n      endParent &&\n      startParent &&\n      endParent === startParent &&\n      (endParent as Node).nodeType !== 11\n    ) {\n      const parentNode = endParent as ParentNode & Node\n      if ('isConnected' in parentNode && !parentNode.isConnected) return null\n      return parentNode\n    }\n    return null\n  }\n\n  const performDiff = () => {\n    if (disposed) return\n    // During SSR, render synchronously without waiting for DOM connection\n    const isSSR = __fictIsSSR()\n    const parent = isSSR\n      ? (container.startMarker.parentNode as (ParentNode & Node) | null)\n      : getConnectedParent()\n    if (!parent) return\n    batch(() => {\n      const oldBlocks = container.blocks\n      const newBlocks = container.nextBlocks\n      const prevOrderedBlocks = container.orderedBlocks\n      const nextOrderedBlocks = container.nextOrderedBlocks\n      const orderedIndexByKey = container.orderedIndexByKey\n      const newItems = getItems()\n\n      if (initialHydrating && isHydratingActive()) {\n        initialHydrating = false\n        newBlocks.clear()\n        nextOrderedBlocks.length = 0\n        orderedIndexByKey.clear()\n\n        if (newItems.length === 0) {\n          oldBlocks.clear()\n          prevOrderedBlocks.length = 0\n          container.currentNodes = [container.startMarker, container.endMarker]\n          container.nextNodes.length = 0\n          return\n        }\n\n        const createdBlocks: KeyedBlock<T>[] = []\n        withHydrationRange(\n          container.startMarker.nextSibling,\n          container.endMarker,\n          parent.ownerDocument ?? document,\n          () => {\n            for (let index = 0; index < newItems.length; index++) {\n              const item = newItems[index]!\n              const key = keyFn(item, index)\n              if (newBlocks.has(key)) {\n                if (isDev) {\n                  console.warn(\n                    `[fict] Duplicate key \"${String(key)}\" detected in list hydration. ` +\n                      `Each item should have a unique key.`,\n                  )\n                }\n                const existing = newBlocks.get(key)\n                if (existing) {\n                  destroyRoot(existing.root)\n                  removeNodes(existing.nodes)\n                }\n              }\n              const block = createKeyedBlock(key, item, index, renderItem, needsIndex, hostRoot)\n              createdBlocks.push(block)\n              newBlocks.set(key, block)\n              orderedIndexByKey.set(key, nextOrderedBlocks.length)\n              nextOrderedBlocks.push(block)\n            }\n          },\n        )\n\n        container.blocks = newBlocks\n        container.nextBlocks = oldBlocks\n        container.orderedBlocks = nextOrderedBlocks\n        container.nextOrderedBlocks = prevOrderedBlocks\n        oldBlocks.clear()\n        prevOrderedBlocks.length = 0\n        container.currentNodes = [container.startMarker, ...collectBetween(), container.endMarker]\n        container.nextNodes.length = 0\n\n        for (const block of createdBlocks) {\n          if (newBlocks.get(block.key) === block) {\n            flushOnMount(block.root)\n          }\n        }\n\n        return\n      }\n\n      if (newItems.length === 0) {\n        if (oldBlocks.size > 0) {\n          // Destroy all block roots first\n          for (const block of oldBlocks.values()) {\n            destroyRoot(block.root)\n          }\n          // Use Range.deleteContents for efficient bulk DOM removal\n          const range = document.createRange()\n          range.setStartAfter(container.startMarker)\n          range.setEndBefore(container.endMarker)\n          range.deleteContents()\n        }\n        oldBlocks.clear()\n        newBlocks.clear()\n        prevOrderedBlocks.length = 0\n        nextOrderedBlocks.length = 0\n        orderedIndexByKey.clear()\n        container.currentNodes.length = 0\n        container.currentNodes.push(container.startMarker, container.endMarker)\n        container.nextNodes.length = 0\n        return\n      }\n\n      const prevCount = prevOrderedBlocks.length\n      if (prevCount > 0 && newItems.length === prevCount && orderedIndexByKey.size === prevCount) {\n        let stableOrder = true\n        const seen = new Set<string | number>()\n        for (let i = 0; i < prevCount; i++) {\n          const item = newItems[i]!\n          const key = keyFn(item, i)\n          if (seen.has(key) || prevOrderedBlocks[i]!.key !== key) {\n            stableOrder = false\n            break\n          }\n          seen.add(key)\n        }\n        if (stableOrder) {\n          for (let i = 0; i < prevCount; i++) {\n            const item = newItems[i]!\n            const block = prevOrderedBlocks[i]!\n            if (block.rawItem !== item) {\n              block.rawItem = item\n              block.item(item)\n            }\n            if (needsIndex && block.rawIndex !== i) {\n              block.rawIndex = i\n              block.index(i)\n            }\n          }\n          return\n        }\n      }\n\n      newBlocks.clear()\n      nextOrderedBlocks.length = 0\n      orderedIndexByKey.clear()\n      const createdBlocks: KeyedBlock<T>[] = []\n      let appendCandidate = prevCount > 0 && newItems.length >= prevCount\n      const appendedBlocks: KeyedBlock<T>[] = []\n      let mismatchCount = 0\n      let mismatchFirst = -1\n      let mismatchSecond = -1\n      let hasDuplicateKey = false\n\n      // Phase 1: Build new blocks map (reuse or create)\n      newItems.forEach((item, index) => {\n        const key = keyFn(item, index)\n        // Micro-optimization: single Map.get instead of has+get\n        let block = oldBlocks.get(key)\n        const existed = block !== undefined\n\n        if (block) {\n          if (block.rawItem !== item) {\n            block.rawItem = item\n            block.item(item)\n          }\n          if (needsIndex && block.rawIndex !== index) {\n            block.rawIndex = index\n            block.index(index)\n          }\n        }\n\n        if (block) {\n          // Reusing existing block from oldBlocks\n          newBlocks.set(key, block)\n          oldBlocks.delete(key)\n        } else {\n          // If newBlocks already has this key (duplicate key case), clean up the previous block\n          const existingBlock = newBlocks.get(key)\n          if (existingBlock) {\n            if (isDev) {\n              console.warn(\n                `[fict] Duplicate key \"${String(key)}\" detected in list rendering. ` +\n                  `Each item should have a unique key. The previous item with this key will be replaced.`,\n              )\n            }\n            destroyRoot(existingBlock.root)\n            removeNodes(existingBlock.nodes)\n          }\n          // Create new block\n          block = createKeyedBlock(key, item, index, renderItem, needsIndex, hostRoot)\n          createdBlocks.push(block)\n        }\n\n        const resolvedBlock = block\n\n        newBlocks.set(key, resolvedBlock)\n\n        // Micro-optimization: single Map.get instead of checking position multiple times\n        const position = orderedIndexByKey.get(key)\n        if (position !== undefined) {\n          appendCandidate = false\n          hasDuplicateKey = true\n          const prior = nextOrderedBlocks[position]\n          if (prior && prior !== resolvedBlock) {\n            destroyRoot(prior.root)\n            removeNodes(prior.nodes)\n          }\n          nextOrderedBlocks[position] = resolvedBlock\n        } else {\n          if (appendCandidate) {\n            if (index < prevCount) {\n              if (!prevOrderedBlocks[index] || prevOrderedBlocks[index]!.key !== key) {\n                appendCandidate = false\n              }\n            } else if (existed) {\n              appendCandidate = false\n            }\n          }\n          const nextIndex = nextOrderedBlocks.length\n          orderedIndexByKey.set(key, nextIndex)\n          nextOrderedBlocks.push(resolvedBlock)\n          if (\n            mismatchCount < 3 &&\n            (nextIndex >= prevCount || prevOrderedBlocks[nextIndex] !== resolvedBlock)\n          ) {\n            if (mismatchCount === 0) {\n              mismatchFirst = nextIndex\n            } else if (mismatchCount === 1) {\n              mismatchSecond = nextIndex\n            }\n            mismatchCount++\n          }\n        }\n\n        if (appendCandidate && index >= prevCount) {\n          appendedBlocks.push(resolvedBlock)\n        }\n      })\n\n      const canAppend =\n        appendCandidate &&\n        prevCount > 0 &&\n        newItems.length > prevCount &&\n        oldBlocks.size === 0 &&\n        appendedBlocks.length > 0\n      if (canAppend) {\n        const appendedNodes: Node[] = []\n        for (const block of appendedBlocks) {\n          for (let i = 0; i < block.nodes.length; i++) {\n            appendedNodes.push(block.nodes[i]!)\n          }\n        }\n        if (appendedNodes.length > 0) {\n          insertNodesBefore(parent, appendedNodes, container.endMarker)\n          const currentNodes = container.currentNodes\n          currentNodes.pop()\n          for (let i = 0; i < appendedNodes.length; i++) {\n            currentNodes.push(appendedNodes[i]!)\n          }\n          currentNodes.push(container.endMarker)\n        }\n\n        container.blocks = newBlocks\n        container.nextBlocks = oldBlocks\n        container.orderedBlocks = nextOrderedBlocks\n        container.nextOrderedBlocks = prevOrderedBlocks\n        for (const block of createdBlocks) {\n          if (newBlocks.get(block.key) === block) {\n            flushOnMount(block.root)\n          }\n        }\n        return\n      }\n\n      // Phase 2: Remove old blocks that are no longer in the list\n      if (oldBlocks.size > 0) {\n        for (const block of oldBlocks.values()) {\n          destroyRoot(block.root)\n          removeNodes(block.nodes)\n        }\n        oldBlocks.clear()\n      }\n\n      const canReorderInPlace =\n        createdBlocks.length === 0 &&\n        oldBlocks.size === 0 &&\n        nextOrderedBlocks.length === prevOrderedBlocks.length\n\n      let skipReconcile = false\n      let updateNodeBuffer = true\n\n      if (canReorderInPlace && nextOrderedBlocks.length > 0 && !hasDuplicateKey) {\n        if (mismatchCount === 0) {\n          skipReconcile = true\n          updateNodeBuffer = false\n        } else if (\n          mismatchCount === 2 &&\n          prevOrderedBlocks[mismatchFirst] === nextOrderedBlocks[mismatchSecond] &&\n          prevOrderedBlocks[mismatchSecond] === nextOrderedBlocks[mismatchFirst]\n        ) {\n          if (\n            reorderBySwap(\n              parent,\n              prevOrderedBlocks[mismatchFirst]!,\n              prevOrderedBlocks[mismatchSecond]!,\n            )\n          ) {\n            skipReconcile = true\n          }\n        } else if (\n          reorderByLIS(parent, container.endMarker, prevOrderedBlocks, nextOrderedBlocks)\n        ) {\n          skipReconcile = true\n        }\n      }\n\n      // Phase 3: Reconcile DOM with buffered node arrays\n      if (!skipReconcile && (newBlocks.size > 0 || container.currentNodes.length > 0)) {\n        const prevNodes = container.currentNodes\n        const nextNodes = container.nextNodes\n        nextNodes.length = 0\n        nextNodes.push(container.startMarker)\n\n        for (let i = 0; i < nextOrderedBlocks.length; i++) {\n          const nodes = nextOrderedBlocks[i]!.nodes\n          for (let j = 0; j < nodes.length; j++) {\n            nextNodes.push(nodes[j]!)\n          }\n        }\n\n        nextNodes.push(container.endMarker)\n\n        reconcileArrays(parent, prevNodes, nextNodes)\n\n        // Swap buffers to reuse arrays on next diff\n        container.currentNodes = nextNodes\n        container.nextNodes = prevNodes\n      } else if (skipReconcile && updateNodeBuffer) {\n        const prevNodes = container.currentNodes\n        const nextNodes = container.nextNodes\n        nextNodes.length = 0\n        nextNodes.push(container.startMarker)\n        for (let i = 0; i < nextOrderedBlocks.length; i++) {\n          const nodes = nextOrderedBlocks[i]!.nodes\n          for (let j = 0; j < nodes.length; j++) {\n            nextNodes.push(nodes[j]!)\n          }\n        }\n        nextNodes.push(container.endMarker)\n        container.currentNodes = nextNodes\n        container.nextNodes = prevNodes\n      }\n\n      // Swap block maps for reuse\n      container.blocks = newBlocks\n      container.nextBlocks = oldBlocks\n      container.orderedBlocks = nextOrderedBlocks\n      container.nextOrderedBlocks = prevOrderedBlocks\n      for (const block of createdBlocks) {\n        if (newBlocks.get(block.key) === block) {\n          flushOnMount(block.root)\n        }\n      }\n    })\n  }\n\n  const disconnectObserver = () => {\n    connectObserver?.disconnect()\n    connectObserver = null\n  }\n\n  const ensureEffectStarted = (): boolean => {\n    if (disposed || effectStarted) return effectStarted\n    // During SSR, render synchronously without waiting for DOM connection\n    const isSSR = __fictIsSSR()\n    const parent = isSSR\n      ? (container.startMarker.parentNode as (ParentNode & Node) | null)\n      : getConnectedParent()\n    if (!parent) return false\n    const start = () => {\n      effectDispose = createRenderEffect(performDiff)\n      effectStarted = true\n    }\n    if (hostRoot) {\n      const prev = pushRoot(hostRoot)\n      try {\n        start()\n      } finally {\n        popRoot(prev)\n      }\n    } else {\n      start()\n    }\n    return true\n  }\n\n  const waitForConnection = () => {\n    if (connectObserver || typeof MutationObserver === 'undefined') return\n    connectObserver = new MutationObserver(() => {\n      if (disposed) return\n      if (getConnectedParent()) {\n        disconnectObserver()\n        if (ensureEffectStarted()) {\n          flush()\n        }\n      }\n    })\n    connectObserver.observe(document, { childList: true, subtree: true })\n  }\n\n  const scheduleStart = () => {\n    if (startScheduled || disposed || effectStarted) return\n    startScheduled = true\n    const run = () => {\n      startScheduled = false\n      if (!ensureEffectStarted()) {\n        waitForConnection()\n      }\n    }\n    if (typeof queueMicrotask === 'function') {\n      queueMicrotask(run)\n    } else {\n      Promise.resolve()\n        .then(run)\n        .catch(() => undefined)\n    }\n  }\n\n  scheduleStart()\n\n  return {\n    get marker() {\n      scheduleStart()\n      return fragment\n    },\n    startMarker: container.startMarker,\n    endMarker: container.endMarker,\n    // Flush pending items - call after markers are inserted into DOM\n    flush: () => {\n      if (disposed) return\n      scheduleStart()\n      if (ensureEffectStarted()) {\n        flush()\n      } else {\n        waitForConnection()\n      }\n    },\n    dispose: () => {\n      disposed = true\n      effectDispose?.()\n      disconnectObserver()\n      container.dispose()\n    },\n  }\n}\n"],"mappings":"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","names":["render","createdBlocks"]}
+{"version":3,"sources":["../src/reconcile.ts","../src/list-helpers.ts"],"sourcesContent":["/**\n * Fict DOM Reconciliation\n *\n * Efficient array reconciliation algorithm based on udomdiff.\n * https://github.com/WebReflection/udomdiff\n *\n * This algorithm uses a 5-step strategy:\n * 1. Common prefix - skip matching nodes at start\n * 2. Common suffix - skip matching nodes at end\n * 3. Append - insert remaining new nodes\n * 4. Remove - remove remaining old nodes\n * 5. Swap/Map fallback - handle complex rearrangements\n *\n * Most real-world updates (95%+) use fast paths without building a Map.\n */\n\n/**\n * Reconcile two arrays of DOM nodes, efficiently updating the DOM.\n *\n * @param parentNode - The parent element containing the nodes\n * @param a - The old array of nodes (currently in DOM)\n * @param b - The new array of nodes (target state)\n *\n * **Note:** This function may mutate the input array `a` during the swap\n * optimization (step 5a). If you need to preserve the original array,\n * pass a shallow copy: `reconcileArrays(parent, [...oldNodes], newNodes)`.\n *\n * @example\n * ```ts\n * const oldNodes = [node1, node2, node3]\n * const newNodes = [node1, node4, node3]  // node2 replaced with node4\n * reconcileArrays(parent, oldNodes, newNodes)\n * ```\n */\nexport default function reconcileArrays(parentNode: ParentNode, a: Node[], b: Node[]): void {\n  const bLength = b.length\n  let aEnd = a.length\n  let bEnd = bLength\n  let aStart = 0\n  let bStart = 0\n  const after = aEnd > 0 ? a[aEnd - 1]!.nextSibling : null\n  let map: Map<Node, number> | null = null\n\n  while (aStart < aEnd || bStart < bEnd) {\n    // 1. Common prefix - nodes match at start\n    if (a[aStart] === b[bStart]) {\n      aStart++\n      bStart++\n      continue\n    }\n\n    // 2. Common suffix - nodes match at end\n    while (a[aEnd - 1] === b[bEnd - 1]) {\n      aEnd--\n      bEnd--\n    }\n\n    // 3. Append - old array exhausted, insert remaining new nodes\n    if (aEnd === aStart) {\n      const node: Node | null =\n        bEnd < bLength ? (bStart ? b[bStart - 1]!.nextSibling : (b[bEnd - bStart] ?? null)) : after\n\n      const count = bEnd - bStart\n      const doc = (parentNode as Node).ownerDocument\n      if (count > 1 && doc) {\n        const frag = doc.createDocumentFragment()\n        for (let i = bStart; i < bEnd; i++) {\n          frag.appendChild(b[i]!)\n        }\n        parentNode.insertBefore(frag, node)\n        bStart = bEnd\n      } else {\n        while (bStart < bEnd) {\n          parentNode.insertBefore(b[bStart++]!, node)\n        }\n      }\n    }\n    // 4. Remove - new array exhausted, remove remaining old nodes\n    else if (bEnd === bStart) {\n      while (aStart < aEnd) {\n        const nodeToRemove = a[aStart]!\n        if (!map || !map.has(nodeToRemove)) {\n          nodeToRemove.parentNode?.removeChild(nodeToRemove)\n        }\n        aStart++\n      }\n    }\n    // 5a. Swap backward - detect backward swap pattern\n    else if (a[aStart] === b[bEnd - 1] && b[bStart] === a[aEnd - 1]) {\n      const node = a[--aEnd]!.nextSibling\n      parentNode.insertBefore(b[bStart++]!, a[aStart++]!.nextSibling)\n      parentNode.insertBefore(b[--bEnd]!, node)\n      // Update reference in old array for potential future matches\n      a[aEnd] = b[bEnd]!\n    }\n    // 5b. Map fallback - use Map for complex rearrangements\n    else {\n      // Build map on first use (lazy initialization)\n      if (!map) {\n        map = new Map()\n        let i = bStart\n        while (i < bEnd) {\n          map.set(b[i]!, i++)\n        }\n      }\n\n      const index = map.get(a[aStart]!)\n\n      if (index != null) {\n        if (bStart < index && index < bEnd) {\n          // Check for longest increasing subsequence\n          let i = aStart\n          let sequence = 1\n          let t: number | undefined\n\n          while (++i < aEnd && i < bEnd) {\n            t = map.get(a[i]!)\n            if (t == null || t !== index + sequence) break\n            sequence++\n          }\n\n          // Use optimal strategy based on sequence length\n          if (sequence > index - bStart) {\n            // Sequence is long enough - insert nodes before current\n            const node = a[aStart]!\n            while (bStart < index) {\n              parentNode.insertBefore(b[bStart++]!, node)\n            }\n          } else {\n            // Short sequence - replace\n            parentNode.replaceChild(b[bStart++]!, a[aStart++]!)\n          }\n        } else {\n          aStart++\n        }\n      } else {\n        // Node not in new array - remove it\n        const nodeToRemove = a[aStart++]!\n        nodeToRemove.parentNode?.removeChild(nodeToRemove)\n      }\n    }\n  }\n}\n\n/**\n * Simple reconciliation for keyed lists.\n * Uses the same algorithm but works with keyed blocks.\n *\n * @param parentNode - The parent element\n * @param oldNodes - Old nodes in DOM order\n * @param newNodes - New nodes in target order\n */\nexport function reconcileNodes(parentNode: ParentNode, oldNodes: Node[], newNodes: Node[]): void {\n  reconcileArrays(parentNode, oldNodes, newNodes)\n}\n","/**\n * List Helpers for Compiler-Generated Fine-Grained Updates\n *\n * These helpers are used by the compiler to generate efficient keyed list rendering.\n * They provide low-level primitives for DOM node manipulation without rebuilding.\n */\n\nimport { createElement } from './dom'\nimport { createRenderEffect } from './effect'\nimport { isHydratingActive, withHydrationRange } from './hydration'\nimport {\n  createRootContext,\n  destroyRoot,\n  flushOnMount,\n  getCurrentRoot,\n  popRoot,\n  pushRoot,\n  type RootContext,\n} from './lifecycle'\nimport { insertNodesBefore, removeNodes, toNodeArray } from './node-ops'\nimport reconcileArrays from './reconcile'\nimport { __fictIsHydrating, __fictIsSSR } from './resume'\nimport { batch } from './scheduler'\nimport { createSignal, effectScope, flush, setActiveSub, type Signal } from './signal'\nimport type { FictNode } from './types'\n\n// Re-export shared DOM helpers for compiler-generated code\nexport { insertNodesBefore, removeNodes, toNodeArray }\n\nconst isDev =\n  typeof __DEV__ !== 'undefined'\n    ? __DEV__\n    : typeof process === 'undefined' || process.env?.NODE_ENV !== 'production'\n\nconst isShadowRoot = (node: Node): node is ShadowRoot =>\n  typeof ShadowRoot !== 'undefined' && node instanceof ShadowRoot\n\n// ============================================================================\n// Types\n// ============================================================================\n\n/**\n * A keyed block represents a single item in a list with its associated DOM nodes and state\n */\ninterface KeyedBlock<T = unknown> {\n  /** Unique key for this block */\n  key: string | number\n  /** DOM nodes belonging to this block */\n  nodes: Node[]\n  /** Root context for lifecycle management */\n  root: RootContext\n  /** Signal containing the current item value */\n  item: Signal<T>\n  /** Signal containing the current index */\n  index: Signal<number>\n  /** Last raw item value assigned to this block */\n  rawItem: T\n  /** Last raw index value assigned to this block */\n  rawIndex: number\n}\n\n/**\n * Container for managing keyed list blocks\n */\ninterface KeyedListContainer<T = unknown> {\n  /** Start marker comment node */\n  startMarker: Comment\n  /** End marker comment node */\n  endMarker: Comment\n  /** Map of key to block */\n  blocks: Map<string | number, KeyedBlock<T>>\n  /** Scratch map reused for the next render */\n  nextBlocks: Map<string | number, KeyedBlock<T>>\n  /** Current nodes in DOM order (including markers) */\n  currentNodes: Node[]\n  /** Next-frame node buffer to avoid reallocations */\n  nextNodes: Node[]\n  /** Ordered blocks in current DOM order */\n  orderedBlocks: KeyedBlock<T>[]\n  /** Next-frame ordered block buffer to avoid reallocations */\n  nextOrderedBlocks: KeyedBlock<T>[]\n  /** Track position of keys in the ordered buffer to handle duplicates */\n  orderedIndexByKey: Map<string | number, number>\n  /** Cleanup function */\n  dispose: () => void\n}\n\n/**\n * Binding handle returned by createKeyedList for compiler-generated code\n */\nexport interface KeyedListBinding {\n  /** Document fragment placeholder inserted by the compiler/runtime */\n  marker: Comment | DocumentFragment\n  /** Start marker comment node */\n  startMarker: Comment\n  /** End marker comment node */\n  endMarker: Comment\n  /** Flush pending items - call after markers are inserted into DOM */\n  flush?: () => void\n  /** Cleanup function */\n  dispose: () => void\n}\n\ntype FineGrainedRenderItem<T> = (\n  itemSig: Signal<T>,\n  indexSig: Signal<number>,\n  key: string | number,\n) => Node[]\n\n// ============================================================================\n// DOM Manipulation Primitives\n// ============================================================================\n\n/**\n * Move nodes to a position before the anchor node.\n * This is optimized to avoid unnecessary DOM operations.\n *\n * @param parent - Parent node to move nodes within\n * @param nodes - Array of nodes to move\n * @param anchor - Node to insert before (or null for end)\n */\nexport function moveNodesBefore(parent: Node, nodes: Node[], anchor: Node | null): void {\n  // Insert in reverse order to maintain correct sequence\n  // This way each node becomes the new anchor for the next\n  for (let i = nodes.length - 1; i >= 0; i--) {\n    const node = nodes[i]!\n    if (!node || !(node instanceof Node)) {\n      const message = isDev ? 'Invalid node in moveNodesBefore' : 'FICT:E_NODE'\n      throw new Error(message)\n    }\n    // Only move if not already in correct position\n    if (node.nextSibling !== anchor) {\n      if (node.ownerDocument !== parent.ownerDocument && parent.ownerDocument) {\n        parent.ownerDocument.adoptNode(node)\n      }\n      try {\n        parent.insertBefore(node, anchor)\n      } catch (e: any) {\n        if (parent.ownerDocument) {\n          try {\n            const clone = parent.ownerDocument.importNode(node, true)\n            parent.insertBefore(clone, anchor)\n            // Update the nodes array with the clone to maintain correct references.\n            // This ensures future operations (like removal or reordering) work correctly.\n            nodes[i] = clone\n            if (isDev) {\n              console.warn(\n                `[fict] Node cloning fallback triggered during list reordering. ` +\n                  `This may indicate cross-document node insertion. ` +\n                  `The node reference has been updated to the clone.`,\n              )\n            }\n            anchor = clone\n            continue\n          } catch {\n            // Clone fallback failed\n          }\n        }\n        throw e\n      }\n    }\n    anchor = node\n  }\n}\n\n/**\n * Remove an array of nodes from the DOM\n *\n * @param nodes - Array of nodes to remove\n */\n// Number.MAX_SAFE_INTEGER is 2^53 - 1, but we reset earlier to avoid any precision issues\nconst MAX_SAFE_VERSION = 0x1fffffffffffff // 2^53 - 1\n\nexport function createVersionedSignalAccessor<T>(initialValue: T): Signal<T> {\n  let current = initialValue\n  let version = 0\n  const track = createSignal(version)\n\n  function accessor(value?: T): T | void {\n    if (arguments.length === 0) {\n      track()\n      return current\n    }\n    current = value as T\n    // This is safe because we only care about version changes, not absolute values\n    version = version >= MAX_SAFE_VERSION ? 1 : version + 1\n    track(version)\n  }\n\n  return accessor as Signal<T>\n}\n\n// ============================================================================\n// Keyed List Container\n// ============================================================================\n\n/**\n * Create a container for managing a keyed list.\n * This sets up the marker nodes and provides cleanup.\n *\n * @returns Container object with markers, blocks map, and dispose function\n */\nfunction createKeyedListContainer<T = unknown>(\n  startOverride?: Comment,\n  endOverride?: Comment,\n): KeyedListContainer<T> {\n  const startMarker = startOverride ?? document.createComment('fict:list:start')\n  const endMarker = endOverride ?? document.createComment('fict:list:end')\n\n  const dispose = () => {\n    // Clean up all blocks\n    for (const block of container.blocks.values()) {\n      destroyRoot(block.root)\n      // Nodes are removed by parent disposal or specific cleanup if needed\n      // But for list disposal, we just clear the container\n    }\n    container.blocks.clear()\n    container.nextBlocks.clear()\n\n    // Remove nodes (including markers)\n    // Check if markers are still in DOM before using Range\n    if (!startMarker.parentNode || !endMarker.parentNode) {\n      // Markers already removed, nothing to do\n      container.currentNodes = []\n      container.nextNodes = []\n      container.orderedBlocks.length = 0\n      container.nextOrderedBlocks.length = 0\n      container.orderedIndexByKey.clear()\n      return\n    }\n    const range = document.createRange()\n    range.setStartBefore(startMarker)\n    range.setEndAfter(endMarker)\n    range.deleteContents()\n\n    // Clear cache\n    container.currentNodes = []\n    container.nextNodes = []\n    container.nextBlocks.clear()\n    container.orderedBlocks.length = 0\n    container.nextOrderedBlocks.length = 0\n    container.orderedIndexByKey.clear()\n  }\n\n  const container: KeyedListContainer<T> = {\n    startMarker,\n    endMarker,\n    blocks: new Map<string | number, KeyedBlock<T>>(),\n    nextBlocks: new Map<string | number, KeyedBlock<T>>(),\n    currentNodes: [startMarker, endMarker],\n    nextNodes: [],\n    orderedBlocks: [],\n    nextOrderedBlocks: [],\n    orderedIndexByKey: new Map<string | number, number>(),\n    dispose,\n  }\n\n  return container\n}\n\n// ============================================================================\n// Block Creation Helpers\n// ============================================================================\n\n/**\n * Create a new keyed block with the given render function\n *\n * @param key - Unique key for this block\n * @param item - Initial item value\n * @param index - Initial index\n * @param render - Function that creates the DOM nodes and sets up bindings\n * @returns New KeyedBlock\n */\nfunction createKeyedBlock<T>(\n  key: string | number,\n  item: T,\n  index: number,\n  render: (item: Signal<T>, index: Signal<number>, key: string | number) => Node[],\n  needsIndex = true,\n  hostRoot?: RootContext,\n): KeyedBlock<T> {\n  // Use versioned signal for all item types; avoid diffing proxy overhead for objects\n  const itemSig = createVersionedSignalAccessor(item)\n\n  const indexSig = needsIndex\n    ? createSignal<number>(index)\n    : (((next?: number) => {\n        if (arguments.length === 0) return index\n        index = next as number\n        return index\n      }) as Signal<number>)\n  const root = createRootContext(hostRoot)\n  const prevRoot = pushRoot(root)\n  // maintaining proper cleanup chain. The scope will be disposed when\n  // the root is destroyed, ensuring nested effects are properly cleaned up.\n  let nodes: Node[] = []\n  let scopeDispose: (() => void) | undefined\n\n  // First, isolate from parent effect to prevent child effects from being\n  // purged when the outer effect (e.g., performDiff) re-runs\n  const prevSub = setActiveSub(undefined)\n\n  try {\n    // Create an effectScope that will track all effects created during render\n    scopeDispose = effectScope(() => {\n      const rendered = render(itemSig, indexSig, key)\n      // If render returns real DOM nodes/arrays, preserve them to avoid\n      // reparenting side-effects (tests may pre-insert them).\n      if (\n        rendered instanceof Node ||\n        (Array.isArray(rendered) && rendered.every(n => n instanceof Node))\n      ) {\n        nodes = toNodeArray(rendered)\n      } else {\n        const element = createElement(rendered as unknown as FictNode)\n        nodes = toNodeArray(element)\n      }\n    })\n\n    // Register the scope cleanup with the root so effects are cleaned up\n    // when the block is destroyed\n    if (scopeDispose) {\n      root.cleanups.push(scopeDispose)\n    }\n  } finally {\n    setActiveSub(prevSub)\n    popRoot(prevRoot)\n  }\n\n  return {\n    key,\n    nodes,\n    root,\n    item: itemSig,\n    index: indexSig,\n    rawItem: item,\n    rawIndex: index,\n  }\n}\n\n// ============================================================================\n// Utilities\n// ============================================================================\n\n/**\n * Check if a node is between two markers\n */\nexport function isNodeBetweenMarkers(\n  node: Node,\n  startMarker: Comment,\n  endMarker: Comment,\n): boolean {\n  let current: Node | null = startMarker.nextSibling\n  while (current && current !== endMarker) {\n    if (current === node) return true\n    current = current.nextSibling\n  }\n  return false\n}\n\nfunction reorderBySwap<T>(\n  parent: ParentNode & Node,\n  first: KeyedBlock<T>,\n  second: KeyedBlock<T>,\n): boolean {\n  if (first === second) return false\n  const firstNodes = first.nodes\n  const secondNodes = second.nodes\n  if (firstNodes.length === 0 || secondNodes.length === 0) return false\n  const lastFirst = firstNodes[firstNodes.length - 1]!\n  const lastSecond = secondNodes[secondNodes.length - 1]!\n  const afterFirst = lastFirst.nextSibling\n  const afterSecond = lastSecond.nextSibling\n  moveNodesBefore(parent, firstNodes, afterSecond)\n  moveNodesBefore(parent, secondNodes, afterFirst)\n  return true\n}\n\nfunction getLISIndices(sequence: number[]): number[] {\n  const predecessors = new Array<number>(sequence.length)\n  const result: number[] = []\n\n  for (let i = 0; i < sequence.length; i++) {\n    const value = sequence[i]!\n    if (value < 0) {\n      predecessors[i] = -1\n      continue\n    }\n\n    let low = 0\n    let high = result.length\n    while (low < high) {\n      const mid = (low + high) >> 1\n      if (sequence[result[mid]!]! < value) {\n        low = mid + 1\n      } else {\n        high = mid\n      }\n    }\n\n    predecessors[i] = low > 0 ? result[low - 1]! : -1\n    if (low === result.length) {\n      result.push(i)\n    } else {\n      result[low] = i\n    }\n  }\n\n  const lis: number[] = new Array(result.length)\n  let k = result.length > 0 ? result[result.length - 1]! : -1\n  for (let i = result.length - 1; i >= 0; i--) {\n    lis[i] = k\n    k = predecessors[k]!\n  }\n  return lis\n}\n\nfunction reorderByLIS<T>(\n  parent: ParentNode & Node,\n  endMarker: Comment,\n  prev: KeyedBlock<T>[],\n  next: KeyedBlock<T>[],\n): boolean {\n  const positions = new Map<KeyedBlock<T>, number>()\n  for (let i = 0; i < prev.length; i++) {\n    positions.set(prev[i]!, i)\n  }\n\n  const sequence = new Array<number>(next.length)\n  for (let i = 0; i < next.length; i++) {\n    const position = positions.get(next[i]!)\n    if (position === undefined) return false\n    sequence[i] = position\n  }\n\n  const lisIndices = getLISIndices(sequence)\n  if (lisIndices.length === sequence.length) return true\n\n  const inLIS = new Array<boolean>(sequence.length).fill(false)\n  for (let i = 0; i < lisIndices.length; i++) {\n    inLIS[lisIndices[i]!] = true\n  }\n\n  let anchor: Node | null = endMarker\n  let moved = false\n  for (let i = next.length - 1; i >= 0; i--) {\n    const block = next[i]!\n    const nodes = block.nodes\n    if (nodes.length === 0) continue\n    if (inLIS[i]) {\n      anchor = nodes[0]!\n      continue\n    }\n    moveNodesBefore(parent, nodes, anchor)\n    anchor = nodes[0]!\n    moved = true\n  }\n\n  return moved\n}\n\n// ============================================================================\n// High-Level List Binding (for compiler-generated code)\n// ============================================================================\n\n/**\n * Create a keyed list binding with automatic diffing and DOM updates.\n * This is used by compiler-generated code for efficient list rendering.\n *\n * @param getItems - Function that returns the current array of items\n * @param keyFn - Function to extract unique key from each item\n * @param renderItem - Function that creates DOM nodes for each item\n * @returns Binding handle with markers and dispose function\n */\nexport function createKeyedList<T>(\n  getItems: () => T[],\n  keyFn: (item: T, index: number) => string | number,\n  renderItem: FineGrainedRenderItem<T>,\n  needsIndex?: boolean,\n  startMarker?: Comment,\n  endMarker?: Comment,\n): KeyedListBinding {\n  const resolvedNeedsIndex =\n    arguments.length >= 4 ? !!needsIndex : renderItem.length > 1 /* has index param */\n  return createFineGrainedKeyedList(\n    getItems,\n    keyFn,\n    renderItem,\n    resolvedNeedsIndex,\n    startMarker,\n    endMarker,\n  )\n}\n\nfunction createFineGrainedKeyedList<T>(\n  getItems: () => T[],\n  keyFn: (item: T, index: number) => string | number,\n  renderItem: FineGrainedRenderItem<T>,\n  needsIndex: boolean,\n  startOverride?: Comment,\n  endOverride?: Comment,\n): KeyedListBinding {\n  const container = createKeyedListContainer<T>(startOverride, endOverride)\n  const hostRoot = getCurrentRoot()\n  const useProvided = !!(startOverride && endOverride)\n  const fragment = useProvided ? container.startMarker : document.createDocumentFragment()\n  if (!useProvided) {\n    ;(fragment as DocumentFragment).append(container.startMarker, container.endMarker)\n  }\n  let disposed = false\n  let effectDispose: (() => void) | undefined\n  let connectObserver: MutationObserver | null = null\n  let effectStarted = false\n  let startScheduled = false\n  let initialHydrating = __fictIsHydrating()\n\n  const collectBetween = (): Node[] => {\n    const nodes: Node[] = []\n    let cursor = container.startMarker.nextSibling\n    while (cursor && cursor !== container.endMarker) {\n      nodes.push(cursor)\n      cursor = cursor.nextSibling\n    }\n    return nodes\n  }\n\n  const getConnectedParent = (): (ParentNode & Node) | null => {\n    const endParent = container.endMarker.parentNode\n    const startParent = container.startMarker.parentNode\n    if (\n      endParent &&\n      startParent &&\n      endParent === startParent &&\n      (endParent as Node).nodeType !== 11\n    ) {\n      const parentNode = endParent as ParentNode & Node\n      if ('isConnected' in parentNode && !parentNode.isConnected) return null\n      return parentNode\n    }\n    if (endParent && startParent && endParent === startParent && isShadowRoot(endParent as Node)) {\n      const shadowRoot = endParent as ShadowRoot\n      const host = shadowRoot.host\n      if ('isConnected' in host && !host.isConnected) return null\n      return shadowRoot as unknown as ParentNode & Node\n    }\n    return null\n  }\n\n  const performDiff = () => {\n    if (disposed) return\n    // During SSR, render synchronously without waiting for DOM connection\n    const isSSR = __fictIsSSR()\n    const parent = isSSR\n      ? (container.startMarker.parentNode as (ParentNode & Node) | null)\n      : getConnectedParent()\n    if (!parent) return\n    batch(() => {\n      const oldBlocks = container.blocks\n      const newBlocks = container.nextBlocks\n      const prevOrderedBlocks = container.orderedBlocks\n      const nextOrderedBlocks = container.nextOrderedBlocks\n      const orderedIndexByKey = container.orderedIndexByKey\n      const newItems = getItems()\n\n      if (initialHydrating && isHydratingActive()) {\n        initialHydrating = false\n        newBlocks.clear()\n        nextOrderedBlocks.length = 0\n        orderedIndexByKey.clear()\n\n        if (newItems.length === 0) {\n          oldBlocks.clear()\n          prevOrderedBlocks.length = 0\n          container.currentNodes = [container.startMarker, container.endMarker]\n          container.nextNodes.length = 0\n          return\n        }\n\n        const createdBlocks: KeyedBlock<T>[] = []\n        withHydrationRange(\n          container.startMarker.nextSibling,\n          container.endMarker,\n          parent.ownerDocument ?? document,\n          () => {\n            for (let index = 0; index < newItems.length; index++) {\n              const item = newItems[index]!\n              const key = keyFn(item, index)\n              if (newBlocks.has(key)) {\n                if (isDev) {\n                  console.warn(\n                    `[fict] Duplicate key \"${String(key)}\" detected in list hydration. ` +\n                      `Each item should have a unique key.`,\n                  )\n                }\n                const existing = newBlocks.get(key)\n                if (existing) {\n                  destroyRoot(existing.root)\n                  removeNodes(existing.nodes)\n                }\n              }\n              const block = createKeyedBlock<T>(key, item, index, renderItem, needsIndex, hostRoot)\n              createdBlocks.push(block)\n              newBlocks.set(key, block)\n              orderedIndexByKey.set(key, nextOrderedBlocks.length)\n              nextOrderedBlocks.push(block)\n            }\n          },\n        )\n\n        container.blocks = newBlocks\n        container.nextBlocks = oldBlocks\n        container.orderedBlocks = nextOrderedBlocks\n        container.nextOrderedBlocks = prevOrderedBlocks\n        oldBlocks.clear()\n        prevOrderedBlocks.length = 0\n        container.currentNodes = [container.startMarker, ...collectBetween(), container.endMarker]\n        container.nextNodes.length = 0\n\n        for (const block of createdBlocks) {\n          if (newBlocks.get(block.key) === block) {\n            flushOnMount(block.root)\n          }\n        }\n\n        return\n      }\n\n      if (newItems.length === 0) {\n        if (oldBlocks.size > 0) {\n          // Destroy all block roots first\n          for (const block of oldBlocks.values()) {\n            destroyRoot(block.root)\n          }\n          // Use Range.deleteContents for efficient bulk DOM removal\n          const range = document.createRange()\n          range.setStartAfter(container.startMarker)\n          range.setEndBefore(container.endMarker)\n          range.deleteContents()\n        }\n        oldBlocks.clear()\n        newBlocks.clear()\n        prevOrderedBlocks.length = 0\n        nextOrderedBlocks.length = 0\n        orderedIndexByKey.clear()\n        container.currentNodes.length = 0\n        container.currentNodes.push(container.startMarker, container.endMarker)\n        container.nextNodes.length = 0\n        return\n      }\n\n      const prevCount = prevOrderedBlocks.length\n      if (prevCount > 0 && newItems.length === prevCount && orderedIndexByKey.size === prevCount) {\n        let stableOrder = true\n        const seen = new Set<string | number>()\n        for (let i = 0; i < prevCount; i++) {\n          const item = newItems[i]!\n          const key = keyFn(item, i)\n          if (seen.has(key) || prevOrderedBlocks[i]!.key !== key) {\n            stableOrder = false\n            break\n          }\n          seen.add(key)\n        }\n        if (stableOrder) {\n          for (let i = 0; i < prevCount; i++) {\n            const item = newItems[i]!\n            const block = prevOrderedBlocks[i]!\n            if (block.rawItem !== item) {\n              block.rawItem = item\n              block.item(item)\n            }\n            if (needsIndex && block.rawIndex !== i) {\n              block.rawIndex = i\n              block.index(i)\n            }\n          }\n          return\n        }\n      }\n\n      newBlocks.clear()\n      nextOrderedBlocks.length = 0\n      orderedIndexByKey.clear()\n      const createdBlocks: KeyedBlock<T>[] = []\n      let appendCandidate = prevCount > 0 && newItems.length >= prevCount\n      const appendedBlocks: KeyedBlock<T>[] = []\n      let mismatchCount = 0\n      let mismatchFirst = -1\n      let mismatchSecond = -1\n      let hasDuplicateKey = false\n\n      // Phase 1: Build new blocks map (reuse or create)\n      newItems.forEach((item, index) => {\n        const key = keyFn(item, index)\n        // Micro-optimization: single Map.get instead of has+get\n        let block = oldBlocks.get(key)\n        const existed = block !== undefined\n\n        if (block) {\n          if (block.rawItem !== item) {\n            block.rawItem = item\n            block.item(item)\n          }\n          if (needsIndex && block.rawIndex !== index) {\n            block.rawIndex = index\n            block.index(index)\n          }\n        }\n\n        if (block) {\n          // Reusing existing block from oldBlocks\n          newBlocks.set(key, block)\n          oldBlocks.delete(key)\n        } else {\n          // If newBlocks already has this key (duplicate key case), clean up the previous block\n          const existingBlock = newBlocks.get(key)\n          if (existingBlock) {\n            if (isDev) {\n              console.warn(\n                `[fict] Duplicate key \"${String(key)}\" detected in list rendering. ` +\n                  `Each item should have a unique key. The previous item with this key will be replaced.`,\n              )\n            }\n            destroyRoot(existingBlock.root)\n            removeNodes(existingBlock.nodes)\n          }\n          // Create new block\n          block = createKeyedBlock<T>(key, item, index, renderItem, needsIndex, hostRoot)\n          createdBlocks.push(block)\n        }\n\n        const resolvedBlock = block\n\n        newBlocks.set(key, resolvedBlock)\n\n        // Micro-optimization: single Map.get instead of checking position multiple times\n        const position = orderedIndexByKey.get(key)\n        if (position !== undefined) {\n          appendCandidate = false\n          hasDuplicateKey = true\n          const prior = nextOrderedBlocks[position]\n          if (prior && prior !== resolvedBlock) {\n            destroyRoot(prior.root)\n            removeNodes(prior.nodes)\n          }\n          nextOrderedBlocks[position] = resolvedBlock\n        } else {\n          if (appendCandidate) {\n            if (index < prevCount) {\n              if (!prevOrderedBlocks[index] || prevOrderedBlocks[index]!.key !== key) {\n                appendCandidate = false\n              }\n            } else if (existed) {\n              appendCandidate = false\n            }\n          }\n          const nextIndex = nextOrderedBlocks.length\n          orderedIndexByKey.set(key, nextIndex)\n          nextOrderedBlocks.push(resolvedBlock)\n          if (\n            mismatchCount < 3 &&\n            (nextIndex >= prevCount || prevOrderedBlocks[nextIndex] !== resolvedBlock)\n          ) {\n            if (mismatchCount === 0) {\n              mismatchFirst = nextIndex\n            } else if (mismatchCount === 1) {\n              mismatchSecond = nextIndex\n            }\n            mismatchCount++\n          }\n        }\n\n        if (appendCandidate && index >= prevCount) {\n          appendedBlocks.push(resolvedBlock)\n        }\n      })\n\n      const canAppend =\n        appendCandidate &&\n        prevCount > 0 &&\n        newItems.length > prevCount &&\n        oldBlocks.size === 0 &&\n        appendedBlocks.length > 0\n      if (canAppend) {\n        const appendedNodes: Node[] = []\n        for (const block of appendedBlocks) {\n          for (let i = 0; i < block.nodes.length; i++) {\n            appendedNodes.push(block.nodes[i]!)\n          }\n        }\n        if (appendedNodes.length > 0) {\n          insertNodesBefore(parent, appendedNodes, container.endMarker)\n          const currentNodes = container.currentNodes\n          currentNodes.pop()\n          for (let i = 0; i < appendedNodes.length; i++) {\n            currentNodes.push(appendedNodes[i]!)\n          }\n          currentNodes.push(container.endMarker)\n        }\n\n        container.blocks = newBlocks\n        container.nextBlocks = oldBlocks\n        container.orderedBlocks = nextOrderedBlocks\n        container.nextOrderedBlocks = prevOrderedBlocks\n        for (const block of createdBlocks) {\n          if (newBlocks.get(block.key) === block) {\n            flushOnMount(block.root)\n          }\n        }\n        return\n      }\n\n      // Phase 2: Remove old blocks that are no longer in the list\n      if (oldBlocks.size > 0) {\n        for (const block of oldBlocks.values()) {\n          destroyRoot(block.root)\n          removeNodes(block.nodes)\n        }\n        oldBlocks.clear()\n      }\n\n      const canReorderInPlace =\n        createdBlocks.length === 0 &&\n        oldBlocks.size === 0 &&\n        nextOrderedBlocks.length === prevOrderedBlocks.length\n\n      let skipReconcile = false\n      let updateNodeBuffer = true\n\n      if (canReorderInPlace && nextOrderedBlocks.length > 0 && !hasDuplicateKey) {\n        if (mismatchCount === 0) {\n          skipReconcile = true\n          updateNodeBuffer = false\n        } else if (\n          mismatchCount === 2 &&\n          prevOrderedBlocks[mismatchFirst] === nextOrderedBlocks[mismatchSecond] &&\n          prevOrderedBlocks[mismatchSecond] === nextOrderedBlocks[mismatchFirst]\n        ) {\n          if (\n            reorderBySwap(\n              parent,\n              prevOrderedBlocks[mismatchFirst]!,\n              prevOrderedBlocks[mismatchSecond]!,\n            )\n          ) {\n            skipReconcile = true\n          }\n        } else if (\n          reorderByLIS(parent, container.endMarker, prevOrderedBlocks, nextOrderedBlocks)\n        ) {\n          skipReconcile = true\n        }\n      }\n\n      // Phase 3: Reconcile DOM with buffered node arrays\n      if (!skipReconcile && (newBlocks.size > 0 || container.currentNodes.length > 0)) {\n        const prevNodes = container.currentNodes\n        const nextNodes = container.nextNodes\n        nextNodes.length = 0\n        nextNodes.push(container.startMarker)\n\n        for (let i = 0; i < nextOrderedBlocks.length; i++) {\n          const nodes = nextOrderedBlocks[i]!.nodes\n          for (let j = 0; j < nodes.length; j++) {\n            nextNodes.push(nodes[j]!)\n          }\n        }\n\n        nextNodes.push(container.endMarker)\n\n        reconcileArrays(parent, prevNodes, nextNodes)\n\n        // Swap buffers to reuse arrays on next diff\n        container.currentNodes = nextNodes\n        container.nextNodes = prevNodes\n      } else if (skipReconcile && updateNodeBuffer) {\n        const prevNodes = container.currentNodes\n        const nextNodes = container.nextNodes\n        nextNodes.length = 0\n        nextNodes.push(container.startMarker)\n        for (let i = 0; i < nextOrderedBlocks.length; i++) {\n          const nodes = nextOrderedBlocks[i]!.nodes\n          for (let j = 0; j < nodes.length; j++) {\n            nextNodes.push(nodes[j]!)\n          }\n        }\n        nextNodes.push(container.endMarker)\n        container.currentNodes = nextNodes\n        container.nextNodes = prevNodes\n      }\n\n      // Swap block maps for reuse\n      container.blocks = newBlocks\n      container.nextBlocks = oldBlocks\n      container.orderedBlocks = nextOrderedBlocks\n      container.nextOrderedBlocks = prevOrderedBlocks\n      for (const block of createdBlocks) {\n        if (newBlocks.get(block.key) === block) {\n          flushOnMount(block.root)\n        }\n      }\n    })\n  }\n\n  const disconnectObserver = () => {\n    connectObserver?.disconnect()\n    connectObserver = null\n  }\n\n  const ensureEffectStarted = (): boolean => {\n    if (disposed || effectStarted) return effectStarted\n    // During SSR, render synchronously without waiting for DOM connection\n    const isSSR = __fictIsSSR()\n    const parent = isSSR\n      ? (container.startMarker.parentNode as (ParentNode & Node) | null)\n      : getConnectedParent()\n    if (!parent) return false\n    const start = () => {\n      effectDispose = createRenderEffect(performDiff)\n      effectStarted = true\n    }\n    if (hostRoot) {\n      const prev = pushRoot(hostRoot)\n      try {\n        start()\n      } finally {\n        popRoot(prev)\n      }\n    } else {\n      start()\n    }\n    return true\n  }\n\n  const waitForConnection = () => {\n    if (connectObserver || typeof MutationObserver === 'undefined') return\n    const root = container.startMarker.getRootNode?.() ?? document\n    const shadowRoot =\n      root && root.nodeType === 11 && isShadowRoot(root as Node) ? (root as ShadowRoot) : null\n    connectObserver = new MutationObserver(() => {\n      if (disposed) return\n      if (getConnectedParent()) {\n        disconnectObserver()\n        if (ensureEffectStarted()) {\n          flush()\n        }\n      }\n    })\n    connectObserver.observe(document, { childList: true, subtree: true })\n    if (shadowRoot) {\n      connectObserver.observe(shadowRoot, { childList: true, subtree: true })\n    }\n  }\n\n  const scheduleStart = () => {\n    if (startScheduled || disposed || effectStarted) return\n    startScheduled = true\n    const run = () => {\n      startScheduled = false\n      if (!ensureEffectStarted()) {\n        waitForConnection()\n      }\n    }\n    if (typeof queueMicrotask === 'function') {\n      queueMicrotask(run)\n    } else {\n      Promise.resolve()\n        .then(run)\n        .catch(() => undefined)\n    }\n  }\n\n  scheduleStart()\n\n  return {\n    get marker() {\n      scheduleStart()\n      return fragment\n    },\n    startMarker: container.startMarker,\n    endMarker: container.endMarker,\n    // Flush pending items - call after markers are inserted into DOM\n    flush: () => {\n      if (disposed) return\n      scheduleStart()\n      if (ensureEffectStarted()) {\n        flush()\n      } else {\n        waitForConnection()\n      }\n    },\n    dispose: () => {\n      disposed = true\n      effectDispose?.()\n      disconnectObserver()\n      container.dispose()\n    },\n  }\n}\n"],"mappings":"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","names":["render","createdBlocks"]}

package/dist/loader.cjs

@@ -6,7 +6,7 @@
 
 
 
-var _chunk6SOPF5LZcjs = require('./chunk-6SOPF5LZ.cjs');
+var _chunk6RCEIWZLcjs = require('./chunk-6RCEIWZL.cjs');
 
 // src/loader.ts
 function resolveModuleUrl(url) {
@@ -57,12 +57,12 @@ function installResumableLoader(options = {}) {
   if (_optionalChain([snapshotEl, 'optionalAccess', _ => _.textContent])) {
     try {
       const state = JSON.parse(snapshotEl.textContent);
-      _chunk6SOPF5LZcjs.__fictSetSSRState.call(void 0, state);
+      _chunk6RCEIWZLcjs.__fictSetSSRState.call(void 0, state);
     } catch (e) {
     }
   }
-  _chunk6SOPF5LZcjs.__fictEnableResumable.call(void 0, );
-  const events = _nullishCoalesce(options.events, () => ( Array.from(_chunk6SOPF5LZcjs.DelegatedEvents)));
+  _chunk6RCEIWZLcjs.__fictEnableResumable.call(void 0, );
+  const events = _nullishCoalesce(options.events, () => ( Array.from(_chunk6RCEIWZLcjs.DelegatedEvents)));
   for (const eventName of events) {
     doc.addEventListener(eventName, handleResumableEvent, true);
   }
@@ -209,9 +209,9 @@ async function handleResumableEventAsync(event) {
     if (!host) continue;
     const scopeId = host.getAttribute("data-fict-s");
     if (!scopeId) continue;
-    const snapshot = _chunk6SOPF5LZcjs.__fictGetSSRScope.call(void 0, scopeId);
+    const snapshot = _chunk6RCEIWZLcjs.__fictGetSSRScope.call(void 0, scopeId);
     if (snapshot) {
-      _chunk6SOPF5LZcjs.__fictEnsureScope.call(void 0, scopeId, host, snapshot);
+      _chunk6RCEIWZLcjs.__fictEnsureScope.call(void 0, scopeId, host, snapshot);
     }
     const { url, exportName } = parseQrl(qrl);
     if (event.cancelable && (event.type === "click" || event.type === "submit")) {
@@ -229,7 +229,7 @@ async function handleResumableEventAsync(event) {
           /* @vite-ignore */
           resolvedResumeUrl
         )));
-        const resumeFn = _chunk6SOPF5LZcjs.__fictGetResume.call(void 0, resumeExport);
+        const resumeFn = _chunk6RCEIWZLcjs.__fictGetResume.call(void 0, resumeExport);
         if (typeof resumeFn === "function") {
           await resumeFn(scopeId, host);
           hydratedScopes.add(scopeId);
@@ -276,5 +276,5 @@ function buildEventPath(event) {
 
 
 
-exports.__fictUseLexicalScope = _chunk6SOPF5LZcjs.__fictUseLexicalScope; exports.cleanupEventListeners = cleanupEventListeners; exports.installResumableLoader = installResumableLoader; exports.resetHydratedScopes = resetHydratedScopes; exports.resetPrefetchedUrls = resetPrefetchedUrls; exports.waitForPendingHandlers = waitForPendingHandlers;
+exports.__fictUseLexicalScope = _chunk6RCEIWZLcjs.__fictUseLexicalScope; exports.cleanupEventListeners = cleanupEventListeners; exports.installResumableLoader = installResumableLoader; exports.resetHydratedScopes = resetHydratedScopes; exports.resetPrefetchedUrls = resetPrefetchedUrls; exports.waitForPendingHandlers = waitForPendingHandlers;
 //# sourceMappingURL=loader.cjs.map

package/dist/loader.js

@@ -6,7 +6,7 @@ import {
   __fictGetSSRScope,
   __fictSetSSRState,
   __fictUseLexicalScope
-} from "./chunk-FKDMDAUR.js";
+} from "./chunk-7BO6P2KP.js";
 
 // src/loader.ts
 function resolveModuleUrl(url) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fictjs/runtime",
-  "version": "0.5.0",
+  "version": "0.5.1",
   "description": "Fict reactive runtime",
   "publishConfig": {
     "access": "public",

package/src/cycle-guard.ts

@@ -35,7 +35,7 @@ let enterRootGuard: (root: object) => boolean = () => true
 let exitRootGuard: (root: object) => void = () => {}
 
 const defaultOptions = {
-  enabled: true,
+  enabled: isDev,
   maxFlushCyclesPerMicrotask: 10_000,
   maxEffectRunsPerFlush: 20_000,
   windowSize: 5,

package/src/list-helpers.ts

@@ -32,6 +32,9 @@ const isDev =
     ? __DEV__
     : typeof process === 'undefined' || process.env?.NODE_ENV !== 'production'
 
+const isShadowRoot = (node: Node): node is ShadowRoot =>
+  typeof ShadowRoot !== 'undefined' && node instanceof ShadowRoot
+
 // ============================================================================
 // Types
 // ============================================================================
@@ -469,7 +472,7 @@ function reorderByLIS<T>(
  * @param renderItem - Function that creates DOM nodes for each item
  * @returns Binding handle with markers and dispose function
  */
-export function createKeyedList<T extends object>(
+export function createKeyedList<T>(
   getItems: () => T[],
   keyFn: (item: T, index: number) => string | number,
   renderItem: FineGrainedRenderItem<T>,
@@ -489,7 +492,7 @@ export function createKeyedList<T extends object>(
   )
 }
 
-function createFineGrainedKeyedList<T extends object>(
+function createFineGrainedKeyedList<T>(
   getItems: () => T[],
   keyFn: (item: T, index: number) => string | number,
   renderItem: FineGrainedRenderItem<T>,
@@ -534,6 +537,12 @@ function createFineGrainedKeyedList<T extends object>(
       if ('isConnected' in parentNode && !parentNode.isConnected) return null
       return parentNode
     }
+    if (endParent && startParent && endParent === startParent && isShadowRoot(endParent as Node)) {
+      const shadowRoot = endParent as ShadowRoot
+      const host = shadowRoot.host
+      if ('isConnected' in host && !host.isConnected) return null
+      return shadowRoot as unknown as ParentNode & Node
+    }
     return null
   }
 
@@ -589,7 +598,7 @@ function createFineGrainedKeyedList<T extends object>(
                   removeNodes(existing.nodes)
                 }
               }
-              const block = createKeyedBlock(key, item, index, renderItem, needsIndex, hostRoot)
+              const block = createKeyedBlock<T>(key, item, index, renderItem, needsIndex, hostRoot)
               createdBlocks.push(block)
               newBlocks.set(key, block)
               orderedIndexByKey.set(key, nextOrderedBlocks.length)
@@ -716,7 +725,7 @@ function createFineGrainedKeyedList<T extends object>(
             removeNodes(existingBlock.nodes)
           }
           // Create new block
-          block = createKeyedBlock(key, item, index, renderItem, needsIndex, hostRoot)
+          block = createKeyedBlock<T>(key, item, index, renderItem, needsIndex, hostRoot)
           createdBlocks.push(block)
         }
 
@@ -925,6 +934,9 @@ function createFineGrainedKeyedList<T extends object>(
 
   const waitForConnection = () => {
     if (connectObserver || typeof MutationObserver === 'undefined') return
+    const root = container.startMarker.getRootNode?.() ?? document
+    const shadowRoot =
+      root && root.nodeType === 11 && isShadowRoot(root as Node) ? (root as ShadowRoot) : null
     connectObserver = new MutationObserver(() => {
       if (disposed) return
       if (getConnectedParent()) {
@@ -935,6 +947,9 @@ function createFineGrainedKeyedList<T extends object>(
       }
     })
     connectObserver.observe(document, { childList: true, subtree: true })
+    if (shadowRoot) {
+      connectObserver.observe(shadowRoot, { childList: true, subtree: true })
+    }
   }
 
   const scheduleStart = () => {

package/src/signal.ts

@@ -103,6 +103,10 @@ export interface SignalNode<T = unknown> extends BaseNode {
   currentValue: T
   /** Pending value to be committed */
   pendingValue: T
+  /** Previous committed value (for cleanup reads) */
+  prevValue?: T
+  /** Flush id when prevValue was recorded */
+  prevFlushId?: number
   /** Signals don't have dependencies */
   deps?: undefined
   depsTail?: undefined
@@ -123,6 +127,10 @@ export interface SignalNode<T = unknown> extends BaseNode {
 export interface ComputedNode<T = unknown> extends BaseNode {
   /** Current computed value */
   value: T
+  /** Previous computed value (for cleanup reads) */
+  prevValue?: T
+  /** Flush id when prevValue was recorded */
+  prevFlushId?: number
   /** First dependency link */
   deps: Link | undefined
   /** Last dependency link */
@@ -251,6 +259,8 @@ let cycle = 0
 let batchDepth = 0
 let activeSub: ReactiveNode | undefined
 let flushScheduled = false
+let currentFlushId = 0
+let activeCleanupFlushId = 0
 // Dual-priority queue for scheduler
 const highPriorityQueue: EffectNode[] = []
 const lowPriorityQueue: EffectNode[] = []
@@ -798,6 +808,8 @@ function updateSignal(s: SignalNode): boolean {
   const current = s.currentValue
   const pending = s.pendingValue
   if (valuesDiffer(s, current, pending)) {
+    s.prevValue = current
+    s.prevFlushId = currentFlushId
     s.currentValue = pending
     return true
   }
@@ -822,6 +834,8 @@ function updateComputed<T>(c: ComputedNode<T>): boolean {
     c.flags &= ~Running
     purgeDeps(c)
     if (valuesDiffer(c, oldValue, newValue)) {
+      c.prevValue = oldValue
+      c.prevFlushId = currentFlushId
       c.value = newValue
       if (isDev) updateComputedDevtools(c, newValue)
       return true
@@ -839,16 +853,20 @@ function updateComputed<T>(c: ComputedNode<T>): boolean {
  */
 function runEffect(e: EffectNode): void {
   const flags = e.flags
-  // Run cleanup BEFORE checkDirty so cleanup sees previous signal values
-  if (flags & Dirty) {
-    if (e.runCleanup) {
-      inCleanup = true
-      try {
-        e.runCleanup()
-      } finally {
-        inCleanup = false
-      }
+  const runCleanup = () => {
+    if (!e.runCleanup) return
+    inCleanup = true
+    activeCleanupFlushId = currentFlushId
+    try {
+      e.runCleanup()
+    } finally {
+      activeCleanupFlushId = 0
+      inCleanup = false
     }
+  }
+  if (flags & Dirty) {
+    // Run cleanup before re-run; values are still the previous commit.
+    runCleanup()
     ++cycle
     if (isDev) effectRunDevtools(e)
     e.depsTail = undefined
@@ -866,15 +884,6 @@ function runEffect(e: EffectNode): void {
       throw err
     }
   } else if (flags & Pending && e.deps) {
-    // Run cleanup before checkDirty which commits signal values
-    if (e.runCleanup) {
-      inCleanup = true
-      try {
-        e.runCleanup()
-      } finally {
-        inCleanup = false
-      }
-    }
     let isDirty = false
     try {
       isDirty = checkDirty(e.deps, e)
@@ -894,6 +903,9 @@ function runEffect(e: EffectNode): void {
       throw err
     }
     if (isDirty) {
+      // Only run cleanup if the effect will actually re-run.
+      // Cleanup reads should observe previous values for this flush.
+      runCleanup()
       ++cycle
       if (isDev) effectRunDevtools(e)
       e.depsTail = undefined
@@ -947,6 +959,7 @@ function flush(): void {
     endFlushGuard()
     return
   }
+  currentFlushId++
   flushScheduled = false
 
   // 1. Process all high-priority effects first
@@ -1071,6 +1084,12 @@ function signalOper<T>(this: SignalNode<T>, value?: T): T | void {
       if (subs !== undefined) shallowPropagate(subs)
     }
   }
+  if (inCleanup) {
+    if (this.prevFlushId === activeCleanupFlushId) {
+      return this.prevValue as T
+    }
+    return this.currentValue
+  }
 
   let sub = activeSub
   while (sub !== undefined) {
@@ -1118,10 +1137,14 @@ export function computed<T>(
   return bound as ComputedAccessor<T>
 }
 function computedOper<T>(this: ComputedNode<T>): T {
-  // fix: During cleanup, return cached value without triggering any updates.
-  // This ensures cleanup functions see the previous state, not the new pending values.
-  // Without this check, checkDirty() could commit pending signal values during cleanup.
-  if (inCleanup) return this.value
+  // fix: During cleanup, return previous value for this flush without triggering updates.
+  // This ensures cleanup functions observe the pre-commit state for this effect.
+  if (inCleanup) {
+    if (this.prevFlushId === activeCleanupFlushId) {
+      return this.prevValue as T
+    }
+    return this.value
+  }
 
   const flags = this.flags
 
@@ -1388,6 +1411,8 @@ export function __resetReactiveState(): void {
   isInTransition = false
   inCleanup = false
   cycle = 0
+  currentFlushId = 0
+  activeCleanupFlushId = 0
 }
 /**
  * Execute a function without tracking dependencies