@farm.js/react 0.1.0-beta.5 → 0.1.0-beta.6

package/dist/vite.mjs

@@ -66,14 +66,46 @@ var COMPILER_RUNTIME_FEATURE_EXPORTS = {
   "conditional-ranges": "conditionalRangesRuntimeFeature",
   "keyed-list": "keyedListRuntimeFeature",
   "keyed-rows": "keyedRowsRuntimeFeature",
+  "keyed-rows-hinted": "keyedRowsHintedRuntimeFeature",
+  "keyed-rows-position-hinted": "keyedRowsPositionHintedRuntimeFeature",
+  "keyed-rows-reorder-hinted": "keyedRowsReorderHintedRuntimeFeature",
+  "keyed-rows-all-hinted": "keyedRowsAllHintedRuntimeFeature",
+  "keyed-rows-every-hinted": "keyedRowsEveryHintedRuntimeFeature",
+  "keyed-rows-filter-hinted": "keyedRowsFilterHintedRuntimeFeature",
+  "keyed-rows-prepend-hinted": "keyedRowsPrependHintedRuntimeFeature",
+  "keyed-rows-filter-prepend-hinted": "keyedRowsFilterPrependHintedRuntimeFeature",
   "keyed-rows-conditional": "keyedRowsConditionalRuntimeFeature",
+  "keyed-rows-conditional-hinted": "keyedRowsConditionalHintedRuntimeFeature",
+  "keyed-rows-conditional-position-hinted": "keyedRowsConditionalPositionHintedRuntimeFeature",
+  "keyed-rows-conditional-reorder-hinted": "keyedRowsConditionalReorderHintedRuntimeFeature",
+  "keyed-rows-conditional-all-hinted": "keyedRowsConditionalAllHintedRuntimeFeature",
+  "keyed-rows-conditional-every-hinted": "keyedRowsConditionalEveryHintedRuntimeFeature",
+  "keyed-rows-conditional-filter-hinted": "keyedRowsConditionalFilterHintedRuntimeFeature",
+  "keyed-rows-conditional-prepend-hinted": "keyedRowsConditionalPrependHintedRuntimeFeature",
+  "keyed-rows-conditional-filter-prepend-hinted": "keyedRowsConditionalFilterPrependHintedRuntimeFeature",
   "keyed-rows-host": "keyedRowsHostRuntimeFeature",
+  "keyed-rows-host-hinted": "keyedRowsHostHintedRuntimeFeature",
+  "keyed-rows-host-position-hinted": "keyedRowsHostPositionHintedRuntimeFeature",
+  "keyed-rows-host-reorder-hinted": "keyedRowsHostReorderHintedRuntimeFeature",
+  "keyed-rows-host-all-hinted": "keyedRowsHostAllHintedRuntimeFeature",
+  "keyed-rows-host-every-hinted": "keyedRowsHostEveryHintedRuntimeFeature",
+  "keyed-rows-host-filter-hinted": "keyedRowsHostFilterHintedRuntimeFeature",
+  "keyed-rows-host-prepend-hinted": "keyedRowsHostPrependHintedRuntimeFeature",
+  "keyed-rows-host-filter-prepend-hinted": "keyedRowsHostFilterPrependHintedRuntimeFeature",
   "keyed-rows-complete": "keyedRowsCompleteRuntimeFeature",
+  "keyed-rows-complete-hinted": "keyedRowsCompleteHintedRuntimeFeature",
+  "keyed-rows-complete-position-hinted": "keyedRowsCompletePositionHintedRuntimeFeature",
+  "keyed-rows-complete-reorder-hinted": "keyedRowsCompleteReorderHintedRuntimeFeature",
+  "keyed-rows-complete-all-hinted": "keyedRowsCompleteAllHintedRuntimeFeature",
+  "keyed-rows-complete-every-hinted": "keyedRowsCompleteEveryHintedRuntimeFeature",
+  "keyed-rows-complete-filter-hinted": "keyedRowsCompleteFilterHintedRuntimeFeature",
+  "keyed-rows-complete-prepend-hinted": "keyedRowsCompletePrependHintedRuntimeFeature",
+  "keyed-rows-complete-filter-prepend-hinted": "keyedRowsCompleteFilterPrependHintedRuntimeFeature",
   "keyed-ranges": "keyedRangesRuntimeFeature",
   "mixed-ranges": "mixedRangesRuntimeFeature",
   component: "componentRuntimeFeature"
 };
-function runtimeFeaturesForPlans(plans) {
+function runtimeFeaturesForPlans(plans, keyedMapUpdateHints, keyedArrayFilterHints, keyedArrayPrependHints, keyedArrayPositionHints, keyedArrayReorderHints, keyedArrayRollingWindowHints) {
   const features = /* @__PURE__ */ new Set();
   let keyedRowsHaveConditionals = false;
   let keyedRowsHaveHostBlocks = false;
@@ -88,9 +120,10 @@ function runtimeFeaturesForPlans(plans) {
     }
   }
   if (plans.some((plan) => plan.kind === "keyed-rows")) {
-    features.add(
-      keyedRowsHaveConditionals && keyedRowsHaveHostBlocks ? "keyed-rows-complete" : keyedRowsHaveConditionals ? "keyed-rows-conditional" : keyedRowsHaveHostBlocks ? "keyed-rows-host" : "keyed-rows"
-    );
+    const keyedRowsFeature = keyedRowsHaveConditionals && keyedRowsHaveHostBlocks ? "keyed-rows-complete" : keyedRowsHaveConditionals ? "keyed-rows-conditional" : keyedRowsHaveHostBlocks ? "keyed-rows-host" : "keyed-rows";
+    const arrayRangeHints = keyedArrayRollingWindowHints || keyedArrayFilterHints || keyedArrayPrependHints;
+    const hintSuffix = keyedArrayPositionHints && (arrayRangeHints || keyedArrayReorderHints) || keyedArrayReorderHints && arrayRangeHints ? "-every-hinted" : keyedArrayRollingWindowHints ? "-all-hinted" : keyedArrayPositionHints ? "-position-hinted" : keyedArrayReorderHints ? "-reorder-hinted" : keyedArrayFilterHints && keyedArrayPrependHints ? "-filter-prepend-hinted" : keyedArrayFilterHints ? "-filter-hinted" : keyedArrayPrependHints ? "-prepend-hinted" : keyedMapUpdateHints ? "-hinted" : "";
+    features.add(`${keyedRowsFeature}${hintSuffix}`);
   }
   return [...features].sort();
 }
@@ -139,6 +172,174 @@ function referencesIdentifier(expression, name) {
   });
   return referenced;
 }
+function rewriteFreeIdentifierNames(expression, replacements) {
+  if (replacements.size === 0) return cloneExpression(expression);
+  const file = expressionFile(cloneExpression(expression));
+  traverse(file, {
+    ReferencedIdentifier(path) {
+      if (path.scope.hasBinding(path.node.name)) return;
+      const replacement = replacements.get(path.node.name);
+      if (!replacement) return;
+      path.replaceWith(types.cloneNode(replacement));
+      path.skip();
+    }
+  });
+  return file.program.body[0].expression;
+}
+function keyedIdentityTarget(binding, keyCallback, renderCallback, reactiveByValue, structureDependencies) {
+  const dependencies = binding.dependencies || [];
+  if (dependencies.length !== 1 || structureDependencies.has(dependencies[0])) return void 0;
+  const keyExpression = returnedExpression(keyCallback);
+  const keyItem = keyCallback.params[0];
+  const rowItem = renderCallback.params[0];
+  if (!keyExpression || !types.isIdentifier(keyItem) || !types.isIdentifier(rowItem)) return void 0;
+  const replacements = /* @__PURE__ */ new Map([[keyItem.name, rowItem]]);
+  const keyIndex = keyCallback.params[1];
+  const rowIndex = renderCallback.params[1];
+  if (types.isIdentifier(keyIndex) && types.isIdentifier(rowIndex)) {
+    replacements.set(keyIndex.name, rowIndex);
+  }
+  const rowKeyExpression = rewriteFreeIdentifierNames(keyExpression, replacements);
+  const file = expressionFile(cloneExpression(binding.value));
+  let target;
+  let valid = true;
+  let comparisons = 0;
+  traverse(file, {
+    ReferencedIdentifier(path) {
+      if (!valid || path.scope.hasBinding(path.node.name)) return;
+      const reactive = reactiveByValue.get(path.node.name);
+      if (!reactive) return;
+      if (reactive.index !== dependencies[0] || target && target !== reactive) {
+        valid = false;
+        path.stop();
+        return;
+      }
+      const parent = path.parentPath;
+      if (!parent.isBinaryExpression() || parent.node.operator !== "===" && parent.node.operator !== "!==") {
+        valid = false;
+        path.stop();
+        return;
+      }
+      const other = parent.node.left === path.node ? parent.node.right : parent.node.left;
+      if (!types.isExpression(other) || !types.isNodesEquivalent(other, rowKeyExpression)) {
+        valid = false;
+        path.stop();
+        return;
+      }
+      target = reactive;
+      comparisons += 1;
+    }
+  });
+  return valid && target && comparisons > 0 ? { dependency: target.index, value: types.identifier(target.valueName) } : void 0;
+}
+function isPotentialKeyedMembershipCall(expression, reactiveByValue) {
+  if (expression.arguments.length !== 1 || !types.isExpression(expression.arguments[0]) || !types.isMemberExpression(expression.callee) || expression.callee.computed || !types.isIdentifier(expression.callee.object) || !types.isIdentifier(expression.callee.property, { name: "has" })) {
+    return false;
+  }
+  const reactive = reactiveByValue.get(expression.callee.object.name);
+  return Boolean(reactive?.setterName);
+}
+function containsPotentialKeyedMembershipCall(expression, reactiveByValue) {
+  let found = false;
+  traverse(expressionFile(cloneExpression(expression)), {
+    CallExpression(path) {
+      if (!isPotentialKeyedMembershipCall(path.node, reactiveByValue)) return;
+      found = true;
+      path.stop();
+    }
+  });
+  return found;
+}
+function isPotentialKeyedMapLookupCall(expression, reactiveByValue) {
+  if (expression.arguments.length !== 1 || !types.isExpression(expression.arguments[0]) || !types.isMemberExpression(expression.callee) || expression.callee.computed || !types.isIdentifier(expression.callee.object) || !types.isIdentifier(expression.callee.property, { name: "get" })) {
+    return false;
+  }
+  const reactive = reactiveByValue.get(expression.callee.object.name);
+  return Boolean(reactive?.setterName);
+}
+function containsPotentialKeyedMapLookupCall(expression, reactiveByValue) {
+  let found = false;
+  traverse(expressionFile(cloneExpression(expression)), {
+    CallExpression(path) {
+      if (!isPotentialKeyedMapLookupCall(path.node, reactiveByValue)) return;
+      found = true;
+      path.stop();
+    }
+  });
+  return found;
+}
+function keyedMembershipTarget(binding, keyCallback, renderCallback, reactiveByValue, structureDependencies) {
+  const dependencies = binding.dependencies || [];
+  if (dependencies.length !== 1 || structureDependencies.has(dependencies[0])) return void 0;
+  const keyExpression = returnedExpression(keyCallback);
+  const keyItem = keyCallback.params[0];
+  const rowItem = renderCallback.params[0];
+  if (!keyExpression || !types.isIdentifier(keyItem) || !types.isIdentifier(rowItem)) return void 0;
+  const replacements = /* @__PURE__ */ new Map([[keyItem.name, rowItem]]);
+  const keyIndex = keyCallback.params[1];
+  const rowIndex = renderCallback.params[1];
+  if (types.isIdentifier(keyIndex) && types.isIdentifier(rowIndex)) {
+    replacements.set(keyIndex.name, rowIndex);
+  }
+  const rowKeyExpression = rewriteFreeIdentifierNames(keyExpression, replacements);
+  const file = expressionFile(cloneExpression(binding.value));
+  let target;
+  let valid = true;
+  let calls = 0;
+  traverse(file, {
+    ReferencedIdentifier(path) {
+      if (!valid || path.scope.hasBinding(path.node.name)) return;
+      const reactive = reactiveByValue.get(path.node.name);
+      if (!reactive) return;
+      const member = path.parentPath;
+      const call = member.parentPath;
+      if (!reactive.setterName || reactive.index !== dependencies[0] || target && target !== reactive || !member.isMemberExpression() || member.node.object !== path.node || member.node.computed || !types.isIdentifier(member.node.property, { name: "has" }) || !call || !call.isCallExpression() || call.node.callee !== member.node || call.node.arguments.length !== 1 || !types.isExpression(call.node.arguments[0]) || !types.isNodesEquivalent(call.node.arguments[0], rowKeyExpression)) {
+        valid = false;
+        path.stop();
+        return;
+      }
+      target = reactive;
+      calls += 1;
+    }
+  });
+  return valid && target && calls > 0 ? { dependency: target.index, value: types.identifier(target.valueName) } : void 0;
+}
+function keyedMapLookupTarget(binding, keyCallback, renderCallback, reactiveByValue, structureDependencies) {
+  const dependencies = binding.dependencies || [];
+  if (dependencies.length !== 1 || structureDependencies.has(dependencies[0])) return void 0;
+  const keyExpression = returnedExpression(keyCallback);
+  const keyItem = keyCallback.params[0];
+  const rowItem = renderCallback.params[0];
+  if (!keyExpression || !types.isIdentifier(keyItem) || !types.isIdentifier(rowItem)) return void 0;
+  const replacements = /* @__PURE__ */ new Map([[keyItem.name, rowItem]]);
+  const keyIndex = keyCallback.params[1];
+  const rowIndex = renderCallback.params[1];
+  if (types.isIdentifier(keyIndex) && types.isIdentifier(rowIndex)) {
+    replacements.set(keyIndex.name, rowIndex);
+  }
+  const rowKeyExpression = rewriteFreeIdentifierNames(keyExpression, replacements);
+  const file = expressionFile(cloneExpression(binding.value));
+  let target;
+  let valid = true;
+  let calls = 0;
+  traverse(file, {
+    ReferencedIdentifier(path) {
+      if (!valid || path.scope.hasBinding(path.node.name)) return;
+      const reactive = reactiveByValue.get(path.node.name);
+      if (!reactive) return;
+      const member = path.parentPath;
+      const call = member.parentPath;
+      if (!reactive.setterName || reactive.index !== dependencies[0] || target && target !== reactive || !member.isMemberExpression() || member.node.object !== path.node || member.node.computed || !types.isIdentifier(member.node.property, { name: "get" }) || !call || !call.isCallExpression() || call.node.callee !== member.node || call.node.arguments.length !== 1 || !types.isExpression(call.node.arguments[0]) || !types.isNodesEquivalent(call.node.arguments[0], rowKeyExpression)) {
+        valid = false;
+        path.stop();
+        return;
+      }
+      target = reactive;
+      calls += 1;
+    }
+  });
+  return valid && target && calls > 0 ? { dependency: target.index, value: types.identifier(target.valueName) } : void 0;
+}
 function collectReferencedLocals(expression, names) {
   const references = /* @__PURE__ */ new Set();
   traverse(expressionFile(cloneExpression(expression)), {
@@ -239,7 +440,9 @@ function rewriteHandlerAccess(root, handlersByName) {
       path.skip();
     }
   });
-  return reason ? { reason } : { root: file.program.body[0].expression };
+  return reason ? { reason } : {
+    root: file.program.body[0].expression
+  };
 }
 function isSafeCompilerCall(expression, safeGlobals) {
   if (types.isIdentifier(expression.callee)) {
@@ -247,7 +450,7 @@ function isSafeCompilerCall(expression, safeGlobals) {
   }
   return types.isMemberExpression(expression.callee) && !expression.callee.computed && types.isIdentifier(expression.callee.object, { name: "Math" }) && safeGlobals.has("Math") && types.isIdentifier(expression.callee.property) && SAFE_MATH_CALLS.has(expression.callee.property.name);
 }
-function validateDerivedExpression(expression, safeGlobals) {
+function validateDerivedExpression(expression, safeGlobals, additionalSafeCall) {
   let unsupported;
   const reject = (reason, path) => {
     unsupported = reason;
@@ -258,7 +461,9 @@ function validateDerivedExpression(expression, safeGlobals) {
     AssignmentExpression: (path) => reject("assignments", path),
     AwaitExpression: (path) => reject("await expressions", path),
     CallExpression(path) {
-      if (!isSafeCompilerCall(path.node, safeGlobals)) reject("function calls", path);
+      if (!isSafeCompilerCall(path.node, safeGlobals) && !additionalSafeCall?.(path.node)) {
+        reject("function calls", path);
+      }
     },
     ClassExpression: (path) => reject("class expressions", path),
     Function: (path) => reject("function expressions", path),
@@ -298,6 +503,879 @@ function validateSetterUsage(root, statesBySetter) {
   });
   return reason;
 }
+function isUnchangedMapItem(expression, item) {
+  return types.isIdentifier(expression, { name: item.name });
+}
+function isSafeKeyedMapReplacement(expression, item, safeGlobals) {
+  if (!types.isObjectExpression(expression)) return false;
+  let spreadsItem = false;
+  for (const property of expression.properties) {
+    if (types.isSpreadElement(property)) {
+      if (!types.isIdentifier(property.argument, { name: item.name })) return false;
+      spreadsItem = true;
+      continue;
+    }
+    if (!types.isObjectProperty(property) || property.computed || !types.isExpression(property.value)) {
+      return false;
+    }
+    if (validateDerivedExpression(property.value, safeGlobals)) return false;
+  }
+  return spreadsItem;
+}
+function isSafeKeyedMapResult(expression, item, safeGlobals) {
+  if (!types.isConditionalExpression(expression)) return false;
+  if (validateDerivedExpression(expression.test, safeGlobals)) return false;
+  return isUnchangedMapItem(expression.consequent, item) && isSafeKeyedMapReplacement(expression.alternate, item, safeGlobals) || isUnchangedMapItem(expression.alternate, item) && isSafeKeyedMapReplacement(expression.consequent, item, safeGlobals);
+}
+function rewriteKeyedMapUpdateHints(root, hintedStateIndices, statesBySetter, helperIdentifier, safeGlobals) {
+  if (hintedStateIndices.size === 0) return { root: types.cloneNode(root, true), count: 0 };
+  const file = expressionFile(types.cloneNode(root, true));
+  let count = 0;
+  traverse(file, {
+    CallExpression(path) {
+      const callee = path.get("callee");
+      if (!callee.isIdentifier() || callee.scope.hasBinding(callee.node.name)) return;
+      const state = statesBySetter.get(callee.node.name);
+      if (!state || !hintedStateIndices.has(state.index) || path.node.arguments.length !== 1) {
+        return;
+      }
+      const updater = path.node.arguments[0];
+      if (!types.isArrowFunctionExpression(updater) || updater.async || updater.generator || updater.params.length !== 1 || !types.isIdentifier(updater.params[0]) || !types.isCallExpression(updater.body) || !types.isMemberExpression(updater.body.callee) || updater.body.callee.computed || !types.isIdentifier(updater.body.callee.object, {
+        name: updater.params[0].name
+      }) || !types.isIdentifier(updater.body.callee.property, { name: "map" })) {
+        return;
+      }
+      const callback = updater.body.arguments[0];
+      if (!types.isArrowFunctionExpression(callback) || callback.async || callback.generator || callback.params.length === 0 || callback.params.length > 3 || callback.params.some((parameter) => !types.isIdentifier(parameter)) || !types.isExpression(callback.body)) {
+        return;
+      }
+      const item = callback.params[0];
+      if (!isSafeKeyedMapResult(callback.body, item, safeGlobals)) return;
+      const changedIndices = path.scope.generateUidIdentifier("farmChangedIndices");
+      const mappedItem = path.scope.generateUidIdentifier("farmMappedItem");
+      const nextValue = path.scope.generateUidIdentifier("farmNextItems");
+      const index = types.isIdentifier(callback.params[1]) ? types.cloneNode(callback.params[1]) : path.scope.generateUidIdentifier("farmMapIndex");
+      const wrappedCallback = types.cloneNode(callback, true);
+      if (wrappedCallback.params.length === 1) wrappedCallback.params.push(types.cloneNode(index));
+      wrappedCallback.body = types.blockStatement([
+        types.variableDeclaration("const", [
+          types.variableDeclarator(types.cloneNode(mappedItem), types.cloneNode(callback.body, true))
+        ]),
+        types.ifStatement(
+          types.binaryExpression("!==", types.cloneNode(mappedItem), types.cloneNode(item)),
+          types.expressionStatement(
+            types.callExpression(
+              types.memberExpression(types.cloneNode(changedIndices), types.identifier("push")),
+              [types.cloneNode(index)]
+            )
+          )
+        ),
+        types.returnStatement(types.cloneNode(mappedItem))
+      ]);
+      const mapCall = types.cloneNode(updater.body, true);
+      mapCall.arguments[0] = wrappedCallback;
+      const previous = types.cloneNode(updater.params[0]);
+      path.node.arguments[0] = types.arrowFunctionExpression(
+        [types.cloneNode(previous)],
+        types.blockStatement([
+          types.variableDeclaration("const", [
+            types.variableDeclarator(types.cloneNode(changedIndices), types.arrayExpression([]))
+          ]),
+          types.variableDeclaration("const", [types.variableDeclarator(types.cloneNode(nextValue), mapCall)]),
+          types.returnStatement(
+            types.callExpression(types.cloneNode(helperIdentifier), [
+              types.cloneNode(previous),
+              types.cloneNode(nextValue),
+              types.cloneNode(changedIndices)
+            ])
+          )
+        ])
+      );
+      count += 1;
+      path.skip();
+    }
+  });
+  return {
+    root: file.program.body[0].expression,
+    count
+  };
+}
+function rewriteKeyedArrayAppendHints(root, hintedStateIndices, statesBySetter, helperIdentifier, safeGlobals) {
+  if (hintedStateIndices.size === 0) return { root: types.cloneNode(root, true), count: 0 };
+  const file = expressionFile(types.cloneNode(root, true));
+  let count = 0;
+  traverse(file, {
+    CallExpression(path) {
+      const callee = path.get("callee");
+      if (!callee.isIdentifier() || callee.scope.hasBinding(callee.node.name)) return;
+      const state = statesBySetter.get(callee.node.name);
+      if (!state || !hintedStateIndices.has(state.index) || path.node.arguments.length !== 1) {
+        return;
+      }
+      const updater = path.node.arguments[0];
+      if (!types.isArrowFunctionExpression(updater) || updater.async || updater.generator || updater.params.length !== 1 || !types.isIdentifier(updater.params[0]) || !types.isArrayExpression(updater.body) || updater.body.elements.length < 2 || updater.body.elements.some((element) => element === null) || !types.isSpreadElement(updater.body.elements[0]) || !types.isIdentifier(updater.body.elements[0].argument, {
+        name: updater.params[0].name
+      })) {
+        return;
+      }
+      const safeAppendValue = (value) => {
+        if (types.isArrayExpression(value)) {
+          return value.elements.every(
+            (element) => element !== null && !types.isJSXNamespacedName(element) && !types.isArgumentPlaceholder(element) && safeAppendValue(types.isSpreadElement(element) ? element.argument : element)
+          );
+        }
+        if (types.isObjectExpression(value)) {
+          return value.properties.every((property) => {
+            if (types.isSpreadElement(property)) return safeAppendValue(property.argument);
+            if (!types.isObjectProperty(property) || !types.isExpression(property.value)) return false;
+            return (!property.computed || types.isExpression(property.key) && safeAppendValue(property.key)) && safeAppendValue(property.value);
+          });
+        }
+        return validateDerivedExpression(value, safeGlobals) === void 0;
+      };
+      if (updater.body.elements.slice(1).some((element) => {
+        if (!element || types.isJSXNamespacedName(element) || types.isArgumentPlaceholder(element)) {
+          return true;
+        }
+        return !safeAppendValue(types.isSpreadElement(element) ? element.argument : element);
+      })) {
+        return;
+      }
+      const previous = types.cloneNode(updater.params[0]);
+      const nextValue = path.scope.generateUidIdentifier("farmNextItems");
+      path.node.arguments[0] = types.arrowFunctionExpression(
+        [types.cloneNode(previous)],
+        types.blockStatement([
+          types.variableDeclaration("const", [
+            types.variableDeclarator(types.cloneNode(nextValue), types.cloneNode(updater.body, true))
+          ]),
+          types.returnStatement(
+            types.callExpression(types.cloneNode(helperIdentifier), [
+              types.cloneNode(previous),
+              types.cloneNode(nextValue)
+            ])
+          )
+        ])
+      );
+      count += 1;
+      path.skip();
+    }
+  });
+  return {
+    root: file.program.body[0].expression,
+    count
+  };
+}
+function rewriteKeyedArrayPrependHints(root, hintedStateIndices, statesBySetter, helperIdentifier, safeGlobals) {
+  if (hintedStateIndices.size === 0) {
+    return { root: types.cloneNode(root, true), count: 0, stateIndices: /* @__PURE__ */ new Set() };
+  }
+  const file = expressionFile(types.cloneNode(root, true));
+  const stateIndices = /* @__PURE__ */ new Set();
+  let count = 0;
+  traverse(file, {
+    CallExpression(path) {
+      const callee = path.get("callee");
+      if (!callee.isIdentifier() || callee.scope.hasBinding(callee.node.name)) return;
+      const state = statesBySetter.get(callee.node.name);
+      if (!state || !hintedStateIndices.has(state.index) || path.node.arguments.length !== 1) {
+        return;
+      }
+      const updater = path.node.arguments[0];
+      if (!types.isArrowFunctionExpression(updater) || updater.async || updater.generator || updater.params.length !== 1 || !types.isIdentifier(updater.params[0]) || !types.isArrayExpression(updater.body) || updater.body.elements.length < 2 || updater.body.elements.some((element) => element === null)) {
+        return;
+      }
+      const suffix = updater.body.elements[updater.body.elements.length - 1];
+      if (!types.isSpreadElement(suffix) || !types.isIdentifier(suffix.argument, { name: updater.params[0].name })) {
+        return;
+      }
+      const safePrependValue = (value) => {
+        if (types.isArrayExpression(value)) {
+          return value.elements.every(
+            (element) => element !== null && !types.isJSXNamespacedName(element) && !types.isArgumentPlaceholder(element) && safePrependValue(types.isSpreadElement(element) ? element.argument : element)
+          );
+        }
+        if (types.isObjectExpression(value)) {
+          return value.properties.every((property) => {
+            if (types.isSpreadElement(property)) return safePrependValue(property.argument);
+            if (!types.isObjectProperty(property) || !types.isExpression(property.value)) return false;
+            return (!property.computed || types.isExpression(property.key) && safePrependValue(property.key)) && safePrependValue(property.value);
+          });
+        }
+        return validateDerivedExpression(value, safeGlobals) === void 0;
+      };
+      if (updater.body.elements.slice(0, -1).some((element) => {
+        if (!element || types.isJSXNamespacedName(element) || types.isArgumentPlaceholder(element)) {
+          return true;
+        }
+        return !safePrependValue(types.isSpreadElement(element) ? element.argument : element);
+      })) {
+        return;
+      }
+      const previous = types.cloneNode(updater.params[0]);
+      const nextValue = path.scope.generateUidIdentifier("farmNextItems");
+      path.node.arguments[0] = types.arrowFunctionExpression(
+        [types.cloneNode(previous)],
+        types.blockStatement([
+          types.variableDeclaration("const", [
+            types.variableDeclarator(types.cloneNode(nextValue), types.cloneNode(updater.body, true))
+          ]),
+          types.returnStatement(
+            types.callExpression(types.cloneNode(helperIdentifier), [
+              types.cloneNode(previous),
+              types.cloneNode(nextValue)
+            ])
+          )
+        ])
+      );
+      count += 1;
+      stateIndices.add(state.index);
+      path.skip();
+    }
+  });
+  return {
+    root: file.program.body[0].expression,
+    count,
+    stateIndices
+  };
+}
+function rewriteKeyedArrayRollingWindowHints(root, hintedStateIndices, statesBySetter, sliceHelperIdentifier, rollingWindowHelperIdentifier, safeGlobals) {
+  if (hintedStateIndices.size === 0) {
+    return { root: types.cloneNode(root, true), count: 0, stateIndices: /* @__PURE__ */ new Set() };
+  }
+  const file = expressionFile(types.cloneNode(root, true));
+  const stateIndices = /* @__PURE__ */ new Set();
+  let count = 0;
+  traverse(file, {
+    CallExpression(path) {
+      const callee = path.get("callee");
+      if (!callee.isIdentifier() || callee.scope.hasBinding(callee.node.name)) return;
+      const state = statesBySetter.get(callee.node.name);
+      if (!state || !hintedStateIndices.has(state.index) || path.node.arguments.length !== 1) {
+        return;
+      }
+      const updater = path.node.arguments[0];
+      if (!types.isArrowFunctionExpression(updater) || updater.async || updater.generator || updater.params.length !== 1 || !types.isIdentifier(updater.params[0]) || !types.isArrayExpression(updater.body) || updater.body.elements.length < 2 || updater.body.elements.some((element) => element === null)) {
+        return;
+      }
+      const retainedSpread = updater.body.elements[0];
+      if (!types.isSpreadElement(retainedSpread) || !types.isCallExpression(retainedSpread.argument) || retainedSpread.argument.arguments.length !== 1 || !types.isMemberExpression(retainedSpread.argument.callee) || retainedSpread.argument.callee.computed || !types.isIdentifier(retainedSpread.argument.callee.object, {
+        name: updater.params[0].name
+      }) || !types.isIdentifier(retainedSpread.argument.callee.property, { name: "slice" }) || !types.isExpression(retainedSpread.argument.arguments[0])) {
+        return;
+      }
+      const retainedStart = staticSliceIndex(retainedSpread.argument.arguments[0]);
+      if (retainedStart === void 0 || retainedStart === 0) return;
+      const safeIncomingValue = (value) => {
+        if (types.isArrayExpression(value)) {
+          return value.elements.every(
+            (element) => element !== null && !types.isJSXNamespacedName(element) && !types.isArgumentPlaceholder(element) && safeIncomingValue(types.isSpreadElement(element) ? element.argument : element)
+          );
+        }
+        if (types.isObjectExpression(value)) {
+          return value.properties.every((property) => {
+            if (types.isSpreadElement(property)) return safeIncomingValue(property.argument);
+            if (!types.isObjectProperty(property) || !types.isExpression(property.value)) return false;
+            return (!property.computed || types.isExpression(property.key) && safeIncomingValue(property.key)) && safeIncomingValue(property.value);
+          });
+        }
+        return validateDerivedExpression(value, safeGlobals) === void 0;
+      };
+      if (updater.body.elements.slice(1).some((element) => {
+        if (!element || types.isJSXNamespacedName(element) || types.isArgumentPlaceholder(element)) {
+          return true;
+        }
+        return !safeIncomingValue(types.isSpreadElement(element) ? element.argument : element);
+      })) {
+        return;
+      }
+      const previous = types.cloneNode(updater.params[0]);
+      const sliceMethod = path.scope.generateUidIdentifier("farmSlice");
+      const retained = path.scope.generateUidIdentifier("farmRetainedItems");
+      const nextValue = path.scope.generateUidIdentifier("farmNextItems");
+      const nextElements = types.cloneNode(updater.body, true).elements;
+      nextElements[0] = types.spreadElement(types.cloneNode(retained));
+      path.node.arguments[0] = types.arrowFunctionExpression(
+        [types.cloneNode(previous)],
+        types.blockStatement([
+          types.variableDeclaration("const", [
+            types.variableDeclarator(
+              types.cloneNode(sliceMethod),
+              types.memberExpression(types.cloneNode(previous), types.identifier("slice"))
+            ),
+            types.variableDeclarator(
+              types.cloneNode(retained),
+              types.callExpression(types.cloneNode(sliceHelperIdentifier), [
+                types.cloneNode(previous),
+                types.cloneNode(sliceMethod),
+                types.numericLiteral(retainedStart)
+              ])
+            ),
+            types.variableDeclarator(types.cloneNode(nextValue), types.arrayExpression(nextElements))
+          ]),
+          types.returnStatement(
+            types.callExpression(types.cloneNode(rollingWindowHelperIdentifier), [
+              types.cloneNode(previous),
+              types.cloneNode(retained),
+              types.cloneNode(nextValue)
+            ])
+          )
+        ])
+      );
+      count += 1;
+      stateIndices.add(state.index);
+      path.skip();
+    }
+  });
+  return {
+    root: file.program.body[0].expression,
+    count,
+    stateIndices
+  };
+}
+function staticSliceIndex(expression) {
+  if (types.isNumericLiteral(expression) && Number.isSafeInteger(expression.value)) {
+    return expression.value;
+  }
+  if (types.isUnaryExpression(expression) && (expression.operator === "+" || expression.operator === "-") && types.isNumericLiteral(expression.argument)) {
+    const value = expression.operator === "-" ? -expression.argument.value : expression.argument.value;
+    return Number.isSafeInteger(value) ? value : void 0;
+  }
+  return void 0;
+}
+function rewriteKeyedArrayPositionHints(root, hintedStateIndices, statesBySetter, helperIdentifier, safeGlobals) {
+  if (hintedStateIndices.size === 0) {
+    return { root: types.cloneNode(root, true), count: 0, stateIndices: /* @__PURE__ */ new Set() };
+  }
+  const file = expressionFile(types.cloneNode(root, true));
+  const stateIndices = /* @__PURE__ */ new Set();
+  let count = 0;
+  traverse(file, {
+    CallExpression(path) {
+      const callee = path.get("callee");
+      if (!callee.isIdentifier() || callee.scope.hasBinding(callee.node.name)) return;
+      const state = statesBySetter.get(callee.node.name);
+      if (!state || !hintedStateIndices.has(state.index) || path.node.arguments.length !== 1) {
+        return;
+      }
+      const updater = path.node.arguments[0];
+      if (!types.isArrowFunctionExpression(updater) || updater.async || updater.generator || updater.params.length !== 1 || !types.isIdentifier(updater.params[0]) || !types.isCallExpression(updater.body) || !types.isMemberExpression(updater.body.callee) || updater.body.callee.computed || !types.isIdentifier(updater.body.callee.object, { name: updater.params[0].name }) || !types.isIdentifier(updater.body.callee.property)) {
+        return;
+      }
+      const methodName = updater.body.callee.property.name;
+      const args = updater.body.arguments;
+      const kind = methodName === "with" && args.length === 2 ? "replace" : methodName === "toSpliced" && args.length === 3 && types.isNumericLiteral(args[1], { value: 0 }) ? "insert" : void 0;
+      if (!kind || !types.isExpression(args[0]) || !types.isExpression(args.at(-1))) return;
+      const position = staticSliceIndex(args[0]);
+      const item = args.at(-1);
+      if (position === void 0 || !types.isExpression(item) || validateDerivedExpression(item, safeGlobals) !== void 0) {
+        return;
+      }
+      const previous = types.cloneNode(updater.params[0]);
+      const method = path.scope.generateUidIdentifier(
+        methodName === "with" ? "farmWith" : "farmToSpliced"
+      );
+      path.node.arguments[0] = types.arrowFunctionExpression(
+        [types.cloneNode(previous)],
+        types.blockStatement([
+          types.variableDeclaration("const", [
+            types.variableDeclarator(
+              types.cloneNode(method),
+              types.memberExpression(types.cloneNode(previous), types.identifier(methodName))
+            )
+          ]),
+          types.returnStatement(
+            types.callExpression(types.cloneNode(helperIdentifier), [
+              types.cloneNode(previous),
+              types.cloneNode(method),
+              types.stringLiteral(kind),
+              ...args.map((argument) => types.cloneNode(argument, true))
+            ])
+          )
+        ])
+      );
+      count += 1;
+      stateIndices.add(state.index);
+      path.skip();
+    }
+  });
+  return {
+    root: file.program.body[0].expression,
+    count,
+    stateIndices
+  };
+}
+function rewriteKeyedArrayReorderHints(root, hintedStateIndices, statesBySetter, helperIdentifier) {
+  if (hintedStateIndices.size === 0) {
+    return { root: types.cloneNode(root, true), count: 0, stateIndices: /* @__PURE__ */ new Set() };
+  }
+  const file = expressionFile(types.cloneNode(root, true));
+  const stateIndices = /* @__PURE__ */ new Set();
+  let count = 0;
+  traverse(file, {
+    CallExpression(path) {
+      const callee = path.get("callee");
+      if (!callee.isIdentifier() || callee.scope.hasBinding(callee.node.name)) return;
+      const state = statesBySetter.get(callee.node.name);
+      if (!state || !hintedStateIndices.has(state.index) || path.node.arguments.length !== 1) {
+        return;
+      }
+      const updater = path.node.arguments[0];
+      if (!types.isArrowFunctionExpression(updater) || updater.async || updater.generator || updater.params.length !== 1 || !types.isIdentifier(updater.params[0]) || !types.isCallExpression(updater.body) || updater.body.arguments.length !== 0 || !types.isMemberExpression(updater.body.callee) || updater.body.callee.computed || !types.isIdentifier(updater.body.callee.object, { name: updater.params[0].name }) || !types.isIdentifier(updater.body.callee.property, { name: "toReversed" })) {
+        return;
+      }
+      const previous = types.cloneNode(updater.params[0]);
+      const method = path.scope.generateUidIdentifier("farmToReversed");
+      path.node.arguments[0] = types.arrowFunctionExpression(
+        [types.cloneNode(previous)],
+        types.blockStatement([
+          types.variableDeclaration("const", [
+            types.variableDeclarator(
+              types.cloneNode(method),
+              types.memberExpression(types.cloneNode(previous), types.identifier("toReversed"))
+            )
+          ]),
+          types.returnStatement(
+            types.callExpression(types.cloneNode(helperIdentifier), [
+              types.cloneNode(previous),
+              types.cloneNode(method)
+            ])
+          )
+        ])
+      );
+      count += 1;
+      stateIndices.add(state.index);
+      path.skip();
+    }
+  });
+  return {
+    root: file.program.body[0].expression,
+    count,
+    stateIndices
+  };
+}
+function rewriteKeyedArraySliceHints(root, hintedStateIndices, statesBySetter, helperIdentifier) {
+  if (hintedStateIndices.size === 0) {
+    return { root: types.cloneNode(root, true), count: 0, stateIndices: /* @__PURE__ */ new Set() };
+  }
+  const file = expressionFile(types.cloneNode(root, true));
+  const stateIndices = /* @__PURE__ */ new Set();
+  let count = 0;
+  traverse(file, {
+    CallExpression(path) {
+      const callee = path.get("callee");
+      if (!callee.isIdentifier() || callee.scope.hasBinding(callee.node.name)) return;
+      const state = statesBySetter.get(callee.node.name);
+      if (!state || !hintedStateIndices.has(state.index) || path.node.arguments.length !== 1) {
+        return;
+      }
+      const updater = path.node.arguments[0];
+      if (!types.isArrowFunctionExpression(updater) || updater.async || updater.generator || updater.params.length !== 1 || !types.isIdentifier(updater.params[0]) || !types.isCallExpression(updater.body) || updater.body.arguments.length < 1 || updater.body.arguments.length > 2 || !types.isMemberExpression(updater.body.callee) || updater.body.callee.computed || !types.isIdentifier(updater.body.callee.object, { name: updater.params[0].name }) || !types.isIdentifier(updater.body.callee.property, { name: "slice" })) {
+        return;
+      }
+      const indexes = [];
+      for (const argument of updater.body.arguments) {
+        if (!types.isExpression(argument)) return;
+        const value = staticSliceIndex(argument);
+        if (value === void 0) return;
+        indexes.push(value);
+      }
+      if (indexes.length === 1 && indexes[0] === 0) return;
+      const previous = types.cloneNode(updater.params[0]);
+      const sliceMethod = path.scope.generateUidIdentifier("farmSlice");
+      path.node.arguments[0] = types.arrowFunctionExpression(
+        [types.cloneNode(previous)],
+        types.blockStatement([
+          types.variableDeclaration("const", [
+            types.variableDeclarator(
+              types.cloneNode(sliceMethod),
+              types.memberExpression(types.cloneNode(previous), types.identifier("slice"))
+            )
+          ]),
+          types.returnStatement(
+            types.callExpression(types.cloneNode(helperIdentifier), [
+              types.cloneNode(previous),
+              types.cloneNode(sliceMethod),
+              ...indexes.map((value) => types.numericLiteral(value))
+            ])
+          )
+        ])
+      );
+      count += 1;
+      stateIndices.add(state.index);
+      path.skip();
+    }
+  });
+  return {
+    root: file.program.body[0].expression,
+    count,
+    stateIndices
+  };
+}
+function rewriteKeyedArrayFilterHints(root, hintedStateIndices, statesBySetter, helperIdentifier, safeGlobals) {
+  if (hintedStateIndices.size === 0) {
+    return { root: types.cloneNode(root, true), count: 0, stateIndices: /* @__PURE__ */ new Set() };
+  }
+  const file = expressionFile(types.cloneNode(root, true));
+  const stateIndices = /* @__PURE__ */ new Set();
+  let count = 0;
+  traverse(file, {
+    CallExpression(path) {
+      const callee = path.get("callee");
+      if (!callee.isIdentifier() || callee.scope.hasBinding(callee.node.name)) return;
+      const state = statesBySetter.get(callee.node.name);
+      if (!state || !hintedStateIndices.has(state.index) || path.node.arguments.length !== 1) {
+        return;
+      }
+      const updater = path.node.arguments[0];
+      if (!types.isArrowFunctionExpression(updater) || updater.async || updater.generator || updater.params.length !== 1 || !types.isIdentifier(updater.params[0]) || !types.isCallExpression(updater.body) || updater.body.arguments.length !== 1 || !types.isMemberExpression(updater.body.callee) || updater.body.callee.computed || !types.isIdentifier(updater.body.callee.object, {
+        name: updater.params[0].name
+      }) || !types.isIdentifier(updater.body.callee.property, { name: "filter" })) {
+        return;
+      }
+      const predicate = updater.body.arguments[0];
+      if (!types.isArrowFunctionExpression(predicate) || predicate.async || predicate.generator || predicate.params.length !== 1 || !types.isIdentifier(predicate.params[0]) || !types.isExpression(predicate.body) || validateDerivedExpression(predicate.body, safeGlobals)) {
+        return;
+      }
+      const previous = types.cloneNode(updater.params[0]);
+      const filterMethod = path.scope.generateUidIdentifier("farmFilter");
+      path.node.arguments[0] = types.arrowFunctionExpression(
+        [types.cloneNode(previous)],
+        types.blockStatement([
+          types.variableDeclaration("const", [
+            types.variableDeclarator(
+              types.cloneNode(filterMethod),
+              types.memberExpression(types.cloneNode(previous), types.identifier("filter"))
+            )
+          ]),
+          types.returnStatement(
+            types.callExpression(types.cloneNode(helperIdentifier), [
+              types.cloneNode(previous),
+              types.cloneNode(filterMethod),
+              types.cloneNode(predicate, true)
+            ])
+          )
+        ])
+      );
+      count += 1;
+      stateIndices.add(state.index);
+      path.skip();
+    }
+  });
+  return {
+    root: file.program.body[0].expression,
+    count,
+    stateIndices
+  };
+}
+function collectionConstructorName(kind) {
+  return kind === "set" ? "Set" : "Map";
+}
+function isCollectionConstruction(expression, kind, previous) {
+  if (!types.isNewExpression(expression) || !types.isIdentifier(expression.callee, {
+    name: collectionConstructorName(kind)
+  })) {
+    return false;
+  }
+  if (!previous) return true;
+  return expression.arguments.length === 1 && types.isIdentifier(expression.arguments[0], { name: previous.name });
+}
+function collectionStateInitializerIsOwned(initialValue, kind, constructorIsGlobal) {
+  if (!initialValue || !constructorIsGlobal) return false;
+  if (isCollectionConstruction(initialValue, kind)) return true;
+  if (!types.isArrowFunctionExpression(initialValue) && !types.isFunctionExpression(initialValue)) {
+    return false;
+  }
+  if (types.isBlockStatement(initialValue.body) && initialValue.body.body.length !== 1) return false;
+  const value = returnedExpression(initialValue);
+  return Boolean(value && isCollectionConstruction(value, kind));
+}
+function collectionStateHasOnlyOwnedReads(root, state, kind) {
+  const file = expressionFile(types.cloneNode(root, true));
+  let valid = true;
+  const readMethods = kind === "set" ? /* @__PURE__ */ new Set(["has"]) : /* @__PURE__ */ new Set(["get", "has"]);
+  traverse(file, {
+    ReferencedIdentifier(path) {
+      if (!valid || !types.isIdentifier(path.node) || path.node.name !== state.valueName || path.scope.hasBinding(path.node.name)) {
+        return;
+      }
+      const parent = path.parentPath;
+      if (parent.isNewExpression() && types.isIdentifier(parent.node.callee, {
+        name: collectionConstructorName(kind)
+      }) && parent.node.arguments.length === 1 && parent.node.arguments[0] === path.node) {
+        return;
+      }
+      if (!parent.isMemberExpression() || parent.node.object !== path.node || parent.node.computed || !types.isIdentifier(parent.node.property)) {
+        valid = false;
+        path.stop();
+        return;
+      }
+      const property = parent.node.property.name;
+      if (property === "size") return;
+      const call = parent.parentPath;
+      if (!readMethods.has(property) || !call?.isCallExpression() || call.node.callee !== parent.node) {
+        valid = false;
+        path.stop();
+      }
+    }
+  });
+  return valid;
+}
+function collectionMutationOperation(kind, method) {
+  if (kind === "set" && method === "add") return "set-add";
+  if (kind === "set" && method === "delete") return "set-delete";
+  if (kind === "map" && method === "set") return "map-set";
+  if (kind === "map" && method === "delete") return "map-delete";
+  return void 0;
+}
+function collectionMutationArgumentsAreValid(operation, args) {
+  if (!operation || args.some((argument) => !types.isExpression(argument))) return false;
+  return operation === "map-set" ? args.length === 2 : args.length === 1;
+}
+function prepareKeyedCollectionUpdater(updater, kind, updateHelper, mutationHelper) {
+  if (updater.async || updater.generator || updater.params.length !== 1 || !types.isIdentifier(updater.params[0])) {
+    return void 0;
+  }
+  const previous = updater.params[0];
+  if (types.isExpression(updater.body)) {
+    if (!types.isCallExpression(updater.body) || !types.isMemberExpression(updater.body.callee) || updater.body.callee.computed || !types.isIdentifier(updater.body.callee.property)) {
+      return void 0;
+    }
+    const operation = collectionMutationOperation(kind, updater.body.callee.property.name);
+    if (operation !== "set-add" && operation !== "map-set" || !collectionMutationArgumentsAreValid(operation, updater.body.arguments) || !isCollectionConstruction(updater.body.callee.object, kind, previous)) {
+      return void 0;
+    }
+    const collection = uniqueLocalIdentifier("_farmCollection", [updater]);
+    const body = types.blockStatement([
+      types.variableDeclaration("const", [
+        types.variableDeclarator(
+          types.cloneNode(collection),
+          types.cloneNode(updater.body.callee.object, true)
+        )
+      ]),
+      types.returnStatement(
+        types.callExpression(types.cloneNode(updateHelper), [
+          types.cloneNode(previous),
+          types.callExpression(types.cloneNode(mutationHelper), [
+            types.cloneNode(collection),
+            types.memberExpression(types.cloneNode(collection), types.cloneNode(updater.body.callee.property)),
+            types.stringLiteral(operation),
+            ...updater.body.arguments.map(
+              (argument) => types.cloneNode(argument, true)
+            )
+          ]),
+          types.stringLiteral(kind)
+        ])
+      )
+    ]);
+    return {
+      updater: types.arrowFunctionExpression([types.cloneNode(previous)], body),
+      mutations: 1
+    };
+  }
+  const cloned = types.cloneNode(updater, true);
+  const file = expressionFile(cloned);
+  let functionPath;
+  traverse(file, {
+    Function(path) {
+      if (functionPath) return;
+      if (path.isArrowFunctionExpression() || path.isFunctionExpression()) {
+        functionPath = path;
+      }
+    }
+  });
+  if (!functionPath || !types.isBlockStatement(functionPath.node.body)) return void 0;
+  const clonedPrevious = functionPath.node.params[0];
+  if (!types.isIdentifier(clonedPrevious)) return void 0;
+  let collectionDeclaration;
+  const updaterBody = functionPath.get("body");
+  if (!updaterBody.isBlockStatement()) return void 0;
+  for (const statement of updaterBody.get("body")) {
+    if (!statement.isVariableDeclaration({ kind: "const" })) continue;
+    for (const declaration of statement.get("declarations")) {
+      if (declaration.isVariableDeclarator() && types.isIdentifier(declaration.node.id) && types.isExpression(declaration.node.init) && isCollectionConstruction(declaration.node.init, kind, clonedPrevious)) {
+        if (collectionDeclaration) return void 0;
+        collectionDeclaration = declaration;
+      }
+    }
+  }
+  if (!collectionDeclaration || !types.isIdentifier(collectionDeclaration.node.id)) return void 0;
+  if (collectionDeclaration.scope.getBinding(collectionConstructorName(kind))) return void 0;
+  const collectionName = collectionDeclaration.node.id.name;
+  const collectionBinding = collectionDeclaration.scope.getBinding(collectionName);
+  const previousBinding = functionPath.scope.getBinding(clonedPrevious.name);
+  if (!collectionBinding || !previousBinding) return void 0;
+  let valid = true;
+  let mutations = 0;
+  traverse(file, {
+    ReferencedIdentifier(path) {
+      if (!valid) return;
+      const binding = path.scope.getBinding(path.node.name);
+      const belongsToUpdater = path.getFunctionParent()?.node === functionPath?.node;
+      if (binding === collectionBinding) {
+        if (!belongsToUpdater) {
+          valid = false;
+          path.stop();
+          return;
+        }
+        const parent = path.parentPath;
+        if (parent.isReturnStatement() && parent.node.argument === path.node) return;
+        if (!parent.isMemberExpression() || parent.node.object !== path.node || parent.node.computed || !types.isIdentifier(parent.node.property)) {
+          valid = false;
+          path.stop();
+          return;
+        }
+        const method = parent.node.property.name;
+        if (method === "size") return;
+        const call = parent.parentPath;
+        if (!call?.isCallExpression() || call.node.callee !== parent.node) {
+          valid = false;
+          path.stop();
+          return;
+        }
+        const operation = collectionMutationOperation(kind, method);
+        const read = kind === "set" ? method === "has" : method === "get" || method === "has";
+        if (read) return;
+        if (!collectionMutationArgumentsAreValid(operation, call.node.arguments) || call.parentPath.isMemberExpression() && call.parentPath.node.object === call.node) {
+          valid = false;
+          path.stop();
+          return;
+        }
+        mutations += 1;
+        return;
+      }
+      if (binding === previousBinding) {
+        if (!belongsToUpdater) {
+          valid = false;
+          path.stop();
+          return;
+        }
+        const parent = path.parentPath;
+        if (parent.isReturnStatement() && parent.node.argument === path.node) return;
+        if (parent.isNewExpression() && parent.node.arguments.length === 1 && parent.node.arguments[0] === path.node && types.isIdentifier(parent.node.callee, {
+          name: collectionConstructorName(kind)
+        })) {
+          return;
+        }
+        if (parent.isMemberExpression() && parent.node.object === path.node && !parent.node.computed && types.isIdentifier(parent.node.property)) {
+          const method = parent.node.property.name;
+          const call = parent.parentPath;
+          if (method === "size" || (kind === "set" ? method === "has" : method === "get" || method === "has") && call?.isCallExpression() && call.node.callee === parent.node) {
+            return;
+          }
+        }
+        valid = false;
+        path.stop();
+      }
+    },
+    ReturnStatement(path) {
+      if (!valid || path.getFunctionParent()?.node !== functionPath?.node || !path.node.argument) {
+        return;
+      }
+      const value = path.node.argument;
+      const returnsOwnedCollection = types.isIdentifier(value) && (path.scope.getBinding(value.name) === collectionBinding || path.scope.getBinding(value.name) === previousBinding) || isCollectionConstruction(value, kind);
+      if (!returnsOwnedCollection) {
+        valid = false;
+        path.stop();
+      }
+    }
+  });
+  if (!valid || mutations === 0) return void 0;
+  traverse(file, {
+    CallExpression(path) {
+      if (path.getFunctionParent()?.node !== functionPath?.node) return;
+      const callee = path.node.callee;
+      if (!types.isMemberExpression(callee) || callee.computed || !types.isIdentifier(callee.object, { name: collectionName }) || path.scope.getBinding(collectionName) !== collectionBinding || !types.isIdentifier(callee.property)) {
+        return;
+      }
+      const operation = collectionMutationOperation(kind, callee.property.name);
+      if (!collectionMutationArgumentsAreValid(operation, path.node.arguments)) return;
+      path.replaceWith(
+        types.callExpression(types.cloneNode(mutationHelper), [
+          types.cloneNode(callee.object),
+          types.memberExpression(types.cloneNode(callee.object), types.cloneNode(callee.property)),
+          types.stringLiteral(operation),
+          ...path.node.arguments.map((argument) => types.cloneNode(argument, true))
+        ])
+      );
+      path.skip();
+    },
+    ReturnStatement(path) {
+      if (path.getFunctionParent()?.node !== functionPath?.node || !path.node.argument) return;
+      path.node.argument = types.callExpression(types.cloneNode(updateHelper), [
+        types.cloneNode(clonedPrevious),
+        types.cloneNode(path.node.argument, true),
+        types.stringLiteral(kind)
+      ]);
+    }
+  });
+  const prepared = file.program.body[0].expression;
+  return types.isArrowFunctionExpression(prepared) || types.isFunctionExpression(prepared) ? { updater: prepared, mutations } : void 0;
+}
+function rewriteKeyedCollectionUpdateHints(root, targetKinds, states, statesBySetter, updateHelper, mutationHelper, globalCollections) {
+  if (targetKinds.size === 0) return { root: types.cloneNode(root, true), count: 0 };
+  const file = expressionFile(types.cloneNode(root, true));
+  let count = 0;
+  for (const [stateIndex, kind] of targetKinds) {
+    const state = states[stateIndex];
+    if (!state || !collectionStateInitializerIsOwned(
+      state.initialValue,
+      kind,
+      globalCollections.has(collectionConstructorName(kind))
+    ) || !collectionStateHasOnlyOwnedReads(root, state, kind)) {
+      continue;
+    }
+    const replacements = /* @__PURE__ */ new Map();
+    let valid = true;
+    traverse(file, {
+      CallExpression(path) {
+        if (!valid) return;
+        const callee = path.get("callee");
+        if (!callee.isIdentifier({ name: state.setterName }) || callee.scope.hasBinding(callee.node.name) || statesBySetter.get(callee.node.name)?.index !== stateIndex) {
+          return;
+        }
+        if (path.node.arguments.length !== 1 || !types.isExpression(path.node.arguments[0])) {
+          valid = false;
+          path.stop();
+          return;
+        }
+        const update = path.node.arguments[0];
+        if (path.scope.getBinding(collectionConstructorName(kind))) {
+          valid = false;
+          path.stop();
+          return;
+        }
+        if (isCollectionConstruction(update, kind)) return;
+        if (!types.isArrowFunctionExpression(update) && !types.isFunctionExpression(update)) {
+          valid = false;
+          path.stop();
+          return;
+        }
+        const prepared = prepareKeyedCollectionUpdater(update, kind, updateHelper, mutationHelper);
+        if (!prepared) {
+          valid = false;
+          path.stop();
+          return;
+        }
+        replacements.set(path.node, prepared);
+      }
+    });
+    if (!valid || replacements.size === 0) continue;
+    traverse(file, {
+      CallExpression(path) {
+        const prepared = replacements.get(path.node);
+        if (!prepared) return;
+        path.node.arguments[0] = types.cloneNode(prepared.updater, true);
+        count += prepared.mutations;
+        path.skip();
+      }
+    });
+  }
+  return {
+    root: file.program.body[0].expression,
+    count
+  };
+}
 function rewriteStateAccess(expression, stateParameter, statesByValue, statesBySetter) {
   const file = expressionFile(cloneExpression(expression));
   traverse(file, {
@@ -548,21 +1626,28 @@ function analyzeMapList(expression, statesByValue, safeGlobals) {
   const collection = callee.object;
   const collectionUnsupported = validateCollectionPipeline(collection, safeGlobals);
   if (collectionUnsupported) {
-    return { reason: `keyed list collection cannot use ${collectionUnsupported}` };
+    return {
+      reason: `keyed list collection cannot use ${collectionUnsupported}`
+    };
   }
   if (expression.arguments.length !== 1 || !types.isArrowFunctionExpression(expression.arguments[0]) && !types.isFunctionExpression(expression.arguments[0])) {
     return { reason: "keyed list map must use one inline render callback" };
   }
   const callback = expression.arguments[0];
   if (containsDirectHookCall(callback)) {
-    return { reason: "Hooks cannot be called directly inside a keyed list callback" };
+    return {
+      reason: "Hooks cannot be called directly inside a keyed list callback"
+    };
   }
   const row = returnedExpression(callback);
   if (!row || !types.isJSXElement(row)) {
     return { reason: "keyed list map callbacks must return one React element" };
   }
   const key = jsxKeyExpression(row);
-  if (!key) return { reason: "automatically compiled lists require an explicit item key" };
+  if (!key)
+    return {
+      reason: "automatically compiled lists require an explicit item key"
+    };
   const keyReason = validateKeyFunction(callback, key, safeGlobals);
   if (keyReason) return { reason: keyReason };
   return { dependencies: collectStateDependencies(expression, statesByValue) };
@@ -577,7 +1662,9 @@ function listAttributeExpression(element, name) {
 }
 function analyzePublicList(element, statesByValue, safeGlobals) {
   if (element.openingElement.attributes.some((attribute) => types.isJSXSpreadAttribute(attribute))) {
-    return { reason: "compiled List boundaries do not support JSX attribute spreads" };
+    return {
+      reason: "compiled List boundaries do not support JSX attribute spreads"
+    };
   }
   const each = listAttributeExpression(element, "each");
   const by = listAttributeExpression(element, "by");
@@ -595,7 +1682,9 @@ function analyzePublicList(element, statesByValue, safeGlobals) {
   if (keyReason) return { reason: keyReason };
   const children = meaningfulJsxChildren(element);
   if (children.length !== 1 || !types.isJSXExpressionContainer(children[0]) || types.isJSXEmptyExpression(children[0].expression) || !types.isArrowFunctionExpression(children[0].expression) && !types.isFunctionExpression(children[0].expression)) {
-    return { reason: "compiled List children must use one inline render function" };
+    return {
+      reason: "compiled List children must use one inline render function"
+    };
   }
   const render = children[0].expression;
   if (!returnedExpression(render)) {
@@ -709,13 +1798,20 @@ function stabilizeDeferredEventCurrentTargets(root, compilerSetters) {
   const expression = file.program.body[0].expression;
   return types.isJSXElement(expression) ? expression : types.cloneNode(root, true);
 }
-function analyzeKeyedRowTree(row, renderCallback, safeGlobals, compilerSetters) {
+function analyzeKeyedRowTree(row, renderCallback, safeGlobals, compilerSetters, keyedTargetReactiveByValue) {
   if (renderCallback.async || renderCallback.generator || renderCallback.params.length < 1 || renderCallback.params.length > 2 || !types.isIdentifier(renderCallback.params[0]) || renderCallback.params[1] !== void 0 && !types.isIdentifier(renderCallback.params[1])) {
-    return { reason: "compiled keyed rows require item and optional index identifiers" };
+    return {
+      reason: "compiled keyed rows require item and optional index identifiers"
+    };
   }
   const bindings = [];
   const events = [];
   const conditionals = [];
+  const validateBindingExpression = (expression) => validateDerivedExpression(
+    expression,
+    safeGlobals,
+    keyedTargetReactiveByValue ? (call) => isPotentialKeyedMembershipCall(call, keyedTargetReactiveByValue) || isPotentialKeyedMapLookupCall(call, keyedTargetReactiveByValue) : void 0
+  );
   const visit = (element, path) => {
     const tag = element.openingElement.name;
     if (!types.isJSXIdentifier(tag) || !/^[a-z]/.test(tag.name)) {
@@ -794,7 +1890,7 @@ function analyzeKeyedRowTree(row, renderCallback, safeGlobals, compilerSetters)
           if (!propertyName || propertyName.includes("-") && !propertyName.startsWith("--")) {
             return "compiled keyed row style names must use camelCase or a CSS custom property";
           }
-          const unsupported2 = validateDerivedExpression(property.value, safeGlobals);
+          const unsupported2 = validateBindingExpression(property.value);
           if (unsupported2) {
             return `compiled keyed row style ${propertyName} cannot use ${unsupported2}`;
           }
@@ -808,7 +1904,7 @@ function analyzeKeyedRowTree(row, renderCallback, safeGlobals, compilerSetters)
         continue;
       }
       if (name === "children") return "compiled keyed row children props are not supported yet";
-      const unsupported = validateDerivedExpression(expression, safeGlobals);
+      const unsupported = validateBindingExpression(expression);
       if (unsupported) return `compiled keyed row ${name} cannot use ${unsupported}`;
       bindings.push({
         kind: "attribute",
@@ -858,7 +1954,7 @@ function analyzeKeyedRowTree(row, renderCallback, safeGlobals, compilerSetters)
       (child) => types.isJSXExpressionContainer(child) && !types.isJSXEmptyExpression(child.expression)
     );
     for (const child of expressions) {
-      const unsupported = validateDerivedExpression(child.expression, safeGlobals);
+      const unsupported = validateBindingExpression(child.expression);
       if (unsupported) return `compiled keyed row text cannot use ${unsupported}`;
     }
     if (nestedElements.length > 0 && expressions.length > 0) {
@@ -874,7 +1970,11 @@ function analyzeKeyedRowTree(row, renderCallback, safeGlobals, compilerSetters)
           parts.push(cloneExpression(child.expression));
         }
       }
-      bindings.push({ kind: "text", path: [...path], value: types.arrayExpression(parts) });
+      bindings.push({
+        kind: "text",
+        path: [...path],
+        value: types.arrayExpression(parts)
+      });
     }
     let elementIndex = 0;
     for (const child of element.children) {
@@ -888,7 +1988,7 @@ function analyzeKeyedRowTree(row, renderCallback, safeGlobals, compilerSetters)
   const reason = visit(row, []);
   return reason ? { reason } : { bindings, events, conditionals };
 }
-function analyzeKeyedRowChild(child, statesByValue, safeGlobals, listNames, acceptUnsupportedRow = false) {
+function analyzeKeyedRowChild(child, statesByValue, safeGlobals, listNames, acceptUnsupportedRow = false, allowMembershipTargets = false) {
   let collection;
   let keyCallback;
   let renderCallback;
@@ -941,7 +2041,8 @@ function analyzeKeyedRowChild(child, statesByValue, safeGlobals, listNames, acce
     row,
     renderCallback,
     safeGlobals,
-    new Set([...statesByValue.values()].map((state) => state.setterName))
+    new Set([...statesByValue.values()].map((state) => state.setterName)),
+    allowMembershipTargets ? statesByValue : void 0
   );
   if (rowAnalysis.reason && !acceptUnsupportedRow) return void 0;
   const keyExpression = returnedExpression(keyCallback);
@@ -954,6 +2055,7 @@ function analyzeKeyedRowChild(child, statesByValue, safeGlobals, listNames, acce
   return {
     source,
     collection,
+    collectionDependency: types.isIdentifier(collection) ? statesByValue.get(collection.name)?.index : void 0,
     structureDependencies: [...structureDependencies].sort((left, right) => left - right),
     keyCallback,
     renderCallback,
@@ -982,7 +2084,74 @@ function analyzeKeyedRowsContainer(container, statesByValue, safeGlobals, listNa
   }
   const children = meaningfulJsxChildren(container);
   if (children.length !== 1) return void 0;
-  return analyzeKeyedRowChild(children[0], statesByValue, safeGlobals, listNames, true);
+  const shape = analyzeKeyedRowChild(
+    children[0],
+    statesByValue,
+    safeGlobals,
+    listNames,
+    true,
+    true
+  );
+  if (!shape || shape.rowReason) return shape;
+  const needsMembershipProof = (binding) => containsPotentialKeyedMembershipCall(binding.value, statesByValue);
+  const needsMapLookupProof = (binding) => containsPotentialKeyedMapLookupCall(binding.value, statesByValue);
+  if (shape.conditionals.length > 0 || shape.events.length > 0 && !canDelegateKeyedRowEvents({
+    conditionals: shape.conditionals,
+    events: shape.events,
+    source: container
+  })) {
+    return shape.bindings.some(
+      (binding) => needsMembershipProof(binding) || needsMapLookupProof(binding)
+    ) ? {
+      ...shape,
+      rowReason: "keyed collection targets require compiler-owned rows without React-owned branches or events"
+    } : shape;
+  }
+  const structureDependencies = new Set(shape.structureDependencies);
+  const bindings = shape.bindings.map((binding) => ({
+    ...binding,
+    identityTarget: keyedIdentityTarget(
+      binding,
+      shape.keyCallback,
+      shape.renderCallback,
+      statesByValue,
+      structureDependencies
+    ),
+    membershipTarget: keyedMembershipTarget(
+      binding,
+      shape.keyCallback,
+      shape.renderCallback,
+      statesByValue,
+      structureDependencies
+    ),
+    mapLookupTarget: keyedMapLookupTarget(
+      binding,
+      shape.keyCallback,
+      shape.renderCallback,
+      statesByValue,
+      structureDependencies
+    )
+  }));
+  if (bindings.some(
+    (binding, index) => needsMembershipProof(shape.bindings[index]) && !binding.membershipTarget
+  )) {
+    return {
+      ...shape,
+      rowReason: "keyed membership targets must call one local Set state with the exact row key"
+    };
+  }
+  if (bindings.some(
+    (binding, index) => needsMapLookupProof(shape.bindings[index]) && !binding.mapLookupTarget
+  )) {
+    return {
+      ...shape,
+      rowReason: "keyed Map lookup targets must call one local Map state with the exact row key"
+    };
+  }
+  return {
+    ...shape,
+    bindings
+  };
 }
 function analyzeKeyedRangesContainer(container, statesByValue, safeGlobals, listNames, allowSingleRange = false) {
   if (container.openingElement.attributes.some(
@@ -1138,7 +2307,11 @@ function analyzeHostConditionalTree(branch, safeGlobals, allowStaticEvents = fal
           parts.push(cloneExpression(child.expression));
         }
       }
-      bindings.push({ kind: "text", path: [...path], value: types.arrayExpression(parts) });
+      bindings.push({
+        kind: "text",
+        path: [...path],
+        value: types.arrayExpression(parts)
+      });
     }
     let elementIndex = 0;
     for (const child of element.children) {
@@ -1310,7 +2483,11 @@ function analyzeRecursiveHostTree(branch, statesByValue, safeGlobals, listNames,
           listNames,
           id,
           allocateId
-        ) : { bindings: [], plans: [], blocks: /* @__PURE__ */ new Map() };
+        ) : {
+          bindings: [],
+          plans: [],
+          blocks: /* @__PURE__ */ new Map()
+        };
         const falsy = shape.falsy ? analyzeRecursiveHostTree(
           shape.falsy,
           statesByValue,
@@ -1318,7 +2495,11 @@ function analyzeRecursiveHostTree(branch, statesByValue, safeGlobals, listNames,
           listNames,
           id,
           allocateId
-        ) : { bindings: [], plans: [], blocks: /* @__PURE__ */ new Map() };
+        ) : {
+          bindings: [],
+          plans: [],
+          blocks: /* @__PURE__ */ new Map()
+        };
         if (truthy.reason) return truthy.reason;
         if (falsy.reason) return falsy.reason;
         plans.push(...truthy.plans, ...falsy.plans);
@@ -1476,7 +2657,11 @@ function analyzeRecursiveHostTree(branch, statesByValue, safeGlobals, listNames,
           parts.push(cloneExpression(child.expression));
         }
       }
-      bindings.push({ kind: "text", path: [...path], value: types.arrayExpression(parts) });
+      bindings.push({
+        kind: "text",
+        path: [...path],
+        value: types.arrayExpression(parts)
+      });
     }
     let elementIndex = 0;
     for (const child of element.children) {
@@ -1543,7 +2728,11 @@ function analyzeHostConditionalContainer(container, statesByValue, safeGlobals,
     listNames,
     parent,
     allocateId
-  ) : { bindings: [], plans: [], blocks: /* @__PURE__ */ new Map() };
+  ) : {
+    bindings: [],
+    plans: [],
+    blocks: /* @__PURE__ */ new Map()
+  };
   const falsyAnalysis = shape.falsy ? analyzeRecursiveHostTree(
     shape.falsy,
     statesByValue,
@@ -1551,7 +2740,11 @@ function analyzeHostConditionalContainer(container, statesByValue, safeGlobals,
     listNames,
     parent,
     allocateId
-  ) : { bindings: [], plans: [], blocks: /* @__PURE__ */ new Map() };
+  ) : {
+    bindings: [],
+    plans: [],
+    blocks: /* @__PURE__ */ new Map()
+  };
   if (truthyAnalysis.reason || falsyAnalysis.reason) return void 0;
   const dependencies = new Set(collectStateDependencies(shape.test, statesByValue));
   for (const binding of [...truthyAnalysis.bindings || [], ...falsyAnalysis.bindings || []]) {
@@ -1597,7 +2790,11 @@ function analyzeConditionalRangesContainer(container, statesByValue, safeGlobals
           listNames,
           parent,
           allocateId
-        ) : { bindings: [], plans: [], blocks: /* @__PURE__ */ new Map() };
+        ) : {
+          bindings: [],
+          plans: [],
+          blocks: /* @__PURE__ */ new Map()
+        };
         const falsyAnalysis = shape.falsy ? analyzeRecursiveHostTree(
           shape.falsy,
           statesByValue,
@@ -1605,7 +2802,11 @@ function analyzeConditionalRangesContainer(container, statesByValue, safeGlobals
           listNames,
           parent,
           allocateId
-        ) : { bindings: [], plans: [], blocks: /* @__PURE__ */ new Map() };
+        ) : {
+          bindings: [],
+          plans: [],
+          blocks: /* @__PURE__ */ new Map()
+        };
         if (truthyAnalysis.reason || falsyAnalysis.reason) return void 0;
         nestedPlans.push(...truthyAnalysis.plans, ...falsyAnalysis.plans);
         for (const [element, plan] of truthyAnalysis.blocks) descriptorBlocks.set(element, plan);
@@ -1698,7 +2899,11 @@ function analyzeMixedRangesContainer(container, statesByValue, safeGlobals, list
           listNames,
           parent,
           allocateId
-        ) : { bindings: [], plans: [], blocks: /* @__PURE__ */ new Map() };
+        ) : {
+          bindings: [],
+          plans: [],
+          blocks: /* @__PURE__ */ new Map()
+        };
         const falsyAnalysis = shape.falsy ? analyzeRecursiveHostTree(
           shape.falsy,
           statesByValue,
@@ -1706,7 +2911,11 @@ function analyzeMixedRangesContainer(container, statesByValue, safeGlobals, list
           listNames,
           parent,
           allocateId
-        ) : { bindings: [], plans: [], blocks: /* @__PURE__ */ new Map() };
+        ) : {
+          bindings: [],
+          plans: [],
+          blocks: /* @__PURE__ */ new Map()
+        };
         if (!mergeAnalysis(truthyAnalysis) || !mergeAnalysis(falsyAnalysis)) return void 0;
         for (const dependency of collectStateDependencies(shape.test, statesByValue)) {
           dependencies.add(dependency);
@@ -1947,6 +3156,57 @@ function keyedRowBindingObject(binding, parameters) {
   if (binding.name) {
     properties.push(types.objectProperty(types.identifier("name"), types.stringLiteral(binding.name)));
   }
+  if (binding.identityTarget) {
+    properties.push(
+      types.objectProperty(
+        types.identifier("identityTarget"),
+        types.objectExpression([
+          types.objectProperty(
+            types.identifier("dependency"),
+            types.numericLiteral(binding.identityTarget.dependency)
+          ),
+          types.objectProperty(
+            types.identifier("read"),
+            types.arrowFunctionExpression([], cloneExpression(binding.identityTarget.value))
+          )
+        ])
+      )
+    );
+  }
+  if (binding.membershipTarget) {
+    properties.push(
+      types.objectProperty(
+        types.identifier("membershipTarget"),
+        types.objectExpression([
+          types.objectProperty(
+            types.identifier("dependency"),
+            types.numericLiteral(binding.membershipTarget.dependency)
+          ),
+          types.objectProperty(
+            types.identifier("read"),
+            types.arrowFunctionExpression([], cloneExpression(binding.membershipTarget.value))
+          )
+        ])
+      )
+    );
+  }
+  if (binding.mapLookupTarget) {
+    properties.push(
+      types.objectProperty(
+        types.identifier("mapLookupTarget"),
+        types.objectExpression([
+          types.objectProperty(
+            types.identifier("dependency"),
+            types.numericLiteral(binding.mapLookupTarget.dependency)
+          ),
+          types.objectProperty(
+            types.identifier("read"),
+            types.arrowFunctionExpression([], cloneExpression(binding.mapLookupTarget.value))
+          )
+        ])
+      )
+    );
+  }
   properties.push(
     types.objectProperty(
       types.identifier("read"),
@@ -2141,7 +3401,7 @@ function keyedRowConditionalObject(conditional, parameters) {
   }
   return types.objectExpression(properties);
 }
-function keyedRowsBoundary(blockRuntime, plan) {
+function keyedRowsBoundary(blockRuntime, plan, keyedMapUpdateHints, keyedArrayFilterHintedStateIndices, keyedArrayPrependHintedStateIndices, keyedArrayPositionHintedStateIndices, keyedArrayReorderHintedStateIndices) {
   const name = types.jsxMemberExpression(
     types.jsxIdentifier(blockRuntime.name),
     types.jsxIdentifier("KeyedRows")
@@ -2175,6 +3435,16 @@ function keyedRowsBoundary(blockRuntime, plan) {
           types.jsxIdentifier("items"),
           types.jsxExpressionContainer(types.arrowFunctionExpression([], cloneExpression(plan.collection)))
         ),
+        ...keyedMapUpdateHints ? [
+          types.jsxAttribute(
+            types.jsxIdentifier("dependencies"),
+            types.jsxExpressionContainer(
+              types.arrayExpression(
+                plan.dependencies.map((dependency) => types.numericLiteral(dependency))
+              )
+            )
+          )
+        ] : [],
         types.jsxAttribute(
           types.jsxIdentifier("structureDependencies"),
           types.jsxExpressionContainer(
@@ -2183,6 +3453,36 @@ function keyedRowsBoundary(blockRuntime, plan) {
             )
           )
         ),
+        ...!keyedMapUpdateHints || plan.collectionDependency === void 0 ? [] : [
+          types.jsxAttribute(
+            types.jsxIdentifier("collectionDependency"),
+            types.jsxExpressionContainer(types.numericLiteral(plan.collectionDependency))
+          )
+        ],
+        ...plan.collectionDependency !== void 0 && keyedArrayFilterHintedStateIndices.has(plan.collectionDependency) ? [
+          types.jsxAttribute(
+            types.jsxIdentifier("filterIndexIndependent"),
+            types.jsxExpressionContainer(types.booleanLiteral(true))
+          )
+        ] : [],
+        ...plan.collectionDependency !== void 0 && keyedArrayPrependHintedStateIndices.has(plan.collectionDependency) ? [
+          types.jsxAttribute(
+            types.jsxIdentifier("prependIndexIndependent"),
+            types.jsxExpressionContainer(types.booleanLiteral(true))
+          )
+        ] : [],
+        ...plan.collectionDependency !== void 0 && keyedArrayPositionHintedStateIndices.has(plan.collectionDependency) ? [
+          types.jsxAttribute(
+            types.jsxIdentifier("positionIndexIndependent"),
+            types.jsxExpressionContainer(types.booleanLiteral(true))
+          )
+        ] : [],
+        ...plan.collectionDependency !== void 0 && keyedArrayReorderHintedStateIndices.has(plan.collectionDependency) ? [
+          types.jsxAttribute(
+            types.jsxIdentifier("reorderIndexIndependent"),
+            types.jsxExpressionContainer(types.booleanLiteral(true))
+          )
+        ] : [],
         types.jsxAttribute(
           types.jsxIdentifier("rowKey"),
           types.jsxExpressionContainer(types.cloneNode(plan.keyCallback, true))
@@ -2509,7 +3809,9 @@ function conditionalRangesBoundary(blockRuntime, plan) {
 function analyzeComponentIslandElement(element, statesByValue, safeGlobals, allowedComponentNames) {
   const name = element.openingElement.name;
   if (!types.isJSXIdentifier(name) || !isComponentName(name.name)) {
-    return { reason: "component islands require a direct component identifier" };
+    return {
+      reason: "component islands require a direct component identifier"
+    };
   }
   if (!allowedComponentNames.has(name.name)) {
     return {
@@ -2517,19 +3819,27 @@ function analyzeComponentIslandElement(element, statesByValue, safeGlobals, allo
     };
   }
   if (meaningfulJsxChildren(element).length > 0) {
-    return { reason: `component island ${name.name} does not support children yet` };
+    return {
+      reason: `component island ${name.name} does not support children yet`
+    };
   }
   const dependencies = /* @__PURE__ */ new Set();
   for (const attribute of element.openingElement.attributes) {
     if (types.isJSXSpreadAttribute(attribute)) {
-      return { reason: `component island ${name.name} does not support JSX attribute spreads` };
+      return {
+        reason: `component island ${name.name} does not support JSX attribute spreads`
+      };
     }
     const attributeName = jsxAttributeName(attribute);
     if (!attributeName) {
-      return { reason: `component island ${name.name} does not support namespaced JSX attributes` };
+      return {
+        reason: `component island ${name.name} does not support namespaced JSX attributes`
+      };
     }
     if (attributeName === "ref" || attributeName === "key" || attributeName === "children") {
-      return { reason: `component island ${name.name} does not support ${attributeName} yet` };
+      return {
+        reason: `component island ${name.name} does not support ${attributeName} yet`
+      };
     }
     if (!types.isJSXExpressionContainer(attribute.value) || types.isJSXEmptyExpression(attribute.value.expression)) {
       continue;
@@ -2548,7 +3858,9 @@ function analyzeComponentIslandElement(element, statesByValue, safeGlobals, allo
       (dependency) => dependencies.add(dependency)
     );
   }
-  return { dependencies: [...dependencies].sort((left, right) => left - right) };
+  return {
+    dependencies: [...dependencies].sort((left, right) => left - right)
+  };
 }
 function componentIslandBoundary(blockRuntime, plan, source) {
   const name = types.jsxMemberExpression(
@@ -2805,6 +4117,7 @@ function analyzeComposableBlocks(root, statesByValue, safeGlobals, listNames, al
               dependencies: keyedRows.dependencies,
               source: child,
               collection: keyedRows.collection,
+              collectionDependency: keyedRows.collectionDependency,
               structureDependencies: keyedRows.structureDependencies,
               keyCallback: keyedRows.keyCallback,
               renderCallback: keyedRows.renderCallback,
@@ -3046,7 +4359,7 @@ function conditionalBlockBoundary(blockRuntime, plan, source) {
     true
   );
 }
-function lowerComposableBlocks(root, plans, blockRuntime, listNames) {
+function lowerComposableBlocks(root, plans, blockRuntime, listNames, keyedMapUpdateHints, keyedArrayFilterHintedStateIndices, keyedArrayPrependHintedStateIndices, keyedArrayPositionHintedStateIndices, keyedArrayReorderHintedStateIndices) {
   const planBySource = new Map(
     plans.map((plan) => [plan.source, plan])
   );
@@ -3071,7 +4384,15 @@ function lowerComposableBlocks(root, plans, blockRuntime, listNames) {
           return mixedRangesBoundary(blockRuntime, plan2);
         }
         if (plan2?.kind === "keyed-rows") {
-          return keyedRowsBoundary(blockRuntime, plan2);
+          return keyedRowsBoundary(
+            blockRuntime,
+            plan2,
+            keyedMapUpdateHints,
+            keyedArrayFilterHintedStateIndices,
+            keyedArrayPrependHintedStateIndices,
+            keyedArrayPositionHintedStateIndices,
+            keyedArrayReorderHintedStateIndices
+          );
         }
         if (plan2?.kind === "keyed-ranges") {
           return keyedRangesBoundary(blockRuntime, plan2);
@@ -3434,7 +4755,7 @@ function wrapperElement(definitionIdentifier, props) {
   const attributes = props ? [types.jsxSpreadAttribute(types.cloneNode(props))] : [];
   return types.jsxElement(types.jsxOpeningElement(name, attributes, true), null, [], true);
 }
-function compileCandidate(candidate, createComponentIdentifier, runtimeFeatureIdentifiers, usedRuntimeFeatures, useStateNames, reactNames, listNames, moduleId, reactivity) {
+function compileCandidate(candidate, createComponentIdentifier, keyedMapUpdateIdentifier, keyedArrayAppendIdentifier, keyedArrayFilterIdentifier, keyedArrayPrependIdentifier, keyedArrayPositionIdentifier, keyedArrayReorderIdentifier, keyedArrayRollingWindowIdentifier, keyedArraySliceIdentifier, keyedCollectionUpdateIdentifier, keyedCollectionMutationIdentifier, runtimeFeatureIdentifiers, usedRuntimeFeatures, optimizationCounts, useStateNames, reactNames, listNames, moduleId, reactivity) {
   const { path, name, statementPath } = candidate;
   if (path.node.async || path.node.generator)
     return "async and generator components are not supported";
@@ -3446,6 +4767,7 @@ function compileCandidate(candidate, createComponentIdentifier, runtimeFeatureId
   const safeGlobals = new Set(
     [...SAFE_GLOBAL_CALLS, "Math"].filter((name2) => !path.scope.getBinding(name2))
   );
+  const globalCollections = new Set(["Set", "Map"].filter((name2) => !path.scope.getBinding(name2)));
   const states = [];
   const locals = [];
   let returned;
@@ -3493,9 +4815,17 @@ function compileCandidate(candidate, createComponentIdentifier, runtimeFeatureId
       if (declaration.init.async || declaration.init.generator) {
         return `event handler ${declaration.id.name} must be synchronous`;
       }
-      locals.push({ kind: "handler", name: declaration.id.name, value: declaration.init });
+      locals.push({
+        kind: "handler",
+        name: declaration.id.name,
+        value: declaration.init
+      });
     } else {
-      locals.push({ kind: "derived", name: declaration.id.name, value: declaration.init });
+      locals.push({
+        kind: "derived",
+        name: declaration.id.name,
+        value: declaration.init
+      });
     }
   }
   if (states.length === 0) return "no local useState binding was found";
@@ -3634,8 +4964,378 @@ function compileCandidate(candidate, createComponentIdentifier, runtimeFeatureId
   }
   if (blockAnalysis.reason) return blockAnalysis.reason;
   if (analysis.reason) return analysis.reason;
+  const hintedStateIndices = new Set(
+    (blockAnalysis.plans || []).filter(
+      (plan) => plan.kind === "keyed-rows" && plan.collectionDependency !== void 0
+    ).map((plan) => plan.collectionDependency)
+  );
+  const hintedRoot = rewriteKeyedMapUpdateHints(
+    expandedReactiveRoot,
+    hintedStateIndices,
+    statesBySetter,
+    keyedMapUpdateIdentifier,
+    safeGlobals
+  );
+  let appliedKeyedMapUpdateHints = 0;
+  if (hintedRoot.count > 0) {
+    const hintedBlockAnalysis = analyzeComposableBlocks(
+      hintedRoot.root,
+      reactiveByValue,
+      safeGlobals,
+      listNames,
+      allowedComponentNames
+    );
+    const hintedAnalysis = analyzeHostTree(
+      hintedRoot.root,
+      reactiveByValue,
+      safeGlobals,
+      hintedBlockAnalysis.conditionalExpressions || /* @__PURE__ */ new Set(),
+      hintedBlockAnalysis.keyedExpressions || /* @__PURE__ */ new Set(),
+      hintedBlockAnalysis.ownedElements || /* @__PURE__ */ new Set(),
+      hintedBlockAnalysis.componentElements || /* @__PURE__ */ new Set()
+    );
+    if (!hintedBlockAnalysis.reason && !hintedAnalysis.reason) {
+      expandedReactiveRoot = hintedRoot.root;
+      blockAnalysis = hintedBlockAnalysis;
+      analysis = hintedAnalysis;
+      appliedKeyedMapUpdateHints = hintedRoot.count;
+      optimizationCounts.keyedMapUpdateHints += hintedRoot.count;
+    }
+  }
+  const appendHintedStateIndices = new Set(hintedStateIndices);
+  for (const plan of blockAnalysis.plans || []) {
+    if (plan.kind !== "keyed-rows" || plan.collectionDependency === void 0) continue;
+    const keyExpression = returnedExpression(plan.keyCallback);
+    if (!keyExpression || collectStateDependencies(keyExpression, reactiveByValue).includes(plan.collectionDependency)) {
+      appendHintedStateIndices.delete(plan.collectionDependency);
+    }
+  }
+  const appendHintedRoot = rewriteKeyedArrayAppendHints(
+    expandedReactiveRoot,
+    appendHintedStateIndices,
+    statesBySetter,
+    keyedArrayAppendIdentifier,
+    safeGlobals
+  );
+  let appliedKeyedArrayAppendHints = 0;
+  if (appendHintedRoot.count > 0) {
+    const hintedBlockAnalysis = analyzeComposableBlocks(
+      appendHintedRoot.root,
+      reactiveByValue,
+      safeGlobals,
+      listNames,
+      allowedComponentNames
+    );
+    const hintedAnalysis = analyzeHostTree(
+      appendHintedRoot.root,
+      reactiveByValue,
+      safeGlobals,
+      hintedBlockAnalysis.conditionalExpressions || /* @__PURE__ */ new Set(),
+      hintedBlockAnalysis.keyedExpressions || /* @__PURE__ */ new Set(),
+      hintedBlockAnalysis.ownedElements || /* @__PURE__ */ new Set(),
+      hintedBlockAnalysis.componentElements || /* @__PURE__ */ new Set()
+    );
+    if (!hintedBlockAnalysis.reason && !hintedAnalysis.reason) {
+      expandedReactiveRoot = appendHintedRoot.root;
+      blockAnalysis = hintedBlockAnalysis;
+      analysis = hintedAnalysis;
+      appliedKeyedArrayAppendHints = appendHintedRoot.count;
+      optimizationCounts.keyedArrayAppendHints += appendHintedRoot.count;
+    }
+  }
+  const shiftedIndexIndependentStateIndices = new Set(hintedStateIndices);
+  for (const plan of blockAnalysis.plans || []) {
+    if (plan.kind !== "keyed-rows" || plan.collectionDependency === void 0) continue;
+    const keyExpression = returnedExpression(plan.keyCallback);
+    if (plan.renderCallback.params.length > 1 || !keyExpression || collectStateDependencies(keyExpression, reactiveByValue).includes(plan.collectionDependency)) {
+      shiftedIndexIndependentStateIndices.delete(plan.collectionDependency);
+    }
+  }
+  const prependHintedRoot = rewriteKeyedArrayPrependHints(
+    expandedReactiveRoot,
+    shiftedIndexIndependentStateIndices,
+    statesBySetter,
+    keyedArrayPrependIdentifier,
+    safeGlobals
+  );
+  let appliedKeyedArrayPrependHints = 0;
+  let appliedPrependHintedStateIndices = /* @__PURE__ */ new Set();
+  if (prependHintedRoot.count > 0) {
+    const hintedBlockAnalysis = analyzeComposableBlocks(
+      prependHintedRoot.root,
+      reactiveByValue,
+      safeGlobals,
+      listNames,
+      allowedComponentNames
+    );
+    const hintedAnalysis = analyzeHostTree(
+      prependHintedRoot.root,
+      reactiveByValue,
+      safeGlobals,
+      hintedBlockAnalysis.conditionalExpressions || /* @__PURE__ */ new Set(),
+      hintedBlockAnalysis.keyedExpressions || /* @__PURE__ */ new Set(),
+      hintedBlockAnalysis.ownedElements || /* @__PURE__ */ new Set(),
+      hintedBlockAnalysis.componentElements || /* @__PURE__ */ new Set()
+    );
+    if (!hintedBlockAnalysis.reason && !hintedAnalysis.reason) {
+      expandedReactiveRoot = prependHintedRoot.root;
+      blockAnalysis = hintedBlockAnalysis;
+      analysis = hintedAnalysis;
+      appliedKeyedArrayPrependHints = prependHintedRoot.count;
+      appliedPrependHintedStateIndices = prependHintedRoot.stateIndices;
+      optimizationCounts.keyedArrayPrependHints += prependHintedRoot.count;
+    }
+  }
+  const rollingWindowHintedRoot = rewriteKeyedArrayRollingWindowHints(
+    expandedReactiveRoot,
+    shiftedIndexIndependentStateIndices,
+    statesBySetter,
+    keyedArraySliceIdentifier,
+    keyedArrayRollingWindowIdentifier,
+    safeGlobals
+  );
+  let appliedKeyedArrayRollingWindowHints = 0;
+  let appliedRollingWindowHintedStateIndices = /* @__PURE__ */ new Set();
+  if (rollingWindowHintedRoot.count > 0) {
+    const hintedBlockAnalysis = analyzeComposableBlocks(
+      rollingWindowHintedRoot.root,
+      reactiveByValue,
+      safeGlobals,
+      listNames,
+      allowedComponentNames
+    );
+    const hintedAnalysis = analyzeHostTree(
+      rollingWindowHintedRoot.root,
+      reactiveByValue,
+      safeGlobals,
+      hintedBlockAnalysis.conditionalExpressions || /* @__PURE__ */ new Set(),
+      hintedBlockAnalysis.keyedExpressions || /* @__PURE__ */ new Set(),
+      hintedBlockAnalysis.ownedElements || /* @__PURE__ */ new Set(),
+      hintedBlockAnalysis.componentElements || /* @__PURE__ */ new Set()
+    );
+    if (!hintedBlockAnalysis.reason && !hintedAnalysis.reason) {
+      expandedReactiveRoot = rollingWindowHintedRoot.root;
+      blockAnalysis = hintedBlockAnalysis;
+      analysis = hintedAnalysis;
+      appliedKeyedArrayRollingWindowHints = rollingWindowHintedRoot.count;
+      appliedRollingWindowHintedStateIndices = rollingWindowHintedRoot.stateIndices;
+      optimizationCounts.keyedArrayRollingWindowHints += rollingWindowHintedRoot.count;
+    }
+  }
+  const positionHintedRoot = rewriteKeyedArrayPositionHints(
+    expandedReactiveRoot,
+    shiftedIndexIndependentStateIndices,
+    statesBySetter,
+    keyedArrayPositionIdentifier,
+    safeGlobals
+  );
+  let appliedKeyedArrayPositionHints = 0;
+  let appliedPositionHintedStateIndices = /* @__PURE__ */ new Set();
+  if (positionHintedRoot.count > 0) {
+    const hintedBlockAnalysis = analyzeComposableBlocks(
+      positionHintedRoot.root,
+      reactiveByValue,
+      safeGlobals,
+      listNames,
+      allowedComponentNames
+    );
+    const hintedAnalysis = analyzeHostTree(
+      positionHintedRoot.root,
+      reactiveByValue,
+      safeGlobals,
+      hintedBlockAnalysis.conditionalExpressions || /* @__PURE__ */ new Set(),
+      hintedBlockAnalysis.keyedExpressions || /* @__PURE__ */ new Set(),
+      hintedBlockAnalysis.ownedElements || /* @__PURE__ */ new Set(),
+      hintedBlockAnalysis.componentElements || /* @__PURE__ */ new Set()
+    );
+    if (!hintedBlockAnalysis.reason && !hintedAnalysis.reason) {
+      expandedReactiveRoot = positionHintedRoot.root;
+      blockAnalysis = hintedBlockAnalysis;
+      analysis = hintedAnalysis;
+      appliedKeyedArrayPositionHints = positionHintedRoot.count;
+      appliedPositionHintedStateIndices = positionHintedRoot.stateIndices;
+      optimizationCounts.keyedArrayPositionHints += positionHintedRoot.count;
+    }
+  }
+  const reorderHintedRoot = rewriteKeyedArrayReorderHints(
+    expandedReactiveRoot,
+    shiftedIndexIndependentStateIndices,
+    statesBySetter,
+    keyedArrayReorderIdentifier
+  );
+  let appliedKeyedArrayReorderHints = 0;
+  let appliedReorderHintedStateIndices = /* @__PURE__ */ new Set();
+  if (reorderHintedRoot.count > 0) {
+    const hintedBlockAnalysis = analyzeComposableBlocks(
+      reorderHintedRoot.root,
+      reactiveByValue,
+      safeGlobals,
+      listNames,
+      allowedComponentNames
+    );
+    const hintedAnalysis = analyzeHostTree(
+      reorderHintedRoot.root,
+      reactiveByValue,
+      safeGlobals,
+      hintedBlockAnalysis.conditionalExpressions || /* @__PURE__ */ new Set(),
+      hintedBlockAnalysis.keyedExpressions || /* @__PURE__ */ new Set(),
+      hintedBlockAnalysis.ownedElements || /* @__PURE__ */ new Set(),
+      hintedBlockAnalysis.componentElements || /* @__PURE__ */ new Set()
+    );
+    if (!hintedBlockAnalysis.reason && !hintedAnalysis.reason) {
+      expandedReactiveRoot = reorderHintedRoot.root;
+      blockAnalysis = hintedBlockAnalysis;
+      analysis = hintedAnalysis;
+      appliedKeyedArrayReorderHints = reorderHintedRoot.count;
+      appliedReorderHintedStateIndices = reorderHintedRoot.stateIndices;
+      optimizationCounts.keyedArrayReorderHints += reorderHintedRoot.count;
+    }
+  }
+  const sliceHintedRoot = rewriteKeyedArraySliceHints(
+    expandedReactiveRoot,
+    shiftedIndexIndependentStateIndices,
+    statesBySetter,
+    keyedArraySliceIdentifier
+  );
+  let appliedKeyedArraySliceHints = 0;
+  let appliedSliceHintedStateIndices = /* @__PURE__ */ new Set();
+  if (sliceHintedRoot.count > 0) {
+    const hintedBlockAnalysis = analyzeComposableBlocks(
+      sliceHintedRoot.root,
+      reactiveByValue,
+      safeGlobals,
+      listNames,
+      allowedComponentNames
+    );
+    const hintedAnalysis = analyzeHostTree(
+      sliceHintedRoot.root,
+      reactiveByValue,
+      safeGlobals,
+      hintedBlockAnalysis.conditionalExpressions || /* @__PURE__ */ new Set(),
+      hintedBlockAnalysis.keyedExpressions || /* @__PURE__ */ new Set(),
+      hintedBlockAnalysis.ownedElements || /* @__PURE__ */ new Set(),
+      hintedBlockAnalysis.componentElements || /* @__PURE__ */ new Set()
+    );
+    if (!hintedBlockAnalysis.reason && !hintedAnalysis.reason) {
+      expandedReactiveRoot = sliceHintedRoot.root;
+      blockAnalysis = hintedBlockAnalysis;
+      analysis = hintedAnalysis;
+      appliedKeyedArraySliceHints = sliceHintedRoot.count;
+      appliedSliceHintedStateIndices = sliceHintedRoot.stateIndices;
+      optimizationCounts.keyedArraySliceHints += sliceHintedRoot.count;
+    }
+  }
+  const filterHintedRoot = rewriteKeyedArrayFilterHints(
+    expandedReactiveRoot,
+    shiftedIndexIndependentStateIndices,
+    statesBySetter,
+    keyedArrayFilterIdentifier,
+    safeGlobals
+  );
+  let appliedKeyedArrayFilterHints = 0;
+  let appliedFilterHintedStateIndices = /* @__PURE__ */ new Set();
+  if (filterHintedRoot.count > 0) {
+    const hintedBlockAnalysis = analyzeComposableBlocks(
+      filterHintedRoot.root,
+      reactiveByValue,
+      safeGlobals,
+      listNames,
+      allowedComponentNames
+    );
+    const hintedAnalysis = analyzeHostTree(
+      filterHintedRoot.root,
+      reactiveByValue,
+      safeGlobals,
+      hintedBlockAnalysis.conditionalExpressions || /* @__PURE__ */ new Set(),
+      hintedBlockAnalysis.keyedExpressions || /* @__PURE__ */ new Set(),
+      hintedBlockAnalysis.ownedElements || /* @__PURE__ */ new Set(),
+      hintedBlockAnalysis.componentElements || /* @__PURE__ */ new Set()
+    );
+    if (!hintedBlockAnalysis.reason && !hintedAnalysis.reason) {
+      expandedReactiveRoot = filterHintedRoot.root;
+      blockAnalysis = hintedBlockAnalysis;
+      analysis = hintedAnalysis;
+      appliedKeyedArrayFilterHints = filterHintedRoot.count;
+      appliedFilterHintedStateIndices = filterHintedRoot.stateIndices;
+      optimizationCounts.keyedArrayFilterHints += filterHintedRoot.count;
+    }
+  }
+  const keyedCollectionTargetKinds = /* @__PURE__ */ new Map();
+  const conflictingKeyedCollectionTargets = /* @__PURE__ */ new Set();
+  for (const plan of blockAnalysis.plans || []) {
+    if (plan.kind !== "keyed-rows") continue;
+    for (const binding of plan.bindings) {
+      const target = binding.membershipTarget || binding.mapLookupTarget;
+      if (!target) continue;
+      const kind = binding.membershipTarget ? "set" : "map";
+      const previousKind = keyedCollectionTargetKinds.get(target.dependency);
+      if (previousKind && previousKind !== kind) {
+        conflictingKeyedCollectionTargets.add(target.dependency);
+      } else {
+        keyedCollectionTargetKinds.set(target.dependency, kind);
+      }
+    }
+  }
+  for (const dependency of conflictingKeyedCollectionTargets) {
+    keyedCollectionTargetKinds.delete(dependency);
+  }
+  const keyedCollectionHintedRoot = rewriteKeyedCollectionUpdateHints(
+    expandedReactiveRoot,
+    keyedCollectionTargetKinds,
+    states,
+    statesBySetter,
+    keyedCollectionUpdateIdentifier,
+    keyedCollectionMutationIdentifier,
+    globalCollections
+  );
+  if (keyedCollectionHintedRoot.count > 0) {
+    const hintedBlockAnalysis = analyzeComposableBlocks(
+      keyedCollectionHintedRoot.root,
+      reactiveByValue,
+      safeGlobals,
+      listNames,
+      allowedComponentNames
+    );
+    const hintedAnalysis = analyzeHostTree(
+      keyedCollectionHintedRoot.root,
+      reactiveByValue,
+      safeGlobals,
+      hintedBlockAnalysis.conditionalExpressions || /* @__PURE__ */ new Set(),
+      hintedBlockAnalysis.keyedExpressions || /* @__PURE__ */ new Set(),
+      hintedBlockAnalysis.ownedElements || /* @__PURE__ */ new Set(),
+      hintedBlockAnalysis.componentElements || /* @__PURE__ */ new Set()
+    );
+    if (!hintedBlockAnalysis.reason && !hintedAnalysis.reason) {
+      expandedReactiveRoot = keyedCollectionHintedRoot.root;
+      blockAnalysis = hintedBlockAnalysis;
+      analysis = hintedAnalysis;
+      optimizationCounts.keyedCollectionUpdateHints += keyedCollectionHintedRoot.count;
+    }
+  }
   const blockPlans = blockAnalysis.plans || [];
-  const runtimeFeatures = runtimeFeaturesForPlans(blockPlans);
+  optimizationCounts.keyedIdentityTargets += blockPlans.reduce(
+    (count, plan) => count + (plan.kind === "keyed-rows" ? plan.bindings.filter((binding) => binding.identityTarget !== void 0).length : 0),
+    0
+  );
+  optimizationCounts.keyedMembershipTargets += blockPlans.reduce(
+    (count, plan) => count + (plan.kind === "keyed-rows" ? plan.bindings.filter((binding) => binding.membershipTarget !== void 0).length : 0),
+    0
+  );
+  optimizationCounts.keyedMapLookupTargets += blockPlans.reduce(
+    (count, plan) => count + (plan.kind === "keyed-rows" ? plan.bindings.filter((binding) => binding.mapLookupTarget !== void 0).length : 0),
+    0
+  );
+  const hasKeyedUpdateHints = appliedKeyedMapUpdateHints > 0 || appliedKeyedArrayAppendHints > 0 || appliedKeyedArrayFilterHints > 0 || appliedKeyedArrayPrependHints > 0 || appliedKeyedArrayPositionHints > 0 || appliedKeyedArrayReorderHints > 0 || appliedKeyedArrayRollingWindowHints > 0 || appliedKeyedArraySliceHints > 0;
+  const hasKeyedArrayRemovalHints = appliedKeyedArrayFilterHints > 0 || appliedKeyedArrayRollingWindowHints > 0 || appliedKeyedArraySliceHints > 0;
+  const runtimeFeatures = runtimeFeaturesForPlans(
+    blockPlans,
+    hasKeyedUpdateHints,
+    hasKeyedArrayRemovalHints,
+    appliedKeyedArrayPrependHints > 0,
+    appliedKeyedArrayPositionHints > 0,
+    appliedKeyedArrayReorderHints > 0,
+    appliedKeyedArrayRollingWindowHints > 0
+  );
   markShortCircuitBindings(analysis.bindings || []);
   assignStableBindingTargets(analysis.bindings || []);
   const stateParameter = path.scope.generateUidIdentifier("farmState");
@@ -3648,11 +5348,21 @@ function compileCandidate(candidate, createComponentIdentifier, runtimeFeatureId
     blockParameter,
     blockAnalysis.ownedElements || /* @__PURE__ */ new Set()
   );
+  const appliedRemovalHintedStateIndices = /* @__PURE__ */ new Set([
+    ...appliedFilterHintedStateIndices,
+    ...appliedRollingWindowHintedStateIndices,
+    ...appliedSliceHintedStateIndices
+  ]);
   const rootWithBlocks = lowerComposableBlocks(
     rootWithTargets,
     blockPlans,
     blockParameter,
-    listNames
+    listNames,
+    hasKeyedUpdateHints,
+    appliedRemovalHintedStateIndices,
+    appliedPrependHintedStateIndices,
+    appliedPositionHintedStateIndices,
+    appliedReorderHintedStateIndices
   );
   const rewrittenRoot = rewriteStateAccess(
     rootWithBlocks,
@@ -3790,6 +5500,20 @@ function collectCandidates(programPath) {
 async function compileReactModule(code, id, options) {
   const compiled = [];
   const diagnostics = [];
+  const optimizationCounts = {
+    keyedArrayAppendHints: 0,
+    keyedArrayFilterHints: 0,
+    keyedArrayPrependHints: 0,
+    keyedArrayPositionHints: 0,
+    keyedArrayReorderHints: 0,
+    keyedArrayRollingWindowHints: 0,
+    keyedArraySliceHints: 0,
+    keyedCollectionUpdateHints: 0,
+    keyedIdentityTargets: 0,
+    keyedMapLookupTargets: 0,
+    keyedMembershipTargets: 0,
+    keyedMapUpdateHints: 0
+  };
   const plugin = () => ({
     name: "farm-react-aot",
     visitor: {
@@ -3819,6 +5543,36 @@ async function compileReactModule(code, id, options) {
         }
         const candidates = collectCandidates(programPath);
         const createComponentIdentifier = programPath.scope.generateUidIdentifier("createCompiledComponent");
+        const keyedMapUpdateIdentifier = programPath.scope.generateUidIdentifier(
+          "createCompilerKeyedMapUpdate"
+        );
+        const keyedArrayAppendIdentifier = programPath.scope.generateUidIdentifier(
+          "createCompilerKeyedArrayAppend"
+        );
+        const keyedArrayFilterIdentifier = programPath.scope.generateUidIdentifier(
+          "createCompilerKeyedArrayFilter"
+        );
+        const keyedArrayPrependIdentifier = programPath.scope.generateUidIdentifier(
+          "createCompilerKeyedArrayPrepend"
+        );
+        const keyedArrayPositionIdentifier = programPath.scope.generateUidIdentifier(
+          "createCompilerKeyedArrayPositionUpdate"
+        );
+        const keyedArrayReorderIdentifier = programPath.scope.generateUidIdentifier(
+          "createCompilerKeyedArrayReorder"
+        );
+        const keyedArrayRollingWindowIdentifier = programPath.scope.generateUidIdentifier(
+          "createCompilerKeyedArrayRollingWindow"
+        );
+        const keyedArraySliceIdentifier = programPath.scope.generateUidIdentifier(
+          "createCompilerKeyedArraySlice"
+        );
+        const keyedCollectionUpdateIdentifier = programPath.scope.generateUidIdentifier(
+          "createCompilerKeyedCollectionUpdate"
+        );
+        const keyedCollectionMutationIdentifier = programPath.scope.generateUidIdentifier(
+          "applyCompilerKeyedCollectionMutation"
+        );
         const runtimeFeatureIdentifiers = new Map(
           Object.entries(COMPILER_RUNTIME_FEATURE_EXPORTS).map(([feature, exportName]) => [
             feature,
@@ -3836,8 +5590,19 @@ async function compileReactModule(code, id, options) {
           const reason = compileCandidate(
             candidate,
             createComponentIdentifier,
+            keyedMapUpdateIdentifier,
+            keyedArrayAppendIdentifier,
+            keyedArrayFilterIdentifier,
+            keyedArrayPrependIdentifier,
+            keyedArrayPositionIdentifier,
+            keyedArrayReorderIdentifier,
+            keyedArrayRollingWindowIdentifier,
+            keyedArraySliceIdentifier,
+            keyedCollectionUpdateIdentifier,
+            keyedCollectionMutationIdentifier,
             runtimeFeatureIdentifiers,
             usedRuntimeFeatures,
+            optimizationCounts,
             useStateNames,
             reactNames,
             listNames,
@@ -3863,6 +5628,64 @@ async function compileReactModule(code, id, options) {
                   createComponentIdentifier,
                   types.identifier("createCompiledComponentWithFeatures")
                 ),
+                ...optimizationCounts.keyedMapUpdateHints > 0 ? [
+                  types.importSpecifier(
+                    keyedMapUpdateIdentifier,
+                    types.identifier("createCompilerKeyedMapUpdate")
+                  )
+                ] : [],
+                ...optimizationCounts.keyedArrayAppendHints > 0 ? [
+                  types.importSpecifier(
+                    keyedArrayAppendIdentifier,
+                    types.identifier("createCompilerKeyedArrayAppend")
+                  )
+                ] : [],
+                ...optimizationCounts.keyedArrayFilterHints > 0 ? [
+                  types.importSpecifier(
+                    keyedArrayFilterIdentifier,
+                    types.identifier("createCompilerKeyedArrayFilter")
+                  )
+                ] : [],
+                ...optimizationCounts.keyedArrayPrependHints > 0 ? [
+                  types.importSpecifier(
+                    keyedArrayPrependIdentifier,
+                    types.identifier("createCompilerKeyedArrayPrepend")
+                  )
+                ] : [],
+                ...optimizationCounts.keyedArrayPositionHints > 0 ? [
+                  types.importSpecifier(
+                    keyedArrayPositionIdentifier,
+                    types.identifier("createCompilerKeyedArrayPositionUpdate")
+                  )
+                ] : [],
+                ...optimizationCounts.keyedArrayReorderHints > 0 ? [
+                  types.importSpecifier(
+                    keyedArrayReorderIdentifier,
+                    types.identifier("createCompilerKeyedArrayReorder")
+                  )
+                ] : [],
+                ...optimizationCounts.keyedArrayRollingWindowHints > 0 ? [
+                  types.importSpecifier(
+                    keyedArrayRollingWindowIdentifier,
+                    types.identifier("createCompilerKeyedArrayRollingWindow")
+                  )
+                ] : [],
+                ...optimizationCounts.keyedArraySliceHints > 0 || optimizationCounts.keyedArrayRollingWindowHints > 0 ? [
+                  types.importSpecifier(
+                    keyedArraySliceIdentifier,
+                    types.identifier("createCompilerKeyedArraySlice")
+                  )
+                ] : [],
+                ...optimizationCounts.keyedCollectionUpdateHints > 0 ? [
+                  types.importSpecifier(
+                    keyedCollectionUpdateIdentifier,
+                    types.identifier("createCompilerKeyedCollectionUpdate")
+                  ),
+                  types.importSpecifier(
+                    keyedCollectionMutationIdentifier,
+                    types.identifier("applyCompilerKeyedCollectionMutation")
+                  )
+                ] : [],
                 ...[...usedRuntimeFeatures].sort().map(
                   (feature) => types.importSpecifier(
                     types.cloneNode(runtimeFeatureIdentifiers.get(feature)),
@@ -3899,7 +5722,8 @@ async function compileReactModule(code, id, options) {
     code: result?.code || code,
     map: result?.map || null,
     compiled,
-    diagnostics
+    diagnostics,
+    optimizations: optimizationCounts
   };
 }
 function projectRelativeId(projectRoot, id) {
@@ -3910,10 +5734,34 @@ function createReactCompilerReport(projectRoot, observations) {
   let componentsConsidered = 0;
   let compiled = 0;
   let fallback = 0;
+  let keyedArrayAppendHints = 0;
+  let keyedArrayFilterHints = 0;
+  let keyedArrayPrependHints = 0;
+  let keyedArrayPositionHints = 0;
+  let keyedArrayReorderHints = 0;
+  let keyedArrayRollingWindowHints = 0;
+  let keyedArraySliceHints = 0;
+  let keyedCollectionUpdateHints = 0;
+  let keyedIdentityTargets = 0;
+  let keyedMapLookupTargets = 0;
+  let keyedMembershipTargets = 0;
+  let keyedMapUpdateHints = 0;
   const modules = [...observations].map(({ id, result }) => {
     componentsConsidered += result.compiled.length + result.diagnostics.length;
     compiled += result.compiled.length;
     fallback += result.diagnostics.length;
+    keyedArrayAppendHints += result.optimizations.keyedArrayAppendHints || 0;
+    keyedArrayFilterHints += result.optimizations.keyedArrayFilterHints || 0;
+    keyedArrayPrependHints += result.optimizations.keyedArrayPrependHints || 0;
+    keyedArrayPositionHints += result.optimizations.keyedArrayPositionHints || 0;
+    keyedArrayReorderHints += result.optimizations.keyedArrayReorderHints || 0;
+    keyedArrayRollingWindowHints += result.optimizations.keyedArrayRollingWindowHints || 0;
+    keyedArraySliceHints += result.optimizations.keyedArraySliceHints || 0;
+    keyedCollectionUpdateHints += result.optimizations.keyedCollectionUpdateHints || 0;
+    keyedIdentityTargets += result.optimizations.keyedIdentityTargets || 0;
+    keyedMapLookupTargets += result.optimizations.keyedMapLookupTargets || 0;
+    keyedMembershipTargets += result.optimizations.keyedMembershipTargets || 0;
+    keyedMapUpdateHints += result.optimizations.keyedMapUpdateHints;
     const moduleId = projectRelativeId(projectRoot, id);
     const fallbacks = result.diagnostics.map((diagnostic) => {
       reasonCounts.set(diagnostic.reason, (reasonCounts.get(diagnostic.reason) || 0) + 1);
@@ -3922,6 +5770,7 @@ function createReactCompilerReport(projectRoot, observations) {
     return {
       id: moduleId,
       compiled: [...result.compiled].sort(),
+      optimizations: result.optimizations,
       fallbacks
     };
   }).sort((left, right) => left.id.localeCompare(right.id));
@@ -3932,7 +5781,19 @@ function createReactCompilerReport(projectRoot, observations) {
       modules: modules.length,
       componentsConsidered,
       compiled,
-      fallback
+      fallback,
+      keyedArrayAppendHints,
+      keyedArrayFilterHints,
+      keyedArrayPrependHints,
+      keyedArrayPositionHints,
+      keyedArrayReorderHints,
+      keyedArrayRollingWindowHints,
+      keyedArraySliceHints,
+      keyedCollectionUpdateHints,
+      keyedIdentityTargets,
+      keyedMapLookupTargets,
+      keyedMembershipTargets,
+      keyedMapUpdateHints
     },
     fallbackReasons,
     modules