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

package/dist/compiler-runtime.cjs

@@ -25,6 +25,463 @@ function materializeIterable(source) {
 }
 
 // src/compiler-runtime.tsx
+var COMPILER_KEYED_COLLECTION_TOKENS = /* @__PURE__ */ new WeakMap();
+var COMPILER_KEYED_MAP_UPDATES = /* @__PURE__ */ new WeakMap();
+var COMPILER_KEYED_ARRAY_APPENDS = /* @__PURE__ */ new WeakMap();
+var COMPILER_KEYED_ARRAY_FILTERS = /* @__PURE__ */ new WeakMap();
+var COMPILER_KEYED_ARRAY_PREPENDS = /* @__PURE__ */ new WeakMap();
+var COMPILER_KEYED_ARRAY_ROLLING_WINDOWS = /* @__PURE__ */ new WeakMap();
+var COMPILER_KEYED_ARRAY_POSITIONS = /* @__PURE__ */ new WeakMap();
+var COMPILER_KEYED_ARRAY_REORDERS = /* @__PURE__ */ new WeakMap();
+var COMPILER_KEYED_COLLECTION_DRAFTS = /* @__PURE__ */ new WeakMap();
+var COMPILER_KEYED_COLLECTION_UPDATES = /* @__PURE__ */ new WeakMap();
+var COMPILER_KEYED_COMMITTED_COLLECTIONS = /* @__PURE__ */ new WeakSet();
+var NATIVE_ARRAY_PROTOTYPE = Array.prototype;
+var NATIVE_ARRAY_ITERATOR = Array.prototype[Symbol.iterator];
+var NATIVE_ARRAY_FILTER = Array.prototype.filter;
+var NATIVE_ARRAY_SLICE = Array.prototype.slice;
+var NATIVE_ARRAY_TO_SPLICED = Array.prototype.toSpliced;
+var NATIVE_ARRAY_WITH = Array.prototype.with;
+var NATIVE_ARRAY_TO_REVERSED = Array.prototype.toReversed;
+var NATIVE_ARRAY_TO_SORTED = Array.prototype.toSorted;
+var NATIVE_REFLECT_APPLY = Reflect.apply;
+function compilerObject(value) {
+  return typeof value === "object" && value !== null || typeof value === "function" ? value : void 0;
+}
+function compilerKeyedCollectionToken(value) {
+  const target = compilerObject(value);
+  if (!target) return void 0;
+  let token = COMPILER_KEYED_COLLECTION_TOKENS.get(target);
+  if (!token) {
+    token = {};
+    COMPILER_KEYED_COLLECTION_TOKENS.set(target, token);
+  }
+  return token;
+}
+function commitCompilerKeyedCollection(value) {
+  const target = compilerObject(value);
+  if (!target) return void 0;
+  COMPILER_KEYED_COMMITTED_COLLECTIONS.add(target);
+  return compilerKeyedCollectionToken(target);
+}
+function compilerKeyedMapChangedIndices(value, sourceToken) {
+  const target = compilerObject(value);
+  if (!target || !sourceToken) return void 0;
+  const update = COMPILER_KEYED_MAP_UPDATES.get(target);
+  if (!update || update.sourceToken !== sourceToken) return void 0;
+  const changedIndices = [];
+  for (let current = update; current; current = current.previous) {
+    changedIndices.push(...current.changedIndices);
+  }
+  return changedIndices;
+}
+function compilerKeyedArrayAppendStart(value, sourceToken, expectedStart) {
+  const target = compilerObject(value);
+  if (!target || !sourceToken || !Array.isArray(value)) return void 0;
+  const update = COMPILER_KEYED_ARRAY_APPENDS.get(target);
+  if (!update || update.sourceToken !== sourceToken) return void 0;
+  const updates = [];
+  for (let current = update; current; current = current.previous) {
+    if (current.sourceToken !== sourceToken) return void 0;
+    updates.push(current);
+  }
+  let length = expectedStart;
+  for (let index = updates.length - 1; index >= 0; index -= 1) {
+    const current = updates[index];
+    if (current.startIndex !== length || current.resultLength < length) return void 0;
+    length = current.resultLength;
+  }
+  return length === value.length ? expectedStart : void 0;
+}
+function compilerKeyedArrayFilterSurvivors(value, sourceToken, expectedLength) {
+  const target = compilerObject(value);
+  if (!target || !sourceToken || !Array.isArray(value)) return void 0;
+  const update = COMPILER_KEYED_ARRAY_FILTERS.get(target);
+  if (!update || update.sourceToken !== sourceToken) return void 0;
+  const updates = [];
+  for (let current = update; current; current = current.previous) {
+    if (current.sourceToken !== sourceToken) return void 0;
+    updates.push(current);
+  }
+  let survivors = Array.from({ length: expectedLength }, (_, index) => index);
+  let keysStable = true;
+  for (let updateIndex = updates.length - 1; updateIndex >= 0; updateIndex -= 1) {
+    const current = updates[updateIndex];
+    if (current.sourceLength !== survivors.length) return void 0;
+    if (current.kind === "slice") {
+      const start = current.retainedStart;
+      const end = current.retainedEnd;
+      if (start === void 0 || end === void 0 || !Number.isSafeInteger(start) || !Number.isSafeInteger(end) || start < 0 || end < start || end > current.sourceLength || current.resultLength !== end - start) {
+        return void 0;
+      }
+      survivors = survivors.slice(start, end);
+      continue;
+    }
+    keysStable = false;
+    const removed = /* @__PURE__ */ new Set();
+    for (const index of current.removedIndices || []) {
+      if (!Number.isSafeInteger(index) || index < 0 || index >= current.sourceLength)
+        return void 0;
+      removed.add(index);
+    }
+    if (current.resultLength !== current.sourceLength - removed.size) return void 0;
+    survivors = survivors.filter((_sourceIndex, index) => !removed.has(index));
+  }
+  return survivors.length === value.length ? { indices: survivors, keysStable } : void 0;
+}
+function compilerKeyedArrayPrependLength(value, sourceToken, expectedLength) {
+  const target = compilerObject(value);
+  if (!target || !sourceToken || !Array.isArray(value)) return void 0;
+  const update = COMPILER_KEYED_ARRAY_PREPENDS.get(target);
+  if (!update || update.sourceToken !== sourceToken) return void 0;
+  const updates = [];
+  for (let current = update; current; current = current.previous) {
+    if (current.sourceToken !== sourceToken) return void 0;
+    updates.push(current);
+  }
+  let length = expectedLength;
+  let prefixLength = 0;
+  for (let index = updates.length - 1; index >= 0; index -= 1) {
+    const current = updates[index];
+    if (current.sourceLength !== length || current.prefixLength < 1 || current.resultLength !== current.sourceLength + current.prefixLength) {
+      return void 0;
+    }
+    length = current.resultLength;
+    prefixLength += current.prefixLength;
+  }
+  return length === value.length ? prefixLength : void 0;
+}
+function compilerKeyedArrayRollingWindow(value, sourceToken, expectedLength) {
+  const target = compilerObject(value);
+  if (!target || !sourceToken || !Array.isArray(value)) return void 0;
+  const update = COMPILER_KEYED_ARRAY_ROLLING_WINDOWS.get(target);
+  if (!update || update.sourceToken !== sourceToken || update.sourceLength !== expectedLength || update.resultLength !== value.length || update.retainedStart < 1 || update.retainedEnd !== update.sourceLength || update.resultLength <= update.retainedEnd - update.retainedStart) {
+    return void 0;
+  }
+  return update;
+}
+function compilerKeyedArrayPosition(value, sourceToken, expectedLength) {
+  const target = compilerObject(value);
+  if (!target || !sourceToken || !Array.isArray(value)) return void 0;
+  const update = COMPILER_KEYED_ARRAY_POSITIONS.get(target);
+  if (!update || update.sourceToken !== sourceToken || update.sourceLength !== expectedLength || update.resultLength !== value.length || update.position < 0 || update.position > expectedLength || update.kind === "insert" && update.resultLength !== expectedLength + 1 || update.kind === "remove" && (update.position >= expectedLength || update.resultLength !== expectedLength - 1) || update.kind === "replace" && (update.position >= expectedLength || update.resultLength !== expectedLength)) {
+    return void 0;
+  }
+  return update;
+}
+function compilerKeyedArrayReorder(value, sourceToken, expectedLength) {
+  const target = compilerObject(value);
+  if (!target || !sourceToken || !Array.isArray(value)) return void 0;
+  const update = COMPILER_KEYED_ARRAY_REORDERS.get(target);
+  if (!update || update.sourceToken !== sourceToken || update.sourceLength !== expectedLength || update.resultLength !== expectedLength || update.resultLength !== value.length) {
+    return void 0;
+  }
+  return update;
+}
+function compilerKeyedCollectionChangedKeys(value, sourceToken, kind) {
+  const target = compilerObject(value);
+  if (!target || !sourceToken) return void 0;
+  const update = COMPILER_KEYED_COLLECTION_UPDATES.get(target);
+  if (!update || update.kind !== kind || update.sourceToken !== sourceToken) return void 0;
+  const changedKeys = [];
+  for (let current = update; current; current = current.previous) {
+    if (current.kind !== kind || current.sourceToken !== sourceToken) return void 0;
+    changedKeys.push(...current.changedKeys);
+  }
+  return changedKeys;
+}
+function createCompilerKeyedMapUpdate(previous, value, changedIndices) {
+  const previousTarget = compilerObject(previous);
+  const valueTarget = compilerObject(value);
+  const sourceToken = compilerKeyedCollectionToken(previousTarget);
+  if (valueTarget && sourceToken) {
+    const previousUpdate = previousTarget && !COMPILER_KEYED_COMMITTED_COLLECTIONS.has(previousTarget) ? COMPILER_KEYED_MAP_UPDATES.get(previousTarget) : void 0;
+    COMPILER_KEYED_MAP_UPDATES.set(valueTarget, {
+      sourceToken: previousUpdate?.sourceToken || sourceToken,
+      changedIndices,
+      ...previousUpdate ? { previous: previousUpdate } : {}
+    });
+  }
+  return value;
+}
+function createCompilerKeyedArrayAppend(previous, value) {
+  try {
+    const previousTarget = compilerObject(previous);
+    const valueTarget = compilerObject(value);
+    if (!previousTarget || !valueTarget || !Array.isArray(previous) || !Array.isArray(value) || Object.getPrototypeOf(previous) !== NATIVE_ARRAY_PROTOTYPE || Object.getPrototypeOf(value) !== NATIVE_ARRAY_PROTOTYPE || previous[Symbol.iterator] !== NATIVE_ARRAY_ITERATOR) {
+      return value;
+    }
+    const startIndex = previous.length;
+    if (value.length < startIndex) return value;
+    const sourceToken = compilerKeyedCollectionToken(previousTarget);
+    if (!sourceToken) return value;
+    const previousUpdate = !COMPILER_KEYED_COMMITTED_COLLECTIONS.has(previousTarget) ? COMPILER_KEYED_ARRAY_APPENDS.get(previousTarget) : void 0;
+    COMPILER_KEYED_ARRAY_APPENDS.set(valueTarget, {
+      sourceToken: previousUpdate?.sourceToken || sourceToken,
+      startIndex,
+      resultLength: value.length,
+      ...previousUpdate ? { previous: previousUpdate } : {}
+    });
+    return value;
+  } catch {
+    return value;
+  }
+}
+function createCompilerKeyedArrayPrepend(previous, value) {
+  try {
+    const previousTarget = compilerObject(previous);
+    const valueTarget = compilerObject(value);
+    if (!previousTarget || !valueTarget || !Array.isArray(previous) || !Array.isArray(value) || Object.getPrototypeOf(previous) !== NATIVE_ARRAY_PROTOTYPE || Object.getPrototypeOf(value) !== NATIVE_ARRAY_PROTOTYPE || previous[Symbol.iterator] !== NATIVE_ARRAY_ITERATOR) {
+      return value;
+    }
+    const sourceLength = previous.length;
+    const prefixLength = value.length - sourceLength;
+    if (prefixLength < 1) return value;
+    const sourceToken = compilerKeyedCollectionToken(previousTarget);
+    if (!sourceToken) return value;
+    const previousUpdate = !COMPILER_KEYED_COMMITTED_COLLECTIONS.has(previousTarget) ? COMPILER_KEYED_ARRAY_PREPENDS.get(previousTarget) : void 0;
+    COMPILER_KEYED_ARRAY_PREPENDS.set(valueTarget, {
+      sourceToken: previousUpdate?.sourceToken || sourceToken,
+      sourceLength,
+      resultLength: value.length,
+      prefixLength,
+      ...previousUpdate ? { previous: previousUpdate } : {}
+    });
+    return value;
+  } catch {
+    return value;
+  }
+}
+function createCompilerKeyedArrayFilter(previous, method, predicate) {
+  let canHint = false;
+  let sourceLength = 0;
+  try {
+    canHint = Array.isArray(previous) && Object.getPrototypeOf(previous) === NATIVE_ARRAY_PROTOTYPE && method === NATIVE_ARRAY_FILTER && typeof predicate === "function";
+    if (canHint) sourceLength = previous.length;
+  } catch {
+    canHint = false;
+  }
+  if (!canHint) {
+    return NATIVE_REFLECT_APPLY(method, previous, [predicate]);
+  }
+  const removedIndices = [];
+  let visited = 0;
+  const wrappedPredicate = function(item, index, collection) {
+    visited += 1;
+    const keep = NATIVE_REFLECT_APPLY(predicate, this, [
+      item,
+      index,
+      collection
+    ]);
+    if (!keep) removedIndices.push(index);
+    return keep;
+  };
+  const value = NATIVE_REFLECT_APPLY(method, previous, [
+    wrappedPredicate
+  ]);
+  try {
+    const previousTarget = compilerObject(previous);
+    const valueTarget = compilerObject(value);
+    if (!previousTarget || !valueTarget || !Array.isArray(value) || Object.getPrototypeOf(value) !== NATIVE_ARRAY_PROTOTYPE || visited !== sourceLength || value.length !== sourceLength - removedIndices.length) {
+      return value;
+    }
+    const sourceToken = compilerKeyedCollectionToken(previousTarget);
+    if (!sourceToken) return value;
+    const previousUpdate = !COMPILER_KEYED_COMMITTED_COLLECTIONS.has(previousTarget) ? COMPILER_KEYED_ARRAY_FILTERS.get(previousTarget) : void 0;
+    COMPILER_KEYED_ARRAY_FILTERS.set(valueTarget, {
+      kind: "filter",
+      sourceToken: previousUpdate?.sourceToken || sourceToken,
+      sourceLength,
+      resultLength: value.length,
+      removedIndices,
+      ...previousUpdate ? { previous: previousUpdate } : {}
+    });
+  } catch {
+  }
+  return value;
+}
+function createCompilerKeyedArraySlice(previous, method, ...args) {
+  const canHint = (() => {
+    try {
+      return Array.isArray(previous) && Object.getPrototypeOf(previous) === NATIVE_ARRAY_PROTOTYPE && method === NATIVE_ARRAY_SLICE && args.length > 0 && args.length <= 2 && args.every((value2) => Number.isSafeInteger(value2));
+    } catch {
+      return false;
+    }
+  })();
+  const value = NATIVE_REFLECT_APPLY(method, previous, args);
+  if (!canHint) return value;
+  try {
+    const previousTarget = compilerObject(previous);
+    const valueTarget = compilerObject(value);
+    if (!previousTarget || !valueTarget || !Array.isArray(value) || Object.getPrototypeOf(value) !== NATIVE_ARRAY_PROTOTYPE) {
+      return value;
+    }
+    const sourceLength = previous.length;
+    const normalize = (relative) => relative < 0 ? Math.max(sourceLength + relative, 0) : Math.min(relative, sourceLength);
+    const retainedStart = normalize(args[0]);
+    const retainedEnd = args.length === 2 ? normalize(args[1]) : sourceLength;
+    const resultLength = Math.max(retainedEnd - retainedStart, 0);
+    if (value.length !== resultLength || resultLength >= sourceLength) return value;
+    const sourceToken = compilerKeyedCollectionToken(previousTarget);
+    if (!sourceToken) return value;
+    const previousUpdate = !COMPILER_KEYED_COMMITTED_COLLECTIONS.has(previousTarget) ? COMPILER_KEYED_ARRAY_FILTERS.get(previousTarget) : void 0;
+    COMPILER_KEYED_ARRAY_FILTERS.set(valueTarget, {
+      kind: "slice",
+      sourceToken: previousUpdate?.sourceToken || sourceToken,
+      sourceLength,
+      resultLength,
+      retainedEnd: Math.max(retainedEnd, retainedStart),
+      retainedStart,
+      ...previousUpdate ? { previous: previousUpdate } : {}
+    });
+  } catch {
+  }
+  return value;
+}
+function createCompilerKeyedArrayRollingWindow(previous, retained, value) {
+  try {
+    const previousTarget = compilerObject(previous);
+    const retainedTarget = compilerObject(retained);
+    const valueTarget = compilerObject(value);
+    if (!previousTarget || !retainedTarget || !valueTarget || !COMPILER_KEYED_COMMITTED_COLLECTIONS.has(previousTarget) || !Array.isArray(previous) || !Array.isArray(retained) || !Array.isArray(value) || Object.getPrototypeOf(previous) !== NATIVE_ARRAY_PROTOTYPE || Object.getPrototypeOf(retained) !== NATIVE_ARRAY_PROTOTYPE || Object.getPrototypeOf(value) !== NATIVE_ARRAY_PROTOTYPE) {
+      return value;
+    }
+    const sourceToken = compilerKeyedCollectionToken(previousTarget);
+    const slice = COMPILER_KEYED_ARRAY_FILTERS.get(retainedTarget);
+    if (!sourceToken || !slice || slice.previous || slice.kind !== "slice" || slice.sourceToken !== sourceToken || slice.sourceLength !== previous.length || slice.retainedStart === void 0 || slice.retainedEnd !== previous.length || slice.retainedStart < 1 || slice.resultLength !== retained.length || value.length <= retained.length) {
+      return value;
+    }
+    for (let index = 0; index < retained.length; index += 1) {
+      if (!Object.is(value[index], retained[index])) return value;
+    }
+    COMPILER_KEYED_ARRAY_ROLLING_WINDOWS.set(valueTarget, {
+      sourceToken,
+      sourceLength: previous.length,
+      resultLength: value.length,
+      retainedEnd: slice.retainedEnd,
+      retainedStart: slice.retainedStart
+    });
+  } catch {
+  }
+  return value;
+}
+function createCompilerKeyedArrayPositionUpdate(previous, method, kind, position, ...args) {
+  const callArgs = [position, ...args];
+  const value = NATIVE_REFLECT_APPLY(
+    method,
+    previous,
+    callArgs
+  );
+  try {
+    const previousTarget = compilerObject(previous);
+    const valueTarget = compilerObject(value);
+    if (!previousTarget || !valueTarget || !COMPILER_KEYED_COMMITTED_COLLECTIONS.has(previousTarget) || !Array.isArray(previous) || !Array.isArray(value) || Object.getPrototypeOf(previous) !== NATIVE_ARRAY_PROTOTYPE || Object.getPrototypeOf(value) !== NATIVE_ARRAY_PROTOTYPE || !Number.isSafeInteger(position)) {
+      return value;
+    }
+    const sourceLength = previous.length;
+    const normalizedPosition = position < 0 ? Math.max(sourceLength + position, 0) : Math.min(position, sourceLength);
+    const validInsert = kind === "insert" && method === NATIVE_ARRAY_TO_SPLICED && args.length === 2 && Object.is(args[0], 0) && value.length === sourceLength + 1;
+    const validRemove = kind === "remove" && method === NATIVE_ARRAY_TO_SPLICED && args.length === 1 && Object.is(args[0], 1) && normalizedPosition < sourceLength && value.length === sourceLength - 1;
+    const validReplace = kind === "replace" && method === NATIVE_ARRAY_WITH && args.length === 1 && position >= -sourceLength && position < sourceLength && value.length === sourceLength;
+    if (!validInsert && !validRemove && !validReplace) return value;
+    const sourceToken = compilerKeyedCollectionToken(previousTarget);
+    if (!sourceToken) return value;
+    COMPILER_KEYED_ARRAY_POSITIONS.set(valueTarget, {
+      kind,
+      sourceToken,
+      sourceLength,
+      resultLength: value.length,
+      position: normalizedPosition
+    });
+  } catch {
+  }
+  return value;
+}
+function createCompilerKeyedArrayReorder(previous, method) {
+  const value = NATIVE_REFLECT_APPLY(
+    method,
+    previous,
+    []
+  );
+  try {
+    const previousTarget = compilerObject(previous);
+    const valueTarget = compilerObject(value);
+    if (!previousTarget || !valueTarget || !COMPILER_KEYED_COMMITTED_COLLECTIONS.has(previousTarget) || !Array.isArray(previous) || !Array.isArray(value) || Object.getPrototypeOf(previous) !== NATIVE_ARRAY_PROTOTYPE || Object.getPrototypeOf(value) !== NATIVE_ARRAY_PROTOTYPE || method !== NATIVE_ARRAY_TO_REVERSED || value.length !== previous.length) {
+      return value;
+    }
+    const sourceToken = compilerKeyedCollectionToken(previousTarget);
+    if (!sourceToken) return value;
+    COMPILER_KEYED_ARRAY_REORDERS.set(valueTarget, {
+      kind: "reverse",
+      sourceToken,
+      sourceLength: previous.length,
+      resultLength: value.length
+    });
+  } catch {
+  }
+  return value;
+}
+function createCompilerKeyedArraySort(previous, method, ...args) {
+  const value = NATIVE_REFLECT_APPLY(
+    method,
+    previous,
+    args
+  );
+  try {
+    const previousTarget = compilerObject(previous);
+    const valueTarget = compilerObject(value);
+    if (!previousTarget || !valueTarget || !COMPILER_KEYED_COMMITTED_COLLECTIONS.has(previousTarget) || !Array.isArray(previous) || !Array.isArray(value) || Object.getPrototypeOf(previous) !== NATIVE_ARRAY_PROTOTYPE || Object.getPrototypeOf(value) !== NATIVE_ARRAY_PROTOTYPE || method !== NATIVE_ARRAY_TO_SORTED || args.length > 1 || args.length === 1 && args[0] !== void 0 && typeof args[0] !== "function" || value.length !== previous.length) {
+      return value;
+    }
+    for (let index = 0; index < previous.length; index += 1) {
+      if (!(index in previous)) return value;
+    }
+    const sourceToken = compilerKeyedCollectionToken(previousTarget);
+    if (!sourceToken) return value;
+    COMPILER_KEYED_ARRAY_REORDERS.set(valueTarget, {
+      kind: "sort",
+      sourceToken,
+      sourceLength: previous.length,
+      resultLength: value.length
+    });
+  } catch {
+  }
+  return value;
+}
+function applyCompilerKeyedCollectionMutation(collection, method, operation, key, value) {
+  const args = operation === "map-set" ? [key, value] : [key];
+  const result = NATIVE_REFLECT_APPLY(method, collection, args);
+  const target = compilerObject(collection);
+  if (!target) return result;
+  const kind = operation.startsWith("set-") ? "set" : "map";
+  const nativeMethod = operation === "set-add" ? NATIVE_SET_ADD : operation === "set-delete" ? NATIVE_SET_DELETE : operation === "map-set" ? NATIVE_MAP_SET : NATIVE_MAP_DELETE;
+  const nativePrototype = kind === "set" ? NATIVE_SET_PROTOTYPE : NATIVE_MAP_PROTOTYPE;
+  if (method !== nativeMethod || Object.getPrototypeOf(collection) !== nativePrototype) {
+    return result;
+  }
+  const existing = COMPILER_KEYED_COLLECTION_DRAFTS.get(target);
+  if (existing && existing.kind !== kind) return result;
+  if (existing) existing.changedKeys.push(key);
+  else COMPILER_KEYED_COLLECTION_DRAFTS.set(target, { kind, changedKeys: [key] });
+  return result;
+}
+function createCompilerKeyedCollectionUpdate(previous, value, kind) {
+  const previousTarget = compilerObject(previous);
+  const valueTarget = compilerObject(value);
+  if (!previousTarget || !valueTarget || previousTarget === valueTarget) return value;
+  const draft = COMPILER_KEYED_COLLECTION_DRAFTS.get(valueTarget);
+  if (!draft || draft.kind !== kind || draft.changedKeys.length === 0) return value;
+  const sourceToken = compilerKeyedCollectionToken(previousTarget);
+  if (!sourceToken) return value;
+  const previousUpdate = !COMPILER_KEYED_COMMITTED_COLLECTIONS.has(previousTarget) ? COMPILER_KEYED_COLLECTION_UPDATES.get(previousTarget) : void 0;
+  COMPILER_KEYED_COLLECTION_UPDATES.set(valueTarget, {
+    kind,
+    sourceToken: previousUpdate?.sourceToken || sourceToken,
+    changedKeys: [...draft.changedKeys],
+    ...previousUpdate ? { previous: previousUpdate } : {}
+  });
+  return value;
+}
 var COMPILER_HMR_REGISTRY = /* @__PURE__ */ Symbol.for("@farm.js/react/compiler-hmr-registry");
 function getCompilerHmrRegistry() {
   const globalTarget = globalThis;
@@ -412,6 +869,240 @@ var UNSET_KEYED_ROW_BINDING = /* @__PURE__ */ Symbol("unset interactive keyed-ro
 function keyedRowIdentity(key) {
   return String(key);
 }
+function keyedIdentityTargetSnapshot(value) {
+  const kind = typeof value;
+  return value === null || value === void 0 || kind === "string" || kind === "number" || kind === "bigint" ? { eligible: true, key: String(value) } : { eligible: false };
+}
+var NATIVE_SET_PROTOTYPE = Set.prototype;
+var NATIVE_SET_ADD = Set.prototype.add;
+var NATIVE_SET_DELETE = Set.prototype.delete;
+var NATIVE_SET_HAS = Set.prototype.has;
+var NATIVE_SET_VALUES = Set.prototype.values;
+var KEYED_COLLECTION_SNAPSHOT_MAX_DEPTH = 64;
+function materializeKeyedMembershipSnapshot(snapshot) {
+  if (!snapshot.eligible) return void 0;
+  if (snapshot.values) return new Set(snapshot.values);
+  if (!snapshot.previous || !snapshot.changes) return void 0;
+  const values = materializeKeyedMembershipSnapshot(snapshot.previous);
+  if (!values) return void 0;
+  for (const [key, present] of snapshot.changes) {
+    if (present) NATIVE_SET_ADD.call(values, key);
+    else NATIVE_SET_DELETE.call(values, key);
+  }
+  return values;
+}
+function keyedMembershipSnapshotHas(snapshot, key) {
+  for (let current = snapshot; current; current = current.previous) {
+    if (!current.eligible) return void 0;
+    if (current.changes?.has(key)) return current.changes.get(key);
+    if (current.values) return NATIVE_SET_HAS.call(current.values, key);
+  }
+  return void 0;
+}
+function keyedMembershipDeltaSnapshot(value, previous) {
+  if (!previous.eligible || !previous.sourceToken) return void 0;
+  const target = compilerObject(value);
+  if (!target) return void 0;
+  const changedKeys = compilerKeyedCollectionChangedKeys(value, previous.sourceToken, "set");
+  if (!changedKeys) return void 0;
+  if (Object.getPrototypeOf(value) !== NATIVE_SET_PROTOTYPE || Object.prototype.hasOwnProperty.call(value, "has") || value.has !== NATIVE_SET_HAS) {
+    return void 0;
+  }
+  const changes = /* @__PURE__ */ new Map();
+  const targetedKeys = /* @__PURE__ */ new Set();
+  try {
+    for (const key of changedKeys) {
+      if (!keyedIdentityTargetSnapshot(key).eligible) return void 0;
+      const present = NATIVE_SET_HAS.call(value, key);
+      const before = keyedMembershipSnapshotHas(previous, key);
+      if (before === void 0) return void 0;
+      changes.set(key, present);
+      if (before !== present) NATIVE_SET_ADD.call(targetedKeys, String(key));
+    }
+  } catch {
+    return void 0;
+  }
+  const depth = (previous.depth || 0) + 1;
+  if (depth > KEYED_COLLECTION_SNAPSHOT_MAX_DEPTH) return void 0;
+  return {
+    eligible: true,
+    previous,
+    changes,
+    sourceToken: commitCompilerKeyedCollection(value),
+    targetedKeys,
+    depth
+  };
+}
+function keyedMembershipTargetSnapshot(value, previous) {
+  if (previous) {
+    const delta = keyedMembershipDeltaSnapshot(value, previous);
+    if (delta) return delta;
+  }
+  if (typeof value !== "object" || value === null) return { eligible: false };
+  let iterator;
+  try {
+    iterator = NATIVE_SET_VALUES.call(value);
+  } catch {
+    return { eligible: false };
+  }
+  if (Object.getPrototypeOf(value) !== NATIVE_SET_PROTOTYPE || Object.prototype.hasOwnProperty.call(value, "has") || value.has !== NATIVE_SET_HAS) {
+    return { eligible: false };
+  }
+  const values = /* @__PURE__ */ new Set();
+  try {
+    for (const entry of iterator) {
+      if (!keyedIdentityTargetSnapshot(entry).eligible) return { eligible: false };
+      NATIVE_SET_ADD.call(values, entry);
+    }
+  } catch {
+    return { eligible: false };
+  }
+  return {
+    eligible: true,
+    values,
+    sourceToken: commitCompilerKeyedCollection(value),
+    depth: 0
+  };
+}
+function keyedMembershipChangedKeys(previousSnapshot, nextSnapshot) {
+  if (nextSnapshot.targetedKeys) return new Set(nextSnapshot.targetedKeys);
+  const previous = materializeKeyedMembershipSnapshot(previousSnapshot);
+  const next = materializeKeyedMembershipSnapshot(nextSnapshot);
+  const keys = /* @__PURE__ */ new Set();
+  if (!previous || !next) return keys;
+  for (const value of previous) {
+    if (!NATIVE_SET_HAS.call(next, value)) NATIVE_SET_ADD.call(keys, String(value));
+  }
+  for (const value of next) {
+    if (!NATIVE_SET_HAS.call(previous, value)) NATIVE_SET_ADD.call(keys, String(value));
+  }
+  return keys;
+}
+var NATIVE_MAP_PROTOTYPE = Map.prototype;
+var NATIVE_MAP_GET = Map.prototype.get;
+var NATIVE_MAP_HAS = Map.prototype.has;
+var NATIVE_MAP_SET = Map.prototype.set;
+var NATIVE_MAP_DELETE = Map.prototype.delete;
+var NATIVE_MAP_ENTRIES = Map.prototype.entries;
+function isSafeKeyedMapLookupValue(value) {
+  return value === null || value === void 0 || typeof value === "string" || typeof value === "number" || typeof value === "bigint" || typeof value === "boolean";
+}
+function materializeKeyedMapLookupSnapshot(snapshot) {
+  if (!snapshot.eligible) return void 0;
+  if (snapshot.values) return new Map(snapshot.values);
+  if (!snapshot.previous || !snapshot.changes) return void 0;
+  const values = materializeKeyedMapLookupSnapshot(snapshot.previous);
+  if (!values) return void 0;
+  for (const [key, entry] of snapshot.changes) {
+    if (entry.present) NATIVE_MAP_SET.call(values, key, entry.value);
+    else NATIVE_MAP_DELETE.call(values, key);
+  }
+  return values;
+}
+function keyedMapLookupSnapshotValue(snapshot, key) {
+  for (let current = snapshot; current; current = current.previous) {
+    if (!current.eligible) return void 0;
+    const changed = current.changes?.get(key);
+    if (changed) return changed;
+    if (current.values) {
+      const present = NATIVE_MAP_HAS.call(current.values, key);
+      return {
+        present,
+        ...present ? { value: NATIVE_MAP_GET.call(current.values, key) } : {}
+      };
+    }
+  }
+  return void 0;
+}
+function keyedMapLookupDeltaSnapshot(value, previous) {
+  if (!previous.eligible || !previous.sourceToken) return void 0;
+  const target = compilerObject(value);
+  if (!target) return void 0;
+  const changedKeys = compilerKeyedCollectionChangedKeys(value, previous.sourceToken, "map");
+  if (!changedKeys) return void 0;
+  if (Object.getPrototypeOf(value) !== NATIVE_MAP_PROTOTYPE || Object.prototype.hasOwnProperty.call(value, "get") || value.get !== NATIVE_MAP_GET) {
+    return void 0;
+  }
+  const changes = /* @__PURE__ */ new Map();
+  const targetedKeys = /* @__PURE__ */ new Set();
+  try {
+    for (const key of changedKeys) {
+      if (!keyedIdentityTargetSnapshot(key).eligible) return void 0;
+      const present = NATIVE_MAP_HAS.call(value, key);
+      const entry = present ? NATIVE_MAP_GET.call(value, key) : void 0;
+      if (present && !isSafeKeyedMapLookupValue(entry)) return void 0;
+      const before = keyedMapLookupSnapshotValue(previous, key);
+      if (!before) return void 0;
+      changes.set(key, { present, ...present ? { value: entry } : {} });
+      if (before.present !== present || !Object.is(before.value, entry)) {
+        NATIVE_SET_ADD.call(targetedKeys, String(key));
+      }
+    }
+  } catch {
+    return void 0;
+  }
+  const depth = (previous.depth || 0) + 1;
+  if (depth > KEYED_COLLECTION_SNAPSHOT_MAX_DEPTH) return void 0;
+  return {
+    eligible: true,
+    previous,
+    changes,
+    sourceToken: commitCompilerKeyedCollection(value),
+    targetedKeys,
+    depth
+  };
+}
+function keyedMapLookupTargetSnapshot(value, previous) {
+  if (previous) {
+    const delta = keyedMapLookupDeltaSnapshot(value, previous);
+    if (delta) return delta;
+  }
+  if (typeof value !== "object" || value === null) return { eligible: false };
+  let iterator;
+  try {
+    iterator = NATIVE_MAP_ENTRIES.call(value);
+  } catch {
+    return { eligible: false };
+  }
+  if (Object.getPrototypeOf(value) !== NATIVE_MAP_PROTOTYPE || Object.prototype.hasOwnProperty.call(value, "get") || value.get !== NATIVE_MAP_GET) {
+    return { eligible: false };
+  }
+  const values = /* @__PURE__ */ new Map();
+  try {
+    for (const [key, entry] of iterator) {
+      if (!keyedIdentityTargetSnapshot(key).eligible || !isSafeKeyedMapLookupValue(entry)) {
+        return { eligible: false };
+      }
+      NATIVE_MAP_SET.call(values, key, entry);
+    }
+  } catch {
+    return { eligible: false };
+  }
+  return {
+    eligible: true,
+    values,
+    sourceToken: commitCompilerKeyedCollection(value),
+    depth: 0
+  };
+}
+function keyedMapLookupChangedKeys(previousSnapshot, nextSnapshot) {
+  if (nextSnapshot.targetedKeys) return new Set(nextSnapshot.targetedKeys);
+  const previous = materializeKeyedMapLookupSnapshot(previousSnapshot);
+  const next = materializeKeyedMapLookupSnapshot(nextSnapshot);
+  const keys = /* @__PURE__ */ new Set();
+  if (!previous || !next) return keys;
+  for (const [key, value] of previous) {
+    if (!Object.is(value, NATIVE_MAP_GET.call(next, key))) {
+      NATIVE_SET_ADD.call(keys, String(key));
+    }
+  }
+  for (const [key, value] of next) {
+    if (!Object.is(value, NATIVE_MAP_GET.call(previous, key))) {
+      NATIVE_SET_ADD.call(keys, String(key));
+    }
+  }
+  return keys;
+}
 function normalizedKeyedRowBindingValue(binding, value) {
   return binding.kind === "text" ? renderTextValue(value) : value;
 }
@@ -1883,6 +2574,475 @@ function longestIncreasingSubsequencePositions(sequence) {
   }
   return positions;
 }
+var keyedUpdateRuntime = {
+  append: reconcileCompilerKeyedArrayAppend,
+  commit: commitCompilerKeyedCollection,
+  reconcile: reconcileCompilerKeyedMapUpdate
+};
+var keyedFilterUpdateRuntime = {
+  ...keyedUpdateRuntime,
+  filter: reconcileCompilerKeyedArrayFilter
+};
+var keyedPrependUpdateRuntime = {
+  ...keyedUpdateRuntime,
+  prepend: reconcileCompilerKeyedArrayPrepend
+};
+var keyedFilterPrependUpdateRuntime = {
+  ...keyedFilterUpdateRuntime,
+  prepend: reconcileCompilerKeyedArrayPrepend
+};
+var keyedPositionUpdateRuntime = {
+  ...keyedUpdateRuntime,
+  position: reconcileCompilerKeyedArrayPosition
+};
+var keyedReorderUpdateRuntime = {
+  ...keyedUpdateRuntime,
+  reorder: reconcileCompilerKeyedArrayReorder
+};
+var keyedCompleteUpdateRuntime = {
+  ...keyedFilterPrependUpdateRuntime,
+  rollingWindow: reconcileCompilerKeyedArrayRollingWindow
+};
+var keyedEveryUpdateRuntime = {
+  ...keyedCompleteUpdateRuntime,
+  position: reconcileCompilerKeyedArrayPosition,
+  reorder: reconcileCompilerKeyedArrayReorder
+};
+function reconcileCompilerKeyedMapUpdate(props, dirtyState, collectionToken, instances, conditionals) {
+  const dependency = props.collectionDependency;
+  if (dependency === void 0) return void 0;
+  const dependencies = props.dependencies || props.structureDependencies || [];
+  const relevantDirty = [...dirtyState].filter((index) => dependencies.includes(index));
+  if (relevantDirty.length !== 1 || relevantDirty[0] !== dependency) return void 0;
+  const finalValue = props.items();
+  const hintedIndices = compilerKeyedMapChangedIndices(finalValue, collectionToken);
+  if (!hintedIndices || !Array.isArray(finalValue) || finalValue.length !== instances.size) {
+    return void 0;
+  }
+  const changedIndices = [...new Set(hintedIndices)].sort((left, right) => left - right);
+  const updates = [];
+  try {
+    for (const index of changedIndices) {
+      if (!Number.isSafeInteger(index) || index < 0 || index >= finalValue.length) return void 0;
+      const item = finalValue[index];
+      const key = keyedRowIdentity(props.rowKey(item, index));
+      const instance = instances.get(key);
+      if (!instance || instance.index !== index) return void 0;
+      updates.push({ key, item, index, instance });
+    }
+  } catch {
+    return void 0;
+  }
+  const conditionalChanges = [];
+  for (const { key, item, index, instance } of updates) {
+    if (props.hostBlocks) {
+      const descriptor = props.create(item, index);
+      if (!instance.scope?.update(descriptor)) {
+        return { collectionToken, conditionalChanges: [], fallback: true };
+      }
+    }
+    applyKeyedRowBindings(props, instance, item, index);
+    const conditionalValues = conditionals?.readValues(props, item, index) || EMPTY_KEYED_ROW_CONDITIONAL_VALUES;
+    for (const [id, values] of conditionalValues) {
+      if (conditionals?.changed(instance.conditionalValues.get(id), values)) {
+        conditionalChanges.push({ key, id, item, index });
+      }
+    }
+    instance.conditionalValues = conditionalValues;
+    instance.item = item;
+  }
+  return {
+    collectionToken: commitCompilerKeyedCollection(finalValue),
+    conditionalChanges,
+    fallback: false
+  };
+}
+function reconcileCompilerKeyedArrayAppend(props, dirtyState, collectionToken, instances, root, reactOwnedRows) {
+  if (reactOwnedRows || props.hostBlocks || (props.conditionals?.length || 0) > 0 || props.collectionDependency === void 0) {
+    return void 0;
+  }
+  const collectionDependency = props.collectionDependency;
+  if (props.bindings.some((binding) => binding.dependencies?.includes(collectionDependency))) {
+    return void 0;
+  }
+  const dependencies = props.dependencies || props.structureDependencies;
+  const relevantDirty = (dependencies || []).filter((index) => dirtyState.has(index));
+  if (relevantDirty.length !== 1 || relevantDirty[0] !== collectionDependency) {
+    return void 0;
+  }
+  const finalValue = props.items();
+  const startIndex = compilerKeyedArrayAppendStart(finalValue, collectionToken, instances.size);
+  if (startIndex === void 0 || !Array.isArray(finalValue)) return void 0;
+  const nextInstances = new Map(instances);
+  const appended = [];
+  try {
+    for (let index = startIndex; index < finalValue.length; index += 1) {
+      const item = finalValue[index];
+      const key = keyedRowIdentity(props.rowKey(item, index));
+      if (nextInstances.has(key)) return void 0;
+      const descriptor = props.create(item, index);
+      const instance = {
+        key,
+        element: createCompilerHostElement(root.ownerDocument, descriptor),
+        values: readKeyedRowBindingValues(props, item, index),
+        item,
+        index,
+        conditionalValues: EMPTY_KEYED_ROW_CONDITIONAL_VALUES
+      };
+      appended.push(instance);
+      nextInstances.set(key, instance);
+    }
+  } catch {
+    return void 0;
+  }
+  if (appended.length > 0) {
+    const fragment = root.ownerDocument.createDocumentFragment();
+    for (const instance of appended) fragment.append(instance.element);
+    root.append(fragment);
+  }
+  return nextInstances;
+}
+function reconcileCompilerKeyedArrayRollingWindow(props, dirtyState, collectionToken, instances, root, reactOwnedRows) {
+  if (reactOwnedRows || props.hostBlocks || (props.conditionals?.length || 0) > 0 || !props.filterIndexIndependent || props.collectionDependency === void 0) {
+    return void 0;
+  }
+  const collectionDependency = props.collectionDependency;
+  if (props.bindings.some((binding) => binding.dependencies?.includes(collectionDependency))) {
+    return void 0;
+  }
+  const dependencies = props.dependencies || props.structureDependencies;
+  const relevantDirty = (dependencies || []).filter((index) => dirtyState.has(index));
+  if (relevantDirty.length !== 1 || relevantDirty[0] !== collectionDependency) {
+    return void 0;
+  }
+  const finalValue = props.items();
+  const update = compilerKeyedArrayRollingWindow(finalValue, collectionToken, instances.size);
+  if (!update || !Array.isArray(finalValue)) return void 0;
+  const previousInstances = [...instances.values()];
+  const retainedLength = update.retainedEnd - update.retainedStart;
+  const survivors = [];
+  try {
+    for (let index = 0; index < retainedLength; index += 1) {
+      const sourceIndex = update.retainedStart + index;
+      const instance = previousInstances[sourceIndex];
+      if (!instance || instance.index !== sourceIndex || !Object.is(instance.item, finalValue[index])) {
+        return void 0;
+      }
+      survivors.push(instance);
+    }
+  } catch {
+    return void 0;
+  }
+  const knownKeys = new Set(instances.keys());
+  const incoming = [];
+  try {
+    for (let index = retainedLength; index < finalValue.length; index += 1) {
+      const item = finalValue[index];
+      const key = keyedRowIdentity(props.rowKey(item, index));
+      if (knownKeys.has(key)) return void 0;
+      knownKeys.add(key);
+      const descriptor = props.create(item, index);
+      incoming.push({
+        key,
+        element: createCompilerHostElement(root.ownerDocument, descriptor),
+        values: readKeyedRowBindingValues(props, item, index),
+        item,
+        index,
+        conditionalValues: EMPTY_KEYED_ROW_CONDITIONAL_VALUES
+      });
+    }
+  } catch {
+    return void 0;
+  }
+  for (let index = 0; index < update.retainedStart; index += 1) {
+    previousInstances[index].scope?.cleanup();
+    previousInstances[index].element.remove();
+  }
+  for (let index = 0; index < survivors.length; index += 1) survivors[index].index = index;
+  if (incoming.length > 0) {
+    const fragment = root.ownerDocument.createDocumentFragment();
+    for (const instance of incoming) fragment.append(instance.element);
+    root.append(fragment);
+  }
+  const nextInstances = new Map(
+    [...survivors, ...incoming].map((instance) => [instance.key, instance])
+  );
+  return nextInstances;
+}
+function reconcileCompilerKeyedArrayPosition(props, dirtyState, collectionToken, instances, root, reactOwnedRows) {
+  if (reactOwnedRows || props.hostBlocks || (props.conditionals?.length || 0) > 0 || !props.positionIndexIndependent || props.collectionDependency === void 0) {
+    return void 0;
+  }
+  const collectionDependency = props.collectionDependency;
+  if (props.bindings.some((binding) => binding.dependencies?.includes(collectionDependency))) {
+    return void 0;
+  }
+  const dependencies = props.dependencies || props.structureDependencies;
+  const relevantDirty = (dependencies || []).filter((index) => dirtyState.has(index));
+  if (relevantDirty.length !== 1 || relevantDirty[0] !== collectionDependency) {
+    return void 0;
+  }
+  const finalValue = props.items();
+  const update = compilerKeyedArrayPosition(finalValue, collectionToken, instances.size);
+  if (!update || !Array.isArray(finalValue)) return void 0;
+  const previousInstances = [...instances.values()];
+  const previous = previousInstances[update.position];
+  if (update.kind === "remove") {
+    if (!previous || previous.index !== update.position) return void 0;
+    previous.scope?.cleanup();
+    previous.element.remove();
+    previousInstances.splice(update.position, 1);
+    for (let index = update.position; index < previousInstances.length; index += 1) {
+      previousInstances[index].index = index;
+    }
+    return new Map(previousInstances.map((instance) => [instance.key, instance]));
+  }
+  let item;
+  let key;
+  try {
+    item = finalValue[update.position];
+    key = keyedRowIdentity(props.rowKey(item, update.position));
+  } catch {
+    return void 0;
+  }
+  if (update.kind === "insert") {
+    if (instances.has(key)) return void 0;
+    let inserted;
+    try {
+      const descriptor = props.create(item, update.position);
+      inserted = {
+        key,
+        element: createCompilerHostElement(root.ownerDocument, descriptor),
+        values: readKeyedRowBindingValues(props, item, update.position),
+        item,
+        index: update.position,
+        conditionalValues: EMPTY_KEYED_ROW_CONDITIONAL_VALUES
+      };
+    } catch {
+      return void 0;
+    }
+    root.insertBefore(inserted.element, previous?.element || null);
+    previousInstances.splice(update.position, 0, inserted);
+    for (let index = update.position + 1; index < previousInstances.length; index += 1) {
+      previousInstances[index].index = index;
+    }
+    return new Map(previousInstances.map((instance) => [instance.key, instance]));
+  }
+  if (!previous || previous.index !== update.position) return void 0;
+  if (key === previous.key) {
+    try {
+      applyKeyedRowBindings(props, previous, item, update.position);
+    } catch {
+      return void 0;
+    }
+    previous.item = item;
+    return instances;
+  }
+  if (instances.has(key)) return void 0;
+  let replacement;
+  try {
+    const descriptor = props.create(item, update.position);
+    replacement = {
+      key,
+      element: createCompilerHostElement(root.ownerDocument, descriptor),
+      values: readKeyedRowBindingValues(props, item, update.position),
+      item,
+      index: update.position,
+      conditionalValues: EMPTY_KEYED_ROW_CONDITIONAL_VALUES
+    };
+  } catch {
+    return void 0;
+  }
+  previous.scope?.cleanup();
+  previous.element.replaceWith(replacement.element);
+  previousInstances[update.position] = replacement;
+  return new Map(previousInstances.map((instance) => [instance.key, instance]));
+}
+function reconcileCompilerKeyedArrayReorder(props, dirtyState, collectionToken, instances, root, reactOwnedRows) {
+  if (reactOwnedRows || props.hostBlocks || (props.conditionals?.length || 0) > 0 || !props.reorderIndexIndependent || props.collectionDependency === void 0) {
+    return void 0;
+  }
+  const collectionDependency = props.collectionDependency;
+  if (props.bindings.some((binding) => binding.dependencies?.includes(collectionDependency))) {
+    return void 0;
+  }
+  const dependencies = props.dependencies || props.structureDependencies;
+  const relevantDirty = (dependencies || []).filter((index) => dirtyState.has(index));
+  if (relevantDirty.length !== 1 || relevantDirty[0] !== collectionDependency) {
+    return void 0;
+  }
+  const finalValue = props.items();
+  const update = compilerKeyedArrayReorder(finalValue, collectionToken, instances.size);
+  if (!update || !Array.isArray(finalValue)) return void 0;
+  const previousInstances = [...instances.values()];
+  if (update.kind === "sort") {
+    const instancesByItem = /* @__PURE__ */ new Map();
+    try {
+      for (let sourceIndex = 0; sourceIndex < previousInstances.length; sourceIndex += 1) {
+        const instance = previousInstances[sourceIndex];
+        if (instance.index !== sourceIndex || instancesByItem.has(instance.item)) return void 0;
+        instancesByItem.set(instance.item, instance);
+      }
+      const nextInstances = [];
+      const sequence = [];
+      for (let targetIndex = 0; targetIndex < finalValue.length; targetIndex += 1) {
+        const item = finalValue[targetIndex];
+        const instance = instancesByItem.get(item);
+        if (!instance || !Object.is(instance.item, item)) return void 0;
+        instancesByItem.delete(item);
+        nextInstances.push(instance);
+        sequence.push(instance.index);
+      }
+      if (instancesByItem.size > 0) return void 0;
+      const activeElement2 = root.ownerDocument.activeElement;
+      const restoreFocus2 = Boolean(activeElement2 && root.contains(activeElement2));
+      const stablePositions = longestIncreasingSubsequencePositions(sequence);
+      let anchor2 = null;
+      for (let index = nextInstances.length - 1; index >= 0; index -= 1) {
+        const instance = nextInstances[index];
+        if (!stablePositions.has(index) && instance.element.nextSibling !== anchor2) {
+          root.insertBefore(instance.element, anchor2);
+        }
+        anchor2 = instance.element;
+        instance.index = index;
+      }
+      if (restoreFocus2 && activeElement2?.isConnected && activeElement2.ownerDocument.activeElement !== activeElement2 && "focus" in activeElement2) {
+        activeElement2.focus({ preventScroll: true });
+      }
+      return new Map(nextInstances.map((instance) => [instance.key, instance]));
+    } catch {
+      return void 0;
+    }
+  }
+  try {
+    for (let sourceIndex = 0; sourceIndex < previousInstances.length; sourceIndex += 1) {
+      const instance = previousInstances[sourceIndex];
+      const targetIndex = previousInstances.length - sourceIndex - 1;
+      if (instance.index !== sourceIndex || !Object.is(instance.item, finalValue[targetIndex])) {
+        return void 0;
+      }
+    }
+  } catch {
+    return void 0;
+  }
+  const activeElement = root.ownerDocument.activeElement;
+  const restoreFocus = Boolean(activeElement && root.contains(activeElement));
+  let anchor = previousInstances[0]?.element || null;
+  for (let sourceIndex = 1; sourceIndex < previousInstances.length; sourceIndex += 1) {
+    const element = previousInstances[sourceIndex].element;
+    root.insertBefore(element, anchor);
+    anchor = element;
+  }
+  previousInstances.reverse();
+  for (let index = 0; index < previousInstances.length; index += 1) {
+    previousInstances[index].index = index;
+  }
+  if (restoreFocus && activeElement?.isConnected && activeElement.ownerDocument.activeElement !== activeElement && "focus" in activeElement) {
+    activeElement.focus({ preventScroll: true });
+  }
+  return new Map(previousInstances.map((instance) => [instance.key, instance]));
+}
+function reconcileCompilerKeyedArrayPrepend(props, dirtyState, collectionToken, instances, root, reactOwnedRows) {
+  if (reactOwnedRows || props.hostBlocks || (props.conditionals?.length || 0) > 0 || !props.prependIndexIndependent || props.collectionDependency === void 0) {
+    return void 0;
+  }
+  const collectionDependency = props.collectionDependency;
+  if (props.bindings.some((binding) => binding.dependencies?.includes(collectionDependency))) {
+    return void 0;
+  }
+  const dependencies = props.dependencies || props.structureDependencies;
+  const relevantDirty = (dependencies || []).filter((index) => dirtyState.has(index));
+  if (relevantDirty.length !== 1 || relevantDirty[0] !== collectionDependency) {
+    return void 0;
+  }
+  const finalValue = props.items();
+  const prefixLength = compilerKeyedArrayPrependLength(finalValue, collectionToken, instances.size);
+  if (prefixLength === void 0 || !Array.isArray(finalValue)) return void 0;
+  const previousInstances = [...instances.values()];
+  for (let index = 0; index < previousInstances.length; index += 1) {
+    const instance = previousInstances[index];
+    if (instance.index !== index || !Object.is(instance.item, finalValue[prefixLength + index])) {
+      return void 0;
+    }
+  }
+  const knownKeys = new Set(instances.keys());
+  const prepended = [];
+  try {
+    for (let index = 0; index < prefixLength; index += 1) {
+      const item = finalValue[index];
+      const key = keyedRowIdentity(props.rowKey(item, index));
+      if (knownKeys.has(key)) return void 0;
+      knownKeys.add(key);
+      const descriptor = props.create(item, index);
+      prepended.push({
+        key,
+        element: createCompilerHostElement(root.ownerDocument, descriptor),
+        values: readKeyedRowBindingValues(props, item, index),
+        item,
+        index,
+        conditionalValues: EMPTY_KEYED_ROW_CONDITIONAL_VALUES
+      });
+    }
+  } catch {
+    return void 0;
+  }
+  if (prepended.length > 0) {
+    const fragment = root.ownerDocument.createDocumentFragment();
+    for (const instance of prepended) fragment.append(instance.element);
+    root.insertBefore(fragment, root.firstChild);
+  }
+  for (let index = 0; index < previousInstances.length; index += 1) {
+    previousInstances[index].index = prefixLength + index;
+  }
+  return new Map([...prepended, ...previousInstances].map((instance) => [instance.key, instance]));
+}
+function reconcileCompilerKeyedArrayFilter(props, dirtyState, collectionToken, instances, reactOwnedRows) {
+  if (reactOwnedRows || props.hostBlocks || (props.conditionals?.length || 0) > 0 || !props.filterIndexIndependent || props.collectionDependency === void 0) {
+    return void 0;
+  }
+  const collectionDependency = props.collectionDependency;
+  if (props.bindings.some((binding) => binding.dependencies?.includes(collectionDependency))) {
+    return void 0;
+  }
+  const dependencies = props.dependencies || props.structureDependencies;
+  const relevantDirty = (dependencies || []).filter((index) => dirtyState.has(index));
+  if (relevantDirty.length !== 1 || relevantDirty[0] !== collectionDependency) {
+    return void 0;
+  }
+  const finalValue = props.items();
+  const survivorResult = compilerKeyedArrayFilterSurvivors(
+    finalValue,
+    collectionToken,
+    instances.size
+  );
+  if (!survivorResult || !Array.isArray(finalValue)) return void 0;
+  const { indices: survivorIndices, keysStable } = survivorResult;
+  const previousInstances = [...instances.values()];
+  const survivors = [];
+  try {
+    for (let index = 0; index < survivorIndices.length; index += 1) {
+      const sourceIndex = survivorIndices[index];
+      const instance = previousInstances[sourceIndex];
+      const item = finalValue[index];
+      if (!instance || instance.index !== sourceIndex || !Object.is(instance.item, item) || !keysStable && keyedRowIdentity(props.rowKey(item, index)) !== instance.key) {
+        return void 0;
+      }
+      survivors.push(instance);
+    }
+  } catch {
+    return void 0;
+  }
+  const survivorSet = new Set(survivorIndices);
+  for (let index = 0; index < previousInstances.length; index += 1) {
+    if (survivorSet.has(index)) continue;
+    previousInstances[index].scope?.cleanup();
+    previousInstances[index].element.remove();
+  }
+  for (let index = 0; index < survivors.length; index += 1) {
+    survivors[index].index = index;
+  }
+  return new Map(survivors.map((instance) => [instance.key, instance]));
+}
 function createKeyedRowConditionalRuntime() {
   class FarmKeyedRowConditional extends React__default.default.Component {
     constructor() {
@@ -1953,6 +3113,9 @@ function createKeyedRowsBlockComponent(owner, options = {}) {
       this.propSyncQueued = false;
       this.currentProps = this.props;
       this.instances = /* @__PURE__ */ new Map();
+      this.identityTargets = /* @__PURE__ */ new Map();
+      this.membershipTargets = /* @__PURE__ */ new Map();
+      this.mapLookupTargets = /* @__PURE__ */ new Map();
       this.renderVersion = 0;
       this.eventHandlers = /* @__PURE__ */ new Map();
       this.conditionalListeners = /* @__PURE__ */ new Map();
@@ -2027,8 +3190,123 @@ function createKeyedRowsBlockComponent(owner, options = {}) {
         });
       };
       this.refresh = (afterCommit, dirtyState) => {
+        if (dirtyState && options.keyedUpdates && this.mounted && this.root && !this.state.fallback) {
+          const result = options.keyedUpdates.reconcile(
+            this.currentProps,
+            dirtyState,
+            this.collectionToken,
+            this.instances,
+            options.conditionals
+          );
+          if (result) {
+            if (result.fallback) this.activateFallback(afterCommit);
+            else {
+              this.collectionToken = result.collectionToken;
+              this.notifyConditionalChanges(result.conditionalChanges, afterCommit);
+            }
+            return;
+          }
+          const appendedInstances = options.keyedUpdates.append(
+            this.currentProps,
+            dirtyState,
+            this.collectionToken,
+            this.instances,
+            this.root,
+            this.hasReactOwnedRows()
+          );
+          if (appendedInstances) {
+            this.instances = new Map(appendedInstances);
+            this.rebuildElementIndex(this.instances);
+            this.commitCurrentCollection(dirtyState);
+            afterCommit?.();
+            return;
+          }
+          const positionedInstances = options.keyedUpdates.position?.(
+            this.currentProps,
+            dirtyState,
+            this.collectionToken,
+            this.instances,
+            this.root,
+            this.hasReactOwnedRows()
+          );
+          if (positionedInstances) {
+            this.instances = new Map(positionedInstances);
+            this.rebuildElementIndex(this.instances);
+            const keys = [...this.instances.keys()];
+            this.pruneEventHandlers(keys);
+            this.pruneConditionalListeners(keys);
+            this.commitCurrentCollection(dirtyState);
+            afterCommit?.();
+            return;
+          }
+          const reorderedInstances = options.keyedUpdates.reorder?.(
+            this.currentProps,
+            dirtyState,
+            this.collectionToken,
+            this.instances,
+            this.root,
+            this.hasReactOwnedRows()
+          );
+          if (reorderedInstances) {
+            this.instances = new Map(reorderedInstances);
+            this.rebuildElementIndex(this.instances);
+            this.commitCurrentCollection(dirtyState);
+            afterCommit?.();
+            return;
+          }
+          const rollingWindowInstances = options.keyedUpdates.rollingWindow?.(
+            this.currentProps,
+            dirtyState,
+            this.collectionToken,
+            this.instances,
+            this.root,
+            this.hasReactOwnedRows()
+          );
+          if (rollingWindowInstances) {
+            this.instances = new Map(rollingWindowInstances);
+            this.rebuildElementIndex(this.instances);
+            const keys = [...this.instances.keys()];
+            this.pruneEventHandlers(keys);
+            this.pruneConditionalListeners(keys);
+            this.commitCurrentCollection(dirtyState);
+            afterCommit?.();
+            return;
+          }
+          const filteredInstances = options.keyedUpdates.filter?.(
+            this.currentProps,
+            dirtyState,
+            this.collectionToken,
+            this.instances,
+            this.hasReactOwnedRows()
+          );
+          if (filteredInstances) {
+            this.instances = new Map(filteredInstances);
+            this.rebuildElementIndex(this.instances);
+            const keys = [...this.instances.keys()];
+            this.pruneEventHandlers(keys);
+            this.pruneConditionalListeners(keys);
+            this.commitCurrentCollection(dirtyState);
+            afterCommit?.();
+            return;
+          }
+          const prependedInstances = options.keyedUpdates.prepend?.(
+            this.currentProps,
+            dirtyState,
+            this.collectionToken,
+            this.instances,
+            this.root,
+            this.hasReactOwnedRows()
+          );
+          if (prependedInstances) {
+            this.instances = new Map(prependedInstances);
+            this.rebuildElementIndex(this.instances);
+            this.commitCurrentCollection(dirtyState);
+            afterCommit?.();
+            return;
+          }
+        }
         if (dirtyState && this.refreshDirtyBindings(dirtyState, afterCommit)) return;
-        this.reconcile(afterCommit);
+        this.reconcile(afterCommit, dirtyState);
       };
     }
     readRows(props) {
@@ -2126,8 +3404,66 @@ function createKeyedRowsBlockComponent(owner, options = {}) {
         if (!active.has(key)) this.conditionalListeners.delete(key);
       }
     }
+    commitCurrentCollection(dirtyState) {
+      this.collectionToken = options.keyedUpdates?.commit(this.currentProps.items());
+      this.commitKeyedTargets(dirtyState);
+    }
+    hasSafeMembershipTargets(dirtyState) {
+      for (const binding of this.currentProps.bindings) {
+        const target = binding.membershipTarget;
+        if (!target || dirtyState && !dirtyState.has(target.dependency)) continue;
+        if (!keyedMembershipTargetSnapshot(target.read()).eligible) return false;
+      }
+      return true;
+    }
+    hasSafeMapLookupTargets(dirtyState) {
+      for (const binding of this.currentProps.bindings) {
+        const target = binding.mapLookupTarget;
+        if (!target || dirtyState && !dirtyState.has(target.dependency)) continue;
+        if (!keyedMapLookupTargetSnapshot(target.read()).eligible) return false;
+      }
+      return true;
+    }
+    commitKeyedTargets(dirtyState) {
+      if (!dirtyState) {
+        this.identityTargets.clear();
+        this.membershipTargets.clear();
+        this.mapLookupTargets.clear();
+      }
+      for (let bindingIndex = 0; bindingIndex < this.currentProps.bindings.length; bindingIndex += 1) {
+        const binding = this.currentProps.bindings[bindingIndex];
+        const identityTarget = binding.identityTarget;
+        if (!identityTarget) {
+          this.identityTargets.delete(bindingIndex);
+        } else if (!dirtyState || dirtyState.has(identityTarget.dependency)) {
+          this.identityTargets.set(
+            bindingIndex,
+            keyedIdentityTargetSnapshot(identityTarget.read())
+          );
+        }
+        const membershipTarget = binding.membershipTarget;
+        if (!membershipTarget) {
+          this.membershipTargets.delete(bindingIndex);
+        } else if (!dirtyState || dirtyState.has(membershipTarget.dependency)) {
+          this.membershipTargets.set(
+            bindingIndex,
+            keyedMembershipTargetSnapshot(membershipTarget.read())
+          );
+        }
+        const mapLookupTarget = binding.mapLookupTarget;
+        if (!mapLookupTarget) {
+          this.mapLookupTargets.delete(bindingIndex);
+        } else if (!dirtyState || dirtyState.has(mapLookupTarget.dependency)) {
+          this.mapLookupTargets.set(
+            bindingIndex,
+            keyedMapLookupTargetSnapshot(mapLookupTarget.read())
+          );
+        }
+      }
+    }
     adopt() {
       if (!this.root) return false;
+      if (!this.hasSafeMembershipTargets() || !this.hasSafeMapLookupTargets()) return false;
       const rows = this.readRows(this.currentProps);
       const elements = [...this.root.children];
       if (!rows || rows.items.length !== elements.length) return false;
@@ -2169,6 +3505,7 @@ function createKeyedRowsBlockComponent(owner, options = {}) {
       this.rebuildElementIndex(instances);
       this.pruneEventHandlers(rows.keys);
       this.pruneConditionalListeners(rows.keys);
+      this.commitCurrentCollection();
       return true;
     }
     hasUnsafeFallbackKeys() {
@@ -2231,21 +3568,132 @@ function createKeyedRowsBlockComponent(owner, options = {}) {
           affectedBindingIndices.push(bindingIndex);
         }
       }
-      for (const instance of this.instances.values()) {
-        for (const bindingIndex of affectedBindingIndices) {
-          applyKeyedRowBinding(
-            this.currentProps,
-            instance,
-            instance.item,
-            instance.index,
-            bindingIndex
+      const nextIdentityTargets = /* @__PURE__ */ new Map();
+      const nextMembershipTargets = /* @__PURE__ */ new Map();
+      const nextMapLookupTargets = /* @__PURE__ */ new Map();
+      for (const bindingIndex of affectedBindingIndices) {
+        const binding = this.currentProps.bindings[bindingIndex];
+        if (binding.identityTarget) {
+          nextIdentityTargets.set(
+            bindingIndex,
+            keyedIdentityTargetSnapshot(binding.identityTarget.read())
+          );
+        }
+        if (binding.membershipTarget) {
+          const snapshot = keyedMembershipTargetSnapshot(
+            binding.membershipTarget.read(),
+            this.membershipTargets.get(bindingIndex)
+          );
+          if (!snapshot.eligible) {
+            this.activateFallback(afterCommit);
+            return true;
+          }
+          nextMembershipTargets.set(bindingIndex, snapshot);
+        }
+        if (binding.mapLookupTarget) {
+          const snapshot = keyedMapLookupTargetSnapshot(
+            binding.mapLookupTarget.read(),
+            this.mapLookupTargets.get(bindingIndex)
           );
+          if (!snapshot.eligible) {
+            this.activateFallback(afterCommit);
+            return true;
+          }
+          nextMapLookupTargets.set(bindingIndex, snapshot);
+        }
+      }
+      for (const bindingIndex of affectedBindingIndices) {
+        const binding = this.currentProps.bindings[bindingIndex];
+        const identityTarget = binding.identityTarget;
+        const previousIdentityTarget = this.identityTargets.get(bindingIndex);
+        const nextIdentityTarget = nextIdentityTargets.get(bindingIndex);
+        const canTargetIdentity = Boolean(
+          identityTarget && binding.dependencies?.length === 1 && binding.dependencies[0] === identityTarget.dependency && dirtyState.has(identityTarget.dependency) && previousIdentityTarget?.eligible && nextIdentityTarget?.eligible
+        );
+        const membershipTarget = binding.membershipTarget;
+        const previousMembershipTarget = this.membershipTargets.get(bindingIndex);
+        const nextMembershipTarget = nextMembershipTargets.get(bindingIndex);
+        const canTargetMembership = Boolean(
+          membershipTarget && binding.dependencies?.length === 1 && binding.dependencies[0] === membershipTarget.dependency && dirtyState.has(membershipTarget.dependency) && previousMembershipTarget?.eligible && nextMembershipTarget?.eligible
+        );
+        const mapLookupTarget = binding.mapLookupTarget;
+        const previousMapLookupTarget = this.mapLookupTargets.get(bindingIndex);
+        const nextMapLookupTarget = nextMapLookupTargets.get(bindingIndex);
+        const canTargetMapLookup = Boolean(
+          mapLookupTarget && binding.dependencies?.length === 1 && binding.dependencies[0] === mapLookupTarget.dependency && dirtyState.has(mapLookupTarget.dependency) && previousMapLookupTarget?.eligible && nextMapLookupTarget?.eligible
+        );
+        if (canTargetMapLookup && previousMapLookupTarget && nextMapLookupTarget) {
+          const keys = keyedMapLookupChangedKeys(previousMapLookupTarget, nextMapLookupTarget);
+          for (const key of keys) {
+            const instance = this.instances.get(key);
+            if (instance) {
+              applyKeyedRowBinding(
+                this.currentProps,
+                instance,
+                instance.item,
+                instance.index,
+                bindingIndex
+              );
+            }
+          }
+        } else if (canTargetMembership && previousMembershipTarget && nextMembershipTarget) {
+          const keys = keyedMembershipChangedKeys(previousMembershipTarget, nextMembershipTarget);
+          for (const key of keys) {
+            const instance = this.instances.get(key);
+            if (instance) {
+              applyKeyedRowBinding(
+                this.currentProps,
+                instance,
+                instance.item,
+                instance.index,
+                bindingIndex
+              );
+            }
+          }
+        } else if (canTargetIdentity && previousIdentityTarget && nextIdentityTarget) {
+          const keys = /* @__PURE__ */ new Set();
+          if (previousIdentityTarget.key !== void 0) keys.add(previousIdentityTarget.key);
+          if (nextIdentityTarget.key !== void 0) keys.add(nextIdentityTarget.key);
+          for (const key of keys) {
+            const instance = this.instances.get(key);
+            if (instance) {
+              applyKeyedRowBinding(
+                this.currentProps,
+                instance,
+                instance.item,
+                instance.index,
+                bindingIndex
+              );
+            }
+          }
+        } else {
+          for (const instance of this.instances.values()) {
+            applyKeyedRowBinding(
+              this.currentProps,
+              instance,
+              instance.item,
+              instance.index,
+              bindingIndex
+            );
+          }
+        }
+        if (nextIdentityTarget) this.identityTargets.set(bindingIndex, nextIdentityTarget);
+        else this.identityTargets.delete(bindingIndex);
+        if (nextMembershipTarget) {
+          this.membershipTargets.set(bindingIndex, nextMembershipTarget);
+        } else {
+          this.membershipTargets.delete(bindingIndex);
+        }
+        if (nextMapLookupTarget) {
+          this.mapLookupTargets.set(bindingIndex, nextMapLookupTarget);
+        } else {
+          this.mapLookupTargets.delete(bindingIndex);
         }
       }
       afterCommit?.();
       return true;
     }
-    reconcileStableRows(rows, afterCommit) {
+    reconcileStableRows(rows, afterCommit, dirtyState) {
       if (rows.keys.length !== this.instances.size) return false;
       let index = 0;
       for (const key of this.instances.keys()) {
@@ -2272,17 +3720,23 @@ function createKeyedRowsBlockComponent(owner, options = {}) {
         );
         for (const [id, values] of conditionalValues) {
           if (options.conditionals?.changed(existing.conditionalValues.get(id), values)) {
-            conditionalChanges.push({ key, id, item: rows.items[index], index });
+            conditionalChanges.push({
+              key,
+              id,
+              item: rows.items[index],
+              index
+            });
           }
         }
         existing.conditionalValues = conditionalValues;
         existing.item = rows.items[index];
         existing.index = index;
       }
+      this.commitCurrentCollection(dirtyState);
       this.notifyConditionalChanges(conditionalChanges, afterCommit);
       return true;
     }
-    reconcileSingleRemoval(rows, afterCommit) {
+    reconcileSingleRemoval(rows, afterCommit, dirtyState) {
       if (this.hasReactOwnedRows() || rows.keys.length + 1 !== this.instances.size) return false;
       const previousKeys = [...this.instances.keys()];
       let removedIndex = 0;
@@ -2315,7 +3769,12 @@ function createKeyedRowsBlockComponent(owner, options = {}) {
         );
         for (const [id, values] of conditionalValues) {
           if (options.conditionals?.changed(existing.conditionalValues.get(id), values)) {
-            conditionalChanges.push({ key, id, item: rows.items[index], index });
+            conditionalChanges.push({
+              key,
+              id,
+              item: rows.items[index],
+              index
+            });
           }
         }
         existing.conditionalValues = conditionalValues;
@@ -2327,10 +3786,11 @@ function createKeyedRowsBlockComponent(owner, options = {}) {
       this.instances.delete(removedKey);
       this.eventHandlers.delete(removedKey);
       this.conditionalListeners.delete(removedKey);
+      this.commitCurrentCollection(dirtyState);
       this.notifyConditionalChanges(conditionalChanges, afterCommit);
       return true;
     }
-    reconcile(afterCommit) {
+    reconcile(afterCommit, dirtyState) {
       if (!this.mounted || !this.root) {
         afterCommit?.();
         return;
@@ -2344,6 +3804,14 @@ function createKeyedRowsBlockComponent(owner, options = {}) {
         this.forceUpdate(afterCommit);
         return;
       }
+      if (!this.hasSafeMembershipTargets(dirtyState)) {
+        this.activateFallback(afterCommit);
+        return;
+      }
+      if (!this.hasSafeMapLookupTargets(dirtyState)) {
+        this.activateFallback(afterCommit);
+        return;
+      }
       const rows = this.readRows(this.currentProps);
       if (!rows) {
         this.activateFallback(afterCommit);
@@ -2363,11 +3831,12 @@ function createKeyedRowsBlockComponent(owner, options = {}) {
         this.instancesByElement = /* @__PURE__ */ new WeakMap();
         this.eventHandlers.clear();
         this.conditionalListeners.clear();
+        this.commitCurrentCollection(dirtyState);
         afterCommit?.();
         return;
       }
-      if (this.reconcileStableRows(rows, afterCommit)) return;
-      if (this.reconcileSingleRemoval(rows, afterCommit)) return;
+      if (this.reconcileStableRows(rows, afterCommit, dirtyState)) return;
+      if (this.reconcileSingleRemoval(rows, afterCommit, dirtyState)) return;
       const activeElement = this.root.ownerDocument.activeElement;
       const restoreFocus = Boolean(activeElement && this.root.contains(activeElement));
       const nextKeys = new Set(rows.keys);
@@ -2405,7 +3874,12 @@ function createKeyedRowsBlockComponent(owner, options = {}) {
           );
           for (const [id, values] of conditionalValues) {
             if (options.conditionals?.changed(existing.conditionalValues.get(id), values)) {
-              conditionalChanges.push({ key, id, item: rows.items[index], index });
+              conditionalChanges.push({
+                key,
+                id,
+                item: rows.items[index],
+                index
+              });
             }
           }
           existing.conditionalValues = conditionalValues;
@@ -2471,6 +3945,7 @@ function createKeyedRowsBlockComponent(owner, options = {}) {
       if (restoreFocus && activeElement?.isConnected && activeElement.ownerDocument.activeElement !== activeElement && "focus" in activeElement) {
         activeElement.focus({ preventScroll: true });
       }
+      this.commitCurrentCollection(dirtyState);
       this.notifyConditionalChanges(conditionalChanges, afterCommit);
     }
     schedulePropSync() {
@@ -2510,6 +3985,9 @@ function createKeyedRowsBlockComponent(owner, options = {}) {
       this.root = null;
       this.cleanupHostScopes();
       this.instances.clear();
+      this.identityTargets.clear();
+      this.membershipTargets.clear();
+      this.mapLookupTargets.clear();
       this.instancesByElement = /* @__PURE__ */ new WeakMap();
       this.eventHandlers.clear();
       this.conditionalListeners.clear();
@@ -2940,6 +4418,70 @@ var keyedRowsRuntimeFeature = {
     KeyedRows: createKeyedRowsBlockComponent(owner)
   })
 };
+var keyedRowsHintedRuntimeFeature = {
+  name: "keyed-rows:hinted",
+  create: (owner) => ({
+    KeyedRows: createKeyedRowsBlockComponent(owner, {
+      keyedUpdates: keyedUpdateRuntime
+    })
+  })
+};
+var keyedRowsPositionHintedRuntimeFeature = {
+  name: "keyed-rows:position-hinted",
+  create: (owner) => ({
+    KeyedRows: createKeyedRowsBlockComponent(owner, {
+      keyedUpdates: keyedPositionUpdateRuntime
+    })
+  })
+};
+var keyedRowsReorderHintedRuntimeFeature = {
+  name: "keyed-rows:reorder-hinted",
+  create: (owner) => ({
+    KeyedRows: createKeyedRowsBlockComponent(owner, {
+      keyedUpdates: keyedReorderUpdateRuntime
+    })
+  })
+};
+var keyedRowsAllHintedRuntimeFeature = {
+  name: "keyed-rows:all-hinted",
+  create: (owner) => ({
+    KeyedRows: createKeyedRowsBlockComponent(owner, {
+      keyedUpdates: keyedCompleteUpdateRuntime
+    })
+  })
+};
+var keyedRowsEveryHintedRuntimeFeature = {
+  name: "keyed-rows:every-hinted",
+  create: (owner) => ({
+    KeyedRows: createKeyedRowsBlockComponent(owner, {
+      keyedUpdates: keyedEveryUpdateRuntime
+    })
+  })
+};
+var keyedRowsFilterHintedRuntimeFeature = {
+  name: "keyed-rows:filter-hinted",
+  create: (owner) => ({
+    KeyedRows: createKeyedRowsBlockComponent(owner, {
+      keyedUpdates: keyedFilterUpdateRuntime
+    })
+  })
+};
+var keyedRowsPrependHintedRuntimeFeature = {
+  name: "keyed-rows:prepend-hinted",
+  create: (owner) => ({
+    KeyedRows: createKeyedRowsBlockComponent(owner, {
+      keyedUpdates: keyedPrependUpdateRuntime
+    })
+  })
+};
+var keyedRowsFilterPrependHintedRuntimeFeature = {
+  name: "keyed-rows:filter-prepend-hinted",
+  create: (owner) => ({
+    KeyedRows: createKeyedRowsBlockComponent(owner, {
+      keyedUpdates: keyedFilterPrependUpdateRuntime
+    })
+  })
+};
 var keyedRowsConditionalRuntimeFeature = {
   name: "keyed-rows:conditional",
   create: (owner) => ({
@@ -2948,6 +4490,78 @@ var keyedRowsConditionalRuntimeFeature = {
     })
   })
 };
+var keyedRowsConditionalHintedRuntimeFeature = {
+  name: "keyed-rows:conditional:hinted",
+  create: (owner) => ({
+    KeyedRows: createKeyedRowsBlockComponent(owner, {
+      conditionals: createKeyedRowConditionalRuntime(),
+      keyedUpdates: keyedUpdateRuntime
+    })
+  })
+};
+var keyedRowsConditionalPositionHintedRuntimeFeature = {
+  name: "keyed-rows:conditional:position-hinted",
+  create: (owner) => ({
+    KeyedRows: createKeyedRowsBlockComponent(owner, {
+      conditionals: createKeyedRowConditionalRuntime(),
+      keyedUpdates: keyedPositionUpdateRuntime
+    })
+  })
+};
+var keyedRowsConditionalReorderHintedRuntimeFeature = {
+  name: "keyed-rows:conditional:reorder-hinted",
+  create: (owner) => ({
+    KeyedRows: createKeyedRowsBlockComponent(owner, {
+      conditionals: createKeyedRowConditionalRuntime(),
+      keyedUpdates: keyedReorderUpdateRuntime
+    })
+  })
+};
+var keyedRowsConditionalAllHintedRuntimeFeature = {
+  name: "keyed-rows:conditional:all-hinted",
+  create: (owner) => ({
+    KeyedRows: createKeyedRowsBlockComponent(owner, {
+      conditionals: createKeyedRowConditionalRuntime(),
+      keyedUpdates: keyedCompleteUpdateRuntime
+    })
+  })
+};
+var keyedRowsConditionalEveryHintedRuntimeFeature = {
+  name: "keyed-rows:conditional:every-hinted",
+  create: (owner) => ({
+    KeyedRows: createKeyedRowsBlockComponent(owner, {
+      conditionals: createKeyedRowConditionalRuntime(),
+      keyedUpdates: keyedEveryUpdateRuntime
+    })
+  })
+};
+var keyedRowsConditionalFilterHintedRuntimeFeature = {
+  name: "keyed-rows:conditional:filter-hinted",
+  create: (owner) => ({
+    KeyedRows: createKeyedRowsBlockComponent(owner, {
+      conditionals: createKeyedRowConditionalRuntime(),
+      keyedUpdates: keyedFilterUpdateRuntime
+    })
+  })
+};
+var keyedRowsConditionalPrependHintedRuntimeFeature = {
+  name: "keyed-rows:conditional:prepend-hinted",
+  create: (owner) => ({
+    KeyedRows: createKeyedRowsBlockComponent(owner, {
+      conditionals: createKeyedRowConditionalRuntime(),
+      keyedUpdates: keyedPrependUpdateRuntime
+    })
+  })
+};
+var keyedRowsConditionalFilterPrependHintedRuntimeFeature = {
+  name: "keyed-rows:conditional:filter-prepend-hinted",
+  create: (owner) => ({
+    KeyedRows: createKeyedRowsBlockComponent(owner, {
+      conditionals: createKeyedRowConditionalRuntime(),
+      keyedUpdates: keyedFilterPrependUpdateRuntime
+    })
+  })
+};
 var keyedRowsHostRuntimeFeature = {
   name: "keyed-rows:host",
   create: (owner) => ({
@@ -2956,6 +4570,78 @@ var keyedRowsHostRuntimeFeature = {
     })
   })
 };
+var keyedRowsHostHintedRuntimeFeature = {
+  name: "keyed-rows:host:hinted",
+  create: (owner) => ({
+    KeyedRows: createKeyedRowsBlockComponent(owner, {
+      hostBlocks: createKeyedRowHostRuntime(),
+      keyedUpdates: keyedUpdateRuntime
+    })
+  })
+};
+var keyedRowsHostPositionHintedRuntimeFeature = {
+  name: "keyed-rows:host:position-hinted",
+  create: (owner) => ({
+    KeyedRows: createKeyedRowsBlockComponent(owner, {
+      hostBlocks: createKeyedRowHostRuntime(),
+      keyedUpdates: keyedPositionUpdateRuntime
+    })
+  })
+};
+var keyedRowsHostReorderHintedRuntimeFeature = {
+  name: "keyed-rows:host:reorder-hinted",
+  create: (owner) => ({
+    KeyedRows: createKeyedRowsBlockComponent(owner, {
+      hostBlocks: createKeyedRowHostRuntime(),
+      keyedUpdates: keyedReorderUpdateRuntime
+    })
+  })
+};
+var keyedRowsHostAllHintedRuntimeFeature = {
+  name: "keyed-rows:host:all-hinted",
+  create: (owner) => ({
+    KeyedRows: createKeyedRowsBlockComponent(owner, {
+      hostBlocks: createKeyedRowHostRuntime(),
+      keyedUpdates: keyedCompleteUpdateRuntime
+    })
+  })
+};
+var keyedRowsHostEveryHintedRuntimeFeature = {
+  name: "keyed-rows:host:every-hinted",
+  create: (owner) => ({
+    KeyedRows: createKeyedRowsBlockComponent(owner, {
+      hostBlocks: createKeyedRowHostRuntime(),
+      keyedUpdates: keyedEveryUpdateRuntime
+    })
+  })
+};
+var keyedRowsHostFilterHintedRuntimeFeature = {
+  name: "keyed-rows:host:filter-hinted",
+  create: (owner) => ({
+    KeyedRows: createKeyedRowsBlockComponent(owner, {
+      hostBlocks: createKeyedRowHostRuntime(),
+      keyedUpdates: keyedFilterUpdateRuntime
+    })
+  })
+};
+var keyedRowsHostPrependHintedRuntimeFeature = {
+  name: "keyed-rows:host:prepend-hinted",
+  create: (owner) => ({
+    KeyedRows: createKeyedRowsBlockComponent(owner, {
+      hostBlocks: createKeyedRowHostRuntime(),
+      keyedUpdates: keyedPrependUpdateRuntime
+    })
+  })
+};
+var keyedRowsHostFilterPrependHintedRuntimeFeature = {
+  name: "keyed-rows:host:filter-prepend-hinted",
+  create: (owner) => ({
+    KeyedRows: createKeyedRowsBlockComponent(owner, {
+      hostBlocks: createKeyedRowHostRuntime(),
+      keyedUpdates: keyedFilterPrependUpdateRuntime
+    })
+  })
+};
 var keyedRowsCompleteRuntimeFeature = {
   name: "keyed-rows:complete",
   create: (owner) => ({
@@ -2965,6 +4651,86 @@ var keyedRowsCompleteRuntimeFeature = {
     })
   })
 };
+var keyedRowsCompleteHintedRuntimeFeature = {
+  name: "keyed-rows:complete:hinted",
+  create: (owner) => ({
+    KeyedRows: createKeyedRowsBlockComponent(owner, {
+      conditionals: createKeyedRowConditionalRuntime(),
+      hostBlocks: createKeyedRowHostRuntime(),
+      keyedUpdates: keyedUpdateRuntime
+    })
+  })
+};
+var keyedRowsCompletePositionHintedRuntimeFeature = {
+  name: "keyed-rows:complete:position-hinted",
+  create: (owner) => ({
+    KeyedRows: createKeyedRowsBlockComponent(owner, {
+      conditionals: createKeyedRowConditionalRuntime(),
+      hostBlocks: createKeyedRowHostRuntime(),
+      keyedUpdates: keyedPositionUpdateRuntime
+    })
+  })
+};
+var keyedRowsCompleteReorderHintedRuntimeFeature = {
+  name: "keyed-rows:complete:reorder-hinted",
+  create: (owner) => ({
+    KeyedRows: createKeyedRowsBlockComponent(owner, {
+      conditionals: createKeyedRowConditionalRuntime(),
+      hostBlocks: createKeyedRowHostRuntime(),
+      keyedUpdates: keyedReorderUpdateRuntime
+    })
+  })
+};
+var keyedRowsCompleteAllHintedRuntimeFeature = {
+  name: "keyed-rows:complete:all-hinted",
+  create: (owner) => ({
+    KeyedRows: createKeyedRowsBlockComponent(owner, {
+      conditionals: createKeyedRowConditionalRuntime(),
+      hostBlocks: createKeyedRowHostRuntime(),
+      keyedUpdates: keyedCompleteUpdateRuntime
+    })
+  })
+};
+var keyedRowsCompleteEveryHintedRuntimeFeature = {
+  name: "keyed-rows:complete:every-hinted",
+  create: (owner) => ({
+    KeyedRows: createKeyedRowsBlockComponent(owner, {
+      conditionals: createKeyedRowConditionalRuntime(),
+      hostBlocks: createKeyedRowHostRuntime(),
+      keyedUpdates: keyedEveryUpdateRuntime
+    })
+  })
+};
+var keyedRowsCompleteFilterHintedRuntimeFeature = {
+  name: "keyed-rows:complete:filter-hinted",
+  create: (owner) => ({
+    KeyedRows: createKeyedRowsBlockComponent(owner, {
+      conditionals: createKeyedRowConditionalRuntime(),
+      hostBlocks: createKeyedRowHostRuntime(),
+      keyedUpdates: keyedFilterUpdateRuntime
+    })
+  })
+};
+var keyedRowsCompletePrependHintedRuntimeFeature = {
+  name: "keyed-rows:complete:prepend-hinted",
+  create: (owner) => ({
+    KeyedRows: createKeyedRowsBlockComponent(owner, {
+      conditionals: createKeyedRowConditionalRuntime(),
+      hostBlocks: createKeyedRowHostRuntime(),
+      keyedUpdates: keyedPrependUpdateRuntime
+    })
+  })
+};
+var keyedRowsCompleteFilterPrependHintedRuntimeFeature = {
+  name: "keyed-rows:complete:filter-prepend-hinted",
+  create: (owner) => ({
+    KeyedRows: createKeyedRowsBlockComponent(owner, {
+      conditionals: createKeyedRowConditionalRuntime(),
+      hostBlocks: createKeyedRowHostRuntime(),
+      keyedUpdates: keyedFilterPrependUpdateRuntime
+    })
+  })
+};
 var keyedRangesRuntimeFeature = {
   name: "keyed-ranges",
   create: (owner) => ({
@@ -2996,7 +4762,9 @@ function createCompiledComponentWithFeatures(definition, runtimeFeatures) {
       return existing.component;
     }
   }
-  const definitionReference = { current: definition };
+  const definitionReference = {
+    current: definition
+  };
   const refreshListeners = /* @__PURE__ */ new Set();
   class FarmCompiledComponent extends React__default.default.Component {
     constructor(props) {
@@ -3435,7 +5203,7 @@ var COMPLETE_RUNTIME_FEATURES = [
   hostConditionalRuntimeFeature,
   conditionalRangesRuntimeFeature,
   keyedListRuntimeFeature,
-  keyedRowsCompleteRuntimeFeature,
+  keyedRowsCompleteEveryHintedRuntimeFeature,
   keyedRangesRuntimeFeature,
   mixedRangesRuntimeFeature,
   componentRuntimeFeature
@@ -3444,17 +5212,60 @@ function createCompiledComponent(definition) {
   return createCompiledComponentWithFeatures(definition, COMPLETE_RUNTIME_FEATURES);
 }
 
+exports.applyCompilerKeyedCollectionMutation = applyCompilerKeyedCollectionMutation;
 exports.componentRuntimeFeature = componentRuntimeFeature;
 exports.conditionalRangesRuntimeFeature = conditionalRangesRuntimeFeature;
 exports.conditionalRuntimeFeature = conditionalRuntimeFeature;
 exports.createCompiledComponent = createCompiledComponent;
 exports.createCompiledComponentWithFeatures = createCompiledComponentWithFeatures;
+exports.createCompilerKeyedArrayAppend = createCompilerKeyedArrayAppend;
+exports.createCompilerKeyedArrayFilter = createCompilerKeyedArrayFilter;
+exports.createCompilerKeyedArrayPositionUpdate = createCompilerKeyedArrayPositionUpdate;
+exports.createCompilerKeyedArrayPrepend = createCompilerKeyedArrayPrepend;
+exports.createCompilerKeyedArrayReorder = createCompilerKeyedArrayReorder;
+exports.createCompilerKeyedArrayRollingWindow = createCompilerKeyedArrayRollingWindow;
+exports.createCompilerKeyedArraySlice = createCompilerKeyedArraySlice;
+exports.createCompilerKeyedArraySort = createCompilerKeyedArraySort;
+exports.createCompilerKeyedCollectionUpdate = createCompilerKeyedCollectionUpdate;
+exports.createCompilerKeyedMapUpdate = createCompilerKeyedMapUpdate;
 exports.hostConditionalRuntimeFeature = hostConditionalRuntimeFeature;
 exports.keyedListRuntimeFeature = keyedListRuntimeFeature;
 exports.keyedRangesRuntimeFeature = keyedRangesRuntimeFeature;
+exports.keyedRowsAllHintedRuntimeFeature = keyedRowsAllHintedRuntimeFeature;
+exports.keyedRowsCompleteAllHintedRuntimeFeature = keyedRowsCompleteAllHintedRuntimeFeature;
+exports.keyedRowsCompleteEveryHintedRuntimeFeature = keyedRowsCompleteEveryHintedRuntimeFeature;
+exports.keyedRowsCompleteFilterHintedRuntimeFeature = keyedRowsCompleteFilterHintedRuntimeFeature;
+exports.keyedRowsCompleteFilterPrependHintedRuntimeFeature = keyedRowsCompleteFilterPrependHintedRuntimeFeature;
+exports.keyedRowsCompleteHintedRuntimeFeature = keyedRowsCompleteHintedRuntimeFeature;
+exports.keyedRowsCompletePositionHintedRuntimeFeature = keyedRowsCompletePositionHintedRuntimeFeature;
+exports.keyedRowsCompletePrependHintedRuntimeFeature = keyedRowsCompletePrependHintedRuntimeFeature;
+exports.keyedRowsCompleteReorderHintedRuntimeFeature = keyedRowsCompleteReorderHintedRuntimeFeature;
 exports.keyedRowsCompleteRuntimeFeature = keyedRowsCompleteRuntimeFeature;
+exports.keyedRowsConditionalAllHintedRuntimeFeature = keyedRowsConditionalAllHintedRuntimeFeature;
+exports.keyedRowsConditionalEveryHintedRuntimeFeature = keyedRowsConditionalEveryHintedRuntimeFeature;
+exports.keyedRowsConditionalFilterHintedRuntimeFeature = keyedRowsConditionalFilterHintedRuntimeFeature;
+exports.keyedRowsConditionalFilterPrependHintedRuntimeFeature = keyedRowsConditionalFilterPrependHintedRuntimeFeature;
+exports.keyedRowsConditionalHintedRuntimeFeature = keyedRowsConditionalHintedRuntimeFeature;
+exports.keyedRowsConditionalPositionHintedRuntimeFeature = keyedRowsConditionalPositionHintedRuntimeFeature;
+exports.keyedRowsConditionalPrependHintedRuntimeFeature = keyedRowsConditionalPrependHintedRuntimeFeature;
+exports.keyedRowsConditionalReorderHintedRuntimeFeature = keyedRowsConditionalReorderHintedRuntimeFeature;
 exports.keyedRowsConditionalRuntimeFeature = keyedRowsConditionalRuntimeFeature;
+exports.keyedRowsEveryHintedRuntimeFeature = keyedRowsEveryHintedRuntimeFeature;
+exports.keyedRowsFilterHintedRuntimeFeature = keyedRowsFilterHintedRuntimeFeature;
+exports.keyedRowsFilterPrependHintedRuntimeFeature = keyedRowsFilterPrependHintedRuntimeFeature;
+exports.keyedRowsHintedRuntimeFeature = keyedRowsHintedRuntimeFeature;
+exports.keyedRowsHostAllHintedRuntimeFeature = keyedRowsHostAllHintedRuntimeFeature;
+exports.keyedRowsHostEveryHintedRuntimeFeature = keyedRowsHostEveryHintedRuntimeFeature;
+exports.keyedRowsHostFilterHintedRuntimeFeature = keyedRowsHostFilterHintedRuntimeFeature;
+exports.keyedRowsHostFilterPrependHintedRuntimeFeature = keyedRowsHostFilterPrependHintedRuntimeFeature;
+exports.keyedRowsHostHintedRuntimeFeature = keyedRowsHostHintedRuntimeFeature;
+exports.keyedRowsHostPositionHintedRuntimeFeature = keyedRowsHostPositionHintedRuntimeFeature;
+exports.keyedRowsHostPrependHintedRuntimeFeature = keyedRowsHostPrependHintedRuntimeFeature;
+exports.keyedRowsHostReorderHintedRuntimeFeature = keyedRowsHostReorderHintedRuntimeFeature;
 exports.keyedRowsHostRuntimeFeature = keyedRowsHostRuntimeFeature;
+exports.keyedRowsPositionHintedRuntimeFeature = keyedRowsPositionHintedRuntimeFeature;
+exports.keyedRowsPrependHintedRuntimeFeature = keyedRowsPrependHintedRuntimeFeature;
+exports.keyedRowsReorderHintedRuntimeFeature = keyedRowsReorderHintedRuntimeFeature;
 exports.keyedRowsRuntimeFeature = keyedRowsRuntimeFeature;
 exports.mixedRangesRuntimeFeature = mixedRangesRuntimeFeature;
 //# sourceMappingURL=compiler-runtime.cjs.map