@farm.js/react 0.1.0-beta.18 → 0.1.0-beta.19

package/dist/compiler-runtime.cjs

@@ -2254,6 +2254,249 @@ function keyedMapLookupChangedKeys(previousSnapshot, nextSnapshot) {
   }
   return keys;
 }
+function createSingleKindKeyedTargetRuntime(props, kind, snapshot, changedKeys) {
+  if (!props.bindings.some(
+    (binding) => binding.identityTarget || binding.membershipTarget || binding.mapLookupTarget
+  ))
+    return void 0;
+  const previous = /* @__PURE__ */ new Map();
+  let next = /* @__PURE__ */ new Map();
+  const compatible = (binding) => (kind === "identityTarget" || !binding.identityTarget) && (kind === "membershipTarget" || !binding.membershipTarget) && (kind === "mapLookupTarget" || !binding.mapLookupTarget);
+  return {
+    hasSafeTargets(props2, dirtyState) {
+      for (const binding of props2.bindings) {
+        if (!compatible(binding)) return false;
+        const target = binding[kind];
+        if (kind !== "identityTarget" && target && (!dirtyState || dirtyState.has(target.dependency)) && !snapshot(target.read()).eligible)
+          return false;
+      }
+      return true;
+    },
+    commit(props2, dirtyState) {
+      if (!dirtyState) previous.clear();
+      for (let index = 0; index < props2.bindings.length; index++) {
+        const target = props2.bindings[index][kind];
+        if (!target) previous.delete(index);
+        else if (!dirtyState || dirtyState.has(target.dependency))
+          previous.set(index, snapshot(target.read()));
+      }
+    },
+    prepare(props2, indices) {
+      next = /* @__PURE__ */ new Map();
+      for (const index of indices) {
+        const binding = props2.bindings[index];
+        if (!compatible(binding)) return false;
+        const target = binding[kind];
+        if (!target) continue;
+        const value = snapshot(target.read(), previous.get(index));
+        if (kind !== "identityTarget" && !value.eligible) return false;
+        next.set(index, value);
+      }
+      return true;
+    },
+    select(props2, index, dirtyState, fallbackKeys, fallbackCount) {
+      const binding = props2.bindings[index];
+      const target = binding[kind];
+      const before = previous.get(index);
+      const after = next.get(index);
+      if (target && binding.dependencies?.length === 1 && binding.dependencies[0] === target.dependency && dirtyState.has(target.dependency) && before?.eligible && after?.eligible) {
+        const keys = changedKeys(before, after);
+        return { keys, count: keys.size };
+      }
+      return { keys: fallbackKeys, count: fallbackCount };
+    },
+    commitPrepared(indices) {
+      for (const index of indices) {
+        const value = next.get(index);
+        if (value) previous.set(index, value);
+        else previous.delete(index);
+      }
+    },
+    clear() {
+      previous.clear();
+      next.clear();
+    }
+  };
+}
+function createKeyedIdentityTargetRuntime(props) {
+  return createSingleKindKeyedTargetRuntime(
+    props,
+    "identityTarget",
+    keyedIdentityTargetSnapshot,
+    (previous, next) => {
+      const keys = /* @__PURE__ */ new Set();
+      if (previous.key !== void 0) keys.add(previous.key);
+      if (next.key !== void 0) keys.add(next.key);
+      return keys;
+    }
+  );
+}
+function createKeyedMembershipTargetRuntime(props) {
+  return createSingleKindKeyedTargetRuntime(
+    props,
+    "membershipTarget",
+    keyedMembershipTargetSnapshot,
+    keyedMembershipChangedKeys
+  );
+}
+function createKeyedMapLookupTargetRuntime(props) {
+  return createSingleKindKeyedTargetRuntime(
+    props,
+    "mapLookupTarget",
+    keyedMapLookupTargetSnapshot,
+    keyedMapLookupChangedKeys
+  );
+}
+function createKeyedTargetRuntime(props) {
+  if (!props.bindings.some(
+    (binding) => binding.identityTarget || binding.membershipTarget || binding.mapLookupTarget
+  )) {
+    return void 0;
+  }
+  const identityTargets = /* @__PURE__ */ new Map();
+  const membershipTargets = /* @__PURE__ */ new Map();
+  const mapLookupTargets = /* @__PURE__ */ new Map();
+  let nextIdentityTargets = /* @__PURE__ */ new Map();
+  let nextMembershipTargets = /* @__PURE__ */ new Map();
+  let nextMapLookupTargets = /* @__PURE__ */ new Map();
+  return {
+    hasSafeTargets(props2, dirtyState) {
+      for (const binding of props2.bindings) {
+        const membershipTarget = binding.membershipTarget;
+        if (membershipTarget && (!dirtyState || dirtyState.has(membershipTarget.dependency)) && !keyedMembershipTargetSnapshot(membershipTarget.read()).eligible) {
+          return false;
+        }
+        const mapLookupTarget = binding.mapLookupTarget;
+        if (mapLookupTarget && (!dirtyState || dirtyState.has(mapLookupTarget.dependency)) && !keyedMapLookupTargetSnapshot(mapLookupTarget.read()).eligible) {
+          return false;
+        }
+      }
+      return true;
+    },
+    commit(props2, dirtyState) {
+      if (!dirtyState) {
+        identityTargets.clear();
+        membershipTargets.clear();
+        mapLookupTargets.clear();
+      }
+      for (let bindingIndex = 0; bindingIndex < props2.bindings.length; bindingIndex += 1) {
+        const binding = props2.bindings[bindingIndex];
+        const identityTarget = binding.identityTarget;
+        if (!identityTarget) {
+          identityTargets.delete(bindingIndex);
+        } else if (!dirtyState || dirtyState.has(identityTarget.dependency)) {
+          identityTargets.set(bindingIndex, keyedIdentityTargetSnapshot(identityTarget.read()));
+        }
+        const membershipTarget = binding.membershipTarget;
+        if (!membershipTarget) {
+          membershipTargets.delete(bindingIndex);
+        } else if (!dirtyState || dirtyState.has(membershipTarget.dependency)) {
+          membershipTargets.set(
+            bindingIndex,
+            keyedMembershipTargetSnapshot(membershipTarget.read())
+          );
+        }
+        const mapLookupTarget = binding.mapLookupTarget;
+        if (!mapLookupTarget) {
+          mapLookupTargets.delete(bindingIndex);
+        } else if (!dirtyState || dirtyState.has(mapLookupTarget.dependency)) {
+          mapLookupTargets.set(bindingIndex, keyedMapLookupTargetSnapshot(mapLookupTarget.read()));
+        }
+      }
+    },
+    prepare(props2, bindingIndices) {
+      nextIdentityTargets = /* @__PURE__ */ new Map();
+      nextMembershipTargets = /* @__PURE__ */ new Map();
+      nextMapLookupTargets = /* @__PURE__ */ new Map();
+      for (const bindingIndex of bindingIndices) {
+        const binding = props2.bindings[bindingIndex];
+        if (binding.identityTarget) {
+          nextIdentityTargets.set(
+            bindingIndex,
+            keyedIdentityTargetSnapshot(binding.identityTarget.read())
+          );
+        }
+        if (binding.membershipTarget) {
+          const snapshot = keyedMembershipTargetSnapshot(
+            binding.membershipTarget.read(),
+            membershipTargets.get(bindingIndex)
+          );
+          if (!snapshot.eligible) return false;
+          nextMembershipTargets.set(bindingIndex, snapshot);
+        }
+        if (binding.mapLookupTarget) {
+          const snapshot = keyedMapLookupTargetSnapshot(
+            binding.mapLookupTarget.read(),
+            mapLookupTargets.get(bindingIndex)
+          );
+          if (!snapshot.eligible) return false;
+          nextMapLookupTargets.set(bindingIndex, snapshot);
+        }
+      }
+      return true;
+    },
+    select(props2, bindingIndex, dirtyState, fallbackKeys, fallbackCount) {
+      const binding = props2.bindings[bindingIndex];
+      const identityTarget = binding.identityTarget;
+      const previousIdentityTarget = 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 = 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 = 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);
+        return { keys, count: keys.size };
+      }
+      if (canTargetMembership && previousMembershipTarget && nextMembershipTarget) {
+        const keys = keyedMembershipChangedKeys(previousMembershipTarget, nextMembershipTarget);
+        return { keys, count: keys.size };
+      }
+      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);
+        return { keys, count: keys.size };
+      }
+      return { keys: fallbackKeys, count: fallbackCount };
+    },
+    commitPrepared(bindingIndices) {
+      for (const bindingIndex of bindingIndices) {
+        const nextIdentityTarget = nextIdentityTargets.get(bindingIndex);
+        const nextMembershipTarget = nextMembershipTargets.get(bindingIndex);
+        const nextMapLookupTarget = nextMapLookupTargets.get(bindingIndex);
+        if (nextIdentityTarget) identityTargets.set(bindingIndex, nextIdentityTarget);
+        else identityTargets.delete(bindingIndex);
+        if (nextMembershipTarget) {
+          membershipTargets.set(bindingIndex, nextMembershipTarget);
+        } else {
+          membershipTargets.delete(bindingIndex);
+        }
+        if (nextMapLookupTarget) {
+          mapLookupTargets.set(bindingIndex, nextMapLookupTarget);
+        } else {
+          mapLookupTargets.delete(bindingIndex);
+        }
+      }
+    },
+    clear() {
+      identityTargets.clear();
+      membershipTargets.clear();
+      mapLookupTargets.clear();
+    }
+  };
+}
 function normalizedKeyedRowBindingValue(binding, value) {
   return binding.kind === "text" ? renderTextValue(value) : value;
 }
@@ -5745,7 +5988,7 @@ function createKeyedRowHostRuntime() {
     mount: (element, descriptor, requestFallback) => mountCompilerHostTree(owner, element, descriptor, requestFallback)
   };
 }
-function createKeyedRowsBlockComponent(owner, options = {}) {
+function createKeyedRowsBlockComponentCore(owner, options = {}) {
   class FarmKeyedRowsBlock extends React__default.default.Component {
     constructor() {
       super(...arguments);
@@ -5759,9 +6002,7 @@ function createKeyedRowsBlockComponent(owner, options = {}) {
       this.currentProps = this.props;
       this.definitionVersion = owner.getDefinitionVersion?.();
       this.instances = /* @__PURE__ */ new Map();
-      this.identityTargets = /* @__PURE__ */ new Map();
-      this.membershipTargets = /* @__PURE__ */ new Map();
-      this.mapLookupTargets = /* @__PURE__ */ new Map();
+      this.keyedTargets = options.keyedTargets?.(this.props);
       this.renderVersion = 0;
       this.eventHandlers = /* @__PURE__ */ new Map();
       this.conditionalListeners = /* @__PURE__ */ new Map();
@@ -6075,64 +6316,11 @@ function createKeyedRowsBlockComponent(owner, options = {}) {
         this.currentProps.items(),
         this.instances
       );
-      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())
-          );
-        }
-      }
+      this.keyedTargets?.commit(this.currentProps, dirtyState);
     }
     adopt() {
       if (!this.root) return false;
-      if (!this.hasSafeMembershipTargets() || !this.hasSafeMapLookupTargets()) return false;
+      if (this.keyedTargets && !this.keyedTargets.hasSafeTargets(this.currentProps)) return false;
       const rows = this.readRows(this.currentProps);
       const elements = [...this.root.children];
       if (!rows || rows.items.length !== elements.length) return false;
@@ -6240,81 +6428,22 @@ function createKeyedRowsBlockComponent(owner, options = {}) {
           affectedBindingIndices.push(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);
-        }
+      const targetsPrepared = this.keyedTargets?.prepare(this.currentProps, affectedBindingIndices);
+      if (targetsPrepared === false) {
+        this.activateFallback(afterCommit);
+        return true;
       }
       let preparedBindingUpdates;
       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
+        const selection = this.keyedTargets?.select(
+          this.currentProps,
+          bindingIndex,
+          dirtyState,
+          this.instances.keys(),
+          this.instances.size
         );
-        let selectedKeys;
-        let selectedCount;
-        if (canTargetMapLookup && previousMapLookupTarget && nextMapLookupTarget) {
-          const keys = keyedMapLookupChangedKeys(previousMapLookupTarget, nextMapLookupTarget);
-          selectedKeys = keys;
-          selectedCount = keys.size;
-        } else if (canTargetMembership && previousMembershipTarget && nextMembershipTarget) {
-          const keys = keyedMembershipChangedKeys(previousMembershipTarget, nextMembershipTarget);
-          selectedKeys = keys;
-          selectedCount = keys.size;
-        } 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);
-          selectedKeys = keys;
-          selectedCount = keys.size;
-        } else {
-          selectedKeys = this.instances.keys();
-          selectedCount = this.instances.size;
-        }
+        const selectedKeys = selection?.keys || this.instances.keys();
+        const selectedCount = selection?.count ?? this.instances.size;
         const prepare = affectedBindingIndices.length > 1 || selectedCount > 1;
         if (prepare) preparedBindingUpdates || (preparedBindingUpdates = []);
         for (const key of selectedKeys) {
@@ -6355,23 +6484,7 @@ function createKeyedRowsBlockComponent(owner, options = {}) {
           );
         }
       }
-      for (const bindingIndex of affectedBindingIndices) {
-        const nextIdentityTarget = nextIdentityTargets.get(bindingIndex);
-        const nextMembershipTarget = nextMembershipTargets.get(bindingIndex);
-        const nextMapLookupTarget = nextMapLookupTargets.get(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);
-        }
-      }
+      this.keyedTargets?.commitPrepared(affectedBindingIndices);
       afterCommit?.();
       return true;
     }
@@ -6510,11 +6623,7 @@ function createKeyedRowsBlockComponent(owner, options = {}) {
         this.forceUpdate(afterCommit);
         return;
       }
-      if (!this.hasSafeMembershipTargets(dirtyState)) {
-        this.activateFallback(afterCommit);
-        return;
-      }
-      if (!this.hasSafeMapLookupTargets(dirtyState)) {
+      if (this.keyedTargets && !this.keyedTargets.hasSafeTargets(this.currentProps, dirtyState)) {
         this.activateFallback(afterCommit);
         return;
       }
@@ -6666,6 +6775,7 @@ function createKeyedRowsBlockComponent(owner, options = {}) {
       const willBeReactOwned = this.hasReactOwnedRows(nextProps);
       const definitionChanged = this.definitionVersion !== owner.getDefinitionVersion?.();
       this.currentProps = nextProps;
+      this.keyedTargets || (this.keyedTargets = options.keyedTargets?.(nextProps));
       if (this.state.fallback && nextState.fallback) {
         const unsafeKeys = this.hasUnsafeFallbackKeys();
         if (unsafeKeys || this.fallbackKeysWereUnsafe) this.fallbackVersion += 1;
@@ -6701,9 +6811,7 @@ function createKeyedRowsBlockComponent(owner, options = {}) {
       this.id = void 0;
       this.cleanupHostScopes();
       this.instances.clear();
-      this.identityTargets.clear();
-      this.membershipTargets.clear();
-      this.mapLookupTargets.clear();
+      this.keyedTargets?.clear();
       this.instancesByElement = /* @__PURE__ */ new WeakMap();
       this.eventHandlers.clear();
       this.conditionalListeners.clear();
@@ -6726,6 +6834,12 @@ function createKeyedRowsBlockComponent(owner, options = {}) {
   FarmKeyedRowsBlock.displayName = "FarmCompiledKeyedRows";
   return FarmKeyedRowsBlock;
 }
+function createKeyedRowsBlockComponent(owner, options = {}) {
+  return createKeyedRowsBlockComponentCore(owner, {
+    ...options,
+    keyedTargets: createKeyedTargetRuntime
+  });
+}
 function createKeyedRangesBlockComponent(owner) {
   class FarmKeyedRangesBlock extends React__default.default.Component {
     constructor() {
@@ -7201,6 +7315,36 @@ var keyedRowsRuntimeFeature = {
     KeyedRows: createKeyedRowsBlockComponent(owner)
   })
 };
+var keyedRowsPlainRuntimeFeature = {
+  name: "keyed-rows:plain",
+  create: (owner) => ({
+    KeyedRows: createKeyedRowsBlockComponentCore(owner)
+  })
+};
+var keyedRowsIdentityRuntimeFeature = {
+  name: "keyed-rows:identity",
+  create: (owner) => ({
+    KeyedRows: createKeyedRowsBlockComponentCore(owner, {
+      keyedTargets: createKeyedIdentityTargetRuntime
+    })
+  })
+};
+var keyedRowsMembershipRuntimeFeature = {
+  name: "keyed-rows:membership",
+  create: (owner) => ({
+    KeyedRows: createKeyedRowsBlockComponentCore(owner, {
+      keyedTargets: createKeyedMembershipTargetRuntime
+    })
+  })
+};
+var keyedRowsMapLookupRuntimeFeature = {
+  name: "keyed-rows:map-lookup",
+  create: (owner) => ({
+    KeyedRows: createKeyedRowsBlockComponentCore(owner, {
+      keyedTargets: createKeyedMapLookupTargetRuntime
+    })
+  })
+};
 var keyedRowsHintedRuntimeFeature = {
   name: "keyed-rows:hinted",
   create: (owner) => ({
@@ -8431,8 +8575,12 @@ exports.keyedRowsHostStructuralPrependHintedRuntimeFeature = keyedRowsHostStruct
 exports.keyedRowsHostStructuralPrependMapHintedRuntimeFeature = keyedRowsHostStructuralPrependMapHintedRuntimeFeature;
 exports.keyedRowsHostWindowEveryHintedRuntimeFeature = keyedRowsHostWindowEveryHintedRuntimeFeature;
 exports.keyedRowsHostWindowPositionHintedRuntimeFeature = keyedRowsHostWindowPositionHintedRuntimeFeature;
+exports.keyedRowsIdentityRuntimeFeature = keyedRowsIdentityRuntimeFeature;
+exports.keyedRowsMapLookupRuntimeFeature = keyedRowsMapLookupRuntimeFeature;
 exports.keyedRowsMapReorderHintedRuntimeFeature = keyedRowsMapReorderHintedRuntimeFeature;
 exports.keyedRowsMappedRollingWindowHintedRuntimeFeature = keyedRowsMappedRollingWindowHintedRuntimeFeature;
+exports.keyedRowsMembershipRuntimeFeature = keyedRowsMembershipRuntimeFeature;
+exports.keyedRowsPlainRuntimeFeature = keyedRowsPlainRuntimeFeature;
 exports.keyedRowsPositionHintedRuntimeFeature = keyedRowsPositionHintedRuntimeFeature;
 exports.keyedRowsPrependHintedRuntimeFeature = keyedRowsPrependHintedRuntimeFeature;
 exports.keyedRowsReorderHintedRuntimeFeature = keyedRowsReorderHintedRuntimeFeature;