wip(drivers): recovered uncommitted own-key-undefined pins from a killed seat

NOT REVIEWED, NOT VERIFIED. The resumed dispatch was killed before it
committed these; recovered so they survive the container.

Both files are the card's two outstanding obligations by name:
memory-own-key-undefined.test.ts and mongodb-own-key-undefined.test.ts —
the second being the driver-mongodb measurement the card asked for
explicitly and told the dev not to assume matched driver-memory.

No gate was run against them, no ablation exists, and the fail-OPEN
consumer sweep the card stars as a separate, more urgent card is not
evidenced anywhere in this branch.

Author: claude

packages/drivers/driver-memory/src/memory-own-key-undefined.test.ts

@@ -62,12 +62,26 @@ function comparable(row: Record<string, unknown>): Record<string, unknown> {
 /**
  * The contract itself: `written` (the field carried an explicit `undefined`)
  * and `neverWritten` (the field was simply absent) must be the same row.
+ *
+ * ⚠️ `toStrictEqual`, never `toEqual`. Measured on this repo's vitest, on the
+ * exact input class this file is about:
+ *
+ * ```
+ * expect({ a: 1, status: undefined }).toEqual({ a: 1 })        // PASSES
+ * expect({ a: 1, status: undefined }).toStrictEqual({ a: 1 })  // fails
+ * ```
+ *
+ * `toEqual` ignores own keys holding `undefined` — so spelled with it, the one
+ * assertion that states the CONTRACT would be vacuous here, green against the
+ * unrepaired driver, and the file would owe its whole discriminating power to
+ * the key-list and `in` assertions below, which pin a SPELLING ("the key is
+ * dropped") rather than the rule. Do not relax this back.
  */
 function assertIndistinguishable(
   written: Record<string, unknown>,
   neverWritten: Record<string, unknown>,
 ) {
-  expect(comparable(written)).toEqual(comparable(neverWritten));
+  expect(comparable(written)).toStrictEqual(comparable(neverWritten));
   // Diagnostic, so a failure names WHICH way the two diverged.
   expect(Object.keys(written).sort()).toEqual(Object.keys(neverWritten).sort());
   expect('status' in written).toBe('status' in neverWritten);
@@ -94,7 +108,7 @@ describe('#9276 an own key holding `undefined` is not a row state this driver em
     const [found] = await d.find('article', { where: { id: 'a1' } });
 
     expect('status' in created).toBe(false);
-    expect(created).toEqual(found);
+    expect(created).toStrictEqual(found);
   });
 
   it('findOne() agrees with find()', async () => {
@@ -132,7 +146,7 @@ describe('#9276 an own key holding `undefined` is not a row state this driver em
 
     expect('status' in (updated as any)).toBe(false);
     const [found] = await d.find('article', { where: { id: 'a1' } });
-    expect(found).toEqual(updated);
+    expect(found).toStrictEqual(updated);
     expect('status' in found).toBe(false);
   });
 

packages/drivers/driver-mongodb/src/mongodb-own-key-undefined.test.ts

@@ -77,7 +77,11 @@ describe('#9276 driver-mongodb — measured separately from driver-memory', () =
     // would store it as `null`, which is a value — not the absence the caller
     // expressed. Guarding at the insert door is what keeps it from getting
     // there.
-    expect(asStored({ id: 'a1', status: undefined })).toEqual({ id: 'a1', status: null });
+    // `toStrictEqual` throughout this file: `toEqual` IGNORES own keys holding
+    // `undefined`, which is precisely the input class here, so it cannot tell the
+    // two rows apart. See the note on `assertIndistinguishable` in
+    // `driver-memory`'s `memory-own-key-undefined.test.ts`.
+    expect(asStored({ id: 'a1', status: undefined })).toStrictEqual({ id: 'a1', status: null });
     expect(Object.keys(asStored({ id: 'a1' }))).toEqual(['id']);
   });
 
@@ -88,7 +92,7 @@ describe('#9276 driver-mongodb — measured separately from driver-memory', () =
     const neverWritten = await driver.create('article', { id: 'a2', title: 't' });
 
     expect('status' in written).toBe(false);
-    expect(comparable(written)).toEqual(comparable(neverWritten));
+    expect(comparable(written)).toStrictEqual(comparable(neverWritten));
   });
 
   it('nothing is stored for the field, so find() agrees with create()', async () => {
@@ -110,7 +114,7 @@ describe('#9276 driver-mongodb — measured separately from driver-memory', () =
     ]);
 
     expect('status' in written).toBe(false);
-    expect(comparable(written)).toEqual(comparable(neverWritten));
+    expect(comparable(written)).toStrictEqual(comparable(neverWritten));
     expect(inserted.every((doc) => !('status' in doc))).toBe(true);
     expect(inserted.every((doc) => !('status' in asStored(doc)))).toBe(true);
   });