const out = execFileSync('git', ['-C', root, 'ls-files', 'packages'], {

encoding: 'utf8',

maxBuffer: 64 * 1024 * 1024,

env: gitFreeEnv(),

});

return out

.split('\n')

.filter(Boolean)

.filter((f) => f.endsWith('.ts') && f.includes('/src/') && !/\.(test|spec)\.ts$/.test(f));

const keys = [];

let indexSignature = false;

for (const member of node.members) {

if (ts.isIndexSignatureDeclaration(member)) {

indexSignature = true;

continue;

}

if (!ts.isPropertySignature(member) || !member.name) continue;

if (ts.isIdentifier(member.name) || ts.isStringLiteral(member.name)) keys.push(member.name.text);

}

return { keys, indexSignature };

if (!typeNode) return { kind: 'none' };

if (ts.isTypeLiteralNode(typeNode)) return { kind: 'object', ...literalKeys(typeNode) };

if (ts.isArrayTypeNode(typeNode) && ts.isTypeLiteralNode(typeNode.elementType)) {

return { kind: 'array', ...literalKeys(typeNode.elementType) };

}

if (

ts.isTypeReferenceNode(typeNode)

&& ts.isIdentifier(typeNode.typeName)

&& typeNode.typeName.text === 'Array'

&& typeNode.typeArguments?.length === 1

&& ts.isTypeLiteralNode(typeNode.typeArguments[0])

) {

return { kind: 'array', ...literalKeys(typeNode.typeArguments[0]) };

}

return { kind: 'opaque', text: typeNode.getText() };

let e = expr;

while (ts.isParenthesizedExpression(e)) e = e.expression;

return e;

const sourceFile = parseSourceFile(fileName, text, ts.ScriptKind.TS);

const lineOf = (node) => sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile)).line + 1;

const classes = [];

const castReads = [];

const collectCastReads = (fnNode, ownerLabel) => {

/** identifier -> the object shape it is known to carry */

const env = new Map();

for (const param of fnNode.parameters) {

if (!ts.isIdentifier(param.name)) continue;

const shape = classifyParamType(param.type);

if (shape.kind === 'object' || shape.kind === 'array') {

env.set(param.name.text, { ...shape, origin: 'a parameter' });

}

}

const walk = (node) => {

// `for (const obj of objects)` where `objects` is an array-shaped

// parameter: the binding carries the element shape. This is not a nicety

// -- #16711's `lifecycle` read is spelled exactly this way, and a gate

// that only followed parameters directly would have missed it.

if (

ts.isForOfStatement(node)

&& ts.isVariableDeclarationList(node.initializer)

&& node.initializer.declarations.length === 1

&& ts.isIdentifier(node.expression)

) {

const decl = node.initializer.declarations[0];

const source = env.get(node.expression.text);

if (ts.isIdentifier(decl.name) && source?.kind === 'array') {

env.set(decl.name.text, {

kind: 'object',

keys: source.keys,

indexSignature: source.indexSignature,

origin: `an element of \`${node.expression.text}\``,

});

}

}

if (ts.isPropertyAccessExpression(node) || ts.isElementAccessExpression(node)) {

const inner = unwrap(node.expression);

if (

ts.isAsExpression(inner)

&& inner.type.kind === ts.SyntaxKind.AnyKeyword

&& ts.isIdentifier(inner.expression)

) {

const shape = env.get(inner.expression.text);

const key = ts.isPropertyAccessExpression(node)

? node.name.text

: (ts.isStringLiteral(node.argumentExpression) ? node.argumentExpression.text : null);

if (shape && key && !shape.indexSignature && !shape.keys.includes(key)) {

castReads.push({

file: fileName,

line: lineOf(node),

owner: ownerLabel,

identifier: inner.expression.text,

key,

origin: shape.origin,

declared: shape.keys,

});

}

}

}

ts.forEachChild(node, walk);

};

if (fnNode.body) walk(fnNode.body);

};

const visit = (node) => {

if ((ts.isClassDeclaration(node) || ts.isClassExpression(node)) && node.name) {

const extendsClause = node.heritageClauses?.find((h) => h.token === ts.SyntaxKind.ExtendsKeyword);

const baseExpr = extendsClause?.types?.[0]?.expression;

const methods = new Map();

for (const member of node.members) {

if (!ts.isMethodDeclaration(member) || !member.name || !ts.isIdentifier(member.name)) continue;

methods.set(member.name.text, {

line: lineOf(member),

params: member.parameters.map((p) => classifyParamType(p.type)),

});

}

classes.push({

name: node.name.text,

base: baseExpr && ts.isIdentifier(baseExpr) ? baseExpr.text : null,

file: fileName,

line: lineOf(node),

methods,

});

}

if (ts.isMethodDeclaration(node) && node.name && ts.isIdentifier(node.name)) {

collectCastReads(node, node.name.text);

} else if (ts.isFunctionDeclaration(node) && node.name) {

collectCastReads(node, node.name.text);

}

ts.forEachChild(node, visit);

};

visit(sourceFile);

return { classes, castReads };

const byName = new Map();

for (const c of classes) {

if (!byName.has(c.name)) byName.set(c.name, []);

byName.get(c.name).push(c);

}

const narrowing = [];

const erasure = [];

const ambiguous = [];

let comparedPairs = 0;

for (const derived of classes) {

if (!derived.base) continue;

const candidates = byName.get(derived.base);

if (!candidates || candidates.length === 0) continue;

if (candidates.length > 1) {

ambiguous.push({ derived: derived.name, file: derived.file, base: derived.base, count: candidates.length });

continue;

}

const base = candidates[0];

if (base === derived) continue;

for (const [methodName, method] of derived.methods) {

const baseMethod = base.methods.get(methodName);

if (!baseMethod) continue;

const arity = Math.min(method.params.length, baseMethod.params.length);

for (let i = 0; i < arity; i++) {

const basePar = baseMethod.params[i];

const derPar = method.params[i];

if (basePar.kind !== 'object' && basePar.kind !== 'array') continue;

comparedPairs += 1;

const exemptKey = `${derived.file}::${derived.name}.${methodName}#${i}`;

if (Object.prototype.hasOwnProperty.call(ARM_C_EXEMPT, exemptKey)) continue;

if (derPar.kind === 'opaque' || derPar.kind === 'none') {

erasure.push({

kind: 'erased',

file: derived.file,

line: method.line,

derived: derived.name,

base: base.name,

baseFile: base.file,

method: methodName,

param: i,

detail: derPar.kind === 'none' ? '(no annotation)' : derPar.text,

exemptKey,

});

continue;

}

if (derPar.indexSignature || basePar.indexSignature) {

erasure.push({

kind: 'index-signature',

file: derPar.indexSignature ? derived.file : base.file,

line: derPar.indexSignature ? method.line : baseMethod.line,

derived: derived.name,

base: base.name,

baseFile: base.file,

method: methodName,

param: i,

detail: 'an index signature makes every key "declared"',

exemptKey,

});

continue;

}

const missing = basePar.keys.filter((k) => !derPar.keys.includes(k));

if (missing.length > 0) {

narrowing.push({

file: derived.file,

line: method.line,

derived: derived.name,

base: base.name,

baseFile: base.file,

baseLine: baseMethod.line,

method: methodName,

param: i,

missing,

baseKeys: basePar.keys,

derivedKeys: derPar.keys,

});

}

}

}

}

return { narrowing, erasure, ambiguous, comparedPairs };

const files = corpusFiles(root);

const missingControls = REQUIRED_CORPUS_FILES.filter((f) => !files.includes(f));

const classes = [];

const castReads = [];

if (missingControls.length === 0) {

for (const rel of files) {

const analyzed = analyzeSource(rel, readFileSync(resolve(root, rel), 'utf8'));

classes.push(...analyzed.classes);

castReads.push(...analyzed.castReads);

}

}

return { files, missingControls, classes, castReads, ...findOverrideFindings(classes) };

const failures = [];

const t = (name, ok) => { if (!ok) failures.push(name); };

// ── Arm A: the firing control, and both directions around it ──

const before = analyzeSnippet(TURSO_OVERRIDE_BEFORE_16711);

t(

'FIRING CONTROL: the pre-#16711 TursoDriver override is RED for both keys',

before.narrowing.length === 1

&& before.narrowing[0].method === 'initObjects'

&& before.narrowing[0].missing.join(',') === 'tenancy,indexes',

);

t(

'FIRING CONTROL: it is red because of the SUBCLASS, not the base',

before.narrowing[0]?.derived === 'TursoDriver' && before.narrowing[0]?.base === 'SqlDriver',

);

t('the widened override is green', analyzeSnippet(`

`).narrowing.length === 0);

t('an override declaring MORE than the base is green', analyzeSnippet(`

`).narrowing.length === 0);

t('a method the base does not have is not compared', analyzeSnippet(`

`).narrowing.length === 0);

t('a class with no resolvable base is not compared', analyzeSnippet(`

`).narrowing.length === 0);

t('a duplicated base name is reported ambiguous, never guessed', analyzeSnippet(`

`).ambiguous.length === 1);

// ⭐ The wrap trap, pinned. #16711's PM comment recorded a single-line grep

// for these two keys over this exact shape returning nothing -- AND its

// control returning nothing -- because the parameter is on its own line.

const wrapped = analyzeSnippet(`

t('a signature wrapped across lines is still read (the recorded grep trap)',

wrapped.narrowing.length === 1 && wrapped.narrowing[0].missing.join(',') === 'tenancy');

// ── Arm B: the undeclared cast read ──

const armB = analyzeSnippet(`

t('a cast read of an undeclared key is RED',

armB.castReads.length === 1 && armB.castReads[0].key === 'indexes');

t('a cast read of a DECLARED key is green', analyzeSnippet(`

`).castReads.length === 0);

// ⭐ The `for…of` binding: #16711's `lifecycle` read is spelled this way, so a

// gate that only followed parameters directly would have scored it clean.

const loop = analyzeSnippet(`

t('a cast read on a for…of binding over an array parameter is RED',

loop.castReads.length === 1 && loop.castReads[0].key === 'lifecycle');

t('optional-chained and element-access spellings are read too', analyzeSnippet(`

`).castReads.length === 2);

t('a cast on a NON-parameter identifier is out of scan scope', analyzeSnippet(`

`).castReads.length === 0);

t('a parameter with an opaque named type is out of scan scope', analyzeSnippet(`

`).castReads.length === 0);

// ── Arm C: the two edits that would make arms A and B vacuous ──

const erased = analyzeSnippet(`

t('replacing the base literal with an opaque type is RED (not silently skipped)',

erased.erasure.length === 1 && erased.erasure[0].kind === 'erased');

const idx = analyzeSnippet(`

t('an index signature on the override is RED', idx.erasure.length === 1 && idx.erasure[0].kind === 'index-signature');

t('an index signature makes arm B silent, so arm C has to hold that line', analyzeSnippet(`

`).castReads.length === 0);

// ── The corpus predicate itself, which is where this gate's own bug was ──

const files = corpusFiles();

for (const control of REQUIRED_CORPUS_FILES) {

t(`POSITIVE CONTROL: the corpus contains ${control}`, files.includes(control));

}

t('the corpus excludes test files', !files.some((f) => /\.(test|spec)\.ts$/.test(f)));

t('the corpus is only package sources', files.every((f) => f.startsWith('packages/') && f.includes('/src/')));

if (failures.length > 0) {

console.error(`\n✗ check-object-def-param-keys self-test: ${failures.length} case(s) failed\n`);

for (const f of failures) console.error(` - ${f}`);

console.error('');

process.exit(1);

}

console.log(`${SELF_TEST_VERDICT} (${files.length} corpus file(s), every control fired)`);

return SELF_TEST_VERDICT;

const { narrowing, erasure, castReads } = result;

const total = narrowing.length + erasure.length + castReads.length;

if (total === 0) {

console.log(

`check:object-def-param-keys: OK — ${result.files.length} source file(s), `

+ `${result.classes.length} class(es), ${result.comparedPairs} override parameter position(s) compared.`,

);

return 0;

}

console.error(`check:object-def-param-keys: ${total} problem(s)\n`);

if (narrowing.length > 0) {

console.error(' ── A · an override declares FEWER keys than the base it shadows ──');

for (const v of narrowing) {

console.error(` ${v.file}:${v.line} ${v.derived} extends ${v.base} — ${v.method}(param ${v.param})`);

console.error(` drops: ${v.missing.join(', ')}`);

console.error(` base declares {${v.baseKeys.join('; ')}} at ${v.baseFile}:${v.baseLine}`);

}

console.error('');

}

if (erasure.length > 0) {

console.error(' ── C · the base\'s declared shape is erased rather than widened ──');

for (const v of erasure) {

console.error(` ${v.file}:${v.line} ${v.derived} extends ${v.base} — ${v.method}(param ${v.param}) [${v.kind}]`);

console.error(` ${v.detail}`);

}

console.error('');

}

if (castReads.length > 0) {

console.error(' ── B · a key is READ off a parameter its own type does not declare ──');

for (const v of castReads) {

console.error(` ${v.file}:${v.line} ${v.owner}: (${v.identifier} as any).${v.key}`);

console.error(` ${v.identifier} is ${v.origin} declared {${v.declared.join('; ')}}`);

}

console.error('');

}

console.error(`An object-definition parameter is a CONTRACT with the people who call it.

return 1;

if (argv.includes('--self-test')) {

selfTest();

return;

}

if (selfTest() !== SELF_TEST_VERDICT) {

console.error(

'\n✗ check-object-def-param-keys: the self-test returned without reaching its verdict,\n'

+ 'so the sweep below would be running on an unverified instrument.\n',

);

process.exit(1);

}

const result = sweep();

if (result.missingControls.length > 0) {

console.error(`\n✗ check-object-def-param-keys — REFUSING to report on a corpus that lost its controls.\n`);

console.error(` ${result.files.length} file(s) enumerated, but these are not among them:\n`);

for (const f of result.missingControls) console.error(` ${f}`);

console.error(`

process.exit(EXIT_CORPUS_UNVERIFIED);

}

if (argv.includes('--list')) {

console.log(`corpus: ${result.files.length} file(s), ${result.classes.length} class(es)`);

console.log(`override parameter positions compared: ${result.comparedPairs}`);

for (const c of result.classes.filter((c) => c.base)) {

console.log(` ${c.file}:${c.line} ${c.name} extends ${c.base}`);

}

if (result.ambiguous.length > 0) {

console.log(`\nambiguous base names (judged by nothing):`);

for (const a of result.ambiguous) console.log(` ${a.file} ${a.derived} extends ${a.base} (${a.count} declarations)`);

}

}

const status = report(result);

if (status !== 0) process.exit(status);