@farm.js/react 0.1.0-beta.8 → 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();
@@ -38,9 +41,11 @@ 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;
@@ -66,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;
@@ -95,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;
@@ -129,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);
@@ -153,14 +292,104 @@ 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);
@@ -204,7 +433,7 @@ 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;
@@ -221,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);
@@ -235,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);
@@ -258,6 +693,187 @@ function createCompilerKeyedArrayAppend(previous, value) {
     return 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 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;
+    COMPILER_KEYED_ARRAY_APPENDS.set(valueTarget, {
+      sourceToken,
+      startIndex,
+      resultLength: value.length,
+      ...structuralUpdate ? { structuralUpdate } : {},
+      ...previousUpdate ? { previous: previousUpdate } : {}
+    });
+    return value;
+  } catch {
+    return value;
+  }
+}
+function createCompilerKeyedArrayMappedStructuralAppend(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 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);
@@ -265,23 +881,187 @@ function createCompilerKeyedArrayPrepend(previous, 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;
+    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, {
-      sourceToken: previousUpdate?.sourceToken || sourceToken,
-      sourceLength,
-      resultLength: value.length,
-      prefixLength,
-      ...previousUpdate ? { previous: previousUpdate } : {}
+      ...prependUpdate,
+      mappedItemSources,
+      mappedItemValues,
+      mappedSurvivorsValidated: true
     });
-    return value;
   } catch {
-    return value;
   }
+  return value;
 }
 function createCompilerKeyedArrayFilter(previous, method, predicate) {
   let canHint = false;
@@ -316,15 +1096,20 @@ function createCompilerKeyedArrayFilter(previous, method, predicate) {
     if (!previousTarget || !valueTarget || !Array.isArray(value) || Object.getPrototypeOf(value) !== NATIVE_ARRAY_PROTOTYPE || visited !== sourceLength || value.length !== sourceLength - removedIndices.length) {
       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: "filter",
       sourceToken: previousUpdate?.sourceToken || sourceToken,
       sourceLength,
       resultLength: value.length,
       removedIndices,
+      ...mappedItemSources ? { mappedItemSources } : {},
       ...previousUpdate ? { previous: previousUpdate } : {}
     });
   } catch {
@@ -353,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,
@@ -363,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) {
@@ -390,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 {
   }
@@ -504,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
@@ -528,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
@@ -546,6 +1371,75 @@ function createCompilerKeyedArraySort(previous, method, ...args) {
   }
   return value;
 }
+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);
@@ -963,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);
@@ -1815,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) {
@@ -2143,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) {
@@ -2699,8 +3596,7 @@ function longestIncreasingSubsequencePositions(sequence) {
   return positions;
 }
 function reorderCompilerKeyedRows(root, instances, sequence, anchor) {
-  const activeElement = root.ownerDocument.activeElement;
-  const restoreFocus = Boolean(activeElement && root.contains(activeElement));
+  const activeElement = compilerFocusedElement(root);
   const stablePositions = longestIncreasingSubsequencePositions(sequence);
   for (let index = instances.length - 1; index >= 0; index -= 1) {
     const instance = instances[index];
@@ -2721,10 +3617,31 @@ function reorderCompilerKeyedRows(root, instances, sequence, anchor) {
       anchor = instance.element;
     }
   }
-  if (restoreFocus && activeElement?.isConnected && activeElement.ownerDocument.activeElement !== activeElement && "focus" in activeElement) {
+  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,
@@ -2742,6 +3659,10 @@ var keyedFilterPrependUpdateRuntime = {
   ...keyedFilterUpdateRuntime,
   prepend: reconcileCompilerKeyedArrayPrepend
 };
+var keyedStructuralPrependUpdateRuntime = {
+  ...keyedFilterPrependUpdateRuntime,
+  prepend: reconcileCompilerKeyedArrayPrependWithStructural
+};
 var keyedPositionUpdateRuntime = {
   ...keyedUpdateRuntime,
   position: reconcileCompilerKeyedArrayPosition
@@ -2758,6 +3679,10 @@ var keyedReorderUpdateRuntime = {
   ...keyedUpdateRuntime,
   reorder: reconcileCompilerKeyedArrayReorder
 };
+var keyedMapReorderUpdateRuntime = {
+  ...keyedUpdateRuntime,
+  reorder: reconcileCompilerKeyedArrayReorderWithMap
+};
 var keyedCompleteUpdateRuntime = {
   ...keyedFilterPrependUpdateRuntime,
   rollingWindow: reconcileCompilerKeyedArrayRollingWindow
@@ -2765,7 +3690,7 @@ var keyedCompleteUpdateRuntime = {
 var keyedEveryUpdateRuntime = {
   ...keyedCompleteUpdateRuntime,
   position: reconcileCompilerKeyedArrayPosition,
-  reorder: reconcileCompilerKeyedArrayReorder
+  reorder: reconcileCompilerKeyedArrayReorderWithMapAndStructural
 };
 var keyedBatchEveryUpdateRuntime = {
   ...keyedEveryUpdateRuntime,
@@ -2775,6 +3700,23 @@ 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;
   if (dependency === void 0) return void 0;
@@ -2824,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;
@@ -2846,28 +3868,243 @@ function reconcileCompilerKeyedArrayAppend(props, dirtyState, collectionToken, i
     for (let index = startIndex; index < finalValue.length; index += 1) {
       const item = finalValue[index];
       const key = keyedRowIdentity(props.rowKey(item, index));
-      if (nextInstances.has(key)) return void 0;
+      if (nextInstances.has(key)) return void 0;
+      const descriptor = props.create(item, index);
+      const instance = {
+        key,
+        element: createCompilerHostElement(root.ownerDocument, descriptor),
+        values: readKeyedRowBindingValues(props, item, index),
+        item,
+        index,
+        conditionalValues: EMPTY_KEYED_ROW_CONDITIONAL_VALUES
+      };
+      appended.push(instance);
+      nextInstances.set(key, instance);
+    }
+  } catch {
+    return void 0;
+  }
+  if (appended.length > 0) {
+    const fragment = root.ownerDocument.createDocumentFragment();
+    for (const instance of appended) fragment.append(instance.element);
+    root.append(fragment);
+  }
+  return nextInstances;
+}
+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;
+  }
+  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 = 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 survivors = [];
+  const knownKeys = new Set(instances.keys());
+  const appended = [];
+  try {
+    for (let index = 0; index < survivorResult.indices.length; index += 1) {
+      const sourceIndex = survivorResult.indices[index];
+      const instance = previousInstances[sourceIndex];
+      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);
+    }
+    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);
+      appended.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();
+  }
+  for (let index = 0; index < survivors.length; index += 1) survivors[index].index = index;
+  if (appended.length > 0) {
+    const fragment = root.ownerDocument.createDocumentFragment();
+    for (const instance of appended) fragment.append(instance.element);
+    root.append(fragment);
+  }
+  return keyedRowInstancesByKey([...survivors, ...appended]);
+}
+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;
+  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 = 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 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 {
+    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);
-      const instance = {
+      appended.push({
         key,
         element: createCompilerHostElement(root.ownerDocument, descriptor),
         values: readKeyedRowBindingValues(props, item, index),
         item,
         index,
         conditionalValues: EMPTY_KEYED_ROW_CONDITIONAL_VALUES
-      };
-      appended.push(instance);
-      nextInstances.set(key, instance);
+      });
     }
   } 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;
+    }
+  }
   if (appended.length > 0) {
     const fragment = root.ownerDocument.createDocumentFragment();
-    for (const instance of appended) fragment.append(instance.element);
+    for (const instance of appended) {
+      fragment.append(instance.element);
+      mutableInstances.set(instance.key, instance);
+    }
     root.append(fragment);
   }
-  return nextInstances;
+  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) {
@@ -2883,14 +4120,18 @@ 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 updates = compilerKeyedArrayRollingWindows(finalValue, collectionToken, instances.size);
+  if (!updates || !Array.isArray(finalValue)) return void 0;
   const previousInstances = [...instances.values()];
-  const retainedLength = update.retainedEnd - update.retainedStart;
+  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 = update.retainedStart + index;
+      const sourceIndex = retainedStart + index;
       const instance = previousInstances[sourceIndex];
       if (!instance || instance.index !== sourceIndex || !Object.is(instance.item, finalValue[index])) {
         return void 0;
@@ -2921,7 +4162,7 @@ function reconcileCompilerKeyedArrayRollingWindow(props, dirtyState, collectionT
   } catch {
     return void 0;
   }
-  for (let index = 0; index < update.retainedStart; index += 1) {
+  for (let index = 0; index < retainedStart; index += 1) {
     previousInstances[index].scope?.cleanup();
     previousInstances[index].element.remove();
   }
@@ -2968,7 +4209,7 @@ function reconcileCompilerKeyedArrayPosition(props, dirtyState, collectionToken,
     for (let index = update.position; index < previousInstances.length; index += 1) {
       previousInstances[index].index = index;
     }
-    return new Map(previousInstances.map((instance) => [instance.key, instance]));
+    return keyedRowInstancesByKey(previousInstances);
   }
   let item;
   let key;
@@ -2999,7 +4240,7 @@ function reconcileCompilerKeyedArrayPosition(props, dirtyState, collectionToken,
     for (let index = update.position + 1; index < previousInstances.length; index += 1) {
       previousInstances[index].index = index;
     }
-    return new Map(previousInstances.map((instance) => [instance.key, instance]));
+    return keyedRowInstancesByKey(previousInstances);
   }
   if (!previous || previous.index !== update.position) return void 0;
   if (key === previous.key) {
@@ -3029,7 +4270,7 @@ 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 reconcileCompilerKeyedArrayBatchInsert(props, dirtyState, collectionToken, instances, root, reactOwnedRows) {
   if (reactOwnedRows || props.hostBlocks || (props.conditionals?.length || 0) > 0 || !props.positionIndexIndependent || props.collectionDependency === void 0) {
@@ -3085,7 +4326,111 @@ function reconcileCompilerKeyedArrayBatchInsert(props, dirtyState, collectionTok
   for (let index = update.position + insertCount; index < previousInstances.length; index += 1) {
     previousInstances[index].index = index;
   }
-  return new Map(previousInstances.map((instance) => [instance.key, instance]));
+  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) {
@@ -3105,9 +4450,68 @@ function reconcileCompilerKeyedArrayWindowReplace(props, dirtyState, collectionT
   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) {
-      if (update2.insertedCount !== update2.removedCount) return void 0;
       for (let index = update2.position; index < update2.position + update2.removedCount; index += 1) {
         touchedIndices.add(index);
       }
@@ -3119,21 +4523,21 @@ function reconcileCompilerKeyedArrayWindowReplace(props, dirtyState, collectionT
         return void 0;
       }
     }
-    const knownKeys2 = new Set(instances.keys());
+    const knownKeys = new Set(instances.keys());
     const incomingKeys2 = /* @__PURE__ */ new Set();
     let replacesRows = false;
-    const prepared = [];
+    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 (knownKeys2.has(key) || incomingKeys2.has(key)) return void 0;
+          if (knownKeys.has(key) || incomingKeys2.has(key)) return void 0;
           incomingKeys2.add(key);
           replacesRows = true;
           const descriptor = props.create(item, index);
-          prepared.push([
+          prepared2.push([
             index,
             instance,
             item,
@@ -3151,12 +4555,12 @@ function reconcileCompilerKeyedArrayWindowReplace(props, dirtyState, collectionT
         }
         const bindingUpdates = prepareKeyedRowBindingUpdates(props, instance, item, index);
         if (!bindingUpdates) return void 0;
-        prepared.push([index, instance, item, bindingUpdates, void 0]);
+        prepared2.push([index, instance, item, bindingUpdates, void 0]);
       }
     } catch {
       return void 0;
     }
-    for (const [index, instance, item, bindingUpdates, replacement] of prepared) {
+    for (const [index, instance, item, bindingUpdates, replacement] of prepared2) {
       if (replacement) {
         instance.scope?.cleanup();
         instance.element.replaceWith(replacement.element);
@@ -3166,7 +4570,7 @@ function reconcileCompilerKeyedArrayWindowReplace(props, dirtyState, collectionT
         instance.item = item;
       }
     }
-    return replacesRows ? new Map(previousInstances.map((instance) => [instance.key, instance])) : instances;
+    return replacesRows ? keyedRowInstancesByKey(previousInstances) : instances;
   }
   const update = updates[0];
   const removedEnd = update.position + update.removedCount;
@@ -3182,21 +4586,17 @@ function reconcileCompilerKeyedArrayWindowReplace(props, dirtyState, collectionT
   if (removed.length !== update.removedCount || removed.some((instance) => instance.element.parentNode !== root) || anchor && anchor.parentNode !== root) {
     return void 0;
   }
-  const incomingItems = [];
-  const incomingKeys = [];
-  try {
-    for (let offset = 0; offset < update.insertedCount; offset += 1) {
-      const index = update.position + offset;
-      const item = finalValue[index];
-      const key = keyedRowIdentity(props.rowKey(item, index));
-      incomingItems.push(item);
-      incomingKeys.push(key);
-    }
-  } catch {
-    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 prepared = [];
+    const prepared2 = [];
     try {
       for (let offset = 0; offset < update.insertedCount; offset += 1) {
         const updates2 = prepareKeyedRowBindingUpdates(
@@ -3206,92 +4606,289 @@ function reconcileCompilerKeyedArrayWindowReplace(props, dirtyState, collectionT
           update.position + offset
         );
         if (!updates2) return void 0;
-        prepared.push(updates2);
+        prepared2.push(updates2);
       }
     } catch {
       return void 0;
     }
     for (let offset = 0; offset < update.insertedCount; offset += 1) {
-      applyPreparedKeyedRowBindingUpdates(props, removed[offset], prepared[offset]);
+      applyPreparedKeyedRowBindingUpdates(props, removed[offset], prepared2[offset]);
       removed[offset].item = incomingItems[offset];
     }
     return instances;
   }
-  if (update.insertedCount === update.removedCount) {
-    const incomingKeySet = new Set(incomingKeys);
-    if (incomingKeySet.size !== incomingKeys.length) return void 0;
-    const removedByKey = new Map(
-      removed.map((instance, offset) => [instance.key, { instance, offset }])
-    );
-    if (incomingKeys.some((key) => removedByKey.has(key))) {
-      const nextWindow = [];
-      const sequence = [];
-      const preparedBindings = [];
-      try {
-        for (let offset = 0; offset < update.insertedCount; offset += 1) {
-          const index = update.position + offset;
-          const item = incomingItems[offset];
-          const key = incomingKeys[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);
+  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;
         }
-      } catch {
-        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 (const instance of removed) {
-        if (incomingKeySet.has(instance.key)) continue;
-        instance.scope?.cleanup();
-        instance.element.remove();
-      }
-      for (let offset = 0; offset < nextWindow.length; offset += 1) {
-        const bindingUpdates = preparedBindings[offset];
-        if (bindingUpdates) {
-          const instance = nextWindow[offset];
-          applyPreparedKeyedRowBindingUpdates(props, instance, bindingUpdates);
-          instance.item = incomingItems[offset];
-          instance.index = update.position + offset;
+      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) {
+        const instance = previousInstances[sourceIndex];
+        if (instance.index !== sourceIndex || instancesByItem.has(instance.item)) return void 0;
+        instancesByItem.set(instance.item, instance);
       }
-      reorderCompilerKeyedRows(root, nextWindow, sequence, anchor || null);
-      previousInstances.splice(update.position, update.removedCount, ...nextWindow);
-      return new Map(previousInstances.map((instance) => [instance.key, instance]));
+      const nextInstances = [];
+      const sequence = [];
+      for (let targetIndex = 0; targetIndex < finalValue.length; targetIndex += 1) {
+        const item = finalValue[targetIndex];
+        const instance = instancesByItem.get(item);
+        if (!instance || !Object.is(instance.item, item)) return void 0;
+        instancesByItem.delete(item);
+        nextInstances.push(instance);
+        sequence.push(instance.index);
+      }
+      if (instancesByItem.size > 0) return void 0;
+      reorderCompilerKeyedRows(root, nextInstances, sequence, null);
+      for (let index = 0; index < nextInstances.length; index += 1) {
+        nextInstances[index].index = index;
+      }
+      return keyedRowInstancesByKey(nextInstances);
+    } catch {
+      return void 0;
+    }
+  }
+  try {
+    for (let targetIndex = 0; targetIndex < previousInstances.length; targetIndex += 1) {
+      const sourceIndex = update.kind === 0 /* Reverse */ ? previousInstances.length - targetIndex - 1 : targetIndex;
+      const instance = previousInstances[sourceIndex];
+      if (instance.index !== sourceIndex || !Object.is(instance.item, finalValue[targetIndex])) {
+        return void 0;
+      }
+    }
+  } catch {
+    return void 0;
+  }
+  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;
+  }
+  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 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) {
+    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 prefixLength = compilerKeyedArrayPrependLength(finalValue, collectionToken, instances.size);
+  if (prefixLength === void 0 || !Array.isArray(finalValue)) return void 0;
+  const previousInstances = [...instances.values()];
+  for (let index = 0; index < previousInstances.length; index += 1) {
+    const instance = previousInstances[index];
+    if (instance.index !== index || !Object.is(instance.item, finalValue[prefixLength + index])) {
+      return void 0;
     }
   }
   const knownKeys = new Set(instances.keys());
-  const incoming = [];
+  const prepended = [];
   try {
-    for (let offset = 0; offset < update.insertedCount; offset += 1) {
-      const index = update.position + offset;
-      const item = incomingItems[offset];
-      const key = incomingKeys[offset];
+    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);
-      incoming.push({
+      prepended.push({
         key,
         element: createCompilerHostElement(root.ownerDocument, descriptor),
         values: readKeyedRowBindingValues(props, item, index),
@@ -3303,29 +4900,18 @@ function reconcileCompilerKeyedArrayWindowReplace(props, dirtyState, collectionT
   } catch {
     return void 0;
   }
-  for (const instance of removed) {
-    instance.scope?.cleanup();
-    instance.element.remove();
-  }
-  if (incoming.length > 0) {
+  if (prepended.length > 0) {
     const fragment = root.ownerDocument.createDocumentFragment();
-    for (const instance of incoming) fragment.append(instance.element);
-    root.insertBefore(fragment, anchor || null);
+    for (const instance of prepended) fragment.append(instance.element);
+    root.insertBefore(fragment, root.firstChild);
   }
-  previousInstances.splice(update.position, update.removedCount, ...incoming);
-  for (let index = update.position + update.insertedCount; index < previousInstances.length; index += 1) {
-    previousInstances[index].index = index;
+  for (let index = 0; index < previousInstances.length; index += 1) {
+    previousInstances[index].index = prefixLength + index;
   }
-  return new Map(previousInstances.map((instance) => [instance.key, instance]));
-}
-function reconcileCompilerKeyedArrayPositionWithBatch(...args) {
-  return reconcileCompilerKeyedArrayBatchInsert(...args) || reconcileCompilerKeyedArrayPosition(...args);
-}
-function reconcileCompilerKeyedArrayPositionWithWindow(...args) {
-  return reconcileCompilerKeyedArrayWindowReplace(...args) || reconcileCompilerKeyedArrayBatchInsert(...args) || reconcileCompilerKeyedArrayPosition(...args);
+  return keyedRowInstancesByKey([...prepended, ...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 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;
@@ -3338,78 +4924,66 @@ function reconcileCompilerKeyedArrayReorder(props, dirtyState, collectionToken,
     return void 0;
   }
   const finalValue = props.items();
-  const update = compilerKeyedArrayReorder(finalValue, collectionToken, instances.size);
-  if (!update || !Array.isArray(finalValue)) return void 0;
-  const previousInstances = [...instances.values()];
-  if (update.kind === "sort") {
-    const instancesByItem = /* @__PURE__ */ new Map();
-    try {
-      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 = [];
-      const sequence = [];
-      for (let targetIndex = 0; targetIndex < finalValue.length; targetIndex += 1) {
-        const item = finalValue[targetIndex];
-        const instance = instancesByItem.get(item);
-        if (!instance || !Object.is(instance.item, item)) return void 0;
-        instancesByItem.delete(item);
-        nextInstances.push(instance);
-        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;
-      }
-      if (restoreFocus2 && activeElement2?.isConnected && activeElement2.ownerDocument.activeElement !== activeElement2 && "focus" in activeElement2) {
-        activeElement2.focus({ preventScroll: true });
-      }
-      return new Map(nextInstances.map((instance) => [instance.key, instance]));
-    } catch {
-      return void 0;
-    }
+  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 sourceIndex = 0; sourceIndex < previousInstances.length; sourceIndex += 1) {
+    for (let index = 0; index < survivorResult.indices.length; index += 1) {
+      const sourceIndex = survivorResult.indices[index];
       const instance = previousInstances[sourceIndex];
-      const targetIndex = previousInstances.length - sourceIndex - 1;
-      if (instance.index !== sourceIndex || !Object.is(instance.item, finalValue[targetIndex])) {
+      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 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;
-  }
-  previousInstances.reverse();
+  const survivorSet = new Set(survivorResult.indices);
   for (let index = 0; index < previousInstances.length; index += 1) {
-    previousInstances[index].index = index;
+    if (survivorSet.has(index)) continue;
+    previousInstances[index].scope?.cleanup();
+    previousInstances[index].element.remove();
   }
-  if (restoreFocus && activeElement?.isConnected && activeElement.ownerDocument.activeElement !== activeElement && "focus" in activeElement) {
-    activeElement.focus({ preventScroll: true });
+  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 new Map(previousInstances.map((instance) => [instance.key, instance]));
+  return keyedRowInstancesByKey([...prepended, ...survivors]);
 }
-function reconcileCompilerKeyedArrayPrepend(props, dirtyState, collectionToken, instances, root, reactOwnedRows) {
-  if (reactOwnedRows || props.hostBlocks || (props.conditionals?.length || 0) > 0 || !props.prependIndexIndependent || props.collectionDependency === void 0) {
+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;
@@ -3422,19 +4996,78 @@ function reconcileCompilerKeyedArrayPrepend(props, dirtyState, collectionToken,
     return void 0;
   }
   const finalValue = props.items();
-  const prefixLength = compilerKeyedArrayPrependLength(finalValue, collectionToken, instances.size);
-  if (prefixLength === void 0 || !Array.isArray(finalValue)) return void 0;
+  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()];
-  for (let index = 0; index < previousInstances.length; index += 1) {
-    const instance = previousInstances[index];
-    if (instance.index !== index || !Object.is(instance.item, finalValue[prefixLength + index])) {
-      return void 0;
-    }
-  }
+  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 {
-    for (let index = 0; index < prefixLength; index += 1) {
+    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;
@@ -3452,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) {
@@ -3507,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 {
@@ -3681,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?.();
@@ -3714,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;
@@ -3871,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) {
@@ -4382,7 +6052,7 @@ function createKeyedRowsBlockComponent(owner, options = {}) {
       } else {
         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);
@@ -4899,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) => ({
@@ -4939,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) => ({
@@ -4951,7 +6661,7 @@ var keyedRowsFilterPrependHintedRuntimeFeature = {
   name: "keyed-rows:filter-prepend-hinted",
   create: (owner) => ({
     KeyedRows: createKeyedRowsBlockComponent(owner, {
-      keyedUpdates: keyedFilterPrependUpdateRuntime
+      keyedUpdates: keyedStructuralPrependUpdateRuntime
     })
   })
 };
@@ -5053,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) => ({
@@ -5169,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) => ({
@@ -5296,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) => ({
@@ -5316,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) => ({
@@ -5788,7 +7620,7 @@ var COMPLETE_RUNTIME_FEATURES = [
   hostConditionalRuntimeFeature,
   conditionalRangesRuntimeFeature,
   keyedListRuntimeFeature,
-  keyedRowsCompleteWindowEveryHintedRuntimeFeature,
+  keyedRowsCompleteCompatibilityRuntimeFeature,
   keyedRangesRuntimeFeature,
   mixedRangesRuntimeFeature,
   componentRuntimeFeature
@@ -5806,15 +7638,27 @@ exports.createCompiledComponentWithFeatures = createCompiledComponentWithFeature
 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;
@@ -5832,6 +7676,10 @@ 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;
@@ -5845,6 +7693,10 @@ 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;
@@ -5862,12 +7714,21 @@ 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;