fix(run-store): drop the redundant own-property guard in carryUnknownKeys

The normalizer only ever sets known keys, so a non-known source key is never
already present; the check was unnecessary and tripped the lint rule against
hasOwnProperty. Skipping the prototype-pollution keys still holds.

Author: d-cs

internal-packages/run-store/src/snapshotComparator.test.ts

@@ -143,7 +143,7 @@ describe("diffLatest", () => {
     const read: SnapshotRead = { id: "s1", seq: 1, isValid: true, raw: "{}", entry };
     const n = normalizeFromRedis(read) as Record<string, unknown>;
 
-    expect(Object.prototype.hasOwnProperty.call(n, "toString")).toBe(true); // carried despite inherited name
+    expect(Object.keys(n)).toContain("toString"); // carried as an own key despite the inherited name
     expect(n["toString"]).toBe("surprise");
     expect(Object.getPrototypeOf(n)).toBe(Object.prototype); // __proto__ skipped, no pollution
     expect("polluted" in {}).toBe(false);

internal-packages/run-store/src/snapshotComparator.ts

@@ -78,16 +78,15 @@ const KNOWN_KEYS = new Set<string>([
   "waitpointIdSet",
 ]);
 
-// Carry a source key normalization does not recognise onto the normalized object, so the
-// unknownField check sees it instead of it being silently dropped (a false clean comparison).
-// Uses an own-property check (not `in`, which sees the prototype chain and would hide keys like
-// `constructor`), and skips prototype-pollution keys.
+// Carry a source key normalization does not recognise onto the normalized object, so the unknownField
+// check sees it instead of it being silently dropped (a false clean comparison). Skips the
+// prototype-pollution keys. No own-property guard is needed: the normalizer only ever sets KNOWN_KEYS,
+// so a non-known source key is never already present and cannot overwrite a normalized value.
 const DANGEROUS_KEYS = new Set(["__proto__", "constructor", "prototype"]);
-const hasOwn = (o: object, k: string): boolean => Object.prototype.hasOwnProperty.call(o, k);
 function carryUnknownKeys(target: NormalizedSnapshot, source: Record<string, unknown>): void {
   for (const k of Object.keys(source)) {
     if (DANGEROUS_KEYS.has(k)) continue;
-    if (!KNOWN_KEYS.has(k) && !hasOwn(target, k)) target[k] = source[k];
+    if (!KNOWN_KEYS.has(k)) target[k] = source[k];
   }
 }