@cbnventures/docusaurus-preset-nova 0.16.2 → 0.18.0

package/build/src/tests/type-declarations.test.js

@@ -1,8 +1,10 @@
-import { strictEqual } from 'node:assert/strict';
+import { deepStrictEqual, ok, strictEqual } from 'node:assert/strict';
+import { existsSync } from 'node:fs';
 import { readFile } from 'node:fs/promises';
 import { dirname, relative, resolve, sep, } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { glob } from 'glob';
+import { createSourceFile, forEachChild, isArrowFunction, isCallExpression, isClassDeclaration, isClassExpression, isConstructorDeclaration, isFunctionDeclaration, isFunctionExpression, isGetAccessorDeclaration, isIdentifier, isMethodDeclaration, isPrivateIdentifier, isSetAccessorDeclaration, isStringLiteral, isTypePredicateNode, isTypeReferenceNode, isVariableStatement, ScriptTarget, } from 'typescript';
 import { describe, it } from 'vitest';
 const testConfig = {
     standaloneTypeFiles: [
@@ -14,6 +16,193 @@ const testConfig = {
         'utils',
     ],
 };
+describe('buildSourceSectionMap', () => {
+    it.skipIf(existsSync(resolve(getPackageRoot(), 'src/lib/utility.ts')) === false)('tags function declaration line and body var lines with the function section', async () => {
+        const filePath = resolve(getPackageRoot(), 'src/lib/utility.ts');
+        const content = await readFile(filePath, 'utf-8');
+        const classPrefix = deriveClassPrefix(filePath);
+        const sectionMap = buildSourceSectionMap(filePath, content, classPrefix);
+        strictEqual(sectionMap.get(325), 'Lib_Utility_CurrentTimestamp');
+        strictEqual(sectionMap.get(326), 'Lib_Utility_CurrentTimestamp');
+        return;
+    });
+    it.skipIf(existsSync(resolve(getPackageRoot(), 'src/lib/utility.ts')) === false)('tags nested const-arrow-function body lines with the sub-section while keeping the const declaration in the parent section', async () => {
+        const filePath = resolve(getPackageRoot(), 'src/lib/utility.ts');
+        const content = await readFile(filePath, 'utf-8');
+        const classPrefix = deriveClassPrefix(filePath);
+        const sectionMap = buildSourceSectionMap(filePath, content, classPrefix);
+        strictEqual(sectionMap.get(343), 'Lib_Utility_CurrentTimestamp');
+        strictEqual(sectionMap.get(344), 'Lib_Utility_CurrentTimestamp_PadLeft');
+        return;
+    });
+    it.skipIf(existsSync(resolve(getPackageRoot(), 'src/toolkit/markdown-table.ts')) === false)('tags method declaration and body lines with the method section', async () => {
+        const filePath = resolve(getPackageRoot(), 'src/toolkit/markdown-table.ts');
+        const content = await readFile(filePath, 'utf-8');
+        const classPrefix = deriveClassPrefix(filePath);
+        const sectionMap = buildSourceSectionMap(filePath, content, classPrefix);
+        strictEqual(sectionMap.get(142), 'Toolkit_MarkdownTable_Runner_AddRow');
+        return;
+    });
+    it.skipIf(existsSync(resolve(getPackageRoot(), 'src/tests/cli/utility/initialize.test.ts')) === false)('tags describe block contents with the describe-derived section', async () => {
+        const filePath = resolve(getPackageRoot(), 'src/tests/cli/utility/initialize.test.ts');
+        const content = await readFile(filePath, 'utf-8');
+        const classPrefix = deriveClassPrefix(filePath);
+        const sectionMap = buildSourceSectionMap(filePath, content, classPrefix);
+        strictEqual(sectionMap.get(92), 'Tests_Cli_Utility_Initialize_CliUtilityInitializeRun');
+        return;
+    });
+    return;
+});
+describe('extractBodyDeclarations', () => {
+    it('extracts const x: T = ... and let x: T = ... lines, skips for-of and untyped', () => {
+        const lines = [
+            'function foo() {',
+            '  const a: Some_Type_A = 1;',
+            '  let b: Some_Type_B = 2;',
+            '  const c = 3;',
+            '  for (const d of items) { }',
+            '}',
+        ];
+        const result = extractBodyDeclarations(lines);
+        strictEqual(result.length, 2);
+        strictEqual((result[0] !== undefined) ? result[0]['varName'] : undefined, 'a');
+        strictEqual((result[0] !== undefined) ? result[0]['typeName'] : undefined, 'Some_Type_A');
+        strictEqual((result[0] !== undefined) ? result[0]['lineNumber'] : undefined, 2);
+        strictEqual((result[1] !== undefined) ? result[1]['varName'] : undefined, 'b');
+        strictEqual((result[1] !== undefined) ? result[1]['typeName'] : undefined, 'Some_Type_B');
+        strictEqual((result[1] !== undefined) ? result[1]['lineNumber'] : undefined, 3);
+        return;
+    });
+    return;
+});
+describe('extractFunctionParams', () => {
+    it.skipIf(existsSync(resolve(getPackageRoot(), 'src/toolkit/markdown-table.ts')) === false)('extracts typed params from method declarations', async () => {
+        const filePath = resolve(getPackageRoot(), 'src/toolkit/markdown-table.ts');
+        const content = await readFile(filePath, 'utf-8');
+        const result = extractFunctionParams(filePath, content);
+        const addRowParam = result.find((p) => p['paramName'] === 'row');
+        ok(addRowParam !== undefined, 'should find row param of addRow method');
+        strictEqual(addRowParam['typeName'], 'Toolkit_MarkdownTable_Runner_AddRow_Row');
+        return;
+    });
+    it.skipIf(existsSync(resolve(getPackageRoot(), 'src/lib/utility.ts')) === false)('extracts typed params from top-level function declarations', async () => {
+        const filePath = resolve(getPackageRoot(), 'src/lib/utility.ts');
+        const content = await readFile(filePath, 'utf-8');
+        const result = extractFunctionParams(filePath, content);
+        const isExecuteShellErrorParam = result.find((p) => p['paramName'] === 'error' && p['typeName'] === 'Lib_Utility_IsExecuteShellError_Error');
+        ok(isExecuteShellErrorParam !== undefined, 'should find error param of isExecuteShellError function');
+        return;
+    });
+    return;
+});
+describe('deriveClassPrefix', () => {
+    it('joins path segments with underscore, kebab-case stays one chunk', () => {
+        const filePath = resolve(getPackageRoot(), 'src/types/toolkit/markdown-table.d.ts');
+        const result = deriveClassPrefix(filePath);
+        strictEqual(result, 'Toolkit_MarkdownTable');
+        return;
+    });
+    it('drops .test from test files', () => {
+        const filePath = resolve(getPackageRoot(), 'src/types/tests/cli/utility/initialize.test.d.ts');
+        const result = deriveClassPrefix(filePath);
+        strictEqual(result, 'Tests_Cli_Utility_Initialize');
+        return;
+    });
+    it('handles deep paths', () => {
+        const filePath = resolve(getPackageRoot(), 'src/types/cli/recipe/package-json/cleanup.d.ts');
+        const result = deriveClassPrefix(filePath);
+        strictEqual(result, 'Cli_Recipe_PackageJson_Cleanup');
+        return;
+    });
+    return;
+});
+describe('extractReferencedTypes', () => {
+    it('matches types starting with classPrefix followed by underscore', () => {
+        const line = 'export type Lib_Utility_Foo = Lib_Utility_Bar | Lib_Utility_Baz;';
+        const classPrefix = 'Lib_Utility';
+        const result = extractReferencedTypes(line, classPrefix);
+        deepStrictEqual(result, [
+            'Lib_Utility_Bar',
+            'Lib_Utility_Baz',
+        ]);
+        return;
+    });
+    it('does not match unrelated module types', () => {
+        const line = 'export type Lib_Utility_Foo = Other_Module_Type;';
+        const classPrefix = 'Lib_Utility';
+        const result = extractReferencedTypes(line, classPrefix);
+        deepStrictEqual(result, []);
+        return;
+    });
+    it('captures multi-segment leaves greedily', () => {
+        const line = 'export type Cli_Foo_Bar = Cli_Foo_Baz_Qux_Quux;';
+        const classPrefix = 'Cli_Foo';
+        const result = extractReferencedTypes(line, classPrefix);
+        deepStrictEqual(result, ['Cli_Foo_Baz_Qux_Quux']);
+        return;
+    });
+    it('rejects malformed types that lack the underscore boundary after classPrefix', () => {
+        const line = 'export type Cli_Foo_Bar = Cli_FooBadJoin | Cli_Foo_Valid;';
+        const classPrefix = 'Cli_Foo';
+        const result = extractReferencedTypes(line, classPrefix);
+        deepStrictEqual(result, ['Cli_Foo_Valid']);
+        return;
+    });
+    return;
+});
+describe('discoverSourceFiles', () => {
+    it.skipIf(existsSync(resolve(getPackageRoot(), 'src/toolkit/markdown-table.ts')) === false)('returns absolute paths to .ts source files, excluding .d.ts', async () => {
+        const files = await discoverSourceFiles();
+        ok(files.length > 0, 'should find at least one source file');
+        ok(files.every((file) => file.endsWith('.ts')), 'all results should end with .ts');
+        ok(files.every((file) => file.endsWith('.d.ts') === false), 'no result should end with .d.ts');
+        ok(files.some((file) => file.endsWith('toolkit/markdown-table.ts')), 'should include markdown-table.ts');
+        return;
+    });
+    return;
+});
+describe('parseDescribeString', () => {
+    it('splits Class.method form and joins as one PascalCase chunk', () => {
+        const input = 'CliUtilityInitialize.run';
+        const result = parseDescribeString(input);
+        strictEqual(result, 'CliUtilityInitializeRun');
+        return;
+    });
+    it('handles space-separated descriptions', () => {
+        const input = 'does the thing';
+        const result = parseDescribeString(input);
+        strictEqual(result, 'DoesTheThing');
+        return;
+    });
+    it('handles single-word strings', () => {
+        const input = 'run';
+        const result = parseDescribeString(input);
+        strictEqual(result, 'Run');
+        return;
+    });
+    return;
+});
+describe('stripUnderscorePrefix', () => {
+    it('strips a single leading underscore', () => {
+        const input = '_prev';
+        const result = stripUnderscorePrefix(input);
+        strictEqual(result, 'prev');
+        return;
+    });
+    it('returns the name unchanged when there is no leading underscore', () => {
+        const input = 'value';
+        const result = stripUnderscorePrefix(input);
+        strictEqual(result, 'value');
+        return;
+    });
+    it('only strips ONE leading underscore', () => {
+        const input = '__double';
+        const result = stripUnderscorePrefix(input);
+        strictEqual(result, '_double');
+        return;
+    });
+    return;
+});
 describe('type declaration cross-section references', async () => {
     const files = await discoverTypeFiles();
     const crossSectionCurrentDirectory = getPackageRoot();
@@ -23,11 +212,19 @@ describe('type declaration cross-section references', async () => {
             if (testConfig['standaloneTypeFiles'].some((pattern) => file.endsWith(pattern)) === true) {
                 return;
             }
+            const sourcePath = deriveSourcePath(file);
+            const sourceExists = await fileExists(sourcePath);
+            if (sourceExists === false) {
+                return;
+            }
             const content = await readFile(file, 'utf-8');
             const lines = content.split('\n');
+            const sourceContent = await readFile(sourcePath, 'utf-8');
             const classPrefix = deriveClassPrefix(file);
+            const sectionMap = buildSourceSectionMap(sourcePath, sourceContent, classPrefix);
+            const sourceSectionSet = new Set(sectionMap.values());
             const importedNames = extractImportedNames(lines);
-            const sections = extractSections(lines);
+            const sections = buildDtsSections(lines, sourceSectionSet, classPrefix);
             const sectionPrefixes = sections.map((section) => section['prefix']);
             const violations = [];
             for (const section of sections) {
@@ -62,9 +259,21 @@ describe('type declaration section alphabetical order', async () => {
     for (const file of files) {
         const sectionOrderRelativePath = relative(sectionOrderCurrentDirectory, file);
         it(`sections alphabetical in ${sectionOrderRelativePath}`, async () => {
+            if (testConfig['standaloneTypeFiles'].some((pattern) => file.endsWith(pattern)) === true) {
+                return;
+            }
+            const sourcePath = deriveSourcePath(file);
+            const sourceExists = await fileExists(sourcePath);
+            if (sourceExists === false) {
+                return;
+            }
             const content = await readFile(file, 'utf-8');
             const lines = content.split('\n');
-            const sections = extractSections(lines);
+            const sourceContent = await readFile(sourcePath, 'utf-8');
+            const classPrefix = deriveClassPrefix(file);
+            const sectionMap = buildSourceSectionMap(sourcePath, sourceContent, classPrefix);
+            const sourceSectionSet = new Set(sectionMap.values());
+            const sections = buildDtsSections(lines, sourceSectionSet, classPrefix);
             const violations = [];
             for (let i = 1; i < sections.length; i += 1) {
                 const previous = sections[i - 1];
@@ -74,7 +283,7 @@ describe('type declaration section alphabetical order', async () => {
                 }
                 const compareResult = previous['prefix'].localeCompare(current['prefix']);
                 if (compareResult > 0) {
-                    const violation = `Section "${current['prefix']}" should come before "${previous['prefix']}"`;
+                    const violation = `Section "${current['prefix']}" appears after section "${previous['prefix']}" but should come before it. Sections in a .d.ts file must be alphabetical by section prefix; move "${current['prefix']}"'s types above "${previous['prefix']}"'s types.`;
                     violations.push(violation);
                 }
             }
@@ -110,7 +319,7 @@ describe('type declaration import specifier order', async () => {
                             if (previousSpecifier !== undefined
                                 && currentSpecifier !== undefined
                                 && previousSpecifier.localeCompare(currentSpecifier) > 0) {
-                                const violation = `Import specifier "${currentSpecifier}" should come before "${previousSpecifier}"`;
+                                const violation = `Import specifier "${currentSpecifier}" appears after "${previousSpecifier}" but should come before it. Specifiers within a single import block must be alphabetical; reorder so "${currentSpecifier}" comes before "${previousSpecifier}".`;
                                 violations.push(violation);
                             }
                         }
@@ -122,13 +331,13 @@ describe('type declaration import specifier order', async () => {
                     const trimmed = line.trim().replace(',', '');
                     if (trimmed.startsWith('}') === true) {
                         for (let i = 1; i < specifierBuffer.length; i += 1) {
-                            const previousSpecifier = specifierBuffer[i - 1];
-                            const currentSpecifier = specifierBuffer[i];
-                            if (previousSpecifier !== undefined
-                                && currentSpecifier !== undefined
-                                && previousSpecifier.localeCompare(currentSpecifier) > 0) {
-                                const violation = `Import specifier "${currentSpecifier}" should come before "${previousSpecifier}"`;
-                                violations.push(violation);
+                            const previousSpecifier2 = specifierBuffer[i - 1];
+                            const currentSpecifier2 = specifierBuffer[i];
+                            if (previousSpecifier2 !== undefined
+                                && currentSpecifier2 !== undefined
+                                && previousSpecifier2.localeCompare(currentSpecifier2) > 0) {
+                                const violation2 = `Import specifier "${currentSpecifier2}" appears after "${previousSpecifier2}" but should come before it. Specifiers within a single import block must be alphabetical; reorder so "${currentSpecifier2}" comes before "${previousSpecifier2}".`;
+                                violations.push(violation2);
                             }
                         }
                         inImportBlock = false;
@@ -170,15 +379,22 @@ describe('type declaration first-come-first-serve order', async () => {
             const sourceLines = sourceContent.split('\n');
             const dtsContent = await readFile(file, 'utf-8');
             const dtsLines = dtsContent.split('\n');
-            const sections = extractSections(dtsLines);
             const classPrefix = deriveClassPrefix(file);
+            const sectionMap = buildSourceSectionMap(sourcePath, sourceContent, classPrefix);
+            const sourceSectionSet = new Set(sectionMap.values());
+            const sections = buildDtsSections(dtsLines, sourceSectionSet, classPrefix);
             const objectTypes = extractObjectTypes(dtsLines, classPrefix);
             const objectPropertyTypeNames = new Set();
+            const arrayElementTypeNames = new Set();
             for (const objectType of objectTypes) {
                 for (const property of objectType['properties']) {
                     objectPropertyTypeNames.add(property['valueType']);
                 }
             }
+            const arrayTypesForOrder = extractArrayTypes(dtsLines);
+            for (const arrayType of arrayTypesForOrder) {
+                arrayElementTypeNames.add(arrayType['elementTypeName']);
+            }
             const violations = [];
             for (const section of sections) {
                 const typeNames = extractTypeNames(section['typeLines']);
@@ -187,6 +403,9 @@ describe('type declaration first-come-first-serve order', async () => {
                     if (objectPropertyTypeNames.has(typeName) === true) {
                         continue;
                     }
+                    if (arrayElementTypeNames.has(typeName) === true) {
+                        continue;
+                    }
                     const sourceLineIndex = findFirstOccurrence(sourceLines, typeName);
                     if (sourceLineIndex === -1) {
                         continue;
@@ -204,7 +423,7 @@ describe('type declaration first-come-first-serve order', async () => {
                         continue;
                     }
                     if (actual['name'] !== expected['name']) {
-                        const violation = `Section "${section['prefix']}": type "${actual['name']}" (source line ${actual['sourceLine'] + 1}) is at .d.ts position ${j + 1}, but should be "${expected['name']}" (source line ${expected['sourceLine'] + 1}).`;
+                        const violation = `Section "${section['prefix']}": at .d.ts position ${j + 1}, found "${actual['name']}" (first appears at source line ${actual['sourceLine'] + 1}) but expected "${expected['name']}" (first appears at source line ${expected['sourceLine'] + 1}, which comes earlier in source). Move "${expected['name']}" to position ${j + 1} so the .d.ts mirrors the source's first-come-first-serve order.`;
                         violations.push(violation);
                     }
                 }
@@ -247,16 +466,55 @@ describe('type declaration object property types', async () => {
                         continue;
                     }
                     if (definedTypes.has(property['valueType']) === false) {
-                        const violation = `"${objectType['name']}": property type "${property['valueType']}" is not defined in this file.`;
-                        violations.push(violation);
+                        const violation2 = `"${objectType['name']}": property type "${property['valueType']}" is not defined in this file.`;
+                        violations.push(violation2);
                         continue;
                     }
                     if (property['typeLineIndex'] > objectType['lineIndex']) {
-                        const violation = `"${objectType['name']}": property type "${property['valueType']}" (line ${property['typeLineIndex'] + 1}) must be defined before the object type (line ${objectType['lineIndex'] + 1}).`;
-                        violations.push(violation);
+                        const violation3 = `"${objectType['name']}": property type "${property['valueType']}" (line ${property['typeLineIndex'] + 1}) must be defined before the object type (line ${objectType['lineIndex'] + 1}).`;
+                        violations.push(violation3);
                     }
                 }
             }
+            const importedNames = extractImportedNames(lines);
+            const arrayTypes = extractArrayTypes(lines);
+            const typeDefLines = new Map();
+            for (let i = 0; i < lines.length; i += 1) {
+                const line2 = lines[i];
+                if (line2 === undefined) {
+                    continue;
+                }
+                const defMatch = line2.match(new RegExp('^export type (\\w+)'));
+                if (defMatch !== null
+                    && defMatch[1] !== undefined
+                    && typeDefLines.has(defMatch[1]) === false) {
+                    typeDefLines.set(defMatch[1], i);
+                }
+            }
+            for (const arrayType of arrayTypes) {
+                if (arrayType['arrayTypeName'].endsWith('Returns') === true
+                    || arrayType['arrayTypeName'].endsWith('_Returns') === true
+                    || arrayType['arrayTypeName'].endsWith('TypeGuard') === true
+                    || arrayType['arrayTypeName'].endsWith('_TypeGuard') === true
+                    || arrayType['arrayTypeName'].endsWith('Return') === true
+                    || arrayType['arrayTypeName'].endsWith('_Return') === true) {
+                    continue;
+                }
+                if (importedNames.has(arrayType['elementTypeName']) === true) {
+                    continue;
+                }
+                if (definedTypes.has(arrayType['elementTypeName']) === false) {
+                    continue;
+                }
+                const elementLine = typeDefLines.get(arrayType['elementTypeName']) ?? -1;
+                if (elementLine === -1) {
+                    continue;
+                }
+                if (elementLine > arrayType['lineIndex']) {
+                    const violation4 = `"${arrayType['arrayTypeName']}" (line ${arrayType['lineIndex'] + 1}): array element type "${arrayType['elementTypeName']}" (line ${elementLine + 1}) must be defined before the array type.`;
+                    violations.push(violation4);
+                }
+            }
             const violationMessage = violations.join('\n');
             strictEqual(violations.length, 0, violationMessage);
             return;
@@ -284,26 +542,73 @@ describe('type declaration section coverage', async () => {
                 }
             }
             const sourceContent = await readFile(sourcePath, 'utf-8');
-            const sourceLines = sourceContent.split('\n');
             const dtsContent = await readFile(file, 'utf-8');
             const dtsLines = dtsContent.split('\n');
-            const sourceSections = extractSourceSections(sourceLines);
-            const dtsSections = extractSections(dtsLines);
-            const dtsSectionPrefixes = dtsSections.map((section) => section['prefix']);
+            const classPrefix = deriveClassPrefix(file);
+            const sectionMap = buildSourceSectionMap(sourcePath, sourceContent, classPrefix);
+            const sourceSectionSet = new Set(sectionMap.values());
+            const dtsSections = buildDtsSections(dtsLines, sourceSectionSet, classPrefix);
+            const dtsSectionPrefixes = new Set(dtsSections.map((section) => section['prefix']));
             const violations = [];
-            for (const sourceSection of sourceSections) {
-                const sourceSectionPrefix = sourceSection['prefix'];
-                const isParent = sourceSections.some((otherSection) => {
-                    return otherSection['prefix'] !== sourceSectionPrefix && otherSection['prefix'].startsWith(sourceSectionPrefix) === true;
+            for (const sourceSectionPrefix of sourceSectionSet) {
+                if (sourceSectionPrefix === classPrefix) {
+                    continue;
+                }
+                const isParent = Array.from(sourceSectionSet).some((otherSection) => {
+                    return otherSection !== sourceSectionPrefix && otherSection.startsWith(`${sourceSectionPrefix}_`) === true;
                 });
                 if (isParent === true) {
                     continue;
                 }
-                if (dtsSectionPrefixes.includes(sourceSectionPrefix) === false) {
-                    const violation = `Source has section "${sourceSectionPrefix}" but .d.ts does not.`;
+                if (dtsSectionPrefixes.has(sourceSectionPrefix) === false) {
+                    const violation = `Source has section "${sourceSectionPrefix}" but .d.ts has no types belonging to it. Add an "export type" with that prefix, or remove the corresponding source identifier.`;
                     violations.push(violation);
                 }
             }
+            const singleChunkTopLevelTypes = new Set();
+            for (const line of dtsLines) {
+                if (line.startsWith('export type ') === false) {
+                    continue;
+                }
+                const singleChunkMatch = line.match(new RegExp('^export type (\\w+)'));
+                if (singleChunkMatch === null || singleChunkMatch[1] === undefined) {
+                    continue;
+                }
+                const singleChunkTypeName = singleChunkMatch[1];
+                if (singleChunkTypeName.startsWith(`${classPrefix}_`) === false) {
+                    continue;
+                }
+                const singleChunkAfterClassPrefix = singleChunkTypeName.slice(classPrefix.length + 1);
+                if (singleChunkAfterClassPrefix.includes('_') === false) {
+                    singleChunkTopLevelTypes.add(singleChunkTypeName);
+                }
+            }
+            for (const line of dtsLines) {
+                if (line.startsWith('export type ') === false) {
+                    continue;
+                }
+                const reverseMatch = line.match(new RegExp('^export type (\\w+)'));
+                if (reverseMatch === null || reverseMatch[1] === undefined) {
+                    continue;
+                }
+                const reverseTypeName = reverseMatch[1];
+                if (reverseTypeName.startsWith(`${classPrefix}_`) === false) {
+                    continue;
+                }
+                const reverseAfterClassPrefix = reverseTypeName.slice(classPrefix.length + 1);
+                const reverseChunks = reverseAfterClassPrefix.split('_');
+                if (reverseChunks.length <= 1) {
+                    continue;
+                }
+                const reverseExpectedMethodSection = `${classPrefix}_${reverseChunks[0]}`;
+                if (singleChunkTopLevelTypes.has(reverseExpectedMethodSection) === true) {
+                    continue;
+                }
+                if (sourceSectionSet.has(reverseExpectedMethodSection) === false) {
+                    const violation2 = `.d.ts type "${reverseTypeName}" expects source section "${reverseExpectedMethodSection}" but no class/method/function/(string, fn) call by that name exists in the source file. Fix options: (a) rename the .d.ts type to match an existing source section, (b) add a matching source identifier (class, method, top-level function, or function-typed const), or (c) add this file to testConfig.standaloneTypeFiles if the .d.ts is a domain type file with no source mirror.`;
+                    violations.push(violation2);
+                }
+            }
             const violationMessage = violations.join('\n');
             strictEqual(violations.length, 0, violationMessage);
             return;
@@ -311,159 +616,2411 @@ describe('type declaration section coverage', async () => {
     }
     return;
 });
-async function discoverTypeFiles() {
-    const patterns = testConfig['typeRoots'].map((typeRoot) => `${typeRoot}/types/**/*.d.ts`);
-    const matched = await glob(patterns, {
-        cwd: getPackageRoot(),
-        absolute: true,
-    });
-    return matched.sort();
-}
-function deriveClassPrefix(filePath) {
-    const currentDirectory = getPackageRoot();
-    const relativePath = relative(currentDirectory, filePath);
-    let relativeCleaned = relativePath;
-    for (const typeRoot of testConfig['typeRoots']) {
-        relativeCleaned = relativeCleaned.replace(`${typeRoot}/types/`, '');
-    }
-    const segments = relativeCleaned
-        .replace('.d.ts', '')
-        .replace('.test', '')
-        .split(sep)
-        .join('/')
-        .split('/');
-    return segments.map((segment) => {
-        return segment.split('-').map((part) => {
-            return part.charAt(0).toUpperCase() + part.slice(1);
-        }).join('');
-    }).join('');
-}
-function extractImportedNames(lines) {
-    const importedNames = new Set();
-    let inImportBlock = false;
-    for (const line of lines) {
-        if (line.startsWith('import type') === true) {
-            inImportBlock = true;
-            const inlineMatch = line.match(new RegExp('^import type \\{ (.+) \\} from'));
-            if (inlineMatch !== null && inlineMatch[1] !== undefined) {
-                const inlineMatchCapture = inlineMatch[1];
-                const specifiers = inlineMatchCapture.split(',').map((specifier) => specifier.trim());
-                for (const specifier of specifiers) {
-                    importedNames.add(specifier);
+describe('type declaration variable type symmetry', async () => {
+    const files = await discoverSourceFiles();
+    const symmetryCurrentDirectory = getPackageRoot();
+    for (const file of files) {
+        const symmetryRelativePath = relative(symmetryCurrentDirectory, file);
+        it(`variable type symmetry in ${symmetryRelativePath}`, async () => {
+            const content = await readFile(file, 'utf-8');
+            const lines = content.split('\n');
+            const classPrefix = deriveClassPrefix(file);
+            const sectionMap = buildSourceSectionMap(file, content, classPrefix);
+            const dtsPath = file.replace('/src/', '/src/types/').replace('.ts', '.d.ts');
+            const dtsExists = await fileExists(dtsPath);
+            const dtsContent = (dtsExists === true) ? await readFile(dtsPath, 'utf-8') : '';
+            const violations = [];
+            const inlineCallbacks = detectInlineTypedCallbacks(file, content);
+            for (const callback of inlineCallbacks) {
+                const violation = `${symmetryRelativePath}:${callback['lineNumber']}: rule 7.4 violation: inline typed callback param "${callback['paramName']}: ${callback['typeName']}" is forbidden. Extract the callback to a named const so it follows rule 7.1.`;
+                violations.push(violation);
+            }
+            const bodyDecls = extractBodyDeclarations(lines);
+            const expectedNames = [];
+            for (const decl of bodyDecls) {
+                const sourceSection = sectionMap.get(decl['lineNumber']) ?? classPrefix;
+                if (isReservedSuffix(decl['typeName']) === true) {
+                    const violation2 = `${symmetryRelativePath}:${decl['lineNumber']}: rule 7.3 violation: body var "${decl['varName']}: ${decl['typeName']}" uses a return-position-only suffix (Returns/TypeGuard/Return). Use a different type name without that suffix.`;
+                    violations.push(violation2);
+                    continue;
                 }
-                inImportBlock = false;
+                const leafResult = validateLeaf(decl['varName'], decl['typeName'], sourceSection, classPrefix);
+                if (leafResult !== null) {
+                    const violation3 = `${symmetryRelativePath}:${decl['lineNumber']}: rule 7.1 violation: body var "${decl['varName']}: ${decl['typeName']}" — expected leaf "${leafResult['expectedLeaf']}" but found "${leafResult['actualLeaf']}". Rename the type to "${sourceSection}_${leafResult['expectedLeaf']}" or "${classPrefix}_${leafResult['expectedLeaf']}".`;
+                    violations.push(violation3);
+                }
+                if (dtsExists === true) {
+                    if (isLocallyDefined(decl['typeName'], dtsContent) === false) {
+                        const relativeDtsPath = dtsPath.replace(symmetryCurrentDirectory, '');
+                        const cleanedDtsPath = (relativeDtsPath.startsWith('/') === true) ? relativeDtsPath.slice(1) : relativeDtsPath;
+                        const violation4 = `${symmetryRelativePath}:${decl['lineNumber']}: rule 7.2 violation: body var type "${decl['typeName']}" is not defined in the corresponding .d.ts. Cross-module body-var types are forbidden -- define the type concretely in ${cleanedDtsPath}, or promote the shape to shared.d.ts, or skip the typed body var.`;
+                        violations.push(violation4);
+                    }
+                    else if (isAliasToForeignType(decl['typeName'], dtsContent, classPrefix) === true) {
+                        const relativeDtsPath2 = dtsPath.replace(symmetryCurrentDirectory, '');
+                        const cleanedDtsPath2 = (relativeDtsPath2.startsWith('/') === true) ? relativeDtsPath2.slice(1) : relativeDtsPath2;
+                        const violation5 = `${symmetryRelativePath}:${decl['lineNumber']}: rule 7.2 violation: body var type "${decl['typeName']}" is locally defined but only as an alias to a foreign type. Cross-module body-var types are forbidden -- escape hatches: (a) promote the shape to shared.d.ts, (b) redefine the concrete shape in ${cleanedDtsPath2}, or (c) inline the call to skip the typed body var.`;
+                        violations.push(violation5);
+                    }
+                }
+                const stripped = stripUnderscorePrefix(decl['varName']);
+                const titleVar = stripped.charAt(0).toUpperCase() + stripped.slice(1);
+                expectedNames.push({
+                    name: decl['varName'],
+                    typeName: `${sourceSection}_${titleVar}`,
+                    lineNumber: decl['lineNumber'],
+                });
             }
-            continue;
-        }
-        if (inImportBlock === true) {
-            const trimmed = line.trim().replace(',', '');
-            if (trimmed.startsWith('}') === true) {
-                inImportBlock = false;
+            const params = extractFunctionParams(file, content);
+            for (const param of params) {
+                const sourceSection2 = sectionMap.get(param['lineNumber']) ?? classPrefix;
+                if (isReservedSuffix(param['typeName']) === true) {
+                    const violation6 = `${symmetryRelativePath}:${param['lineNumber']}: rule 7.3 violation: param "${param['paramName']}: ${param['typeName']}" uses a return-position-only suffix (Returns/TypeGuard/Return). Use a different type name without that suffix.`;
+                    violations.push(violation6);
+                    continue;
+                }
+                const leafResult2 = validateLeaf(param['paramName'], param['typeName'], sourceSection2, classPrefix);
+                if (leafResult2 !== null) {
+                    const violation7 = `${symmetryRelativePath}:${param['lineNumber']}: rule 7.1 violation: param "${param['paramName']}: ${param['typeName']}" — expected leaf "${leafResult2['expectedLeaf']}" but found "${leafResult2['actualLeaf']}". Rename the type to "${sourceSection2}_${leafResult2['expectedLeaf']}" or "${classPrefix}_${leafResult2['expectedLeaf']}".`;
+                    violations.push(violation7);
+                }
+                const stripped2 = stripUnderscorePrefix(param['paramName']);
+                const titleVar2 = stripped2.charAt(0).toUpperCase() + stripped2.slice(1);
+                expectedNames.push({
+                    name: param['paramName'],
+                    typeName: `${sourceSection2}_${titleVar2}`,
+                    lineNumber: param['lineNumber'],
+                });
             }
-            else if (trimmed !== '' && trimmed.startsWith('//') === false) {
-                importedNames.add(trimmed);
+            const fnReturnRecords = extractFunctionReturns(file, content);
+            for (const ret of fnReturnRecords) {
+                const returnValidationReason = validateReturnType(ret['returnType'], ret['isTypeGuard']);
+                if (returnValidationReason !== null) {
+                    const violation8 = `${symmetryRelativePath}:${ret['lineNumber']}: rule 7.5/7.6/7.7 violation: ${returnValidationReason}`;
+                    violations.push(violation8);
+                }
             }
-        }
-    }
-    return importedNames;
-}
-function extractSections(lines) {
-    const sections = [];
-    let currentSection = undefined;
-    for (let i = 0; i < lines.length; i += 1) {
-        const line = lines[i];
-        if (line === undefined) {
-            continue;
-        }
-        const sectionComment = line.match(new RegExp('^ \\* (.+)\\.$'));
-        if (sectionComment !== null
-            && sectionComment[1] !== undefined
-            && line.includes('@') === false) {
-            const rawPrefix = sectionComment[1];
-            const segments = rawPrefix.split(' - ');
-            const methodName = segments.map((segment) => {
-                return segment.split(new RegExp('[\\s.]+', 'g')).map((word) => {
-                    return word.charAt(0).toUpperCase() + word.slice(1).toLowerCase();
-                }).join('');
-            }).join('');
-            if (currentSection !== undefined) {
-                sections.push(currentSection);
+            const uniquenessViolations = checkTypeNameUniqueness(expectedNames);
+            for (const uniquenessViolation of uniquenessViolations) {
+                const violation9 = `${symmetryRelativePath}: rule 7.8 violation: ${uniquenessViolation}`;
+                violations.push(violation9);
             }
-            currentSection = {
-                prefix: methodName,
-                typeLines: [],
-            };
-            continue;
-        }
-        if (currentSection !== undefined && line.startsWith('export type ') === true) {
-            currentSection['typeLines'].push(line);
-        }
-    }
-    if (currentSection !== undefined) {
-        sections.push(currentSection);
-    }
-    return sections;
-}
-function extractReferencedTypes(line, classPrefix) {
-    const match = line.match(new RegExp('^export type (\\w+)'));
-    if (match === null || match[1] === undefined) {
-        return [];
-    }
-    const typeName = match[1];
-    const rightSide = line.slice(line.indexOf('=') + 1);
-    const referencedTypes = [];
-    const typePattern = new RegExp(`${classPrefix}\\w+`, 'g');
-    let typeMatch = typePattern.exec(rightSide);
-    while (typeMatch !== null) {
-        const referencedType = typeMatch[0];
-        if (referencedType !== typeName) {
-            referencedTypes.push(referencedType);
-        }
-        typeMatch = typePattern.exec(rightSide);
+            const violationMessage = violations.join('\n');
+            strictEqual(violations.length, 0, violationMessage);
+            return;
+        });
     }
-    return referencedTypes;
-}
-function deriveSourcePath(dtsPath) {
-    return dtsPath.replace('/types/', '/').replace('.d.ts', '.ts');
-}
-async function fileExists(filePath) {
-    try {
-        await readFile(filePath, 'utf-8');
-        return true;
+    return;
+});
+describe('type declaration identifier vs file name', async () => {
+    const files = await discoverSourceFiles();
+    const identifierVsFileNameCurrentDirectory = getPackageRoot();
+    for (const file of files) {
+        const identifierVsFileNameRelativePath = relative(identifierVsFileNameCurrentDirectory, file);
+        it(`top-level identifiers in ${identifierVsFileNameRelativePath} do not equal file name`, async () => {
+            const content = await readFile(file, 'utf-8');
+            const classPrefix = deriveClassPrefix(file);
+            const segments = classPrefix.split('_');
+            const fileName = segments[segments.length - 1] ?? '';
+            const identifiers = extractTopLevelIdentifiers(file, content);
+            const violations = [];
+            for (const identifier of identifiers) {
+                if (identifier['name'] === fileName) {
+                    const violation = `${identifierVsFileNameRelativePath}:${identifier['lineNumber']}: rule C1/C2/C3 violation: top-level ${identifier['kind']} name "${identifier['name']}" equals file name "${fileName}". Rename the ${identifier['kind']} (use a barrel re-export if consumers need to import the file-name as the public name).`;
+                    violations.push(violation);
+                }
+            }
+            const violationMessage = violations.join('\n');
+            strictEqual(violations.length, 0, violationMessage);
+            return;
+        });
     }
-    catch {
-        return false;
+    return;
+});
+describe('type declaration filename validation', async () => {
+    const sourceFiles = await discoverSourceFiles();
+    const dtsFiles = await discoverTypeFiles();
+    const allFiles = [
+        ...sourceFiles,
+        ...dtsFiles,
+    ];
+    const filenameValidationCurrentDirectory = getPackageRoot();
+    for (const file of allFiles) {
+        const filenameValidationRelativePath = relative(filenameValidationCurrentDirectory, file);
+        it(`filename and path segments in ${filenameValidationRelativePath} are valid`, () => {
+            let cleaned = filenameValidationRelativePath;
+            for (const typeRoot of testConfig['typeRoots']) {
+                cleaned = cleaned.replace(`${typeRoot}/types/`, '');
+                cleaned = cleaned.replace(`${typeRoot}/`, '');
+            }
+            cleaned = cleaned.replace(new RegExp('\\.d\\.ts$'), '');
+            cleaned = cleaned.replace(new RegExp('\\.d\\.mts$'), '');
+            cleaned = cleaned.replace(new RegExp('\\.d\\.cts$'), '');
+            cleaned = cleaned.replace(new RegExp('\\.tsx$'), '');
+            cleaned = cleaned.replace(new RegExp('\\.ts$'), '');
+            cleaned = cleaned.replace(new RegExp('\\.mts$'), '');
+            cleaned = cleaned.replace(new RegExp('\\.cts$'), '');
+            cleaned = cleaned.replace(new RegExp('\\.jsx$'), '');
+            cleaned = cleaned.replace(new RegExp('\\.js$'), '');
+            cleaned = cleaned.replace(new RegExp('\\.mjs$'), '');
+            cleaned = cleaned.replace(new RegExp('\\.cjs$'), '');
+            cleaned = cleaned.replace(new RegExp('\\.test$'), '');
+            const segments = cleaned.split(sep).join('/').split('/').filter((segment) => segment.length > 0);
+            const pattern = new RegExp('^[a-z][a-z0-9-]*$');
+            const pascalCasePattern = new RegExp('^[A-Z][A-Za-z0-9]*$');
+            const violations = [];
+            for (const segment of segments) {
+                const matchesKebab = pattern.test(segment);
+                const matchesPascal = pascalCasePattern.test(segment);
+                if (matchesKebab === false && matchesPascal === false) {
+                    const violation = `${filenameValidationRelativePath}: invalid path segment "${segment}". Path segments must be kebab-case (/^[a-z][a-z0-9-]*$/) or PascalCase (/^[A-Z][A-Za-z0-9]*$/). Recognized strippable suffixes: .d.ts, .d.mts, .d.cts, .tsx, .ts, .mts, .cts, .jsx, .js, .mjs, .cjs, .test. Underscores, dots, spaces, camelCase, and leading digits are rejected.`;
+                    violations.push(violation);
+                }
+            }
+            const violationMessage = violations.join('\n');
+            strictEqual(violations.length, 0, violationMessage);
+            return;
+        });
     }
-}
-function getPackageRoot() {
-    const currentFilePath = fileURLToPath(import.meta.url);
-    const currentFileDirectory = dirname(currentFilePath);
-    return resolve(currentFileDirectory, '..', '..');
-}
-function extractTypeNames(typeLines) {
-    const typeNames = [];
-    for (const line of typeLines) {
-        const match = line.match(new RegExp('^export type (\\w+)'));
-        if (match !== null && match[1] !== undefined) {
-            typeNames.push(match[1]);
+    return;
+});
+describe('type declaration standalone type files', async () => {
+    const standaloneSourceFiles = await discoverSourceFiles();
+    const standaloneDtsFiles = await discoverTypeFiles();
+    const topLevelPathPrefixes = new Set();
+    for (const sourceFile of standaloneSourceFiles) {
+        const sourceClassPrefix = deriveClassPrefix(sourceFile);
+        const firstChunk = sourceClassPrefix.split('_')[0];
+        if (firstChunk !== undefined && firstChunk !== '') {
+            topLevelPathPrefixes.add(firstChunk);
         }
     }
-    return typeNames;
-}
-function findFirstOccurrence(sourceLines, typeName) {
-    let inImportBlock = false;
-    for (let i = 0; i < sourceLines.length; i += 1) {
-        const line = sourceLines[i];
-        if (line === undefined) {
-            continue;
-        }
-        if (line.startsWith('import ') === true || line.startsWith('import type') === true) {
-            inImportBlock = true;
-        }
-        if (inImportBlock === true) {
-            if (line.includes(' from ') === true) {
-                inImportBlock = false;
-            }
+    const standaloneFiles = standaloneDtsFiles.filter((dtsFile) => testConfig['standaloneTypeFiles'].some((pattern) => dtsFile.endsWith(pattern)));
+    const standaloneCurrentDirectory = getPackageRoot();
+    for (const file of standaloneFiles) {
+        const standaloneRelativePath = relative(standaloneCurrentDirectory, file);
+        it(`standalone file rules in ${standaloneRelativePath}`, async () => {
+            const content = await readFile(file, 'utf-8');
+            const lines = content.split('\n');
+            const typeLines = lines.filter((line) => line.startsWith('export type '));
+            const typeNames = extractTypeNames(typeLines);
+            const localTypeSet = new Set(typeNames);
+            const primitiveSet = new Set([
+                'string',
+                'number',
+                'boolean',
+                'unknown',
+                'never',
+                'void',
+                'null',
+                'undefined',
+                'any',
+                'object',
+                'symbol',
+                'bigint',
+            ]);
+            const pascalCasePattern = new RegExp('^[A-Z][A-Za-z0-9]*(_[A-Z][A-Za-z0-9]*)*$');
+            const brandCasePattern = new RegExp('[A-Z]{3,}');
+            const violations = [];
+            for (const typeName of typeNames) {
+                if (pascalCasePattern.test(typeName) === false) {
+                    const violation = `${standaloneRelativePath}: rule S1 violation: type "${typeName}" is not PascalCase. Standalone-file types must be PascalCase, optionally underscore-separated for nested properties (e.g., EntryItem, EntryItem_Category).`;
+                    violations.push(violation);
+                    continue;
+                }
+                if (brandCasePattern.test(typeName) === true) {
+                    const violation2 = `${standaloneRelativePath}: rule S1 violation: type "${typeName}" uses brand casing (3+ consecutive uppercase letters). Use Pascal-cased acronyms instead (e.g., Url, Api, Cli — not URL, API, CLI).`;
+                    violations.push(violation2);
+                }
+            }
+            for (const typeName of typeNames) {
+                for (const pathPrefix of topLevelPathPrefixes) {
+                    if (typeName.startsWith(`${pathPrefix}_`) === true) {
+                        const violation3 = `${standaloneRelativePath}: rule S2 violation: type "${typeName}" looks like a path-prefix-style name (starts with "${pathPrefix}_" — a known source-file top-level segment). Standalone-file types must be domain concepts, not path-derived.`;
+                        violations.push(violation3);
+                        break;
+                    }
+                }
+            }
+            const objectTypes = extractObjectTypes(lines, '');
+            for (const objectType of objectTypes) {
+                const expectedPropertyPrefix = `${objectType['name']}_`;
+                for (const property of objectType['properties']) {
+                    if (primitiveSet.has(property['valueType']) === true) {
+                        continue;
+                    }
+                    if (localTypeSet.has(property['valueType']) === false) {
+                        continue;
+                    }
+                    if (property['valueType'].startsWith(expectedPropertyPrefix) === false) {
+                        const violation4 = `${standaloneRelativePath}: rule S3 violation: object type "${objectType['name']}" property "${property['key']}" uses local type "${property['valueType']}" which does not start with "${expectedPropertyPrefix}". Add an intermediate alias (e.g., "${expectedPropertyPrefix}${property['key'].charAt(0).toUpperCase() + property['key'].slice(1)} = ${property['valueType']};") to use the Parent_Property nesting form.`;
+                        violations.push(violation4);
+                    }
+                }
+            }
+            const arrayTypes = extractArrayTypes(lines);
+            const typePositions = new Map();
+            for (let i = 0; i < lines.length; i += 1) {
+                const lineToScan = lines[i];
+                if (lineToScan === undefined) {
+                    continue;
+                }
+                const positionMatch = lineToScan.match(new RegExp('^export type (\\w+)'));
+                if (positionMatch !== null
+                    && positionMatch[1] !== undefined
+                    && typePositions.has(positionMatch[1]) === false) {
+                    typePositions.set(positionMatch[1], i);
+                }
+            }
+            for (const arrayType of arrayTypes) {
+                const elementLine = typePositions.get(arrayType['elementTypeName']) ?? -1;
+                if (elementLine === -1) {
+                    continue;
+                }
+                if (elementLine >= arrayType['lineIndex']) {
+                    const violation5 = `${standaloneRelativePath}:${arrayType['lineIndex'] + 1}: rule S4 violation: array type "${arrayType['arrayTypeName']}" defined before its element type "${arrayType['elementTypeName']}" (element at line ${elementLine + 1}). Define element types before arrays.`;
+                    violations.push(violation5);
+                }
+            }
+            const violationMessage = violations.join('\n');
+            strictEqual(violations.length, 0, violationMessage);
+            return;
+        });
+    }
+    return;
+});
+describe('parseDescribeString comprehensive', () => {
+    it('returns empty string for purely non-alphanumeric input', () => {
+        strictEqual(parseDescribeString('!@#$%^&*()'), '');
+        return;
+    });
+    it('handles digits-only input by preserving the digit run', () => {
+        strictEqual(parseDescribeString('123abc'), '123abc');
+        return;
+    });
+    it('parses path-style /users into Users', () => {
+        strictEqual(parseDescribeString('/users'), 'Users');
+        return;
+    });
+    it('joins multiple non-alphanumeric separators', () => {
+        strictEqual(parseDescribeString('foo.bar-baz/qux'), 'FooBarBazQux');
+        return;
+    });
+    it('preserves CamelCase parts within a piece', () => {
+        strictEqual(parseDescribeString('CliUtility runner'), 'CliUtilityRunner');
+        return;
+    });
+    it('handles single character', () => {
+        strictEqual(parseDescribeString('a'), 'A');
+        return;
+    });
+    it('handles empty string', () => {
+        strictEqual(parseDescribeString(''), '');
+        return;
+    });
+    it('handles unicode by treating non-ASCII letters as separators', () => {
+        strictEqual(parseDescribeString('fooébar'), 'FooBar');
+        return;
+    });
+    return;
+});
+describe('stripUnderscorePrefix comprehensive', () => {
+    it('strips a single leading underscore', () => {
+        strictEqual(stripUnderscorePrefix('_prev'), 'prev');
+        return;
+    });
+    it('preserves only-underscore input as empty', () => {
+        strictEqual(stripUnderscorePrefix('_'), '');
+        return;
+    });
+    it('does not strip non-prefix underscores', () => {
+        strictEqual(stripUnderscorePrefix('foo_bar'), 'foo_bar');
+        return;
+    });
+    it('does not strip when input has no underscore', () => {
+        strictEqual(stripUnderscorePrefix('plain'), 'plain');
+        return;
+    });
+    it('strips only the first underscore', () => {
+        strictEqual(stripUnderscorePrefix('__double'), '_double');
+        return;
+    });
+    return;
+});
+describe('isReservedSuffix comprehensive', () => {
+    it('detects underscore-separated _Returns', () => {
+        strictEqual(isReservedSuffix('Foo_Bar_Returns'), true);
+        return;
+    });
+    it('detects glued Returns', () => {
+        strictEqual(isReservedSuffix('FooBarReturns'), true);
+        return;
+    });
+    it('detects underscore-separated _TypeGuard', () => {
+        strictEqual(isReservedSuffix('Foo_Bar_TypeGuard'), true);
+        return;
+    });
+    it('detects glued TypeGuard', () => {
+        strictEqual(isReservedSuffix('FooBarTypeGuard'), true);
+        return;
+    });
+    it('detects underscore-separated _Return (singular)', () => {
+        strictEqual(isReservedSuffix('Foo_Bar_Return'), true);
+        return;
+    });
+    it('detects glued Return (singular)', () => {
+        strictEqual(isReservedSuffix('FooBarReturn'), true);
+        return;
+    });
+    it('does not match Result', () => {
+        strictEqual(isReservedSuffix('Foo_Bar_Result'), false);
+        return;
+    });
+    it('does not match Returnable (false suffix)', () => {
+        strictEqual(isReservedSuffix('Foo_Bar_Returnable'), false);
+        return;
+    });
+    it('does not match TypeGuardian (false suffix)', () => {
+        strictEqual(isReservedSuffix('Foo_TypeGuardian'), false);
+        return;
+    });
+    it('does match Reborn -- banned because endsWith Return matches the substring', () => {
+        strictEqual(isReservedSuffix('Reborn'), false);
+        return;
+    });
+    return;
+});
+describe('validateLeaf comprehensive', () => {
+    it('returns null when leaf matches sourceSection_titleVar', () => {
+        const reasonResult = validateLeaf('items', 'Cli_Foo_Run_Items', 'Cli_Foo_Run', 'Cli_Foo');
+        strictEqual(reasonResult, null);
+        return;
+    });
+    it('returns null when leaf matches classPrefix_titleVar (passthrough)', () => {
+        const reasonResult = validateLeaf('items', 'Cli_Foo_Items', 'Cli_Foo_Run', 'Cli_Foo');
+        strictEqual(reasonResult, null);
+        return;
+    });
+    it('returns reason when leaf does not match', () => {
+        const reasonResult = validateLeaf('items', 'Cli_Foo_Run_Things', 'Cli_Foo_Run', 'Cli_Foo');
+        deepStrictEqual(reasonResult, {
+            actualLeaf: 'Things', expectedLeaf: 'Items',
+        });
+        return;
+    });
+    it('strips underscore prefix from var name before comparison', () => {
+        const reasonResult = validateLeaf('_prev', 'Cli_Foo_Run_Prev', 'Cli_Foo_Run', 'Cli_Foo');
+        strictEqual(reasonResult, null);
+        return;
+    });
+    it('handles single-character var name', () => {
+        const reasonResult = validateLeaf('i', 'Cli_Foo_Run_I', 'Cli_Foo_Run', 'Cli_Foo');
+        strictEqual(reasonResult, null);
+        return;
+    });
+    it('returns the actualLeaf when typeName starts with sourceSection but leaf differs', () => {
+        const reasonResult = validateLeaf('items', 'Cli_Foo_Run_Things', 'Cli_Foo_Run', 'Cli_Foo');
+        deepStrictEqual(reasonResult, {
+            actualLeaf: 'Things', expectedLeaf: 'Items',
+        });
+        return;
+    });
+    it('returns the actualLeaf when typeName starts with classPrefix passthrough but leaf differs', () => {
+        const reasonResult = validateLeaf('items', 'Cli_Foo_Things', 'Cli_Foo_Run', 'Cli_Foo');
+        deepStrictEqual(reasonResult, {
+            actualLeaf: 'Things', expectedLeaf: 'Items',
+        });
+        return;
+    });
+    it('returns full typeName as actualLeaf when no prefix matches', () => {
+        const reasonResult = validateLeaf('items', 'Foreign_Type', 'Cli_Foo_Run', 'Cli_Foo');
+        deepStrictEqual(reasonResult, {
+            actualLeaf: 'Foreign_Type', expectedLeaf: 'Items',
+        });
+        return;
+    });
+    return;
+});
+describe('validateReturnType comprehensive', () => {
+    it('passes _Returns at non-type-guard return', () => {
+        strictEqual(validateReturnType('Foo_Bar_Returns', false), null);
+        return;
+    });
+    it('passes Returns at non-type-guard return', () => {
+        strictEqual(validateReturnType('FooBarReturns', false), null);
+        return;
+    });
+    it('passes _TypeGuard at type-guard return', () => {
+        strictEqual(validateReturnType('Foo_Bar_TypeGuard', true), null);
+        return;
+    });
+    it('passes TypeGuard at type-guard return', () => {
+        strictEqual(validateReturnType('FooBarTypeGuard', true), null);
+        return;
+    });
+    it('rejects singular _Return at any return position (rule 7.6)', () => {
+        ok((validateReturnType('Foo_Bar_Return', false) ?? '').includes('singular'));
+        return;
+    });
+    it('rejects glued Return at any return position', () => {
+        ok((validateReturnType('FooBarReturn', false) ?? '').includes('singular'));
+        return;
+    });
+    it('rejects non-Returns at non-type-guard (rule 7.5)', () => {
+        ok((validateReturnType('Foo_Bar_Result', false) ?? '').includes('Returns'));
+        return;
+    });
+    it('rejects TypeGuard at non-type-guard return position (rule 7.7)', () => {
+        ok((validateReturnType('Foo_Bar_TypeGuard', false) ?? '').includes('value is T'));
+        return;
+    });
+    it('rejects non-TypeGuard at type-guard position (rule 7.7)', () => {
+        ok((validateReturnType('Foo_Bar_Returns', true) ?? '').includes('TypeGuard'));
+        return;
+    });
+    it('rejects Result at type-guard position', () => {
+        ok((validateReturnType('Foo_Bar_Result', true) ?? '').includes('TypeGuard'));
+        return;
+    });
+    return;
+});
+describe('isLocallyDefined comprehensive', () => {
+    it('returns true for export type X = ...;', () => {
+        const dtsContent = 'export type Cli_Foo_Bar = string;\n';
+        strictEqual(isLocallyDefined('Cli_Foo_Bar', dtsContent), true);
+        return;
+    });
+    it('returns false for missing type', () => {
+        const dtsContent = 'export type Cli_Foo_Bar = string;\n';
+        strictEqual(isLocallyDefined('Cli_Foo_NotThere', dtsContent), false);
+        return;
+    });
+    it('only matches at line start with export type prefix', () => {
+        const dtsContent = '// some comment about Cli_Foo_Bar\n';
+        strictEqual(isLocallyDefined('Cli_Foo_Bar', dtsContent), false);
+        return;
+    });
+    it('matches with word boundary (does not partial-match)', () => {
+        const dtsContent = 'export type Cli_Foo_BarExtended = string;\n';
+        strictEqual(isLocallyDefined('Cli_Foo_Bar', dtsContent), false);
+        return;
+    });
+    it('handles type defined at end of file without trailing newline', () => {
+        const dtsContent = 'export type Cli_Foo_Bar = string;';
+        strictEqual(isLocallyDefined('Cli_Foo_Bar', dtsContent), true);
+        return;
+    });
+    return;
+});
+describe('isAliasToForeignType comprehensive', () => {
+    it('detects direct alias to a foreign-prefix type', () => {
+        const dtsContent = 'export type Cli_Foo_Run_Data = Lib_Utility_FetchData_Returns;\n';
+        strictEqual(isAliasToForeignType('Cli_Foo_Run_Data', dtsContent, 'Cli_Foo'), true);
+        return;
+    });
+    it('does not flag alias to same-prefix type', () => {
+        const dtsContent = 'export type Cli_Foo_Run_Data = Cli_Foo_Helper_Result;\n';
+        strictEqual(isAliasToForeignType('Cli_Foo_Run_Data', dtsContent, 'Cli_Foo'), false);
+        return;
+    });
+    it('does not flag concrete object shape', () => {
+        const dtsContent = 'export type Cli_Foo_Run_Data = { name: string; version: string };\n';
+        strictEqual(isAliasToForeignType('Cli_Foo_Run_Data', dtsContent, 'Cli_Foo'), false);
+        return;
+    });
+    it('does not flag primitive alias', () => {
+        const dtsContent = 'export type Cli_Foo_Run_Data = string;\n';
+        strictEqual(isAliasToForeignType('Cli_Foo_Run_Data', dtsContent, 'Cli_Foo'), false);
+        return;
+    });
+    it('does not flag union types', () => {
+        const dtsContent = 'export type Cli_Foo_Run_Data = Lib_Utility_X | null;\n';
+        strictEqual(isAliasToForeignType('Cli_Foo_Run_Data', dtsContent, 'Cli_Foo'), false);
+        return;
+    });
+    it('handles array form: alias to foreign[]', () => {
+        const dtsContent = 'export type Cli_Foo_Run_Data = Lib_Utility_X[];\n';
+        strictEqual(isAliasToForeignType('Cli_Foo_Run_Data', dtsContent, 'Cli_Foo'), true);
+        return;
+    });
+    it('strips generics before checking', () => {
+        const dtsContent = 'export type Cli_Foo_Run_Data = Promise<Lib_Utility_X>;\n';
+        strictEqual(isAliasToForeignType('Cli_Foo_Run_Data', dtsContent, 'Cli_Foo'), false);
+        return;
+    });
+    it('does not flag unprefixed PascalCase type', () => {
+        const dtsContent = 'export type Cli_Foo_Run_Data = SomeType;\n';
+        strictEqual(isAliasToForeignType('Cli_Foo_Run_Data', dtsContent, 'Cli_Foo'), false);
+        return;
+    });
+    it('returns false when type not present in dts', () => {
+        const dtsContent = '\n';
+        strictEqual(isAliasToForeignType('Cli_Foo_Run_Data', dtsContent, 'Cli_Foo'), false);
+        return;
+    });
+    return;
+});
+describe('buildSourceSectionMap comprehensive', () => {
+    it('class declaration adds class name as a chunk (Mode 2)', () => {
+        const sectionMap = buildSourceSectionMap('/fake/cli/foo.ts', [
+            'class Runner {',
+            '  public bar(): void {}',
+            '}',
+            '',
+        ].join('\n'), 'Cli_Foo');
+        strictEqual(sectionMap.get(1), 'Cli_Foo_Runner');
+        strictEqual(sectionMap.get(2), 'Cli_Foo_Runner_Bar');
+        return;
+    });
+    it('anonymous class declaration (default export without name) does NOT add chunk', () => {
+        const sectionMap = buildSourceSectionMap('/fake/cli/foo.ts', 'export default class {}\n', 'Cli_Foo');
+        strictEqual(sectionMap.get(1), 'Cli_Foo');
+        return;
+    });
+    it('constructor adds Constructor chunk', () => {
+        const sectionMap = buildSourceSectionMap('/fake/cli/foo.ts', [
+            'class Runner {',
+            '  constructor(name: string) {}',
+            '}',
+            '',
+        ].join('\n'), 'Cli_Foo');
+        strictEqual(sectionMap.get(2), 'Cli_Foo_Runner_Constructor');
+        return;
+    });
+    it('method declaration adds method chunk', () => {
+        const sectionMap = buildSourceSectionMap('/fake/cli/foo.ts', [
+            'class Runner {',
+            '  public addRow(): void {}',
+            '}',
+            '',
+        ].join('\n'), 'Cli_Foo');
+        strictEqual(sectionMap.get(2), 'Cli_Foo_Runner_AddRow');
+        return;
+    });
+    it('private # method strips # and adds chunk', () => {
+        const sectionMap = buildSourceSectionMap('/fake/cli/foo.ts', [
+            'class Runner {',
+            '  #helper(): void {}',
+            '}',
+            '',
+        ].join('\n'), 'Cli_Foo');
+        strictEqual(sectionMap.get(2), 'Cli_Foo_Runner_Helper');
+        return;
+    });
+    it('top-level function declaration adds function chunk', () => {
+        const sectionMap = buildSourceSectionMap('/fake/lib/utility.ts', [
+            'function getCurrentTimestamp(): number {',
+            '  return Date.now();',
+            '}',
+            '',
+        ].join('\n'), 'Lib_Utility');
+        strictEqual(sectionMap.get(1), 'Lib_Utility_GetCurrentTimestamp');
+        return;
+    });
+    it('top-level function-typed const adds const chunk', () => {
+        const sectionMap = buildSourceSectionMap('/fake/lib/utility.ts', [
+            'const formatRow = (row: string[]) => {',
+            '  return row.join(\'|\');',
+            '};',
+            '',
+        ].join('\n'), 'Lib_Utility');
+        strictEqual(sectionMap.get(2), 'Lib_Utility_FormatRow');
+        return;
+    });
+    it('function expression const adds chunk', () => {
+        const sectionMap = buildSourceSectionMap('/fake/lib/utility.ts', [
+            'const handler = function (x: number) {',
+            '  return x;',
+            '};',
+            '',
+        ].join('\n'), 'Lib_Utility');
+        strictEqual(sectionMap.get(2), 'Lib_Utility_Handler');
+        return;
+    });
+    it('nested function declaration adds chunk under outer', () => {
+        const sectionMap = buildSourceSectionMap('/fake/lib/utility.ts', [
+            'function process() {',
+            '  function visit() {',
+            '    const x: number = 1;',
+            '  }',
+            '}',
+            '',
+        ].join('\n'), 'Lib_Utility');
+        strictEqual(sectionMap.get(3), 'Lib_Utility_Process_Visit');
+        return;
+    });
+    it('generic (string, fn) call adds chunk via parseDescribeString', () => {
+        const sectionMap = buildSourceSectionMap('/fake/cli/server.ts', [
+            'function start() {',
+            '  app.get(\'/users\', (req, res) => {',
+            '    const x: number = 1;',
+            '  });',
+            '}',
+            '',
+        ].join('\n'), 'Cli_Server');
+        strictEqual(sectionMap.get(3), 'Cli_Server_Start_Users');
+        return;
+    });
+    it('describe call adds chunk via generic (string, fn)', () => {
+        const sectionMap = buildSourceSectionMap('/fake/tests/foo.test.ts', [
+            'describe(\'Foo\', () => {',
+            '  const x: number = 1;',
+            '});',
+            '',
+        ].join('\n'), 'Tests_Foo');
+        strictEqual(sectionMap.get(2), 'Tests_Foo_Foo');
+        return;
+    });
+    it('it call adds chunk via generic (string, fn)', () => {
+        const sectionMap = buildSourceSectionMap('/fake/tests/foo.test.ts', [
+            'describe(\'Foo\', () => {',
+            '  it(\'does something\', () => {',
+            '    const x: number = 1;',
+            '  });',
+            '});',
+            '',
+        ].join('\n'), 'Tests_Foo');
+        strictEqual(sectionMap.get(3), 'Tests_Foo_Foo_DoesSomething');
+        return;
+    });
+    it('template string in (string, fn) does NOT add chunk (EC23)', () => {
+        const interp = [
+            '$',
+            '{',
+            '1}',
+        ].join('');
+        const sourceContent = [
+            'describe(\'Foo\', () => {',
+            `  it(\`test ${interp}\`, () => {`,
+            '    const x: number = 1;',
+            '  });',
+            '});',
+            '',
+        ].join('\n');
+        const sectionMap = buildSourceSectionMap('/fake/tests/foo.test.ts', sourceContent, 'Tests_Foo');
+        strictEqual(sectionMap.get(3), 'Tests_Foo_Foo');
+        return;
+    });
+    it('variable in (string, fn) arg[0] does NOT add chunk (EC23)', () => {
+        const sectionMap = buildSourceSectionMap('/fake/tests/foo.test.ts', [
+            'const name = \'Foo\';',
+            'describe(name, () => {',
+            '  const x: number = 1;',
+            '});',
+            '',
+        ].join('\n'), 'Tests_Foo');
+        strictEqual(sectionMap.get(3), 'Tests_Foo');
+        return;
+    });
+    it('async arrow function callback in (string, fn) works (EC24)', () => {
+        const sectionMap = buildSourceSectionMap('/fake/tests/foo.test.ts', [
+            'describe(\'Foo\', async () => {',
+            '  const x: number = 1;',
+            '});',
+            '',
+        ].join('\n'), 'Tests_Foo');
+        strictEqual(sectionMap.get(2), 'Tests_Foo_Foo');
+        return;
+    });
+    it('multiple top-level classes each add their own chunk (EC1)', () => {
+        const sectionMap = buildSourceSectionMap('/fake/cli/multi.ts', [
+            'class Foo {',
+            '  process(): void {}',
+            '}',
+            'class Bar {',
+            '  process(): void {}',
+            '}',
+            '',
+        ].join('\n'), 'Cli_Multi');
+        strictEqual(sectionMap.get(2), 'Cli_Multi_Foo_Process');
+        strictEqual(sectionMap.get(5), 'Cli_Multi_Bar_Process');
+        return;
+    });
+    it('static method adds chunk (EC26)', () => {
+        const sectionMap = buildSourceSectionMap('/fake/cli/foo.ts', [
+            'class Runner {',
+            '  public static doThing(): void {}',
+            '}',
+            '',
+        ].join('\n'), 'Cli_Foo');
+        strictEqual(sectionMap.get(2), 'Cli_Foo_Runner_DoThing');
+        return;
+    });
+    it('getter adds chunk based on property name (EC25)', () => {
+        const sectionMap = buildSourceSectionMap('/fake/cli/foo.ts', [
+            'class Runner {',
+            '  public get bar(): number { return 1; }',
+            '}',
+            '',
+        ].join('\n'), 'Cli_Foo');
+        strictEqual(sectionMap.get(2), 'Cli_Foo_Runner_Bar');
+        return;
+    });
+    it('nested class inside method adds chunk under method (EC33)', () => {
+        const sectionMap = buildSourceSectionMap('/fake/cli/foo.ts', [
+            'class Outer {',
+            '  run(): void {',
+            '    class Inner {}',
+            '  }',
+            '}',
+            '',
+        ].join('\n'), 'Cli_Foo');
+        strictEqual(sectionMap.get(3), 'Cli_Foo_Outer_Run_Inner');
+        return;
+    });
+    it('default export class adds chunk (EC11)', () => {
+        const sectionMap = buildSourceSectionMap('/fake/cli/foo.ts', [
+            'export default class Runner {',
+            '  bar(): void {}',
+            '}',
+            '',
+        ].join('\n'), 'Cli_Foo');
+        strictEqual(sectionMap.get(2), 'Cli_Foo_Runner_Bar');
+        return;
+    });
+    it('vitest bench / suite calls add chunks generically (EC34)', () => {
+        const sectionMap = buildSourceSectionMap('/fake/tests/foo.test.ts', [
+            'bench(\'fast\', () => {',
+            '  const x: number = 1;',
+            '});',
+            '',
+        ].join('\n'), 'Tests_Foo');
+        strictEqual(sectionMap.get(2), 'Tests_Foo_Fast');
+        return;
+    });
+    it('describe.skip adds chunk (EC30)', () => {
+        const sectionMap = buildSourceSectionMap('/fake/tests/foo.test.ts', [
+            'describe.skip(\'Foo\', () => {',
+            '  const x: number = 1;',
+            '});',
+            '',
+        ].join('\n'), 'Tests_Foo');
+        strictEqual(sectionMap.get(2), 'Tests_Foo_Foo');
+        return;
+    });
+    it('class method body section overrides class section for body lines', () => {
+        const sectionMap = buildSourceSectionMap('/fake/cli/foo.ts', [
+            'class Runner {',
+            '  bar(): void {',
+            '    const x: number = 1;',
+            '  }',
+            '}',
+            '',
+        ].join('\n'), 'Cli_Foo');
+        strictEqual(sectionMap.get(3), 'Cli_Foo_Runner_Bar');
+        return;
+    });
+    it('arrow function const at file root adds chunk (EC2 -- file with only top-level const)', () => {
+        const sectionMap = buildSourceSectionMap('/fake/lib/foo.ts', [
+            'export const helper = () => {',
+            '  const x: number = 1;',
+            '};',
+            '',
+        ].join('\n'), 'Lib_Foo');
+        strictEqual(sectionMap.get(2), 'Lib_Foo_Helper');
+        return;
+    });
+    it('non-fn-typed const (string value) does NOT add chunk', () => {
+        const sectionMap = buildSourceSectionMap('/fake/lib/foo.ts', 'const constant = \'value\';\n', 'Lib_Foo');
+        strictEqual(sectionMap.get(1), 'Lib_Foo');
+        return;
+    });
+    it('only-string-no-fn call expression does NOT add chunk', () => {
+        const sectionMap = buildSourceSectionMap('/fake/lib/foo.ts', [
+            'function bar() {',
+            '  console.log(\'hello\');',
+            '  const x: number = 1;',
+            '}',
+            '',
+        ].join('\n'), 'Lib_Foo');
+        strictEqual(sectionMap.get(3), 'Lib_Foo_Bar');
+        return;
+    });
+    it('(string, options-object, fn) call adds chunk -- function in arg[2]', () => {
+        const sectionMap = buildSourceSectionMap('/fake/tests/foo.test.ts', [
+            'describe(\'Foo\', { skip: true }, () => {',
+            '  const x: number = 1;',
+            '});',
+            '',
+        ].join('\n'), 'Tests_Foo');
+        strictEqual(sectionMap.get(2), 'Tests_Foo_Foo');
+        return;
+    });
+    it('(string, string, fn) call uses arg[0] for chunk -- picks first function in any later arg', () => {
+        const sectionMap = buildSourceSectionMap('/fake/tests/foo.test.ts', [
+            'foo(\'first\', \'second\', () => {',
+            '  const x: number = 1;',
+            '});',
+            '',
+        ].join('\n'), 'Tests_Foo');
+        strictEqual(sectionMap.get(2), 'Tests_Foo_First');
+        return;
+    });
+    it('(fn, string) -- function in arg[0] (not a string), rule does NOT match -- covers setTimeout-style', () => {
+        const sectionMap = buildSourceSectionMap('/fake/lib/foo.ts', [
+            'function bar() {',
+            '  setTimeout(() => {',
+            '    const x: number = 1;',
+            '  }, 1000);',
+            '}',
+            '',
+        ].join('\n'), 'Lib_Foo');
+        strictEqual(sectionMap.get(3), 'Lib_Foo_Bar');
+        return;
+    });
+    it('(string, fn, fn) call uses the first function arg only, ignores the second', () => {
+        const sectionMap = buildSourceSectionMap('/fake/tests/foo.test.ts', [
+            'foo(\'Bar\', () => {',
+            '  const a: number = 1;',
+            '}, () => {',
+            '  const b: number = 2;',
+            '});',
+            '',
+        ].join('\n'), 'Tests_Foo');
+        strictEqual(sectionMap.get(2), 'Tests_Foo_Bar');
+        return;
+    });
+    return;
+});
+describe('extractTopLevelIdentifiers comprehensive', () => {
+    it('extracts top-level class', () => {
+        const identifiers = extractTopLevelIdentifiers('/fake/cli/foo.ts', 'export class Runner {}\n');
+        strictEqual(identifiers.length, 1);
+        strictEqual((identifiers[0] !== undefined) ? identifiers[0]['name'] : undefined, 'Runner');
+        strictEqual((identifiers[0] !== undefined) ? identifiers[0]['kind'] : undefined, 'class');
+        return;
+    });
+    it('extracts top-level function', () => {
+        const identifiers = extractTopLevelIdentifiers('/fake/lib/foo.ts', 'export function getNow() { return Date.now(); }\n');
+        strictEqual(identifiers.length, 1);
+        strictEqual((identifiers[0] !== undefined) ? identifiers[0]['name'] : undefined, 'getNow');
+        strictEqual((identifiers[0] !== undefined) ? identifiers[0]['kind'] : undefined, 'function');
+        return;
+    });
+    it('extracts top-level function-typed const', () => {
+        const identifiers = extractTopLevelIdentifiers('/fake/lib/foo.ts', 'const helper = () => 1;\n');
+        strictEqual(identifiers.length, 1);
+        strictEqual((identifiers[0] !== undefined) ? identifiers[0]['name'] : undefined, 'helper');
+        strictEqual((identifiers[0] !== undefined) ? identifiers[0]['kind'] : undefined, 'const');
+        return;
+    });
+    it('skips non-function const (primitive)', () => {
+        const identifiers = extractTopLevelIdentifiers('/fake/lib/foo.ts', 'const value = 42;\n');
+        strictEqual(identifiers.length, 0);
+        return;
+    });
+    it('skips nested function inside class method', () => {
+        const identifiers = extractTopLevelIdentifiers('/fake/cli/foo.ts', [
+            'class Runner {',
+            '  bar() {',
+            '    function nested() {}',
+            '  }',
+            '}',
+            '',
+        ].join('\n'));
+        strictEqual(identifiers.length, 1);
+        strictEqual((identifiers[0] !== undefined) ? identifiers[0]['name'] : undefined, 'Runner');
+        return;
+    });
+    it('handles multiple top-level identifiers (EC1)', () => {
+        const identifiers = extractTopLevelIdentifiers('/fake/cli/multi.ts', [
+            'export class Foo {}',
+            'export class Bar {}',
+            'export function baz() {}',
+            '',
+        ].join('\n'));
+        strictEqual(identifiers.length, 3);
+        strictEqual((identifiers[0] !== undefined) ? identifiers[0]['name'] : undefined, 'Foo');
+        strictEqual((identifiers[1] !== undefined) ? identifiers[1]['name'] : undefined, 'Bar');
+        strictEqual((identifiers[2] !== undefined) ? identifiers[2]['name'] : undefined, 'baz');
+        return;
+    });
+    it('returns line numbers (1-indexed)', () => {
+        const identifiers = extractTopLevelIdentifiers('/fake/cli/foo.ts', [
+            '',
+            '',
+            'export class Runner {}',
+            '',
+        ].join('\n'));
+        strictEqual((identifiers[0] !== undefined) ? identifiers[0]['lineNumber'] : undefined, 3);
+        return;
+    });
+    it('skips anonymous default export class', () => {
+        const identifiers = extractTopLevelIdentifiers('/fake/cli/foo.ts', 'export default class {}\n');
+        strictEqual(identifiers.length, 0);
+        return;
+    });
+    it('extracts class-expression-typed const as kind "const" (EC9 -- class Wrapper = class {})', () => {
+        const identifiers = extractTopLevelIdentifiers('/fake/lib/foo.ts', 'const Wrapper = class { run() {} };\n');
+        strictEqual(identifiers.length, 1);
+        strictEqual((identifiers[0] !== undefined) ? identifiers[0]['name'] : undefined, 'Wrapper');
+        strictEqual((identifiers[0] !== undefined) ? identifiers[0]['kind'] : undefined, 'const');
+        return;
+    });
+    return;
+});
+describe('deriveClassPrefix comprehensive', () => {
+    it('derives Cli_Utility_Changelog from src/cli/utility/changelog.ts', () => {
+        const prefix = deriveClassPrefix(resolve(getPackageRoot(), 'src/cli/utility/changelog.ts'));
+        strictEqual(prefix, 'Cli_Utility_Changelog');
+        return;
+    });
+    it('flattens hyphenated segments (package-json -> PackageJson)', () => {
+        const prefix = deriveClassPrefix(resolve(getPackageRoot(), 'src/cli/recipe/package-json/cleanup.ts'));
+        strictEqual(prefix, 'Cli_Recipe_PackageJson_Cleanup');
+        return;
+    });
+    it('strips .test marker for test files', () => {
+        const prefix = deriveClassPrefix(resolve(getPackageRoot(), 'src/tests/cli/utility/initialize.test.ts'));
+        strictEqual(prefix, 'Tests_Cli_Utility_Initialize');
+        return;
+    });
+    it('handles .d.ts type files', () => {
+        const prefix = deriveClassPrefix(resolve(getPackageRoot(), 'src/types/cli/utility/changelog.d.ts'));
+        strictEqual(prefix, 'Cli_Utility_Changelog');
+        return;
+    });
+    it('handles index files (no segment stripping per Mode 2)', () => {
+        const prefix = deriveClassPrefix(resolve(getPackageRoot(), 'src/cli/index.ts'));
+        strictEqual(prefix, 'Cli_Index');
+        return;
+    });
+    it('handles single-segment path (file at typeRoot)', () => {
+        const prefix = deriveClassPrefix(resolve(getPackageRoot(), 'src/main.ts'));
+        strictEqual(prefix, 'Main');
+        return;
+    });
+    return;
+});
+describe('extractTypeNames comprehensive', () => {
+    it('extracts type names from export type lines', () => {
+        const lines = [
+            'export type Foo = string;',
+            'export type Bar_Baz = number;',
+            'export type Cli_Foo_Run_Returns = void;',
+        ];
+        deepStrictEqual(extractTypeNames(lines), [
+            'Foo',
+            'Bar_Baz',
+            'Cli_Foo_Run_Returns',
+        ]);
+        return;
+    });
+    it('returns empty for non-export-type lines', () => {
+        const lines = [
+            'import { foo } from \'./bar.js\';',
+            '// comment',
+            '',
+        ];
+        deepStrictEqual(extractTypeNames(lines), []);
+        return;
+    });
+    it('handles type with object body', () => {
+        const lines = ['export type Foo_Bar = { x: number };'];
+        deepStrictEqual(extractTypeNames(lines), ['Foo_Bar']);
+        return;
+    });
+    return;
+});
+describe('extractImportedNames comprehensive', () => {
+    it('extracts inline imports', () => {
+        const lines = ['import type { Foo, Bar } from \'./baz.d.ts\';'];
+        const names = extractImportedNames(lines);
+        ok(names.has('Foo'));
+        ok(names.has('Bar'));
+        return;
+    });
+    it('extracts multi-line imports', () => {
+        const lines = [
+            'import type {',
+            '  Foo,',
+            '  Bar,',
+            '} from \'./baz.d.ts\';',
+        ];
+        const names = extractImportedNames(lines);
+        ok(names.has('Foo'));
+        ok(names.has('Bar'));
+        return;
+    });
+    it('returns empty set for no imports', () => {
+        const lines = ['export type Foo = string;'];
+        const names = extractImportedNames(lines);
+        strictEqual(names.size, 0);
+        return;
+    });
+    return;
+});
+describe('extractReferencedTypes comprehensive', () => {
+    it('extracts same-prefix referenced type from export type alias', () => {
+        const refs = extractReferencedTypes('export type Cli_Foo_Run_Data = Cli_Foo_Helper_Result;', 'Cli_Foo');
+        deepStrictEqual(refs, ['Cli_Foo_Helper_Result']);
+        return;
+    });
+    it('returns empty for foreign-prefix references (only same-prefix counted)', () => {
+        const refs = extractReferencedTypes('export type Cli_Foo_Run_Data = Lib_Utility_X;', 'Cli_Foo');
+        strictEqual(refs.length, 0);
+        return;
+    });
+    it('extracts multiple same-prefix references', () => {
+        const refs = extractReferencedTypes('export type Cli_Foo_X = Cli_Foo_A | Cli_Foo_B | Cli_Foo_C;', 'Cli_Foo');
+        strictEqual(refs.length, 3);
+        return;
+    });
+    it('excludes the type being defined from references (self-ref)', () => {
+        const refs = extractReferencedTypes('export type Cli_Foo_Bar = Cli_Foo_Bar;', 'Cli_Foo');
+        strictEqual(refs.length, 0);
+        return;
+    });
+    it('returns empty for primitive RHS', () => {
+        const refs = extractReferencedTypes('export type Cli_Foo_X = string;', 'Cli_Foo');
+        strictEqual(refs.length, 0);
+        return;
+    });
+    return;
+});
+describe('extractObjectTypes comprehensive', () => {
+    it('extracts object type with properties', () => {
+        const lines = [
+            'export type Cli_Foo_Run_Status = string;',
+            'export type Cli_Foo_Run_Result = {',
+            '  status: Cli_Foo_Run_Status;',
+            '};',
+        ];
+        const objectTypes = extractObjectTypes(lines, 'Cli_Foo');
+        strictEqual(objectTypes.length, 1);
+        strictEqual((objectTypes[0] !== undefined) ? objectTypes[0]['name'] : undefined, 'Cli_Foo_Run_Result');
+        strictEqual((objectTypes[0] !== undefined) ? objectTypes[0]['properties'].length : undefined, 1);
+        strictEqual((objectTypes[0] !== undefined && objectTypes[0]['properties'][0] !== undefined) ? objectTypes[0]['properties'][0]['key'] : undefined, 'status');
+        return;
+    });
+    it('handles empty classPrefix (matches any prefix)', () => {
+        const lines = [
+            'export type Anything = {',
+            '  foo: string;',
+            '};',
+        ];
+        const objectTypes = extractObjectTypes(lines, '');
+        strictEqual(objectTypes.length, 1);
+        return;
+    });
+    it('handles Readonly<...> wrapper', () => {
+        const lines = [
+            'export type Cli_Foo_X = Readonly<{',
+            '  bar: number;',
+            '}>;',
+        ];
+        const objectTypes = extractObjectTypes(lines, 'Cli_Foo');
+        strictEqual(objectTypes.length, 1);
+        strictEqual((objectTypes[0] !== undefined && objectTypes[0]['properties'][0] !== undefined) ? objectTypes[0]['properties'][0]['key'] : undefined, 'bar');
+        return;
+    });
+    return;
+});
+describe('extractArrayTypes comprehensive', () => {
+    it('extracts simple array form X = Y[]', () => {
+        const lines = ['export type Cli_Foo_Items = Cli_Foo_Item[];'];
+        const arrays = extractArrayTypes(lines);
+        strictEqual(arrays.length, 1);
+        strictEqual((arrays[0] !== undefined) ? arrays[0]['arrayTypeName'] : undefined, 'Cli_Foo_Items');
+        strictEqual((arrays[0] !== undefined) ? arrays[0]['elementTypeName'] : undefined, 'Cli_Foo_Item');
+        return;
+    });
+    it('skips multi-dim arrays X = Y[][] (EC7)', () => {
+        const lines = ['export type Cli_Foo_Matrix = Cli_Foo_Cell[][];'];
+        const arrays = extractArrayTypes(lines);
+        strictEqual(arrays.length, 0);
+        return;
+    });
+    it('skips union types X = Y | Z[]', () => {
+        const lines = ['export type Cli_Foo_Mix = Cli_Foo_X | Cli_Foo_Y[];'];
+        const arrays = extractArrayTypes(lines);
+        strictEqual(arrays.length, 0);
+        return;
+    });
+    it('skips generic-wrapped X = Map<...> (EC6)', () => {
+        const lines = ['export type Cli_Foo_Cache = Map<string, Cli_Foo_Item>;'];
+        const arrays = extractArrayTypes(lines);
+        strictEqual(arrays.length, 0);
+        return;
+    });
+    return;
+});
+describe('extractBodyDeclarations comprehensive', () => {
+    it('extracts typed const declarations', () => {
+        const lines = ['  const foo: Cli_X_Foo = 1;'];
+        const decls = extractBodyDeclarations(lines);
+        strictEqual(decls.length, 1);
+        strictEqual((decls[0] !== undefined) ? decls[0]['varName'] : undefined, 'foo');
+        strictEqual((decls[0] !== undefined) ? decls[0]['typeName'] : undefined, 'Cli_X_Foo');
+        strictEqual((decls[0] !== undefined) ? decls[0]['keyword'] : undefined, 'const');
+        return;
+    });
+    it('extracts typed let declarations', () => {
+        const lines = ['  let counter: Cli_X_Counter = 0;'];
+        const decls = extractBodyDeclarations(lines);
+        strictEqual((decls[0] !== undefined) ? decls[0]['keyword'] : undefined, 'let');
+        return;
+    });
+    it('skips untyped const', () => {
+        const lines = ['  const foo = 1;'];
+        const decls = extractBodyDeclarations(lines);
+        strictEqual(decls.length, 0);
+        return;
+    });
+    it('skips destructured assignments (EC13)', () => {
+        const lines = ['  const { foo, bar } = options;'];
+        const decls = extractBodyDeclarations(lines);
+        strictEqual(decls.length, 0);
+        return;
+    });
+    return;
+});
+describe('extractFunctionParams comprehensive', () => {
+    it('extracts function declaration params', () => {
+        const params = extractFunctionParams('/fake/lib/foo.ts', 'function bar(name: Lib_Foo_Bar_Name): void {}\n');
+        strictEqual(params.length, 1);
+        strictEqual((params[0] !== undefined) ? params[0]['paramName'] : undefined, 'name');
+        strictEqual((params[0] !== undefined) ? params[0]['typeName'] : undefined, 'Lib_Foo_Bar_Name');
+        return;
+    });
+    it('extracts method params', () => {
+        const params = extractFunctionParams('/fake/cli/foo.ts', [
+            'class Runner {',
+            '  bar(x: Cli_Foo_Runner_Bar_X): void {}',
+            '}',
+            '',
+        ].join('\n'));
+        strictEqual((params[0] !== undefined) ? params[0]['paramName'] : undefined, 'x');
+        return;
+    });
+    it('extracts constructor params', () => {
+        const params = extractFunctionParams('/fake/cli/foo.ts', [
+            'class Runner {',
+            '  constructor(name: Cli_Foo_Runner_Constructor_Name) {}',
+            '}',
+            '',
+        ].join('\n'));
+        strictEqual((params[0] !== undefined) ? params[0]['paramName'] : undefined, 'name');
+        return;
+    });
+    it('extracts function-typed const params', () => {
+        const params = extractFunctionParams('/fake/lib/foo.ts', 'const helper = (x: Lib_Foo_Helper_X) => x;\n');
+        strictEqual((params[0] !== undefined) ? params[0]['paramName'] : undefined, 'x');
+        return;
+    });
+    it('handles multiple params', () => {
+        const params = extractFunctionParams('/fake/lib/foo.ts', 'function bar(a: A, b: B, c: C): void {}\n');
+        strictEqual(params.length, 3);
+        return;
+    });
+    return;
+});
+describe('extractFunctionReturns comprehensive', () => {
+    it('extracts function declaration return type', () => {
+        const returnRecords = extractFunctionReturns('/fake/lib/foo.ts', 'function bar(): Lib_Foo_Bar_Returns { return; }\n');
+        strictEqual((returnRecords[0] !== undefined) ? returnRecords[0]['returnType'] : undefined, 'Lib_Foo_Bar_Returns');
+        strictEqual((returnRecords[0] !== undefined) ? returnRecords[0]['isTypeGuard'] : undefined, false);
+        return;
+    });
+    it('detects type-guard returns (value is X)', () => {
+        const returnRecords = extractFunctionReturns('/fake/lib/foo.ts', 'function isFoo(x: unknown): x is Lib_Foo_IsFoo_TypeGuard { return true; }\n');
+        strictEqual((returnRecords[0] !== undefined) ? returnRecords[0]['isTypeGuard'] : undefined, true);
+        return;
+    });
+    it('extracts method return type', () => {
+        const returnRecords = extractFunctionReturns('/fake/cli/foo.ts', [
+            'class Runner {',
+            '  bar(): Cli_Foo_Runner_Bar_Returns { return; }',
+            '}',
+            '',
+        ].join('\n'));
+        strictEqual((returnRecords[0] !== undefined) ? returnRecords[0]['returnType'] : undefined, 'Cli_Foo_Runner_Bar_Returns');
+        return;
+    });
+    it('[gap] does NOT extract arrow function const returns -- extractFunctionReturns only inspects function/method/constructor declarations', () => {
+        const returnRecords = extractFunctionReturns('/fake/lib/foo.ts', 'const helper = (): Lib_Foo_Helper_Returns => 42;\n');
+        strictEqual(returnRecords.length, 0);
+        return;
+    });
+    return;
+});
+describe('detectInlineTypedCallbacks comprehensive', () => {
+    it('detects typed arrow callback param', () => {
+        const callbacks = detectInlineTypedCallbacks('/fake/cli/foo.ts', [
+            'function run() {',
+            '  items.filter((item: Cli_Foo_Item) => item.active);',
+            '}',
+            '',
+        ].join('\n'));
+        strictEqual(callbacks.length, 1);
+        strictEqual((callbacks[0] !== undefined) ? callbacks[0]['paramName'] : undefined, 'item');
+        strictEqual((callbacks[0] !== undefined) ? callbacks[0]['typeName'] : undefined, 'Cli_Foo_Item');
+        return;
+    });
+    it('skips untyped callback param (rule 7.4 H2)', () => {
+        const callbacks = detectInlineTypedCallbacks('/fake/cli/foo.ts', [
+            'function run() {',
+            '  items.filter((item) => item.active);',
+            '}',
+            '',
+        ].join('\n'));
+        strictEqual(callbacks.length, 0);
+        return;
+    });
+    it('detects typed function expression callback', () => {
+        const callbacks = detectInlineTypedCallbacks('/fake/cli/foo.ts', [
+            'function run() {',
+            '  items.filter(function (item: Cli_Foo_Item) { return item.active; });',
+            '}',
+            '',
+        ].join('\n'));
+        strictEqual(callbacks.length, 1);
+        return;
+    });
+    return;
+});
+describe('checkTypeNameUniqueness comprehensive', () => {
+    it('returns no violations for unique names', () => {
+        const violations = checkTypeNameUniqueness([
+            {
+                name: 'foo', typeName: 'Cli_X_Foo', lineNumber: 1,
+            },
+            {
+                name: 'bar', typeName: 'Cli_X_Bar', lineNumber: 2,
+            },
+        ]);
+        strictEqual(violations.length, 0);
+        return;
+    });
+    it('detects duplicate expected names (rule 7.8)', () => {
+        const violations = checkTypeNameUniqueness([
+            {
+                name: 'foo', typeName: 'Cli_X_Foo', lineNumber: 1,
+            },
+            {
+                name: 'foo', typeName: 'Cli_X_Foo', lineNumber: 5,
+            },
+        ]);
+        strictEqual(violations.length, 1);
+        return;
+    });
+    return;
+});
+describe('buildDtsSections comprehensive', () => {
+    it('groups types by source section', () => {
+        const dtsLines = [
+            'export type Cli_Foo_Run_X = string;',
+            'export type Cli_Foo_Helper_Y = string;',
+        ];
+        const sourceSections = new Set([
+            'Cli_Foo_Run',
+            'Cli_Foo_Helper',
+        ]);
+        const sections = buildDtsSections(dtsLines, sourceSections, 'Cli_Foo');
+        strictEqual(sections.length, 2);
+        return;
+    });
+    it('uses longest prefix match', () => {
+        const dtsLines = ['export type Cli_Foo_Run_Helper_X = string;'];
+        const sourceSections = new Set([
+            'Cli_Foo_Run',
+            'Cli_Foo_Run_Helper',
+        ]);
+        const sections = buildDtsSections(dtsLines, sourceSections, 'Cli_Foo');
+        strictEqual((sections[0] !== undefined) ? sections[0]['prefix'] : undefined, 'Cli_Foo_Run_Helper');
+        return;
+    });
+    it('falls back to classPrefix for unmatched types', () => {
+        const dtsLines = ['export type Cli_Foo_OrphanType = string;'];
+        const sourceSections = new Set();
+        const sections = buildDtsSections(dtsLines, sourceSections, 'Cli_Foo');
+        strictEqual((sections[0] !== undefined) ? sections[0]['prefix'] : undefined, 'Cli_Foo');
+        return;
+    });
+    it('skips types not starting with classPrefix or any source section', () => {
+        const dtsLines = ['export type ForeignType = string;'];
+        const sourceSections = new Set(['Cli_Foo_Run']);
+        const sections = buildDtsSections(dtsLines, sourceSections, 'Cli_Foo');
+        strictEqual(sections.length, 0);
+        return;
+    });
+    return;
+});
+describe('Rule C1/C2/C3 integration', () => {
+    it('detects class name == file name (C1)', () => {
+        const identifiers = extractTopLevelIdentifiers('/fake/cli/utility/changelog.ts', 'export class Changelog {}\n');
+        const fileName = 'Changelog';
+        const violations = identifiers
+            .filter((identifier) => identifier['name'] === fileName)
+            .map((identifier) => `${identifier['kind']}:${identifier['name']}`);
+        deepStrictEqual(violations, ['class:Changelog']);
+        return;
+    });
+    it('detects function name == file name (C2)', () => {
+        const identifiers = extractTopLevelIdentifiers('/fake/lib/utility.ts', 'export function utility() {}\n');
+        const fileName = 'utility';
+        const violations = identifiers
+            .filter((identifier) => identifier['name'] === fileName)
+            .map((identifier) => identifier['name']);
+        strictEqual(violations.length, 1);
+        return;
+    });
+    it('detects function-typed const name == file name (C2)', () => {
+        const identifiers = extractTopLevelIdentifiers('/fake/lib/utility.ts', 'const utility = () => 1;\n');
+        const fileName = 'utility';
+        const violations = identifiers
+            .filter((identifier) => identifier['name'] === fileName)
+            .map((identifier) => identifier['name']);
+        strictEqual(violations.length, 1);
+        return;
+    });
+    it('detects hyphenated file name flattened (C3)', () => {
+        const filePath = resolve(getPackageRoot(), 'src/toolkit/markdown-table.ts');
+        const classPrefix = deriveClassPrefix(filePath);
+        const segments = classPrefix.split('_');
+        const fileName = segments[segments.length - 1] ?? '';
+        strictEqual(fileName, 'MarkdownTable');
+        const identifiers = extractTopLevelIdentifiers(filePath, 'export class MarkdownTable {}\n');
+        strictEqual(identifiers.filter((identifier) => identifier['name'] === fileName).length, 1);
+        return;
+    });
+    it('does NOT fire for non-matching name', () => {
+        const identifiers = extractTopLevelIdentifiers('/fake/cli/utility/changelog.ts', 'export class Runner {}\n');
+        const fileName = 'Changelog';
+        strictEqual(identifiers.filter((identifier) => identifier['name'] === fileName).length, 0);
+        return;
+    });
+    it('does NOT fire for nested class with same name as file', () => {
+        const identifiers = extractTopLevelIdentifiers('/fake/cli/utility/changelog.ts', [
+            'export class Runner {',
+            '  doStuff() {',
+            '    class Changelog {}',
+            '  }',
+            '}',
+            '',
+        ].join('\n'));
+        const fileName = 'Changelog';
+        strictEqual(identifiers.filter((identifier) => identifier['name'] === fileName).length, 0);
+        return;
+    });
+    return;
+});
+describe('Rule 7.2 integration', () => {
+    it('passes when type is locally defined as a concrete shape', () => {
+        const dtsContent = 'export type Cli_Foo_Run_Data = { name: string };\n';
+        strictEqual(isLocallyDefined('Cli_Foo_Run_Data', dtsContent), true);
+        strictEqual(isAliasToForeignType('Cli_Foo_Run_Data', dtsContent, 'Cli_Foo'), false);
+        return;
+    });
+    it('fires when type is not defined locally', () => {
+        const dtsContent = '';
+        strictEqual(isLocallyDefined('Cli_Foo_Run_Data', dtsContent), false);
+        return;
+    });
+    it('fires when locally defined as alias to foreign type (Mode 2 tightening)', () => {
+        const dtsContent = 'export type Cli_Foo_Run_Data = Lib_Utility_X;\n';
+        strictEqual(isLocallyDefined('Cli_Foo_Run_Data', dtsContent), true);
+        strictEqual(isAliasToForeignType('Cli_Foo_Run_Data', dtsContent, 'Cli_Foo'), true);
+        return;
+    });
+    it('passes when alias is to same-prefix type (not foreign)', () => {
+        const dtsContent = 'export type Cli_Foo_Run_Data = Cli_Foo_Helper_Result;\n';
+        strictEqual(isAliasToForeignType('Cli_Foo_Run_Data', dtsContent, 'Cli_Foo'), false);
+        return;
+    });
+    return;
+});
+describe('Rule 7.3 integration', () => {
+    it('rejects body var typed Foo_Returns', () => {
+        strictEqual(isReservedSuffix('Foo_Bar_Returns'), true);
+        return;
+    });
+    it('rejects body var typed Foo_TypeGuard', () => {
+        strictEqual(isReservedSuffix('Foo_Bar_TypeGuard'), true);
+        return;
+    });
+    it('rejects body var typed Foo_Return', () => {
+        strictEqual(isReservedSuffix('Foo_Bar_Return'), true);
+        return;
+    });
+    it('passes body var typed Foo_Result (not reserved)', () => {
+        strictEqual(isReservedSuffix('Foo_Bar_Result'), false);
+        return;
+    });
+    return;
+});
+describe('Rule 7.4 integration', () => {
+    it('detects typed inline arrow callback', () => {
+        const callbacks = detectInlineTypedCallbacks('/fake/cli/foo.ts', [
+            'function run() {',
+            '  items.filter((item: Cli_Foo_Item) => item.active);',
+            '}',
+            '',
+        ].join('\n'));
+        strictEqual(callbacks.length, 1);
+        return;
+    });
+    it('passes named const callback (extracted) -- items.filter(isActive) has no inline arrow arg', () => {
+        const callbacks = detectInlineTypedCallbacks('/fake/cli/foo.ts', [
+            'function run() {',
+            '  const isActive = (item: Cli_Foo_Item) => item.active;',
+            '  items.filter(isActive);',
+            '}',
+            '',
+        ].join('\n'));
+        strictEqual(callbacks.length, 0);
+        return;
+    });
+    it('passes untyped inline callback (rule H2 exemption)', () => {
+        const callbacks = detectInlineTypedCallbacks('/fake/cli/foo.ts', [
+            'function run() {',
+            '  items.filter((item) => item.active);',
+            '}',
+            '',
+        ].join('\n'));
+        strictEqual(callbacks.length, 0);
+        return;
+    });
+    return;
+});
+describe('Rule 7.5/7.6/7.7 integration', () => {
+    it('rule 7.5: function returning Foo_Returns passes', () => {
+        strictEqual(validateReturnType('Foo_Bar_Returns', false), null);
+        return;
+    });
+    it('rule 7.5: function returning Foo_Result fails (must end in Returns)', () => {
+        ok(validateReturnType('Foo_Bar_Result', false) !== null);
+        return;
+    });
+    it('rule 7.6: function returning Foo_Return (singular) fails', () => {
+        ok(validateReturnType('Foo_Bar_Return', false) !== null);
+        return;
+    });
+    it('rule 7.7: type-guard returning Foo_TypeGuard passes', () => {
+        strictEqual(validateReturnType('Foo_Bar_TypeGuard', true), null);
+        return;
+    });
+    it('rule 7.7: function returning Foo_TypeGuard at non-type-guard fails', () => {
+        ok(validateReturnType('Foo_Bar_TypeGuard', false) !== null);
+        return;
+    });
+    it('rule 7.7: type-guard returning Foo_Returns at type-guard fails', () => {
+        ok(validateReturnType('Foo_Bar_Returns', true) !== null);
+        return;
+    });
+    return;
+});
+describe('Rule 7.8 integration', () => {
+    it('passes when all expected names unique', () => {
+        const violations = checkTypeNameUniqueness([
+            {
+                name: 'foo', typeName: 'Cli_X_Foo', lineNumber: 1,
+            },
+            {
+                name: 'bar', typeName: 'Cli_X_Bar', lineNumber: 2,
+            },
+        ]);
+        strictEqual(violations.length, 0);
+        return;
+    });
+    it('fires when two body vars produce the same expected type name (rule 7.8)', () => {
+        const violations = checkTypeNameUniqueness([
+            {
+                name: 'foo', typeName: 'Cli_X_Run_Foo', lineNumber: 5,
+            },
+            {
+                name: 'foo', typeName: 'Cli_X_Run_Foo', lineNumber: 12,
+            },
+        ]);
+        strictEqual(violations.length, 1);
+        return;
+    });
+    return;
+});
+describe('Rule E3 integration (Mode 2 expansion to Returns | TypeGuard | Return)', () => {
+    it('Returns suffix array IS exempt from element-before-array', () => {
+        const arrayName = 'Cli_Foo_Run_Returns';
+        const exempt = arrayName.endsWith('Returns') === true || arrayName.endsWith('_Returns') === true;
+        strictEqual(exempt, true);
+        return;
+    });
+    it('TypeGuard suffix array IS exempt (Mode 2)', () => {
+        const arrayName = 'Cli_Foo_IsUser_TypeGuard';
+        const exempt = arrayName.endsWith('TypeGuard') === true || arrayName.endsWith('_TypeGuard') === true;
+        strictEqual(exempt, true);
+        return;
+    });
+    it('Return (singular) suffix array IS exempt (Mode 2 defensive)', () => {
+        const arrayName = 'Cli_Foo_Run_Return';
+        const exempt = arrayName.endsWith('Return') === true || arrayName.endsWith('_Return') === true;
+        strictEqual(exempt, true);
+        return;
+    });
+    it('Items suffix array is NOT exempt (must define element first)', () => {
+        const arrayName = 'Cli_Foo_Run_Items';
+        const exempt = (arrayName.endsWith('Returns') === true
+            || arrayName.endsWith('_Returns') === true
+            || arrayName.endsWith('TypeGuard') === true
+            || arrayName.endsWith('_TypeGuard') === true
+            || arrayName.endsWith('Return') === true
+            || arrayName.endsWith('_Return') === true);
+        strictEqual(exempt, false);
+        return;
+    });
+    return;
+});
+describe('Rule S1/S2/S3/S4 integration', () => {
+    it('S1: PascalCase top-level type passes', () => {
+        const pascalCasePattern = new RegExp('^[A-Z][A-Za-z0-9]*(_[A-Z][A-Za-z0-9]*)*$');
+        strictEqual(pascalCasePattern.test('EntryCategory'), true);
+        strictEqual(pascalCasePattern.test('EntryItem_Category'), true);
+        return;
+    });
+    it('S1: snake_case fails', () => {
+        const pascalCasePattern = new RegExp('^[A-Z][A-Za-z0-9]*(_[A-Z][A-Za-z0-9]*)*$');
+        strictEqual(pascalCasePattern.test('entry_category'), false);
+        return;
+    });
+    it('S1: brand casing (3+ caps) fails', () => {
+        const brandCasePattern = new RegExp('[A-Z]{3,}');
+        strictEqual(brandCasePattern.test('CLIEntryCategory'), true);
+        strictEqual(brandCasePattern.test('URLBuilder'), true);
+        return;
+    });
+    it('S1: standalone 2-cap acronyms pass when followed by lowercase', () => {
+        const brandCasePattern = new RegExp('[A-Z]{3,}');
+        strictEqual(brandCasePattern.test('UiCore'), false);
+        strictEqual(brandCasePattern.test('IoError'), false);
+        strictEqual(brandCasePattern.test('UICore'), true);
+        strictEqual(brandCasePattern.test('IOError'), true);
+        return;
+    });
+    it('S2: path-prefix-style names detected', () => {
+        const knownTopLevels = new Set([
+            'Cli',
+            'Lib',
+            'Tests',
+        ]);
+        const typeName = 'Cli_Foo_Bar';
+        const isPathPrefixStyle = [...knownTopLevels].some((prefix) => typeName.startsWith(`${prefix}_`));
+        strictEqual(isPathPrefixStyle, true);
+        return;
+    });
+    it('S2: domain concept names pass', () => {
+        const knownTopLevels = new Set([
+            'Cli',
+            'Lib',
+            'Tests',
+        ]);
+        const typeName = 'EntryCategory';
+        const isPathPrefixStyle = [...knownTopLevels].some((prefix) => typeName.startsWith(`${prefix}_`));
+        strictEqual(isPathPrefixStyle, false);
+        return;
+    });
+    it('S3: property type using Parent_Property form passes', () => {
+        const objectName = 'EntryItem';
+        const propertyValueType = 'EntryItem_Category';
+        strictEqual(propertyValueType.startsWith(`${objectName}_`), true);
+        return;
+    });
+    it('S3: property type without parent prefix fails', () => {
+        const objectName = 'EntryItem';
+        const propertyValueType = 'EntryCategory';
+        strictEqual(propertyValueType.startsWith(`${objectName}_`), false);
+        return;
+    });
+    it('S4: array element types defined before array', () => {
+        const lines = [
+            'export type EntryItem_Tag = string;',
+            'export type EntryItem_Tags = EntryItem_Tag[];',
+        ];
+        const arrays = extractArrayTypes(lines);
+        const elementLine = lines.findIndex((line) => line.startsWith('export type EntryItem_Tag '));
+        const arrayLine = (arrays[0] !== undefined) ? arrays[0]['lineIndex'] : -1;
+        ok(elementLine < arrayLine);
+        return;
+    });
+    return;
+});
+describe('Rule EC19/EC20/EC21 integration', () => {
+    it('passes plain filename foo.ts', () => {
+        const pattern = new RegExp('^[a-z][a-z0-9-]*$');
+        strictEqual(pattern.test('foo'), true);
+        return;
+    });
+    it('passes hyphenated foo-bar.ts', () => {
+        const pattern = new RegExp('^[a-z][a-z0-9-]*$');
+        strictEqual(pattern.test('foo-bar'), true);
+        return;
+    });
+    it('passes filename with trailing digits foo123.ts', () => {
+        const pattern = new RegExp('^[a-z][a-z0-9-]*$');
+        strictEqual(pattern.test('foo123'), true);
+        return;
+    });
+    it('fails filename starting with digit (EC20)', () => {
+        const pattern = new RegExp('^[a-z][a-z0-9-]*$');
+        strictEqual(pattern.test('123foo'), false);
+        return;
+    });
+    it('fails filename with underscore (EC21)', () => {
+        const pattern = new RegExp('^[a-z][a-z0-9-]*$');
+        strictEqual(pattern.test('foo_bar'), false);
+        return;
+    });
+    it('fails filename with special character (EC21)', () => {
+        const pattern = new RegExp('^[a-z][a-z0-9-]*$');
+        strictEqual(pattern.test('foo$bar'), false);
+        strictEqual(pattern.test('foo bar'), false);
+        return;
+    });
+    it('fails filename with uppercase', () => {
+        const pattern = new RegExp('^[a-z][a-z0-9-]*$');
+        strictEqual(pattern.test('Foo'), false);
+        return;
+    });
+    it('fails dotted segment after stripping recognized suffixes (EC19)', () => {
+        const pattern = new RegExp('^[a-z][a-z0-9-]*$');
+        strictEqual(pattern.test('foo.spec'), false);
+        return;
+    });
+    return;
+});
+describe('Edge cases EC1-EC10', () => {
+    it('EC1: multiple top-level classes each contribute their own chunk', () => {
+        const sectionMap = buildSourceSectionMap('/fake/cli/multi.ts', [
+            'class Foo {',
+            '  process(): void {}',
+            '}',
+            'class Bar {',
+            '  process(): void {}',
+            '}',
+            '',
+        ].join('\n'), 'Cli_Multi');
+        strictEqual(sectionMap.get(2), 'Cli_Multi_Foo_Process');
+        strictEqual(sectionMap.get(5), 'Cli_Multi_Bar_Process');
+        return;
+    });
+    it('EC2: file with only top-level functions, no class', () => {
+        const sectionMap = buildSourceSectionMap('/fake/lib/utility.ts', [
+            'export function getCurrentTimestamp(): number {',
+            '  return Date.now();',
+            '}',
+            '',
+        ].join('\n'), 'Lib_Utility');
+        strictEqual(sectionMap.get(1), 'Lib_Utility_GetCurrentTimestamp');
+        return;
+    });
+    it('EC3: generic type parameters do not get their own chunks', () => {
+        const sectionMap = buildSourceSectionMap('/fake/cli/foo.ts', 'function getItems<T>(): T[] { return []; }\n', 'Cli_Foo');
+        strictEqual(sectionMap.get(1), 'Cli_Foo_GetItems');
+        return;
+    });
+    it('EC5: tuple types are not subject to E3 (only X[] form)', () => {
+        const lines = ['export type Cli_Foo_Run_Pair = [string, number];'];
+        const arrays = extractArrayTypes(lines);
+        strictEqual(arrays.length, 0);
+        return;
+    });
+    it('EC6: Map/Set/Promise generic collection types not subject to E3', () => {
+        const lines = [
+            'export type Cli_Foo_Run_Cache = Map<string, Cli_Foo_Run_Item>;',
+            'export type Cli_Foo_Run_Promise = Promise<Cli_Foo_Run_Item>;',
+        ];
+        const arrays = extractArrayTypes(lines);
+        strictEqual(arrays.length, 0);
+        return;
+    });
+    it('EC7: multi-dimensional arrays X[][] not checked by E3', () => {
+        const lines = ['export type Cli_Foo_Run_Matrix = Cli_Foo_Run_Cell[][];'];
+        const arrays = extractArrayTypes(lines);
+        strictEqual(arrays.length, 0);
+        return;
+    });
+    it('EC8: type-level operations (extends/conditional) inside body do not add chunks', () => {
+        const sectionMap = buildSourceSectionMap('/fake/lib/foo.ts', [
+            'function bar() {',
+            '  type Conditional = string extends string ? number : never;',
+            '}',
+            '',
+        ].join('\n'), 'Lib_Foo');
+        strictEqual(sectionMap.get(1), 'Lib_Foo_Bar');
+        return;
+    });
+    it('EC9: anonymous class expression in const uses const name as chunk (Mode 2: closes prior gap)', () => {
+        const sectionMap = buildSourceSectionMap('/fake/lib/foo.ts', 'const Wrapper = class { run() {} };\n', 'Lib_Foo');
+        strictEqual(sectionMap.get(1), 'Lib_Foo_Wrapper_Run');
+        return;
+    });
+    return;
+});
+describe('Edge cases EC11-EC20', () => {
+    it('EC11: default export class adds chunk like regular class', () => {
+        const sectionMap = buildSourceSectionMap('/fake/cli/foo.ts', [
+            'export default class Runner {',
+            '  bar(): void {}',
+            '}',
+            '',
+        ].join('\n'), 'Cli_Foo');
+        strictEqual(sectionMap.get(2), 'Cli_Foo_Runner_Bar');
+        return;
+    });
+    it('EC12: this parameters do not pollute body var rule (skipped from extractFunctionParams)', () => {
+        const params = extractFunctionParams('/fake/lib/foo.ts', 'function bar(this: SomeType, x: Lib_Foo_Bar_X): void {}\n');
+        const nonThisParams = params.filter((param) => param['paramName'] !== 'this');
+        ok(nonThisParams.length >= 1);
+        return;
+    });
+    it('EC13: destructured parameter does not get its own type extracted via extractBodyDeclarations', () => {
+        const lines = ['  const { foo } = options;'];
+        const decls = extractBodyDeclarations(lines);
+        strictEqual(decls.length, 0);
+        return;
+    });
+    it('EC14: parameter property (TS shorthand) is treated as a normal constructor param', () => {
+        const params = extractFunctionParams('/fake/cli/foo.ts', [
+            'class Runner {',
+            '  constructor(public name: Cli_Foo_Runner_Constructor_Name) {}',
+            '}',
+            '',
+        ].join('\n'));
+        strictEqual((params[0] !== undefined) ? params[0]['paramName'] : undefined, 'name');
+        return;
+    });
+    it('EC15: index signature is not detected as a regular property', () => {
+        const lines = [
+            'export type Cli_Foo_Run_Map = {',
+            '  [key: string]: Cli_Foo_Run_Item;',
+            '};',
+        ];
+        const objectTypes = extractObjectTypes(lines, 'Cli_Foo');
+        strictEqual((objectTypes[0] !== undefined) ? objectTypes[0]['properties'].length : undefined, 0);
+        return;
+    });
+    it('[gap] EC16: optional/readonly modifiers -- extractObjectTypes property regex requires bare `key: Type;` form, so `readonly id: ...` is silently skipped', () => {
+        const lines = [
+            'export type Cli_Foo_Run_Result = {',
+            '  readonly id: Cli_Foo_Run_Result_Id;',
+            '  status: Cli_Foo_Run_Result_Status;',
+            '};',
+        ];
+        const objectTypes = extractObjectTypes(lines, 'Cli_Foo');
+        strictEqual((objectTypes[0] !== undefined) ? objectTypes[0]['properties'].length : undefined, 1);
+        strictEqual((objectTypes[0] !== undefined && objectTypes[0]['properties'][0] !== undefined) ? objectTypes[0]['properties'][0]['key'] : undefined, 'status');
+        return;
+    });
+    it('EC17: underscore-prefixed var name strips underscore for leaf comparison', () => {
+        strictEqual(stripUnderscorePrefix('_prev'), 'prev');
+        strictEqual(validateLeaf('_prev', 'Cli_Foo_Run_Prev', 'Cli_Foo_Run', 'Cli_Foo'), null);
+        return;
+    });
+    it('EC18: single-character var name title-cases the single character', () => {
+        strictEqual(validateLeaf('i', 'Cli_Foo_Run_I', 'Cli_Foo_Run', 'Cli_Foo'), null);
+        return;
+    });
+    it('EC19: dotted filename like foo.spec fails segment regex', () => {
+        const pattern = new RegExp('^[a-z][a-z0-9-]*$');
+        strictEqual(pattern.test('foo.spec'), false);
+        strictEqual(pattern.test('foo.bar'), false);
+        return;
+    });
+    it('EC20: filename starting with digit fails segment regex', () => {
+        const pattern = new RegExp('^[a-z][a-z0-9-]*$');
+        strictEqual(pattern.test('123foo'), false);
+        return;
+    });
+    return;
+});
+describe('Edge cases EC21-EC30', () => {
+    it('EC21: filename with underscore/space/special-char fails segment regex', () => {
+        const pattern = new RegExp('^[a-z][a-z0-9-]*$');
+        strictEqual(pattern.test('foo_bar'), false);
+        strictEqual(pattern.test('foo bar'), false);
+        strictEqual(pattern.test('foo$bar'), false);
+        return;
+    });
+    it('EC22: file at typeRoot produces single-chunk classPrefix', () => {
+        const prefix = deriveClassPrefix(resolve(getPackageRoot(), 'src/main.ts'));
+        strictEqual(prefix, 'Main');
+        return;
+    });
+    it('EC23: template string in (string, fn) arg[0] does NOT add chunk', () => {
+        const interp = [
+            '$',
+            '{',
+            '1}',
+        ].join('');
+        const sourceContent = [
+            `describe(\`Foo ${interp}\`, () => {`,
+            '  const x: number = 1;',
+            '});',
+            '',
+        ].join('\n');
+        const sectionMap = buildSourceSectionMap('/fake/tests/foo.test.ts', sourceContent, 'Tests_Foo');
+        strictEqual(sectionMap.get(2), 'Tests_Foo');
+        return;
+    });
+    it('EC24: async arrow function callback in (string, fn) is accepted', () => {
+        const sectionMap = buildSourceSectionMap('/fake/tests/foo.test.ts', [
+            'describe(\'Foo\', async () => {',
+            '  const x: number = 1;',
+            '});',
+            '',
+        ].join('\n'), 'Tests_Foo');
+        strictEqual(sectionMap.get(2), 'Tests_Foo_Foo');
+        return;
+    });
+    it('EC24b: async function expression callback in (string, fn) is accepted', () => {
+        const sectionMap = buildSourceSectionMap('/fake/tests/foo.test.ts', [
+            'describe(\'Foo\', async function () {',
+            '  const x: number = 1;',
+            '});',
+            '',
+        ].join('\n'), 'Tests_Foo');
+        strictEqual(sectionMap.get(2), 'Tests_Foo_Foo');
+        return;
+    });
+    it('EC25: class getter adds chunk based on property name', () => {
+        const sectionMap = buildSourceSectionMap('/fake/cli/foo.ts', [
+            'class Runner {',
+            '  get bar(): number { return 1; }',
+            '}',
+            '',
+        ].join('\n'), 'Cli_Foo');
+        strictEqual(sectionMap.get(2), 'Cli_Foo_Runner_Bar');
+        return;
+    });
+    it('EC25b: class setter adds chunk based on property name', () => {
+        const sectionMap = buildSourceSectionMap('/fake/cli/foo.ts', [
+            'class Runner {',
+            '  set bar(value: number) {}',
+            '}',
+            '',
+        ].join('\n'), 'Cli_Foo');
+        strictEqual(sectionMap.get(2), 'Cli_Foo_Runner_Bar');
+        return;
+    });
+    it('EC26: static method adds chunk like an instance method', () => {
+        const sectionMap = buildSourceSectionMap('/fake/cli/foo.ts', [
+            'class Runner {',
+            '  static doThing(): void {}',
+            '}',
+            '',
+        ].join('\n'), 'Cli_Foo');
+        strictEqual(sectionMap.get(2), 'Cli_Foo_Runner_DoThing');
+        return;
+    });
+    it('EC28: nested function declaration adds chunk under the outer function', () => {
+        const sectionMap = buildSourceSectionMap('/fake/lib/foo.ts', [
+            'function processItems() {',
+            '  function visit(node: any) {',
+            '    const result: any = node;',
+            '  }',
+            '}',
+            '',
+        ].join('\n'), 'Lib_Foo');
+        strictEqual(sectionMap.get(3), 'Lib_Foo_ProcessItems_Visit');
+        return;
+    });
+    it('EC30: describe.skip(string, fn) adds chunk via generic rule', () => {
+        const sectionMap = buildSourceSectionMap('/fake/tests/foo.test.ts', [
+            'describe.skip(\'Foo\', () => {',
+            '  const x: number = 1;',
+            '});',
+            '',
+        ].join('\n'), 'Tests_Foo');
+        strictEqual(sectionMap.get(2), 'Tests_Foo_Foo');
+        return;
+    });
+    it('EC30b: describe.only(string, fn) adds chunk via generic rule', () => {
+        const sectionMap = buildSourceSectionMap('/fake/tests/foo.test.ts', [
+            'describe.only(\'Foo\', () => {',
+            '  const x: number = 1;',
+            '});',
+            '',
+        ].join('\n'), 'Tests_Foo');
+        strictEqual(sectionMap.get(2), 'Tests_Foo_Foo');
+        return;
+    });
+    return;
+});
+describe('Edge cases EC31-EC55', () => {
+    it('EC31: primitive-like return types (void, never, etc.) pass validateLeaf at body var', () => {
+        const result = validateLeaf('result', 'unknown', 'Cli_Foo_Run', 'Cli_Foo');
+        strictEqual((result !== null) ? result['actualLeaf'] : undefined, 'unknown');
+        return;
+    });
+    it('EC33: nested class inside method adds chunk under method', () => {
+        const sectionMap = buildSourceSectionMap('/fake/cli/foo.ts', [
+            'class Outer {',
+            '  run(): void {',
+            '    class Inner {}',
+            '  }',
+            '}',
+            '',
+        ].join('\n'), 'Cli_Foo');
+        strictEqual(sectionMap.get(3), 'Cli_Foo_Outer_Run_Inner');
+        return;
+    });
+    it('EC34: vitest bench(string, fn) adds chunk via generic rule', () => {
+        const sectionMap = buildSourceSectionMap('/fake/tests/foo.bench.ts', [
+            'bench(\'fast op\', () => {',
+            '  const x: number = 1;',
+            '});',
+            '',
+        ].join('\n'), 'Tests_Foo');
+        strictEqual(sectionMap.get(2), 'Tests_Foo_FastOp');
+        return;
+    });
+    it('EC35: rule 7.8 catches two body vars producing the same expected type name', () => {
+        const violations = checkTypeNameUniqueness([
+            {
+                name: 'foo', typeName: 'Cli_X_Foo', lineNumber: 10,
+            },
+            {
+                name: 'foo', typeName: 'Cli_X_Foo', lineNumber: 20,
+            },
+        ]);
+        strictEqual(violations.length, 1);
+        return;
+    });
+    it('EC37/EC42: JSX function component name == file name fires C2', () => {
+        const identifiers = extractTopLevelIdentifiers('/fake/components/logo.tsx', 'export default function Logo(): null { return null; }\n');
+        strictEqual((identifiers[0] !== undefined) ? identifiers[0]['name'] : undefined, 'Logo');
+        strictEqual((identifiers[0] !== undefined) ? identifiers[0]['kind'] : undefined, 'function');
+        return;
+    });
+    it('EC43: JSX class component name == file name fires C1', () => {
+        const identifiers = extractTopLevelIdentifiers('/fake/components/logo.tsx', [
+            'export default class Logo {',
+            '  render() { return null; }',
+            '}',
+            '',
+        ].join('\n'));
+        strictEqual((identifiers[0] !== undefined) ? identifiers[0]['name'] : undefined, 'Logo');
+        strictEqual((identifiers[0] !== undefined) ? identifiers[0]['kind'] : undefined, 'class');
+        return;
+    });
+    it('EC44: branded types follow standard naming', () => {
+        const lines = ['export type Cli_Foo_UserId = string & { __brand: \'UserId\' };'];
+        deepStrictEqual(extractTypeNames(lines), ['Cli_Foo_UserId']);
+        return;
+    });
+    it('EC46: recursive type definition is detected as self-reference (no infinite loop)', () => {
+        const refs = extractReferencedTypes('export type Cli_Foo_Node = { value: string; next: Cli_Foo_Node | null };', 'Cli_Foo');
+        strictEqual(refs.length, 0);
+        return;
+    });
+    it('EC47: enum declaration is not subject to type-naming rules (out of helper scope)', () => {
+        const lines = ['export enum Cli_Foo_Run_Status { Pending, Done }'];
+        deepStrictEqual(extractTypeNames(lines), []);
+        return;
+    });
+    it('[gap] EC52: same-line multi-declaration -- extractBodyDeclarations regex matches one declarator per line, so only the first is captured', () => {
+        const lines = ['  const a: A = 1, b: B = 2;'];
+        const decls = extractBodyDeclarations(lines);
+        strictEqual(decls.length, 1);
+        return;
+    });
+    it('EC54: empty source file produces empty section map (just classPrefix at top-level lines)', () => {
+        const sectionMap = buildSourceSectionMap('/fake/lib/empty.ts', 'export {};\n', 'Lib_Empty');
+        strictEqual(sectionMap.get(1), 'Lib_Empty');
+        return;
+    });
+    return;
+});
+describe('Rule 7.1 integration', () => {
+    it('passes when leaf matches sourceSection_titleVar', () => {
+        strictEqual(validateLeaf('items', 'Cli_Foo_Run_Items', 'Cli_Foo_Run', 'Cli_Foo'), null);
+        return;
+    });
+    it('passes class-prefix passthrough form (skip method chunk)', () => {
+        strictEqual(validateLeaf('items', 'Cli_Foo_Items', 'Cli_Foo_Run', 'Cli_Foo'), null);
+        return;
+    });
+    it('fails when leaf differs from var name', () => {
+        const result = validateLeaf('items', 'Cli_Foo_Run_Things', 'Cli_Foo_Run', 'Cli_Foo');
+        deepStrictEqual(result, {
+            actualLeaf: 'Things', expectedLeaf: 'Items',
+        });
+        return;
+    });
+    it('integrates with extractBodyDeclarations + buildSourceSectionMap', () => {
+        const sourceContent = [
+            'class Runner {',
+            '  bar() {',
+            '    const items: Cli_Foo_Runner_Bar_Items = [];',
+            '  }',
+            '}',
+            '',
+        ].join('\n');
+        const sectionMap = buildSourceSectionMap('/fake/cli/foo.ts', sourceContent, 'Cli_Foo');
+        const decls = extractBodyDeclarations(sourceContent.split('\n'));
+        strictEqual(decls.length, 1);
+        const firstDecl = decls[0];
+        const sourceSection = sectionMap.get((firstDecl !== undefined) ? firstDecl['lineNumber'] : 0) ?? '';
+        strictEqual(sourceSection, 'Cli_Foo_Runner_Bar');
+        strictEqual(validateLeaf((firstDecl !== undefined) ? firstDecl['varName'] : '', (firstDecl !== undefined) ? firstDecl['typeName'] : '', sourceSection, 'Cli_Foo'), null);
+        return;
+    });
+    return;
+});
+describe('Rule E1/E2 integration', () => {
+    it('E1: property type starts with parent type name (passes)', () => {
+        const lines = [
+            'export type Cli_Foo_Run_Result_Status = string;',
+            'export type Cli_Foo_Run_Result = {',
+            '  status: Cli_Foo_Run_Result_Status;',
+            '};',
+        ];
+        const objectTypes = extractObjectTypes(lines, 'Cli_Foo');
+        const result = objectTypes.find((objectType) => objectType['name'] === 'Cli_Foo_Run_Result');
+        strictEqual((result !== undefined && result['properties'][0] !== undefined) ? result['properties'][0]['valueType'].startsWith('Cli_Foo_Run_Result') : false, true);
+        return;
+    });
+    it('E1: property type does not start with parent type name (fails)', () => {
+        const lines = [
+            'export type Cli_Foo_Run_Status = string;',
+            'export type Cli_Foo_Run_Result = {',
+            '  status: Cli_Foo_Run_Status;',
+            '};',
+        ];
+        const objectTypes = extractObjectTypes(lines, 'Cli_Foo');
+        const result = objectTypes.find((objectType) => objectType['name'] === 'Cli_Foo_Run_Result');
+        strictEqual((result !== undefined && result['properties'][0] !== undefined) ? result['properties'][0]['valueType'].startsWith('Cli_Foo_Run_Result') : false, false);
+        return;
+    });
+    it('E2: property type defined before parent (passes)', () => {
+        const lines = [
+            'export type Cli_Foo_Run_Result_Status = string;',
+            'export type Cli_Foo_Run_Result = {',
+            '  status: Cli_Foo_Run_Result_Status;',
+            '};',
+        ];
+        const objectTypes = extractObjectTypes(lines, 'Cli_Foo');
+        const result = objectTypes.find((objectType) => objectType['name'] === 'Cli_Foo_Run_Result');
+        const propertyTypeLine = (result !== undefined && result['properties'][0] !== undefined) ? result['properties'][0]['typeLineIndex'] : -1;
+        const parentLine = (result !== undefined) ? result['lineIndex'] : -1;
+        ok(propertyTypeLine < parentLine);
+        return;
+    });
+    it('E2: property type defined after parent (fails)', () => {
+        const lines = [
+            'export type Cli_Foo_Run_Result = {',
+            '  status: Cli_Foo_Run_Result_Status;',
+            '};',
+            'export type Cli_Foo_Run_Result_Status = string;',
+        ];
+        const objectTypes = extractObjectTypes(lines, 'Cli_Foo');
+        const result = objectTypes.find((objectType) => objectType['name'] === 'Cli_Foo_Run_Result');
+        const propertyTypeLine = (result !== undefined && result['properties'][0] !== undefined) ? result['properties'][0]['typeLineIndex'] : -1;
+        const parentLine = (result !== undefined) ? result['lineIndex'] : -1;
+        ok(propertyTypeLine > parentLine);
+        return;
+    });
+    return;
+});
+describe('Section F coverage integration', () => {
+    it('F1: same-section references are allowed', () => {
+        const refs = extractReferencedTypes('export type Cli_Foo_Run_X = Cli_Foo_Run_Y;', 'Cli_Foo');
+        deepStrictEqual(refs, ['Cli_Foo_Run_Y']);
+        return;
+    });
+    it('F2: sections in alphabetical order check (compare strings directly)', () => {
+        const sectionA = 'Cli_Foo_Bar';
+        const sectionB = 'Cli_Foo_Foo';
+        ok(sectionA < sectionB);
+        return;
+    });
+    it('F4: within section, first-come-first-serve order via findFirstOccurrence', () => {
+        const sourceLines = [
+            'class Runner {',
+            '  bar() {',
+            '    const items: Cli_Foo_Runner_Bar_Items = [];',
+            '    const result: Cli_Foo_Runner_Bar_Result = items;',
+            '  }',
+            '}',
+        ];
+        const itemsLine = findFirstOccurrence(sourceLines, 'Cli_Foo_Runner_Bar_Items');
+        const resultLine = findFirstOccurrence(sourceLines, 'Cli_Foo_Runner_Bar_Result');
+        ok(itemsLine < resultLine);
+        return;
+    });
+    it('F6 forward: every source section should have at least one matching .d.ts type', () => {
+        const dtsLines = ['export type Cli_Foo_Run_X = string;'];
+        const sourceSections = new Set(['Cli_Foo_Run']);
+        const sections = buildDtsSections(dtsLines, sourceSections, 'Cli_Foo');
+        strictEqual(sections.length, 1);
+        strictEqual((sections[0] !== undefined) ? sections[0]['prefix'] : undefined, 'Cli_Foo_Run');
+        return;
+    });
+    it('F6 reverse: orphan multi-chunk type without source section', () => {
+        const dtsLines = ['export type Cli_Foo_NoSource_X = string;'];
+        const sourceSections = new Set();
+        const sections = buildDtsSections(dtsLines, sourceSections, 'Cli_Foo');
+        strictEqual((sections[0] !== undefined) ? sections[0]['prefix'] : undefined, 'Cli_Foo');
+        return;
+    });
+    return;
+});
+describe('Section G imports integration', () => {
+    it('G1: extractImportedNames captures alphabetized inline imports', () => {
+        const lines = ['import type { Apple, Banana, Cherry } from \'./fruits.d.ts\';'];
+        const names = extractImportedNames(lines);
+        ok(names.has('Apple'));
+        ok(names.has('Banana'));
+        ok(names.has('Cherry'));
+        return;
+    });
+    it('G1: multi-line import block alphabetical order can be checked', () => {
+        const specifiers = [
+            'Apple',
+            'Banana',
+            'Cherry',
+        ];
+        const sortedSpecifiers = [...specifiers].sort();
+        deepStrictEqual(specifiers, sortedSpecifiers);
+        return;
+    });
+    it('G1: detects out-of-order specifiers', () => {
+        const specifiers = [
+            'Banana',
+            'Apple',
+            'Cherry',
+        ];
+        const sortedSpecifiers = [...specifiers].sort();
+        ok(specifiers[0] !== sortedSpecifiers[0]);
+        return;
+    });
+    return;
+});
+describe('end-to-end fixture pipeline', () => {
+    it('catches the expected violations across rules 7.1 / 7.2 / 7.3 / 7.4 / 7.5 in a single fixture', () => {
+        const sourceContent = [
+            'class Runner {',
+            '  bar() {',
+            '    const items: Cli_Foo_Wrong_Leaf = [];',
+            '    const result: Cli_Foo_Bar_Result_Returns = [];',
+            '    const data: Cli_Foo_Bar_Data = {};',
+            '    items.filter((x: Cli_Foo_Item) => x);',
+            '  }',
+            '  bad(): Cli_Foo_Runner_Bad_Result { return null; }',
+            '}',
+            '',
+        ].join('\n');
+        const dtsContent = [
+            'export type Cli_Foo_Wrong_Leaf = unknown;',
+            'export type Cli_Foo_Bar_Result_Returns = unknown;',
+            'export type Cli_Foo_Bar_Data = Lib_Utility_X;',
+            'export type Cli_Foo_Item = unknown;',
+            '',
+        ].join('\n');
+        const violations = runRulePipeline('/fake/cli/foo.ts', sourceContent, dtsContent, 'Cli_Foo');
+        ok(violations.some((violation) => violation.startsWith('7.1:')), `7.1 expected, got: ${violations.join(' | ')}`);
+        ok(violations.some((violation) => violation.startsWith('7.2-alias:')), `7.2-alias expected, got: ${violations.join(' | ')}`);
+        ok(violations.some((violation) => violation.startsWith('7.3:')), `7.3 expected, got: ${violations.join(' | ')}`);
+        ok(violations.some((violation) => violation.startsWith('7.4:')), `7.4 expected, got: ${violations.join(' | ')}`);
+        ok(violations.some((violation) => violation.startsWith('7.5/6/7:')), `7.5/6/7 expected, got: ${violations.join(' | ')}`);
+        return;
+    });
+    it('clean fixture (no violations) produces empty violation list', () => {
+        const sourceContent = [
+            'class Runner {',
+            '  bar(): Cli_Foo_Runner_Bar_Returns {',
+            '    const items: Cli_Foo_Runner_Bar_Items = [];',
+            '    return items;',
+            '  }',
+            '}',
+            '',
+        ].join('\n');
+        const dtsContent = [
+            'export type Cli_Foo_Runner_Bar_Items = unknown[];',
+            'export type Cli_Foo_Runner_Bar_Returns = Cli_Foo_Runner_Bar_Items;',
+            '',
+        ].join('\n');
+        const violations = runRulePipeline('/fake/cli/foo.ts', sourceContent, dtsContent, 'Cli_Foo');
+        strictEqual(violations.length, 0, violations.join(' | '));
+        return;
+    });
+    return;
+});
+export async function discoverSourceFiles() {
+    const patterns = testConfig['typeRoots'].map((typeRoot) => `${typeRoot}/**/*.ts`);
+    const ignorePatterns = testConfig['typeRoots'].map((typeRoot) => `${typeRoot}/**/*.d.ts`);
+    const matched = await glob(patterns, {
+        cwd: getPackageRoot(),
+        absolute: true,
+        ignore: ignorePatterns,
+    });
+    return matched.sort();
+}
+export async function discoverTypeFiles() {
+    const patterns = testConfig['typeRoots'].map((typeRoot) => `${typeRoot}/types/**/*.d.ts`);
+    const matched = await glob(patterns, {
+        cwd: getPackageRoot(),
+        absolute: true,
+    });
+    return matched.sort();
+}
+export function deriveClassPrefix(filePath) {
+    const currentDirectory = getPackageRoot();
+    const relativePath = relative(currentDirectory, filePath);
+    let relativeCleaned = relativePath;
+    for (const typeRoot of testConfig['typeRoots']) {
+        relativeCleaned = relativeCleaned.replace(`${typeRoot}/types/`, '');
+        relativeCleaned = relativeCleaned.replace(`${typeRoot}/`, '');
+    }
+    const segments = relativeCleaned
+        .replace('.d.ts', '')
+        .replace('.ts', '')
+        .replace('.test', '')
+        .split(sep)
+        .join('/')
+        .split('/');
+    const camelCaseWordsPattern = new RegExp('[a-z]+|[A-Z]{2,}(?=[A-Z][a-z]|\\b|$)|[A-Z][a-z]*', 'g');
+    return segments.map((segment) => {
+        if (segment.includes('-') === false
+            && segment.charAt(0) === segment.charAt(0).toUpperCase()
+            && segment.length > 0) {
+            const words = segment.match(camelCaseWordsPattern);
+            if (words !== null) {
+                return words.map((word) => {
+                    return word.charAt(0).toUpperCase() + word.slice(1).toLowerCase();
+                }).join('');
+            }
+        }
+        return segment.split('-').map((part) => {
+            return part.charAt(0).toUpperCase() + part.slice(1);
+        }).join('');
+    }).join('_');
+}
+export function extractImportedNames(lines) {
+    const importedNames = new Set();
+    let inImportBlock = false;
+    for (const line of lines) {
+        if (line.startsWith('import type') === true) {
+            inImportBlock = true;
+            const inlineMatch = line.match(new RegExp('^import type \\{ (.+) \\} from'));
+            if (inlineMatch !== null && inlineMatch[1] !== undefined) {
+                const inlineMatchCapture = inlineMatch[1];
+                const specifiers = inlineMatchCapture.split(',').map((specifier) => specifier.trim());
+                for (const specifier of specifiers) {
+                    importedNames.add(specifier);
+                }
+                inImportBlock = false;
+            }
+            continue;
+        }
+        if (inImportBlock === true) {
+            const trimmed = line.trim().replace(',', '');
+            if (trimmed.startsWith('}') === true) {
+                inImportBlock = false;
+            }
+            else if (trimmed !== '' && trimmed.startsWith('//') === false) {
+                importedNames.add(trimmed);
+            }
+        }
+    }
+    return importedNames;
+}
+export function buildDtsSections(dtsLines, sourceSections, classPrefix) {
+    const sortedSections = [...sourceSections].sort((sectionA, sectionB) => sectionB.length - sectionA.length);
+    const sectionMap = new Map();
+    const sectionOrder = [];
+    for (const line of dtsLines) {
+        if (line.startsWith('export type ') === false) {
+            continue;
+        }
+        const match = line.match(new RegExp('^export type (\\w+)'));
+        if (match === null || match[1] === undefined) {
+            continue;
+        }
+        const typeName = match[1];
+        let owningSection = '';
+        for (const candidate of sortedSections) {
+            if (typeName.startsWith(`${candidate}_`) === true) {
+                owningSection = candidate;
+                break;
+            }
+        }
+        if (owningSection === '' && typeName.startsWith(`${classPrefix}_`) === true) {
+            owningSection = classPrefix;
+        }
+        if (owningSection === '') {
+            continue;
+        }
+        if (sectionMap.has(owningSection) === false) {
+            sectionMap.set(owningSection, {
+                prefix: owningSection,
+                typeLines: [],
+            });
+            sectionOrder.push(owningSection);
+        }
+        const section = sectionMap.get(owningSection);
+        section['typeLines'].push(line);
+    }
+    return sectionOrder.map((prefix) => sectionMap.get(prefix));
+}
+export function extractReferencedTypes(line, classPrefix) {
+    const match = line.match(new RegExp('^export type (\\w+)'));
+    if (match === null || match[1] === undefined) {
+        return [];
+    }
+    const typeName = match[1];
+    const rightSide = line.slice(line.indexOf('=') + 1);
+    const referencedTypes = [];
+    const typePattern = new RegExp(`${classPrefix}_\\w+`, 'g');
+    let typeMatch = typePattern.exec(rightSide);
+    while (typeMatch !== null) {
+        const referencedType = typeMatch[0];
+        if (referencedType !== typeName) {
+            referencedTypes.push(referencedType);
+        }
+        typeMatch = typePattern.exec(rightSide);
+    }
+    return referencedTypes;
+}
+export function deriveSourcePath(dtsPath) {
+    return dtsPath.replace('/types/', '/').replace('.d.ts', '.ts');
+}
+export async function fileExists(filePath) {
+    try {
+        await readFile(filePath, 'utf-8');
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function getPackageRoot() {
+    const currentFilePath = fileURLToPath(import.meta.url);
+    const currentFileDirectory = dirname(currentFilePath);
+    return resolve(currentFileDirectory, '..', '..');
+}
+export function extractTypeNames(typeLines) {
+    const typeNames = [];
+    for (const line of typeLines) {
+        const match = line.match(new RegExp('^export type (\\w+)'));
+        if (match !== null && match[1] !== undefined) {
+            typeNames.push(match[1]);
+        }
+    }
+    return typeNames;
+}
+export function findFirstOccurrence(sourceLines, typeName) {
+    let inImportBlock = false;
+    for (let i = 0; i < sourceLines.length; i += 1) {
+        const line = sourceLines[i];
+        if (line === undefined) {
+            continue;
+        }
+        if (line.startsWith('import ') === true || line.startsWith('import type') === true) {
+            inImportBlock = true;
+        }
+        if (inImportBlock === true) {
+            if (line.includes(' from ') === true) {
+                inImportBlock = false;
+            }
             continue;
         }
         const typeNamePattern = new RegExp(`\\b${typeName}\\b`);
@@ -473,7 +3030,7 @@ function findFirstOccurrence(sourceLines, typeName) {
     }
     return -1;
 }
-function extractObjectTypes(lines, classPrefix) {
+export function extractObjectTypes(lines, classPrefix) {
     const objectTypes = [];
     const typeLineMap = new Map();
     for (let i = 0; i < lines.length; i += 1) {
@@ -487,11 +3044,11 @@ function extractObjectTypes(lines, classPrefix) {
         }
     }
     for (let i = 0; i < lines.length; i += 1) {
-        const line = lines[i];
-        if (line === undefined) {
+        const line2 = lines[i];
+        if (line2 === undefined) {
             continue;
         }
-        const objectMatch = line.match(new RegExp(`^export type (${classPrefix}\\w+) = (?:Readonly<)?\\{$`));
+        const objectMatch = line2.match(new RegExp(`^export type (${classPrefix}\\w+) = (?:Readonly<)?\\{$`));
         if (objectMatch === null || objectMatch[1] === undefined) {
             continue;
         }
@@ -530,35 +3087,499 @@ function extractObjectTypes(lines, classPrefix) {
     }
     return objectTypes;
 }
-function extractSourceSections(lines) {
-    const sections = [];
-    let nextIsSummary = false;
-    for (const line of lines) {
-        if (line.trim() === '/**') {
-            nextIsSummary = true;
+const sourceFileCache = new Map();
+export function parseSourceFile(filePath, content) {
+    const cached = sourceFileCache.get(filePath);
+    if (cached !== undefined && cached['content'] === content) {
+        return cached['sourceFile'];
+    }
+    const sourceFile = createSourceFile(filePath, content, ScriptTarget.Latest, true);
+    sourceFileCache.set(filePath, {
+        content, sourceFile,
+    });
+    return sourceFile;
+}
+export function extractFunctionParams(filePath, content) {
+    const sourceFile = parseSourceFile(filePath, content);
+    const params = [];
+    function visit(node) {
+        let parameterList = undefined;
+        if (isFunctionDeclaration(node) === true
+            || isMethodDeclaration(node) === true
+            || isConstructorDeclaration(node) === true) {
+            parameterList = node['parameters'];
+        }
+        else if (isVariableStatement(node) === true) {
+            for (const decl of node.declarationList.declarations) {
+                if (decl.initializer !== undefined
+                    && (isArrowFunction(decl.initializer) === true
+                        || isFunctionExpression(decl.initializer) === true)) {
+                    parameterList = decl.initializer.parameters;
+                }
+            }
+        }
+        if (parameterList !== undefined) {
+            for (const param of parameterList) {
+                const paramNode = param;
+                if (paramNode['name'] !== undefined
+                    && isIdentifier(paramNode['name']) === true
+                    && paramNode['type'] !== undefined
+                    && isTypeReferenceNode(paramNode['type']) === true
+                    && isIdentifier(paramNode['type']['typeName']) === true) {
+                    const lineNumber = sourceFile.getLineAndCharacterOfPosition((param).getStart()).line + 1;
+                    const paramRecord = {
+                        paramName: paramNode['name']['text'],
+                        typeName: paramNode['type']['typeName']['text'],
+                        lineNumber,
+                    };
+                    params.push(paramRecord);
+                }
+            }
+        }
+        forEachChild(node, visit);
+        return;
+    }
+    forEachChild(sourceFile, visit);
+    return params;
+}
+export function extractBodyDeclarations(lines) {
+    const declarations = [];
+    for (let i = 0; i < lines.length; i += 1) {
+        const line = lines[i];
+        if (line === undefined) {
             continue;
         }
-        if (nextIsSummary === true) {
-            nextIsSummary = false;
-            const sectionComment = line.match(new RegExp('^\\s*\\* (.+)\\.$'));
-            if (sectionComment !== null
-                && sectionComment[1] !== undefined
-                && line.includes('@') === false
-                && sectionComment[1].includes(' - ') === true) {
-                const rawPrefix = sectionComment[1];
-                const segments = rawPrefix.split(' - ');
-                const methodName = segments.map((segment) => {
-                    return segment.split(new RegExp('[\\s.]+', 'g')).map((word) => {
-                        return word.charAt(0).toUpperCase() + word.slice(1).toLowerCase();
-                    }).join('');
-                }).join('');
-                sections.push({
-                    prefix: methodName,
-                    typeLines: [],
-                });
+        const match = line.match(new RegExp('^\\s*(const|let)\\s+(\\w+):\\s+(\\w+)\\s*='));
+        if (match !== null
+            && match[1] !== undefined
+            && match[2] !== undefined
+            && match[3] !== undefined) {
+            const declaration = {
+                keyword: match[1],
+                varName: match[2],
+                typeName: match[3],
+                lineNumber: i + 1,
+            };
+            declarations.push(declaration);
+        }
+    }
+    return declarations;
+}
+export function extractTopLevelIdentifiers(filePath, content) {
+    const sourceFile = parseSourceFile(filePath, content);
+    const identifiers = [];
+    function getLine(node) {
+        return sourceFile.getLineAndCharacterOfPosition(node.getStart()).line + 1;
+    }
+    forEachChild(sourceFile, (node) => {
+        if (isClassDeclaration(node) === true && node.name !== undefined) {
+            const identifier = {
+                name: node.name.text,
+                kind: 'class',
+                lineNumber: getLine(node),
+            };
+            identifiers.push(identifier);
+            return;
+        }
+        if (isFunctionDeclaration(node) === true && node.name !== undefined) {
+            const identifier2 = {
+                name: node.name.text,
+                kind: 'function',
+                lineNumber: getLine(node),
+            };
+            identifiers.push(identifier2);
+            return;
+        }
+        if (isVariableStatement(node) === true) {
+            for (const decl of node.declarationList.declarations) {
+                if (decl.name !== undefined
+                    && isIdentifier(decl.name) === true
+                    && decl.initializer !== undefined
+                    && (isArrowFunction(decl.initializer) === true
+                        || isFunctionExpression(decl.initializer) === true
+                        || isClassExpression(decl.initializer) === true)) {
+                    const identifier3 = {
+                        name: decl.name.text,
+                        kind: 'const',
+                        lineNumber: getLine(decl),
+                    };
+                    identifiers.push(identifier3);
+                }
+            }
+        }
+        return;
+    });
+    return identifiers;
+}
+export function buildSourceSectionMap(filePath, content, classPrefix) {
+    const sourceFile = parseSourceFile(filePath, content);
+    const sectionMap = new Map();
+    const maxDepth = 5000;
+    function getLine(node) {
+        return sourceFile.getLineAndCharacterOfPosition(node.getStart()).line + 1;
+    }
+    function pascalCase(name) {
+        return name.charAt(0).toUpperCase() + name.slice(1);
+    }
+    let currentDepth = 0;
+    function tagAllChildren(node, section) {
+        if (currentDepth >= maxDepth) {
+            return;
+        }
+        currentDepth += 1;
+        forEachChild(node, (child) => visit(child, section));
+        currentDepth -= 1;
+        return;
+    }
+    function visit(node, section) {
+        if (isClassDeclaration(node) === true && node.name !== undefined) {
+            const newSection = `${section}_${pascalCase(node.name.text)}`;
+            sectionMap.set(getLine(node), newSection);
+            tagAllChildren(node, newSection);
+            return;
+        }
+        const accessor = node;
+        if ((isMethodDeclaration(node) === true
+            || isGetAccessorDeclaration(node) === true
+            || isSetAccessorDeclaration(node) === true)
+            && accessor.name !== undefined
+            && (isIdentifier(accessor.name) === true
+                || isPrivateIdentifier(accessor.name) === true)) {
+            const rawMethodName = accessor.name.text;
+            const cleanMethodName = (rawMethodName.startsWith('#') === true) ? rawMethodName.slice(1) : rawMethodName;
+            const newSection2 = `${section}_${pascalCase(cleanMethodName)}`;
+            sectionMap.set(getLine(node), newSection2);
+            tagAllChildren(node, newSection2);
+            return;
+        }
+        if (isConstructorDeclaration(node) === true) {
+            const newSection3 = `${section}_Constructor`;
+            sectionMap.set(getLine(node), newSection3);
+            tagAllChildren(node, newSection3);
+            return;
+        }
+        if (isFunctionDeclaration(node) === true && node.name !== undefined) {
+            const newSection4 = `${section}_${pascalCase(node.name.text)}`;
+            sectionMap.set(getLine(node), newSection4);
+            tagAllChildren(node, newSection4);
+            return;
+        }
+        if (isVariableStatement(node) === true) {
+            let hasInitializer = false;
+            let subSection = section;
+            for (const decl of node.declarationList.declarations) {
+                if (decl.name !== undefined
+                    && isIdentifier(decl.name) === true
+                    && decl.initializer !== undefined
+                    && (isArrowFunction(decl.initializer) === true
+                        || isFunctionExpression(decl.initializer) === true
+                        || isClassExpression(decl.initializer) === true)) {
+                    hasInitializer = true;
+                    subSection = `${section}_${pascalCase(decl.name.text)}`;
+                }
+            }
+            sectionMap.set(getLine(node), section);
+            if (hasInitializer === true) {
+                for (const decl of node.declarationList.declarations) {
+                    if (decl.initializer === undefined) {
+                        continue;
+                    }
+                    if (isArrowFunction(decl.initializer) === true || isFunctionExpression(decl.initializer) === true) {
+                        if (decl.initializer.body !== undefined) {
+                            tagAllChildren(decl.initializer.body, subSection);
+                        }
+                    }
+                    else if (isClassExpression(decl.initializer) === true) {
+                        tagAllChildren(decl.initializer, subSection);
+                    }
+                }
+            }
+            else {
+                tagAllChildren(node, section);
+            }
+            return;
+        }
+        if (isCallExpression(node) === true
+            && node.arguments.length >= 2
+            && node.arguments[0] !== undefined
+            && isStringLiteral(node.arguments[0]) === true) {
+            let callbackArg = undefined;
+            for (let argIndex = 1; argIndex < node.arguments.length; argIndex += 1) {
+                const arg = node.arguments[argIndex];
+                if (arg !== undefined
+                    && (isArrowFunction(arg) === true
+                        || isFunctionExpression(arg) === true)) {
+                    callbackArg = arg;
+                    break;
+                }
+            }
+            if (callbackArg !== undefined) {
+                const stringArg = node.arguments[0];
+                const chunk = parseDescribeString(stringArg.text);
+                if (chunk !== '') {
+                    const newSection5 = `${section}_${chunk}`;
+                    sectionMap.set(getLine(node), section);
+                    tagAllChildren(callbackArg, newSection5);
+                    return;
+                }
+            }
+        }
+        sectionMap.set(getLine(node), section);
+        tagAllChildren(node, section);
+        return;
+    }
+    forEachChild(sourceFile, (child) => visit(child, classPrefix));
+    return sectionMap;
+}
+export function parseDescribeString(input) {
+    const pieces = input
+        .split(new RegExp('[^A-Za-z0-9]+'))
+        .filter((piece) => piece.length > 0)
+        .map((piece) => piece.charAt(0).toUpperCase() + piece.slice(1));
+    return pieces.join('');
+}
+export function stripUnderscorePrefix(input) {
+    if (input.startsWith('_') === true) {
+        return input.slice(1);
+    }
+    return input;
+}
+export function checkTypeNameUniqueness(declarations) {
+    const violations = [];
+    const seen = new Map();
+    for (const declaration of declarations) {
+        const existing = seen.get(declaration['typeName']);
+        if (existing !== undefined) {
+            const violation = `Two declarations would produce the same type name '${declaration['typeName']}'. First: line ${existing['lineNumber']} ('${existing['name']}'); duplicate: line ${declaration['lineNumber']} ('${declaration['name']}'). Rename one of the declarations so the type names differ.`;
+            violations.push(violation);
+        }
+        else {
+            seen.set(declaration['typeName'], {
+                name: declaration['name'],
+                lineNumber: declaration['lineNumber'],
+            });
+        }
+    }
+    return violations;
+}
+export function detectInlineTypedCallbacks(filePath, content) {
+    const sourceFile = parseSourceFile(filePath, content);
+    const callbacks = [];
+    function visit(node) {
+        if ((isArrowFunction(node) === true
+            || isFunctionExpression(node) === true)
+            && node.parent !== undefined) {
+            let isFunctionTypedConst = false;
+            let walker = node.parent;
+            while (walker !== undefined) {
+                if (isVariableStatement(walker) === true) {
+                    isFunctionTypedConst = true;
+                    break;
+                }
+                if (walker['kind'] !== undefined
+                    && (isCallExpression(walker) === true
+                        || isArrowFunction(walker) === true
+                        || isFunctionExpression(walker) === true)) {
+                    break;
+                }
+                walker = walker['parent'];
+            }
+            if (isFunctionTypedConst === false) {
+                for (const param of node.parameters) {
+                    const paramNode = param;
+                    if (paramNode['name'] !== undefined
+                        && isIdentifier(paramNode['name']) === true
+                        && paramNode['type'] !== undefined
+                        && isTypeReferenceNode(paramNode['type']) === true
+                        && isIdentifier(paramNode['type']['typeName']) === true) {
+                        const lineNumber = sourceFile.getLineAndCharacterOfPosition(param.getStart()).line + 1;
+                        const callback = {
+                            paramName: paramNode['name']['text'],
+                            typeName: paramNode['type']['typeName']['text'],
+                            lineNumber,
+                        };
+                        callbacks.push(callback);
+                    }
+                }
+            }
+        }
+        forEachChild(node, visit);
+        return;
+    }
+    forEachChild(sourceFile, visit);
+    return callbacks;
+}
+export function extractArrayTypes(lines) {
+    const arrayTypes = [];
+    for (let i = 0; i < lines.length; i += 1) {
+        const line = lines[i];
+        if (line === undefined) {
+            continue;
+        }
+        const match = line.match(new RegExp('^export type (\\w+) = (\\w+)\\[\\];?$'));
+        if (match !== null
+            && match[1] !== undefined
+            && match[2] !== undefined) {
+            const arrayType = {
+                arrayTypeName: match[1],
+                elementTypeName: match[2],
+                lineIndex: i,
+            };
+            arrayTypes.push(arrayType);
+        }
+    }
+    return arrayTypes;
+}
+export function extractFunctionReturns(filePath, content) {
+    const sourceFile = parseSourceFile(filePath, content);
+    const returnRecords = [];
+    function visit(node) {
+        if (isFunctionDeclaration(node) === true
+            || isMethodDeclaration(node) === true
+            || isConstructorDeclaration(node) === true) {
+            const fnNode = node;
+            const typeNode = fnNode['type'];
+            if (typeNode !== undefined) {
+                let returnType = '';
+                let typeGuardFlag = false;
+                if (isTypePredicateNode(typeNode) === true) {
+                    typeGuardFlag = true;
+                    const predicateNode = typeNode;
+                    if (predicateNode['type'] !== undefined
+                        && isTypeReferenceNode(predicateNode['type']) === true
+                        && isIdentifier(predicateNode['type']['typeName']) === true) {
+                        returnType = predicateNode['type']['typeName']['text'];
+                    }
+                }
+                else if (isTypeReferenceNode(typeNode) === true && isIdentifier(typeNode['typeName']) === true) {
+                    returnType = typeNode['typeName']['text'];
+                }
+                if (returnType !== '') {
+                    const lineNumber = sourceFile.getLineAndCharacterOfPosition(node.getStart()).line + 1;
+                    const returnRecord = {
+                        returnType,
+                        isTypeGuard: typeGuardFlag,
+                        lineNumber,
+                    };
+                    returnRecords.push(returnRecord);
+                }
             }
         }
+        forEachChild(node, visit);
+        return;
+    }
+    forEachChild(sourceFile, visit);
+    return returnRecords;
+}
+export function isAliasToForeignType(typeName, dtsContent, classPrefix) {
+    const escapedTypeName = typeName.replace(new RegExp('[.*+?^${}()|[\\]\\\\]', 'g'), '\\$&');
+    const pattern = new RegExp(`^export type ${escapedTypeName}\\s*=\\s*([^;]+);`, 'm');
+    const match = dtsContent.match(pattern);
+    if (match === null || match[1] === undefined) {
+        return false;
+    }
+    let rhs = match[1].trim();
+    rhs = rhs.replace(new RegExp('<[^>]*>', 'g'), '');
+    rhs = rhs.replace(new RegExp('\\[\\]', 'g'), '');
+    if (new RegExp('[|&{}();,]').test(rhs) === true) {
+        return false;
+    }
+    const typeMatch = rhs.trim().match(new RegExp('^([A-Z][A-Za-z0-9_]*)$'));
+    if (typeMatch === null || typeMatch[1] === undefined) {
+        return false;
+    }
+    const leftmostType = typeMatch[1];
+    if (leftmostType.includes('_') === false) {
+        return false;
+    }
+    if (leftmostType.startsWith(`${classPrefix}_`) === true) {
+        return false;
+    }
+    return true;
+}
+export function isLocallyDefined(typeName, dtsContent) {
+    const escapedTypeName = typeName.replace(new RegExp('[.*+?^${}()|[\\]\\\\]', 'g'), '\\$&');
+    const pattern = new RegExp(`^export type ${escapedTypeName}\\b`, 'm');
+    return pattern.test(dtsContent);
+}
+export function isReservedSuffix(typeName) {
+    return (typeName.endsWith('_Returns') === true
+        || typeName.endsWith('_TypeGuard') === true
+        || typeName.endsWith('_Return') === true
+        || typeName.endsWith('Returns') === true
+        || typeName.endsWith('TypeGuard') === true
+        || typeName.endsWith('Return') === true);
+}
+export function validateLeaf(varName, typeName, sourceSection, classPrefix) {
+    const stripped = stripUnderscorePrefix(varName);
+    const titleVar = stripped.charAt(0).toUpperCase() + stripped.slice(1);
+    const expectedSection = `${sourceSection}_${titleVar}`;
+    const expectedClass = `${classPrefix}_${titleVar}`;
+    if (typeName === expectedSection || typeName === expectedClass) {
+        return null;
+    }
+    let actualLeaf = typeName;
+    if (typeName.startsWith(`${sourceSection}_`) === true) {
+        actualLeaf = typeName.slice(sourceSection.length + 1);
+    }
+    else if (typeName.startsWith(`${classPrefix}_`) === true) {
+        actualLeaf = typeName.slice(classPrefix.length + 1);
+    }
+    return {
+        actualLeaf,
+        expectedLeaf: titleVar,
+    };
+}
+export function validateReturnType(returnType, typeGuardFlag) {
+    if (returnType.endsWith('_Return') === true || returnType.endsWith('Return') === true) {
+        return `Return type '${returnType}' uses banned singular 'Return' suffix; rename to use 'Returns' (plural).`;
+    }
+    if (typeGuardFlag === true) {
+        if (returnType.endsWith('_TypeGuard') === false && returnType.endsWith('TypeGuard') === false) {
+            return `Type-guard return type '${returnType}' must end in 'TypeGuard'.`;
+        }
+    }
+    else if (returnType.endsWith('_Returns') === false && returnType.endsWith('Returns') === false) {
+        if (returnType.endsWith('_TypeGuard') === true || returnType.endsWith('TypeGuard') === true) {
+            return `Return type '${returnType}' ends in 'TypeGuard' but the function does not use 'value is T' form; either rename to '_Returns' or rewrite as a type guard.`;
+        }
+        return `Function return type '${returnType}' must end in 'Returns' (plural).`;
+    }
+    return null;
+}
+export function runRulePipeline(filePath, sourceContent, dtsContent, classPrefix) {
+    const sectionMap = buildSourceSectionMap(filePath, sourceContent, classPrefix);
+    const lines = sourceContent.split('\n');
+    const declarations = extractBodyDeclarations(lines);
+    const callbacks = detectInlineTypedCallbacks(filePath, sourceContent);
+    const fnReturnRecords = extractFunctionReturns(filePath, sourceContent);
+    const violations = [];
+    for (const callback of callbacks) {
+        violations.push(`7.4: ${callback['paramName']}: ${callback['typeName']}`);
+    }
+    for (const declaration of declarations) {
+        const sourceSection = sectionMap.get(declaration['lineNumber']) ?? classPrefix;
+        if (isReservedSuffix(declaration['typeName']) === true) {
+            violations.push(`7.3: ${declaration['varName']}: ${declaration['typeName']}`);
+            continue;
+        }
+        const leafResult = validateLeaf(declaration['varName'], declaration['typeName'], sourceSection, classPrefix);
+        if (leafResult !== null) {
+            violations.push(`7.1: ${declaration['varName']}: ${declaration['typeName']}`);
+        }
+        if (isLocallyDefined(declaration['typeName'], dtsContent) === false) {
+            violations.push(`7.2-not-defined: ${declaration['typeName']}`);
+        }
+        else if (isAliasToForeignType(declaration['typeName'], dtsContent, classPrefix) === true) {
+            violations.push(`7.2-alias: ${declaration['typeName']}`);
+        }
+    }
+    for (const fnReturn of fnReturnRecords) {
+        const reason = validateReturnType(fnReturn['returnType'], fnReturn['isTypeGuard']);
+        if (reason !== null) {
+            violations.push(`7.5/6/7: ${fnReturn['returnType']}`);
+        }
     }
-    return sections;
+    return violations;
 }
 //# sourceMappingURL=type-declarations.test.js.map