@shapeshift-labs/frontier-lang-compiler 0.2.150 → 0.2.151

package/bench/real-repo-corpus-evidence.mjs

@@ -0,0 +1,165 @@
+function createCheckoutEvidenceRows(manifest, checkoutProof, commandExecution = null) {
+  const proof = manifest.localBehavior?.checkoutProof ?? {};
+  const dependencyInstallExecution = proof.dependencyInstallExecution ?? 'not-run-default-network-free';
+  const repositoryCommandExecution = proof.repositoryCommandExecution ?? 'not-run-default-network-free';
+  const repositoryCommandProofStatus = proof.repositoryCommandProofStatus ?? repositoryCommandExecution;
+  const commandRowsByEntry = new Map((commandExecution?.rows ?? []).map((row) => [row.entryId, row]));
+  return checkoutProof.rows.map((row) => {
+    const checkoutProofExecution = row.checkoutProofExecution ?? (row.status === 'skipped-missing-checkout' ? 'skipped' : 'executed');
+    const commandDryRunPhases = createCommandDryRunPhases(row, checkoutProofExecution, proof);
+    const commandRun = commandRowsByEntry.get(row.entryId) ?? createDefaultCommandRunRow(row, commandDryRunPhases);
+    const commandDryRunSkippedPhases = commandDryRunPhases.filter((phase) => phase.readinessStatus === 'skipped-missing-checkout').length;
+    const commandDryRunReadyPhases = commandDryRunPhases.filter((phase) => phase.readinessStatus === 'ready-local-checkout').length;
+    const commandDryRunOptInRequiredPhases = commandDryRunPhases.filter((phase) => phase.executionStatus === 'opt-in-required').length;
+    const commandDryRunExecutedPhases = commandDryRunPhases.filter((phase) => phase.executionStatus === 'executed').length;
+    const commandDryRunDefaultOffPhases = commandDryRunPhases.filter((phase) => phase.defaultExecution === 'not-run-default-network-free').length;
+    const commandDryRunStatus = checkoutProofExecution === 'skipped' ? 'skipped-missing-checkout' : 'ready-local-checkout';
+    const commandDryRunExecutionStatus = checkoutProofExecution === 'skipped' ? 'skipped-missing-checkout' : 'opt-in-required';
+    return {
+      entryId: row.entryId,
+      checkoutDir: row.checkoutDir,
+      manifestMetadataStatus: manifest.mode ?? 'unknown',
+      checkoutProofStatus: row.status,
+      checkoutProofExecution,
+      checkoutRootMode: checkoutProof.rootMode,
+      checkoutRootEnv: proof.rootEnv ?? 'FRONTIER_REAL_REPO_CORPUS_ROOT',
+      checkoutRootPresent: checkoutProof.rootPresent,
+      checkoutDirPresent: row.checkoutDirPresent ?? checkoutProofExecution === 'executed',
+      checkoutPresenceStatus: row.checkoutPresenceStatus ?? (checkoutProofExecution === 'skipped' ? 'checkout-dir-missing' : 'checkout-dir-present'),
+      checkoutProofReason: row.checkoutProofReason ?? row.status,
+      checkoutIdentityStatus: row.checkoutIdentityStatus ?? (checkoutProofExecution === 'skipped' ? 'skipped-missing-checkout' : 'git-metadata-missing'),
+      checkoutIdentityExecution: row.checkoutIdentityExecution ?? checkoutProofExecution,
+      gitMetadataPresent: row.gitMetadataPresent ?? false,
+      gitMetadataKind: row.gitMetadataKind ?? (checkoutProofExecution === 'skipped' ? 'not-scanned' : 'missing'),
+      gitDirPointerPresent: row.gitDirPointerPresent ?? false,
+      gitHeadPresent: row.gitHeadPresent ?? false,
+      gitConfigPresent: row.gitConfigPresent ?? false,
+      gitRemoteOriginUrlPresent: row.gitRemoteOriginUrlPresent ?? false,
+      gitRemoteOriginMatchesManifest: row.gitRemoteOriginMatchesManifest ?? null,
+      gitRefMatchesManifest: row.gitRefMatchesManifest ?? null,
+      dependencyInstallProofStatus: dependencyInstallProofStatus(row, checkoutProofExecution),
+      dependencyInstallExecution: commandRun.dependencyInstallExecution ?? dependencyInstallExecution,
+      dependencyInstallDefaultOffReason: proof.dependencyInstallDefaultOffReason ?? 'dependency installs require an explicit opt-in after a local checkout is supplied',
+      dependencyInstallOptInRequired: (commandRun.dependencyInstallExecution ?? dependencyInstallExecution) !== 'executed',
+      repositoryCommandProofStatus: commandRun.repositoryCommandExecution ?? repositoryCommandProofStatus,
+      repositoryCommandExecution: commandRun.repositoryCommandExecution ?? repositoryCommandExecution,
+      repositoryCommandDefaultOffReason: proof.repositoryCommandDefaultOffReason ?? 'repository build/test commands require explicit opt-in after dependency metadata is reviewed',
+      repositoryCommandOptInRequired: (commandRun.repositoryCommandExecution ?? repositoryCommandExecution) !== 'executed',
+      commandDryRunStatus,
+      commandDryRunExecutionStatus,
+      commandDryRunPhaseCount: commandDryRunPhases.length,
+      commandDryRunPhases,
+      commandDryRunSkippedPhases,
+      commandDryRunReadyPhases,
+      commandDryRunOptInRequiredPhases,
+      commandDryRunExecutedPhases,
+      commandDryRunDefaultOffPhases,
+      commandRunStatus: commandRun.commandRunStatus,
+      commandRunExecutionStatus: commandRun.commandRunExecutionStatus,
+      commandRunReason: commandRun.commandRunReason,
+      commandRunEnabled: commandRun.commandRunEnabled,
+      commandRunPhaseCount: commandRun.commandRunPhaseCount,
+      commandRunPhases: commandRun.commandRunPhases,
+      commandRunExecutedPhases: commandRun.commandRunExecutedPhases,
+      commandRunFailedPhases: commandRun.commandRunFailedPhases,
+      commandRunTimedOutPhases: commandRun.commandRunTimedOutPhases,
+      commandRunSkippedPhases: commandRun.commandRunSkippedPhases,
+      commandRunDefaultOffPhases: commandRun.commandRunDefaultOffPhases,
+      commandRunOutputTruncatedPhases: commandRun.commandRunOutputTruncatedPhases,
+      networkAccess: proof.networkRequired === true ? 'required' : 'none',
+      sourceTextRead: proof.readsSourceText === true,
+      installCommandsRun: commandRun.dependencyInstallExecution === 'executed',
+      packageManagerLockFilesPresent: row.packageManagerLockFilesPresent ?? 0,
+      packageManagerLockFiles: row.packageManagerLockFiles ?? [],
+      packageManagersPresent: row.packageManagersPresent ?? [],
+      packageManagerCommandMatrixStatus: row.packageManagerCommandMatrixStatus ?? 'metadata-only',
+      packageManagerCommandMatrixCommands: row.packageManagerCommandMatrixCommands ?? 0,
+      packageManagerInstallCommands: row.packageManagerInstallCommands ?? 0,
+      packageManagerBuildCommands: row.packageManagerBuildCommands ?? 0,
+      packageManagerTestCommands: row.packageManagerTestCommands ?? 0,
+      plannedSampleFiles: row.plannedSampleFiles,
+      proofGlobs: row.proofGlobs,
+      matchedFiles: row.matchedFiles,
+      maxObservedBytesPerFile: row.maxObservedBytesPerFile
+    };
+  });
+}
+
+function createDefaultCommandRunRow(row, phases) {
+  const commandRunPhases = phases.map((phase) => ({
+    phase: phase.phase,
+    executionStatus: 'blocked-opt-in-required',
+    reason: 'real-repo-command-opt-in-missing',
+    defaultExecution: 'not-run-default-network-free',
+    command: null,
+    argv: [],
+    manager: null,
+    commandHash: null,
+    stdoutBytes: 0,
+    stderrBytes: 0,
+    stdoutHash: null,
+    stderrHash: null,
+    stdoutPreview: '',
+    stderrPreview: '',
+    stdoutTruncated: false,
+    stderrTruncated: false
+  }));
+  return {
+    entryId: row.entryId,
+    commandRunEnabled: false,
+    commandRunStatus: 'blocked-opt-in-required',
+    commandRunExecutionStatus: 'not-run-default-network-free',
+    commandRunReason: 'real-repo-command-opt-in-missing',
+    commandRunPhaseCount: commandRunPhases.length,
+    commandRunPhases,
+    commandRunExecutedPhases: 0,
+    commandRunFailedPhases: 0,
+    commandRunTimedOutPhases: 0,
+    commandRunSkippedPhases: 0,
+    commandRunDefaultOffPhases: commandRunPhases.length,
+    commandRunOutputTruncatedPhases: 0,
+    dependencyInstallExecution: 'not-run-default-network-free',
+    repositoryCommandExecution: 'not-run-default-network-free'
+  };
+}
+
+function createCommandDryRunPhases(row, checkoutProofExecution, proof) {
+  const dryRun = proof.commandDryRun ?? {};
+  const phases = dryRun.phases ?? ['dependency-install', 'build', 'test'];
+  const readinessStatus = checkoutProofExecution === 'skipped' ? 'skipped-missing-checkout' : 'ready-local-checkout';
+  const executionStatus = checkoutProofExecution === 'skipped' ? 'skipped-missing-checkout' : 'opt-in-required';
+  return phases.map((phase) => ({
+    phase,
+    readinessStatus,
+    executionStatus,
+    defaultExecution: dryRun.defaultExecution ?? 'not-run-default-network-free',
+    optInRequired: executionStatus === 'opt-in-required',
+    commandKinds: commandKindsForDryRunPhase(phase),
+    commandCount: commandCountForDryRunPhase(row, phase),
+    networkAccess: dryRun.networkRequired === true ? 'required' : 'none',
+    sourceTextRead: dryRun.readsSourceText === true
+  }));
+}
+
+function commandKindsForDryRunPhase(phase) {
+  if (phase === 'dependency-install') return ['install'];
+  if (phase === 'build') return ['build'];
+  if (phase === 'test') return ['test'];
+  return [phase];
+}
+
+function commandCountForDryRunPhase(row, phase) {
+  if (phase === 'dependency-install') return row.packageManagerInstallCommands ?? 0;
+  if (phase === 'build') return row.packageManagerBuildCommands ?? 0;
+  if (phase === 'test') return row.packageManagerTestCommands ?? 0;
+  return 0;
+}
+
+function dependencyInstallProofStatus(row, execution) {
+  if (execution === 'skipped') return 'skipped-missing-checkout';
+  return (row.packageManagerLockFilesPresent ?? 0) > 0
+    ? 'lockfile-metadata-present'
+    : 'lockfile-metadata-missing';
+}
+
+export { createCheckoutEvidenceRows };

package/bench/real-repo-corpus-suite.mjs

@@ -0,0 +1,273 @@
+import assert from 'node:assert/strict';
+import { existsSync, readFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { performance } from 'node:perf_hooks';
+import { fileURLToPath } from 'node:url';
+import { collectExternalCheckoutProofs } from './real-repo-corpus-checkout-proof.mjs';
+import { collectRealRepoCommandExecution } from './real-repo-corpus-command-execution.mjs';
+import { createCheckoutEvidenceRows } from './real-repo-corpus-evidence.mjs';
+
+const realRepoCorpusFixtureCandidates = [
+  {
+    mode: 'workspace',
+    url: new URL('../test/fixtures/js-ts-semantic-merge/corpus.json', import.meta.url)
+  },
+  {
+    mode: 'split-parent-checkout',
+    url: new URL('../../../../test/fixtures/js-ts-semantic-merge/corpus.json', import.meta.url)
+  }
+];
+
+function measureRealRepoCorpus(options = {}) {
+  const start = performance.now();
+  const fixture = loadRealRepoCorpusFixture();
+  const corpus = fixture.corpus;
+  const manifest = corpus.realRepoCorpus ?? {};
+  const entries = manifest.entries ?? [];
+  const fixturesById = new Map((corpus.fixtures ?? []).map((fixture) => [fixture.id, fixture]));
+  const fixtureIds = new Set();
+  const mergeSurfaces = new Set();
+  const oracleFixtureIds = new Set();
+  const oracleSurfaces = new Set();
+  const oracleLanguages = new Set();
+  const oracleMatrixRows = new Set();
+  const gapStatuses = new Set();
+  const gapIds = new Set();
+  const packageManagers = new Set((manifest.localBehavior?.packageManagerMatrix ?? []).map((row) => row.manager));
+  const packageManagerCommands = (manifest.localBehavior?.packageManagerMatrix ?? [])
+    .reduce((sum, row) => sum + (row.commands?.length ?? 0), 0);
+  const realisticPatternFixtureIds = new Set(['react-tsx-child-additions-shell', 'vite-config-import-shape-addition']);
+  const realisticPatternOracleFixtureIds = new Set();
+  let sampleFiles = 0;
+  let maxBytesPerFile = 0;
+  let entriesWithOracleCases = 0;
+  let oracleCases = 0;
+  let oracleCaseFixturesPresent = 0;
+  let oracleAdmissionMatches = 0;
+  let oracleAutoMergeCandidates = 0;
+  let oracleBlocked = 0;
+  let oracleConflicts = 0;
+
+  for (const gap of manifest.broadSuiteGaps ?? []) {
+    gapIds.add(gap.id);
+    gapStatuses.add(gap.status);
+  }
+
+  for (const entry of entries) {
+    sampleFiles += entry.metrics?.sampleFiles ?? 0;
+    maxBytesPerFile = Math.max(maxBytesPerFile, entry.metrics?.maxBytesPerFile ?? 0);
+    for (const fixtureId of entry.fixtureIds ?? []) fixtureIds.add(fixtureId);
+    for (const surface of entry.metrics?.mergeSurfaces ?? []) mergeSurfaces.add(surface);
+    if ((entry.oracleCases ?? []).length > 0) entriesWithOracleCases += 1;
+    for (const oracleCase of entry.oracleCases ?? []) {
+      oracleCases += 1;
+      oracleFixtureIds.add(oracleCase.fixtureId);
+      oracleSurfaces.add(oracleCase.surface);
+      oracleLanguages.add(oracleCase.language);
+      for (const row of matrixRowsForOracleSurface(oracleCase.surface)) oracleMatrixRows.add(row);
+      if (realisticPatternFixtureIds.has(oracleCase.fixtureId)) realisticPatternOracleFixtureIds.add(oracleCase.fixtureId);
+      if (oracleCase.expectedAdmissionStatus === 'auto-merge-candidate') oracleAutoMergeCandidates += 1;
+      if (oracleCase.expectedAdmissionStatus === 'blocked') oracleBlocked += 1;
+      if (oracleCase.expectedAdmissionStatus === 'conflict') oracleConflicts += 1;
+      const fixture = fixturesById.get(oracleCase.fixtureId);
+      if (!fixture) continue;
+      oracleCaseFixturesPresent += 1;
+      if (fixtureExpectedAdmissionStatus(fixture) === oracleCase.expectedAdmissionStatus) oracleAdmissionMatches += 1;
+    }
+  }
+
+  const checkoutProof = collectExternalCheckoutProofs(manifest, entries);
+  const commandExecution = collectRealRepoCommandExecution(manifest, checkoutProof, options.realRepoCommandExecution ?? {});
+  const checkoutEvidenceRows = createCheckoutEvidenceRows(manifest, checkoutProof, commandExecution);
+  const metrics = {
+    realRepoCorpusFixtureMode: fixture.mode,
+    realRepoCorpusSchema: manifest.schema ?? null,
+    realRepoCorpusMode: manifest.mode ?? null,
+    realRepoCorpusEntries: entries.length,
+    realRepoCorpusFetchCommands: entries.filter((entry) => typeof entry.fetchCommand === 'string').length,
+    realRepoCorpusLinkedFixtures: fixtureIds.size,
+    realRepoCorpusMergeSurfaces: mergeSurfaces.size,
+    realRepoCorpusEntriesWithOracles: entriesWithOracleCases,
+    realRepoCorpusOracleCases: oracleCases,
+    realRepoCorpusOracleLinkedFixtures: oracleFixtureIds.size,
+    realRepoCorpusOracleCaseFixturesPresent: oracleCaseFixturesPresent,
+    realRepoCorpusOracleAdmissionMatches: oracleAdmissionMatches,
+    realRepoCorpusOracleAutoMergeCandidates: oracleAutoMergeCandidates,
+    realRepoCorpusOracleBlocked: oracleBlocked,
+    realRepoCorpusOracleConflicts: oracleConflicts,
+    realRepoCorpusOracleSurfaces: oracleSurfaces.size,
+    realRepoCorpusOracleLanguages: oracleLanguages.size,
+    realRepoCorpusOracleMatrixRows: oracleMatrixRows.size,
+    realRepoCorpusRealisticPatternOracleFixtures: realisticPatternOracleFixtureIds.size,
+    realRepoCorpusHasReactPatternEntry: entries.some((entry) => entry.id === 'react-component-patterns'),
+    realRepoCorpusOracleCoverageRatio: entries.length > 0 ? Number((entriesWithOracleCases / entries.length).toFixed(2)) : 0,
+    realRepoCorpusBroadSuiteGaps: gapIds.size,
+    realRepoCorpusBroadSuiteGapStatuses: gapStatuses.size,
+    realRepoCorpusBroadSuiteMissingGaps: [...(manifest.broadSuiteGaps ?? [])].filter((gap) => gap.status === 'missing').length,
+    realRepoCorpusBroadSuitePartialGaps: [...(manifest.broadSuiteGaps ?? [])].filter((gap) => gap.status === 'partial').length,
+    realRepoCorpusBroadSuiteManualGaps: [...(manifest.broadSuiteGaps ?? [])].filter((gap) => gap.status === 'manual').length,
+    realRepoCorpusPackageManagerMatrixEntries: packageManagers.size,
+    realRepoCorpusPackageManagerMatrixCommands: packageManagerCommands,
+    realRepoCorpusBudgetedSampleFiles: sampleFiles,
+    realRepoCorpusMaxBytesPerFile: maxBytesPerFile,
+    realRepoCorpusCommittedSourceBytes: manifest.localBehavior?.committedSourceBytes ?? null,
+    realRepoCorpusExternalRootPresent: checkoutProof.rootPresent,
+    realRepoCorpusLocalBehavior: checkoutProof.checkedOut > 0 ? 'external-checkout-present' : manifest.localBehavior?.missingCheckoutBehavior ?? 'unknown',
+    realRepoCorpusCheckoutRootMode: checkoutProof.rootMode,
+    realRepoCorpusCheckoutPresenceStatuses: new Set(checkoutEvidenceRows.map((row) => row.checkoutPresenceStatus)).size,
+    realRepoCorpusCheckoutProofReasons: new Set(checkoutEvidenceRows.map((row) => row.checkoutProofReason)).size,
+    realRepoCorpusCheckoutProofEntries: checkoutProof.rows.length,
+    realRepoCorpusCheckoutProofRows: checkoutProof.rows,
+    realRepoCorpusCheckoutEvidenceRows: checkoutEvidenceRows,
+    realRepoCorpusCheckoutCheckedOut: checkoutProof.checkedOut,
+    realRepoCorpusCheckoutSkipped: checkoutProof.skipped,
+    realRepoCorpusCheckoutProofExecuted: checkoutProof.proofExecuted,
+    realRepoCorpusCheckoutProofSkipped: checkoutProof.proofSkipped,
+    realRepoCorpusCheckoutNoProofMatch: checkoutProof.noProofMatch,
+    realRepoCorpusCheckoutEvidenceExecuted: checkoutEvidenceRows.filter((row) => row.checkoutProofExecution === 'executed').length,
+    realRepoCorpusCheckoutEvidenceSkipped: checkoutEvidenceRows.filter((row) => row.checkoutProofExecution === 'skipped').length,
+    realRepoCorpusCheckoutDirPresentRows: checkoutEvidenceRows.filter((row) => row.checkoutDirPresent === true).length,
+    realRepoCorpusCheckoutRootMissingRows: checkoutEvidenceRows.filter((row) => row.checkoutPresenceStatus === 'checkout-root-missing').length,
+    realRepoCorpusCheckoutRootUnconfiguredRows: checkoutEvidenceRows.filter((row) => row.checkoutPresenceStatus === 'checkout-root-unconfigured').length,
+    realRepoCorpusCheckoutDirMissingRows: checkoutEvidenceRows.filter((row) => row.checkoutPresenceStatus === 'checkout-dir-missing').length,
+    realRepoCorpusCheckoutDirNotDeclaredRows: checkoutEvidenceRows.filter((row) => row.checkoutPresenceStatus === 'checkout-dir-not-declared').length,
+    realRepoCorpusRepositoryCommandsRun: checkoutEvidenceRows.filter((row) => row.repositoryCommandExecution === 'executed').length,
+    realRepoCorpusDependencyInstallsRun: checkoutEvidenceRows.filter((row) => row.dependencyInstallExecution === 'executed').length,
+    realRepoCorpusCheckoutLockfileMetadataRows: checkoutEvidenceRows.filter((row) => row.packageManagerLockFilesPresent > 0).length,
+    realRepoCorpusCheckoutProofMatchedEntries: checkoutProof.proofMatchedEntries,
+    realRepoCorpusCheckoutProofMatchedFiles: checkoutProof.matchedFiles,
+    realRepoCorpusCheckoutProofMaxBytesPerFile: checkoutProof.maxBytesPerFile,
+    realRepoCorpusCheckoutProofStatuses: checkoutProof.statuses.size,
+    realRepoCorpusCheckoutIdentityExecuted: checkoutProof.identityExecuted,
+    realRepoCorpusCheckoutIdentitySkipped: checkoutProof.identitySkipped,
+    realRepoCorpusCheckoutIdentityMetadataPresent: checkoutProof.identityMetadataPresent,
+    realRepoCorpusCheckoutIdentityMatched: checkoutProof.identityMatched,
+    realRepoCorpusCheckoutIdentityRemoteMatched: checkoutProof.identityRemoteMatched,
+    realRepoCorpusCheckoutIdentityRefMatched: checkoutProof.identityRefMatched,
+    realRepoCorpusCheckoutGitDirectories: checkoutEvidenceRows.filter((row) => row.gitMetadataKind === 'git-directory').length,
+    realRepoCorpusCheckoutGitDirPointers: checkoutEvidenceRows.filter((row) => row.gitDirPointerPresent === true).length,
+    realRepoCorpusCheckoutGitConfigsPresent: checkoutEvidenceRows.filter((row) => row.gitConfigPresent === true).length,
+    realRepoCorpusCheckoutGitOriginUrlsPresent: checkoutEvidenceRows.filter((row) => row.gitRemoteOriginUrlPresent === true).length,
+    realRepoCorpusCommandReadinessRows: checkoutEvidenceRows.length,
+    realRepoCorpusDependencyInstallDefaultOffRows: checkoutEvidenceRows.filter((row) => row.dependencyInstallExecution === 'not-run-default-network-free').length,
+    realRepoCorpusRepositoryCommandDefaultOffRows: checkoutEvidenceRows.filter((row) => row.repositoryCommandExecution === 'not-run-default-network-free').length,
+    realRepoCorpusPackageManagerCommandMatrixRows: checkoutEvidenceRows.filter((row) => row.packageManagerCommandMatrixStatus === 'metadata-only').length,
+    realRepoCorpusCommandDryRunPhaseRows: checkoutEvidenceRows.reduce((sum, row) => sum + row.commandDryRunPhases.length, 0),
+    realRepoCorpusCommandDryRunPhaseKinds: new Set(checkoutEvidenceRows.flatMap((row) => row.commandDryRunPhases.map((phase) => phase.phase))).size,
+    realRepoCorpusCommandDryRunSkippedPhases: checkoutEvidenceRows.reduce((sum, row) => sum + row.commandDryRunSkippedPhases, 0),
+    realRepoCorpusCommandDryRunReadyPhases: checkoutEvidenceRows.reduce((sum, row) => sum + row.commandDryRunReadyPhases, 0),
+    realRepoCorpusCommandDryRunOptInRequiredPhases: checkoutEvidenceRows.reduce((sum, row) => sum + row.commandDryRunOptInRequiredPhases, 0),
+    realRepoCorpusCommandDryRunExecutedPhases: checkoutEvidenceRows.reduce((sum, row) => sum + row.commandDryRunExecutedPhases, 0),
+    realRepoCorpusCommandDryRunDefaultOffPhases: checkoutEvidenceRows.reduce((sum, row) => sum + row.commandDryRunDefaultOffPhases, 0),
+    realRepoCorpusCommandRunRows: commandExecution.commandRunRows,
+    realRepoCorpusCommandRunEnabledRows: commandExecution.commandRunEnabledRows,
+    realRepoCorpusCommandRunDefaultOffRows: commandExecution.commandRunDefaultOffRows,
+    realRepoCorpusCommandRunOptInRequiredRows: commandExecution.commandRunOptInRequiredRows,
+    realRepoCorpusCommandRunSkippedRows: commandExecution.commandRunSkippedRows,
+    realRepoCorpusCommandRunBlockedRows: commandExecution.commandRunBlockedRows,
+    realRepoCorpusCommandRunExecutedPhases: commandExecution.commandRunExecutedPhases,
+    realRepoCorpusCommandRunFailedPhases: commandExecution.commandRunFailedPhases,
+    realRepoCorpusCommandRunTimedOutPhases: commandExecution.commandRunTimedOutPhases,
+    realRepoCorpusCommandRunSkippedPhases: commandExecution.commandRunSkippedPhases,
+    realRepoCorpusCommandRunDefaultOffPhases: commandExecution.commandRunDefaultOffPhases,
+    realRepoCorpusCommandRunOutputTruncatedPhases: commandExecution.commandRunOutputTruncatedPhases,
+    realRepoCorpusDurationMs: Number((performance.now() - start).toFixed(2))
+  };
+  assert.equal(metrics.realRepoCorpusRealisticPatternOracleFixtures >= 2, true, 'realistic-pattern oracle fixture coverage');
+  assert.equal(metrics.realRepoCorpusHasReactPatternEntry, true, 'React manifest-only pattern entry');
+  assert.equal(metrics.realRepoCorpusPackageManagerMatrixEntries >= 3, true, 'package-manager matrix metadata');
+  assert.equal(oracleMatrixRows.has('module-export-import'), true, 'module/export/import matrix row covered');
+  assert.equal(oracleMatrixRows.has('parser-source-span-trivia'), true, 'parser/source-span/trivia matrix row covered');
+  assert.equal(oracleMatrixRows.has('jsx-tsx-element-prop'), true, 'JSX/TSX matrix row covered');
+  assert.equal(metrics.realRepoCorpusCheckoutProofEntries, entries.length, 'checkout proof row per real-repo entry');
+  assert.equal(
+    metrics.realRepoCorpusCheckoutSkipped + metrics.realRepoCorpusCheckoutCheckedOut,
+    entries.length,
+    'checkout proof rows distinguish skipped and checked-out entries'
+  );
+  assert.equal(
+    metrics.realRepoCorpusCheckoutProofSkipped + metrics.realRepoCorpusCheckoutProofExecuted,
+    entries.length,
+    'checkout proof rows distinguish skipped and executed proof rows'
+  );
+  assert.equal(metrics.realRepoCorpusCheckoutEvidenceRows.length, entries.length, 'checkout evidence row per real-repo entry');
+  assert.equal(
+    metrics.realRepoCorpusCheckoutEvidenceSkipped + metrics.realRepoCorpusCheckoutEvidenceExecuted,
+    entries.length,
+    'checkout evidence rows distinguish skipped and executed proof rows'
+  );
+  assert.equal(metrics.realRepoCorpusCheckoutDirPresentRows, metrics.realRepoCorpusCheckoutProofExecuted, 'checkout dir presence rows match executed proof rows');
+  assert.equal(
+    metrics.realRepoCorpusCheckoutDirPresentRows +
+      metrics.realRepoCorpusCheckoutRootMissingRows +
+      metrics.realRepoCorpusCheckoutRootUnconfiguredRows +
+      metrics.realRepoCorpusCheckoutDirMissingRows +
+      metrics.realRepoCorpusCheckoutDirNotDeclaredRows,
+    entries.length,
+    'checkout presence rows explain every real-repo entry'
+  );
+  if (!commandExecution.enabled) {
+    assert.equal(metrics.realRepoCorpusRepositoryCommandsRun, 0, 'default real-repo bench must not execute repository commands');
+    assert.equal(metrics.realRepoCorpusDependencyInstallDefaultOffRows, entries.length, 'default real-repo bench must keep dependency installs default-off');
+    assert.equal(metrics.realRepoCorpusRepositoryCommandDefaultOffRows, entries.length, 'default real-repo bench must keep repository commands default-off');
+    assert.equal(metrics.realRepoCorpusCommandDryRunExecutedPhases, 0, 'default real-repo bench must not execute command dry-run phases');
+    assert.equal(metrics.realRepoCorpusCommandRunExecutedPhases, 0, 'default real-repo bench must not execute command-run phases');
+    assert.equal(metrics.realRepoCorpusCommandRunDefaultOffRows, entries.length, 'default real-repo bench must keep command-run rows default-off');
+  }
+  return metrics;
+}
+
+function loadRealRepoCorpusFixture() {
+  for (const candidate of realRepoCorpusFixtureCandidates) {
+    if (!existsSync(candidate.url)) continue;
+    return {
+      mode: candidate.mode,
+      path: fileURLToPath(candidate.url),
+      corpus: JSON.parse(readFileSync(candidate.url, 'utf8'))
+    };
+  }
+  const searched = realRepoCorpusFixtureCandidates
+    .map((candidate) => `${candidate.mode}:${fileURLToPath(candidate.url)}`)
+    .join(', ');
+  throw new Error(`Unable to find JS/TS semantic merge corpus fixture. Searched ${searched}`);
+}
+
+function readRealRepoCorpusFixture() {
+  return loadRealRepoCorpusFixture().corpus;
+}
+
+function fixtureExpectedAdmissionStatus(fixture) {
+  if (fixture.expected?.admissionStatus) return fixture.expected.admissionStatus;
+  if (fixture.expected?.safeMergeStatus === 'merged') return 'auto-merge-candidate';
+  if (fixture.expected?.safeMergeStatus === 'rejected') return 'blocked';
+  return undefined;
+}
+
+function matrixRowsForOracleSurface(surface) {
+  if ([
+    'imports',
+    'type-only-imports',
+    'value-import-dependencies',
+    'import-specifier-order',
+    'import-shape-additions',
+    'new-import-declarations',
+    'exports'
+  ].includes(surface)) return ['module-export-import'];
+  if ([
+    'type-aliases',
+    'type-interface-members',
+    'overloads',
+    'exported-types',
+    'dependency-sensitive-edits'
+  ].includes(surface)) return ['type-public-api'];
+  if (surface.startsWith('tsx-jsx-') || surface === 'jsx-component-prop-contracts') return ['jsx-tsx-element-prop'];
+  if (surface === 'control-flow' || surface === 'async-components') return ['control-flow-effect'];
+  if (surface === 'comments-trivia' || surface === 'generated-source-map-boundary') return ['parser-source-span-trivia'];
+  return [];
+}
+
+if (process.argv[1] && fileURLToPath(import.meta.url) === resolve(process.argv[1])) {
+  console.log(JSON.stringify(measureRealRepoCorpus()));
+}
+
+export { loadRealRepoCorpusFixture, measureRealRepoCorpus, readRealRepoCorpusFixture };

package/bench/smoke.mjs

@@ -1,18 +1,46 @@
-import { measureFrontierCompile } from './compile-suite.mjs';
-import { collectNativeImports } from './native-import-suite.mjs';
-import { measureNativeMatrices } from './native-matrix-suite.mjs';
-import { measureNativeTransformations } from './native-transform-suite.mjs';
-import { measureSourceChangeSuites } from './source-change-suite.mjs';
-import { measureUniversalFixtureSuite } from './universal-fixture-suite.mjs';
+import assert from 'node:assert/strict';
+import { existsSync } from 'node:fs';
+import { measureRealRepoCorpus } from './real-repo-corpus-suite.mjs';
+
+const splitWorkspaceMode = !existsSync(new URL('../src/index.js', import.meta.url)) &&
+  !existsSync(new URL('./compile-suite.mjs', import.meta.url));
+
+if (splitWorkspaceMode) {
+  const realRepoCorpusMetrics = measureRealRepoCorpus();
+  assertRealRepoCorpusSmokeMetrics(realRepoCorpusMetrics);
+  console.log(JSON.stringify({
+    benchSmokeMode: 'real-repo-corpus-only-split-workspace',
+    ...realRepoCorpusMetrics
+  }));
+} else {
+const [
+  { measureFrontierCompile },
+  { collectNativeImports },
+  { measureNativeMatrices },
+  { measureNativeTransformations },
+  { measureSourceChangeSuites },
+  { measureUniversalFixtureSuite }
+] = await Promise.all([
+  import('./compile-suite.mjs'),
+  import('./native-import-suite.mjs'),
+  import('./native-matrix-suite.mjs'),
+  import('./native-transform-suite.mjs'),
+  import('./source-change-suite.mjs'),
+  import('./universal-fixture-suite.mjs')
+]);
 
 const compileMetrics = measureFrontierCompile();
 const importMetrics = await collectNativeImports();
 const matrixMetrics = measureNativeMatrices(importMetrics.nativeImportResults, importMetrics.adapters);
 const transformMetrics = measureNativeTransformations(importMetrics.nativeImportResults);
+const realRepoCorpusMetrics = measureRealRepoCorpus();
 const sourceChangeMetrics = measureSourceChangeSuites();
 const universalFixtureMetrics = measureUniversalFixtureSuite(importMetrics.adapters);
 
+assertRealRepoCorpusSmokeMetrics(realRepoCorpusMetrics);
+
 console.log(JSON.stringify({
+  benchSmokeMode: 'full-package',
   compiles: 250,
   bytes: compileMetrics.bytes,
   compileDurationMs: Number(compileMetrics.compileDurationMs.toFixed(2)),
@@ -134,5 +162,79 @@ console.log(JSON.stringify({
   universalFixtureLossCategories: universalFixtureMetrics.lossCategories,
   universalFixtureCandidateRecords: universalFixtureMetrics.candidateRecords,
   universalFixtureBestCandidateSortKey: universalFixtureMetrics.bestCandidateSortKey,
-  universalFixtureDurationMs: Number(universalFixtureMetrics.durationMs.toFixed(2))
+  universalFixtureDurationMs: Number(universalFixtureMetrics.durationMs.toFixed(2)),
+  ...realRepoCorpusMetrics
 }));
+}
+
+function assertRealRepoCorpusSmokeMetrics(realRepoCorpusMetrics) {
+  assert.equal(realRepoCorpusMetrics.realRepoCorpusRealisticPatternOracleFixtures >= 2, true, 'real-repo realistic-pattern oracle fixtures');
+  assert.equal(realRepoCorpusMetrics.realRepoCorpusOracleMatrixRows >= 2, true, 'real-repo matrix row coverage');
+  assert.equal(realRepoCorpusMetrics.realRepoCorpusCheckoutProofEntries, realRepoCorpusMetrics.realRepoCorpusEntries, 'real-repo checkout proof rows');
+  assert.equal(
+    realRepoCorpusMetrics.realRepoCorpusCheckoutSkipped + realRepoCorpusMetrics.realRepoCorpusCheckoutCheckedOut,
+    realRepoCorpusMetrics.realRepoCorpusEntries,
+    'real-repo checkout proof skipped/checked-out accounting'
+  );
+  assert.equal(
+    realRepoCorpusMetrics.realRepoCorpusCheckoutProofSkipped + realRepoCorpusMetrics.realRepoCorpusCheckoutProofExecuted,
+    realRepoCorpusMetrics.realRepoCorpusEntries,
+    'real-repo checkout proof skipped/executed accounting'
+  );
+  assert.equal(realRepoCorpusMetrics.realRepoCorpusCheckoutEvidenceRows.length, realRepoCorpusMetrics.realRepoCorpusEntries, 'real-repo checkout evidence rows');
+  assert.equal(
+    realRepoCorpusMetrics.realRepoCorpusCheckoutEvidenceSkipped + realRepoCorpusMetrics.realRepoCorpusCheckoutEvidenceExecuted,
+    realRepoCorpusMetrics.realRepoCorpusEntries,
+    'real-repo checkout evidence skipped/executed accounting'
+  );
+  assert.equal(
+    realRepoCorpusMetrics.realRepoCorpusCheckoutIdentitySkipped + realRepoCorpusMetrics.realRepoCorpusCheckoutIdentityExecuted,
+    realRepoCorpusMetrics.realRepoCorpusEntries,
+    'real-repo checkout identity skipped/executed accounting'
+  );
+  assert.equal(Number.isInteger(realRepoCorpusMetrics.realRepoCorpusCheckoutGitDirectories), true, 'real-repo git directory proof metric');
+  assert.equal(Number.isInteger(realRepoCorpusMetrics.realRepoCorpusCheckoutGitDirPointers), true, 'real-repo gitdir pointer proof metric');
+  assert.equal(Number.isInteger(realRepoCorpusMetrics.realRepoCorpusCheckoutGitConfigsPresent), true, 'real-repo git config proof metric');
+  assert.equal(Number.isInteger(realRepoCorpusMetrics.realRepoCorpusCheckoutGitOriginUrlsPresent), true, 'real-repo git origin proof metric');
+  assert.equal(realRepoCorpusMetrics.realRepoCorpusRepositoryCommandsRun, 0, 'real-repo default bench must not execute repository commands');
+  assert.equal(realRepoCorpusMetrics.realRepoCorpusDependencyInstallsRun, 0, 'real-repo default bench must not execute dependency installs');
+  assert.equal(
+    realRepoCorpusMetrics.realRepoCorpusRepositoryCommandDefaultOffRows,
+    realRepoCorpusMetrics.realRepoCorpusEntries,
+    'real-repo repository command default-off rows'
+  );
+  assert.equal(
+    realRepoCorpusMetrics.realRepoCorpusCommandDryRunPhaseRows,
+    realRepoCorpusMetrics.realRepoCorpusEntries * 3,
+    'real-repo command dry-run phase rows'
+  );
+  assert.equal(realRepoCorpusMetrics.realRepoCorpusCommandDryRunPhaseKinds, 3, 'real-repo command dry-run phase kinds');
+  assert.equal(
+    realRepoCorpusMetrics.realRepoCorpusCommandDryRunSkippedPhases,
+    realRepoCorpusMetrics.realRepoCorpusCheckoutEvidenceSkipped * 3,
+    'real-repo command dry-run skipped phase accounting'
+  );
+  assert.equal(
+    realRepoCorpusMetrics.realRepoCorpusCommandDryRunReadyPhases,
+    realRepoCorpusMetrics.realRepoCorpusCheckoutEvidenceExecuted * 3,
+    'real-repo command dry-run ready phase accounting'
+  );
+  assert.equal(
+    realRepoCorpusMetrics.realRepoCorpusCommandDryRunOptInRequiredPhases,
+    realRepoCorpusMetrics.realRepoCorpusCheckoutEvidenceExecuted * 3,
+    'real-repo command dry-run opt-in phase accounting'
+  );
+  assert.equal(realRepoCorpusMetrics.realRepoCorpusCommandDryRunExecutedPhases, 0, 'real-repo command dry-run executed phases');
+  assert.equal(
+    realRepoCorpusMetrics.realRepoCorpusCommandDryRunDefaultOffPhases,
+    realRepoCorpusMetrics.realRepoCorpusCommandDryRunPhaseRows,
+    'real-repo command dry-run default-off phases'
+  );
+  assert.equal(realRepoCorpusMetrics.realRepoCorpusCommandRunRows, realRepoCorpusMetrics.realRepoCorpusEntries, 'real-repo command-run rows');
+  assert.equal(realRepoCorpusMetrics.realRepoCorpusCommandRunEnabledRows, 0, 'real-repo default command-run enabled rows');
+  assert.equal(realRepoCorpusMetrics.realRepoCorpusCommandRunDefaultOffRows, realRepoCorpusMetrics.realRepoCorpusEntries, 'real-repo default command-run rows');
+  assert.equal(realRepoCorpusMetrics.realRepoCorpusCommandRunExecutedPhases, 0, 'real-repo command-run executed phases');
+  assert.equal(realRepoCorpusMetrics.realRepoCorpusCommandRunFailedPhases, 0, 'real-repo command-run failed phases');
+  assert.equal(realRepoCorpusMetrics.realRepoCorpusCommandRunTimedOutPhases, 0, 'real-repo command-run timed-out phases');
+  assert.equal(realRepoCorpusMetrics.realRepoCorpusCommandRunOutputTruncatedPhases, 0, 'real-repo command-run truncated output phases');
+}

package/dist/declarations/import-adapter-core.d.ts

@@ -39,14 +39,14 @@ import type { ProjectionTargetLossClass, ProjectionSourceProjectionCoverage, Pro
 import type { UniversalCapabilityLanguageRow, UniversalCapabilityMatrix, UniversalCapabilityMatrixOptions } from './universal-capability.js';
 import type { UniversalDialectRegistry, UniversalDialectRegistryInput, UniversalDialectRecordInput, UniversalExternRecordInput } from './universal-dialects.js';
 import type { NativeImportContractSource, NativeImportSourcePreservationRecordSummary, NativeImportSourcePreservationContract, NativeImportAdapterCoverageRecordSummary, NativeImportAdapterCoverageContract, NativeImportRegionSummary, NativeImportSourceMapSummary, NativeImportReadinessContract, NativeImportResultContract, NativeImportResultContractOptions } from './native-import-contracts.js';
-import type { NativeSourceTokenKind, NativeSourcePreservedToken, NativeSourcePreservedDirective, NativeSourcePreservation, CreateNativeSourcePreservationOptions } from './source-preservation.js';
+import type { NativeSourceTokenKind, NativeSourcePreservedToken, NativeSourcePreservedDirective, NativeSourcePreservation, CreateNativeSourcePreservationOptions, ParserTriviaEvidenceInput } from './source-preservation.js';
 import type { SemanticImportOwnershipRegion, SemanticImportSidecarSymbol, SemanticImportRegionTaxonomySummary, SemanticImportPatchHint, SemanticImportSidecarImportEntry, SemanticImportSidecarSourcePreservationRecord, SemanticImportSidecarUniversalAstLayerSummary, SemanticImportSidecarProofSpecSummary, SemanticImportSidecarParadigmSemanticsSummary, SemanticImportSidecar, SemanticImportSidecarOptions } from './semantic-sidecar.js';
 import type { NativeSourceChangeKind, NativeSourceChangeProjectionEndpoint, NativeSourceChangeProjectionSourceMapLink, NativeSourceChangeProjectionMetadata, NativeSourceChangeProjectionSummary, NativeSourceChangeSymbol, NativeSourceChangeRegion, NativeSourceChangeSummary, DiffNativeSourceImportsOptions, DiffNativeSourcesOptions, NativeSourceChangeSet } from './native-diff.js';
 import type { SemanticSliceInput, CreateSemanticSliceOptions, SemanticSliceSourceMapLink, SemanticSliceSourceFile, SemanticSliceExpectedAssertion, SemanticSlice, TestSemanticSliceOptions, SemanticSliceTestAssertion, SemanticSliceTestResult } from './semantic-slice.js';
 import type { NativeImporterAdapterExactness, NativeImporterAdapterSemanticCoverage, NativeImporterAdapterCoverageSnapshot, NativeImporterAdapterCoverageObserved, NativeImporterAdapterCoverageCapabilityRow, NativeImporterAdapterCoverageCapabilityEvidence, NativeImporterAdapterCoverageSummary, NativeImporterAdapterCoverageInput } from './adapter-coverage.js';
 import type { JavaScriptNativeImporterAdapterOptions, TypeScriptCompilerNativeImporterAdapterOptions, PythonAstNativeImporterAdapterOptions, RustSynNativeImporterAdapterOptions, ClangAstNativeImporterAdapterOptions, GoAstNativeImporterAdapterOptions } from './import-adapter-options-native.js';
 import type { JavaAstNativeImporterAdapterOptions, KotlinPsiNativeImporterAdapterOptions, CSharpRoslynNativeImporterAdapterOptions, SwiftSyntaxNativeImporterAdapterOptions, TreeSitterNativeImporterAdapterOptions } from './import-adapter-options-platform.js';
-import type { NativeTargetProjectionAdapterCoverageInput, NativeTargetProjectionAdapterSummary, NativeTargetProjectionAdapterInput, NativeTargetProjectionAdapterResult, NativeTargetProjectionAdapter, NativeTargetProjectionAdapterResolverInput, NativeTargetProjectionResult } from './target-adapters.js';
+import type { NativeSourceMapInput, NativeTargetProjectionAdapterCoverageInput, NativeTargetProjectionAdapterSummary, NativeTargetProjectionAdapterInput, NativeTargetProjectionAdapterResult, NativeTargetProjectionAdapter, NativeTargetProjectionAdapterResolverInput, NativeTargetProjectionResult } from './target-adapters.js';
 import type { NativeProjectSourceInput, ImportNativeProjectOptions, NativeProjectImportResult, NativeSourceProjectionMode, ProjectNativeImportToSourceOptions, NativeSourceProjectionDeclaration, NativeSourceProjectionResult, NativeSourceCompileOutputMode, CompileNativeSourceOptions, NativeSourceCompileResult } from './native-project.js';
 import type { NativeImportRoundtripReadinessStatus, NativeImportRoundtripReadinessOptions, NativeImportRoundtripReadinessClassification } from './roundtrip.js';
 
@@ -70,6 +70,7 @@ export interface ImportNativeSourceOptions {
   readonly sourcePath?: string;
   readonly sourceHash?: string;
   readonly sourceText?: string;
+  readonly parserTriviaEvidence?: ParserTriviaEvidenceInput;
   readonly symbol?: string;
   readonly name?: string;
   readonly nativeAst?: NativeAstRecord;
@@ -103,7 +104,7 @@ export interface ImportNativeSourceOptions {
   readonly patchHints?: readonly SemanticImportPatchHint[];
   readonly semanticPatchHints?: readonly SemanticImportPatchHint[];
   readonly sourceMapId?: string;
-  readonly sourceMaps?: readonly SourceMapRecord[];
+  readonly sourceMaps?: readonly NativeSourceMapInput[];
   readonly universalAstId?: string;
   readonly universalAstMetadata?: Record<string, unknown>;
   readonly universalDialectRegistry?: UniversalDialectRegistryInput | UniversalDialectRegistry;

package/dist/declarations/import-adapter-options-native.d.ts

@@ -63,6 +63,10 @@ export interface JavaScriptNativeImporterAdapterOptions {
   readonly babelParser?: { readonly parse: (sourceText: string, options: Record<string, unknown>) => unknown };
   readonly parserOptions?: Record<string, unknown> | ((input: NativeImporterAdapterParseInput) => Record<string, unknown>);
   readonly maxNodes?: number;
+  readonly includeTokens?: boolean;
+  readonly includeTrivia?: boolean;
+  readonly maxTokens?: number;
+  readonly maxTrivia?: number;
 }
 
 export interface TypeScriptCompilerNativeImporterAdapterOptions {
@@ -79,12 +83,29 @@ export interface TypeScriptCompilerNativeImporterAdapterOptions {
   readonly program?: { readonly getTypeChecker?: () => unknown } | unknown;
   readonly typeChecker?: unknown;
   readonly checker?: unknown;
+  readonly computedEnumRuntimeValueProofs?: readonly unknown[] | Record<string, unknown>;
+  readonly computedEnumRuntimeValueProof?: unknown;
+  readonly computedEnumRuntimeValueTraces?: readonly unknown[] | Record<string, unknown>;
+  readonly computedEnumRuntimeValueProofProvider?: (input: {
+    readonly sourcePath?: string;
+    readonly sourceHash?: string;
+    readonly enumName?: string;
+    readonly enumRuntimeShapeHash?: string;
+    readonly enumComputedMemberCount?: number;
+    readonly enumMembers?: readonly unknown[];
+    readonly computedMembers?: readonly unknown[];
+    readonly proofKind?: string;
+  }) => unknown;
+  readonly computedEnumRuntimeValueTraceProvider?: TypeScriptCompilerNativeImporterAdapterOptions['computedEnumRuntimeValueProofProvider'];
   readonly sourceFile?: unknown;
   readonly createSourceFile?: (input: NativeImporterAdapterParseInput, typescript?: unknown) => unknown;
   readonly scriptTarget?: unknown;
   readonly scriptKind?: unknown;
   readonly maxNodes?: number;
   readonly includeTokens?: boolean;
+  readonly includeTrivia?: boolean;
+  readonly maxTokens?: number;
+  readonly maxTrivia?: number;
 }
 
 export interface PythonAstNativeImporterAdapterOptions {