@farm.js/react 0.1.0-beta.7 → 0.1.0-beta.9

package/dist/compiler-runtime.cjs

@@ -25,6 +25,9 @@ function materializeIterable(source) {
 }
 
 // src/compiler-runtime.tsx
+function reversedCompilerKeyedArrayOrder(order) {
+  return order === 0 /* Reverse */ ? void 0 : order ?? 0 /* Reverse */;
+}
 var COMPILER_KEYED_COLLECTION_TOKENS = /* @__PURE__ */ new WeakMap();
 var COMPILER_KEYED_MAP_UPDATES = /* @__PURE__ */ new WeakMap();
 var COMPILER_KEYED_ARRAY_APPENDS = /* @__PURE__ */ new WeakMap();
@@ -32,13 +35,17 @@ var COMPILER_KEYED_ARRAY_FILTERS = /* @__PURE__ */ new WeakMap();
 var COMPILER_KEYED_ARRAY_PREPENDS = /* @__PURE__ */ new WeakMap();
 var COMPILER_KEYED_ARRAY_ROLLING_WINDOWS = /* @__PURE__ */ new WeakMap();
 var COMPILER_KEYED_ARRAY_POSITIONS = /* @__PURE__ */ new WeakMap();
+var COMPILER_KEYED_ARRAY_BATCH_INSERTS = /* @__PURE__ */ new WeakMap();
+var COMPILER_KEYED_ARRAY_WINDOW_REPLACEMENTS = /* @__PURE__ */ new WeakMap();
 var COMPILER_KEYED_ARRAY_REORDERS = /* @__PURE__ */ new WeakMap();
 var COMPILER_KEYED_COLLECTION_DRAFTS = /* @__PURE__ */ new WeakMap();
 var COMPILER_KEYED_COLLECTION_UPDATES = /* @__PURE__ */ new WeakMap();
 var COMPILER_KEYED_COMMITTED_COLLECTIONS = /* @__PURE__ */ new WeakSet();
+var COMPILER_KEYED_COMMITTED_ITEM_SNAPSHOTS = /* @__PURE__ */ new WeakMap();
 var NATIVE_ARRAY_PROTOTYPE = Array.prototype;
 var NATIVE_ARRAY_ITERATOR = Array.prototype[Symbol.iterator];
 var NATIVE_ARRAY_FILTER = Array.prototype.filter;
+var NATIVE_ARRAY_MAP = Array.prototype.map;
 var NATIVE_ARRAY_SLICE = Array.prototype.slice;
 var NATIVE_ARRAY_TO_SPLICED = Array.prototype.toSpliced;
 var NATIVE_ARRAY_WITH = Array.prototype.with;
@@ -64,6 +71,26 @@ function commitCompilerKeyedCollection(value) {
   COMPILER_KEYED_COMMITTED_COLLECTIONS.add(target);
   return compilerKeyedCollectionToken(target);
 }
+function commitCompilerKeyedCollectionWithItemSnapshot(value, instances) {
+  const token = commitCompilerKeyedCollection(value);
+  if (!token) return void 0;
+  if (!instances) {
+    COMPILER_KEYED_COMMITTED_ITEM_SNAPSHOTS.delete(token);
+    return token;
+  }
+  const items = [];
+  let index = 0;
+  for (const instance of instances.values()) {
+    if (instance.index !== index) {
+      COMPILER_KEYED_COMMITTED_ITEM_SNAPSHOTS.delete(token);
+      return token;
+    }
+    items.push(instance.item);
+    index += 1;
+  }
+  COMPILER_KEYED_COMMITTED_ITEM_SNAPSHOTS.set(token, items);
+  return token;
+}
 function compilerKeyedMapChangedIndices(value, sourceToken) {
   const target = compilerObject(value);
   if (!target || !sourceToken) return void 0;
@@ -93,11 +120,52 @@ function compilerKeyedArrayAppendStart(value, sourceToken, expectedStart) {
   }
   return length === value.length ? expectedStart : void 0;
 }
+function compilerKeyedArrayStructuralAppendUpdate(value, sourceToken, expectedStart) {
+  const target = compilerObject(value);
+  if (!target || !sourceToken || !Array.isArray(value)) return void 0;
+  const update = COMPILER_KEYED_ARRAY_APPENDS.get(target);
+  if (!update || update.sourceToken !== sourceToken) return void 0;
+  const updates = [];
+  for (let current = update; current; current = current.previous) {
+    if (current.sourceToken !== sourceToken) return void 0;
+    updates.push(current);
+  }
+  updates.reverse();
+  const structuralUpdate = update.structuralUpdate;
+  const first = updates[0];
+  const survivorResult = structuralUpdate ? compilerKeyedArrayFilterSurvivorsFromUpdate(
+    structuralUpdate,
+    sourceToken,
+    expectedStart,
+    first.startIndex
+  ) : void 0;
+  if (structuralUpdate && !survivorResult) return void 0;
+  let length = structuralUpdate ? first.startIndex : expectedStart;
+  const startIndex = length;
+  for (const current of updates) {
+    if (current.startIndex !== length || current.resultLength < length) return void 0;
+    length = current.resultLength;
+  }
+  return length === value.length ? {
+    startIndex,
+    structuralUpdate,
+    ...survivorResult ? { structuralSurvivors: survivorResult } : {}
+  } : void 0;
+}
 function compilerKeyedArrayFilterSurvivors(value, sourceToken, expectedLength) {
   const target = compilerObject(value);
   if (!target || !sourceToken || !Array.isArray(value)) return void 0;
   const update = COMPILER_KEYED_ARRAY_FILTERS.get(target);
   if (!update || update.sourceToken !== sourceToken) return void 0;
+  return compilerKeyedArrayFilterSurvivorsFromUpdate(
+    update,
+    sourceToken,
+    expectedLength,
+    value.length
+  );
+}
+function compilerKeyedArrayFilterSurvivorsFromUpdate(update, sourceToken, expectedLength, resultLength) {
+  if (!sourceToken || update.sourceToken !== sourceToken) return void 0;
   const updates = [];
   for (let current = update; current; current = current.previous) {
     if (current.sourceToken !== sourceToken) return void 0;
@@ -127,7 +195,80 @@ function compilerKeyedArrayFilterSurvivors(value, sourceToken, expectedLength) {
     if (current.resultLength !== current.sourceLength - removed.size) return void 0;
     survivors = survivors.filter((_sourceIndex, index) => !removed.has(index));
   }
-  return survivors.length === value.length ? { indices: survivors, keysStable } : void 0;
+  return survivors.length === resultLength ? { indices: survivors, keysStable } : void 0;
+}
+function compilerKeyedArraySliceSurvivorRangeFromUpdate(update, sourceToken, expectedLength, resultLength) {
+  if (!sourceToken || update.sourceToken !== sourceToken) return void 0;
+  const updates = [];
+  for (let current = update; current; current = current.previous) {
+    if (current.sourceToken !== sourceToken || current.kind !== "slice") return void 0;
+    updates.push(current);
+  }
+  let length = expectedLength;
+  let start = 0;
+  for (let index = updates.length - 1; index >= 0; index -= 1) {
+    const current = updates[index];
+    const retainedStart = current.retainedStart;
+    const retainedEnd = current.retainedEnd;
+    if (current.sourceLength !== length || retainedStart === void 0 || retainedEnd === void 0 || !Number.isSafeInteger(retainedStart) || !Number.isSafeInteger(retainedEnd) || retainedStart < 0 || retainedEnd < retainedStart || retainedEnd > current.sourceLength || current.resultLength !== retainedEnd - retainedStart) {
+      return void 0;
+    }
+    start += retainedStart;
+    length = current.resultLength;
+  }
+  return length === resultLength ? { end: start + length, start } : void 0;
+}
+function compilerKeyedArrayStructuralAppendMapUpdate(value, sourceToken, expectedStart, requireMappedUpdate = false) {
+  const target = compilerObject(value);
+  if (!target || !sourceToken || !Array.isArray(value)) return void 0;
+  const update = COMPILER_KEYED_ARRAY_APPENDS.get(target);
+  if (!update || update.sourceToken !== sourceToken || !update.structuralUpdate || requireMappedUpdate && !update.mappedItemSources) {
+    return void 0;
+  }
+  const updates = [];
+  for (let current = update; current; current = current.previous) {
+    if (current.sourceToken !== sourceToken) return void 0;
+    updates.push(current);
+  }
+  updates.reverse();
+  const first = updates[0];
+  const structuralSurvivorRange = compilerKeyedArraySliceSurvivorRangeFromUpdate(
+    update.structuralUpdate,
+    sourceToken,
+    expectedStart,
+    first.startIndex
+  );
+  const structuralSurvivors = structuralSurvivorRange ? void 0 : compilerKeyedArrayFilterSurvivorsFromUpdate(
+    update.structuralUpdate,
+    sourceToken,
+    expectedStart,
+    first.startIndex
+  )?.indices;
+  if (!structuralSurvivorRange && !structuralSurvivors) return void 0;
+  let length = first.startIndex;
+  const startIndex = length;
+  for (const current of updates) {
+    if (current.startIndex !== length || current.resultLength < length) return void 0;
+    length = current.resultLength;
+  }
+  return length === value.length ? {
+    startIndex,
+    ...structuralSurvivorRange ? { structuralSurvivorRange } : {},
+    ...structuralSurvivors ? { structuralSurvivors } : {},
+    ...update.mappedItemSources ? { mappedItemSources: update.mappedItemSources } : {},
+    ...update.mappedSurvivorsValidated ? { mappedSurvivorsValidated: true } : {}
+  } : void 0;
+}
+function compilerKeyedArrayFilterSource(update, resultLength) {
+  if (update.resultLength !== resultLength) return void 0;
+  let current = update;
+  while (current.previous) {
+    if (current.sourceToken !== current.previous.sourceToken || current.sourceLength !== current.previous.resultLength) {
+      return void 0;
+    }
+    current = current.previous;
+  }
+  return { sourceLength: current.sourceLength, sourceToken: current.sourceToken };
 }
 function compilerKeyedArrayPrependLength(value, sourceToken, expectedLength) {
   const target = compilerObject(value);
@@ -151,29 +292,148 @@ function compilerKeyedArrayPrependLength(value, sourceToken, expectedLength) {
   }
   return length === value.length ? prefixLength : void 0;
 }
-function compilerKeyedArrayRollingWindow(value, sourceToken, expectedLength) {
+function compilerKeyedArrayStructuralPrependUpdate(value, sourceToken, expectedLength) {
   const target = compilerObject(value);
   if (!target || !sourceToken || !Array.isArray(value)) return void 0;
-  const update = COMPILER_KEYED_ARRAY_ROLLING_WINDOWS.get(target);
-  if (!update || update.sourceToken !== sourceToken || update.sourceLength !== expectedLength || update.resultLength !== value.length || update.retainedStart < 1 || update.retainedEnd !== update.sourceLength || update.resultLength <= update.retainedEnd - update.retainedStart) {
+  const update = COMPILER_KEYED_ARRAY_PREPENDS.get(target);
+  if (!update || update.sourceToken !== sourceToken) return void 0;
+  const updates = [];
+  for (let current = update; current; current = current.previous) {
+    if (current.sourceToken !== sourceToken) return void 0;
+    updates.push(current);
+  }
+  updates.reverse();
+  const structuralUpdate = update.structuralUpdate;
+  const first = updates[0];
+  const survivorResult = structuralUpdate ? compilerKeyedArrayFilterSurvivorsFromUpdate(
+    structuralUpdate,
+    sourceToken,
+    expectedLength,
+    first.sourceLength
+  ) : void 0;
+  if (structuralUpdate && !survivorResult) return void 0;
+  let length = structuralUpdate ? first.sourceLength : expectedLength;
+  let prefixLength = 0;
+  for (const current of updates) {
+    if (current.sourceLength !== length || current.prefixLength < 1 || current.resultLength !== current.sourceLength + current.prefixLength) {
+      return void 0;
+    }
+    length = current.resultLength;
+    prefixLength += current.prefixLength;
+  }
+  return length === value.length ? {
+    prefixLength,
+    structuralUpdate,
+    ...survivorResult ? { structuralSurvivors: survivorResult } : {}
+  } : void 0;
+}
+function compilerKeyedArrayStructuralPrependMapUpdate(value, sourceToken, expectedLength, requireMappedUpdate = false) {
+  const target = compilerObject(value);
+  if (!target || !sourceToken || !Array.isArray(value)) return void 0;
+  const update = COMPILER_KEYED_ARRAY_PREPENDS.get(target);
+  if (!update || update.sourceToken !== sourceToken || !update.structuralUpdate || requireMappedUpdate && !update.mappedItemSources) {
     return void 0;
   }
-  return update;
+  const updates = [];
+  for (let current = update; current; current = current.previous) {
+    if (current.sourceToken !== sourceToken) return void 0;
+    updates.push(current);
+  }
+  updates.reverse();
+  const first = updates[0];
+  const structuralSurvivorRange = compilerKeyedArraySliceSurvivorRangeFromUpdate(
+    update.structuralUpdate,
+    sourceToken,
+    expectedLength,
+    first.sourceLength
+  );
+  const structuralSurvivors = structuralSurvivorRange ? void 0 : compilerKeyedArrayFilterSurvivorsFromUpdate(
+    update.structuralUpdate,
+    sourceToken,
+    expectedLength,
+    first.sourceLength
+  )?.indices;
+  if (!structuralSurvivorRange && !structuralSurvivors) return void 0;
+  let length = first.sourceLength;
+  let prefixLength = 0;
+  for (const current of updates) {
+    if (current.sourceLength !== length || current.prefixLength < 1 || current.resultLength !== current.sourceLength + current.prefixLength) {
+      return void 0;
+    }
+    length = current.resultLength;
+    prefixLength += current.prefixLength;
+  }
+  return length === value.length ? {
+    prefixLength,
+    ...structuralSurvivorRange ? { structuralSurvivorRange } : {},
+    ...structuralSurvivors ? { structuralSurvivors } : {},
+    ...update.mappedItemSources ? { mappedItemSources: update.mappedItemSources } : {},
+    ...update.mappedSurvivorsValidated ? { mappedSurvivorsValidated: true } : {}
+  } : void 0;
+}
+function compilerKeyedArrayRollingWindows(value, sourceToken, expectedLength) {
+  const target = compilerObject(value);
+  if (!target || !sourceToken || !Array.isArray(value)) return void 0;
+  const update = COMPILER_KEYED_ARRAY_ROLLING_WINDOWS.get(target);
+  if (!update || update.sourceToken !== sourceToken) return void 0;
+  const updates = [];
+  for (let current = update; current; current = current.previous) {
+    if (current.sourceToken !== sourceToken) return void 0;
+    updates.push(current);
+  }
+  updates.reverse();
+  let length = expectedLength;
+  for (const current of updates) {
+    if (current.sourceLength !== length || current.retainedStart < 1 || current.retainedStart > current.sourceLength || current.retainedEnd !== current.sourceLength || current.resultLength <= current.retainedEnd - current.retainedStart) {
+      return void 0;
+    }
+    length = current.resultLength;
+  }
+  return length === value.length ? updates : void 0;
 }
 function compilerKeyedArrayPosition(value, sourceToken, expectedLength) {
   const target = compilerObject(value);
   if (!target || !sourceToken || !Array.isArray(value)) return void 0;
   const update = COMPILER_KEYED_ARRAY_POSITIONS.get(target);
-  if (!update || update.sourceToken !== sourceToken || update.sourceLength !== expectedLength || update.resultLength !== value.length || update.position < 0 || update.position > expectedLength || update.kind === "insert" && update.resultLength !== expectedLength + 1 || update.kind === "remove" && (update.position >= expectedLength || update.resultLength !== expectedLength - 1) || update.kind === "replace" && (update.position >= expectedLength || update.resultLength !== expectedLength)) {
+  if (!update || update.sourceToken !== sourceToken || update.sourceLength !== expectedLength || update.resultLength !== value.length || update.position < 0 || update.position > expectedLength || update.kind === "insert" && update.resultLength !== expectedLength + 1 || update.kind === "remove" && (update.resultLength >= expectedLength || update.position > update.resultLength) || update.kind === "replace" && (update.position >= expectedLength || update.resultLength !== expectedLength)) {
+    return void 0;
+  }
+  return update;
+}
+function compilerKeyedArrayBatchInsert(value, sourceToken, expectedLength) {
+  const target = compilerObject(value);
+  if (!target || !sourceToken || !Array.isArray(value)) return void 0;
+  const update = COMPILER_KEYED_ARRAY_BATCH_INSERTS.get(target);
+  if (!update || update.sourceToken !== sourceToken || update.sourceLength !== expectedLength || update.resultLength !== value.length || update.resultLength < expectedLength + 2 || update.position < 0 || update.position > expectedLength) {
     return void 0;
   }
   return update;
 }
+function compilerKeyedArrayWindowReplacements(value, sourceToken, expectedLength) {
+  const target = compilerObject(value);
+  if (!target || !sourceToken || !Array.isArray(value)) return void 0;
+  const update = COMPILER_KEYED_ARRAY_WINDOW_REPLACEMENTS.get(target);
+  if (!update || update.sourceToken !== sourceToken) return void 0;
+  const updates = [];
+  for (let current = update; current; current = current.previous) {
+    if (current.sourceToken !== sourceToken) return void 0;
+    updates.push(current);
+  }
+  updates.reverse();
+  let length = expectedLength;
+  for (const current of updates) {
+    if (current.sourceLength !== length || current.position < 0 || current.position >= current.sourceLength || current.removedCount < 1 || current.position + current.removedCount > current.sourceLength || current.insertedCount < 0 || current.resultLength !== current.sourceLength - current.removedCount + current.insertedCount) {
+      return void 0;
+    }
+    length = current.resultLength;
+  }
+  return length === value.length ? updates : void 0;
+}
 function compilerKeyedArrayReorder(value, sourceToken, expectedLength) {
   const target = compilerObject(value);
   if (!target || !sourceToken || !Array.isArray(value)) return void 0;
   const update = COMPILER_KEYED_ARRAY_REORDERS.get(target);
-  if (!update || update.sourceToken !== sourceToken || update.sourceLength !== expectedLength || update.resultLength !== expectedLength || update.resultLength !== value.length) {
+  if (!update || update.sourceToken !== sourceToken || update.sourceLength !== expectedLength || !update.structuralUpdate && update.resultLength !== expectedLength || update.resultLength !== value.length) {
     return void 0;
   }
   return update;
@@ -190,7 +450,7 @@ function compilerKeyedCollectionChangedKeys(value, sourceToken, kind) {
   }
   return changedKeys;
 }
-function createCompilerKeyedMapUpdate(previous, value, changedIndices) {
+function recordCompilerKeyedMapUpdate(previous, value, changedIndices) {
   const previousTarget = compilerObject(previous);
   const valueTarget = compilerObject(value);
   const sourceToken = compilerKeyedCollectionToken(previousTarget);
@@ -204,6 +464,212 @@ function createCompilerKeyedMapUpdate(previous, value, changedIndices) {
   }
   return value;
 }
+function executeCompilerKeyedMapPipeline(previous, pipeline, record) {
+  let eligible = true;
+  const applyMap = (collection, method, callback) => {
+    const value2 = NATIVE_REFLECT_APPLY(
+      method,
+      collection,
+      [callback]
+    );
+    if (method !== NATIVE_ARRAY_MAP) {
+      eligible = false;
+      return value2;
+    }
+    try {
+      if (!Array.isArray(value2) || Object.getPrototypeOf(value2) !== NATIVE_ARRAY_PROTOTYPE) {
+        eligible = false;
+      }
+    } catch {
+      eligible = false;
+    }
+    return value2;
+  };
+  const value = NATIVE_REFLECT_APPLY(pipeline, void 0, [previous, applyMap]);
+  return eligible ? record(previous, value) : value;
+}
+function recordCompilerKeyedMapPipelineUpdate(previous, value) {
+  try {
+    if (!Array.isArray(previous) || !Array.isArray(value) || Object.getPrototypeOf(previous) !== NATIVE_ARRAY_PROTOTYPE || Object.getPrototypeOf(value) !== NATIVE_ARRAY_PROTOTYPE || value.length !== previous.length) {
+      return value;
+    }
+    const finalChangedIndices = [];
+    for (let index = 0; index < previous.length; index += 1) {
+      const previousDescriptor = Object.getOwnPropertyDescriptor(previous, index);
+      const mappedDescriptor = Object.getOwnPropertyDescriptor(value, index);
+      if (!previousDescriptor || !("value" in previousDescriptor) || !mappedDescriptor || !("value" in mappedDescriptor)) {
+        return value;
+      }
+      if (mappedDescriptor.value !== previousDescriptor.value) finalChangedIndices.push(index);
+    }
+    return recordCompilerKeyedMapUpdate(previous, value, finalChangedIndices);
+  } catch {
+    return value;
+  }
+}
+function createCompilerKeyedMapUpdate(previous, valueOrPipeline, changedIndices) {
+  if (Array.isArray(changedIndices)) {
+    return recordCompilerKeyedMapUpdate(previous, valueOrPipeline, changedIndices);
+  }
+  if (changedIndices !== void 0 || typeof valueOrPipeline !== "function") {
+    return valueOrPipeline;
+  }
+  return executeCompilerKeyedMapPipeline(
+    previous,
+    valueOrPipeline,
+    recordCompilerKeyedMapPipelineUpdate
+  );
+}
+function recordCompilerKeyedArrayMapPipeline(previous, value) {
+  try {
+    const previousTarget = compilerObject(previous);
+    const valueTarget = compilerObject(value);
+    if (!previousTarget || !valueTarget || !Array.isArray(previous) || !Array.isArray(value) || Object.getPrototypeOf(previous) !== NATIVE_ARRAY_PROTOTYPE || Object.getPrototypeOf(value) !== NATIVE_ARRAY_PROTOTYPE || value.length !== previous.length) {
+      return value;
+    }
+    const committedSource = COMPILER_KEYED_COMMITTED_COLLECTIONS.has(previousTarget);
+    const previousReorder = committedSource ? void 0 : COMPILER_KEYED_ARRAY_REORDERS.get(previousTarget);
+    const structuralUpdate = previousReorder?.structuralUpdate || (!previousReorder ? COMPILER_KEYED_ARRAY_FILTERS.get(previousTarget) : void 0);
+    const structuralSource = structuralUpdate ? compilerKeyedArrayFilterSource(structuralUpdate, previous.length) : void 0;
+    const previousSource = previousReorder && !previousReorder.structuralUpdate ? previousReorder : void 0;
+    if (!committedSource && (!previousSource || previousSource.resultLength !== previous.length) && !structuralSource) {
+      return value;
+    }
+    const sourceToken = previousSource?.sourceToken || structuralSource?.sourceToken || compilerKeyedCollectionToken(previousTarget);
+    if (!sourceToken) return value;
+    const previousMappedItemSources = previousReorder?.mappedItemSources || structuralUpdate?.mappedItemSources;
+    const mappedItemSources = /* @__PURE__ */ new Map();
+    for (let index = 0; index < value.length; index += 1) {
+      const previousDescriptor = Object.getOwnPropertyDescriptor(previous, index);
+      const mappedDescriptor = Object.getOwnPropertyDescriptor(value, index);
+      if (!previousDescriptor || !("value" in previousDescriptor) || !mappedDescriptor || !("value" in mappedDescriptor)) {
+        return value;
+      }
+      const previousItem = previousDescriptor.value;
+      const sourceItem = previousMappedItemSources?.has(previousItem) ? previousMappedItemSources.get(previousItem) : previousItem;
+      const mappedItem = mappedDescriptor.value;
+      if (!Object.is(mappedItem, sourceItem)) mappedItemSources.set(mappedItem, sourceItem);
+    }
+    const hint = {
+      kind: committedSource ? void 0 : previousReorder?.kind,
+      sourceToken,
+      sourceLength: previousSource?.sourceLength ?? structuralSource?.sourceLength ?? previous.length,
+      resultLength: value.length,
+      mapped: true,
+      mappedItemSources,
+      ...structuralUpdate ? { structuralUpdate } : {}
+    };
+    COMPILER_KEYED_ARRAY_REORDERS.set(valueTarget, hint);
+  } catch {
+  }
+  return value;
+}
+function createCompilerKeyedArrayMapPipeline(previous, methodOrPipeline, callback) {
+  if (callback !== void 0) {
+    const value = NATIVE_REFLECT_APPLY(
+      methodOrPipeline,
+      previous,
+      [callback]
+    );
+    if (methodOrPipeline !== NATIVE_ARRAY_MAP) return value;
+    return recordCompilerKeyedArrayMapPipeline(previous, value);
+  }
+  return executeCompilerKeyedMapPipeline(
+    previous,
+    methodOrPipeline,
+    recordCompilerKeyedArrayMapPipeline
+  );
+}
+function recordCompilerKeyedArrayQueuedMapPipeline(previous, value) {
+  try {
+    const previousTarget = compilerObject(previous);
+    const valueTarget = compilerObject(value);
+    if (!previousTarget || !valueTarget || !Array.isArray(previous) || !Array.isArray(value) || Object.getPrototypeOf(previous) !== NATIVE_ARRAY_PROTOTYPE || Object.getPrototypeOf(value) !== NATIVE_ARRAY_PROTOTYPE || value.length !== previous.length) {
+      return value;
+    }
+    const committedSource = COMPILER_KEYED_COMMITTED_COLLECTIONS.has(previousTarget);
+    const previousReorder = committedSource ? void 0 : COMPILER_KEYED_ARRAY_REORDERS.get(previousTarget);
+    if (!committedSource && (!previousReorder || previousReorder.structuralUpdate || previousReorder.resultLength !== previous.length)) {
+      return value;
+    }
+    const sourceToken = previousReorder?.sourceToken || compilerKeyedCollectionToken(previousTarget);
+    if (!sourceToken) return value;
+    const sourceItems = previousReorder?.mappedItemSources?.queuedSourceItems || previous;
+    let mappedItemSources;
+    const readMappedItemSources = () => {
+      if (mappedItemSources) return mappedItemSources;
+      const sources = /* @__PURE__ */ new Map();
+      for (let index = 0; index < value.length; index += 1) {
+        const sourceDescriptor = Object.getOwnPropertyDescriptor(sourceItems, index);
+        const mappedDescriptor = Object.getOwnPropertyDescriptor(value, index);
+        if (!sourceDescriptor || !("value" in sourceDescriptor) || !mappedDescriptor || !("value" in mappedDescriptor)) {
+          throw new TypeError();
+        }
+        if (!Object.is(sourceDescriptor.value, mappedDescriptor.value)) {
+          sources.set(mappedDescriptor.value, sourceDescriptor.value);
+        }
+      }
+      mappedItemSources = sources;
+      return sources;
+    };
+    COMPILER_KEYED_ARRAY_REORDERS.set(valueTarget, {
+      kind: previousReorder?.kind,
+      sourceToken,
+      sourceLength: previousReorder?.sourceLength ?? previous.length,
+      resultLength: value.length,
+      mapped: true,
+      // Array.map preserves positions. Retain the first queued source collection and validate its
+      // data properties against the final collection once, immediately before the DOM commit.
+      // This avoids rescanning every intermediate Array produced by separately queued setters.
+      mappedItemSources: {
+        queuedSourceItems: sourceItems,
+        get: (item) => readMappedItemSources().get(item),
+        has: (item) => readMappedItemSources().has(item)
+      }
+    });
+  } catch {
+  }
+  return value;
+}
+function createCompilerKeyedArrayQueuedMapPipeline(previous, pipeline) {
+  return executeCompilerKeyedMapPipeline(
+    previous,
+    pipeline,
+    recordCompilerKeyedArrayQueuedMapPipeline
+  );
+}
+function createCompilerKeyedArrayMapReorder(previous, method, ...args) {
+  const value = NATIVE_REFLECT_APPLY(
+    method,
+    previous,
+    args
+  );
+  try {
+    const previousTarget = compilerObject(previous);
+    const valueTarget = compilerObject(value);
+    if (!previousTarget || !valueTarget || !Array.isArray(previous) || !Array.isArray(value) || Object.getPrototypeOf(previous) !== NATIVE_ARRAY_PROTOTYPE || Object.getPrototypeOf(value) !== NATIVE_ARRAY_PROTOTYPE || value.length !== previous.length || method !== NATIVE_ARRAY_TO_REVERSED && method !== NATIVE_ARRAY_TO_SORTED || method === NATIVE_ARRAY_TO_REVERSED && args.length !== 0 || method === NATIVE_ARRAY_TO_SORTED && (args.length > 1 || args.length === 1 && args[0] !== void 0 && typeof args[0] !== "function")) {
+      return value;
+    }
+    for (let index = 0; index < previous.length; index += 1) {
+      if (!Object.prototype.hasOwnProperty.call(previous, index) || !Object.prototype.hasOwnProperty.call(value, index)) {
+        return value;
+      }
+    }
+    const previousReorder = COMPILER_KEYED_ARRAY_REORDERS.get(previousTarget);
+    const source = previousReorder?.mapped ? previousReorder : void 0;
+    if (!source || source.resultLength !== previous.length) return value;
+    COMPILER_KEYED_ARRAY_REORDERS.set(valueTarget, {
+      kind: method !== NATIVE_ARRAY_TO_REVERSED ? 1 /* Permutation */ : reversedCompilerKeyedArrayOrder(source.kind),
+      sourceToken: source.sourceToken,
+      sourceLength: source.sourceLength,
+      resultLength: value.length,
+      mapped: true,
+      mappedItemSources: source.mappedItemSources
+    });
+  } catch {
+  }
+  return value;
+}
 function createCompilerKeyedArrayAppend(previous, value) {
   try {
     const previousTarget = compilerObject(previous);
@@ -227,24 +693,27 @@ function createCompilerKeyedArrayAppend(previous, value) {
     return value;
   }
 }
-function createCompilerKeyedArrayPrepend(previous, value) {
+function createCompilerKeyedArrayStructuralAppend(previous, value) {
   try {
     const previousTarget = compilerObject(previous);
     const valueTarget = compilerObject(value);
     if (!previousTarget || !valueTarget || !Array.isArray(previous) || !Array.isArray(value) || Object.getPrototypeOf(previous) !== NATIVE_ARRAY_PROTOTYPE || Object.getPrototypeOf(value) !== NATIVE_ARRAY_PROTOTYPE || previous[Symbol.iterator] !== NATIVE_ARRAY_ITERATOR) {
       return value;
     }
-    const sourceLength = previous.length;
-    const prefixLength = value.length - sourceLength;
-    if (prefixLength < 1) return value;
-    const sourceToken = compilerKeyedCollectionToken(previousTarget);
+    const startIndex = previous.length;
+    if (value.length < startIndex) return value;
+    const committedSource = COMPILER_KEYED_COMMITTED_COLLECTIONS.has(previousTarget);
+    const previousUpdate = committedSource ? void 0 : COMPILER_KEYED_ARRAY_APPENDS.get(previousTarget);
+    const directStructuralUpdate = !committedSource && !previousUpdate ? COMPILER_KEYED_ARRAY_FILTERS.get(previousTarget) : void 0;
+    const structuralSource = directStructuralUpdate ? compilerKeyedArrayFilterSource(directStructuralUpdate, previous.length) : void 0;
+    const structuralUpdate = previousUpdate?.structuralUpdate || (structuralSource ? directStructuralUpdate : void 0);
+    const sourceToken = previousUpdate?.sourceToken || structuralSource?.sourceToken || compilerKeyedCollectionToken(previousTarget);
     if (!sourceToken) return value;
-    const previousUpdate = !COMPILER_KEYED_COMMITTED_COLLECTIONS.has(previousTarget) ? COMPILER_KEYED_ARRAY_PREPENDS.get(previousTarget) : void 0;
-    COMPILER_KEYED_ARRAY_PREPENDS.set(valueTarget, {
-      sourceToken: previousUpdate?.sourceToken || sourceToken,
-      sourceLength,
+    COMPILER_KEYED_ARRAY_APPENDS.set(valueTarget, {
+      sourceToken,
+      startIndex,
       resultLength: value.length,
-      prefixLength,
+      ...structuralUpdate ? { structuralUpdate } : {},
       ...previousUpdate ? { previous: previousUpdate } : {}
     });
     return value;
@@ -252,48 +721,395 @@ function createCompilerKeyedArrayPrepend(previous, value) {
     return value;
   }
 }
-function createCompilerKeyedArrayFilter(previous, method, predicate) {
-  let canHint = false;
-  let sourceLength = 0;
-  try {
-    canHint = Array.isArray(previous) && Object.getPrototypeOf(previous) === NATIVE_ARRAY_PROTOTYPE && method === NATIVE_ARRAY_FILTER && typeof predicate === "function";
-    if (canHint) sourceLength = previous.length;
-  } catch {
-    canHint = false;
-  }
-  if (!canHint) {
-    return NATIVE_REFLECT_APPLY(method, previous, [predicate]);
-  }
-  const removedIndices = [];
-  let visited = 0;
-  const wrappedPredicate = function(item, index, collection) {
-    visited += 1;
-    const keep = NATIVE_REFLECT_APPLY(predicate, this, [
-      item,
-      index,
-      collection
-    ]);
-    if (!keep) removedIndices.push(index);
-    return keep;
-  };
-  const value = NATIVE_REFLECT_APPLY(method, previous, [
-    wrappedPredicate
-  ]);
+function createCompilerKeyedArrayMappedStructuralAppend(previous, value) {
   try {
     const previousTarget = compilerObject(previous);
     const valueTarget = compilerObject(value);
-    if (!previousTarget || !valueTarget || !Array.isArray(value) || Object.getPrototypeOf(value) !== NATIVE_ARRAY_PROTOTYPE || visited !== sourceLength || value.length !== sourceLength - removedIndices.length) {
+    if (!previousTarget || !valueTarget || !Array.isArray(previous) || !Array.isArray(value) || Object.getPrototypeOf(previous) !== NATIVE_ARRAY_PROTOTYPE || Object.getPrototypeOf(value) !== NATIVE_ARRAY_PROTOTYPE || previous[Symbol.iterator] !== NATIVE_ARRAY_ITERATOR) {
       return value;
     }
-    const sourceToken = compilerKeyedCollectionToken(previousTarget);
-    if (!sourceToken) return value;
-    const previousUpdate = !COMPILER_KEYED_COMMITTED_COLLECTIONS.has(previousTarget) ? COMPILER_KEYED_ARRAY_FILTERS.get(previousTarget) : void 0;
-    COMPILER_KEYED_ARRAY_FILTERS.set(valueTarget, {
-      kind: "filter",
-      sourceToken: previousUpdate?.sourceToken || sourceToken,
-      sourceLength,
-      resultLength: value.length,
-      removedIndices,
+    const startIndex = previous.length;
+    if (value.length < startIndex) return value;
+    const committedSource = COMPILER_KEYED_COMMITTED_COLLECTIONS.has(previousTarget);
+    const previousUpdate = committedSource ? void 0 : COMPILER_KEYED_ARRAY_APPENDS.get(previousTarget);
+    const previousMappedUpdate = !committedSource && !previousUpdate ? COMPILER_KEYED_ARRAY_REORDERS.get(previousTarget) : void 0;
+    const mappedStructuralUpdate = previousMappedUpdate?.mapped && previousMappedUpdate.kind === void 0 && previousMappedUpdate.structuralUpdate && previousMappedUpdate.resultLength === previous.length ? previousMappedUpdate : void 0;
+    const structuralUpdate = previousUpdate?.structuralUpdate || mappedStructuralUpdate?.structuralUpdate;
+    const sourceToken = previousUpdate?.sourceToken || mappedStructuralUpdate?.sourceToken;
+    const mappedItemSources = previousUpdate?.mappedItemSources || mappedStructuralUpdate?.mappedItemSources;
+    if (!sourceToken || !structuralUpdate || !mappedItemSources) return value;
+    COMPILER_KEYED_ARRAY_APPENDS.set(valueTarget, {
+      sourceToken,
+      startIndex,
+      resultLength: value.length,
+      structuralUpdate,
+      mappedItemSources,
+      ...previousUpdate?.mappedSurvivorsValidated ? { mappedSurvivorsValidated: true } : {},
+      ...previousUpdate?.mappedItemValues ? { mappedItemValues: previousUpdate.mappedItemValues } : {},
+      ...previousUpdate ? { previous: previousUpdate } : {}
+    });
+    return value;
+  } catch {
+    return value;
+  }
+}
+function createCompilerKeyedArrayStructuralAppendMapPipeline(previous, pipeline) {
+  let appendUpdate;
+  let committedItems;
+  let survivorRange;
+  let survivorIndices;
+  let mappedItemSources = /* @__PURE__ */ new Map();
+  let mappedItemValues = /* @__PURE__ */ new Map();
+  try {
+    const previousTarget = compilerObject(previous);
+    if (!previousTarget || !Array.isArray(previous) || Object.getPrototypeOf(previous) !== NATIVE_ARRAY_PROTOTYPE || !(appendUpdate = COMPILER_KEYED_ARRAY_APPENDS.get(previousTarget)) || !appendUpdate.structuralUpdate || appendUpdate.resultLength !== previous.length) {
+      appendUpdate = void 0;
+    } else {
+      committedItems = COMPILER_KEYED_COMMITTED_ITEM_SNAPSHOTS.get(appendUpdate.sourceToken);
+      const structuralAppend = committedItems ? compilerKeyedArrayStructuralAppendMapUpdate(
+        previous,
+        appendUpdate.sourceToken,
+        committedItems.length
+      ) : void 0;
+      survivorRange = structuralAppend?.structuralSurvivorRange;
+      survivorIndices = structuralAppend?.structuralSurvivors;
+      if (!survivorRange && !survivorIndices) {
+        appendUpdate = void 0;
+      } else {
+        if (appendUpdate.mappedSurvivorsValidated && appendUpdate.mappedItemSources) {
+          mappedItemSources = new Map(
+            appendUpdate.mappedItemSources
+          );
+        }
+        if (appendUpdate.mappedItemValues) {
+          mappedItemValues = new Map(appendUpdate.mappedItemValues);
+        }
+      }
+    }
+  } catch {
+    appendUpdate = void 0;
+  }
+  let eligible = appendUpdate !== void 0;
+  const applyMap = (collection, method, callback) => {
+    if (method !== NATIVE_ARRAY_MAP || !eligible) {
+      const value3 = NATIVE_REFLECT_APPLY(
+        method,
+        collection,
+        [callback]
+      );
+      if (method !== NATIVE_ARRAY_MAP) eligible = false;
+      return value3;
+    }
+    let expectedIndex = 0;
+    let expectedLength = -1;
+    try {
+      if (!Array.isArray(collection) || Object.getPrototypeOf(collection) !== NATIVE_ARRAY_PROTOTYPE) {
+        eligible = false;
+      } else {
+        expectedLength = collection.length;
+      }
+    } catch {
+      eligible = false;
+    }
+    const wrappedCallback = (item, index, source) => {
+      if (index !== expectedIndex) eligible = false;
+      expectedIndex = index + 1;
+      const survivorCount = survivorRange ? survivorRange.end - survivorRange.start : survivorIndices?.length ?? 0;
+      let committedItem;
+      if (index < survivorCount) {
+        const sourceIndex = survivorRange ? survivorRange.start + index : survivorIndices?.[index];
+        committedItem = sourceIndex === void 0 ? void 0 : committedItems?.[sourceIndex];
+        if (mappedItemValues.has(index)) {
+          if (!Object.is(item, mappedItemValues.get(index))) eligible = false;
+        } else if (appendUpdate?.mappedItemSources && !appendUpdate.mappedSurvivorsValidated) {
+          const mappedStructuralSources = appendUpdate.mappedItemSources;
+          const sourceItem = mappedStructuralSources.has(item) ? mappedStructuralSources.get(item) : item;
+          if (!Object.is(sourceItem, committedItem)) eligible = false;
+        } else if (!Object.is(item, committedItem)) {
+          eligible = false;
+        }
+      }
+      const mappedItem = NATIVE_REFLECT_APPLY(
+        callback,
+        void 0,
+        [item, index, source]
+      );
+      if (index < survivorCount) {
+        if (Object.is(mappedItem, committedItem)) {
+          mappedItemSources.delete(index);
+          mappedItemValues.delete(index);
+        } else {
+          mappedItemSources.set(index, committedItem);
+          mappedItemValues.set(index, mappedItem);
+        }
+      }
+      return mappedItem;
+    };
+    const value2 = NATIVE_REFLECT_APPLY(
+      method,
+      collection,
+      [wrappedCallback]
+    );
+    try {
+      if (expectedIndex !== expectedLength || !Array.isArray(value2) || Object.getPrototypeOf(value2) !== NATIVE_ARRAY_PROTOTYPE || value2.length !== expectedLength) {
+        eligible = false;
+      }
+    } catch {
+      eligible = false;
+    }
+    return value2;
+  };
+  const value = NATIVE_REFLECT_APPLY(pipeline, void 0, [previous, applyMap]);
+  if (!eligible || !appendUpdate) return value;
+  try {
+    const valueTarget = compilerObject(value);
+    if (!valueTarget) return value;
+    COMPILER_KEYED_ARRAY_APPENDS.set(valueTarget, {
+      ...appendUpdate,
+      mappedItemSources,
+      mappedItemValues,
+      mappedSurvivorsValidated: true
+    });
+  } catch {
+  }
+  return value;
+}
+function createCompilerKeyedArrayPrepend(previous, value) {
+  try {
+    const previousTarget = compilerObject(previous);
+    const valueTarget = compilerObject(value);
+    if (!previousTarget || !valueTarget || !Array.isArray(previous) || !Array.isArray(value) || Object.getPrototypeOf(previous) !== NATIVE_ARRAY_PROTOTYPE || Object.getPrototypeOf(value) !== NATIVE_ARRAY_PROTOTYPE || previous[Symbol.iterator] !== NATIVE_ARRAY_ITERATOR) {
+      return value;
+    }
+    const sourceLength = previous.length;
+    const prefixLength = value.length - sourceLength;
+    if (prefixLength < 1) return value;
+    const sourceToken = compilerKeyedCollectionToken(previousTarget);
+    if (!sourceToken) return value;
+    const previousUpdate = !COMPILER_KEYED_COMMITTED_COLLECTIONS.has(previousTarget) ? COMPILER_KEYED_ARRAY_PREPENDS.get(previousTarget) : void 0;
+    COMPILER_KEYED_ARRAY_PREPENDS.set(valueTarget, {
+      sourceToken: previousUpdate?.sourceToken || sourceToken,
+      sourceLength,
+      resultLength: value.length,
+      prefixLength,
+      ...previousUpdate ? { previous: previousUpdate } : {}
+    });
+    return value;
+  } catch {
+    return value;
+  }
+}
+function createCompilerKeyedArrayStructuralPrepend(previous, value) {
+  try {
+    const previousTarget = compilerObject(previous);
+    const valueTarget = compilerObject(value);
+    if (!previousTarget || !valueTarget || !Array.isArray(previous) || !Array.isArray(value) || Object.getPrototypeOf(previous) !== NATIVE_ARRAY_PROTOTYPE || Object.getPrototypeOf(value) !== NATIVE_ARRAY_PROTOTYPE || previous[Symbol.iterator] !== NATIVE_ARRAY_ITERATOR) {
+      return value;
+    }
+    const sourceLength = previous.length;
+    const prefixLength = value.length - sourceLength;
+    if (prefixLength < 1) return value;
+    const committedSource = COMPILER_KEYED_COMMITTED_COLLECTIONS.has(previousTarget);
+    const previousUpdate = committedSource ? void 0 : COMPILER_KEYED_ARRAY_PREPENDS.get(previousTarget);
+    const directStructuralUpdate = !committedSource && !previousUpdate ? COMPILER_KEYED_ARRAY_FILTERS.get(previousTarget) : void 0;
+    const structuralSource = directStructuralUpdate ? compilerKeyedArrayFilterSource(directStructuralUpdate, previous.length) : void 0;
+    const structuralUpdate = previousUpdate?.structuralUpdate || (structuralSource ? directStructuralUpdate : void 0);
+    const sourceToken = previousUpdate?.sourceToken || structuralSource?.sourceToken || compilerKeyedCollectionToken(previousTarget);
+    if (!sourceToken) return value;
+    COMPILER_KEYED_ARRAY_PREPENDS.set(valueTarget, {
+      sourceToken,
+      sourceLength,
+      resultLength: value.length,
+      prefixLength,
+      ...structuralUpdate ? { structuralUpdate } : {},
+      ...previousUpdate ? { previous: previousUpdate } : {}
+    });
+    return value;
+  } catch {
+    return value;
+  }
+}
+function createCompilerKeyedArrayMappedStructuralPrepend(previous, value) {
+  try {
+    const previousTarget = compilerObject(previous);
+    const valueTarget = compilerObject(value);
+    if (!previousTarget || !valueTarget || !Array.isArray(previous) || !Array.isArray(value) || Object.getPrototypeOf(previous) !== NATIVE_ARRAY_PROTOTYPE || Object.getPrototypeOf(value) !== NATIVE_ARRAY_PROTOTYPE || previous[Symbol.iterator] !== NATIVE_ARRAY_ITERATOR) {
+      return value;
+    }
+    const sourceLength = previous.length;
+    const prefixLength = value.length - sourceLength;
+    if (prefixLength < 1) return value;
+    const committedSource = COMPILER_KEYED_COMMITTED_COLLECTIONS.has(previousTarget);
+    const previousUpdate = committedSource ? void 0 : COMPILER_KEYED_ARRAY_PREPENDS.get(previousTarget);
+    const previousMappedUpdate = !committedSource && !previousUpdate ? COMPILER_KEYED_ARRAY_REORDERS.get(previousTarget) : void 0;
+    const mappedStructuralUpdate = previousMappedUpdate?.mapped && previousMappedUpdate.kind === void 0 && previousMappedUpdate.structuralUpdate && previousMappedUpdate.resultLength === previous.length ? previousMappedUpdate : void 0;
+    const structuralUpdate = previousUpdate?.structuralUpdate || mappedStructuralUpdate?.structuralUpdate;
+    const sourceToken = previousUpdate?.sourceToken || mappedStructuralUpdate?.sourceToken;
+    const mappedItemSources = previousUpdate?.mappedItemSources || mappedStructuralUpdate?.mappedItemSources;
+    if (!sourceToken || !structuralUpdate || !mappedItemSources) return value;
+    COMPILER_KEYED_ARRAY_PREPENDS.set(valueTarget, {
+      sourceToken,
+      sourceLength,
+      resultLength: value.length,
+      prefixLength,
+      structuralUpdate,
+      mappedItemSources,
+      ...previousUpdate?.mappedSurvivorsValidated ? { mappedSurvivorsValidated: true } : {},
+      ...previousUpdate?.mappedItemValues ? { mappedItemValues: previousUpdate.mappedItemValues } : {},
+      ...previousUpdate ? { previous: previousUpdate } : {}
+    });
+    return value;
+  } catch {
+    return value;
+  }
+}
+function createCompilerKeyedArrayStructuralPrependMapPipeline(previous, pipeline) {
+  let prependUpdate;
+  let committedItems;
+  let survivorRange;
+  let survivorIndices;
+  let prefixLength = 0;
+  try {
+    const previousTarget = compilerObject(previous);
+    if (!previousTarget || !Array.isArray(previous) || Object.getPrototypeOf(previous) !== NATIVE_ARRAY_PROTOTYPE || !(prependUpdate = COMPILER_KEYED_ARRAY_PREPENDS.get(previousTarget)) || !prependUpdate.structuralUpdate || prependUpdate.resultLength !== previous.length) {
+      prependUpdate = void 0;
+    } else {
+      committedItems = COMPILER_KEYED_COMMITTED_ITEM_SNAPSHOTS.get(prependUpdate.sourceToken);
+      const structuralPrepend = committedItems ? compilerKeyedArrayStructuralPrependMapUpdate(
+        previous,
+        prependUpdate.sourceToken,
+        committedItems.length
+      ) : void 0;
+      survivorRange = structuralPrepend?.structuralSurvivorRange;
+      survivorIndices = structuralPrepend?.structuralSurvivors;
+      prefixLength = structuralPrepend?.prefixLength || 0;
+      if (!survivorRange && !survivorIndices) {
+        prependUpdate = void 0;
+      }
+    }
+  } catch {
+    prependUpdate = void 0;
+  }
+  let eligible = prependUpdate !== void 0;
+  const survivorCount = survivorRange ? survivorRange.end - survivorRange.start : survivorIndices?.length ?? 0;
+  const applyMap = (collection, method, callback) => {
+    if (method !== NATIVE_ARRAY_MAP || !eligible) {
+      const value3 = NATIVE_REFLECT_APPLY(
+        method,
+        collection,
+        [callback]
+      );
+      if (method !== NATIVE_ARRAY_MAP) eligible = false;
+      return value3;
+    }
+    let expectedIndex = 0;
+    let expectedLength = -1;
+    try {
+      if (!Array.isArray(collection) || Object.getPrototypeOf(collection) !== NATIVE_ARRAY_PROTOTYPE) {
+        eligible = false;
+      } else {
+        expectedLength = collection.length;
+      }
+    } catch {
+      eligible = false;
+    }
+    const wrappedCallback = (item, index, source) => {
+      if (index !== expectedIndex) eligible = false;
+      expectedIndex = index + 1;
+      return NATIVE_REFLECT_APPLY(
+        callback,
+        void 0,
+        [item, index, source]
+      );
+    };
+    const value2 = NATIVE_REFLECT_APPLY(
+      method,
+      collection,
+      [wrappedCallback]
+    );
+    try {
+      if (expectedIndex !== expectedLength || !Array.isArray(value2) || Object.getPrototypeOf(value2) !== NATIVE_ARRAY_PROTOTYPE || value2.length !== expectedLength) {
+        eligible = false;
+      }
+    } catch {
+      eligible = false;
+    }
+    return value2;
+  };
+  const value = NATIVE_REFLECT_APPLY(pipeline, void 0, [previous, applyMap]);
+  if (!eligible || !prependUpdate) return value;
+  try {
+    const valueTarget = compilerObject(value);
+    if (!valueTarget || !Array.isArray(value) || Object.getPrototypeOf(value) !== NATIVE_ARRAY_PROTOTYPE || value.length !== prefixLength + survivorCount) {
+      return value;
+    }
+    const mappedItemSources = /* @__PURE__ */ new Map();
+    const mappedItemValues = /* @__PURE__ */ new Map();
+    for (let index = 0; index < survivorCount; index += 1) {
+      const sourceIndex = survivorRange ? survivorRange.start + index : survivorIndices[index];
+      const committedItem = committedItems[sourceIndex];
+      const mappedItem = value[prefixLength + index];
+      if (Object.is(mappedItem, committedItem)) continue;
+      mappedItemSources.set(index, committedItem);
+      mappedItemValues.set(index, mappedItem);
+    }
+    COMPILER_KEYED_ARRAY_PREPENDS.set(valueTarget, {
+      ...prependUpdate,
+      mappedItemSources,
+      mappedItemValues,
+      mappedSurvivorsValidated: true
+    });
+  } catch {
+  }
+  return value;
+}
+function createCompilerKeyedArrayFilter(previous, method, predicate) {
+  let canHint = false;
+  let sourceLength = 0;
+  try {
+    canHint = Array.isArray(previous) && Object.getPrototypeOf(previous) === NATIVE_ARRAY_PROTOTYPE && method === NATIVE_ARRAY_FILTER && typeof predicate === "function";
+    if (canHint) sourceLength = previous.length;
+  } catch {
+    canHint = false;
+  }
+  if (!canHint) {
+    return NATIVE_REFLECT_APPLY(method, previous, [predicate]);
+  }
+  const removedIndices = [];
+  let visited = 0;
+  const wrappedPredicate = function(item, index, collection) {
+    visited += 1;
+    const keep = NATIVE_REFLECT_APPLY(predicate, this, [
+      item,
+      index,
+      collection
+    ]);
+    if (!keep) removedIndices.push(index);
+    return keep;
+  };
+  const value = NATIVE_REFLECT_APPLY(method, previous, [
+    wrappedPredicate
+  ]);
+  try {
+    const previousTarget = compilerObject(previous);
+    const valueTarget = compilerObject(value);
+    if (!previousTarget || !valueTarget || !Array.isArray(value) || Object.getPrototypeOf(value) !== NATIVE_ARRAY_PROTOTYPE || visited !== sourceLength || value.length !== sourceLength - removedIndices.length) {
+      return value;
+    }
+    const committedSource = COMPILER_KEYED_COMMITTED_COLLECTIONS.has(previousTarget);
+    const previousMappedUpdate = committedSource ? void 0 : COMPILER_KEYED_ARRAY_REORDERS.get(previousTarget);
+    const mappedUpdate = previousMappedUpdate?.mapped && previousMappedUpdate.kind === void 0 && previousMappedUpdate.resultLength === sourceLength ? previousMappedUpdate : void 0;
+    const sourceToken = mappedUpdate?.sourceToken || compilerKeyedCollectionToken(previousTarget);
+    if (!sourceToken) return value;
+    const previousUpdate = !committedSource ? COMPILER_KEYED_ARRAY_FILTERS.get(previousTarget) || mappedUpdate?.structuralUpdate : void 0;
+    const mappedItemSources = mappedUpdate?.mappedItemSources || previousUpdate?.mappedItemSources;
+    COMPILER_KEYED_ARRAY_FILTERS.set(valueTarget, {
+      kind: "filter",
+      sourceToken: previousUpdate?.sourceToken || sourceToken,
+      sourceLength,
+      resultLength: value.length,
+      removedIndices,
+      ...mappedItemSources ? { mappedItemSources } : {},
       ...previousUpdate ? { previous: previousUpdate } : {}
     });
   } catch {
@@ -322,9 +1138,13 @@ function createCompilerKeyedArraySlice(previous, method, ...args) {
     const retainedEnd = args.length === 2 ? normalize(args[1]) : sourceLength;
     const resultLength = Math.max(retainedEnd - retainedStart, 0);
     if (value.length !== resultLength || resultLength >= sourceLength) return value;
-    const sourceToken = compilerKeyedCollectionToken(previousTarget);
+    const committedSource = COMPILER_KEYED_COMMITTED_COLLECTIONS.has(previousTarget);
+    const previousMappedUpdate = committedSource ? void 0 : COMPILER_KEYED_ARRAY_REORDERS.get(previousTarget);
+    const mappedUpdate = previousMappedUpdate?.mapped && previousMappedUpdate.kind === void 0 && previousMappedUpdate.resultLength === sourceLength ? previousMappedUpdate : void 0;
+    const sourceToken = mappedUpdate?.sourceToken || compilerKeyedCollectionToken(previousTarget);
     if (!sourceToken) return value;
-    const previousUpdate = !COMPILER_KEYED_COMMITTED_COLLECTIONS.has(previousTarget) ? COMPILER_KEYED_ARRAY_FILTERS.get(previousTarget) : void 0;
+    const previousUpdate = !committedSource ? COMPILER_KEYED_ARRAY_FILTERS.get(previousTarget) || mappedUpdate?.structuralUpdate : void 0;
+    const mappedItemSources = mappedUpdate?.mappedItemSources || previousUpdate?.mappedItemSources;
     COMPILER_KEYED_ARRAY_FILTERS.set(valueTarget, {
       kind: "slice",
       sourceToken: previousUpdate?.sourceToken || sourceToken,
@@ -332,23 +1152,48 @@ function createCompilerKeyedArraySlice(previous, method, ...args) {
       resultLength,
       retainedEnd: Math.max(retainedEnd, retainedStart),
       retainedStart,
+      ...mappedItemSources ? { mappedItemSources } : {},
       ...previousUpdate ? { previous: previousUpdate } : {}
     });
   } catch {
   }
   return value;
 }
+function finalizeCompilerKeyedArrayMappedStructuralUpdate(value) {
+  try {
+    const valueTarget = compilerObject(value);
+    const structuralUpdate = valueTarget ? COMPILER_KEYED_ARRAY_FILTERS.get(valueTarget) : void 0;
+    const mappedItemSources = structuralUpdate?.mappedItemSources;
+    if (!valueTarget || !structuralUpdate || !mappedItemSources) return value;
+    const source = compilerKeyedArrayFilterSource(structuralUpdate, structuralUpdate.resultLength);
+    if (!source) return value;
+    COMPILER_KEYED_ARRAY_REORDERS.set(valueTarget, {
+      sourceToken: source.sourceToken,
+      sourceLength: source.sourceLength,
+      resultLength: structuralUpdate.resultLength,
+      mapped: true,
+      mappedItemSources,
+      structuralUpdate
+    });
+  } catch {
+  }
+  return value;
+}
 function createCompilerKeyedArrayRollingWindow(previous, retained, value) {
   try {
     const previousTarget = compilerObject(previous);
     const retainedTarget = compilerObject(retained);
     const valueTarget = compilerObject(value);
-    if (!previousTarget || !retainedTarget || !valueTarget || !COMPILER_KEYED_COMMITTED_COLLECTIONS.has(previousTarget) || !Array.isArray(previous) || !Array.isArray(retained) || !Array.isArray(value) || Object.getPrototypeOf(previous) !== NATIVE_ARRAY_PROTOTYPE || Object.getPrototypeOf(retained) !== NATIVE_ARRAY_PROTOTYPE || Object.getPrototypeOf(value) !== NATIVE_ARRAY_PROTOTYPE) {
+    if (!previousTarget || !retainedTarget || !valueTarget || !Array.isArray(previous) || !Array.isArray(retained) || !Array.isArray(value) || Object.getPrototypeOf(previous) !== NATIVE_ARRAY_PROTOTYPE || Object.getPrototypeOf(retained) !== NATIVE_ARRAY_PROTOTYPE || Object.getPrototypeOf(value) !== NATIVE_ARRAY_PROTOTYPE) {
       return value;
     }
-    const sourceToken = compilerKeyedCollectionToken(previousTarget);
+    const committedSource = COMPILER_KEYED_COMMITTED_COLLECTIONS.has(previousTarget);
+    const previousUpdate = committedSource ? void 0 : COMPILER_KEYED_ARRAY_ROLLING_WINDOWS.get(previousTarget);
+    if (!committedSource && !previousUpdate) return value;
+    const immediateSourceToken = compilerKeyedCollectionToken(previousTarget);
+    const sourceToken = previousUpdate?.sourceToken || immediateSourceToken;
     const slice = COMPILER_KEYED_ARRAY_FILTERS.get(retainedTarget);
-    if (!sourceToken || !slice || slice.previous || slice.kind !== "slice" || slice.sourceToken !== sourceToken || slice.sourceLength !== previous.length || slice.retainedStart === void 0 || slice.retainedEnd !== previous.length || slice.retainedStart < 1 || slice.resultLength !== retained.length || value.length <= retained.length) {
+    if (!immediateSourceToken || !sourceToken || !slice || slice.previous || slice.kind !== "slice" || slice.sourceToken !== immediateSourceToken || slice.sourceLength !== previous.length || slice.retainedStart === void 0 || slice.retainedEnd !== previous.length || slice.retainedStart < 1 || slice.resultLength !== retained.length || previousUpdate && previousUpdate.resultLength !== previous.length || value.length <= retained.length) {
       return value;
     }
     for (let index = 0; index < retained.length; index += 1) {
@@ -359,7 +1204,8 @@ function createCompilerKeyedArrayRollingWindow(previous, retained, value) {
       sourceLength: previous.length,
       resultLength: value.length,
       retainedEnd: slice.retainedEnd,
-      retainedStart: slice.retainedStart
+      retainedStart: slice.retainedStart,
+      ...previousUpdate ? { previous: previousUpdate } : {}
     });
   } catch {
   }
@@ -380,9 +1226,11 @@ function createCompilerKeyedArrayPositionUpdate(previous, method, kind, position
     }
     const sourceLength = previous.length;
     const normalizedPosition = position < 0 ? Math.max(sourceLength + position, 0) : Math.min(position, sourceLength);
+    const deleteCount = args[0];
+    const removedCount = sourceLength - value.length;
     const validInsert = kind === "insert" && method === NATIVE_ARRAY_TO_SPLICED && args.length === 2 && Object.is(args[0], 0) && value.length === sourceLength + 1;
-    const validRemove = kind === "remove" && method === NATIVE_ARRAY_TO_SPLICED && args.length === 1 && Object.is(args[0], 1) && normalizedPosition < sourceLength && value.length === sourceLength - 1;
-    const validReplace = kind === "replace" && method === NATIVE_ARRAY_WITH && args.length === 1 && position >= -sourceLength && position < sourceLength && value.length === sourceLength;
+    const validRemove = kind === "remove" && method === NATIVE_ARRAY_TO_SPLICED && args.length === 1 && Number.isSafeInteger(deleteCount) && deleteCount > 0 && normalizedPosition < sourceLength && removedCount === Math.min(deleteCount, sourceLength - normalizedPosition);
+    const validReplace = kind === "replace" && value.length === sourceLength && (method === NATIVE_ARRAY_WITH && args.length === 1 && position >= -sourceLength && position < sourceLength || method === NATIVE_ARRAY_TO_SPLICED && args.length === 2 && Object.is(args[0], 1) && normalizedPosition < sourceLength);
     if (!validInsert && !validRemove && !validReplace) return value;
     const sourceToken = compilerKeyedCollectionToken(previousTarget);
     if (!sourceToken) return value;
@@ -397,6 +1245,71 @@ function createCompilerKeyedArrayPositionUpdate(previous, method, kind, position
   }
   return value;
 }
+function createCompilerKeyedArrayBatchInsert(previous, method, position, ...items) {
+  const value = NATIVE_REFLECT_APPLY(
+    method,
+    previous,
+    [position, 0, ...items]
+  );
+  try {
+    const previousTarget = compilerObject(previous);
+    const valueTarget = compilerObject(value);
+    if (!previousTarget || !valueTarget || !COMPILER_KEYED_COMMITTED_COLLECTIONS.has(previousTarget) || !Array.isArray(previous) || !Array.isArray(value) || Object.getPrototypeOf(previous) !== NATIVE_ARRAY_PROTOTYPE || Object.getPrototypeOf(value) !== NATIVE_ARRAY_PROTOTYPE || method !== NATIVE_ARRAY_TO_SPLICED || !Number.isSafeInteger(position) || items.length < 2 || value.length !== previous.length + items.length) {
+      return value;
+    }
+    for (let index = 0; index < previous.length; index += 1) {
+      if (!Object.prototype.hasOwnProperty.call(previous, index)) return value;
+    }
+    const sourceToken = compilerKeyedCollectionToken(previousTarget);
+    if (!sourceToken) return value;
+    COMPILER_KEYED_ARRAY_BATCH_INSERTS.set(valueTarget, {
+      sourceToken,
+      sourceLength: previous.length,
+      resultLength: value.length,
+      position: position < 0 ? Math.max(previous.length + position, 0) : Math.min(position, previous.length)
+    });
+  } catch {
+  }
+  return value;
+}
+function createCompilerKeyedArrayWindowReplace(previous, method, position, deleteCount, ...items) {
+  const value = NATIVE_REFLECT_APPLY(
+    method,
+    previous,
+    [position, deleteCount, ...items]
+  );
+  try {
+    const previousTarget = compilerObject(previous);
+    const valueTarget = compilerObject(value);
+    if (!previousTarget || !valueTarget || !Array.isArray(previous) || !Array.isArray(value) || Object.getPrototypeOf(previous) !== NATIVE_ARRAY_PROTOTYPE || Object.getPrototypeOf(value) !== NATIVE_ARRAY_PROTOTYPE || method !== NATIVE_ARRAY_TO_SPLICED || !Number.isSafeInteger(position) || !Number.isSafeInteger(deleteCount) || deleteCount <= 0) {
+      return value;
+    }
+    for (let index = 0; index < previous.length; index += 1) {
+      if (!Object.prototype.hasOwnProperty.call(previous, index)) return value;
+    }
+    const normalizedPosition = position < 0 ? Math.max(previous.length + position, 0) : Math.min(position, previous.length);
+    const removedCount = Math.min(deleteCount, previous.length - normalizedPosition);
+    if (removedCount < 1 || value.length !== previous.length - removedCount + items.length) {
+      return value;
+    }
+    const committedSource = COMPILER_KEYED_COMMITTED_COLLECTIONS.has(previousTarget);
+    const previousUpdate = committedSource ? void 0 : COMPILER_KEYED_ARRAY_WINDOW_REPLACEMENTS.get(previousTarget);
+    if (!committedSource && !previousUpdate) return value;
+    const sourceToken = previousUpdate?.sourceToken || compilerKeyedCollectionToken(previousTarget);
+    if (!sourceToken) return value;
+    COMPILER_KEYED_ARRAY_WINDOW_REPLACEMENTS.set(valueTarget, {
+      sourceToken,
+      sourceLength: previous.length,
+      resultLength: value.length,
+      position: normalizedPosition,
+      removedCount,
+      insertedCount: items.length,
+      ...previousUpdate ? { previous: previousUpdate } : {}
+    });
+  } catch {
+  }
+  return value;
+}
 function createCompilerKeyedArrayReorder(previous, method) {
   const value = NATIVE_REFLECT_APPLY(
     method,
@@ -406,13 +1319,18 @@ function createCompilerKeyedArrayReorder(previous, method) {
   try {
     const previousTarget = compilerObject(previous);
     const valueTarget = compilerObject(value);
-    if (!previousTarget || !valueTarget || !COMPILER_KEYED_COMMITTED_COLLECTIONS.has(previousTarget) || !Array.isArray(previous) || !Array.isArray(value) || Object.getPrototypeOf(previous) !== NATIVE_ARRAY_PROTOTYPE || Object.getPrototypeOf(value) !== NATIVE_ARRAY_PROTOTYPE || method !== NATIVE_ARRAY_TO_REVERSED || value.length !== previous.length) {
+    if (!previousTarget || !valueTarget || !Array.isArray(previous) || !Array.isArray(value) || Object.getPrototypeOf(previous) !== NATIVE_ARRAY_PROTOTYPE || Object.getPrototypeOf(value) !== NATIVE_ARRAY_PROTOTYPE || method !== NATIVE_ARRAY_TO_REVERSED || value.length !== previous.length) {
       return value;
     }
-    const sourceToken = compilerKeyedCollectionToken(previousTarget);
+    const committedSource = COMPILER_KEYED_COMMITTED_COLLECTIONS.has(previousTarget);
+    const previousUpdate = committedSource ? void 0 : COMPILER_KEYED_ARRAY_REORDERS.get(previousTarget);
+    if (!committedSource && (!previousUpdate || previousUpdate.sourceLength !== previous.length || previousUpdate.resultLength !== previous.length)) {
+      return value;
+    }
+    const sourceToken = previousUpdate?.sourceToken || compilerKeyedCollectionToken(previousTarget);
     if (!sourceToken) return value;
     COMPILER_KEYED_ARRAY_REORDERS.set(valueTarget, {
-      kind: "reverse",
+      kind: reversedCompilerKeyedArrayOrder(previousUpdate?.kind),
       sourceToken,
       sourceLength: previous.length,
       resultLength: value.length
@@ -430,16 +1348,21 @@ function createCompilerKeyedArraySort(previous, method, ...args) {
   try {
     const previousTarget = compilerObject(previous);
     const valueTarget = compilerObject(value);
-    if (!previousTarget || !valueTarget || !COMPILER_KEYED_COMMITTED_COLLECTIONS.has(previousTarget) || !Array.isArray(previous) || !Array.isArray(value) || Object.getPrototypeOf(previous) !== NATIVE_ARRAY_PROTOTYPE || Object.getPrototypeOf(value) !== NATIVE_ARRAY_PROTOTYPE || method !== NATIVE_ARRAY_TO_SORTED || args.length > 1 || args.length === 1 && args[0] !== void 0 && typeof args[0] !== "function" || value.length !== previous.length) {
+    if (!previousTarget || !valueTarget || !Array.isArray(previous) || !Array.isArray(value) || Object.getPrototypeOf(previous) !== NATIVE_ARRAY_PROTOTYPE || Object.getPrototypeOf(value) !== NATIVE_ARRAY_PROTOTYPE || method !== NATIVE_ARRAY_TO_SORTED || args.length > 1 || args.length === 1 && args[0] !== void 0 && typeof args[0] !== "function" || value.length !== previous.length) {
       return value;
     }
     for (let index = 0; index < previous.length; index += 1) {
       if (!(index in previous)) return value;
     }
-    const sourceToken = compilerKeyedCollectionToken(previousTarget);
+    const committedSource = COMPILER_KEYED_COMMITTED_COLLECTIONS.has(previousTarget);
+    const previousUpdate = committedSource ? void 0 : COMPILER_KEYED_ARRAY_REORDERS.get(previousTarget);
+    if (!committedSource && (!previousUpdate || previousUpdate.sourceLength !== previous.length || previousUpdate.resultLength !== previous.length)) {
+      return value;
+    }
+    const sourceToken = previousUpdate?.sourceToken || compilerKeyedCollectionToken(previousTarget);
     if (!sourceToken) return value;
     COMPILER_KEYED_ARRAY_REORDERS.set(valueTarget, {
-      kind: "sort",
+      kind: 1 /* Permutation */,
       sourceToken,
       sourceLength: previous.length,
       resultLength: value.length
@@ -448,11 +1371,80 @@ function createCompilerKeyedArraySort(previous, method, ...args) {
   }
   return value;
 }
-function applyCompilerKeyedCollectionMutation(collection, method, operation, key, value) {
-  const args = operation === "map-set" ? [key, value] : [key];
-  const result = NATIVE_REFLECT_APPLY(method, collection, args);
-  const target = compilerObject(collection);
-  if (!target) return result;
+function recordCompilerKeyedArrayStructuralReorder(previous, value, kind) {
+  try {
+    const previousTarget = compilerObject(previous);
+    const valueTarget = compilerObject(value);
+    if (!previousTarget || !valueTarget || !Array.isArray(previous) || !Array.isArray(value)) {
+      return value;
+    }
+    const previousUpdate = COMPILER_KEYED_ARRAY_REORDERS.get(previousTarget);
+    const structuralUpdate = previousUpdate?.structuralUpdate || (!previousUpdate ? COMPILER_KEYED_ARRAY_FILTERS.get(previousTarget) : void 0);
+    const structuralSource = structuralUpdate ? compilerKeyedArrayFilterSource(structuralUpdate, previous.length) : void 0;
+    if (!structuralUpdate || !structuralSource || previousUpdate && previousUpdate.resultLength !== previous.length) {
+      return value;
+    }
+    const sourceToken = previousUpdate?.sourceToken || structuralSource?.sourceToken;
+    if (!sourceToken) return value;
+    const mappedItemSources = previousUpdate?.mappedItemSources || structuralUpdate.mappedItemSources;
+    COMPILER_KEYED_ARRAY_REORDERS.set(valueTarget, {
+      kind: kind === 0 /* Reverse */ ? reversedCompilerKeyedArrayOrder(previousUpdate?.kind) : 1 /* Permutation */,
+      sourceToken,
+      sourceLength: previousUpdate?.sourceLength || structuralSource.sourceLength,
+      resultLength: value.length,
+      structuralUpdate,
+      ...mappedItemSources ? { mappedItemSources } : {}
+    });
+  } catch {
+  }
+  return value;
+}
+function createCompilerKeyedArrayStructuralReorder(previous, method) {
+  const value = NATIVE_REFLECT_APPLY(
+    method,
+    previous,
+    []
+  );
+  try {
+    if (!Array.isArray(previous) || !Array.isArray(value) || Object.getPrototypeOf(previous) !== NATIVE_ARRAY_PROTOTYPE || Object.getPrototypeOf(value) !== NATIVE_ARRAY_PROTOTYPE || method !== NATIVE_ARRAY_TO_REVERSED || value.length !== previous.length) {
+      return value;
+    }
+  } catch {
+    return value;
+  }
+  return recordCompilerKeyedArrayStructuralReorder(
+    previous,
+    value,
+    0 /* Reverse */
+  );
+}
+function createCompilerKeyedArrayStructuralSort(previous, method, ...args) {
+  const value = NATIVE_REFLECT_APPLY(
+    method,
+    previous,
+    args
+  );
+  try {
+    if (!Array.isArray(previous) || !Array.isArray(value) || Object.getPrototypeOf(previous) !== NATIVE_ARRAY_PROTOTYPE || Object.getPrototypeOf(value) !== NATIVE_ARRAY_PROTOTYPE || method !== NATIVE_ARRAY_TO_SORTED || args.length > 1 || args.length === 1 && args[0] !== void 0 && typeof args[0] !== "function" || value.length !== previous.length) {
+      return value;
+    }
+    for (let index = 0; index < previous.length; index += 1) {
+      if (!(index in previous)) return value;
+    }
+  } catch {
+    return value;
+  }
+  return recordCompilerKeyedArrayStructuralReorder(
+    previous,
+    value,
+    1 /* Permutation */
+  );
+}
+function applyCompilerKeyedCollectionMutation(collection, method, operation, key, value) {
+  const args = operation === "map-set" ? [key, value] : [key];
+  const result = NATIVE_REFLECT_APPLY(method, collection, args);
+  const target = compilerObject(collection);
+  if (!target) return result;
   const kind = operation.startsWith("set-") ? "set" : "map";
   const nativeMethod = operation === "set-add" ? NATIVE_SET_ADD : operation === "set-delete" ? NATIVE_SET_DELETE : operation === "map-set" ? NATIVE_MAP_SET : NATIVE_MAP_DELETE;
   const nativePrototype = kind === "set" ? NATIVE_SET_PROTOTYPE : NATIVE_MAP_PROTOTYPE;
@@ -865,6 +1857,9 @@ function applyStaticRangeBindings(bindings, segments, values) {
   }
   return true;
 }
+function keyedRowInstancesByKey(instances) {
+  return new Map(instances.map((instance) => [instance.key, instance]));
+}
 var UNSET_KEYED_ROW_BINDING = /* @__PURE__ */ Symbol("unset interactive keyed-row binding");
 function keyedRowIdentity(key) {
   return String(key);
@@ -1132,6 +2127,32 @@ function applyKeyedRowBinding(props, instance, item, index, bindingIndex) {
     updateAttribute(target, binding.name, rawValue);
   }
 }
+function prepareKeyedRowBindingUpdates(props, instance, item, index) {
+  const updates = [];
+  for (let bindingIndex = 0; bindingIndex < props.bindings.length; bindingIndex += 1) {
+    const binding = props.bindings[bindingIndex];
+    const rawValue = binding.read(item, index);
+    const value = normalizedKeyedRowBindingValue(binding, rawValue);
+    if (Object.is(instance.values[bindingIndex], value)) continue;
+    const target = findCompilerHostTarget(instance.element, binding.path);
+    if (!target || binding.kind !== "text" && !binding.name) return void 0;
+    updates.push([bindingIndex, rawValue, target, value]);
+  }
+  return updates;
+}
+function applyPreparedKeyedRowBindingUpdates(props, instance, updates) {
+  for (const [bindingIndex, rawValue, target, value] of updates) {
+    const binding = props.bindings[bindingIndex];
+    instance.values[bindingIndex] = value;
+    if (binding.kind === "text") {
+      target.textContent = value;
+    } else if (binding.kind === "style") {
+      updateStyle(target, binding.name, rawValue);
+    } else {
+      updateAttribute(target, binding.name, rawValue);
+    }
+  }
+}
 function keyedRowConditionalSnapshot(conditional, item, index) {
   const test = conditional.test(item, index);
   if (conditional.logical && !test) {
@@ -1691,7 +2712,7 @@ var CompilerNestedKeyedRanges = class {
       }
       anchor = instance.element;
     }
-    this.instances[rangeIndex] = new Map(nextInstances.map((instance) => [instance.key, instance]));
+    this.instances[rangeIndex] = keyedRowInstancesByKey(nextInstances);
     return true;
   }
   updateStaticScopes(descriptor, rowsByRange) {
@@ -2019,7 +3040,7 @@ var CompilerNestedMixedRanges = class {
       }
       anchor = row.element;
     }
-    instance.value = new Map(nextInstances.map((row) => [row.key, row]));
+    instance.value = keyedRowInstancesByKey(nextInstances);
     return true;
   }
   reconcileRange(rangeIndex, snapshot) {
@@ -2574,6 +3595,53 @@ function longestIncreasingSubsequencePositions(sequence) {
   }
   return positions;
 }
+function reorderCompilerKeyedRows(root, instances, sequence, anchor) {
+  const activeElement = compilerFocusedElement(root);
+  const stablePositions = longestIncreasingSubsequencePositions(sequence);
+  for (let index = instances.length - 1; index >= 0; index -= 1) {
+    const instance = instances[index];
+    if (sequence[index] < 0) {
+      let start = index;
+      while (start > 0 && sequence[start - 1] < 0) start -= 1;
+      const fragment = root.ownerDocument.createDocumentFragment();
+      for (let itemIndex = start; itemIndex <= index; itemIndex += 1) {
+        fragment.append(instances[itemIndex].element);
+      }
+      root.insertBefore(fragment, anchor);
+      anchor = instances[start].element;
+      index = start;
+    } else {
+      if (!stablePositions.has(index) && instance.element.nextSibling !== anchor) {
+        root.insertBefore(instance.element, anchor);
+      }
+      anchor = instance.element;
+    }
+  }
+  restoreCompilerFocus(activeElement);
+}
+function compilerFocusedElement(root) {
+  const activeElement = root.ownerDocument.activeElement;
+  return activeElement && root.contains(activeElement) ? activeElement : null;
+}
+function restoreCompilerFocus(activeElement) {
+  if (activeElement?.isConnected && activeElement.ownerDocument.activeElement !== activeElement && "focus" in activeElement) {
+    activeElement.focus({ preventScroll: true });
+  }
+}
+function reverseCompilerKeyedRows(root, instances) {
+  const activeElement = compilerFocusedElement(root);
+  let anchor = instances[0]?.element || null;
+  for (let sourceIndex = 1; sourceIndex < instances.length; sourceIndex += 1) {
+    const element = instances[sourceIndex].element;
+    root.insertBefore(element, anchor);
+    anchor = element;
+  }
+  instances.reverse();
+  for (let index = 0; index < instances.length; index += 1) {
+    instances[index].index = index;
+  }
+  restoreCompilerFocus(activeElement);
+}
 var keyedUpdateRuntime = {
   append: reconcileCompilerKeyedArrayAppend,
   commit: commitCompilerKeyedCollection,
@@ -2591,14 +3659,30 @@ var keyedFilterPrependUpdateRuntime = {
   ...keyedFilterUpdateRuntime,
   prepend: reconcileCompilerKeyedArrayPrepend
 };
+var keyedStructuralPrependUpdateRuntime = {
+  ...keyedFilterPrependUpdateRuntime,
+  prepend: reconcileCompilerKeyedArrayPrependWithStructural
+};
 var keyedPositionUpdateRuntime = {
   ...keyedUpdateRuntime,
   position: reconcileCompilerKeyedArrayPosition
 };
+var keyedBatchPositionUpdateRuntime = {
+  ...keyedUpdateRuntime,
+  position: reconcileCompilerKeyedArrayPositionWithBatch
+};
+var keyedWindowPositionUpdateRuntime = {
+  ...keyedUpdateRuntime,
+  position: reconcileCompilerKeyedArrayPositionWithWindow
+};
 var keyedReorderUpdateRuntime = {
   ...keyedUpdateRuntime,
   reorder: reconcileCompilerKeyedArrayReorder
 };
+var keyedMapReorderUpdateRuntime = {
+  ...keyedUpdateRuntime,
+  reorder: reconcileCompilerKeyedArrayReorderWithMap
+};
 var keyedCompleteUpdateRuntime = {
   ...keyedFilterPrependUpdateRuntime,
   rollingWindow: reconcileCompilerKeyedArrayRollingWindow
@@ -2606,7 +3690,32 @@ var keyedCompleteUpdateRuntime = {
 var keyedEveryUpdateRuntime = {
   ...keyedCompleteUpdateRuntime,
   position: reconcileCompilerKeyedArrayPosition,
-  reorder: reconcileCompilerKeyedArrayReorder
+  reorder: reconcileCompilerKeyedArrayReorderWithMapAndStructural
+};
+var keyedBatchEveryUpdateRuntime = {
+  ...keyedEveryUpdateRuntime,
+  position: reconcileCompilerKeyedArrayPositionWithBatch
+};
+var keyedWindowEveryUpdateRuntime = {
+  ...keyedEveryUpdateRuntime,
+  position: reconcileCompilerKeyedArrayPositionWithWindow
+};
+var keyedWindowEveryStructuralAppendUpdateRuntime = {
+  ...keyedWindowEveryUpdateRuntime,
+  append: reconcileCompilerKeyedArrayAppendWithStructural
+};
+var keyedWindowEveryStructuralAppendMapUpdateRuntime = {
+  ...keyedWindowEveryStructuralAppendUpdateRuntime,
+  append: reconcileCompilerKeyedArrayAppendMapWithStructural,
+  commit: commitCompilerKeyedCollectionWithItemSnapshot
+};
+var keyedCompleteCompatibilityUpdateRuntime = {
+  ...keyedWindowEveryStructuralAppendMapUpdateRuntime,
+  prepend: reconcileCompilerKeyedArrayPrependWithStructural
+};
+var keyedCompleteStructuralPrependMapUpdateRuntime = {
+  ...keyedCompleteCompatibilityUpdateRuntime,
+  prepend: reconcileCompilerKeyedArrayPrependMapWithStructural
 };
 function reconcileCompilerKeyedMapUpdate(props, dirtyState, collectionToken, instances, conditionals) {
   const dependency = props.collectionDependency;
@@ -2657,6 +3766,86 @@ function reconcileCompilerKeyedMapUpdate(props, dirtyState, collectionToken, ins
     fallback: false
   };
 }
+function reconcileCompilerKeyedArrayMapReorder(props, dirtyState, collectionToken, instances, root, reactOwnedRows, preparedReorder) {
+  if (reactOwnedRows || props.hostBlocks || (props.conditionals?.length || 0) > 0 || !props.reorderIndexIndependent || props.collectionDependency === void 0) {
+    return void 0;
+  }
+  const collectionDependency = props.collectionDependency;
+  if (props.bindings.some((binding) => binding.dependencies?.includes(collectionDependency))) {
+    return void 0;
+  }
+  const dependencies = props.dependencies || props.structureDependencies;
+  const relevantDirty = (dependencies || []).filter((index) => dirtyState.has(index));
+  if (relevantDirty.length !== 1 || relevantDirty[0] !== collectionDependency) {
+    return void 0;
+  }
+  const finalValue = preparedReorder?.value ?? props.items();
+  const update = preparedReorder?.update || compilerKeyedArrayReorder(finalValue, collectionToken, instances.size);
+  if (!update?.mapped || !update.mappedItemSources || update.structuralUpdate || !Array.isArray(finalValue)) {
+    return void 0;
+  }
+  const previousInstances = [...instances.values()];
+  const reverse = update.kind === 0 /* Reverse */;
+  const prepared = (() => {
+    const changed = [];
+    try {
+      const instancesByItem = update.kind === 1 /* Permutation */ ? /* @__PURE__ */ new Map() : void 0;
+      if (instancesByItem) {
+        for (let sourceIndex = 0; sourceIndex < previousInstances.length; sourceIndex += 1) {
+          const instance = previousInstances[sourceIndex];
+          if (instance.index !== sourceIndex || instancesByItem.has(instance.item))
+            return void 0;
+          instancesByItem.set(instance.item, instance);
+        }
+      }
+      const nextInstances = instancesByItem ? [] : previousInstances;
+      const sequence = instancesByItem ? [] : void 0;
+      for (let targetIndex = 0; targetIndex < finalValue.length; targetIndex += 1) {
+        const item = finalValue[targetIndex];
+        let instance;
+        if (!instancesByItem) {
+          const sourceIndex = reverse ? finalValue.length - targetIndex - 1 : targetIndex;
+          instance = previousInstances[sourceIndex];
+          if (!instance || instance.index !== sourceIndex) return void 0;
+          if (Object.is(instance.item, item)) continue;
+          if (!update.mappedItemSources.has(item) || !Object.is(instance.item, update.mappedItemSources.get(item))) {
+            return void 0;
+          }
+        } else {
+          const sourceItem = update.mappedItemSources.has(item) ? update.mappedItemSources.get(item) : item;
+          instance = instancesByItem.get(sourceItem);
+          if (!instance) return void 0;
+          instancesByItem.delete(sourceItem);
+          nextInstances.push(instance);
+          sequence.push(instance.index);
+          if (Object.is(instance.item, item)) continue;
+        }
+        if (keyedRowIdentity(props.rowKey(item, targetIndex)) !== instance.key) return void 0;
+        const bindingUpdates = prepareKeyedRowBindingUpdates(props, instance, item, targetIndex);
+        if (!bindingUpdates) return void 0;
+        changed.push({ bindingUpdates, instance, item });
+      }
+      if (instancesByItem?.size) return void 0;
+      return { changed, nextInstances, sequence };
+    } catch {
+      return void 0;
+    }
+  })();
+  if (!prepared) return void 0;
+  if (prepared.sequence) {
+    reorderCompilerKeyedRows(root, prepared.nextInstances, prepared.sequence, null);
+  } else if (reverse) {
+    reverseCompilerKeyedRows(root, prepared.nextInstances);
+  }
+  for (const { bindingUpdates, instance, item } of prepared.changed) {
+    applyPreparedKeyedRowBindingUpdates(props, instance, bindingUpdates);
+    instance.item = item;
+  }
+  for (let index = 0; index < prepared.nextInstances.length; index += 1) {
+    prepared.nextInstances[index].index = index;
+  }
+  return reverse || prepared.sequence ? keyedRowInstancesByKey(prepared.nextInstances) : instances;
+}
 function reconcileCompilerKeyedArrayAppend(props, dirtyState, collectionToken, instances, root, reactOwnedRows) {
   if (reactOwnedRows || props.hostBlocks || (props.conditionals?.length || 0) > 0 || props.collectionDependency === void 0) {
     return void 0;
@@ -2702,7 +3891,7 @@ function reconcileCompilerKeyedArrayAppend(props, dirtyState, collectionToken, i
   }
   return nextInstances;
 }
-function reconcileCompilerKeyedArrayRollingWindow(props, dirtyState, collectionToken, instances, root, reactOwnedRows) {
+function reconcileCompilerKeyedArrayStructuralAppend(props, dirtyState, collectionToken, instances, root, reactOwnedRows) {
   if (reactOwnedRows || props.hostBlocks || (props.conditionals?.length || 0) > 0 || !props.filterIndexIndependent || props.collectionDependency === void 0) {
     return void 0;
   }
@@ -2716,33 +3905,37 @@ function reconcileCompilerKeyedArrayRollingWindow(props, dirtyState, collectionT
     return void 0;
   }
   const finalValue = props.items();
-  const update = compilerKeyedArrayRollingWindow(finalValue, collectionToken, instances.size);
-  if (!update || !Array.isArray(finalValue)) return void 0;
+  const update = compilerKeyedArrayStructuralAppendUpdate(
+    finalValue,
+    collectionToken,
+    instances.size
+  );
+  const structuralUpdate = update?.structuralUpdate;
+  const survivorResult = update?.structuralSurvivors;
+  if (!update || !structuralUpdate || !survivorResult || structuralUpdate.mappedItemSources || !Array.isArray(finalValue)) {
+    return void 0;
+  }
   const previousInstances = [...instances.values()];
-  const retainedLength = update.retainedEnd - update.retainedStart;
   const survivors = [];
+  const knownKeys = new Set(instances.keys());
+  const appended = [];
   try {
-    for (let index = 0; index < retainedLength; index += 1) {
-      const sourceIndex = update.retainedStart + index;
+    for (let index = 0; index < survivorResult.indices.length; index += 1) {
+      const sourceIndex = survivorResult.indices[index];
       const instance = previousInstances[sourceIndex];
-      if (!instance || instance.index !== sourceIndex || !Object.is(instance.item, finalValue[index])) {
+      const item = finalValue[index];
+      if (!instance || instance.index !== sourceIndex || !Object.is(instance.item, item) || !survivorResult.keysStable && keyedRowIdentity(props.rowKey(item, index)) !== instance.key) {
         return void 0;
       }
       survivors.push(instance);
     }
-  } catch {
-    return void 0;
-  }
-  const knownKeys = new Set(instances.keys());
-  const incoming = [];
-  try {
-    for (let index = retainedLength; index < finalValue.length; index += 1) {
+    for (let index = update.startIndex; index < finalValue.length; index += 1) {
       const item = finalValue[index];
       const key = keyedRowIdentity(props.rowKey(item, index));
       if (knownKeys.has(key)) return void 0;
       knownKeys.add(key);
       const descriptor = props.create(item, index);
-      incoming.push({
+      appended.push({
         key,
         element: createCompilerHostElement(root.ownerDocument, descriptor),
         values: readKeyedRowBindingValues(props, item, index),
@@ -2754,23 +3947,22 @@ function reconcileCompilerKeyedArrayRollingWindow(props, dirtyState, collectionT
   } catch {
     return void 0;
   }
-  for (let index = 0; index < update.retainedStart; index += 1) {
+  const survivorSet = new Set(survivorResult.indices);
+  for (let index = 0; index < previousInstances.length; index += 1) {
+    if (survivorSet.has(index)) continue;
     previousInstances[index].scope?.cleanup();
     previousInstances[index].element.remove();
   }
   for (let index = 0; index < survivors.length; index += 1) survivors[index].index = index;
-  if (incoming.length > 0) {
+  if (appended.length > 0) {
     const fragment = root.ownerDocument.createDocumentFragment();
-    for (const instance of incoming) fragment.append(instance.element);
+    for (const instance of appended) fragment.append(instance.element);
     root.append(fragment);
   }
-  const nextInstances = new Map(
-    [...survivors, ...incoming].map((instance) => [instance.key, instance])
-  );
-  return nextInstances;
+  return keyedRowInstancesByKey([...survivors, ...appended]);
 }
-function reconcileCompilerKeyedArrayPosition(props, dirtyState, collectionToken, instances, root, reactOwnedRows) {
-  if (reactOwnedRows || props.hostBlocks || (props.conditionals?.length || 0) > 0 || !props.positionIndexIndependent || props.collectionDependency === void 0) {
+function reconcileCompilerKeyedArrayStructuralAppendMap(props, dirtyState, collectionToken, instances, root, reactOwnedRows) {
+  if (reactOwnedRows || props.hostBlocks || (props.conditionals?.length || 0) > 0 || !props.filterIndexIndependent || props.collectionDependency === void 0) {
     return void 0;
   }
   const collectionDependency = props.collectionDependency;
@@ -2783,70 +3975,292 @@ function reconcileCompilerKeyedArrayPosition(props, dirtyState, collectionToken,
     return void 0;
   }
   const finalValue = props.items();
-  const update = compilerKeyedArrayPosition(finalValue, collectionToken, instances.size);
-  if (!update || !Array.isArray(finalValue)) return void 0;
+  const update = compilerKeyedArrayStructuralAppendMapUpdate(
+    finalValue,
+    collectionToken,
+    instances.size,
+    true
+  );
+  if (!update || !update.mappedItemSources || !Array.isArray(finalValue)) return void 0;
+  const mappedItemSources = update.mappedSurvivorsValidated ? update.mappedItemSources : void 0;
+  const mappedStructuralSources = update.mappedSurvivorsValidated ? void 0 : update.mappedItemSources;
   const previousInstances = [...instances.values()];
-  const previous = previousInstances[update.position];
-  if (update.kind === "remove") {
-    if (!previous || previous.index !== update.position) return void 0;
-    previous.scope?.cleanup();
-    previous.element.remove();
-    previousInstances.splice(update.position, 1);
-    for (let index = update.position; index < previousInstances.length; index += 1) {
-      previousInstances[index].index = index;
-    }
-    return new Map(previousInstances.map((instance) => [instance.key, instance]));
-  }
-  let item;
-  let key;
+  const survivorRange = update.structuralSurvivorRange;
+  const survivorIndices = update.structuralSurvivors;
+  const survivorCount = survivorRange ? survivorRange.end - survivorRange.start : survivorIndices?.length ?? 0;
+  if (!survivorRange && !survivorIndices) return void 0;
+  const changed = [];
+  const appendedKeys = /* @__PURE__ */ new Set();
+  const appended = [];
   try {
-    item = finalValue[update.position];
-    key = keyedRowIdentity(props.rowKey(item, update.position));
-  } catch {
-    return void 0;
-  }
-  if (update.kind === "insert") {
-    if (instances.has(key)) return void 0;
-    let inserted;
-    try {
-      const descriptor = props.create(item, update.position);
-      inserted = {
+    if (mappedStructuralSources) {
+      for (let index = 0; index < survivorCount; index += 1) {
+        const sourceIndex = survivorRange ? survivorRange.start + index : survivorIndices[index];
+        const instance = previousInstances[sourceIndex];
+        const item = finalValue[index];
+        const sourceItem = mappedStructuralSources.has(item) ? mappedStructuralSources.get(item) : item;
+        if (!instance || instance.index !== sourceIndex || !Object.is(instance.item, sourceItem)) {
+          return void 0;
+        }
+      }
+      for (let index = 0; index < survivorCount; index += 1) {
+        const sourceIndex = survivorRange ? survivorRange.start + index : survivorIndices[index];
+        const instance = previousInstances[sourceIndex];
+        const item = finalValue[index];
+        const sourceItem = mappedStructuralSources.has(item) ? mappedStructuralSources.get(item) : item;
+        if (Object.is(item, sourceItem)) continue;
+        if (keyedRowIdentity(props.rowKey(item, index)) !== instance.key) return void 0;
+        const bindingUpdates = prepareKeyedRowBindingUpdates(props, instance, item, index);
+        if (!bindingUpdates) return void 0;
+        changed.push({ bindingUpdates, instance, item });
+      }
+    } else if (survivorIndices) {
+      for (let index = 0; index < survivorCount; index += 1) {
+        const sourceIndex = survivorIndices[index];
+        const instance = previousInstances[sourceIndex];
+        const item = finalValue[index];
+        const expectedItem = mappedItemSources.has(index) ? mappedItemSources.get(index) : item;
+        if (!instance || instance.index !== sourceIndex || !Object.is(instance.item, expectedItem)) {
+          return void 0;
+        }
+      }
+    }
+    for (const [index, sourceItem] of mappedItemSources || []) {
+      if (!Number.isSafeInteger(index) || index < 0 || index >= survivorCount) {
+        return void 0;
+      }
+      const instance = previousInstances[survivorRange ? survivorRange.start + index : survivorIndices[index]];
+      const item = finalValue[index];
+      if (!instance || !Object.is(instance.item, sourceItem) || keyedRowIdentity(props.rowKey(item, index)) !== instance.key) {
+        return void 0;
+      }
+      const bindingUpdates = prepareKeyedRowBindingUpdates(props, instance, item, index);
+      if (!bindingUpdates) return void 0;
+      changed.push({ bindingUpdates, instance, item });
+    }
+    for (let index = update.startIndex; index < finalValue.length; index += 1) {
+      const item = finalValue[index];
+      const key = keyedRowIdentity(props.rowKey(item, index));
+      if (instances.has(key) || appendedKeys.has(key)) return void 0;
+      appendedKeys.add(key);
+      const descriptor = props.create(item, index);
+      appended.push({
         key,
         element: createCompilerHostElement(root.ownerDocument, descriptor),
-        values: readKeyedRowBindingValues(props, item, update.position),
+        values: readKeyedRowBindingValues(props, item, index),
         item,
-        index: update.position,
+        index,
         conditionalValues: EMPTY_KEYED_ROW_CONDITIONAL_VALUES
-      };
-    } catch {
-      return void 0;
+      });
     }
-    root.insertBefore(inserted.element, previous?.element || null);
-    previousInstances.splice(update.position, 0, inserted);
-    for (let index = update.position + 1; index < previousInstances.length; index += 1) {
-      previousInstances[index].index = index;
+  } catch {
+    return void 0;
+  }
+  const mutableInstances = instances;
+  if (survivorRange) {
+    for (let index = 0; index < survivorRange.start; index += 1) {
+      const instance = previousInstances[index];
+      instance.scope?.cleanup();
+      instance.element.remove();
+      mutableInstances.delete(instance.key);
+    }
+    for (let index = survivorRange.end; index < previousInstances.length; index += 1) {
+      const instance = previousInstances[index];
+      instance.scope?.cleanup();
+      instance.element.remove();
+      mutableInstances.delete(instance.key);
+    }
+    for (let index = survivorRange.start; index < survivorRange.end; index += 1) {
+      previousInstances[index].index = index - survivorRange.start;
+    }
+  } else {
+    const survivorSet = new Set(survivorIndices);
+    for (let index = 0; index < previousInstances.length; index += 1) {
+      if (survivorSet.has(index)) continue;
+      const instance = previousInstances[index];
+      instance.scope?.cleanup();
+      instance.element.remove();
+      mutableInstances.delete(instance.key);
+    }
+    for (let index = 0; index < survivorIndices.length; index += 1) {
+      previousInstances[survivorIndices[index]].index = index;
     }
-    return new Map(previousInstances.map((instance) => [instance.key, instance]));
   }
-  if (!previous || previous.index !== update.position) return void 0;
-  if (key === previous.key) {
-    try {
-      applyKeyedRowBindings(props, previous, item, update.position);
-    } catch {
-      return void 0;
+  if (appended.length > 0) {
+    const fragment = root.ownerDocument.createDocumentFragment();
+    for (const instance of appended) {
+      fragment.append(instance.element);
+      mutableInstances.set(instance.key, instance);
     }
-    previous.item = item;
-    return instances;
+    root.append(fragment);
   }
-  if (instances.has(key)) return void 0;
-  let replacement;
-  try {
-    const descriptor = props.create(item, update.position);
-    replacement = {
-      key,
-      element: createCompilerHostElement(root.ownerDocument, descriptor),
-      values: readKeyedRowBindingValues(props, item, update.position),
-      item,
+  for (const { bindingUpdates, instance, item } of changed) {
+    applyPreparedKeyedRowBindingUpdates(props, instance, bindingUpdates);
+    instance.item = item;
+  }
+  return mutableInstances;
+}
+function reconcileCompilerKeyedArrayAppendWithStructural(...args) {
+  return reconcileCompilerKeyedArrayStructuralAppend(...args) || reconcileCompilerKeyedArrayAppend(...args);
+}
+function reconcileCompilerKeyedArrayAppendMapWithStructural(...args) {
+  return reconcileCompilerKeyedArrayStructuralAppendMap(...args) || reconcileCompilerKeyedArrayStructuralAppend(...args) || reconcileCompilerKeyedArrayAppend(...args);
+}
+function reconcileCompilerKeyedArrayRollingWindow(props, dirtyState, collectionToken, instances, root, reactOwnedRows) {
+  if (reactOwnedRows || props.hostBlocks || (props.conditionals?.length || 0) > 0 || !props.filterIndexIndependent || props.collectionDependency === void 0) {
+    return void 0;
+  }
+  const collectionDependency = props.collectionDependency;
+  if (props.bindings.some((binding) => binding.dependencies?.includes(collectionDependency))) {
+    return void 0;
+  }
+  const dependencies = props.dependencies || props.structureDependencies;
+  const relevantDirty = (dependencies || []).filter((index) => dirtyState.has(index));
+  if (relevantDirty.length !== 1 || relevantDirty[0] !== collectionDependency) {
+    return void 0;
+  }
+  const finalValue = props.items();
+  const updates = compilerKeyedArrayRollingWindows(finalValue, collectionToken, instances.size);
+  if (!updates || !Array.isArray(finalValue)) return void 0;
+  const previousInstances = [...instances.values()];
+  let retainedStart = 0;
+  for (const update of updates) {
+    retainedStart += Math.min(update.retainedStart, previousInstances.length - retainedStart);
+  }
+  const retainedLength = previousInstances.length - retainedStart;
+  const survivors = [];
+  try {
+    for (let index = 0; index < retainedLength; index += 1) {
+      const sourceIndex = retainedStart + index;
+      const instance = previousInstances[sourceIndex];
+      if (!instance || instance.index !== sourceIndex || !Object.is(instance.item, finalValue[index])) {
+        return void 0;
+      }
+      survivors.push(instance);
+    }
+  } catch {
+    return void 0;
+  }
+  const knownKeys = new Set(instances.keys());
+  const incoming = [];
+  try {
+    for (let index = retainedLength; index < finalValue.length; index += 1) {
+      const item = finalValue[index];
+      const key = keyedRowIdentity(props.rowKey(item, index));
+      if (knownKeys.has(key)) return void 0;
+      knownKeys.add(key);
+      const descriptor = props.create(item, index);
+      incoming.push({
+        key,
+        element: createCompilerHostElement(root.ownerDocument, descriptor),
+        values: readKeyedRowBindingValues(props, item, index),
+        item,
+        index,
+        conditionalValues: EMPTY_KEYED_ROW_CONDITIONAL_VALUES
+      });
+    }
+  } catch {
+    return void 0;
+  }
+  for (let index = 0; index < retainedStart; index += 1) {
+    previousInstances[index].scope?.cleanup();
+    previousInstances[index].element.remove();
+  }
+  for (let index = 0; index < survivors.length; index += 1) survivors[index].index = index;
+  if (incoming.length > 0) {
+    const fragment = root.ownerDocument.createDocumentFragment();
+    for (const instance of incoming) fragment.append(instance.element);
+    root.append(fragment);
+  }
+  const nextInstances = new Map(
+    [...survivors, ...incoming].map((instance) => [instance.key, instance])
+  );
+  return nextInstances;
+}
+function reconcileCompilerKeyedArrayPosition(props, dirtyState, collectionToken, instances, root, reactOwnedRows) {
+  if (reactOwnedRows || props.hostBlocks || (props.conditionals?.length || 0) > 0 || !props.positionIndexIndependent || props.collectionDependency === void 0) {
+    return void 0;
+  }
+  const collectionDependency = props.collectionDependency;
+  if (props.bindings.some((binding) => binding.dependencies?.includes(collectionDependency))) {
+    return void 0;
+  }
+  const dependencies = props.dependencies || props.structureDependencies;
+  const relevantDirty = (dependencies || []).filter((index) => dirtyState.has(index));
+  if (relevantDirty.length !== 1 || relevantDirty[0] !== collectionDependency) {
+    return void 0;
+  }
+  const finalValue = props.items();
+  const update = compilerKeyedArrayPosition(finalValue, collectionToken, instances.size);
+  if (!update || !Array.isArray(finalValue)) return void 0;
+  const previousInstances = [...instances.values()];
+  const previous = previousInstances[update.position];
+  if (update.kind === "remove") {
+    const count = update.sourceLength - update.resultLength;
+    const removed = previousInstances.slice(update.position, update.position + count);
+    if (removed.some((instance, index) => instance.index !== update.position + index)) {
+      return void 0;
+    }
+    for (const instance of removed) {
+      instance.scope?.cleanup();
+      instance.element.remove();
+    }
+    previousInstances.splice(update.position, count);
+    for (let index = update.position; index < previousInstances.length; index += 1) {
+      previousInstances[index].index = index;
+    }
+    return keyedRowInstancesByKey(previousInstances);
+  }
+  let item;
+  let key;
+  try {
+    item = finalValue[update.position];
+    key = keyedRowIdentity(props.rowKey(item, update.position));
+  } catch {
+    return void 0;
+  }
+  if (update.kind === "insert") {
+    if (instances.has(key)) return void 0;
+    let inserted;
+    try {
+      const descriptor = props.create(item, update.position);
+      inserted = {
+        key,
+        element: createCompilerHostElement(root.ownerDocument, descriptor),
+        values: readKeyedRowBindingValues(props, item, update.position),
+        item,
+        index: update.position,
+        conditionalValues: EMPTY_KEYED_ROW_CONDITIONAL_VALUES
+      };
+    } catch {
+      return void 0;
+    }
+    root.insertBefore(inserted.element, previous?.element || null);
+    previousInstances.splice(update.position, 0, inserted);
+    for (let index = update.position + 1; index < previousInstances.length; index += 1) {
+      previousInstances[index].index = index;
+    }
+    return keyedRowInstancesByKey(previousInstances);
+  }
+  if (!previous || previous.index !== update.position) return void 0;
+  if (key === previous.key) {
+    try {
+      applyKeyedRowBindings(props, previous, item, update.position);
+    } catch {
+      return void 0;
+    }
+    previous.item = item;
+    return instances;
+  }
+  if (instances.has(key)) return void 0;
+  let replacement;
+  try {
+    const descriptor = props.create(item, update.position);
+    replacement = {
+      key,
+      element: createCompilerHostElement(root.ownerDocument, descriptor),
+      values: readKeyedRowBindingValues(props, item, update.position),
+      item,
       index: update.position,
       conditionalValues: EMPTY_KEYED_ROW_CONDITIONAL_VALUES
     };
@@ -2856,10 +4270,10 @@ function reconcileCompilerKeyedArrayPosition(props, dirtyState, collectionToken,
   previous.scope?.cleanup();
   previous.element.replaceWith(replacement.element);
   previousInstances[update.position] = replacement;
-  return new Map(previousInstances.map((instance) => [instance.key, instance]));
+  return keyedRowInstancesByKey(previousInstances);
 }
-function reconcileCompilerKeyedArrayReorder(props, dirtyState, collectionToken, instances, root, reactOwnedRows) {
-  if (reactOwnedRows || props.hostBlocks || (props.conditionals?.length || 0) > 0 || !props.reorderIndexIndependent || props.collectionDependency === void 0) {
+function reconcileCompilerKeyedArrayBatchInsert(props, dirtyState, collectionToken, instances, root, reactOwnedRows) {
+  if (reactOwnedRows || props.hostBlocks || (props.conditionals?.length || 0) > 0 || !props.positionIndexIndependent || props.collectionDependency === void 0) {
     return void 0;
   }
   const collectionDependency = props.collectionDependency;
@@ -2872,10 +4286,502 @@ function reconcileCompilerKeyedArrayReorder(props, dirtyState, collectionToken,
     return void 0;
   }
   const finalValue = props.items();
-  const update = compilerKeyedArrayReorder(finalValue, collectionToken, instances.size);
+  const update = compilerKeyedArrayBatchInsert(finalValue, collectionToken, instances.size);
   if (!update || !Array.isArray(finalValue)) return void 0;
   const previousInstances = [...instances.values()];
-  if (update.kind === "sort") {
+  const insertCount = update.resultLength - update.sourceLength;
+  for (let sourceIndex = 0; sourceIndex < update.sourceLength; sourceIndex += 1) {
+    const instance = previousInstances[sourceIndex];
+    const resultIndex = sourceIndex < update.position ? sourceIndex : sourceIndex + insertCount;
+    if (!instance || instance.index !== sourceIndex || !Object.is(instance.item, finalValue[resultIndex])) {
+      return void 0;
+    }
+  }
+  const knownKeys = new Set(instances.keys());
+  const incoming = [];
+  try {
+    for (let offset = 0; offset < insertCount; offset += 1) {
+      const index = update.position + offset;
+      const item = finalValue[index];
+      const key = keyedRowIdentity(props.rowKey(item, index));
+      if (knownKeys.has(key)) return void 0;
+      knownKeys.add(key);
+      const descriptor = props.create(item, index);
+      incoming.push({
+        key,
+        element: createCompilerHostElement(root.ownerDocument, descriptor),
+        values: readKeyedRowBindingValues(props, item, index),
+        item,
+        index,
+        conditionalValues: EMPTY_KEYED_ROW_CONDITIONAL_VALUES
+      });
+    }
+  } catch {
+    return void 0;
+  }
+  const fragment = root.ownerDocument.createDocumentFragment();
+  for (const instance of incoming) fragment.append(instance.element);
+  root.insertBefore(fragment, previousInstances[update.position]?.element || null);
+  previousInstances.splice(update.position, 0, ...incoming);
+  for (let index = update.position + insertCount; index < previousInstances.length; index += 1) {
+    previousInstances[index].index = index;
+  }
+  return keyedRowInstancesByKey(previousInstances);
+}
+function normalizeCompilerKeyedArrayDisjointWindows(updates) {
+  const windows = [];
+  for (const update of updates) {
+    const updateEnd = update.position + update.removedCount;
+    let sourcePosition = update.position;
+    for (const window of windows) {
+      const windowStart = window[1];
+      const windowEnd = windowStart + window[3];
+      const before = updateEnd <= windowStart;
+      const after = window[3] === 0 ? update.position >= windowStart : update.position >= windowEnd;
+      if (!before && !after) return void 0;
+      if (after) sourcePosition -= window[3] - window[2];
+    }
+    const delta = update.insertedCount - update.removedCount;
+    for (const window of windows) {
+      if (updateEnd <= window[1]) window[1] += delta;
+    }
+    windows.push([sourcePosition, update.position, update.removedCount, update.insertedCount]);
+  }
+  windows.sort((left, right) => left[0] - right[0]);
+  return windows;
+}
+function readCompilerKeyedArrayWindowItems(props, finalValue, resultPosition, insertedCount) {
+  const items = [];
+  const keys = [];
+  try {
+    for (let offset = 0; offset < insertedCount; offset += 1) {
+      const index = resultPosition + offset;
+      const item = finalValue[index];
+      items.push(item);
+      keys.push(keyedRowIdentity(props.rowKey(item, index)));
+    }
+  } catch {
+    return void 0;
+  }
+  return [items, keys];
+}
+function prepareCompilerKeyedArrayWindow(props, instances, previousInstances, root, window, incoming, preparedIncomingKeys) {
+  const removedEnd = window[0] + window[2];
+  const removed = previousInstances.slice(window[0], removedEnd);
+  const anchor = previousInstances[removedEnd]?.element || null;
+  if (removed.length !== window[2] || removed.some(
+    (instance, offset) => instance.index !== window[0] + offset || instance.element.parentNode !== root
+  ) || anchor && anchor.parentNode !== root) {
+    return void 0;
+  }
+  const incomingKeySet = new Set(incoming[1]);
+  if (incomingKeySet.size !== incoming[1].length) return void 0;
+  for (const key of incomingKeySet) {
+    if (preparedIncomingKeys.has(key)) return void 0;
+    preparedIncomingKeys.add(key);
+  }
+  const hasLocalReuse = removed.some((instance) => incomingKeySet.has(instance.key));
+  const removedByKey = hasLocalReuse ? new Map(removed.map((instance, offset) => [instance.key, { instance, offset }])) : void 0;
+  const nextWindow = [];
+  const sequence = [];
+  const preparedBindings = [];
+  try {
+    for (let offset = 0; offset < window[3]; offset += 1) {
+      const index = window[1] + offset;
+      const item = incoming[0][offset];
+      const key = incoming[1][offset];
+      const retained = removedByKey?.get(key);
+      if (retained) {
+        const bindingUpdates = prepareKeyedRowBindingUpdates(props, retained.instance, item, index);
+        if (!bindingUpdates) return void 0;
+        nextWindow.push(retained.instance);
+        sequence.push(retained.offset);
+        preparedBindings.push(bindingUpdates);
+        continue;
+      }
+      if (instances.has(key)) return void 0;
+      const descriptor = props.create(item, index);
+      nextWindow.push({
+        key,
+        element: createCompilerHostElement(root.ownerDocument, descriptor),
+        values: readKeyedRowBindingValues(props, item, index),
+        item,
+        index,
+        conditionalValues: EMPTY_KEYED_ROW_CONDITIONAL_VALUES
+      });
+      sequence.push(-1);
+      preparedBindings.push(void 0);
+    }
+  } catch {
+    return void 0;
+  }
+  return [removed, anchor, incoming[0], incomingKeySet, nextWindow, sequence, preparedBindings];
+}
+function commitCompilerKeyedArrayWindow(props, root, prepared) {
+  for (const instance of prepared[0]) {
+    if (prepared[3].has(instance.key)) continue;
+    instance.scope?.cleanup();
+    instance.element.remove();
+  }
+  for (let offset = 0; offset < prepared[4].length; offset += 1) {
+    const bindingUpdates = prepared[6][offset];
+    if (!bindingUpdates) continue;
+    const instance = prepared[4][offset];
+    applyPreparedKeyedRowBindingUpdates(props, instance, bindingUpdates);
+    instance.item = prepared[2][offset];
+  }
+  reorderCompilerKeyedRows(root, prepared[4], prepared[5], prepared[1]);
+}
+function reconcileCompilerKeyedArrayWindowReplace(props, dirtyState, collectionToken, instances, root, reactOwnedRows) {
+  if (reactOwnedRows || props.hostBlocks || (props.conditionals?.length || 0) > 0 || !props.positionIndexIndependent || props.collectionDependency === void 0) {
+    return void 0;
+  }
+  const collectionDependency = props.collectionDependency;
+  if (props.bindings.some((binding) => binding.dependencies?.includes(collectionDependency))) {
+    return void 0;
+  }
+  const dependencies = props.dependencies || props.structureDependencies;
+  const relevantDirty = (dependencies || []).filter((index) => dirtyState.has(index));
+  if (relevantDirty.length !== 1 || relevantDirty[0] !== collectionDependency) {
+    return void 0;
+  }
+  const finalValue = props.items();
+  const updates = compilerKeyedArrayWindowReplacements(finalValue, collectionToken, instances.size);
+  if (!updates || !Array.isArray(finalValue)) return void 0;
+  const previousInstances = [...instances.values()];
+  if (updates.length > 1) {
+    if (updates.some((update2) => update2.insertedCount !== update2.removedCount)) {
+      const windows = normalizeCompilerKeyedArrayDisjointWindows(updates);
+      if (!windows) return void 0;
+      let sourceCursor = 0;
+      let resultCursor = 0;
+      const preparedIncomingKeys = /* @__PURE__ */ new Set();
+      const preparedWindows = [];
+      const nextInstances = [];
+      for (const window of windows) {
+        if (window[0] < sourceCursor) return void 0;
+        while (sourceCursor < window[0]) {
+          const instance = previousInstances[sourceCursor];
+          if (!instance || instance.index !== sourceCursor || !Object.is(instance.item, finalValue[resultCursor])) {
+            return void 0;
+          }
+          nextInstances.push(instance);
+          sourceCursor += 1;
+          resultCursor += 1;
+        }
+        const incoming2 = readCompilerKeyedArrayWindowItems(
+          props,
+          finalValue,
+          resultCursor,
+          window[3]
+        );
+        if (!incoming2) return void 0;
+        window[1] = resultCursor;
+        const prepared3 = prepareCompilerKeyedArrayWindow(
+          props,
+          instances,
+          previousInstances,
+          root,
+          window,
+          incoming2,
+          preparedIncomingKeys
+        );
+        if (!prepared3) return void 0;
+        preparedWindows.push(prepared3);
+        nextInstances.push(...prepared3[4]);
+        sourceCursor += window[2];
+        resultCursor += window[3];
+      }
+      while (sourceCursor < previousInstances.length) {
+        const instance = previousInstances[sourceCursor];
+        if (!instance || instance.index !== sourceCursor || !Object.is(instance.item, finalValue[resultCursor])) {
+          return void 0;
+        }
+        nextInstances.push(instance);
+        sourceCursor += 1;
+        resultCursor += 1;
+      }
+      if (resultCursor !== finalValue.length) return void 0;
+      for (const prepared3 of preparedWindows) {
+        commitCompilerKeyedArrayWindow(props, root, prepared3);
+      }
+      for (let index = 0; index < nextInstances.length; index += 1) {
+        nextInstances[index].index = index;
+      }
+      return keyedRowInstancesByKey(nextInstances);
+    }
+    const touchedIndices = /* @__PURE__ */ new Set();
+    for (const update2 of updates) {
+      for (let index = update2.position; index < update2.position + update2.removedCount; index += 1) {
+        touchedIndices.add(index);
+      }
+    }
+    for (let index = 0; index < previousInstances.length; index += 1) {
+      const instance = previousInstances[index];
+      const touched = touchedIndices.has(index);
+      if (!instance || instance.index !== index || (touched ? instance.element.parentNode !== root : !Object.is(instance.item, finalValue[index]))) {
+        return void 0;
+      }
+    }
+    const knownKeys = new Set(instances.keys());
+    const incomingKeys2 = /* @__PURE__ */ new Set();
+    let replacesRows = false;
+    const prepared2 = [];
+    try {
+      for (const index of [...touchedIndices].sort((left, right) => left - right)) {
+        const instance = previousInstances[index];
+        const item = finalValue[index];
+        const key = keyedRowIdentity(props.rowKey(item, index));
+        if (key !== instance.key) {
+          if (knownKeys.has(key) || incomingKeys2.has(key)) return void 0;
+          incomingKeys2.add(key);
+          replacesRows = true;
+          const descriptor = props.create(item, index);
+          prepared2.push([
+            index,
+            instance,
+            item,
+            void 0,
+            {
+              key,
+              element: createCompilerHostElement(root.ownerDocument, descriptor),
+              values: readKeyedRowBindingValues(props, item, index),
+              item,
+              index,
+              conditionalValues: EMPTY_KEYED_ROW_CONDITIONAL_VALUES
+            }
+          ]);
+          continue;
+        }
+        const bindingUpdates = prepareKeyedRowBindingUpdates(props, instance, item, index);
+        if (!bindingUpdates) return void 0;
+        prepared2.push([index, instance, item, bindingUpdates, void 0]);
+      }
+    } catch {
+      return void 0;
+    }
+    for (const [index, instance, item, bindingUpdates, replacement] of prepared2) {
+      if (replacement) {
+        instance.scope?.cleanup();
+        instance.element.replaceWith(replacement.element);
+        previousInstances[index] = replacement;
+      } else {
+        applyPreparedKeyedRowBindingUpdates(props, instance, bindingUpdates);
+        instance.item = item;
+      }
+    }
+    return replacesRows ? keyedRowInstancesByKey(previousInstances) : instances;
+  }
+  const update = updates[0];
+  const removedEnd = update.position + update.removedCount;
+  for (let sourceIndex = 0; sourceIndex < update.sourceLength; sourceIndex += 1) {
+    const instance = previousInstances[sourceIndex];
+    if (!instance || instance.index !== sourceIndex) return void 0;
+    if (sourceIndex >= update.position && sourceIndex < removedEnd) continue;
+    const resultIndex = sourceIndex < update.position ? sourceIndex : sourceIndex - update.removedCount + update.insertedCount;
+    if (!Object.is(instance.item, finalValue[resultIndex])) return void 0;
+  }
+  const removed = previousInstances.slice(update.position, removedEnd);
+  const anchor = previousInstances[removedEnd]?.element;
+  if (removed.length !== update.removedCount || removed.some((instance) => instance.element.parentNode !== root) || anchor && anchor.parentNode !== root) {
+    return void 0;
+  }
+  const incoming = readCompilerKeyedArrayWindowItems(
+    props,
+    finalValue,
+    update.position,
+    update.insertedCount
+  );
+  if (!incoming) return void 0;
+  const incomingItems = incoming[0];
+  const incomingKeys = incoming[1];
+  if (update.insertedCount === update.removedCount && incomingKeys.every((key, offset) => key === removed[offset].key)) {
+    const prepared2 = [];
+    try {
+      for (let offset = 0; offset < update.insertedCount; offset += 1) {
+        const updates2 = prepareKeyedRowBindingUpdates(
+          props,
+          removed[offset],
+          incomingItems[offset],
+          update.position + offset
+        );
+        if (!updates2) return void 0;
+        prepared2.push(updates2);
+      }
+    } catch {
+      return void 0;
+    }
+    for (let offset = 0; offset < update.insertedCount; offset += 1) {
+      applyPreparedKeyedRowBindingUpdates(props, removed[offset], prepared2[offset]);
+      removed[offset].item = incomingItems[offset];
+    }
+    return instances;
+  }
+  const prepared = prepareCompilerKeyedArrayWindow(
+    props,
+    instances,
+    previousInstances,
+    root,
+    [update.position, update.position, update.removedCount, update.insertedCount],
+    incoming,
+    /* @__PURE__ */ new Set()
+  );
+  if (!prepared) return void 0;
+  commitCompilerKeyedArrayWindow(props, root, prepared);
+  previousInstances.splice(update.position, update.removedCount, ...prepared[4]);
+  for (let index = update.position; index < previousInstances.length; index += 1) {
+    previousInstances[index].index = index;
+  }
+  return keyedRowInstancesByKey(previousInstances);
+}
+function reconcileCompilerKeyedArrayPositionWithBatch(...args) {
+  return reconcileCompilerKeyedArrayBatchInsert(...args) || reconcileCompilerKeyedArrayPosition(...args);
+}
+function reconcileCompilerKeyedArrayPositionWithWindow(...args) {
+  return reconcileCompilerKeyedArrayWindowReplace(...args) || reconcileCompilerKeyedArrayBatchInsert(...args) || reconcileCompilerKeyedArrayPosition(...args);
+}
+function reconcileCompilerKeyedArrayStructuralReorder(props, dirtyState, collectionToken, instances, root, reactOwnedRows, preparedReorder) {
+  if (reactOwnedRows || props.hostBlocks || (props.conditionals?.length || 0) > 0 || !props.filterIndexIndependent || !props.reorderIndexIndependent || props.collectionDependency === void 0) {
+    return void 0;
+  }
+  const collectionDependency = props.collectionDependency;
+  if (props.bindings.some((binding) => binding.dependencies?.includes(collectionDependency))) {
+    return void 0;
+  }
+  const dependencies = props.dependencies || props.structureDependencies;
+  const relevantDirty = (dependencies || []).filter((index) => dirtyState.has(index));
+  if (relevantDirty.length !== 1 || relevantDirty[0] !== collectionDependency) {
+    return void 0;
+  }
+  const finalValue = preparedReorder?.value ?? props.items();
+  const update = preparedReorder?.update || compilerKeyedArrayReorder(finalValue, collectionToken, instances.size);
+  if (!update?.structuralUpdate || !Array.isArray(finalValue)) return void 0;
+  const survivorResult = compilerKeyedArrayFilterSurvivorsFromUpdate(
+    update.structuralUpdate,
+    collectionToken,
+    instances.size,
+    finalValue.length
+  );
+  if (!survivorResult) return void 0;
+  const previousInstances = [...instances.values()];
+  const mappedItemSources = update.mappedItemSources;
+  const prepared = (() => {
+    try {
+      const survivors = [];
+      let previousSourceIndex = -1;
+      for (const sourceIndex of survivorResult.indices) {
+        const instance = previousInstances[sourceIndex];
+        if (sourceIndex <= previousSourceIndex || !instance || instance.index !== sourceIndex) {
+          return void 0;
+        }
+        previousSourceIndex = sourceIndex;
+        survivors.push(instance);
+      }
+      const prepareChangedInstance = (instance, item, targetIndex) => {
+        if (Object.is(instance.item, item)) return void 0;
+        const bindingUpdates = prepareKeyedRowBindingUpdates(props, instance, item, targetIndex);
+        if (!bindingUpdates) throw new TypeError();
+        return { bindingUpdates, instance, item };
+      };
+      let preservesSurvivorOrder = true;
+      const directChanges = [];
+      if (update.kind !== 1 /* Permutation */) {
+        const positionalInstances = update.kind === 0 /* Reverse */ ? [...survivors].reverse() : survivors;
+        const sequence2 = update.kind === 0 /* Reverse */ ? positionalInstances.map((instance) => instance.index) : void 0;
+        for (let targetIndex = 0; targetIndex < finalValue.length; targetIndex += 1) {
+          const item = finalValue[targetIndex];
+          const instance = positionalInstances[targetIndex];
+          if (keyedRowIdentity(props.rowKey(item, targetIndex)) !== instance.key) return void 0;
+          const changed2 = prepareChangedInstance(instance, item, targetIndex);
+          if (changed2) directChanges.push(changed2);
+        }
+        return { changed: directChanges, nextInstances: positionalInstances, sequence: sequence2 };
+      }
+      for (let targetIndex = 0; targetIndex < finalValue.length; targetIndex += 1) {
+        const item = finalValue[targetIndex];
+        const instance = survivors[targetIndex];
+        const sourceItem = mappedItemSources?.has(item) ? mappedItemSources.get(item) : item;
+        if (!Object.is(instance.item, sourceItem)) {
+          preservesSurvivorOrder = false;
+          break;
+        }
+        if (keyedRowIdentity(props.rowKey(item, targetIndex)) !== instance.key) return void 0;
+        const changed2 = prepareChangedInstance(instance, item, targetIndex);
+        if (changed2) directChanges.push(changed2);
+      }
+      if (preservesSurvivorOrder) {
+        return { changed: directChanges, nextInstances: survivors, sequence: void 0 };
+      }
+      const survivorInstances = /* @__PURE__ */ new Map();
+      for (const instance of survivors) {
+        if (survivorInstances.has(instance.item)) return void 0;
+        survivorInstances.set(instance.item, instance);
+      }
+      const nextInstances = [];
+      const sequence = [];
+      const changed = [];
+      for (let targetIndex = 0; targetIndex < finalValue.length; targetIndex += 1) {
+        const item = finalValue[targetIndex];
+        const sourceItem = mappedItemSources?.has(item) ? mappedItemSources.get(item) : item;
+        const instance = survivorInstances.get(sourceItem);
+        if (!instance || !Object.is(instance.item, sourceItem) || keyedRowIdentity(props.rowKey(item, targetIndex)) !== instance.key) {
+          return void 0;
+        }
+        survivorInstances.delete(sourceItem);
+        nextInstances.push(instance);
+        sequence.push(instance.index);
+        const changedInstance = prepareChangedInstance(instance, item, targetIndex);
+        if (changedInstance) changed.push(changedInstance);
+      }
+      if (survivorInstances.size > 0) return void 0;
+      return { changed, nextInstances, sequence };
+    } catch {
+      return void 0;
+    }
+  })();
+  if (!prepared) return void 0;
+  let survivorCursor = 0;
+  for (let sourceIndex = 0; sourceIndex < previousInstances.length; sourceIndex += 1) {
+    if (survivorResult.indices[survivorCursor] === sourceIndex) {
+      survivorCursor += 1;
+      continue;
+    }
+    const instance = previousInstances[sourceIndex];
+    instance.scope?.cleanup();
+    instance.element.remove();
+  }
+  if (prepared.sequence) {
+    reorderCompilerKeyedRows(root, prepared.nextInstances, prepared.sequence, null);
+  }
+  for (const { bindingUpdates, instance, item } of prepared.changed) {
+    applyPreparedKeyedRowBindingUpdates(props, instance, bindingUpdates);
+    instance.item = item;
+  }
+  for (let index = 0; index < prepared.nextInstances.length; index += 1) {
+    prepared.nextInstances[index].index = index;
+  }
+  return keyedRowInstancesByKey(prepared.nextInstances);
+}
+function reconcileCompilerKeyedArrayReorder(props, dirtyState, collectionToken, instances, root, reactOwnedRows, preparedReorder) {
+  if (reactOwnedRows || props.hostBlocks || (props.conditionals?.length || 0) > 0 || !props.reorderIndexIndependent || props.collectionDependency === void 0) {
+    return void 0;
+  }
+  const collectionDependency = props.collectionDependency;
+  if (props.bindings.some((binding) => binding.dependencies?.includes(collectionDependency))) {
+    return void 0;
+  }
+  const dependencies = props.dependencies || props.structureDependencies;
+  const relevantDirty = (dependencies || []).filter((index) => dirtyState.has(index));
+  if (relevantDirty.length !== 1 || relevantDirty[0] !== collectionDependency) {
+    return void 0;
+  }
+  const finalValue = preparedReorder?.value ?? props.items();
+  const update = preparedReorder?.update || compilerKeyedArrayReorder(finalValue, collectionToken, instances.size);
+  if (!update || update.mapped || update.structuralUpdate || !Array.isArray(finalValue)) {
+    return void 0;
+  }
+  const previousInstances = [...instances.values()];
+  if (update.kind === 1 /* Permutation */) {
     const instancesByItem = /* @__PURE__ */ new Map();
     try {
       for (let sourceIndex = 0; sourceIndex < previousInstances.length; sourceIndex += 1) {
@@ -2894,30 +4800,19 @@ function reconcileCompilerKeyedArrayReorder(props, dirtyState, collectionToken,
         sequence.push(instance.index);
       }
       if (instancesByItem.size > 0) return void 0;
-      const activeElement2 = root.ownerDocument.activeElement;
-      const restoreFocus2 = Boolean(activeElement2 && root.contains(activeElement2));
-      const stablePositions = longestIncreasingSubsequencePositions(sequence);
-      let anchor2 = null;
-      for (let index = nextInstances.length - 1; index >= 0; index -= 1) {
-        const instance = nextInstances[index];
-        if (!stablePositions.has(index) && instance.element.nextSibling !== anchor2) {
-          root.insertBefore(instance.element, anchor2);
-        }
-        anchor2 = instance.element;
-        instance.index = index;
+      reorderCompilerKeyedRows(root, nextInstances, sequence, null);
+      for (let index = 0; index < nextInstances.length; index += 1) {
+        nextInstances[index].index = index;
       }
-      if (restoreFocus2 && activeElement2?.isConnected && activeElement2.ownerDocument.activeElement !== activeElement2 && "focus" in activeElement2) {
-        activeElement2.focus({ preventScroll: true });
-      }
-      return new Map(nextInstances.map((instance) => [instance.key, instance]));
+      return keyedRowInstancesByKey(nextInstances);
     } catch {
       return void 0;
     }
   }
   try {
-    for (let sourceIndex = 0; sourceIndex < previousInstances.length; sourceIndex += 1) {
+    for (let targetIndex = 0; targetIndex < previousInstances.length; targetIndex += 1) {
+      const sourceIndex = update.kind === 0 /* Reverse */ ? previousInstances.length - targetIndex - 1 : targetIndex;
       const instance = previousInstances[sourceIndex];
-      const targetIndex = previousInstances.length - sourceIndex - 1;
       if (instance.index !== sourceIndex || !Object.is(instance.item, finalValue[targetIndex])) {
         return void 0;
       }
@@ -2925,22 +4820,41 @@ function reconcileCompilerKeyedArrayReorder(props, dirtyState, collectionToken,
   } catch {
     return void 0;
   }
-  const activeElement = root.ownerDocument.activeElement;
-  const restoreFocus = Boolean(activeElement && root.contains(activeElement));
-  let anchor = previousInstances[0]?.element || null;
-  for (let sourceIndex = 1; sourceIndex < previousInstances.length; sourceIndex += 1) {
-    const element = previousInstances[sourceIndex].element;
-    root.insertBefore(element, anchor);
-    anchor = element;
+  if (update.kind === void 0) return instances;
+  reverseCompilerKeyedRows(root, previousInstances);
+  return keyedRowInstancesByKey(previousInstances);
+}
+function prepareCompilerKeyedArrayReorder(args) {
+  const [props, dirtyState, collectionToken, instances, , reactOwnedRows] = args;
+  if (reactOwnedRows || props.hostBlocks || (props.conditionals?.length || 0) > 0 || !props.reorderIndexIndependent || props.collectionDependency === void 0) {
+    return void 0;
   }
-  previousInstances.reverse();
-  for (let index = 0; index < previousInstances.length; index += 1) {
-    previousInstances[index].index = index;
+  const collectionDependency = props.collectionDependency;
+  if (props.bindings.some((binding) => binding.dependencies?.includes(collectionDependency))) {
+    return void 0;
   }
-  if (restoreFocus && activeElement?.isConnected && activeElement.ownerDocument.activeElement !== activeElement && "focus" in activeElement) {
-    activeElement.focus({ preventScroll: true });
+  const dependencies = props.dependencies || props.structureDependencies;
+  const relevantDirty = (dependencies || []).filter((index) => dirtyState.has(index));
+  if (relevantDirty.length !== 1 || relevantDirty[0] !== collectionDependency) {
+    return void 0;
   }
-  return new Map(previousInstances.map((instance) => [instance.key, instance]));
+  const value = props.items();
+  return {
+    update: compilerKeyedArrayReorder(value, collectionToken, instances.size),
+    value
+  };
+}
+function reconcileCompilerKeyedArrayReorderWithMap(...args) {
+  const prepared = prepareCompilerKeyedArrayReorder(args);
+  if (!prepared) return void 0;
+  const reconcile = prepared.update?.mapped ? reconcileCompilerKeyedArrayMapReorder : reconcileCompilerKeyedArrayReorder;
+  return reconcile(args[0], args[1], args[2], args[3], args[4], args[5], prepared);
+}
+function reconcileCompilerKeyedArrayReorderWithMapAndStructural(...args) {
+  const prepared = prepareCompilerKeyedArrayReorder(args);
+  if (!prepared) return void 0;
+  const reconcile = prepared.update?.structuralUpdate ? reconcileCompilerKeyedArrayStructuralReorder : prepared.update?.mapped ? reconcileCompilerKeyedArrayMapReorder : reconcileCompilerKeyedArrayReorder;
+  return reconcile(args[0], args[1], args[2], args[3], args[4], args[5], prepared);
 }
 function reconcileCompilerKeyedArrayPrepend(props, dirtyState, collectionToken, instances, root, reactOwnedRows) {
   if (reactOwnedRows || props.hostBlocks || (props.conditionals?.length || 0) > 0 || !props.prependIndexIndependent || props.collectionDependency === void 0) {
@@ -2968,7 +4882,192 @@ function reconcileCompilerKeyedArrayPrepend(props, dirtyState, collectionToken,
   const knownKeys = new Set(instances.keys());
   const prepended = [];
   try {
-    for (let index = 0; index < prefixLength; index += 1) {
+    for (let index = 0; index < prefixLength; index += 1) {
+      const item = finalValue[index];
+      const key = keyedRowIdentity(props.rowKey(item, index));
+      if (knownKeys.has(key)) return void 0;
+      knownKeys.add(key);
+      const descriptor = props.create(item, index);
+      prepended.push({
+        key,
+        element: createCompilerHostElement(root.ownerDocument, descriptor),
+        values: readKeyedRowBindingValues(props, item, index),
+        item,
+        index,
+        conditionalValues: EMPTY_KEYED_ROW_CONDITIONAL_VALUES
+      });
+    }
+  } catch {
+    return void 0;
+  }
+  if (prepended.length > 0) {
+    const fragment = root.ownerDocument.createDocumentFragment();
+    for (const instance of prepended) fragment.append(instance.element);
+    root.insertBefore(fragment, root.firstChild);
+  }
+  for (let index = 0; index < previousInstances.length; index += 1) {
+    previousInstances[index].index = prefixLength + index;
+  }
+  return keyedRowInstancesByKey([...prepended, ...previousInstances]);
+}
+function reconcileCompilerKeyedArrayStructuralPrepend(props, dirtyState, collectionToken, instances, root, reactOwnedRows) {
+  if (reactOwnedRows || props.hostBlocks || (props.conditionals?.length || 0) > 0 || !props.filterIndexIndependent || !props.prependIndexIndependent || props.collectionDependency === void 0) {
+    return void 0;
+  }
+  const collectionDependency = props.collectionDependency;
+  if (props.bindings.some((binding) => binding.dependencies?.includes(collectionDependency))) {
+    return void 0;
+  }
+  const dependencies = props.dependencies || props.structureDependencies;
+  const relevantDirty = (dependencies || []).filter((index) => dirtyState.has(index));
+  if (relevantDirty.length !== 1 || relevantDirty[0] !== collectionDependency) {
+    return void 0;
+  }
+  const finalValue = props.items();
+  const update = compilerKeyedArrayStructuralPrependUpdate(
+    finalValue,
+    collectionToken,
+    instances.size
+  );
+  const structuralUpdate = update?.structuralUpdate;
+  const survivorResult = update?.structuralSurvivors;
+  if (!update || !structuralUpdate || !survivorResult || structuralUpdate.mappedItemSources || !Array.isArray(finalValue)) {
+    return void 0;
+  }
+  const previousInstances = [...instances.values()];
+  const survivors = [];
+  const knownKeys = new Set(instances.keys());
+  const prepended = [];
+  try {
+    for (let index = 0; index < survivorResult.indices.length; index += 1) {
+      const sourceIndex = survivorResult.indices[index];
+      const instance = previousInstances[sourceIndex];
+      const item = finalValue[update.prefixLength + index];
+      if (!instance || instance.index !== sourceIndex || !Object.is(instance.item, item) || !survivorResult.keysStable && keyedRowIdentity(props.rowKey(item, update.prefixLength + index)) !== instance.key) {
+        return void 0;
+      }
+      survivors.push(instance);
+    }
+    for (let index = 0; index < update.prefixLength; index += 1) {
+      const item = finalValue[index];
+      const key = keyedRowIdentity(props.rowKey(item, index));
+      if (knownKeys.has(key)) return void 0;
+      knownKeys.add(key);
+      const descriptor = props.create(item, index);
+      prepended.push({
+        key,
+        element: createCompilerHostElement(root.ownerDocument, descriptor),
+        values: readKeyedRowBindingValues(props, item, index),
+        item,
+        index,
+        conditionalValues: EMPTY_KEYED_ROW_CONDITIONAL_VALUES
+      });
+    }
+  } catch {
+    return void 0;
+  }
+  const survivorSet = new Set(survivorResult.indices);
+  for (let index = 0; index < previousInstances.length; index += 1) {
+    if (survivorSet.has(index)) continue;
+    previousInstances[index].scope?.cleanup();
+    previousInstances[index].element.remove();
+  }
+  if (prepended.length > 0) {
+    const fragment = root.ownerDocument.createDocumentFragment();
+    for (const instance of prepended) fragment.append(instance.element);
+    root.insertBefore(fragment, survivors[0]?.element || root.firstChild);
+  }
+  for (let index = 0; index < survivors.length; index += 1) {
+    survivors[index].index = update.prefixLength + index;
+  }
+  return keyedRowInstancesByKey([...prepended, ...survivors]);
+}
+function reconcileCompilerKeyedArrayStructuralPrependMap(props, dirtyState, collectionToken, instances, root, reactOwnedRows) {
+  if (reactOwnedRows || props.hostBlocks || (props.conditionals?.length || 0) > 0 || !props.filterIndexIndependent || !props.prependIndexIndependent || props.collectionDependency === void 0) {
+    return void 0;
+  }
+  const collectionDependency = props.collectionDependency;
+  if (props.bindings.some((binding) => binding.dependencies?.includes(collectionDependency))) {
+    return void 0;
+  }
+  const dependencies = props.dependencies || props.structureDependencies;
+  const relevantDirty = (dependencies || []).filter((index) => dirtyState.has(index));
+  if (relevantDirty.length !== 1 || relevantDirty[0] !== collectionDependency) {
+    return void 0;
+  }
+  const finalValue = props.items();
+  const update = compilerKeyedArrayStructuralPrependMapUpdate(
+    finalValue,
+    collectionToken,
+    instances.size,
+    true
+  );
+  if (!update || !update.mappedItemSources || !Array.isArray(finalValue)) return void 0;
+  const mappedItemSources = update.mappedSurvivorsValidated ? update.mappedItemSources : void 0;
+  const mappedStructuralSources = update.mappedSurvivorsValidated ? void 0 : update.mappedItemSources;
+  const previousInstances = [...instances.values()];
+  const survivorRange = update.structuralSurvivorRange;
+  const survivorIndices = update.structuralSurvivors;
+  const survivorCount = survivorRange ? survivorRange.end - survivorRange.start : survivorIndices?.length ?? 0;
+  if (!survivorRange && !survivorIndices) return void 0;
+  const changed = [];
+  const knownKeys = new Set(instances.keys());
+  const prepended = [];
+  try {
+    if (mappedStructuralSources) {
+      for (let index = 0; index < survivorCount; index += 1) {
+        const sourceIndex = survivorRange ? survivorRange.start + index : survivorIndices[index];
+        const instance = previousInstances[sourceIndex];
+        const item = finalValue[update.prefixLength + index];
+        const sourceItem = mappedStructuralSources.has(item) ? mappedStructuralSources.get(item) : item;
+        if (!instance || instance.index !== sourceIndex || !Object.is(instance.item, sourceItem)) {
+          return void 0;
+        }
+      }
+      for (let index = 0; index < survivorCount; index += 1) {
+        const sourceIndex = survivorRange ? survivorRange.start + index : survivorIndices[index];
+        const instance = previousInstances[sourceIndex];
+        const item = finalValue[update.prefixLength + index];
+        const sourceItem = mappedStructuralSources.has(item) ? mappedStructuralSources.get(item) : item;
+        if (Object.is(item, sourceItem)) continue;
+        if (keyedRowIdentity(props.rowKey(item, update.prefixLength + index)) !== instance.key) {
+          return void 0;
+        }
+        const bindingUpdates = prepareKeyedRowBindingUpdates(
+          props,
+          instance,
+          item,
+          update.prefixLength + index
+        );
+        if (!bindingUpdates) return void 0;
+        changed.push({ bindingUpdates, instance, item });
+      }
+    } else if (survivorIndices) {
+      for (let index = 0; index < survivorCount; index += 1) {
+        const sourceIndex = survivorIndices[index];
+        const instance = previousInstances[sourceIndex];
+        const item = finalValue[update.prefixLength + index];
+        const expectedItem = mappedItemSources.has(index) ? mappedItemSources.get(index) : item;
+        if (!instance || instance.index !== sourceIndex || !Object.is(instance.item, expectedItem)) {
+          return void 0;
+        }
+      }
+    }
+    for (const [index, sourceItem] of mappedItemSources || []) {
+      if (!Number.isSafeInteger(index) || index < 0 || index >= survivorCount) {
+        return void 0;
+      }
+      const instance = previousInstances[survivorRange ? survivorRange.start + index : survivorIndices[index]];
+      const finalIndex = update.prefixLength + index;
+      const item = finalValue[finalIndex];
+      if (!instance || !Object.is(instance.item, sourceItem) || keyedRowIdentity(props.rowKey(item, finalIndex)) !== instance.key) {
+        return void 0;
+      }
+      const bindingUpdates = prepareKeyedRowBindingUpdates(props, instance, item, finalIndex);
+      if (!bindingUpdates) return void 0;
+      changed.push({ bindingUpdates, instance, item });
+    }
+    for (let index = 0; index < update.prefixLength; index += 1) {
       const item = finalValue[index];
       const key = keyedRowIdentity(props.rowKey(item, index));
       if (knownKeys.has(key)) return void 0;
@@ -2986,15 +5085,43 @@ function reconcileCompilerKeyedArrayPrepend(props, dirtyState, collectionToken,
   } catch {
     return void 0;
   }
+  if (survivorRange) {
+    for (let index = 0; index < survivorRange.start; index += 1) {
+      previousInstances[index].scope?.cleanup();
+      previousInstances[index].element.remove();
+    }
+    for (let index = survivorRange.end; index < previousInstances.length; index += 1) {
+      previousInstances[index].scope?.cleanup();
+      previousInstances[index].element.remove();
+    }
+  } else {
+    const survivorSet = new Set(survivorIndices);
+    for (let index = 0; index < previousInstances.length; index += 1) {
+      if (survivorSet.has(index)) continue;
+      previousInstances[index].scope?.cleanup();
+      previousInstances[index].element.remove();
+    }
+  }
+  const survivors = survivorRange ? previousInstances.slice(survivorRange.start, survivorRange.end) : survivorIndices.map((index) => previousInstances[index]);
   if (prepended.length > 0) {
     const fragment = root.ownerDocument.createDocumentFragment();
     for (const instance of prepended) fragment.append(instance.element);
-    root.insertBefore(fragment, root.firstChild);
+    root.insertBefore(fragment, survivors[0]?.element || root.firstChild);
   }
-  for (let index = 0; index < previousInstances.length; index += 1) {
-    previousInstances[index].index = prefixLength + index;
+  for (let index = 0; index < survivors.length; index += 1) {
+    survivors[index].index = update.prefixLength + index;
+  }
+  for (const { bindingUpdates, instance, item } of changed) {
+    applyPreparedKeyedRowBindingUpdates(props, instance, bindingUpdates);
+    instance.item = item;
   }
-  return new Map([...prepended, ...previousInstances].map((instance) => [instance.key, instance]));
+  return keyedRowInstancesByKey([...prepended, ...survivors]);
+}
+function reconcileCompilerKeyedArrayPrependWithStructural(...args) {
+  return reconcileCompilerKeyedArrayStructuralPrepend(...args) || reconcileCompilerKeyedArrayPrepend(...args);
+}
+function reconcileCompilerKeyedArrayPrependMapWithStructural(...args) {
+  return reconcileCompilerKeyedArrayStructuralPrependMap(...args) || reconcileCompilerKeyedArrayStructuralPrepend(...args) || reconcileCompilerKeyedArrayPrepend(...args);
 }
 function reconcileCompilerKeyedArrayFilter(props, dirtyState, collectionToken, instances, reactOwnedRows) {
   if (reactOwnedRows || props.hostBlocks || (props.conditionals?.length || 0) > 0 || !props.filterIndexIndependent || props.collectionDependency === void 0) {
@@ -3041,7 +5168,7 @@ function reconcileCompilerKeyedArrayFilter(props, dirtyState, collectionToken, i
   for (let index = 0; index < survivors.length; index += 1) {
     survivors[index].index = index;
   }
-  return new Map(survivors.map((instance) => [instance.key, instance]));
+  return keyedRowInstancesByKey(survivors);
 }
 function createKeyedRowConditionalRuntime() {
   class FarmKeyedRowConditional extends React__default.default.Component {
@@ -3215,7 +5342,7 @@ function createKeyedRowsBlockComponent(owner, options = {}) {
             this.hasReactOwnedRows()
           );
           if (appendedInstances) {
-            this.instances = new Map(appendedInstances);
+            this.instances = appendedInstances instanceof Map ? appendedInstances : new Map(appendedInstances);
             this.rebuildElementIndex(this.instances);
             this.commitCurrentCollection(dirtyState);
             afterCommit?.();
@@ -3248,8 +5375,14 @@ function createKeyedRowsBlockComponent(owner, options = {}) {
             this.hasReactOwnedRows()
           );
           if (reorderedInstances) {
+            const removedRows = reorderedInstances.size < this.instances.size;
             this.instances = new Map(reorderedInstances);
             this.rebuildElementIndex(this.instances);
+            if (removedRows) {
+              const keys = [...this.instances.keys()];
+              this.pruneEventHandlers(keys);
+              this.pruneConditionalListeners(keys);
+            }
             this.commitCurrentCollection(dirtyState);
             afterCommit?.();
             return;
@@ -3405,7 +5538,10 @@ function createKeyedRowsBlockComponent(owner, options = {}) {
       }
     }
     commitCurrentCollection(dirtyState) {
-      this.collectionToken = options.keyedUpdates?.commit(this.currentProps.items());
+      this.collectionToken = options.keyedUpdates?.commit(
+        this.currentProps.items(),
+        this.instances
+      );
       this.commitKeyedTargets(dirtyState);
     }
     hasSafeMembershipTargets(dirtyState) {
@@ -3837,8 +5973,6 @@ function createKeyedRowsBlockComponent(owner, options = {}) {
       }
       if (this.reconcileStableRows(rows, afterCommit, dirtyState)) return;
       if (this.reconcileSingleRemoval(rows, afterCommit, dirtyState)) return;
-      const activeElement = this.root.ownerDocument.activeElement;
-      const restoreFocus = Boolean(activeElement && this.root.contains(activeElement));
       const nextKeys = new Set(rows.keys);
       const hasSurvivingRows = rows.keys.some((key) => this.instances.has(key));
       const oldIndices = /* @__PURE__ */ new Map();
@@ -3852,7 +5986,6 @@ function createKeyedRowsBlockComponent(owner, options = {}) {
         }
       }
       const sequence = hasSurvivingRows ? rows.keys.map((key) => oldIndices.get(key) ?? -1) : rows.keys.map(() => -1);
-      const stablePositions = hasSurvivingRows ? longestIncreasingSubsequencePositions(sequence) : /* @__PURE__ */ new Set();
       const nextInstances = [];
       const conditionalChanges = [];
       for (let index = 0; index < rows.items.length; index += 1) {
@@ -3917,34 +6050,12 @@ function createKeyedRowsBlockComponent(owner, options = {}) {
         for (const instance of nextInstances) fragment.append(instance.element);
         this.root.replaceChildren(fragment);
       } else {
-        let anchor = null;
-        for (let index = nextInstances.length - 1; index >= 0; index -= 1) {
-          const instance = nextInstances[index];
-          if (sequence[index] < 0) {
-            let start = index;
-            while (start > 0 && sequence[start - 1] < 0) start -= 1;
-            const fragment = this.root.ownerDocument.createDocumentFragment();
-            for (let itemIndex = start; itemIndex <= index; itemIndex += 1) {
-              fragment.append(nextInstances[itemIndex].element);
-            }
-            this.root.insertBefore(fragment, anchor);
-            anchor = nextInstances[start].element;
-            index = start;
-          } else {
-            if (!stablePositions.has(index) && instance.element.nextSibling !== anchor) {
-              this.root.insertBefore(instance.element, anchor);
-            }
-            anchor = instance.element;
-          }
-        }
+        reorderCompilerKeyedRows(this.root, nextInstances, sequence, null);
       }
-      this.instances = new Map(nextInstances.map((instance) => [instance.key, instance]));
+      this.instances = keyedRowInstancesByKey(nextInstances);
       this.rebuildElementIndex(this.instances);
       this.pruneEventHandlers(rows.keys);
       this.pruneConditionalListeners(rows.keys);
-      if (restoreFocus && activeElement?.isConnected && activeElement.ownerDocument.activeElement !== activeElement && "focus" in activeElement) {
-        activeElement.focus({ preventScroll: true });
-      }
       this.commitCurrentCollection(dirtyState);
       this.notifyConditionalChanges(conditionalChanges, afterCommit);
     }
@@ -4434,6 +6545,22 @@ var keyedRowsPositionHintedRuntimeFeature = {
     })
   })
 };
+var keyedRowsBatchPositionHintedRuntimeFeature = {
+  name: "keyed-rows:batch-position-hinted",
+  create: (owner) => ({
+    KeyedRows: createKeyedRowsBlockComponent(owner, {
+      keyedUpdates: keyedBatchPositionUpdateRuntime
+    })
+  })
+};
+var keyedRowsWindowPositionHintedRuntimeFeature = {
+  name: "keyed-rows:window-position-hinted",
+  create: (owner) => ({
+    KeyedRows: createKeyedRowsBlockComponent(owner, {
+      keyedUpdates: keyedWindowPositionUpdateRuntime
+    })
+  })
+};
 var keyedRowsReorderHintedRuntimeFeature = {
   name: "keyed-rows:reorder-hinted",
   create: (owner) => ({
@@ -4442,6 +6569,14 @@ var keyedRowsReorderHintedRuntimeFeature = {
     })
   })
 };
+var keyedRowsMapReorderHintedRuntimeFeature = {
+  name: "keyed-rows:map-reorder-hinted",
+  create: (owner) => ({
+    KeyedRows: createKeyedRowsBlockComponent(owner, {
+      keyedUpdates: keyedMapReorderUpdateRuntime
+    })
+  })
+};
 var keyedRowsAllHintedRuntimeFeature = {
   name: "keyed-rows:all-hinted",
   create: (owner) => ({
@@ -4458,6 +6593,22 @@ var keyedRowsEveryHintedRuntimeFeature = {
     })
   })
 };
+var keyedRowsBatchEveryHintedRuntimeFeature = {
+  name: "keyed-rows:batch-every-hinted",
+  create: (owner) => ({
+    KeyedRows: createKeyedRowsBlockComponent(owner, {
+      keyedUpdates: keyedBatchEveryUpdateRuntime
+    })
+  })
+};
+var keyedRowsWindowEveryHintedRuntimeFeature = {
+  name: "keyed-rows:window-every-hinted",
+  create: (owner) => ({
+    KeyedRows: createKeyedRowsBlockComponent(owner, {
+      keyedUpdates: keyedWindowEveryUpdateRuntime
+    })
+  })
+};
 var keyedRowsFilterHintedRuntimeFeature = {
   name: "keyed-rows:filter-hinted",
   create: (owner) => ({
@@ -4466,6 +6617,38 @@ var keyedRowsFilterHintedRuntimeFeature = {
     })
   })
 };
+var keyedRowsStructuralAppendHintedRuntimeFeature = {
+  name: "keyed-rows:structural-append-hinted",
+  create: (owner) => ({
+    KeyedRows: createKeyedRowsBlockComponent(owner, {
+      keyedUpdates: keyedWindowEveryStructuralAppendUpdateRuntime
+    })
+  })
+};
+var keyedRowsStructuralAppendMapHintedRuntimeFeature = {
+  name: "keyed-rows:structural-append-map-hinted",
+  create: (owner) => ({
+    KeyedRows: createKeyedRowsBlockComponent(owner, {
+      keyedUpdates: keyedWindowEveryStructuralAppendMapUpdateRuntime
+    })
+  })
+};
+var keyedRowsStructuralPrependHintedRuntimeFeature = {
+  name: "keyed-rows:structural-prepend-hinted",
+  create: (owner) => ({
+    KeyedRows: createKeyedRowsBlockComponent(owner, {
+      keyedUpdates: keyedCompleteCompatibilityUpdateRuntime
+    })
+  })
+};
+var keyedRowsStructuralPrependMapHintedRuntimeFeature = {
+  name: "keyed-rows:structural-prepend-map-hinted",
+  create: (owner) => ({
+    KeyedRows: createKeyedRowsBlockComponent(owner, {
+      keyedUpdates: keyedCompleteStructuralPrependMapUpdateRuntime
+    })
+  })
+};
 var keyedRowsPrependHintedRuntimeFeature = {
   name: "keyed-rows:prepend-hinted",
   create: (owner) => ({
@@ -4478,7 +6661,7 @@ var keyedRowsFilterPrependHintedRuntimeFeature = {
   name: "keyed-rows:filter-prepend-hinted",
   create: (owner) => ({
     KeyedRows: createKeyedRowsBlockComponent(owner, {
-      keyedUpdates: keyedFilterPrependUpdateRuntime
+      keyedUpdates: keyedStructuralPrependUpdateRuntime
     })
   })
 };
@@ -4508,6 +6691,24 @@ var keyedRowsConditionalPositionHintedRuntimeFeature = {
     })
   })
 };
+var keyedRowsConditionalBatchPositionHintedRuntimeFeature = {
+  name: "keyed-rows:conditional:batch-position-hinted",
+  create: (owner) => ({
+    KeyedRows: createKeyedRowsBlockComponent(owner, {
+      conditionals: createKeyedRowConditionalRuntime(),
+      keyedUpdates: keyedBatchPositionUpdateRuntime
+    })
+  })
+};
+var keyedRowsConditionalWindowPositionHintedRuntimeFeature = {
+  name: "keyed-rows:conditional:window-position-hinted",
+  create: (owner) => ({
+    KeyedRows: createKeyedRowsBlockComponent(owner, {
+      conditionals: createKeyedRowConditionalRuntime(),
+      keyedUpdates: keyedWindowPositionUpdateRuntime
+    })
+  })
+};
 var keyedRowsConditionalReorderHintedRuntimeFeature = {
   name: "keyed-rows:conditional:reorder-hinted",
   create: (owner) => ({
@@ -4535,6 +6736,24 @@ var keyedRowsConditionalEveryHintedRuntimeFeature = {
     })
   })
 };
+var keyedRowsConditionalBatchEveryHintedRuntimeFeature = {
+  name: "keyed-rows:conditional:batch-every-hinted",
+  create: (owner) => ({
+    KeyedRows: createKeyedRowsBlockComponent(owner, {
+      conditionals: createKeyedRowConditionalRuntime(),
+      keyedUpdates: keyedBatchEveryUpdateRuntime
+    })
+  })
+};
+var keyedRowsConditionalWindowEveryHintedRuntimeFeature = {
+  name: "keyed-rows:conditional:window-every-hinted",
+  create: (owner) => ({
+    KeyedRows: createKeyedRowsBlockComponent(owner, {
+      conditionals: createKeyedRowConditionalRuntime(),
+      keyedUpdates: keyedWindowEveryUpdateRuntime
+    })
+  })
+};
 var keyedRowsConditionalFilterHintedRuntimeFeature = {
   name: "keyed-rows:conditional:filter-hinted",
   create: (owner) => ({
@@ -4544,6 +6763,42 @@ var keyedRowsConditionalFilterHintedRuntimeFeature = {
     })
   })
 };
+var keyedRowsConditionalStructuralAppendHintedRuntimeFeature = {
+  name: "keyed-rows:conditional:structural-append-hinted",
+  create: (owner) => ({
+    KeyedRows: createKeyedRowsBlockComponent(owner, {
+      conditionals: createKeyedRowConditionalRuntime(),
+      keyedUpdates: keyedWindowEveryStructuralAppendUpdateRuntime
+    })
+  })
+};
+var keyedRowsConditionalStructuralAppendMapHintedRuntimeFeature = {
+  name: "keyed-rows:conditional:structural-append-map-hinted",
+  create: (owner) => ({
+    KeyedRows: createKeyedRowsBlockComponent(owner, {
+      conditionals: createKeyedRowConditionalRuntime(),
+      keyedUpdates: keyedWindowEveryStructuralAppendMapUpdateRuntime
+    })
+  })
+};
+var keyedRowsConditionalStructuralPrependHintedRuntimeFeature = {
+  name: "keyed-rows:conditional:structural-prepend-hinted",
+  create: (owner) => ({
+    KeyedRows: createKeyedRowsBlockComponent(owner, {
+      conditionals: createKeyedRowConditionalRuntime(),
+      keyedUpdates: keyedCompleteCompatibilityUpdateRuntime
+    })
+  })
+};
+var keyedRowsConditionalStructuralPrependMapHintedRuntimeFeature = {
+  name: "keyed-rows:conditional:structural-prepend-map-hinted",
+  create: (owner) => ({
+    KeyedRows: createKeyedRowsBlockComponent(owner, {
+      conditionals: createKeyedRowConditionalRuntime(),
+      keyedUpdates: keyedCompleteStructuralPrependMapUpdateRuntime
+    })
+  })
+};
 var keyedRowsConditionalPrependHintedRuntimeFeature = {
   name: "keyed-rows:conditional:prepend-hinted",
   create: (owner) => ({
@@ -4588,6 +6843,24 @@ var keyedRowsHostPositionHintedRuntimeFeature = {
     })
   })
 };
+var keyedRowsHostBatchPositionHintedRuntimeFeature = {
+  name: "keyed-rows:host:batch-position-hinted",
+  create: (owner) => ({
+    KeyedRows: createKeyedRowsBlockComponent(owner, {
+      hostBlocks: createKeyedRowHostRuntime(),
+      keyedUpdates: keyedBatchPositionUpdateRuntime
+    })
+  })
+};
+var keyedRowsHostWindowPositionHintedRuntimeFeature = {
+  name: "keyed-rows:host:window-position-hinted",
+  create: (owner) => ({
+    KeyedRows: createKeyedRowsBlockComponent(owner, {
+      hostBlocks: createKeyedRowHostRuntime(),
+      keyedUpdates: keyedWindowPositionUpdateRuntime
+    })
+  })
+};
 var keyedRowsHostReorderHintedRuntimeFeature = {
   name: "keyed-rows:host:reorder-hinted",
   create: (owner) => ({
@@ -4615,6 +6888,24 @@ var keyedRowsHostEveryHintedRuntimeFeature = {
     })
   })
 };
+var keyedRowsHostBatchEveryHintedRuntimeFeature = {
+  name: "keyed-rows:host:batch-every-hinted",
+  create: (owner) => ({
+    KeyedRows: createKeyedRowsBlockComponent(owner, {
+      hostBlocks: createKeyedRowHostRuntime(),
+      keyedUpdates: keyedBatchEveryUpdateRuntime
+    })
+  })
+};
+var keyedRowsHostWindowEveryHintedRuntimeFeature = {
+  name: "keyed-rows:host:window-every-hinted",
+  create: (owner) => ({
+    KeyedRows: createKeyedRowsBlockComponent(owner, {
+      hostBlocks: createKeyedRowHostRuntime(),
+      keyedUpdates: keyedWindowEveryUpdateRuntime
+    })
+  })
+};
 var keyedRowsHostFilterHintedRuntimeFeature = {
   name: "keyed-rows:host:filter-hinted",
   create: (owner) => ({
@@ -4624,6 +6915,42 @@ var keyedRowsHostFilterHintedRuntimeFeature = {
     })
   })
 };
+var keyedRowsHostStructuralAppendHintedRuntimeFeature = {
+  name: "keyed-rows:host:structural-append-hinted",
+  create: (owner) => ({
+    KeyedRows: createKeyedRowsBlockComponent(owner, {
+      hostBlocks: createKeyedRowHostRuntime(),
+      keyedUpdates: keyedWindowEveryStructuralAppendUpdateRuntime
+    })
+  })
+};
+var keyedRowsHostStructuralAppendMapHintedRuntimeFeature = {
+  name: "keyed-rows:host:structural-append-map-hinted",
+  create: (owner) => ({
+    KeyedRows: createKeyedRowsBlockComponent(owner, {
+      hostBlocks: createKeyedRowHostRuntime(),
+      keyedUpdates: keyedWindowEveryStructuralAppendMapUpdateRuntime
+    })
+  })
+};
+var keyedRowsHostStructuralPrependHintedRuntimeFeature = {
+  name: "keyed-rows:host:structural-prepend-hinted",
+  create: (owner) => ({
+    KeyedRows: createKeyedRowsBlockComponent(owner, {
+      hostBlocks: createKeyedRowHostRuntime(),
+      keyedUpdates: keyedCompleteCompatibilityUpdateRuntime
+    })
+  })
+};
+var keyedRowsHostStructuralPrependMapHintedRuntimeFeature = {
+  name: "keyed-rows:host:structural-prepend-map-hinted",
+  create: (owner) => ({
+    KeyedRows: createKeyedRowsBlockComponent(owner, {
+      hostBlocks: createKeyedRowHostRuntime(),
+      keyedUpdates: keyedCompleteStructuralPrependMapUpdateRuntime
+    })
+  })
+};
 var keyedRowsHostPrependHintedRuntimeFeature = {
   name: "keyed-rows:host:prepend-hinted",
   create: (owner) => ({
@@ -4671,6 +6998,26 @@ var keyedRowsCompletePositionHintedRuntimeFeature = {
     })
   })
 };
+var keyedRowsCompleteBatchPositionHintedRuntimeFeature = {
+  name: "keyed-rows:complete:batch-position-hinted",
+  create: (owner) => ({
+    KeyedRows: createKeyedRowsBlockComponent(owner, {
+      conditionals: createKeyedRowConditionalRuntime(),
+      hostBlocks: createKeyedRowHostRuntime(),
+      keyedUpdates: keyedBatchPositionUpdateRuntime
+    })
+  })
+};
+var keyedRowsCompleteWindowPositionHintedRuntimeFeature = {
+  name: "keyed-rows:complete:window-position-hinted",
+  create: (owner) => ({
+    KeyedRows: createKeyedRowsBlockComponent(owner, {
+      conditionals: createKeyedRowConditionalRuntime(),
+      hostBlocks: createKeyedRowHostRuntime(),
+      keyedUpdates: keyedWindowPositionUpdateRuntime
+    })
+  })
+};
 var keyedRowsCompleteReorderHintedRuntimeFeature = {
   name: "keyed-rows:complete:reorder-hinted",
   create: (owner) => ({
@@ -4701,6 +7048,26 @@ var keyedRowsCompleteEveryHintedRuntimeFeature = {
     })
   })
 };
+var keyedRowsCompleteBatchEveryHintedRuntimeFeature = {
+  name: "keyed-rows:complete:batch-every-hinted",
+  create: (owner) => ({
+    KeyedRows: createKeyedRowsBlockComponent(owner, {
+      conditionals: createKeyedRowConditionalRuntime(),
+      hostBlocks: createKeyedRowHostRuntime(),
+      keyedUpdates: keyedBatchEveryUpdateRuntime
+    })
+  })
+};
+var keyedRowsCompleteWindowEveryHintedRuntimeFeature = {
+  name: "keyed-rows:complete:window-every-hinted",
+  create: (owner) => ({
+    KeyedRows: createKeyedRowsBlockComponent(owner, {
+      conditionals: createKeyedRowConditionalRuntime(),
+      hostBlocks: createKeyedRowHostRuntime(),
+      keyedUpdates: keyedWindowEveryUpdateRuntime
+    })
+  })
+};
 var keyedRowsCompleteFilterHintedRuntimeFeature = {
   name: "keyed-rows:complete:filter-hinted",
   create: (owner) => ({
@@ -4711,6 +7078,46 @@ var keyedRowsCompleteFilterHintedRuntimeFeature = {
     })
   })
 };
+var keyedRowsCompleteStructuralAppendHintedRuntimeFeature = {
+  name: "keyed-rows:complete:structural-append-hinted",
+  create: (owner) => ({
+    KeyedRows: createKeyedRowsBlockComponent(owner, {
+      conditionals: createKeyedRowConditionalRuntime(),
+      hostBlocks: createKeyedRowHostRuntime(),
+      keyedUpdates: keyedWindowEveryStructuralAppendUpdateRuntime
+    })
+  })
+};
+var keyedRowsCompleteStructuralAppendMapHintedRuntimeFeature = {
+  name: "keyed-rows:complete:structural-append-map-hinted",
+  create: (owner) => ({
+    KeyedRows: createKeyedRowsBlockComponent(owner, {
+      conditionals: createKeyedRowConditionalRuntime(),
+      hostBlocks: createKeyedRowHostRuntime(),
+      keyedUpdates: keyedWindowEveryStructuralAppendMapUpdateRuntime
+    })
+  })
+};
+var keyedRowsCompleteStructuralPrependHintedRuntimeFeature = {
+  name: "keyed-rows:complete:structural-prepend-hinted",
+  create: (owner) => ({
+    KeyedRows: createKeyedRowsBlockComponent(owner, {
+      conditionals: createKeyedRowConditionalRuntime(),
+      hostBlocks: createKeyedRowHostRuntime(),
+      keyedUpdates: keyedCompleteCompatibilityUpdateRuntime
+    })
+  })
+};
+var keyedRowsCompleteStructuralPrependMapHintedRuntimeFeature = {
+  name: "keyed-rows:complete:structural-prepend-map-hinted",
+  create: (owner) => ({
+    KeyedRows: createKeyedRowsBlockComponent(owner, {
+      conditionals: createKeyedRowConditionalRuntime(),
+      hostBlocks: createKeyedRowHostRuntime(),
+      keyedUpdates: keyedCompleteStructuralPrependMapUpdateRuntime
+    })
+  })
+};
 var keyedRowsCompletePrependHintedRuntimeFeature = {
   name: "keyed-rows:complete:prepend-hinted",
   create: (owner) => ({
@@ -4731,6 +7138,16 @@ var keyedRowsCompleteFilterPrependHintedRuntimeFeature = {
     })
   })
 };
+var keyedRowsCompleteCompatibilityRuntimeFeature = {
+  name: "keyed-rows:complete:compatibility",
+  create: (owner) => ({
+    KeyedRows: createKeyedRowsBlockComponent(owner, {
+      conditionals: createKeyedRowConditionalRuntime(),
+      hostBlocks: createKeyedRowHostRuntime(),
+      keyedUpdates: keyedCompleteStructuralPrependMapUpdateRuntime
+    })
+  })
+};
 var keyedRangesRuntimeFeature = {
   name: "keyed-ranges",
   create: (owner) => ({
@@ -5203,7 +7620,7 @@ var COMPLETE_RUNTIME_FEATURES = [
   hostConditionalRuntimeFeature,
   conditionalRangesRuntimeFeature,
   keyedListRuntimeFeature,
-  keyedRowsCompleteEveryHintedRuntimeFeature,
+  keyedRowsCompleteCompatibilityRuntimeFeature,
   keyedRangesRuntimeFeature,
   mixedRangesRuntimeFeature,
   componentRuntimeFeature
@@ -5219,20 +7636,38 @@ exports.conditionalRuntimeFeature = conditionalRuntimeFeature;
 exports.createCompiledComponent = createCompiledComponent;
 exports.createCompiledComponentWithFeatures = createCompiledComponentWithFeatures;
 exports.createCompilerKeyedArrayAppend = createCompilerKeyedArrayAppend;
+exports.createCompilerKeyedArrayBatchInsert = createCompilerKeyedArrayBatchInsert;
 exports.createCompilerKeyedArrayFilter = createCompilerKeyedArrayFilter;
+exports.createCompilerKeyedArrayMapPipeline = createCompilerKeyedArrayMapPipeline;
+exports.createCompilerKeyedArrayMapReorder = createCompilerKeyedArrayMapReorder;
+exports.createCompilerKeyedArrayMappedStructuralAppend = createCompilerKeyedArrayMappedStructuralAppend;
+exports.createCompilerKeyedArrayMappedStructuralPrepend = createCompilerKeyedArrayMappedStructuralPrepend;
 exports.createCompilerKeyedArrayPositionUpdate = createCompilerKeyedArrayPositionUpdate;
 exports.createCompilerKeyedArrayPrepend = createCompilerKeyedArrayPrepend;
+exports.createCompilerKeyedArrayQueuedMapPipeline = createCompilerKeyedArrayQueuedMapPipeline;
 exports.createCompilerKeyedArrayReorder = createCompilerKeyedArrayReorder;
 exports.createCompilerKeyedArrayRollingWindow = createCompilerKeyedArrayRollingWindow;
 exports.createCompilerKeyedArraySlice = createCompilerKeyedArraySlice;
 exports.createCompilerKeyedArraySort = createCompilerKeyedArraySort;
+exports.createCompilerKeyedArrayStructuralAppend = createCompilerKeyedArrayStructuralAppend;
+exports.createCompilerKeyedArrayStructuralAppendMapPipeline = createCompilerKeyedArrayStructuralAppendMapPipeline;
+exports.createCompilerKeyedArrayStructuralPrepend = createCompilerKeyedArrayStructuralPrepend;
+exports.createCompilerKeyedArrayStructuralPrependMapPipeline = createCompilerKeyedArrayStructuralPrependMapPipeline;
+exports.createCompilerKeyedArrayStructuralReorder = createCompilerKeyedArrayStructuralReorder;
+exports.createCompilerKeyedArrayStructuralSort = createCompilerKeyedArrayStructuralSort;
+exports.createCompilerKeyedArrayWindowReplace = createCompilerKeyedArrayWindowReplace;
 exports.createCompilerKeyedCollectionUpdate = createCompilerKeyedCollectionUpdate;
 exports.createCompilerKeyedMapUpdate = createCompilerKeyedMapUpdate;
+exports.finalizeCompilerKeyedArrayMappedStructuralUpdate = finalizeCompilerKeyedArrayMappedStructuralUpdate;
 exports.hostConditionalRuntimeFeature = hostConditionalRuntimeFeature;
 exports.keyedListRuntimeFeature = keyedListRuntimeFeature;
 exports.keyedRangesRuntimeFeature = keyedRangesRuntimeFeature;
 exports.keyedRowsAllHintedRuntimeFeature = keyedRowsAllHintedRuntimeFeature;
+exports.keyedRowsBatchEveryHintedRuntimeFeature = keyedRowsBatchEveryHintedRuntimeFeature;
+exports.keyedRowsBatchPositionHintedRuntimeFeature = keyedRowsBatchPositionHintedRuntimeFeature;
 exports.keyedRowsCompleteAllHintedRuntimeFeature = keyedRowsCompleteAllHintedRuntimeFeature;
+exports.keyedRowsCompleteBatchEveryHintedRuntimeFeature = keyedRowsCompleteBatchEveryHintedRuntimeFeature;
+exports.keyedRowsCompleteBatchPositionHintedRuntimeFeature = keyedRowsCompleteBatchPositionHintedRuntimeFeature;
 exports.keyedRowsCompleteEveryHintedRuntimeFeature = keyedRowsCompleteEveryHintedRuntimeFeature;
 exports.keyedRowsCompleteFilterHintedRuntimeFeature = keyedRowsCompleteFilterHintedRuntimeFeature;
 exports.keyedRowsCompleteFilterPrependHintedRuntimeFeature = keyedRowsCompleteFilterPrependHintedRuntimeFeature;
@@ -5241,7 +7676,15 @@ exports.keyedRowsCompletePositionHintedRuntimeFeature = keyedRowsCompletePositio
 exports.keyedRowsCompletePrependHintedRuntimeFeature = keyedRowsCompletePrependHintedRuntimeFeature;
 exports.keyedRowsCompleteReorderHintedRuntimeFeature = keyedRowsCompleteReorderHintedRuntimeFeature;
 exports.keyedRowsCompleteRuntimeFeature = keyedRowsCompleteRuntimeFeature;
+exports.keyedRowsCompleteStructuralAppendHintedRuntimeFeature = keyedRowsCompleteStructuralAppendHintedRuntimeFeature;
+exports.keyedRowsCompleteStructuralAppendMapHintedRuntimeFeature = keyedRowsCompleteStructuralAppendMapHintedRuntimeFeature;
+exports.keyedRowsCompleteStructuralPrependHintedRuntimeFeature = keyedRowsCompleteStructuralPrependHintedRuntimeFeature;
+exports.keyedRowsCompleteStructuralPrependMapHintedRuntimeFeature = keyedRowsCompleteStructuralPrependMapHintedRuntimeFeature;
+exports.keyedRowsCompleteWindowEveryHintedRuntimeFeature = keyedRowsCompleteWindowEveryHintedRuntimeFeature;
+exports.keyedRowsCompleteWindowPositionHintedRuntimeFeature = keyedRowsCompleteWindowPositionHintedRuntimeFeature;
 exports.keyedRowsConditionalAllHintedRuntimeFeature = keyedRowsConditionalAllHintedRuntimeFeature;
+exports.keyedRowsConditionalBatchEveryHintedRuntimeFeature = keyedRowsConditionalBatchEveryHintedRuntimeFeature;
+exports.keyedRowsConditionalBatchPositionHintedRuntimeFeature = keyedRowsConditionalBatchPositionHintedRuntimeFeature;
 exports.keyedRowsConditionalEveryHintedRuntimeFeature = keyedRowsConditionalEveryHintedRuntimeFeature;
 exports.keyedRowsConditionalFilterHintedRuntimeFeature = keyedRowsConditionalFilterHintedRuntimeFeature;
 exports.keyedRowsConditionalFilterPrependHintedRuntimeFeature = keyedRowsConditionalFilterPrependHintedRuntimeFeature;
@@ -5250,11 +7693,19 @@ exports.keyedRowsConditionalPositionHintedRuntimeFeature = keyedRowsConditionalP
 exports.keyedRowsConditionalPrependHintedRuntimeFeature = keyedRowsConditionalPrependHintedRuntimeFeature;
 exports.keyedRowsConditionalReorderHintedRuntimeFeature = keyedRowsConditionalReorderHintedRuntimeFeature;
 exports.keyedRowsConditionalRuntimeFeature = keyedRowsConditionalRuntimeFeature;
+exports.keyedRowsConditionalStructuralAppendHintedRuntimeFeature = keyedRowsConditionalStructuralAppendHintedRuntimeFeature;
+exports.keyedRowsConditionalStructuralAppendMapHintedRuntimeFeature = keyedRowsConditionalStructuralAppendMapHintedRuntimeFeature;
+exports.keyedRowsConditionalStructuralPrependHintedRuntimeFeature = keyedRowsConditionalStructuralPrependHintedRuntimeFeature;
+exports.keyedRowsConditionalStructuralPrependMapHintedRuntimeFeature = keyedRowsConditionalStructuralPrependMapHintedRuntimeFeature;
+exports.keyedRowsConditionalWindowEveryHintedRuntimeFeature = keyedRowsConditionalWindowEveryHintedRuntimeFeature;
+exports.keyedRowsConditionalWindowPositionHintedRuntimeFeature = keyedRowsConditionalWindowPositionHintedRuntimeFeature;
 exports.keyedRowsEveryHintedRuntimeFeature = keyedRowsEveryHintedRuntimeFeature;
 exports.keyedRowsFilterHintedRuntimeFeature = keyedRowsFilterHintedRuntimeFeature;
 exports.keyedRowsFilterPrependHintedRuntimeFeature = keyedRowsFilterPrependHintedRuntimeFeature;
 exports.keyedRowsHintedRuntimeFeature = keyedRowsHintedRuntimeFeature;
 exports.keyedRowsHostAllHintedRuntimeFeature = keyedRowsHostAllHintedRuntimeFeature;
+exports.keyedRowsHostBatchEveryHintedRuntimeFeature = keyedRowsHostBatchEveryHintedRuntimeFeature;
+exports.keyedRowsHostBatchPositionHintedRuntimeFeature = keyedRowsHostBatchPositionHintedRuntimeFeature;
 exports.keyedRowsHostEveryHintedRuntimeFeature = keyedRowsHostEveryHintedRuntimeFeature;
 exports.keyedRowsHostFilterHintedRuntimeFeature = keyedRowsHostFilterHintedRuntimeFeature;
 exports.keyedRowsHostFilterPrependHintedRuntimeFeature = keyedRowsHostFilterPrependHintedRuntimeFeature;
@@ -5263,10 +7714,23 @@ exports.keyedRowsHostPositionHintedRuntimeFeature = keyedRowsHostPositionHintedR
 exports.keyedRowsHostPrependHintedRuntimeFeature = keyedRowsHostPrependHintedRuntimeFeature;
 exports.keyedRowsHostReorderHintedRuntimeFeature = keyedRowsHostReorderHintedRuntimeFeature;
 exports.keyedRowsHostRuntimeFeature = keyedRowsHostRuntimeFeature;
+exports.keyedRowsHostStructuralAppendHintedRuntimeFeature = keyedRowsHostStructuralAppendHintedRuntimeFeature;
+exports.keyedRowsHostStructuralAppendMapHintedRuntimeFeature = keyedRowsHostStructuralAppendMapHintedRuntimeFeature;
+exports.keyedRowsHostStructuralPrependHintedRuntimeFeature = keyedRowsHostStructuralPrependHintedRuntimeFeature;
+exports.keyedRowsHostStructuralPrependMapHintedRuntimeFeature = keyedRowsHostStructuralPrependMapHintedRuntimeFeature;
+exports.keyedRowsHostWindowEveryHintedRuntimeFeature = keyedRowsHostWindowEveryHintedRuntimeFeature;
+exports.keyedRowsHostWindowPositionHintedRuntimeFeature = keyedRowsHostWindowPositionHintedRuntimeFeature;
+exports.keyedRowsMapReorderHintedRuntimeFeature = keyedRowsMapReorderHintedRuntimeFeature;
 exports.keyedRowsPositionHintedRuntimeFeature = keyedRowsPositionHintedRuntimeFeature;
 exports.keyedRowsPrependHintedRuntimeFeature = keyedRowsPrependHintedRuntimeFeature;
 exports.keyedRowsReorderHintedRuntimeFeature = keyedRowsReorderHintedRuntimeFeature;
 exports.keyedRowsRuntimeFeature = keyedRowsRuntimeFeature;
+exports.keyedRowsStructuralAppendHintedRuntimeFeature = keyedRowsStructuralAppendHintedRuntimeFeature;
+exports.keyedRowsStructuralAppendMapHintedRuntimeFeature = keyedRowsStructuralAppendMapHintedRuntimeFeature;
+exports.keyedRowsStructuralPrependHintedRuntimeFeature = keyedRowsStructuralPrependHintedRuntimeFeature;
+exports.keyedRowsStructuralPrependMapHintedRuntimeFeature = keyedRowsStructuralPrependMapHintedRuntimeFeature;
+exports.keyedRowsWindowEveryHintedRuntimeFeature = keyedRowsWindowEveryHintedRuntimeFeature;
+exports.keyedRowsWindowPositionHintedRuntimeFeature = keyedRowsWindowPositionHintedRuntimeFeature;
 exports.mixedRangesRuntimeFeature = mixedRangesRuntimeFeature;
 //# sourceMappingURL=compiler-runtime.cjs.map
 //# sourceMappingURL=compiler-runtime.cjs.map