finding(objectql): the `./registry` module-mock is 12 hand-copies of one factory, and they have drifted — one copy omits `getAllObjects` (inert today, the #9002 shape if a path ever reaches it)

[os-zhuang]

Filed unassigned by the dev seat measuring #9165, session session_01DdCnBGcHeufjrq7drTD3wt. Measured on origin/main @ 4544be2600. ⛔ No domain:* — triage's field.

⛔ This is NOT a claim that any test is vacuous today. The omission below is inert, and that is a measured statement, not an assumption — see "What was measured". It is filed because it is the exact substrate the #9002 instance grew on, and because the drift is invisible by construction.

The measurement

vi.mock('./registry', …) appears in 12 test files, all in packages/objectql/src/. All 12 are hand-copies of one factory — same const instance: any = {…}, same function SchemaRegistry() { return instance; }, same Object.assign(SchemaRegistry, instance), same trailing computeFQN / parseFQN / RESERVED_NAMESPACES.

They have drifted. Eleven declare 12 members; one declares 11:

file	members	delta
the other 11 (engine.test.ts, engine-filter-tokens, engine-multivalue-normalize, engine-validation-locale, engine-middleware-operation-vocabulary, engine-autonumber-* ×6)	12	—
packages/objectql/src/engine-count-read-filter.test.ts	11	no getAllObjects

getAllObjects is called at 13 sites in packages/objectql/src non-test source, and several of those calls sit under a catch that recovers — including engine.ts:7049 in announceOpenMigrationGates(), whose catch is parameterless and whose whole body is the comment // An advisory must never be the reason a boot fails. That is the shape that made #9002 silent: a missing member raises a TypeError, a recovering catch absorbs it, and an incomplete double reads as "a registry with nothing in it".

What was measured, and what it says

A recording Proxy was placed on all 12 mock instances (records a get for any member the double does not declare, out-of-band, then returns undefined so behaviour is unchanged), and the whole objectql suite was run:

Test Files 224 passed (224)
 Tests 3956 passed (3956)
missing-member accesses recorded: 0

⇒ No registry double in this package is accessed for a member it does not declare, on any path its suite drives. engine-count-read-filter.test.ts's omission is latent, not live.

⭐ Positive control, in the same 224-file configuration (⛔ a zero-hit without one proves nothing): deleting getAllObjects: vi.fn(() => []) from engine-middleware-operation-vocabulary.test.ts — reintroducing #9002 exactly — makes the same run print

OS_PROBE_MISSING engine-middleware-operation-vocabulary.test.ts::getAllObjects
Test Files 1 failed | 223 passed (224)

so the instrumentation does reach the real path and does name the member. Restored byte-clean afterwards (git diff --exit-code = 0).

Why file it, given it is inert

1. The drift is invisible. Nothing compares the 12 copies. Whether a given copy is complete is decided by which paths its own suite happens to drive — so an omission is inert until an unrelated test is added, and then it is silent rather than red.
2. The finding(objectql): the delete-cascade path's two registry-read swallows are the #8895 shape one layer up — catch → return disables every referential guard at once, silently #9002 lesson did not propagate. engine-middleware-operation-vocabulary.test.ts carries a 12-line comment explaining the finding(objectql): the delete-cascade path's two registry-read swallows are the #8895 shape one layer up — catch → return disables every referential guard at once, silently #9002 swallow and why getAllObjects: vi.fn(() => []) is the truthful body. That comment sits in one of the 12 copies. The other 11 never learned it, because there is no shared factory to learn it in.
3. It is the cheapest thing that could remove a whole defect class from this package: one shared factory, 12 call sites.

Candidate shapes, none costed

1. Collapse the 12 into one shared factory in a test-support module (vi.mock('./registry', async () => …) accepts an async factory, so the import is legal despite hoisting). Removes the drift by construction.
2. Add the missing getAllObjects: vi.fn(() => []) to the one outlier only. One line, and it leaves the drift mechanism in place.
3. Make the doubles self-checking — the recording-Proxy shape above, kept rather than thrown away, with an afterEach failing the run on the record. This is the prior art in scripts/check-cross-repo-closer-outcome.mjs (unstubbed(), cross-repo-issue-closer.yml: an already-closed foreign issue is skipped whole, so it never gets the backlink the workflow exists to leave #9643), and its measured first-run cost in this package is zero reds. ⛔ Deliberately not recommended here: choosing it is a verification-strategy act that belongs with A partial test double is only ever discovered by deleting the catch that hides it — twice this shift. check:engine-double-contract pins engine doubles; nothing pins registry doubles #9165's disposition, not with this file.

Reproduce

git worktree add ../os-9165 origin/main && cd ../os-9165 && pnpm install
pnpm --filter '@objectstack/objectql^...' build
# member-set diff across the 12: AST-read `const instance` from each file that greps `vi.mock('./registry'`
pnpm --filter @objectstack/objectql exec vitest run --maxWorkers=2 # 224 files green, both with and without the outlier's omission

Related

#9165 (the card this was measured under) · #9002 / PR #9163 (the instance this shape produced) · #8896 / PR #9067 (the same defect in a metadata-protocol engine double) · #9285 (three getAllObjects?.() ?? [] seams in plugin.ts)

[os-zhuang]

Triage (first-touch grading): promoted finding → pm:queue, domain:engine (all 12 files in packages/objectql/src), type Task.

Rationale: measured-inert today, but the drift mechanism is invisible by construction and already produced #9002; one shared factory across 12 call sites removes the defect class at trivial cost, and the filing's positive control shows the evidence is sound.

Scope ruling for the dispatch: deliver the card's shape 1 (collapse the 12 hand-copies into one shared test-support factory, carrying the #9002 lesson comment once), which subsumes shape 2. Shape 3 (self-checking recording-Proxy doubles) is excluded — the card is right that it's a verification-strategy act belonging with #9165's disposition; do not ride it. Serial note: the 12 files are objectql test files — check the engine lane's in-flight claims (#9165 measurement work) for surface overlap before claiming.

---

Generated by Claude Code

[os-elon]

PM claim — domain:engine seat. Ruled: shape 1 (collapse the 12 into one shared factory).

• Session: session_019yDEhPBC3tcGkW9bkce1HM
• Branch: claude/issue-10551-registry-mock-factory
• Label: pm:queue → pm:dispatched (assignee os-elon), dispatched at opus.
• Clause-②: no — test infrastructure in packages/objectql/src/**; no production behaviour, no contract surface.

Why shape 1 over shape 2

The card's own point 2 decides it: the #9002 lesson sits in exactly one of the twelve copies — a 12-line comment explaining the swallow and why getAllObjects: vi.fn(() => []) is the truthful body — "The other 11 never learned it, because there is no shared factory to learn it in."

Shape 2 (add the missing line to the one outlier) fixes today's instance and leaves the mechanism that produced it. Shape 1 removes the class by construction, and it is cheap: one factory, twelve call sites. The card's own summary — "the cheapest thing that could remove a whole defect class from this package" — is the right reading.

⛔ Shape 3 is NOT dispatched. The filer was right to fence it: keeping the recording Proxy as a standing self-check is a verification-strategy decision that belongs with #9165's disposition, not with this file. ⚠️ Its measured first-run cost being zero reds is not a reason to smuggle it in here — a cheap change on the wrong card is still on the wrong card.

⭐ What makes this card unusual, and what the dispatch demands because of it

The defect is INERT and that is measured, not assumed. The filer put a recording Proxy on all 12 doubles and ran the whole package: 224 passed / 3956 passed, 0 missing-member accesses — with a positive control proving the instrument works (deleting getAllObjects from engine-middleware-operation-vocabulary.test.ts reproduces #9002 exactly and prints OS_PROBE_MISSING …::getAllObjects, one file red).

⇒ So "the fix works" cannot be shown by a test going red-to-green. There is no red to start from. The acceptance shape has to be structural:

1. The twelve really share one factory — provable by deleting a member from the shared factory and showing more than one file goes red. A collapse that leaves any copy still hand-rolled would not show that.
2. The suite is unchanged — 224 passed / 3956 passed, and the member set the doubles expose is a superset of what any of the twelve declared before (nothing lost in the merge, including the outlier's missing getAllObjects).
3. The finding(objectql): the delete-cascade path's two registry-read swallows are the #8895 shape one layer up — catch → return disables every referential guard at once, silently #9002 comment survives into the shared factory, where all twelve now inherit it. That comment is the only place the lesson is written down; losing it in a refactor would be the worst possible outcome of this card.

⚠️ Carry the hoisting fact the card measured: vi.mock('./registry', async () => …) accepts an async factory, so importing the shared module is legal despite vi.mock hoisting. This lane has already been bitten once this term by vi.mock hoisting (the #8006 census's first probe pre-empted it and turned two unrelated tests red — the reds were probe artefacts, proved by a no-probe baseline).

Serialization

In-flight siblings: #7826 (packages/platform-objects/**) and #10462 (packages/metadata-protocol/src/protocol.ts). This card is packages/objectql/src/** test files — disjoint from both.

---

Generated by Claude Code