Enforce typed test and tooling boundaries

eslint.config.mjs

@@ -12,14 +12,28 @@ const eslintConfig = [
       '**/node_modules/**',
       '**/coverage/**',
       '**/docs/**',
-      '**/test/declarations/**',
       '**/*.js',
       '**/*.mjs',
       '**/libs/**',
       // OCF schema submodule - contains TypeScript files not part of our codebase
       '**/Open-Cap-Format-OCF/**',
     ],
   },
+  // Fail closed when a TypeScript file is "disabled" by appending another suffix
+  // (for example, `example.test.ts.skip`). Such files otherwise escape both the
+  // TypeScript project and the `**/*.ts` ESLint configuration silently.
+  {
+    files: ['**/*.ts.*', '**/*.tsx.*'],
+    rules: {
+      'no-restricted-syntax': [
+        'error',
+        {
+          selector: 'Program',
+          message: 'TypeScript source files must end in .ts or .tsx; do not append a suffix after the extension.',
+        },
+      ],
+    },
+  },
   // Main configuration for TypeScript files
   {
     files: ['**/*.ts', '**/*.tsx'],
@@ -31,6 +45,7 @@ const eslintConfig = [
           './tsconfig.tests.json',
           './tsconfig.declaration-tests.json',
           './tsconfig.exact-public-config-tests.json',
+          './tsconfig.package-consumer-tests.json',
         ],
         ecmaVersion: 2020,
         sourceType: 'module',
@@ -182,7 +197,6 @@ const eslintConfig = [
     files: ['scripts/**/*', 'test/**/*'],
     rules: {
       'no-console': 'off',
-      '@typescript-eslint/no-explicit-any': 'off',
       '@typescript-eslint/no-require-imports': 'off',
       '@typescript-eslint/explicit-module-boundary-types': 'off',
       '@typescript-eslint/no-non-null-assertion': 'off',

package.json

@@ -49,10 +49,11 @@
     "test": "npm run -s typecheck && jest --passWithNoTests",
     "test:ci": "npm run -s typecheck && jest --runInBand --coverage",
     "test:coverage": "jest --coverage --passWithNoTests",
-    "test:declarations": "ts-node --project tsconfig.tests.json scripts/check-declarations.ts && tsc -p tsconfig.declaration-tests.json --noEmit && npm run -s test:exact-public-config && node scripts/check-built-cardinality.cjs",
+    "test:declarations": "npm run -s clean && npm run -s build && ts-node --project tsconfig.tests.json scripts/check-declarations.ts && tsc -p tsconfig.declaration-tests.json --noEmit && npm run -s test:exact-public-config && node scripts/check-built-cardinality.cjs && npm run -s test:package-consumer",
     "test:exact-public-config": "tsc -p tsconfig.exact-public-config-tests.json --noEmit",
     "test:integration": "npm run -s typecheck && jest -c jest.integration.config.js --passWithNoTests",
     "test:integration:ci": "npm run -s typecheck && jest -c jest.integration.config.js --runInBand",
+    "test:package-consumer": "tsc -p tsconfig.package-consumer-tests.json --noEmit",
     "test:watch": "jest --watch",
     "typecheck": "tsc -p tsconfig.tests.json --noEmit"
   },

scripts/check-declarations.ts

@@ -8,6 +8,7 @@ import {
 
 const projectRoot = process.cwd();
 const configPath = path.join(projectRoot, 'tsconfig.json');
+const packageJsonPath = path.join(projectRoot, 'package.json');
 const declarationEntryPoint = path.join(projectRoot, 'dist', 'index.d.ts');
 const strictConsumerEntryPoint = path.join(projectRoot, 'test', 'declarations', 'publicApi.types.ts');
 const declarationRoot = `${path.dirname(declarationEntryPoint)}${path.sep}`;
@@ -20,10 +21,95 @@ const diagnosticHost: ts.FormatDiagnosticsHost = {
   getNewLine: () => ts.sys.newLine,
 };
 
+function asRecord(value: unknown, description: string): Record<string, unknown> {
+  if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+    throw new Error(`${description} must be an object`);
+  }
+  return value as Record<string, unknown>;
+}
+
+function requireString(record: Record<string, unknown>, property: string, description: string): string {
+  const value = record[property];
+  if (typeof value !== 'string' || value.length === 0) {
+    throw new Error(`${description}.${property} must be a non-empty string`);
+  }
+  return value;
+}
+
+function normalizedPackageTarget(target: string): string {
+  return target.startsWith('./') ? target.slice(2) : target;
+}
+
+function verifyPackageTarget(label: string, target: string, expectedExtension: '.d.ts' | '.js'): string {
+  const normalizedTarget = normalizedPackageTarget(target);
+  if (!normalizedTarget.startsWith(`dist${path.sep}`) && !normalizedTarget.startsWith('dist/')) {
+    throw new Error(`${label} must reference a generated dist artifact, received: ${target}`);
+  }
+  if (!normalizedTarget.endsWith(expectedExtension)) {
+    throw new Error(`${label} must end in ${expectedExtension}, received: ${target}`);
+  }
+
+  const absoluteTarget = path.resolve(projectRoot, normalizedTarget);
+  const distRoot = path.resolve(projectRoot, 'dist');
+  if (absoluteTarget !== distRoot && !absoluteTarget.startsWith(`${distRoot}${path.sep}`)) {
+    throw new Error(`${label} escapes the generated dist directory: ${target}`);
+  }
+  if (!fs.existsSync(absoluteTarget)) {
+    throw new Error(`${label} references a missing package artifact: ${target}`);
+  }
+  return absoluteTarget;
+}
+
+function verifyPackageEntryPoints(): void {
+  const packageJsonValue: unknown = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+  const packageJson = asRecord(packageJsonValue, 'package.json');
+  const exportsMap = asRecord(packageJson.exports, 'package.json exports');
+  const rootExport = asRecord(exportsMap['.'], 'package.json exports["."]');
+
+  const rootTypes = verifyPackageTarget(
+    'package.json exports["."].types',
+    requireString(rootExport, 'types', 'package.json exports["."]'),
+    '.d.ts'
+  );
+  const topLevelTypes = verifyPackageTarget(
+    'package.json types',
+    requireString(packageJson, 'types', 'package.json'),
+    '.d.ts'
+  );
+  if (rootTypes !== topLevelTypes || rootTypes !== declarationEntryPoint) {
+    throw new Error('package.json types and exports["."].types must both reference dist/index.d.ts');
+  }
+
+  const rootImport = verifyPackageTarget(
+    'package.json exports["."].import',
+    requireString(rootExport, 'import', 'package.json exports["."]'),
+    '.js'
+  );
+  const rootRequire = verifyPackageTarget(
+    'package.json exports["."].require',
+    requireString(rootExport, 'require', 'package.json exports["."]'),
+    '.js'
+  );
+  const rootDefault = verifyPackageTarget(
+    'package.json exports["."].default',
+    requireString(rootExport, 'default', 'package.json exports["."]'),
+    '.js'
+  );
+  const topLevelMain = verifyPackageTarget(
+    'package.json main',
+    requireString(packageJson, 'main', 'package.json'),
+    '.js'
+  );
+  if (rootImport !== rootRequire || rootImport !== rootDefault || rootImport !== topLevelMain) {
+    throw new Error('package.json main and exports["."] runtime targets must reference the same built entry point');
+  }
+}
+
 if (!fs.existsSync(declarationEntryPoint)) {
   throw new Error(`Declaration entry point not found: ${declarationEntryPoint}. Run npm run build first.`);
 }
 
+verifyPackageEntryPoints();
 const sourcePublicTypes = inventoryCanonicalOcfPublicTypes(projectRoot, 'source');
 const builtPublicTypes = inventoryCanonicalOcfPublicTypes(projectRoot, 'built');
 const publicTypeDrift = describeCanonicalOcfPublicTypeDrift(sourcePublicTypes, builtPublicTypes);

scripts/optimize-fixtures.ts

@@ -80,9 +80,9 @@ function runCoverage(): CoverageData {
     });
 
     return parseCoverage(output);
-  } catch (error: any) {
+  } catch (error: unknown) {
     // Jest might exit with non-zero code even on successful coverage run
-    if (error.stdout) {
+    if (typeof error === 'object' && error !== null && 'stdout' in error && typeof error.stdout === 'string') {
       return parseCoverage(error.stdout);
     }
     throw error;

test/batch/generatedOperationConstruction.test.ts

@@ -25,7 +25,7 @@ function loadEntityFixture<T extends OcfEntityType>(
   entityType: T,
   relativePath: string
 ): readonly [type: T, data: OcfWritableDataTypeFor<T>] {
-  const fixture = stripSourceMetadata(loadFixture<Record<string, unknown>>(relativePath));
+  const fixture = stripSourceMetadata(loadFixture(relativePath));
   const canonicalFixture = parseOcfObject(fixture);
   return [entityType, parseOcfEntityInput(entityType, canonicalFixture)];
 }
@@ -183,9 +183,7 @@ describe('generated DAML batch operation construction', () => {
   test('constructs correlated operation objects without rebuilding asserted tuples', () => {
     const stakeholder = parseOcfEntityInput(
       'stakeholder',
-      parseOcfObject(
-        stripSourceMetadata(loadFixture<Record<string, unknown>>('production/stakeholder/individual.json'))
-      )
+      parseOcfObject(stripSourceMetadata(loadFixture('production/stakeholder/individual.json')))
     );
     const { command } = buildUpdateCapTableCommand(
       { capTableContractId: 'cap-table-generated-operation-1' },

test/converters/convertibleIssuanceConverters.test.ts

@@ -18,9 +18,10 @@ import {
 } from '../../src/functions/OpenCapTable/convertibleIssuance/createConvertibleIssuance';
 import { damlConvertibleIssuanceDataToNative } from '../../src/functions/OpenCapTable/convertibleIssuance/getConvertibleIssuanceAsOcf';
 import type { ConvertibleConversionTrigger } from '../../src/types/native';
+import { parseOcfEntityInput } from '../../src/utils/ocfZodSchemas';
 import { requireFirst } from '../../src/utils/requireDefined';
 import { expectInvalidDate } from '../utils/dateValidationAssertions';
-import { loadProductionFixture } from '../utils/productionFixtures';
+import { loadProductionFixture, stripSourceMetadata } from '../utils/productionFixtures';
 
 const BASE_INPUT = {
   id: 'conv-001',
@@ -2022,37 +2023,11 @@ describe('convertible issuance write field boundaries', () => {
  */
 describe('POST_MONEY SAFE – production fixture round-trip', () => {
   it('preserves POST_MONEY timing, trigger type, converts_to_future_round, and cap_def_rules from production fixture', () => {
-    const fixture = loadProductionFixture<{
-      id: string;
-      date: string;
-      security_id: string;
-      custom_id: string;
-      stakeholder_id: string;
-      investment_amount: { amount: string; currency: string };
-      convertible_type: 'SAFE';
-      seniority: number;
-      security_law_exemptions: Array<{ description: string; jurisdiction: string }>;
-      conversion_triggers: Array<{
-        type: string;
-        trigger_id: string;
-        trigger_condition: string;
-        conversion_right: {
-          type: string;
-          converts_to_future_round: boolean;
-          conversion_mechanism: {
-            type: string;
-            conversion_timing: string;
-            conversion_mfn: boolean;
-            conversion_valuation_cap: { amount: string; currency: string };
-            capitalization_definition_rules: Record<string, boolean>;
-          };
-        };
-      }>;
-    }>('convertibleIssuance', 'safe-post-money');
-
-    const daml = convertibleIssuanceDataToDaml(
-      fixture as unknown as Parameters<typeof convertibleIssuanceDataToDaml>[0]
+    const fixture = parseOcfEntityInput(
+      'convertibleIssuance',
+      stripSourceMetadata(loadProductionFixture('convertibleIssuance', 'safe-post-money'))
     );
+    const daml = convertibleIssuanceDataToDaml(fixture);
     const result = damlConvertibleIssuanceDataToNative(daml);
 
     const trigger = requireFirst(result.conversion_triggers, 'production fixture conversion trigger');