fix(run-store): guard carryUnknownKeys against prototype keys and scan imports on raw source

Use an own-property check and skip __proto__/constructor/prototype so an
inherited-name field surfaces as a divergence and no key can pollute the
prototype. Scan import statements on the raw source (line-anchored) so
comment stripping cannot hide a real import.

Author: d-cs

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

@@ -13,17 +13,17 @@ const here = dirname(fileURLToPath(import.meta.url));
 // Returns the module specifiers a file imports FOR VALUE (i.e. that survive to runtime). `import type`
 // declarations and named blocks whose specifiers are all inline `type` are erased and excluded.
 function valueImports(sourcePath: string): string[] {
-  // Strip block AND line comments so a comment mentioning `import(` or `import ... from` cannot
-  // produce a false positive.
-  const src = readFileSync(sourcePath, "utf8")
-    .replace(/\/\*[\s\S]*?\*\//g, "")
-    .replace(/\/\/.*$/gm, "");
+  const raw = readFileSync(sourcePath, "utf8");
   const out: string[] = [];
 
-  if (/(^|[^.\w])import\s*\(/.test(src)) out.push("<dynamic import()>");
+  // Statements are scanned on RAW source, anchored to line start (`^\s*import`), so a `//` comment
+  // line never matches and no stripping can hide a real import. Only the mid-line dynamic `import(`
+  // check runs on comment-stripped source. The pin test below guarantees the scan catches a real import.
+  const stripped = raw.replace(/\/\*[\s\S]*?\*\//g, "").replace(/\/\/.*$/gm, "");
+  if (/(^|[^.\w])import\s*\(/.test(stripped)) out.push("<dynamic import()>");
 
   const importRe = /^\s*import\b([\s\S]*?)\bfrom\s*["']([^"']+)["']/gm;
-  for (let m = importRe.exec(src); m !== null; m = importRe.exec(src)) {
+  for (let m = importRe.exec(raw); m !== null; m = importRe.exec(raw)) {
     const clause = m[1];
     const spec = m[2];
     if (/^\s*type\b/.test(clause)) continue; // `import type ... from`
@@ -36,7 +36,7 @@ function valueImports(sourcePath: string): string[] {
 
   // Bare side-effect imports (`import "x"`) run the module.
   const bareRe = /^\s*import\s*["']([^"']+)["']/gm;
-  for (let m = bareRe.exec(src); m !== null; m = bareRe.exec(src)) out.push(m[1]);
+  for (let m = bareRe.exec(raw); m !== null; m = bareRe.exec(raw)) out.push(m[1]);
 
   return out;
 }

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

@@ -131,6 +131,29 @@ describe("diffLatest", () => {
       expect.objectContaining({ field: "mysteryField", class: "unknownField", redis: "surprise" }),
     ]);
   });
+
+  it("surfaces an inherited-name key and does not pollute the prototype", () => {
+    // JSON.parse produces OWN keys for `toString` and `__proto__` (unlike an object literal).
+    const entry = JSON.parse(
+      '{"engine":"V2","executionStatus":"RUN_CREATED","description":"d","runId":"r1",' +
+        '"runStatus":"PENDING","createdAt":"2026-08-24T00:00:00.000Z","environmentId":"env",' +
+        '"environmentType":"DEVELOPMENT","projectId":"p","organizationId":"o",' +
+        '"toString":"surprise","__proto__":{"polluted":true}}'
+    ) as Record<string, unknown>;
+    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(n["toString"]).toBe("surprise");
+    expect(Object.getPrototypeOf(n)).toBe(Object.prototype); // __proto__ skipped, no pollution
+    expect("polluted" in {}).toBe(false);
+
+    const d = diffLatest(
+      norm({ id: "s1", createdAt: n.createdAt as number, updatedAt: n.updatedAt as number }),
+      n as NormalizedSnapshot
+    );
+    expect(d.some((x) => x.field === "toString" && x.class === "unknownField")).toBe(true);
+  });
 });
 
 describe("diffSince", () => {

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

@@ -80,9 +80,14 @@ const KNOWN_KEYS = new Set<string>([
 
 // 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.
+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 (!KNOWN_KEYS.has(k) && !(k in target)) target[k] = source[k];
+    if (DANGEROUS_KEYS.has(k)) continue;
+    if (!KNOWN_KEYS.has(k) && !hasOwn(target, k)) target[k] = source[k];
   }
 }