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

package/dist/vite.cjs

@@ -70,44 +70,77 @@ var COMPILER_RUNTIME_FEATURE_EXPORTS = {
   "keyed-rows": "keyedRowsRuntimeFeature",
   "keyed-rows-hinted": "keyedRowsHintedRuntimeFeature",
   "keyed-rows-position-hinted": "keyedRowsPositionHintedRuntimeFeature",
+  "keyed-rows-batch-position-hinted": "keyedRowsBatchPositionHintedRuntimeFeature",
+  "keyed-rows-window-position-hinted": "keyedRowsWindowPositionHintedRuntimeFeature",
   "keyed-rows-reorder-hinted": "keyedRowsReorderHintedRuntimeFeature",
+  "keyed-rows-map-reorder-hinted": "keyedRowsMapReorderHintedRuntimeFeature",
   "keyed-rows-all-hinted": "keyedRowsAllHintedRuntimeFeature",
   "keyed-rows-every-hinted": "keyedRowsEveryHintedRuntimeFeature",
+  "keyed-rows-batch-every-hinted": "keyedRowsBatchEveryHintedRuntimeFeature",
+  "keyed-rows-window-every-hinted": "keyedRowsWindowEveryHintedRuntimeFeature",
   "keyed-rows-filter-hinted": "keyedRowsFilterHintedRuntimeFeature",
+  "keyed-rows-structural-append-hinted": "keyedRowsStructuralAppendHintedRuntimeFeature",
+  "keyed-rows-structural-append-map-hinted": "keyedRowsStructuralAppendMapHintedRuntimeFeature",
+  "keyed-rows-structural-prepend-hinted": "keyedRowsStructuralPrependHintedRuntimeFeature",
+  "keyed-rows-structural-prepend-map-hinted": "keyedRowsStructuralPrependMapHintedRuntimeFeature",
   "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-batch-position-hinted": "keyedRowsConditionalBatchPositionHintedRuntimeFeature",
+  "keyed-rows-conditional-window-position-hinted": "keyedRowsConditionalWindowPositionHintedRuntimeFeature",
   "keyed-rows-conditional-reorder-hinted": "keyedRowsConditionalReorderHintedRuntimeFeature",
   "keyed-rows-conditional-all-hinted": "keyedRowsConditionalAllHintedRuntimeFeature",
   "keyed-rows-conditional-every-hinted": "keyedRowsConditionalEveryHintedRuntimeFeature",
+  "keyed-rows-conditional-batch-every-hinted": "keyedRowsConditionalBatchEveryHintedRuntimeFeature",
+  "keyed-rows-conditional-window-every-hinted": "keyedRowsConditionalWindowEveryHintedRuntimeFeature",
   "keyed-rows-conditional-filter-hinted": "keyedRowsConditionalFilterHintedRuntimeFeature",
+  "keyed-rows-conditional-structural-append-hinted": "keyedRowsConditionalStructuralAppendHintedRuntimeFeature",
+  "keyed-rows-conditional-structural-append-map-hinted": "keyedRowsConditionalStructuralAppendMapHintedRuntimeFeature",
+  "keyed-rows-conditional-structural-prepend-hinted": "keyedRowsConditionalStructuralPrependHintedRuntimeFeature",
+  "keyed-rows-conditional-structural-prepend-map-hinted": "keyedRowsConditionalStructuralPrependMapHintedRuntimeFeature",
   "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-batch-position-hinted": "keyedRowsHostBatchPositionHintedRuntimeFeature",
+  "keyed-rows-host-window-position-hinted": "keyedRowsHostWindowPositionHintedRuntimeFeature",
   "keyed-rows-host-reorder-hinted": "keyedRowsHostReorderHintedRuntimeFeature",
   "keyed-rows-host-all-hinted": "keyedRowsHostAllHintedRuntimeFeature",
   "keyed-rows-host-every-hinted": "keyedRowsHostEveryHintedRuntimeFeature",
+  "keyed-rows-host-batch-every-hinted": "keyedRowsHostBatchEveryHintedRuntimeFeature",
+  "keyed-rows-host-window-every-hinted": "keyedRowsHostWindowEveryHintedRuntimeFeature",
   "keyed-rows-host-filter-hinted": "keyedRowsHostFilterHintedRuntimeFeature",
+  "keyed-rows-host-structural-append-hinted": "keyedRowsHostStructuralAppendHintedRuntimeFeature",
+  "keyed-rows-host-structural-append-map-hinted": "keyedRowsHostStructuralAppendMapHintedRuntimeFeature",
+  "keyed-rows-host-structural-prepend-hinted": "keyedRowsHostStructuralPrependHintedRuntimeFeature",
+  "keyed-rows-host-structural-prepend-map-hinted": "keyedRowsHostStructuralPrependMapHintedRuntimeFeature",
   "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-batch-position-hinted": "keyedRowsCompleteBatchPositionHintedRuntimeFeature",
+  "keyed-rows-complete-window-position-hinted": "keyedRowsCompleteWindowPositionHintedRuntimeFeature",
   "keyed-rows-complete-reorder-hinted": "keyedRowsCompleteReorderHintedRuntimeFeature",
   "keyed-rows-complete-all-hinted": "keyedRowsCompleteAllHintedRuntimeFeature",
   "keyed-rows-complete-every-hinted": "keyedRowsCompleteEveryHintedRuntimeFeature",
+  "keyed-rows-complete-batch-every-hinted": "keyedRowsCompleteBatchEveryHintedRuntimeFeature",
+  "keyed-rows-complete-window-every-hinted": "keyedRowsCompleteWindowEveryHintedRuntimeFeature",
   "keyed-rows-complete-filter-hinted": "keyedRowsCompleteFilterHintedRuntimeFeature",
+  "keyed-rows-complete-structural-append-hinted": "keyedRowsCompleteStructuralAppendHintedRuntimeFeature",
+  "keyed-rows-complete-structural-append-map-hinted": "keyedRowsCompleteStructuralAppendMapHintedRuntimeFeature",
+  "keyed-rows-complete-structural-prepend-hinted": "keyedRowsCompleteStructuralPrependHintedRuntimeFeature",
+  "keyed-rows-complete-structural-prepend-map-hinted": "keyedRowsCompleteStructuralPrependMapHintedRuntimeFeature",
   "keyed-rows-complete-prepend-hinted": "keyedRowsCompletePrependHintedRuntimeFeature",
   "keyed-rows-complete-filter-prepend-hinted": "keyedRowsCompleteFilterPrependHintedRuntimeFeature",
   "keyed-ranges": "keyedRangesRuntimeFeature",
   "mixed-ranges": "mixedRangesRuntimeFeature",
   component: "componentRuntimeFeature"
 };
-function runtimeFeaturesForPlans(plans, keyedMapUpdateHints, keyedArrayFilterHints, keyedArrayPrependHints, keyedArrayPositionHints, keyedArrayReorderHints, keyedArrayRollingWindowHints) {
+function runtimeFeaturesForPlans(plans, keyedMapUpdateHints, keyedArrayFilterHints, keyedArrayStructuralAppendHints, keyedArrayStructuralAppendMapHints, keyedArrayPrependHints, keyedArrayStructuralPrependHints, keyedArrayStructuralPrependMapHints, keyedArrayPositionHints, keyedArrayBatchInsertHints, keyedArrayWindowReplaceHints, keyedArrayReorderHints, keyedArrayMapReorderHints, keyedArrayRollingWindowHints) {
   const features = /* @__PURE__ */ new Set();
   let keyedRowsHaveConditionals = false;
   let keyedRowsHaveHostBlocks = false;
@@ -124,7 +157,8 @@ function runtimeFeaturesForPlans(plans, keyedMapUpdateHints, keyedArrayFilterHin
   if (plans.some((plan) => plan.kind === "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" : "";
+    const needsCombinedStructuralPrependRuntime = keyedArrayStructuralPrependHints && (keyedArrayStructuralAppendMapHints || keyedArrayStructuralAppendHints || keyedArrayWindowReplaceHints || keyedArrayBatchInsertHints || keyedArrayPositionHints || keyedArrayReorderHints || keyedArrayRollingWindowHints);
+    const hintSuffix = keyedArrayStructuralPrependMapHints ? "-structural-prepend-map-hinted" : needsCombinedStructuralPrependRuntime ? "-structural-prepend-hinted" : keyedArrayStructuralAppendMapHints ? "-structural-append-map-hinted" : keyedArrayStructuralAppendHints ? "-structural-append-hinted" : keyedArrayWindowReplaceHints ? arrayRangeHints || keyedArrayReorderHints ? "-window-every-hinted" : "-window-position-hinted" : keyedArrayBatchInsertHints ? arrayRangeHints || keyedArrayReorderHints ? "-batch-every-hinted" : "-batch-position-hinted" : keyedArrayPositionHints && (arrayRangeHints || keyedArrayReorderHints) || keyedArrayReorderHints && arrayRangeHints ? "-every-hinted" : keyedArrayRollingWindowHints ? "-all-hinted" : keyedArrayPositionHints ? "-position-hinted" : keyedArrayMapReorderHints && keyedRowsFeature === "keyed-rows" ? "-map-reorder-hinted" : keyedArrayReorderHints ? "-reorder-hinted" : keyedArrayFilterHints && keyedArrayPrependHints ? "-filter-prepend-hinted" : keyedArrayFilterHints ? "-filter-hinted" : keyedArrayPrependHints ? "-prepend-hinted" : keyedMapUpdateHints ? "-hinted" : "";
     features.add(`${keyedRowsFeature}${hintSuffix}`);
   }
   return [...features].sort();
@@ -529,6 +563,22 @@ function isSafeKeyedMapResult(expression, item, safeGlobals) {
   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 keyedMapUpdatePipeline(expression, parameterName, safeGlobals) {
+  const outerCallbacks = [];
+  let current = expression;
+  while (core.types.isCallExpression(current) && current.arguments.length === 1 && core.types.isMemberExpression(current.callee) && !current.callee.computed && core.types.isIdentifier(current.callee.property, { name: "map" }) && core.types.isExpression(current.callee.object)) {
+    const callback = current.arguments[0];
+    if (!core.types.isArrowFunctionExpression(callback) || callback.async || callback.generator || callback.params.length === 0 || callback.params.length > 3 || callback.params.some((parameter) => !core.types.isIdentifier(parameter)) || !core.types.isExpression(callback.body) || !isSafeKeyedMapResult(callback.body, callback.params[0], safeGlobals)) {
+      return void 0;
+    }
+    outerCallbacks.push(callback);
+    current = current.callee.object;
+  }
+  if (!core.types.isIdentifier(current, { name: parameterName }) || outerCallbacks.length === 0) {
+    return void 0;
+  }
+  return outerCallbacks.reverse();
+}
 function rewriteKeyedMapUpdateHints(root, hintedStateIndices, statesBySetter, helperIdentifier, safeGlobals) {
   if (hintedStateIndices.size === 0) return { root: core.types.cloneNode(root, true), count: 0 };
   const file = expressionFile(core.types.cloneNode(root, true));
@@ -542,58 +592,50 @@ function rewriteKeyedMapUpdateHints(root, hintedStateIndices, statesBySetter, he
         return;
       }
       const updater = path.node.arguments[0];
-      if (!core.types.isArrowFunctionExpression(updater) || updater.async || updater.generator || updater.params.length !== 1 || !core.types.isIdentifier(updater.params[0]) || !core.types.isCallExpression(updater.body) || !core.types.isMemberExpression(updater.body.callee) || updater.body.callee.computed || !core.types.isIdentifier(updater.body.callee.object, {
-        name: updater.params[0].name
-      }) || !core.types.isIdentifier(updater.body.callee.property, { name: "map" })) {
-        return;
-      }
-      const callback = updater.body.arguments[0];
-      if (!core.types.isArrowFunctionExpression(callback) || callback.async || callback.generator || callback.params.length === 0 || callback.params.length > 3 || callback.params.some((parameter) => !core.types.isIdentifier(parameter)) || !core.types.isExpression(callback.body)) {
+      if (!core.types.isArrowFunctionExpression(updater) || updater.async || updater.generator || updater.params.length !== 1 || !core.types.isIdentifier(updater.params[0]) || !core.types.isExpression(updater.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 = core.types.isIdentifier(callback.params[1]) ? core.types.cloneNode(callback.params[1]) : path.scope.generateUidIdentifier("farmMapIndex");
-      const wrappedCallback = core.types.cloneNode(callback, true);
-      if (wrappedCallback.params.length === 1) wrappedCallback.params.push(core.types.cloneNode(index));
-      wrappedCallback.body = core.types.blockStatement([
-        core.types.variableDeclaration("const", [
-          core.types.variableDeclarator(core.types.cloneNode(mappedItem), core.types.cloneNode(callback.body, true))
-        ]),
-        core.types.ifStatement(
-          core.types.binaryExpression("!==", core.types.cloneNode(mappedItem), core.types.cloneNode(item)),
-          core.types.expressionStatement(
-            core.types.callExpression(
-              core.types.memberExpression(core.types.cloneNode(changedIndices), core.types.identifier("push")),
-              [core.types.cloneNode(index)]
-            )
-          )
-        ),
-        core.types.returnStatement(core.types.cloneNode(mappedItem))
-      ]);
-      const mapCall = core.types.cloneNode(updater.body, true);
-      mapCall.arguments[0] = wrappedCallback;
+      const callbacks = keyedMapUpdatePipeline(updater.body, updater.params[0].name, safeGlobals);
+      if (!callbacks) return;
       const previous = core.types.cloneNode(updater.params[0]);
-      path.node.arguments[0] = core.types.arrowFunctionExpression(
-        [core.types.cloneNode(previous)],
-        core.types.blockStatement([
+      const pipelineValue = path.scope.generateUidIdentifier("farmMapValue");
+      const applyMap = path.scope.generateUidIdentifier("farmApplyMap");
+      const statements = [];
+      let current = core.types.cloneNode(pipelineValue);
+      for (let index = 0; index < callbacks.length; index += 1) {
+        const method = path.scope.generateUidIdentifier(`farmMap${index + 1}`);
+        const nextValue = path.scope.generateUidIdentifier(`farmMappedItems${index + 1}`);
+        statements.push(
           core.types.variableDeclaration("const", [
-            core.types.variableDeclarator(core.types.cloneNode(changedIndices), core.types.arrayExpression([]))
+            core.types.variableDeclarator(
+              core.types.cloneNode(method),
+              core.types.memberExpression(core.types.cloneNode(current), core.types.identifier("map"))
+            )
           ]),
-          core.types.variableDeclaration("const", [core.types.variableDeclarator(core.types.cloneNode(nextValue), mapCall)]),
-          core.types.returnStatement(
-            core.types.callExpression(core.types.cloneNode(helperIdentifier), [
-              core.types.cloneNode(previous),
+          core.types.variableDeclaration("const", [
+            core.types.variableDeclarator(
               core.types.cloneNode(nextValue),
-              core.types.cloneNode(changedIndices)
-            ])
+              core.types.callExpression(core.types.cloneNode(applyMap), [
+                core.types.cloneNode(current),
+                core.types.cloneNode(method),
+                core.types.cloneNode(callbacks[index], true)
+              ])
+            )
+          ])
+        );
+        current = nextValue;
+      }
+      path.node.arguments[0] = core.types.arrowFunctionExpression(
+        [core.types.cloneNode(previous)],
+        core.types.callExpression(core.types.cloneNode(helperIdentifier), [
+          core.types.cloneNode(previous),
+          core.types.arrowFunctionExpression(
+            [core.types.cloneNode(pipelineValue), core.types.cloneNode(applyMap)],
+            core.types.blockStatement([...statements, core.types.returnStatement(core.types.cloneNode(current))])
           )
         ])
       );
-      count += 1;
+      count += callbacks.length;
       path.skip();
     }
   });
@@ -766,8 +808,10 @@ function rewriteKeyedArrayRollingWindowHints(root, hintedStateIndices, statesByS
       }) || !core.types.isIdentifier(retainedSpread.argument.callee.property, { name: "slice" }) || !core.types.isExpression(retainedSpread.argument.arguments[0])) {
         return;
       }
-      const retainedStart = staticSliceIndex(retainedSpread.argument.arguments[0]);
-      if (retainedStart === void 0 || retainedStart === 0) return;
+      const retainedStart = retainedSpread.argument.arguments[0];
+      if (validateKeyedArrayPositionExpression(retainedStart, safeGlobals) !== void 0 || staticSliceIndex(retainedStart) === 0) {
+        return;
+      }
       const safeIncomingValue = (value) => {
         if (core.types.isArrayExpression(value)) {
           return value.elements.every(
@@ -810,7 +854,7 @@ function rewriteKeyedArrayRollingWindowHints(root, hintedStateIndices, statesByS
               core.types.callExpression(core.types.cloneNode(sliceHelperIdentifier), [
                 core.types.cloneNode(previous),
                 core.types.cloneNode(sliceMethod),
-                core.types.numericLiteral(retainedStart)
+                core.types.cloneNode(retainedStart, true)
               ])
             ),
             core.types.variableDeclarator(core.types.cloneNode(nextValue), core.types.arrayExpression(nextElements))
@@ -852,13 +896,21 @@ function validateKeyedArrayPositionExpression(expression, safeGlobals) {
   }
   return validateDerivedExpression(expression, safeGlobals);
 }
-function rewriteKeyedArrayPositionHints(root, hintedStateIndices, statesBySetter, helperIdentifier, safeGlobals) {
+function rewriteKeyedArrayPositionHints(root, hintedStateIndices, statesBySetter, helperIdentifier, batchInsertHelperIdentifier, windowReplaceHelperIdentifier, safeGlobals) {
   if (hintedStateIndices.size === 0) {
-    return { root: core.types.cloneNode(root, true), count: 0, stateIndices: /* @__PURE__ */ new Set() };
+    return {
+      root: core.types.cloneNode(root, true),
+      count: 0,
+      batchInsertCount: 0,
+      windowReplaceCount: 0,
+      stateIndices: /* @__PURE__ */ new Set()
+    };
   }
   const file = expressionFile(core.types.cloneNode(root, true));
   const stateIndices = /* @__PURE__ */ new Set();
   let count = 0;
+  let batchInsertCount = 0;
+  let windowReplaceCount = 0;
   core.traverse(file, {
     CallExpression(path) {
       const callee = path.get("callee");
@@ -873,11 +925,19 @@ function rewriteKeyedArrayPositionHints(root, hintedStateIndices, statesBySetter
       }
       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 && core.types.isNumericLiteral(args[1], { value: 0 }) ? "insert" : methodName === "toSpliced" && args.length === 2 && core.types.isNumericLiteral(args[1], { value: 1 }) ? "remove" : void 0;
+      const deleteCountExpression = methodName === "toSpliced" && args.length >= 2 && core.types.isExpression(args[1]) ? args[1] : void 0;
+      const toSplicedDeleteCount = deleteCountExpression ? staticSliceIndex(deleteCountExpression) : void 0;
+      const hasRuntimeDeleteCount = deleteCountExpression !== void 0 && toSplicedDeleteCount === void 0 && validateKeyedArrayPositionExpression(deleteCountExpression, safeGlobals) === void 0;
+      const isBatchInsert = methodName === "toSpliced" && args.length >= 3 && core.types.isNumericLiteral(args[1], { value: 0 }) && (args.length > 3 || core.types.isSpreadElement(args[2]));
+      const isWindowReplace = methodName === "toSpliced" && (args.length >= 3 && toSplicedDeleteCount !== void 0 && Number.isSafeInteger(toSplicedDeleteCount) && toSplicedDeleteCount > 0 && (toSplicedDeleteCount !== 1 || args.length > 3 || core.types.isSpreadElement(args[2])) || hasRuntimeDeleteCount);
+      const kind = isBatchInsert ? "batch-insert" : isWindowReplace ? "window-replace" : methodName === "with" && args.length === 2 ? "replace" : methodName === "toSpliced" && args.length === 3 && core.types.isNumericLiteral(args[1], { value: 0 }) ? "insert" : methodName === "toSpliced" && args.length === 3 && core.types.isNumericLiteral(args[1], { value: 1 }) ? "replace" : args.length === 2 && toSplicedDeleteCount !== void 0 && Number.isSafeInteger(toSplicedDeleteCount) && toSplicedDeleteCount > 0 ? "remove" : void 0;
       if (!kind || !core.types.isExpression(args[0])) return;
       const position = args[0];
-      const item = kind === "remove" ? void 0 : args.at(-1);
-      if (validateKeyedArrayPositionExpression(position, safeGlobals) !== void 0 || item !== void 0 && (!core.types.isExpression(item) || validateDerivedExpression(item, safeGlobals) !== void 0)) {
+      const incoming = kind === "batch-insert" || kind === "window-replace" ? args.slice(2) : [args.at(-1)];
+      if (validateKeyedArrayPositionExpression(position, safeGlobals) !== void 0 || kind === "window-replace" && (!deleteCountExpression || validateKeyedArrayPositionExpression(deleteCountExpression, safeGlobals) !== void 0) || kind !== "remove" && incoming.some((item) => {
+        const expression = core.types.isSpreadElement(item) ? item.argument : item;
+        return !expression || !core.types.isExpression(expression) || validateDerivedExpression(expression, safeGlobals) !== void 0;
+      })) {
         return;
       }
       const previous = core.types.cloneNode(updater.params[0]);
@@ -894,7 +954,18 @@ function rewriteKeyedArrayPositionHints(root, hintedStateIndices, statesBySetter
             )
           ]),
           core.types.returnStatement(
-            core.types.callExpression(core.types.cloneNode(helperIdentifier), [
+            kind === "batch-insert" ? core.types.callExpression(core.types.cloneNode(batchInsertHelperIdentifier), [
+              core.types.cloneNode(previous),
+              core.types.cloneNode(method),
+              core.types.cloneNode(position, true),
+              ...args.slice(2).map((argument) => core.types.cloneNode(argument, true))
+            ]) : kind === "window-replace" ? core.types.callExpression(core.types.cloneNode(windowReplaceHelperIdentifier), [
+              core.types.cloneNode(previous),
+              core.types.cloneNode(method),
+              core.types.cloneNode(position, true),
+              core.types.cloneNode(args[1], true),
+              ...args.slice(2).map((argument) => core.types.cloneNode(argument, true))
+            ]) : core.types.callExpression(core.types.cloneNode(helperIdentifier), [
               core.types.cloneNode(previous),
               core.types.cloneNode(method),
               core.types.stringLiteral(kind),
@@ -904,6 +975,8 @@ function rewriteKeyedArrayPositionHints(root, hintedStateIndices, statesBySetter
         ])
       );
       count += 1;
+      if (kind === "batch-insert") batchInsertCount += 1;
+      if (kind === "window-replace") windowReplaceCount += 1;
       stateIndices.add(state.index);
       path.skip();
     }
@@ -911,6 +984,8 @@ function rewriteKeyedArrayPositionHints(root, hintedStateIndices, statesBySetter
   return {
     root: file.program.body[0].expression,
     count,
+    batchInsertCount,
+    windowReplaceCount,
     stateIndices
   };
 }
@@ -933,34 +1008,976 @@ function rewriteKeyedArrayReorderHints(root, hintedStateIndices, statesBySetter,
       if (!core.types.isArrowFunctionExpression(updater) || updater.async || updater.generator || updater.params.length !== 1 || !core.types.isIdentifier(updater.params[0]) || !core.types.isCallExpression(updater.body) || updater.body.arguments.length !== 0 || !core.types.isMemberExpression(updater.body.callee) || updater.body.callee.computed || !core.types.isIdentifier(updater.body.callee.object, { name: updater.params[0].name }) || !core.types.isIdentifier(updater.body.callee.property, { name: "toReversed" })) {
         return;
       }
-      const previous = core.types.cloneNode(updater.params[0]);
-      const method = path.scope.generateUidIdentifier("farmToReversed");
-      path.node.arguments[0] = core.types.arrowFunctionExpression(
-        [core.types.cloneNode(previous)],
-        core.types.blockStatement([
-          core.types.variableDeclaration("const", [
-            core.types.variableDeclarator(
-              core.types.cloneNode(method),
-              core.types.memberExpression(core.types.cloneNode(previous), core.types.identifier("toReversed"))
-            )
-          ]),
-          core.types.returnStatement(
-            core.types.callExpression(core.types.cloneNode(helperIdentifier), [
-              core.types.cloneNode(previous),
-              core.types.cloneNode(method)
-            ])
-          )
-        ])
-      );
-      count += 1;
-      stateIndices.add(state.index);
-      path.skip();
+      const previous = core.types.cloneNode(updater.params[0]);
+      const method = path.scope.generateUidIdentifier("farmToReversed");
+      path.node.arguments[0] = core.types.arrowFunctionExpression(
+        [core.types.cloneNode(previous)],
+        core.types.blockStatement([
+          core.types.variableDeclaration("const", [
+            core.types.variableDeclarator(
+              core.types.cloneNode(method),
+              core.types.memberExpression(core.types.cloneNode(previous), core.types.identifier("toReversed"))
+            )
+          ]),
+          core.types.returnStatement(
+            core.types.callExpression(core.types.cloneNode(helperIdentifier), [
+              core.types.cloneNode(previous),
+              core.types.cloneNode(method)
+            ])
+          )
+        ])
+      );
+      count += 1;
+      stateIndices.add(state.index);
+      path.skip();
+    }
+  });
+  return {
+    root: file.program.body[0].expression,
+    count,
+    stateIndices
+  };
+}
+function keyedArrayReorderPipeline(expression, parameterName, safeGlobals) {
+  const outerSteps = [];
+  let current = expression;
+  while (core.types.isCallExpression(current) && core.types.isMemberExpression(current.callee) && !current.callee.computed && core.types.isIdentifier(current.callee.property) && core.types.isExpression(current.callee.object)) {
+    const methodName = current.callee.property.name;
+    if (methodName === "map") {
+      if (current.arguments.length !== 1) return void 0;
+      const callback = current.arguments[0];
+      if (!core.types.isArrowFunctionExpression(callback) || callback.async || callback.generator || callback.params.length === 0 || callback.params.length > 3 || callback.params.some((parameter) => !core.types.isIdentifier(parameter)) || !core.types.isExpression(callback.body) || !isSafeKeyedMapResult(callback.body, callback.params[0], safeGlobals)) {
+        return void 0;
+      }
+      outerSteps.push({ callback, kind: "map" });
+    } else if (methodName === "filter") {
+      if (current.arguments.length !== 1) return void 0;
+      const predicate = current.arguments[0];
+      if (!core.types.isArrowFunctionExpression(predicate) || predicate.async || predicate.generator || predicate.params.length !== 1 || !core.types.isIdentifier(predicate.params[0]) || !core.types.isExpression(predicate.body) || validateDerivedExpression(predicate.body, safeGlobals)) {
+        return void 0;
+      }
+      outerSteps.push({ kind: "filter", predicate });
+    } else if (methodName === "slice") {
+      if (current.arguments.length < 1 || current.arguments.length > 2) return void 0;
+      const bounds = [];
+      for (const argument of current.arguments) {
+        if (!core.types.isExpression(argument)) return void 0;
+        if (validateKeyedArrayPositionExpression(argument, safeGlobals) !== void 0) {
+          return void 0;
+        }
+        bounds.push(argument);
+      }
+      if (bounds.length === 1 && staticSliceIndex(bounds[0]) === 0) return void 0;
+      outerSteps.push({ bounds, kind: "slice" });
+    } else if (methodName === "toReversed") {
+      if (current.arguments.length !== 0) return void 0;
+      outerSteps.push({ kind: "reverse" });
+    } else if (methodName === "toSorted") {
+      if (current.arguments.length > 1) return void 0;
+      const comparator = current.arguments[0];
+      if (comparator && !core.types.isArrowFunctionExpression(comparator) && !core.types.isFunctionExpression(comparator)) {
+        return void 0;
+      }
+      if (comparator && validateCollectionCallback(comparator, "toSorted", safeGlobals)) {
+        return void 0;
+      }
+      outerSteps.push({ kind: "sort", ...comparator ? { comparator } : {} });
+    } else {
+      return void 0;
+    }
+    current = current.callee.object;
+  }
+  if (!core.types.isIdentifier(current, { name: parameterName }) || outerSteps.length < 2) {
+    return void 0;
+  }
+  const steps = outerSteps.reverse();
+  let mapSteps = 0;
+  let structuralSteps = 0;
+  let reorderSteps = 0;
+  let reachedReorder = false;
+  for (const step of steps) {
+    if (step.kind === "map") {
+      if (reachedReorder && structuralSteps > 0) return void 0;
+      mapSteps += 1;
+    } else if (step.kind === "filter" || step.kind === "slice") {
+      if (reachedReorder) return void 0;
+      structuralSteps += 1;
+    } else {
+      reachedReorder = true;
+      reorderSteps += 1;
+    }
+  }
+  if (reorderSteps < 1) {
+    return structuralSteps > 0 && mapSteps > 0 ? steps : void 0;
+  }
+  if (mapSteps > 0 && reorderSteps >= 1) return steps;
+  if (structuralSteps < 1 && reorderSteps < 2) return void 0;
+  return steps;
+}
+function rewriteKeyedArrayReorderPipelineHints(root, hintedStateIndices, statesBySetter, filterHelperIdentifier, mapHelperIdentifier, mapReorderHelperIdentifier, mappedStructuralHelperIdentifier, reorderHelperIdentifier, structuralReorderHelperIdentifier, sliceHelperIdentifier, sortHelperIdentifier, structuralSortHelperIdentifier, safeGlobals, allowMapPipelines) {
+  if (hintedStateIndices.size === 0) {
+    return {
+      root: core.types.cloneNode(root, true),
+      filterCount: 0,
+      mapCount: 0,
+      mapReorderCount: 0,
+      mapSortCount: 0,
+      reorderCount: 0,
+      sliceCount: 0,
+      sortCount: 0,
+      structuralReorderCount: 0,
+      terminalStructuralPipelineCount: 0,
+      structuralSortCount: 0,
+      stateIndices: /* @__PURE__ */ new Set()
+    };
+  }
+  const file = expressionFile(core.types.cloneNode(root, true));
+  const stateIndices = /* @__PURE__ */ new Set();
+  let filterCount = 0;
+  let mapCount = 0;
+  let mapReorderCount = 0;
+  let mapSortCount = 0;
+  let reorderCount = 0;
+  let sliceCount = 0;
+  let sortCount = 0;
+  let structuralReorderCount = 0;
+  let terminalStructuralPipelineCount = 0;
+  let structuralSortCount = 0;
+  core.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 (!core.types.isArrowFunctionExpression(updater) || updater.async || updater.generator || updater.params.length !== 1 || !core.types.isIdentifier(updater.params[0]) || !core.types.isExpression(updater.body)) {
+        return;
+      }
+      const steps = keyedArrayReorderPipeline(updater.body, updater.params[0].name, safeGlobals);
+      if (!steps) return;
+      const structuralPipeline = steps.some(
+        (step) => step.kind === "filter" || step.kind === "slice"
+      );
+      const mapPipeline = steps.some((step) => step.kind === "map");
+      if (mapPipeline && !allowMapPipelines) return;
+      const terminalStructuralPipeline = mapPipeline && structuralPipeline && steps.every((step) => step.kind !== "reverse" && step.kind !== "sort");
+      const previous = core.types.cloneNode(updater.params[0]);
+      const statements = [];
+      let value = core.types.cloneNode(previous);
+      let hasMappedLineage = false;
+      for (let stepIndex = 0; stepIndex < steps.length; stepIndex += 1) {
+        const step = steps[stepIndex];
+        if (step.kind === "map") {
+          let mapEnd = stepIndex + 1;
+          while (steps[mapEnd]?.kind === "map") mapEnd += 1;
+          if (mapEnd - stepIndex > 1) {
+            const pipelineValue = path.scope.generateUidIdentifier("farmMapValue");
+            const applyMap = path.scope.generateUidIdentifier("farmApplyMap");
+            const pipelineStatements = [];
+            let current = core.types.cloneNode(pipelineValue);
+            for (let mapIndex = stepIndex; mapIndex < mapEnd; mapIndex += 1) {
+              const mapStep = steps[mapIndex];
+              if (mapStep.kind !== "map") break;
+              const method2 = path.scope.generateUidIdentifier(`farmMap${mapIndex + 1}`);
+              const result3 = path.scope.generateUidIdentifier(`farmMappedItems${mapIndex + 1}`);
+              pipelineStatements.push(
+                core.types.variableDeclaration("const", [
+                  core.types.variableDeclarator(
+                    core.types.cloneNode(method2),
+                    core.types.memberExpression(core.types.cloneNode(current), core.types.identifier("map"))
+                  )
+                ]),
+                core.types.variableDeclaration("const", [
+                  core.types.variableDeclarator(
+                    core.types.cloneNode(result3),
+                    core.types.callExpression(core.types.cloneNode(applyMap), [
+                      core.types.cloneNode(current),
+                      core.types.cloneNode(method2),
+                      core.types.cloneNode(mapStep.callback, true)
+                    ])
+                  )
+                ])
+              );
+              current = core.types.cloneNode(result3);
+            }
+            const result2 = path.scope.generateUidIdentifier("farmPipelineValue");
+            statements.push(
+              core.types.variableDeclaration("const", [
+                core.types.variableDeclarator(
+                  core.types.cloneNode(result2),
+                  core.types.callExpression(core.types.cloneNode(mapHelperIdentifier), [
+                    core.types.cloneNode(value),
+                    core.types.arrowFunctionExpression(
+                      [core.types.cloneNode(pipelineValue), core.types.cloneNode(applyMap)],
+                      core.types.blockStatement([
+                        ...pipelineStatements,
+                        core.types.returnStatement(core.types.cloneNode(current))
+                      ])
+                    )
+                  ])
+                )
+              ])
+            );
+            value = core.types.cloneNode(result2);
+            mapCount += mapEnd - stepIndex;
+            hasMappedLineage = true;
+            stepIndex = mapEnd - 1;
+            continue;
+          }
+        }
+        const methodName = step.kind === "map" ? "map" : step.kind === "filter" ? "filter" : step.kind === "slice" ? "slice" : step.kind === "reverse" ? "toReversed" : "toSorted";
+        const method = path.scope.generateUidIdentifier(
+          step.kind === "filter" ? "farmFilter" : step.kind === "map" ? "farmMap" : step.kind === "slice" ? "farmSlice" : step.kind === "reverse" ? "farmToReversed" : "farmToSorted"
+        );
+        const result = path.scope.generateUidIdentifier("farmPipelineValue");
+        const helper = step.kind === "map" ? mapHelperIdentifier : step.kind === "filter" ? filterHelperIdentifier : step.kind === "slice" ? sliceHelperIdentifier : step.kind === "reverse" ? structuralPipeline ? structuralReorderHelperIdentifier : hasMappedLineage ? mapReorderHelperIdentifier : reorderHelperIdentifier : structuralPipeline ? structuralSortHelperIdentifier : hasMappedLineage ? mapReorderHelperIdentifier : sortHelperIdentifier;
+        const args = step.kind === "map" ? [core.types.cloneNode(step.callback, true)] : step.kind === "filter" ? [core.types.cloneNode(step.predicate, true)] : step.kind === "slice" ? step.bounds.map((bound) => core.types.cloneNode(bound, true)) : step.kind === "sort" && step.comparator ? [core.types.cloneNode(step.comparator, true)] : [];
+        statements.push(
+          core.types.variableDeclaration("const", [
+            core.types.variableDeclarator(
+              core.types.cloneNode(method),
+              core.types.memberExpression(core.types.cloneNode(value), core.types.identifier(methodName))
+            )
+          ]),
+          core.types.variableDeclaration("const", [
+            core.types.variableDeclarator(
+              core.types.cloneNode(result),
+              core.types.callExpression(core.types.cloneNode(helper), [
+                core.types.cloneNode(value),
+                core.types.cloneNode(method),
+                ...args
+              ])
+            )
+          ])
+        );
+        value = core.types.cloneNode(result);
+        if (step.kind === "map") {
+          mapCount += 1;
+          hasMappedLineage = true;
+        } else if (step.kind === "filter") filterCount += 1;
+        else if (step.kind === "slice") sliceCount += 1;
+        else if (step.kind === "reverse") {
+          reorderCount += 1;
+          if (hasMappedLineage && !structuralPipeline) mapReorderCount += 1;
+          if (structuralPipeline) structuralReorderCount += 1;
+        } else {
+          sortCount += 1;
+          if (hasMappedLineage && !structuralPipeline) mapSortCount += 1;
+          if (structuralPipeline) structuralSortCount += 1;
+        }
+      }
+      statements.push(
+        core.types.returnStatement(
+          terminalStructuralPipeline ? core.types.callExpression(core.types.cloneNode(mappedStructuralHelperIdentifier), [core.types.cloneNode(value)]) : core.types.cloneNode(value)
+        )
+      );
+      if (terminalStructuralPipeline) terminalStructuralPipelineCount += 1;
+      path.node.arguments[0] = core.types.arrowFunctionExpression(
+        [core.types.cloneNode(previous)],
+        core.types.blockStatement(statements)
+      );
+      stateIndices.add(state.index);
+      path.skip();
+    }
+  });
+  return {
+    root: file.program.body[0].expression,
+    filterCount,
+    mapCount,
+    mapReorderCount,
+    mapSortCount,
+    reorderCount,
+    sliceCount,
+    sortCount,
+    structuralReorderCount,
+    terminalStructuralPipelineCount,
+    structuralSortCount,
+    stateIndices
+  };
+}
+function rewriteQueuedKeyedArrayReorderMapHints(root, statesBySetter, mapUpdateIdentifier, queuedMapPipelineIdentifier, mapReorderIdentifier, reorderIdentifier, sortIdentifier, structuralReorderIdentifier, structuralSortIdentifier, allowed) {
+  if (!allowed) return { root: core.types.cloneNode(root, true), mapCount: 0 };
+  const file = expressionFile(core.types.cloneNode(root, true));
+  let mapCount = 0;
+  const containsHelperCall = (updater, helperNames) => {
+    let found = false;
+    core.types.traverseFast(updater.body, (node) => {
+      if (!found && core.types.isCallExpression(node) && core.types.isIdentifier(node.callee) && helperNames.has(node.callee.name)) {
+        found = true;
+      }
+    });
+    return found;
+  };
+  const reorderHelperNames = /* @__PURE__ */ new Set([
+    mapReorderIdentifier.name,
+    reorderIdentifier.name,
+    sortIdentifier.name
+  ]);
+  const structuralHelperNames = /* @__PURE__ */ new Set([
+    structuralReorderIdentifier.name,
+    structuralSortIdentifier.name
+  ]);
+  core.traverse(file, {
+    BlockStatement(path) {
+      let queuedReorderState;
+      const statements = path.get("body");
+      for (const statementPath of statements) {
+        const statement = statementPath.node;
+        if (!core.types.isExpressionStatement(statement) || !core.types.isCallExpression(statement.expression)) {
+          queuedReorderState = void 0;
+          continue;
+        }
+        const setterCall = statement.expression;
+        if (!core.types.isIdentifier(setterCall.callee) || statementPath.scope.hasBinding(setterCall.callee.name) || setterCall.arguments.length !== 1) {
+          queuedReorderState = void 0;
+          continue;
+        }
+        const state = statesBySetter.get(setterCall.callee.name);
+        const updater = setterCall.arguments[0];
+        if (!state || !core.types.isArrowFunctionExpression(updater) || updater.async || updater.generator || updater.params.length !== 1 || !core.types.isIdentifier(updater.params[0])) {
+          queuedReorderState = void 0;
+          continue;
+        }
+        if (containsHelperCall(updater, reorderHelperNames) && !containsHelperCall(updater, structuralHelperNames)) {
+          queuedReorderState = state.index;
+          continue;
+        }
+        if (queuedReorderState !== state.index || !core.types.isCallExpression(updater.body) || !core.types.isIdentifier(updater.body.callee, { name: mapUpdateIdentifier.name }) || updater.body.arguments.length !== 2) {
+          queuedReorderState = void 0;
+          continue;
+        }
+        const pipeline = updater.body.arguments[1];
+        if (!core.types.isArrowFunctionExpression(pipeline) || pipeline.params.length !== 2 || !core.types.isIdentifier(pipeline.params[1])) {
+          queuedReorderState = void 0;
+          continue;
+        }
+        let pipelineMapCount = 0;
+        const applyMapName = pipeline.params[1].name;
+        core.types.traverseFast(pipeline.body, (node) => {
+          if (core.types.isCallExpression(node) && core.types.isIdentifier(node.callee, { name: applyMapName })) {
+            pipelineMapCount += 1;
+          }
+        });
+        if (pipelineMapCount === 0) {
+          queuedReorderState = void 0;
+          continue;
+        }
+        updater.body.callee = core.types.cloneNode(queuedMapPipelineIdentifier);
+        mapCount += pipelineMapCount;
+      }
+    }
+  });
+  return {
+    root: file.program.body[0].expression,
+    mapCount
+  };
+}
+function countKeyedArrayMapPipeline(updater, mapUpdateIdentifier) {
+  if (!core.types.isCallExpression(updater.body) || !core.types.isIdentifier(updater.body.callee, { name: mapUpdateIdentifier.name }) || updater.body.arguments.length !== 2) {
+    return 0;
+  }
+  const pipeline = updater.body.arguments[1];
+  if (!core.types.isArrowFunctionExpression(pipeline) || pipeline.params.length !== 2 || !core.types.isIdentifier(pipeline.params[1])) {
+    return 0;
+  }
+  const applyMapName = pipeline.params[1].name;
+  let count = 0;
+  core.types.traverseFast(pipeline.body, (node) => {
+    if (core.types.isCallExpression(node) && core.types.isIdentifier(node.callee, { name: applyMapName })) {
+      count += 1;
+    }
+  });
+  return count;
+}
+function rewriteQueuedKeyedArrayMappedStructuralHints(root, statesBySetter, mapUpdateIdentifier, queuedMapPipelineIdentifier, mappedStructuralIdentifier, filterIdentifier, sliceIdentifier, allowed) {
+  if (!allowed) {
+    return {
+      root: core.types.cloneNode(root, true),
+      mapCount: 0,
+      structuralCount: 0,
+      stateIndices: /* @__PURE__ */ new Set()
+    };
+  }
+  const file = expressionFile(core.types.cloneNode(root, true));
+  let mapCount = 0;
+  let structuralCount = 0;
+  const stateIndices = /* @__PURE__ */ new Set();
+  const terminalStructuralReturn = (updater) => {
+    if (!core.types.isBlockStatement(updater.body)) return void 0;
+    const statement = updater.body.body.at(-1);
+    if (!core.types.isReturnStatement(statement) || !statement.argument || !core.types.isCallExpression(statement.argument) || !core.types.isIdentifier(statement.argument.callee) || statement.argument.callee.name !== filterIdentifier.name && statement.argument.callee.name !== sliceIdentifier.name) {
+      return void 0;
+    }
+    return statement;
+  };
+  core.traverse(file, {
+    BlockStatement(path) {
+      let mappedStructuralState;
+      let pendingMaps = [];
+      const statements = path.get("body");
+      for (const statementPath of statements) {
+        const statement = statementPath.node;
+        if (!core.types.isExpressionStatement(statement) || !core.types.isCallExpression(statement.expression)) {
+          mappedStructuralState = void 0;
+          pendingMaps = [];
+          continue;
+        }
+        const setterCall = statement.expression;
+        if (!core.types.isIdentifier(setterCall.callee) || statementPath.scope.hasBinding(setterCall.callee.name) || setterCall.arguments.length !== 1) {
+          mappedStructuralState = void 0;
+          pendingMaps = [];
+          continue;
+        }
+        const state = statesBySetter.get(setterCall.callee.name);
+        const updater = setterCall.arguments[0];
+        if (!state || !core.types.isArrowFunctionExpression(updater) || updater.async || updater.generator || updater.params.length !== 1 || !core.types.isIdentifier(updater.params[0])) {
+          mappedStructuralState = void 0;
+          pendingMaps = [];
+          continue;
+        }
+        const pipelineMapCount = countKeyedArrayMapPipeline(updater, mapUpdateIdentifier);
+        if (pipelineMapCount > 0) {
+          if (mappedStructuralState !== void 0) {
+            mappedStructuralState = void 0;
+            pendingMaps = [];
+            continue;
+          }
+          const candidate = {
+            count: pipelineMapCount,
+            stateIndex: state.index,
+            updater
+          };
+          pendingMaps = pendingMaps[0]?.stateIndex === state.index ? [...pendingMaps, candidate] : [candidate];
+          continue;
+        }
+        const structuralReturn = terminalStructuralReturn(updater);
+        const hasPendingMaps = pendingMaps.length > 0 && pendingMaps[0].stateIndex === state.index;
+        if (!structuralReturn || !hasPendingMaps && mappedStructuralState !== state.index) {
+          mappedStructuralState = void 0;
+          pendingMaps = [];
+          continue;
+        }
+        if (hasPendingMaps) {
+          for (const candidate of pendingMaps) {
+            candidate.updater.body.callee = core.types.cloneNode(queuedMapPipelineIdentifier);
+            mapCount += candidate.count;
+          }
+        }
+        const structuralValue = structuralReturn.argument;
+        if (!core.types.isExpression(structuralValue)) {
+          mappedStructuralState = void 0;
+          pendingMaps = [];
+          continue;
+        }
+        structuralReturn.argument = core.types.callExpression(core.types.cloneNode(mappedStructuralIdentifier), [
+          core.types.cloneNode(structuralValue)
+        ]);
+        structuralCount += 1;
+        stateIndices.add(state.index);
+        mappedStructuralState = state.index;
+        pendingMaps = [];
+      }
+    }
+  });
+  return {
+    root: file.program.body[0].expression,
+    mapCount,
+    structuralCount,
+    stateIndices
+  };
+}
+function rewriteQueuedKeyedArrayStructuralMapHints(root, statesBySetter, mapUpdateIdentifier, mapPipelineIdentifier, appendIdentifier, mappedStructuralAppendIdentifier, structuralAppendMapPipelineIdentifier, filterIdentifier, sliceIdentifier, mappedStructuralIdentifier, allowed) {
+  if (!allowed) {
+    return {
+      root: core.types.cloneNode(root, true),
+      mapCount: 0,
+      mappedStructuralAppendCount: 0,
+      structuralAppendMapCount: 0,
+      stateIndices: /* @__PURE__ */ new Set()
+    };
+  }
+  const file = expressionFile(core.types.cloneNode(root, true));
+  let mapCount = 0;
+  let mappedStructuralAppendCount = 0;
+  let structuralAppendMapCount = 0;
+  const stateIndices = /* @__PURE__ */ new Set();
+  const structuralUpdateKind = (updater) => {
+    if (!core.types.isBlockStatement(updater.body)) return void 0;
+    const statement = updater.body.body.at(-1);
+    if (!core.types.isReturnStatement(statement) || !statement.argument) return void 0;
+    let found;
+    let mapped = false;
+    core.types.traverseFast(statement.argument, (node) => {
+      if (!found && core.types.isCallExpression(node) && core.types.isIdentifier(node.callee)) {
+        if (node.callee.name === filterIdentifier.name) found = "filter";
+        if (node.callee.name === sliceIdentifier.name) found = "slice";
+      }
+      if (!mapped && core.types.isCallExpression(node) && core.types.isIdentifier(node.callee, { name: mappedStructuralIdentifier.name })) {
+        mapped = true;
+      }
+    });
+    return found ? { kind: found, mapped } : void 0;
+  };
+  core.traverse(file, {
+    BlockStatement(path) {
+      let structuralState;
+      let structuralAppendState;
+      let structuralMapState;
+      let structuralKind;
+      const statements = path.get("body");
+      for (const statementPath of statements) {
+        const statement = statementPath.node;
+        if (!core.types.isExpressionStatement(statement) || !core.types.isCallExpression(statement.expression)) {
+          structuralState = void 0;
+          structuralAppendState = void 0;
+          structuralMapState = void 0;
+          structuralKind = void 0;
+          continue;
+        }
+        const setterCall = statement.expression;
+        if (!core.types.isIdentifier(setterCall.callee) || statementPath.scope.hasBinding(setterCall.callee.name) || setterCall.arguments.length !== 1) {
+          structuralState = void 0;
+          structuralAppendState = void 0;
+          structuralMapState = void 0;
+          structuralKind = void 0;
+          continue;
+        }
+        const state = statesBySetter.get(setterCall.callee.name);
+        const updater = setterCall.arguments[0];
+        if (!state || !core.types.isArrowFunctionExpression(updater) || updater.async || updater.generator || updater.params.length !== 1 || !core.types.isIdentifier(updater.params[0])) {
+          structuralState = void 0;
+          structuralAppendState = void 0;
+          structuralMapState = void 0;
+          structuralKind = void 0;
+          continue;
+        }
+        const nextStructuralKind = structuralUpdateKind(updater);
+        if (nextStructuralKind) {
+          structuralState = state.index;
+          structuralAppendState = void 0;
+          structuralMapState = nextStructuralKind.mapped ? state.index : void 0;
+          structuralKind = nextStructuralKind.kind;
+          continue;
+        }
+        const appendCalls = [];
+        core.types.traverseFast(updater.body, (node) => {
+          if (core.types.isCallExpression(node) && core.types.isIdentifier(node.callee, { name: appendIdentifier.name })) {
+            appendCalls.push(node);
+          }
+        });
+        if (appendCalls.length > 0) {
+          if (structuralState === state.index && structuralKind !== void 0) {
+            structuralAppendState = state.index;
+            if (structuralMapState === state.index) {
+              for (const call of appendCalls) {
+                call.callee = core.types.cloneNode(mappedStructuralAppendIdentifier);
+              }
+              mappedStructuralAppendCount += appendCalls.length;
+            }
+          } else {
+            structuralState = void 0;
+            structuralAppendState = void 0;
+            structuralMapState = void 0;
+            structuralKind = void 0;
+          }
+          continue;
+        }
+        const pipelineMapCount = countKeyedArrayMapPipeline(updater, mapUpdateIdentifier);
+        if (structuralState !== state.index || pipelineMapCount === 0) {
+          structuralState = void 0;
+          structuralAppendState = void 0;
+          structuralMapState = void 0;
+          structuralKind = void 0;
+          continue;
+        }
+        updater.body.callee = core.types.cloneNode(
+          structuralAppendState === state.index ? structuralAppendMapPipelineIdentifier : mapPipelineIdentifier
+        );
+        mapCount += pipelineMapCount;
+        if (structuralAppendState === state.index) {
+          structuralAppendMapCount += pipelineMapCount;
+        }
+        structuralMapState = state.index;
+        stateIndices.add(state.index);
+      }
+    }
+  });
+  return {
+    root: file.program.body[0].expression,
+    mapCount,
+    mappedStructuralAppendCount,
+    structuralAppendMapCount,
+    stateIndices
+  };
+}
+function rewriteQueuedKeyedArrayStructuralPrependMapHints(root, statesBySetter, mapUpdateIdentifier, mapPipelineIdentifier, prependIdentifier, mappedStructuralPrependIdentifier, structuralPrependMapPipelineIdentifier, filterIdentifier, sliceIdentifier, mappedStructuralIdentifier, allowed) {
+  if (!allowed) {
+    return {
+      root: core.types.cloneNode(root, true),
+      mapCount: 0,
+      mappedStructuralPrependCount: 0,
+      structuralPrependMapCount: 0,
+      stateIndices: /* @__PURE__ */ new Set()
+    };
+  }
+  const file = expressionFile(core.types.cloneNode(root, true));
+  let mapCount = 0;
+  let mappedStructuralPrependCount = 0;
+  let structuralPrependMapCount = 0;
+  const stateIndices = /* @__PURE__ */ new Set();
+  const structuralUpdateKind = (updater) => {
+    if (!core.types.isBlockStatement(updater.body)) return void 0;
+    const statement = updater.body.body.at(-1);
+    if (!core.types.isReturnStatement(statement) || !statement.argument) return void 0;
+    let found;
+    let mapped = false;
+    core.types.traverseFast(statement.argument, (node) => {
+      if (!found && core.types.isCallExpression(node) && core.types.isIdentifier(node.callee)) {
+        if (node.callee.name === filterIdentifier.name) found = "filter";
+        if (node.callee.name === sliceIdentifier.name) found = "slice";
+      }
+      if (!mapped && core.types.isCallExpression(node) && core.types.isIdentifier(node.callee, { name: mappedStructuralIdentifier.name })) {
+        mapped = true;
+      }
+    });
+    return found ? { kind: found, mapped } : void 0;
+  };
+  core.traverse(file, {
+    BlockStatement(path) {
+      let structuralState;
+      let structuralPrependState;
+      let structuralMapState;
+      let structuralKind;
+      const statements = path.get("body");
+      for (const statementPath of statements) {
+        const statement = statementPath.node;
+        if (!core.types.isExpressionStatement(statement) || !core.types.isCallExpression(statement.expression)) {
+          structuralState = void 0;
+          structuralPrependState = void 0;
+          structuralMapState = void 0;
+          structuralKind = void 0;
+          continue;
+        }
+        const setterCall = statement.expression;
+        if (!core.types.isIdentifier(setterCall.callee) || statementPath.scope.hasBinding(setterCall.callee.name) || setterCall.arguments.length !== 1) {
+          structuralState = void 0;
+          structuralPrependState = void 0;
+          structuralMapState = void 0;
+          structuralKind = void 0;
+          continue;
+        }
+        const state = statesBySetter.get(setterCall.callee.name);
+        const updater = setterCall.arguments[0];
+        if (!state || !core.types.isArrowFunctionExpression(updater) || updater.async || updater.generator || updater.params.length !== 1 || !core.types.isIdentifier(updater.params[0])) {
+          structuralState = void 0;
+          structuralPrependState = void 0;
+          structuralMapState = void 0;
+          structuralKind = void 0;
+          continue;
+        }
+        const nextStructuralKind = structuralUpdateKind(updater);
+        if (nextStructuralKind) {
+          structuralState = state.index;
+          structuralPrependState = void 0;
+          structuralMapState = nextStructuralKind.mapped ? state.index : void 0;
+          structuralKind = nextStructuralKind.kind;
+          continue;
+        }
+        const prependCalls = [];
+        core.types.traverseFast(updater.body, (node) => {
+          if (core.types.isCallExpression(node) && core.types.isIdentifier(node.callee, { name: prependIdentifier.name })) {
+            prependCalls.push(node);
+          }
+        });
+        if (prependCalls.length > 0) {
+          if (structuralState === state.index && structuralKind !== void 0) {
+            structuralPrependState = state.index;
+            if (structuralMapState === state.index) {
+              for (const call of prependCalls) {
+                call.callee = core.types.cloneNode(mappedStructuralPrependIdentifier);
+              }
+              mappedStructuralPrependCount += prependCalls.length;
+            }
+          } else {
+            structuralState = void 0;
+            structuralPrependState = void 0;
+            structuralMapState = void 0;
+            structuralKind = void 0;
+          }
+          continue;
+        }
+        const pipelineMapCount = countKeyedArrayMapPipeline(updater, mapUpdateIdentifier) || countKeyedArrayMapPipeline(updater, mapPipelineIdentifier);
+        if (structuralState !== state.index || pipelineMapCount === 0) {
+          structuralState = void 0;
+          structuralPrependState = void 0;
+          structuralMapState = void 0;
+          structuralKind = void 0;
+          continue;
+        }
+        updater.body.callee = core.types.cloneNode(
+          structuralPrependState === state.index ? structuralPrependMapPipelineIdentifier : mapPipelineIdentifier
+        );
+        mapCount += pipelineMapCount;
+        if (structuralPrependState === state.index) {
+          structuralPrependMapCount += pipelineMapCount;
+        }
+        structuralMapState = state.index;
+        stateIndices.add(state.index);
+      }
+    }
+  });
+  return {
+    root: file.program.body[0].expression,
+    mapCount,
+    mappedStructuralPrependCount,
+    structuralPrependMapCount,
+    stateIndices
+  };
+}
+function rewriteQueuedKeyedArrayStructuralReorderHints(root, statesBySetter, filterIdentifier, sliceIdentifier, mapPipelineIdentifier, queuedMapPipelineIdentifier, mappedStructuralIdentifier, mapReorderIdentifier, reorderIdentifier, sortIdentifier, structuralReorderIdentifier, structuralSortIdentifier, allowed) {
+  if (!allowed) {
+    return {
+      root: core.types.cloneNode(root, true),
+      reorderCount: 0,
+      sortCount: 0,
+      replacedMapReorderCount: 0,
+      replacedMapSortCount: 0,
+      replacedQueuedMapCount: 0
+    };
+  }
+  const file = expressionFile(core.types.cloneNode(root, true));
+  let reorderCount = 0;
+  let sortCount = 0;
+  let replacedMapReorderCount = 0;
+  let replacedMapSortCount = 0;
+  let replacedQueuedMapCount = 0;
+  core.traverse(file, {
+    BlockStatement(path) {
+      let structuralState;
+      const statements = path.get("body");
+      for (const statementPath of statements) {
+        const statement = statementPath.node;
+        if (!core.types.isExpressionStatement(statement) || !core.types.isCallExpression(statement.expression)) {
+          structuralState = void 0;
+          continue;
+        }
+        const setterCall = statement.expression;
+        if (!core.types.isIdentifier(setterCall.callee) || statementPath.scope.hasBinding(setterCall.callee.name) || setterCall.arguments.length !== 1) {
+          structuralState = void 0;
+          continue;
+        }
+        const state = statesBySetter.get(setterCall.callee.name);
+        const updater = setterCall.arguments[0];
+        if (!state || !core.types.isArrowFunctionExpression(updater) || updater.async || updater.generator || updater.params.length !== 1 || !core.types.isIdentifier(updater.params[0])) {
+          structuralState = void 0;
+          continue;
+        }
+        const methodKinds = /* @__PURE__ */ new Map();
+        core.types.traverseFast(updater.body, (node) => {
+          if (!core.types.isVariableDeclarator(node) || !core.types.isIdentifier(node.id) || !core.types.isMemberExpression(node.init) || node.init.computed || !core.types.isIdentifier(node.init.property)) {
+            return;
+          }
+          if (node.init.property.name === "toReversed") methodKinds.set(node.id.name, "reverse");
+          if (node.init.property.name === "toSorted") methodKinds.set(node.id.name, "sort");
+        });
+        let startsStructuralLineage = false;
+        let continuesStructuralLineage = false;
+        let unsupported = false;
+        const queuedMaps = [];
+        const reorderCalls = [];
+        core.types.traverseFast(updater.body, (node) => {
+          if (!core.types.isCallExpression(node) || !core.types.isIdentifier(node.callee)) return;
+          const helperName = node.callee.name;
+          if (helperName === filterIdentifier.name || helperName === sliceIdentifier.name || helperName === mappedStructuralIdentifier.name) {
+            startsStructuralLineage = true;
+            return;
+          }
+          if (helperName === structuralReorderIdentifier.name || helperName === structuralSortIdentifier.name) {
+            startsStructuralLineage = true;
+            return;
+          }
+          if (helperName === mapPipelineIdentifier.name) {
+            continuesStructuralLineage = true;
+            return;
+          }
+          if (helperName === queuedMapPipelineIdentifier.name) {
+            continuesStructuralLineage = true;
+            queuedMaps.push(node);
+            return;
+          }
+          if (helperName === reorderIdentifier.name) {
+            continuesStructuralLineage = true;
+            reorderCalls.push({ call: node, kind: "reverse", mapped: false });
+            return;
+          }
+          if (helperName === sortIdentifier.name) {
+            continuesStructuralLineage = true;
+            reorderCalls.push({ call: node, kind: "sort", mapped: false });
+            return;
+          }
+          if (helperName === mapReorderIdentifier.name) {
+            const method = node.arguments[1];
+            const kind = core.types.isIdentifier(method) ? methodKinds.get(method.name) : void 0;
+            if (!kind) {
+              unsupported = true;
+              return;
+            }
+            continuesStructuralLineage = true;
+            reorderCalls.push({ call: node, kind, mapped: true });
+          }
+        });
+        const hasStructuralLineage = startsStructuralLineage || structuralState === state.index;
+        if (unsupported || !startsStructuralLineage && !continuesStructuralLineage) {
+          structuralState = void 0;
+          continue;
+        }
+        if (!hasStructuralLineage) {
+          structuralState = void 0;
+          continue;
+        }
+        for (const call of queuedMaps) {
+          call.callee = core.types.cloneNode(mapPipelineIdentifier);
+          replacedQueuedMapCount += 1;
+        }
+        for (const { call, kind, mapped } of reorderCalls) {
+          call.callee = core.types.cloneNode(
+            kind === "reverse" ? structuralReorderIdentifier : structuralSortIdentifier
+          );
+          if (kind === "reverse") {
+            reorderCount += 1;
+            if (mapped) replacedMapReorderCount += 1;
+          } else {
+            sortCount += 1;
+            if (mapped) replacedMapSortCount += 1;
+          }
+        }
+        structuralState = state.index;
+      }
+    }
+  });
+  return {
+    root: file.program.body[0].expression,
+    reorderCount,
+    sortCount,
+    replacedMapReorderCount,
+    replacedMapSortCount,
+    replacedQueuedMapCount
+  };
+}
+function rewriteQueuedKeyedArrayMapReorderHints(root, statesBySetter, mapUpdateIdentifier, queuedMapPipelineIdentifier, mapReorderIdentifier, reorderIdentifier, sortIdentifier, structuralReorderIdentifier, structuralSortIdentifier, allowed) {
+  if (!allowed) {
+    return {
+      root: core.types.cloneNode(root, true),
+      mapCount: 0,
+      mapReorderCount: 0,
+      mapSortCount: 0
+    };
+  }
+  const file = expressionFile(core.types.cloneNode(root, true));
+  let mapCount = 0;
+  let mapReorderCount = 0;
+  let mapSortCount = 0;
+  core.traverse(file, {
+    BlockStatement(path) {
+      let mappedReorderState;
+      let pendingMaps = [];
+      const statements = path.get("body");
+      for (const statementPath of statements) {
+        const statement = statementPath.node;
+        if (!core.types.isExpressionStatement(statement) || !core.types.isCallExpression(statement.expression)) {
+          mappedReorderState = void 0;
+          pendingMaps = [];
+          continue;
+        }
+        const setterCall = statement.expression;
+        if (!core.types.isIdentifier(setterCall.callee) || statementPath.scope.hasBinding(setterCall.callee.name) || setterCall.arguments.length !== 1) {
+          mappedReorderState = void 0;
+          pendingMaps = [];
+          continue;
+        }
+        const state = statesBySetter.get(setterCall.callee.name);
+        const updater = setterCall.arguments[0];
+        if (!state || !core.types.isArrowFunctionExpression(updater) || updater.async || updater.generator || updater.params.length !== 1 || !core.types.isIdentifier(updater.params[0])) {
+          mappedReorderState = void 0;
+          pendingMaps = [];
+          continue;
+        }
+        if (core.types.isCallExpression(updater.body) && core.types.isIdentifier(updater.body.callee, { name: mapUpdateIdentifier.name }) && updater.body.arguments.length === 2) {
+          const pipeline = updater.body.arguments[1];
+          let pipelineMapCount = 0;
+          if (core.types.isArrowFunctionExpression(pipeline) && pipeline.params.length === 2 && core.types.isIdentifier(pipeline.params[1])) {
+            const applyMapName = pipeline.params[1].name;
+            core.types.traverseFast(pipeline.body, (node) => {
+              if (core.types.isCallExpression(node) && core.types.isIdentifier(node.callee, { name: applyMapName })) {
+                pipelineMapCount += 1;
+              }
+            });
+          }
+          if (pipelineMapCount > 0) {
+            const candidate = {
+              count: pipelineMapCount,
+              stateIndex: state.index,
+              updater
+            };
+            pendingMaps = pendingMaps[0]?.stateIndex === state.index ? [...pendingMaps, candidate] : [candidate];
+            if (mappedReorderState !== state.index) mappedReorderState = void 0;
+            continue;
+          }
+        }
+        let containsMappedReorder = false;
+        const reorderCalls = [];
+        let structural = false;
+        core.types.traverseFast(updater.body, (node) => {
+          if (!core.types.isCallExpression(node) || !core.types.isIdentifier(node.callee)) return;
+          if (node.callee.name === structuralReorderIdentifier.name || node.callee.name === structuralSortIdentifier.name) {
+            structural = true;
+          } else if (node.callee.name === mapReorderIdentifier.name) {
+            containsMappedReorder = true;
+          } else if (node.callee.name === reorderIdentifier.name) {
+            reorderCalls.push({ call: node, kind: "reverse" });
+          } else if (node.callee.name === sortIdentifier.name) {
+            reorderCalls.push({ call: node, kind: "sort" });
+          }
+        });
+        if (structural) {
+          mappedReorderState = void 0;
+          pendingMaps = [];
+          continue;
+        }
+        const hasPendingMaps = pendingMaps.length > 0 && pendingMaps[0].stateIndex === state.index;
+        if (containsMappedReorder && reorderCalls.length === 0) {
+          mappedReorderState = pendingMaps.length === 0 ? state.index : void 0;
+          pendingMaps = [];
+          continue;
+        }
+        if (containsMappedReorder || reorderCalls.length === 0 || !hasPendingMaps && mappedReorderState !== state.index) {
+          mappedReorderState = void 0;
+          pendingMaps = [];
+          continue;
+        }
+        if (hasPendingMaps) {
+          for (const candidate of pendingMaps) {
+            candidate.updater.body.callee = core.types.cloneNode(queuedMapPipelineIdentifier);
+            mapCount += candidate.count;
+          }
+        }
+        for (const { call, kind } of reorderCalls) {
+          call.callee = core.types.cloneNode(mapReorderIdentifier);
+          if (kind === "reverse") mapReorderCount += 1;
+          else mapSortCount += 1;
+        }
+        mappedReorderState = state.index;
+        pendingMaps = [];
+      }
     }
   });
   return {
     root: file.program.body[0].expression,
-    count,
-    stateIndices
+    mapCount,
+    mapReorderCount,
+    mapSortCount
   };
 }
 function rewriteKeyedArraySortHints(root, hintedStateIndices, statesBySetter, helperIdentifier, safeGlobals) {
@@ -1018,7 +2035,7 @@ function rewriteKeyedArraySortHints(root, hintedStateIndices, statesBySetter, he
     stateIndices
   };
 }
-function rewriteKeyedArraySliceHints(root, hintedStateIndices, statesBySetter, helperIdentifier) {
+function rewriteKeyedArraySliceHints(root, hintedStateIndices, statesBySetter, helperIdentifier, safeGlobals) {
   if (hintedStateIndices.size === 0) {
     return { root: core.types.cloneNode(root, true), count: 0, stateIndices: /* @__PURE__ */ new Set() };
   }
@@ -1037,14 +2054,13 @@ function rewriteKeyedArraySliceHints(root, hintedStateIndices, statesBySetter, h
       if (!core.types.isArrowFunctionExpression(updater) || updater.async || updater.generator || updater.params.length !== 1 || !core.types.isIdentifier(updater.params[0]) || !core.types.isCallExpression(updater.body) || updater.body.arguments.length < 1 || updater.body.arguments.length > 2 || !core.types.isMemberExpression(updater.body.callee) || updater.body.callee.computed || !core.types.isIdentifier(updater.body.callee.object, { name: updater.params[0].name }) || !core.types.isIdentifier(updater.body.callee.property, { name: "slice" })) {
         return;
       }
-      const indexes = [];
+      const bounds = [];
       for (const argument of updater.body.arguments) {
         if (!core.types.isExpression(argument)) return;
-        const value = staticSliceIndex(argument);
-        if (value === void 0) return;
-        indexes.push(value);
+        if (validateKeyedArrayPositionExpression(argument, safeGlobals) !== void 0) return;
+        bounds.push(argument);
       }
-      if (indexes.length === 1 && indexes[0] === 0) return;
+      if (bounds.length === 1 && staticSliceIndex(bounds[0]) === 0) return;
       const previous = core.types.cloneNode(updater.params[0]);
       const sliceMethod = path.scope.generateUidIdentifier("farmSlice");
       path.node.arguments[0] = core.types.arrowFunctionExpression(
@@ -1060,7 +2076,7 @@ function rewriteKeyedArraySliceHints(root, hintedStateIndices, statesBySetter, h
             core.types.callExpression(core.types.cloneNode(helperIdentifier), [
               core.types.cloneNode(previous),
               core.types.cloneNode(sliceMethod),
-              ...indexes.map((value) => core.types.numericLiteral(value))
+              ...bounds.map((bound) => core.types.cloneNode(bound, true))
             ])
           )
         ])
@@ -4819,7 +5835,7 @@ function wrapperElement(definitionIdentifier, props) {
   const attributes = props ? [core.types.jsxSpreadAttribute(core.types.cloneNode(props))] : [];
   return core.types.jsxElement(core.types.jsxOpeningElement(name, attributes, true), null, [], true);
 }
-function compileCandidate(candidate, createComponentIdentifier, keyedMapUpdateIdentifier, keyedArrayAppendIdentifier, keyedArrayFilterIdentifier, keyedArrayPrependIdentifier, keyedArrayPositionIdentifier, keyedArrayReorderIdentifier, keyedArraySortIdentifier, keyedArrayRollingWindowIdentifier, keyedArraySliceIdentifier, keyedCollectionUpdateIdentifier, keyedCollectionMutationIdentifier, runtimeFeatureIdentifiers, usedRuntimeFeatures, optimizationCounts, useStateNames, reactNames, listNames, moduleId, reactivity) {
+function compileCandidate(candidate, createComponentIdentifier, keyedMapUpdateIdentifier, keyedArrayAppendIdentifier, keyedArrayFilterIdentifier, keyedArrayMapPipelineIdentifier, keyedArrayMappedStructuralAppendIdentifier, keyedArrayStructuralAppendMapPipelineIdentifier, keyedArrayMappedStructuralPrependIdentifier, keyedArrayStructuralPrependMapPipelineIdentifier, keyedArrayQueuedMapPipelineIdentifier, keyedArrayMapReorderIdentifier, keyedArrayMappedStructuralIdentifier, keyedArrayPrependIdentifier, keyedArrayPositionIdentifier, keyedArrayBatchInsertIdentifier, keyedArrayWindowReplaceIdentifier, keyedArrayReorderIdentifier, keyedArrayStructuralReorderIdentifier, keyedArraySortIdentifier, keyedArrayStructuralSortIdentifier, keyedArrayRollingWindowIdentifier, keyedArraySliceIdentifier, keyedCollectionUpdateIdentifier, keyedCollectionMutationIdentifier, runtimeFeatureIdentifiers, usedRuntimeFeatures, optimizationCounts, compilerUsage, 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";
@@ -5191,9 +6207,13 @@ function compileCandidate(candidate, createComponentIdentifier, keyedMapUpdateId
     shiftedIndexIndependentStateIndices,
     statesBySetter,
     keyedArrayPositionIdentifier,
+    keyedArrayBatchInsertIdentifier,
+    keyedArrayWindowReplaceIdentifier,
     safeGlobals
   );
   let appliedKeyedArrayPositionHints = 0;
+  let appliedKeyedArrayBatchInsertHints = 0;
+  let appliedKeyedArrayWindowReplaceHints = 0;
   let appliedPositionHintedStateIndices = /* @__PURE__ */ new Set();
   if (positionHintedRoot.count > 0) {
     const hintedBlockAnalysis = analyzeComposableBlocks(
@@ -5217,8 +6237,78 @@ function compileCandidate(candidate, createComponentIdentifier, keyedMapUpdateId
       blockAnalysis = hintedBlockAnalysis;
       analysis = hintedAnalysis;
       appliedKeyedArrayPositionHints = positionHintedRoot.count;
+      appliedKeyedArrayBatchInsertHints = positionHintedRoot.batchInsertCount;
+      appliedKeyedArrayWindowReplaceHints = positionHintedRoot.windowReplaceCount;
       appliedPositionHintedStateIndices = positionHintedRoot.stateIndices;
       optimizationCounts.keyedArrayPositionHints += positionHintedRoot.count;
+      compilerUsage.keyedArrayBatchInsertHints += positionHintedRoot.batchInsertCount;
+      compilerUsage.keyedArrayWindowReplaceHints += positionHintedRoot.windowReplaceCount;
+    }
+  }
+  const allowKeyedArrayMapPipelines = (blockAnalysis.plans || []).every(
+    (plan) => plan.kind !== "keyed-rows" || plan.conditionals.length === 0 && !plan.descriptorBlocks?.size
+  );
+  const reorderPipelineHintedRoot = rewriteKeyedArrayReorderPipelineHints(
+    expandedReactiveRoot,
+    shiftedIndexIndependentStateIndices,
+    statesBySetter,
+    keyedArrayFilterIdentifier,
+    keyedArrayMapPipelineIdentifier,
+    keyedArrayMapReorderIdentifier,
+    keyedArrayMappedStructuralIdentifier,
+    keyedArrayReorderIdentifier,
+    keyedArrayStructuralReorderIdentifier,
+    keyedArraySliceIdentifier,
+    keyedArraySortIdentifier,
+    keyedArrayStructuralSortIdentifier,
+    safeGlobals,
+    allowKeyedArrayMapPipelines
+  );
+  let appliedPipelineFilterHints = 0;
+  let appliedPipelineMapHints = 0;
+  let appliedPipelineReorderHints = 0;
+  let appliedPipelineSliceHints = 0;
+  let appliedPipelineSortHints = 0;
+  let appliedPipelineHintedStateIndices = /* @__PURE__ */ new Set();
+  if (reorderPipelineHintedRoot.filterCount > 0 || reorderPipelineHintedRoot.reorderCount > 0 || reorderPipelineHintedRoot.sliceCount > 0 || reorderPipelineHintedRoot.sortCount > 0) {
+    const hintedBlockAnalysis = analyzeComposableBlocks(
+      reorderPipelineHintedRoot.root,
+      reactiveByValue,
+      safeGlobals,
+      listNames,
+      allowedComponentNames
+    );
+    const hintedAnalysis = analyzeHostTree(
+      reorderPipelineHintedRoot.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 = reorderPipelineHintedRoot.root;
+      blockAnalysis = hintedBlockAnalysis;
+      analysis = hintedAnalysis;
+      appliedPipelineFilterHints = reorderPipelineHintedRoot.filterCount;
+      appliedPipelineMapHints = reorderPipelineHintedRoot.mapCount;
+      appliedKeyedMapUpdateHints += reorderPipelineHintedRoot.mapCount;
+      appliedPipelineReorderHints = reorderPipelineHintedRoot.reorderCount + reorderPipelineHintedRoot.terminalStructuralPipelineCount;
+      appliedPipelineSliceHints = reorderPipelineHintedRoot.sliceCount;
+      appliedPipelineSortHints = reorderPipelineHintedRoot.sortCount;
+      appliedPipelineHintedStateIndices = reorderPipelineHintedRoot.stateIndices;
+      optimizationCounts.keyedArrayFilterHints += reorderPipelineHintedRoot.filterCount;
+      optimizationCounts.keyedMapUpdateHints += reorderPipelineHintedRoot.mapCount;
+      optimizationCounts.keyedArrayReorderHints += reorderPipelineHintedRoot.reorderCount;
+      optimizationCounts.keyedArraySliceHints += reorderPipelineHintedRoot.sliceCount;
+      optimizationCounts.keyedArraySortHints += reorderPipelineHintedRoot.sortCount;
+      compilerUsage.keyedArrayStructuralReorderHints += reorderPipelineHintedRoot.structuralReorderCount;
+      compilerUsage.keyedArrayStructuralSortHints += reorderPipelineHintedRoot.structuralSortCount;
+      compilerUsage.keyedArrayMapUpdateHints += reorderPipelineHintedRoot.mapCount;
+      compilerUsage.keyedArrayMapReorderHints += reorderPipelineHintedRoot.mapReorderCount;
+      compilerUsage.keyedArrayMapSortHints += reorderPipelineHintedRoot.mapSortCount;
+      compilerUsage.keyedArrayMappedStructuralHints += reorderPipelineHintedRoot.terminalStructuralPipelineCount;
     }
   }
   const reorderHintedRoot = rewriteKeyedArrayReorderHints(
@@ -5227,8 +6317,8 @@ function compileCandidate(candidate, createComponentIdentifier, keyedMapUpdateId
     statesBySetter,
     keyedArrayReorderIdentifier
   );
-  let appliedKeyedArrayReorderHints = 0;
-  let appliedReorderHintedStateIndices = /* @__PURE__ */ new Set();
+  let appliedKeyedArrayReorderHints = appliedPipelineReorderHints;
+  let appliedReorderHintedStateIndices = appliedPipelineHintedStateIndices;
   if (reorderHintedRoot.count > 0) {
     const hintedBlockAnalysis = analyzeComposableBlocks(
       reorderHintedRoot.root,
@@ -5250,8 +6340,11 @@ function compileCandidate(candidate, createComponentIdentifier, keyedMapUpdateId
       expandedReactiveRoot = reorderHintedRoot.root;
       blockAnalysis = hintedBlockAnalysis;
       analysis = hintedAnalysis;
-      appliedKeyedArrayReorderHints = reorderHintedRoot.count;
-      appliedReorderHintedStateIndices = reorderHintedRoot.stateIndices;
+      appliedKeyedArrayReorderHints += reorderHintedRoot.count;
+      appliedReorderHintedStateIndices = /* @__PURE__ */ new Set([
+        ...appliedReorderHintedStateIndices,
+        ...reorderHintedRoot.stateIndices
+      ]);
       optimizationCounts.keyedArrayReorderHints += reorderHintedRoot.count;
     }
   }
@@ -5262,8 +6355,8 @@ function compileCandidate(candidate, createComponentIdentifier, keyedMapUpdateId
     keyedArraySortIdentifier,
     safeGlobals
   );
-  let appliedKeyedArraySortHints = 0;
-  let appliedSortHintedStateIndices = /* @__PURE__ */ new Set();
+  let appliedKeyedArraySortHints = appliedPipelineSortHints;
+  let appliedSortHintedStateIndices = appliedPipelineHintedStateIndices;
   if (sortHintedRoot.count > 0) {
     const hintedBlockAnalysis = analyzeComposableBlocks(
       sortHintedRoot.root,
@@ -5285,8 +6378,11 @@ function compileCandidate(candidate, createComponentIdentifier, keyedMapUpdateId
       expandedReactiveRoot = sortHintedRoot.root;
       blockAnalysis = hintedBlockAnalysis;
       analysis = hintedAnalysis;
-      appliedKeyedArraySortHints = sortHintedRoot.count;
-      appliedSortHintedStateIndices = sortHintedRoot.stateIndices;
+      appliedKeyedArraySortHints += sortHintedRoot.count;
+      appliedSortHintedStateIndices = /* @__PURE__ */ new Set([
+        ...appliedSortHintedStateIndices,
+        ...sortHintedRoot.stateIndices
+      ]);
       optimizationCounts.keyedArraySortHints += sortHintedRoot.count;
     }
   }
@@ -5294,10 +6390,11 @@ function compileCandidate(candidate, createComponentIdentifier, keyedMapUpdateId
     expandedReactiveRoot,
     shiftedIndexIndependentStateIndices,
     statesBySetter,
-    keyedArraySliceIdentifier
+    keyedArraySliceIdentifier,
+    safeGlobals
   );
-  let appliedKeyedArraySliceHints = 0;
-  let appliedSliceHintedStateIndices = /* @__PURE__ */ new Set();
+  let appliedKeyedArraySliceHints = appliedPipelineSliceHints;
+  let appliedSliceHintedStateIndices = appliedPipelineSliceHints > 0 ? appliedPipelineHintedStateIndices : /* @__PURE__ */ new Set();
   if (sliceHintedRoot.count > 0) {
     const hintedBlockAnalysis = analyzeComposableBlocks(
       sliceHintedRoot.root,
@@ -5319,8 +6416,11 @@ function compileCandidate(candidate, createComponentIdentifier, keyedMapUpdateId
       expandedReactiveRoot = sliceHintedRoot.root;
       blockAnalysis = hintedBlockAnalysis;
       analysis = hintedAnalysis;
-      appliedKeyedArraySliceHints = sliceHintedRoot.count;
-      appliedSliceHintedStateIndices = sliceHintedRoot.stateIndices;
+      appliedKeyedArraySliceHints += sliceHintedRoot.count;
+      appliedSliceHintedStateIndices = /* @__PURE__ */ new Set([
+        ...appliedSliceHintedStateIndices,
+        ...sliceHintedRoot.stateIndices
+      ]);
       optimizationCounts.keyedArraySliceHints += sliceHintedRoot.count;
     }
   }
@@ -5331,8 +6431,8 @@ function compileCandidate(candidate, createComponentIdentifier, keyedMapUpdateId
     keyedArrayFilterIdentifier,
     safeGlobals
   );
-  let appliedKeyedArrayFilterHints = 0;
-  let appliedFilterHintedStateIndices = /* @__PURE__ */ new Set();
+  let appliedKeyedArrayFilterHints = appliedPipelineFilterHints;
+  let appliedFilterHintedStateIndices = appliedPipelineFilterHints > 0 ? appliedPipelineHintedStateIndices : /* @__PURE__ */ new Set();
   if (filterHintedRoot.count > 0) {
     const hintedBlockAnalysis = analyzeComposableBlocks(
       filterHintedRoot.root,
@@ -5354,11 +6454,243 @@ function compileCandidate(candidate, createComponentIdentifier, keyedMapUpdateId
       expandedReactiveRoot = filterHintedRoot.root;
       blockAnalysis = hintedBlockAnalysis;
       analysis = hintedAnalysis;
-      appliedKeyedArrayFilterHints = filterHintedRoot.count;
-      appliedFilterHintedStateIndices = filterHintedRoot.stateIndices;
+      appliedKeyedArrayFilterHints += filterHintedRoot.count;
+      appliedFilterHintedStateIndices = /* @__PURE__ */ new Set([
+        ...appliedFilterHintedStateIndices,
+        ...filterHintedRoot.stateIndices
+      ]);
       optimizationCounts.keyedArrayFilterHints += filterHintedRoot.count;
     }
   }
+  const queuedMappedStructuralHintedRoot = rewriteQueuedKeyedArrayMappedStructuralHints(
+    expandedReactiveRoot,
+    statesBySetter,
+    keyedMapUpdateIdentifier,
+    keyedArrayQueuedMapPipelineIdentifier,
+    keyedArrayMappedStructuralIdentifier,
+    keyedArrayFilterIdentifier,
+    keyedArraySliceIdentifier,
+    allowKeyedArrayMapPipelines
+  );
+  let appliedQueuedMappedStructuralHints = 0;
+  if (queuedMappedStructuralHintedRoot.mapCount > 0 && queuedMappedStructuralHintedRoot.structuralCount > 0) {
+    const hintedBlockAnalysis = analyzeComposableBlocks(
+      queuedMappedStructuralHintedRoot.root,
+      reactiveByValue,
+      safeGlobals,
+      listNames,
+      allowedComponentNames
+    );
+    const hintedAnalysis = analyzeHostTree(
+      queuedMappedStructuralHintedRoot.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 = queuedMappedStructuralHintedRoot.root;
+      blockAnalysis = hintedBlockAnalysis;
+      analysis = hintedAnalysis;
+      appliedQueuedMappedStructuralHints = queuedMappedStructuralHintedRoot.mapCount + queuedMappedStructuralHintedRoot.structuralCount;
+      appliedKeyedArrayReorderHints += queuedMappedStructuralHintedRoot.structuralCount;
+      appliedReorderHintedStateIndices = /* @__PURE__ */ new Set([
+        ...appliedReorderHintedStateIndices,
+        ...queuedMappedStructuralHintedRoot.stateIndices
+      ]);
+      compilerUsage.keyedArrayMapUpdateHints += queuedMappedStructuralHintedRoot.mapCount;
+      compilerUsage.keyedArrayQueuedMapUpdateHints += queuedMappedStructuralHintedRoot.mapCount;
+      compilerUsage.keyedArrayMappedStructuralHints += queuedMappedStructuralHintedRoot.structuralCount;
+    }
+  }
+  const queuedStructuralMapHintedRoot = rewriteQueuedKeyedArrayStructuralMapHints(
+    expandedReactiveRoot,
+    statesBySetter,
+    keyedMapUpdateIdentifier,
+    keyedArrayMapPipelineIdentifier,
+    keyedArrayAppendIdentifier,
+    keyedArrayMappedStructuralAppendIdentifier,
+    keyedArrayStructuralAppendMapPipelineIdentifier,
+    keyedArrayFilterIdentifier,
+    keyedArraySliceIdentifier,
+    keyedArrayMappedStructuralIdentifier,
+    allowKeyedArrayMapPipelines
+  );
+  let appliedQueuedStructuralMapHints = 0;
+  let appliedQueuedStructuralAppendMapHints = 0;
+  if (queuedStructuralMapHintedRoot.mapCount > 0 || queuedStructuralMapHintedRoot.mappedStructuralAppendCount > 0) {
+    const hintedBlockAnalysis = analyzeComposableBlocks(
+      queuedStructuralMapHintedRoot.root,
+      reactiveByValue,
+      safeGlobals,
+      listNames,
+      allowedComponentNames
+    );
+    const hintedAnalysis = analyzeHostTree(
+      queuedStructuralMapHintedRoot.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 = queuedStructuralMapHintedRoot.root;
+      blockAnalysis = hintedBlockAnalysis;
+      analysis = hintedAnalysis;
+      appliedQueuedStructuralMapHints = queuedStructuralMapHintedRoot.mapCount;
+      appliedQueuedStructuralAppendMapHints = queuedStructuralMapHintedRoot.structuralAppendMapCount + queuedStructuralMapHintedRoot.mappedStructuralAppendCount;
+      appliedKeyedArrayReorderHints += queuedStructuralMapHintedRoot.mapCount;
+      appliedReorderHintedStateIndices = /* @__PURE__ */ new Set([
+        ...appliedReorderHintedStateIndices,
+        ...queuedStructuralMapHintedRoot.stateIndices
+      ]);
+      compilerUsage.keyedArrayMapUpdateHints += queuedStructuralMapHintedRoot.mapCount;
+      compilerUsage.keyedArrayMappedStructuralAppendHints += queuedStructuralMapHintedRoot.mappedStructuralAppendCount;
+      compilerUsage.keyedArrayStructuralAppendMapHints += queuedStructuralMapHintedRoot.structuralAppendMapCount;
+    }
+  }
+  const queuedStructuralPrependMapHintedRoot = rewriteQueuedKeyedArrayStructuralPrependMapHints(
+    expandedReactiveRoot,
+    statesBySetter,
+    keyedMapUpdateIdentifier,
+    keyedArrayMapPipelineIdentifier,
+    keyedArrayPrependIdentifier,
+    keyedArrayMappedStructuralPrependIdentifier,
+    keyedArrayStructuralPrependMapPipelineIdentifier,
+    keyedArrayFilterIdentifier,
+    keyedArraySliceIdentifier,
+    keyedArrayMappedStructuralIdentifier,
+    allowKeyedArrayMapPipelines
+  );
+  let appliedQueuedStructuralPrependMapHints = 0;
+  if (queuedStructuralPrependMapHintedRoot.structuralPrependMapCount > 0 || queuedStructuralPrependMapHintedRoot.mappedStructuralPrependCount > 0) {
+    const hintedBlockAnalysis = analyzeComposableBlocks(
+      queuedStructuralPrependMapHintedRoot.root,
+      reactiveByValue,
+      safeGlobals,
+      listNames,
+      allowedComponentNames
+    );
+    const hintedAnalysis = analyzeHostTree(
+      queuedStructuralPrependMapHintedRoot.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 = queuedStructuralPrependMapHintedRoot.root;
+      blockAnalysis = hintedBlockAnalysis;
+      analysis = hintedAnalysis;
+      appliedQueuedStructuralPrependMapHints = queuedStructuralPrependMapHintedRoot.structuralPrependMapCount + queuedStructuralPrependMapHintedRoot.mappedStructuralPrependCount;
+      compilerUsage.keyedArrayMappedStructuralPrependHints += queuedStructuralPrependMapHintedRoot.mappedStructuralPrependCount;
+      compilerUsage.keyedArrayStructuralPrependMapHints += queuedStructuralPrependMapHintedRoot.structuralPrependMapCount;
+    }
+  }
+  const queuedMapReorderHintedRoot = rewriteQueuedKeyedArrayMapReorderHints(
+    expandedReactiveRoot,
+    statesBySetter,
+    keyedMapUpdateIdentifier,
+    keyedArrayQueuedMapPipelineIdentifier,
+    keyedArrayMapReorderIdentifier,
+    keyedArrayReorderIdentifier,
+    keyedArraySortIdentifier,
+    keyedArrayStructuralReorderIdentifier,
+    keyedArrayStructuralSortIdentifier,
+    allowKeyedArrayMapPipelines
+  );
+  const queuedReorderMapHintedRoot = rewriteQueuedKeyedArrayReorderMapHints(
+    queuedMapReorderHintedRoot.root,
+    statesBySetter,
+    keyedMapUpdateIdentifier,
+    keyedArrayQueuedMapPipelineIdentifier,
+    keyedArrayMapReorderIdentifier,
+    keyedArrayReorderIdentifier,
+    keyedArraySortIdentifier,
+    keyedArrayStructuralReorderIdentifier,
+    keyedArrayStructuralSortIdentifier,
+    allowKeyedArrayMapPipelines
+  );
+  let appliedQueuedReorderMapHints = 0;
+  const queuedMapCount = queuedMapReorderHintedRoot.mapCount + queuedReorderMapHintedRoot.mapCount;
+  const queuedMapReorderCount = queuedMapReorderHintedRoot.mapReorderCount + queuedMapReorderHintedRoot.mapSortCount;
+  if (queuedMapCount > 0 || queuedMapReorderCount > 0) {
+    const hintedBlockAnalysis = analyzeComposableBlocks(
+      queuedReorderMapHintedRoot.root,
+      reactiveByValue,
+      safeGlobals,
+      listNames,
+      allowedComponentNames
+    );
+    const hintedAnalysis = analyzeHostTree(
+      queuedReorderMapHintedRoot.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 = queuedReorderMapHintedRoot.root;
+      blockAnalysis = hintedBlockAnalysis;
+      analysis = hintedAnalysis;
+      appliedQueuedReorderMapHints = queuedMapCount + queuedMapReorderCount;
+      compilerUsage.keyedArrayMapUpdateHints += queuedMapCount;
+      compilerUsage.keyedArrayQueuedMapUpdateHints += queuedMapCount;
+      compilerUsage.keyedArrayMapReorderHints += queuedMapReorderHintedRoot.mapReorderCount;
+      compilerUsage.keyedArrayMapSortHints += queuedMapReorderHintedRoot.mapSortCount;
+    }
+  }
+  const queuedStructuralReorderHintedRoot = rewriteQueuedKeyedArrayStructuralReorderHints(
+    expandedReactiveRoot,
+    statesBySetter,
+    keyedArrayFilterIdentifier,
+    keyedArraySliceIdentifier,
+    keyedArrayMapPipelineIdentifier,
+    keyedArrayQueuedMapPipelineIdentifier,
+    keyedArrayMappedStructuralIdentifier,
+    keyedArrayMapReorderIdentifier,
+    keyedArrayReorderIdentifier,
+    keyedArraySortIdentifier,
+    keyedArrayStructuralReorderIdentifier,
+    keyedArrayStructuralSortIdentifier,
+    allowKeyedArrayMapPipelines
+  );
+  if (queuedStructuralReorderHintedRoot.reorderCount > 0 || queuedStructuralReorderHintedRoot.sortCount > 0 || queuedStructuralReorderHintedRoot.replacedQueuedMapCount > 0) {
+    const hintedBlockAnalysis = analyzeComposableBlocks(
+      queuedStructuralReorderHintedRoot.root,
+      reactiveByValue,
+      safeGlobals,
+      listNames,
+      allowedComponentNames
+    );
+    const hintedAnalysis = analyzeHostTree(
+      queuedStructuralReorderHintedRoot.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 = queuedStructuralReorderHintedRoot.root;
+      blockAnalysis = hintedBlockAnalysis;
+      analysis = hintedAnalysis;
+      compilerUsage.keyedArrayQueuedMapUpdateHints -= queuedStructuralReorderHintedRoot.replacedQueuedMapCount;
+      compilerUsage.keyedArrayMapReorderHints -= queuedStructuralReorderHintedRoot.replacedMapReorderCount;
+      compilerUsage.keyedArrayMapSortHints -= queuedStructuralReorderHintedRoot.replacedMapSortCount;
+      compilerUsage.keyedArrayStructuralReorderHints += queuedStructuralReorderHintedRoot.reorderCount;
+      compilerUsage.keyedArrayStructuralSortHints += queuedStructuralReorderHintedRoot.sortCount;
+    }
+  }
   const keyedCollectionTargetKinds = /* @__PURE__ */ new Map();
   const conflictingKeyedCollectionTargets = /* @__PURE__ */ new Set();
   for (const plan of blockAnalysis.plans || []) {
@@ -5430,9 +6762,16 @@ function compileCandidate(candidate, createComponentIdentifier, keyedMapUpdateId
     blockPlans,
     hasKeyedUpdateHints,
     hasKeyedArrayRemovalHints,
+    appliedKeyedArrayAppendHints > 0 && (appliedKeyedArrayFilterHints > 0 || appliedKeyedArraySliceHints > 0),
+    appliedQueuedStructuralAppendMapHints > 0,
     appliedKeyedArrayPrependHints > 0,
+    appliedKeyedArrayPrependHints > 0 && hasKeyedArrayRemovalHints,
+    appliedQueuedStructuralPrependMapHints > 0,
     appliedKeyedArrayPositionHints > 0,
+    appliedKeyedArrayBatchInsertHints > 0,
+    appliedKeyedArrayWindowReplaceHints > 0,
     appliedKeyedArrayReorderHints > 0 || appliedKeyedArraySortHints > 0,
+    appliedPipelineMapHints > 0 || appliedQueuedReorderMapHints > 0 || appliedQueuedMappedStructuralHints > 0 || appliedQueuedStructuralMapHints > 0,
     appliedKeyedArrayRollingWindowHints > 0
   );
   markShortCircuitBindings(analysis.bindings || []);
@@ -5614,6 +6953,21 @@ async function compileReactModule(code, id, options) {
     keyedMembershipTargets: 0,
     keyedMapUpdateHints: 0
   };
+  const compilerUsage = {
+    keyedArrayBatchInsertHints: 0,
+    keyedArrayMapReorderHints: 0,
+    keyedArrayMapSortHints: 0,
+    keyedArrayMapUpdateHints: 0,
+    keyedArrayMappedStructuralHints: 0,
+    keyedArrayMappedStructuralAppendHints: 0,
+    keyedArrayMappedStructuralPrependHints: 0,
+    keyedArrayQueuedMapUpdateHints: 0,
+    keyedArrayStructuralAppendMapHints: 0,
+    keyedArrayStructuralPrependMapHints: 0,
+    keyedArrayStructuralReorderHints: 0,
+    keyedArrayStructuralSortHints: 0,
+    keyedArrayWindowReplaceHints: 0
+  };
   const plugin = () => ({
     name: "farm-react-aot",
     visitor: {
@@ -5652,18 +7006,54 @@ async function compileReactModule(code, id, options) {
         const keyedArrayFilterIdentifier = programPath.scope.generateUidIdentifier(
           "createCompilerKeyedArrayFilter"
         );
+        const keyedArrayMapPipelineIdentifier = programPath.scope.generateUidIdentifier(
+          "createCompilerKeyedArrayMapPipeline"
+        );
+        const keyedArrayMappedStructuralAppendIdentifier = programPath.scope.generateUidIdentifier(
+          "createCompilerKeyedArrayMappedStructuralAppend"
+        );
+        const keyedArrayStructuralAppendMapPipelineIdentifier = programPath.scope.generateUidIdentifier(
+          "createCompilerKeyedArrayStructuralAppendMapPipeline"
+        );
+        const keyedArrayMappedStructuralPrependIdentifier = programPath.scope.generateUidIdentifier(
+          "createCompilerKeyedArrayMappedStructuralPrepend"
+        );
+        const keyedArrayStructuralPrependMapPipelineIdentifier = programPath.scope.generateUidIdentifier(
+          "createCompilerKeyedArrayStructuralPrependMapPipeline"
+        );
+        const keyedArrayQueuedMapPipelineIdentifier = programPath.scope.generateUidIdentifier(
+          "createCompilerKeyedArrayQueuedMapPipeline"
+        );
+        const keyedArrayMapReorderIdentifier = programPath.scope.generateUidIdentifier(
+          "createCompilerKeyedArrayMapReorder"
+        );
+        const keyedArrayMappedStructuralIdentifier = programPath.scope.generateUidIdentifier(
+          "finalizeCompilerKeyedArrayMappedStructuralUpdate"
+        );
         const keyedArrayPrependIdentifier = programPath.scope.generateUidIdentifier(
           "createCompilerKeyedArrayPrepend"
         );
         const keyedArrayPositionIdentifier = programPath.scope.generateUidIdentifier(
           "createCompilerKeyedArrayPositionUpdate"
         );
+        const keyedArrayBatchInsertIdentifier = programPath.scope.generateUidIdentifier(
+          "createCompilerKeyedArrayBatchInsert"
+        );
+        const keyedArrayWindowReplaceIdentifier = programPath.scope.generateUidIdentifier(
+          "createCompilerKeyedArrayWindowReplace"
+        );
         const keyedArrayReorderIdentifier = programPath.scope.generateUidIdentifier(
           "createCompilerKeyedArrayReorder"
         );
+        const keyedArrayStructuralReorderIdentifier = programPath.scope.generateUidIdentifier(
+          "createCompilerKeyedArrayStructuralReorder"
+        );
         const keyedArraySortIdentifier = programPath.scope.generateUidIdentifier(
           "createCompilerKeyedArraySort"
         );
+        const keyedArrayStructuralSortIdentifier = programPath.scope.generateUidIdentifier(
+          "createCompilerKeyedArrayStructuralSort"
+        );
         const keyedArrayRollingWindowIdentifier = programPath.scope.generateUidIdentifier(
           "createCompilerKeyedArrayRollingWindow"
         );
@@ -5696,10 +7086,22 @@ async function compileReactModule(code, id, options) {
             keyedMapUpdateIdentifier,
             keyedArrayAppendIdentifier,
             keyedArrayFilterIdentifier,
+            keyedArrayMapPipelineIdentifier,
+            keyedArrayMappedStructuralAppendIdentifier,
+            keyedArrayStructuralAppendMapPipelineIdentifier,
+            keyedArrayMappedStructuralPrependIdentifier,
+            keyedArrayStructuralPrependMapPipelineIdentifier,
+            keyedArrayQueuedMapPipelineIdentifier,
+            keyedArrayMapReorderIdentifier,
+            keyedArrayMappedStructuralIdentifier,
             keyedArrayPrependIdentifier,
             keyedArrayPositionIdentifier,
+            keyedArrayBatchInsertIdentifier,
+            keyedArrayWindowReplaceIdentifier,
             keyedArrayReorderIdentifier,
+            keyedArrayStructuralReorderIdentifier,
             keyedArraySortIdentifier,
+            keyedArrayStructuralSortIdentifier,
             keyedArrayRollingWindowIdentifier,
             keyedArraySliceIdentifier,
             keyedCollectionUpdateIdentifier,
@@ -5707,6 +7109,7 @@ async function compileReactModule(code, id, options) {
             runtimeFeatureIdentifiers,
             usedRuntimeFeatures,
             optimizationCounts,
+            compilerUsage,
             useStateNames,
             reactNames,
             listNames,
@@ -5723,6 +7126,12 @@ async function compileReactModule(code, id, options) {
             compiled.push(candidate.name);
           }
         }
+        const hasEagerKeyedArrayMapUpdateHints = compilerUsage.keyedArrayMapUpdateHints > compilerUsage.keyedArrayQueuedMapUpdateHints + compilerUsage.keyedArrayStructuralAppendMapHints + compilerUsage.keyedArrayStructuralPrependMapHints;
+        const hasKeyedArrayMapReorderHints = compilerUsage.keyedArrayMapReorderHints + compilerUsage.keyedArrayMapSortHints > 0;
+        const hasKeyedArrayStructuralAppendHints = optimizationCounts.keyedArrayAppendHints > 0 && (optimizationCounts.keyedArrayFilterHints > 0 || optimizationCounts.keyedArraySliceHints > 0);
+        const hasUnmappedKeyedArrayAppendHints = optimizationCounts.keyedArrayAppendHints > compilerUsage.keyedArrayMappedStructuralAppendHints;
+        const hasKeyedArrayStructuralPrependHints = optimizationCounts.keyedArrayPrependHints > 0 && (optimizationCounts.keyedArrayFilterHints > 0 || optimizationCounts.keyedArraySliceHints > 0);
+        const hasUnmappedKeyedArrayPrependHints = optimizationCounts.keyedArrayPrependHints > compilerUsage.keyedArrayMappedStructuralPrependHints;
         if (compiled.length > 0) {
           programPath.unshiftContainer(
             "body",
@@ -5732,16 +7141,66 @@ async function compileReactModule(code, id, options) {
                   createComponentIdentifier,
                   core.types.identifier("createCompiledComponentWithFeatures")
                 ),
-                ...optimizationCounts.keyedMapUpdateHints > 0 ? [
+                ...optimizationCounts.keyedMapUpdateHints > compilerUsage.keyedArrayMapUpdateHints ? [
                   core.types.importSpecifier(
                     keyedMapUpdateIdentifier,
                     core.types.identifier("createCompilerKeyedMapUpdate")
                   )
                 ] : [],
-                ...optimizationCounts.keyedArrayAppendHints > 0 ? [
+                ...hasEagerKeyedArrayMapUpdateHints ? [
+                  core.types.importSpecifier(
+                    keyedArrayMapPipelineIdentifier,
+                    core.types.identifier("createCompilerKeyedArrayMapPipeline")
+                  )
+                ] : [],
+                ...compilerUsage.keyedArrayStructuralAppendMapHints > 0 ? [
+                  core.types.importSpecifier(
+                    keyedArrayStructuralAppendMapPipelineIdentifier,
+                    core.types.identifier("createCompilerKeyedArrayStructuralAppendMapPipeline")
+                  )
+                ] : [],
+                ...compilerUsage.keyedArrayStructuralPrependMapHints > 0 ? [
+                  core.types.importSpecifier(
+                    keyedArrayStructuralPrependMapPipelineIdentifier,
+                    core.types.identifier("createCompilerKeyedArrayStructuralPrependMapPipeline")
+                  )
+                ] : [],
+                ...hasKeyedArrayMapReorderHints ? [
+                  core.types.importSpecifier(
+                    keyedArrayMapReorderIdentifier,
+                    core.types.identifier("createCompilerKeyedArrayMapReorder")
+                  )
+                ] : [],
+                ...compilerUsage.keyedArrayMappedStructuralHints > 0 ? [
+                  core.types.importSpecifier(
+                    keyedArrayMappedStructuralIdentifier,
+                    core.types.identifier("finalizeCompilerKeyedArrayMappedStructuralUpdate")
+                  )
+                ] : [],
+                ...compilerUsage.keyedArrayMappedStructuralAppendHints > 0 ? [
+                  core.types.importSpecifier(
+                    keyedArrayMappedStructuralAppendIdentifier,
+                    core.types.identifier("createCompilerKeyedArrayMappedStructuralAppend")
+                  )
+                ] : [],
+                ...compilerUsage.keyedArrayMappedStructuralPrependHints > 0 ? [
+                  core.types.importSpecifier(
+                    keyedArrayMappedStructuralPrependIdentifier,
+                    core.types.identifier("createCompilerKeyedArrayMappedStructuralPrepend")
+                  )
+                ] : [],
+                ...compilerUsage.keyedArrayQueuedMapUpdateHints > 0 ? [
+                  core.types.importSpecifier(
+                    keyedArrayQueuedMapPipelineIdentifier,
+                    core.types.identifier("createCompilerKeyedArrayQueuedMapPipeline")
+                  )
+                ] : [],
+                ...hasUnmappedKeyedArrayAppendHints ? [
                   core.types.importSpecifier(
                     keyedArrayAppendIdentifier,
-                    core.types.identifier("createCompilerKeyedArrayAppend")
+                    core.types.identifier(
+                      hasKeyedArrayStructuralAppendHints ? "createCompilerKeyedArrayStructuralAppend" : "createCompilerKeyedArrayAppend"
+                    )
                   )
                 ] : [],
                 ...optimizationCounts.keyedArrayFilterHints > 0 ? [
@@ -5750,30 +7209,56 @@ async function compileReactModule(code, id, options) {
                     core.types.identifier("createCompilerKeyedArrayFilter")
                   )
                 ] : [],
-                ...optimizationCounts.keyedArrayPrependHints > 0 ? [
+                ...hasUnmappedKeyedArrayPrependHints ? [
                   core.types.importSpecifier(
                     keyedArrayPrependIdentifier,
-                    core.types.identifier("createCompilerKeyedArrayPrepend")
+                    core.types.identifier(
+                      hasKeyedArrayStructuralPrependHints ? "createCompilerKeyedArrayStructuralPrepend" : "createCompilerKeyedArrayPrepend"
+                    )
                   )
                 ] : [],
-                ...optimizationCounts.keyedArrayPositionHints > 0 ? [
+                ...optimizationCounts.keyedArrayPositionHints > compilerUsage.keyedArrayBatchInsertHints + compilerUsage.keyedArrayWindowReplaceHints ? [
                   core.types.importSpecifier(
                     keyedArrayPositionIdentifier,
                     core.types.identifier("createCompilerKeyedArrayPositionUpdate")
                   )
                 ] : [],
-                ...optimizationCounts.keyedArrayReorderHints > 0 ? [
+                ...compilerUsage.keyedArrayBatchInsertHints > 0 ? [
+                  core.types.importSpecifier(
+                    keyedArrayBatchInsertIdentifier,
+                    core.types.identifier("createCompilerKeyedArrayBatchInsert")
+                  )
+                ] : [],
+                ...compilerUsage.keyedArrayWindowReplaceHints > 0 ? [
+                  core.types.importSpecifier(
+                    keyedArrayWindowReplaceIdentifier,
+                    core.types.identifier("createCompilerKeyedArrayWindowReplace")
+                  )
+                ] : [],
+                ...optimizationCounts.keyedArrayReorderHints > compilerUsage.keyedArrayStructuralReorderHints + compilerUsage.keyedArrayMapReorderHints ? [
                   core.types.importSpecifier(
                     keyedArrayReorderIdentifier,
                     core.types.identifier("createCompilerKeyedArrayReorder")
                   )
                 ] : [],
-                ...optimizationCounts.keyedArraySortHints > 0 ? [
+                ...compilerUsage.keyedArrayStructuralReorderHints > 0 ? [
+                  core.types.importSpecifier(
+                    keyedArrayStructuralReorderIdentifier,
+                    core.types.identifier("createCompilerKeyedArrayStructuralReorder")
+                  )
+                ] : [],
+                ...optimizationCounts.keyedArraySortHints > compilerUsage.keyedArrayStructuralSortHints + compilerUsage.keyedArrayMapSortHints ? [
                   core.types.importSpecifier(
                     keyedArraySortIdentifier,
                     core.types.identifier("createCompilerKeyedArraySort")
                   )
                 ] : [],
+                ...compilerUsage.keyedArrayStructuralSortHints > 0 ? [
+                  core.types.importSpecifier(
+                    keyedArrayStructuralSortIdentifier,
+                    core.types.identifier("createCompilerKeyedArrayStructuralSort")
+                  )
+                ] : [],
                 ...optimizationCounts.keyedArrayRollingWindowHints > 0 ? [
                   core.types.importSpecifier(
                     keyedArrayRollingWindowIdentifier,
@@ -5914,12 +7399,46 @@ function createReactCompilerReport(projectRoot, observations) {
 }
 async function writeReactCompilerReport(projectRoot, reportFile, observations) {
   const outputPath = path.resolve(projectRoot, reportFile);
+  await assertReportPathInsideProject(projectRoot, outputPath);
   const report = createReactCompilerReport(projectRoot, observations);
   await promises.mkdir(path.dirname(outputPath), { recursive: true });
   await promises.writeFile(outputPath, `${JSON.stringify(report, null, 2)}
 `, "utf8");
   return outputPath;
 }
+async function assertReportPathInsideProject(projectRoot, outputPath) {
+  const realProjectRoot = await promises.realpath(projectRoot);
+  let existingAncestor = outputPath;
+  while (true) {
+    try {
+      existingAncestor = await promises.realpath(existingAncestor);
+      break;
+    } catch (error) {
+      if (error.code !== "ENOENT") throw error;
+      let existingEntry = false;
+      try {
+        await promises.lstat(existingAncestor);
+        existingEntry = true;
+      } catch (statError) {
+        if (statError.code !== "ENOENT") throw statError;
+      }
+      if (existingEntry) {
+        throw new Error(
+          "The React compiler report file must stay inside the project root, including through symlinks."
+        );
+      }
+      const parent = path.dirname(existingAncestor);
+      if (parent === existingAncestor) throw error;
+      existingAncestor = parent;
+    }
+  }
+  const relativePath = path.relative(realProjectRoot, existingAncestor);
+  if (relativePath === ".." || relativePath.startsWith(`..${path.sep}`) || path.isAbsolute(relativePath)) {
+    throw new Error(
+      "The React compiler report file must stay inside the project root, including through symlinks."
+    );
+  }
+}
 
 // src/index.ts
 var DEFAULT_COMPILER_DIRECTIVE = "use compiler";