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

package/dist/js-ts-safe-project-merge-declarations.js

@@ -0,0 +1,227 @@
+import { hashSemanticValue } from '@shapeshift-labs/frontier-lang-kernel';
+import { compactRecord, uniqueStrings } from './js-ts-safe-merge-context.js';
+import {
+  createJsTsVirtualTypeScriptProgram,
+  normalizePath,
+  normalizeSuppliedDiagnostics,
+  normalizeTypeScriptDiagnostic,
+  sourceMapMatch
+} from './js-ts-safe-project-merge-ts-program.js';
+
+function createJsTsProjectMergeDeclarationGate(input = {}, outputFiles = [], id = 'js_ts_project_safe_merge') {
+  const declarationOutput = input.outputDeclarations || input.outputDeclarationFiles
+    ? normalizeSuppliedDeclarationOutput(input.outputDeclarations ?? input.outputDeclarationFiles)
+    : collectTypeScriptDeclarationOutput(input, outputFiles);
+  if (!declarationOutput && shouldSkipDeclarationGate(input)) return undefined;
+  if (!declarationOutput) return unavailableGate(input, id);
+  const diagnostics = declarationOutput.diagnostics ?? [];
+  const conflicts = diagnostics
+    .filter((diagnostic) => diagnostic.severity === 'error')
+    .map((diagnostic) => declarationConflict(input, diagnostic));
+  const requireFiles = input.requireDeclarationOutput === true;
+  if (requireFiles && declarationOutput.declarationFiles.length === 0) conflicts.push(missingDeclarationsConflict(input));
+  const status = conflicts.length ? 'blocked' : 'passed';
+  const core = {
+    kind: 'frontier.lang.jsTsProjectMergeDeclarationGate',
+    version: 1,
+    schema: 'frontier.lang.jsTsProjectMergeDeclarationGate.v1',
+    id: `${id}_declaration_output`,
+    status,
+    sourcePaths: outputFiles.map((file) => file.sourcePath).filter(Boolean),
+    declarationFiles: declarationOutput.declarationFiles,
+    diagnostics,
+    conflicts,
+    admission: {
+      status: status === 'passed' ? 'auto-merge-candidate' : 'blocked',
+      action: status === 'passed' ? 'accept-declarations' : 'human-review',
+      reviewRequired: status !== 'passed',
+      autoApplyCandidate: status === 'passed',
+      autoMergeClaim: false,
+      semanticEquivalenceClaim: false,
+      reasonCodes: uniqueStrings(conflicts.map((conflict) => conflict.code))
+    },
+    summary: declarationSummary(declarationOutput.declarationFiles, diagnostics, conflicts),
+    evidence: [declarationEvidence(id, status, declarationOutput, diagnostics, conflicts, input)]
+  };
+  return { ...core, hash: hashSemanticValue(core) };
+}
+
+function shouldSkipDeclarationGate(input) {
+  return input.includeDeclarationOutput !== true && input.requireDeclarationOutput !== true;
+}
+
+function collectTypeScriptDeclarationOutput(input, outputFiles) {
+  const emitted = new Map();
+  const created = createJsTsVirtualTypeScriptProgram(input, outputFiles, {
+    compilerOptions: {
+      noEmit: false,
+      declaration: true,
+      emitDeclarationOnly: true,
+      outDir: input.declarationOutDir ?? '__frontier_declarations__',
+      ...(input.declarationCompilerOptions ?? input.typescriptDeclarationCompilerOptions ?? {})
+    },
+    writeFile(fileName, text) {
+      emitted.set(normalizePath(fileName), String(text));
+    }
+  });
+  if (!created) return undefined;
+  const { ts, program, sourceMap } = created;
+  const projectRoot = normalizePath(input.projectRoot ?? '');
+  if (!program) return { declarationFiles: [], diagnostics: [] };
+  const preEmitDiagnostics = ts.getPreEmitDiagnostics
+    ? ts.getPreEmitDiagnostics(program)
+    : fallbackPreEmitDiagnostics(program);
+  const emitResult = program.emit(undefined, undefined, undefined, true);
+  const diagnostics = uniqueDiagnostics([...preEmitDiagnostics, ...(emitResult.diagnostics ?? [])]
+    .map((diagnostic) => normalizeTypeScriptDiagnostic(ts, diagnostic))
+    .filter((diagnostic) => diagnostic.sourcePath ? Boolean(sourceMapMatch(sourceMap, diagnostic.sourcePath, projectRoot)) : false));
+  return {
+    declarationFiles: [...emitted.entries()].map(([sourcePath, sourceText]) => declarationFile(sourcePath, sourceText, 'typescript-compiler-api')),
+    diagnostics
+  };
+}
+
+function fallbackPreEmitDiagnostics(program) {
+  const diagnostics = [];
+  for (const sourceFile of program.getSourceFiles()) {
+    diagnostics.push(...(program.getSyntacticDiagnostics?.(sourceFile) ?? []));
+    diagnostics.push(...(program.getSemanticDiagnostics?.(sourceFile) ?? []));
+  }
+  return diagnostics;
+}
+
+function uniqueDiagnostics(diagnostics) {
+  const seen = new Set();
+  return diagnostics.filter((diagnostic) => {
+    const key = `${diagnostic.code}:${diagnostic.sourcePath ?? ''}:${diagnostic.start ?? ''}:${diagnostic.message}`;
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+}
+
+function normalizeSuppliedDeclarationOutput(value) {
+  const entries = value instanceof Map
+    ? [...value.entries()].map(([sourcePath, sourceText]) => ({ sourcePath, sourceText }))
+    : Array.isArray(value) ? value
+      : typeof value === 'object' && value ? Object.entries(value).map(([sourcePath, sourceText]) => ({ sourcePath, sourceText }))
+        : [];
+  return {
+    declarationFiles: entries.map((entry) => declarationFile(
+      entry.sourcePath ?? entry.path,
+      entry.sourceText ?? entry.text ?? '',
+      entry.source ?? 'supplied'
+    )),
+    diagnostics: normalizeSuppliedDiagnostics(value?.diagnostics ?? [])
+  };
+}
+
+function declarationFile(sourcePath, sourceText, source) {
+  const text = String(sourceText ?? '');
+  return compactRecord({
+    sourcePath: normalizePath(sourcePath),
+    sourceText: text,
+    sourceHash: hashSemanticValue(text),
+    source,
+    bytes: byteLength(text)
+  });
+}
+
+function unavailableGate(input, id) {
+  const conflict = input.requireDeclarationOutput === true ? missingCompilerConflict(input) : undefined;
+  const conflicts = [conflict].filter(Boolean);
+  const status = conflict ? 'blocked' : 'skipped';
+  const core = {
+    kind: 'frontier.lang.jsTsProjectMergeDeclarationGate',
+    version: 1,
+    schema: 'frontier.lang.jsTsProjectMergeDeclarationGate.v1',
+    id: `${id}_declaration_output`,
+    status,
+    sourcePaths: [],
+    declarationFiles: [],
+    diagnostics: [],
+    conflicts,
+    admission: {
+      status,
+      action: conflict ? 'human-review' : 'skip-declarations',
+      reviewRequired: Boolean(conflict),
+      autoApplyCandidate: !conflict,
+      autoMergeClaim: false,
+      semanticEquivalenceClaim: false,
+      reasonCodes: uniqueStrings(conflicts.map((entry) => entry.code))
+    },
+    summary: declarationSummary([], [], conflicts),
+    evidence: [{
+      id: `${id}_declaration_output_evidence`,
+      kind: 'js-ts-project-declaration-output',
+      status: conflict ? 'failed' : 'skipped',
+      summary: conflict ? conflict.message : 'Declaration output was requested but no TypeScript compiler API or supplied declarations were provided.',
+      metadata: { declarationFiles: 0, conflicts: conflicts.length, declarationSource: 'missing' }
+    }]
+  };
+  return { ...core, hash: hashSemanticValue(core) };
+}
+
+function missingCompilerConflict(input) {
+  return {
+    code: 'project-declaration-output-unavailable',
+    gateId: 'project-declaration-output',
+    message: 'Project declaration output is required but no TypeScript compiler API or supplied declarations were provided.',
+    details: { required: input.requireDeclarationOutput === true }
+  };
+}
+
+function missingDeclarationsConflict(input) {
+  return {
+    code: 'project-declaration-output-empty',
+    gateId: 'project-declaration-output',
+    message: 'Project declaration output is required but no declaration files were emitted.',
+    details: { projectRoot: input.projectRoot }
+  };
+}
+
+function declarationConflict(input, diagnostic) {
+  return compactRecord({
+    code: 'project-declaration-diagnostic',
+    gateId: 'project-declaration-output',
+    message: `Project declaration diagnostic ${diagnostic.code}: ${diagnostic.message}`,
+    sourcePath: diagnostic.sourcePath,
+    details: { diagnostic, projectRoot: input.projectRoot }
+  });
+}
+
+function declarationSummary(declarationFiles, diagnostics, conflicts) {
+  return {
+    declarationFiles: declarationFiles.length,
+    declarationBytes: declarationFiles.reduce((total, file) => total + Number(file.bytes ?? 0), 0),
+    diagnostics: diagnostics.length,
+    conflicts: conflicts.length,
+    errors: diagnostics.filter((diagnostic) => diagnostic.severity === 'error').length,
+    warnings: diagnostics.filter((diagnostic) => diagnostic.severity === 'warning').length
+  };
+}
+
+function declarationEvidence(id, status, declarationOutput, diagnostics, conflicts, input) {
+  return {
+    id: `${id}_declaration_output_evidence`,
+    kind: 'js-ts-project-declaration-output',
+    status: status === 'passed' ? 'passed' : 'failed',
+    summary: status === 'passed'
+      ? `Emitted ${declarationOutput.declarationFiles.length} declaration file(s) for JS/TS project output.`
+      : `Blocked JS/TS project merge on ${conflicts.length} declaration output conflict(s).`,
+    metadata: {
+      declarationFiles: declarationOutput.declarationFiles.length,
+      diagnostics: diagnostics.length,
+      conflicts: conflicts.length,
+      declarationSource: input.outputDeclarations || input.outputDeclarationFiles ? 'supplied' : 'typescript-compiler-api',
+      autoMergeClaim: false,
+      semanticEquivalenceClaim: false
+    }
+  };
+}
+
+function byteLength(text) {
+  return typeof TextEncoder === 'function' ? new TextEncoder().encode(text).length : String(text).length;
+}
+
+export { createJsTsProjectMergeDeclarationGate };

package/dist/js-ts-safe-project-merge-diagnostics-metadata.js

@@ -0,0 +1,42 @@
+import { compactRecord } from './js-ts-safe-merge-context.js';
+import { describeJsTsProjectCompilerInputs, sourceMapMatch } from './js-ts-safe-project-merge-ts-program.js';
+
+const projectReferenceDiagnosticCodes = new Set([6053, 6305, 6306, 6310, 6311]);
+
+export function optionDiagnosticSource(diagnostic, metadata = {}) {
+  return metadata.projectReferenceCount && projectReferenceDiagnosticCodes.has(diagnostic.code)
+    ? 'typescript-project-references'
+    : 'typescript-compiler-options';
+}
+
+export function keepDiagnostic(diagnostic, sourceMap, projectRoot) {
+  if (!diagnostic.sourcePath) return true;
+  if (diagnostic.source === 'typescript-compiler-options' || diagnostic.source === 'typescript-project-references') return true;
+  return Boolean(sourceMapMatch(sourceMap, diagnostic.sourcePath, projectRoot));
+}
+
+export function uniqueDiagnostics(diagnostics) {
+  const seen = new Set();
+  return diagnostics.filter((diagnostic) => {
+    const key = `${diagnostic.source ?? ''}:${diagnostic.code}:${diagnostic.sourcePath ?? ''}:${diagnostic.start ?? ''}:${diagnostic.message}`;
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+}
+
+export function diagnosticsMetadata(compilerMetadata, rootNames, sourceMap, diagnosticSource) {
+  return compactRecord({
+    ...compilerMetadata,
+    diagnosticSource,
+    rootNames,
+    sourceFiles: sourceMap.size
+  });
+}
+
+export function diagnosticsGateMetadata(input, diagnosticsResult) {
+  return compactRecord({
+    ...(diagnosticsResult?.metadata ?? describeJsTsProjectCompilerInputs(input)),
+    diagnosticSource: diagnosticsResult?.metadata?.diagnosticSource ?? 'missing'
+  });
+}

package/dist/js-ts-safe-project-merge-diagnostics-ts.js

@@ -0,0 +1,73 @@
+import { compactRecord } from './js-ts-safe-merge-context.js';
+import {
+  diagnosticsMetadata,
+  keepDiagnostic,
+  optionDiagnosticSource,
+  uniqueDiagnostics
+} from './js-ts-safe-project-merge-diagnostics-metadata.js';
+import {
+  createJsTsVirtualTypeScriptProgram,
+  normalizePath,
+  normalizeTypeScriptDiagnostic,
+  sourceMapMatch
+} from './js-ts-safe-project-merge-ts-program.js';
+
+export function collectTypeScriptDiagnostics(input, outputFiles) {
+  const created = createJsTsVirtualTypeScriptProgram(input, outputFiles);
+  if (!created) return undefined;
+  const { ts, sourceMap, program, compilerOptionDiagnostics = [], compilerMetadata = {}, rootNames = [] } = created;
+  const projectRoot = normalizePath(input.projectRoot ?? '');
+  const options = input.diagnosticOptions ?? input.typescriptDiagnosticOptions ?? {};
+  const diagnostics = [...compilerOptionDiagnostics];
+  if (!program) {
+    return {
+      diagnostics: uniqueDiagnostics(diagnostics),
+      metadata: diagnosticsMetadata(compilerMetadata, rootNames, sourceMap, 'typescript-compiler-api')
+    };
+  }
+  if (options.options !== false && program.getOptionsDiagnostics) {
+    diagnostics.push(...program.getOptionsDiagnostics().map((diagnostic) => (
+      normalizeTypeScriptDiagnostic(ts, diagnostic, optionDiagnosticSource(diagnostic, compilerMetadata))
+    )));
+  }
+  for (const sourceFile of program.getSourceFiles()) {
+    if (!sourceMapMatch(sourceMap, sourceFile.fileName, projectRoot)) continue;
+    if (options.syntactic !== false && program.getSyntacticDiagnostics) {
+      diagnostics.push(...program.getSyntacticDiagnostics(sourceFile).map((diagnostic) => ({
+        diagnostic,
+        phase: 'syntax'
+      })));
+    }
+    if (options.semantic !== false && program.getSemanticDiagnostics) {
+      diagnostics.push(...program.getSemanticDiagnostics(sourceFile).map((diagnostic) => ({
+        diagnostic,
+        phase: 'semantic'
+      })));
+    }
+  }
+  return {
+    diagnostics: uniqueDiagnostics(diagnostics.map((entry) => (
+      entry?.diagnostic
+        ? withDiagnosticPhase(normalizeTypeScriptDiagnostic(ts, entry.diagnostic), entry.phase)
+        : withDiagnosticPhase(entry, entry.phase)
+    )).filter((diagnostic) => keepDiagnostic(diagnostic, sourceMap, projectRoot))),
+    metadata: diagnosticsMetadata(compilerMetadata, rootNames, sourceMap, 'typescript-compiler-api')
+  };
+}
+
+function withDiagnosticPhase(diagnostic, phase) {
+  const normalizedPhase = normalizeDiagnosticPhase(phase);
+  return compactRecord({
+    ...diagnostic,
+    phase: normalizedPhase,
+    syntax: diagnostic.syntax === true || normalizedPhase === 'syntax' ? true : undefined
+  });
+}
+
+function normalizeDiagnosticPhase(value) {
+  if (typeof value !== 'string') return undefined;
+  const lowered = value.toLowerCase();
+  if (lowered.includes('syntax') || lowered.includes('syntactic') || lowered.includes('parse')) return 'syntax';
+  if (lowered.includes('semantic') || lowered.includes('type')) return 'semantic';
+  return value;
+}

package/dist/js-ts-safe-project-merge-diagnostics.js

@@ -0,0 +1,283 @@
+import { hashSemanticValue } from '@shapeshift-labs/frontier-lang-kernel';
+import { compactRecord, uniqueStrings } from './js-ts-safe-merge-context.js';
+import { diagnosticsGateMetadata } from './js-ts-safe-project-merge-diagnostics-metadata.js';
+import { collectTypeScriptDiagnostics } from './js-ts-safe-project-merge-diagnostics-ts.js';
+import {
+  collectJsxComponentPropContractsFromFileResults,
+  jsxComponentPropContractConflict,
+  jsxComponentPropContractEvidence,
+  jsxComponentPropContractSummary,
+  matchingJsxComponentPropContracts,
+  normalizeJsxComponentPropContracts
+} from './js-ts-safe-project-merge-jsx-prop-contracts.js';
+import {
+  describeJsTsProjectCompilerInputs,
+  normalizeSuppliedDiagnostics
+} from './js-ts-safe-project-merge-ts-program.js';
+
+const projectOutputDiagnosticCode = 'project-output-diagnostic';
+const projectOutputSyntaxDiagnosticCode = 'project-output-syntax-diagnostic';
+const projectOutputDiagnosticsUnavailableCode = 'project-output-diagnostics-unavailable';
+const projectOutputSyntaxDiagnosticsUnavailableCode = 'project-output-syntax-diagnostics-unavailable';
+
+function createJsTsProjectMergeDiagnosticsGate(input = {}, outputFiles = [], id = 'js_ts_project_safe_merge', context = {}) {
+  const jsxComponentPropContracts = normalizeJsxComponentPropContracts(
+    input.jsxComponentPropContracts
+      ?? input.jsxComponentPropContractCandidates
+      ?? context.jsxComponentPropContracts
+      ?? collectJsxComponentPropContractsFromFileResults(context.fileResults)
+  );
+  const suppliedDiagnostics = normalizeSuppliedOutputDiagnostics(input);
+  const diagnosticsResult = suppliedDiagnostics !== undefined
+    ? suppliedDiagnosticsResult(input, suppliedDiagnostics)
+    : collectTypeScriptDiagnostics(input, outputFiles);
+  const diagnostics = diagnosticsResult?.diagnostics;
+  const metadata = diagnosticsGateMetadata(input, diagnosticsResult);
+  const syntaxOnly = requiresOutputSyntaxDiagnostics(input) && input.requireOutputDiagnostics !== true && input.outputDiagnostics === undefined;
+  if (!diagnostics && input.requireOutputDiagnostics !== true && !requiresOutputSyntaxDiagnostics(input) && !jsxComponentPropContracts.length) return undefined;
+  if (!diagnostics) return unavailableGate(input, id, syntaxOnly, metadata, outputFiles, jsxComponentPropContracts);
+  const errorDiagnostics = diagnostics.filter((diagnostic) => (
+    diagnostic.severity === 'error' && (!syntaxOnly || isSyntaxDiagnostic(diagnostic))
+  ));
+  const conflicts = errorDiagnostics.map((diagnostic) => diagnosticConflict(input, diagnostic, jsxComponentPropContracts));
+  const status = conflicts.length ? 'blocked' : 'passed';
+  const core = {
+    kind: 'frontier.lang.jsTsProjectMergeDiagnosticsGate',
+    version: 1,
+    schema: 'frontier.lang.jsTsProjectMergeDiagnosticsGate.v1',
+    id: `${id}_output_diagnostics`,
+    status,
+    sourcePaths: outputFiles.map((file) => file.sourcePath).filter(Boolean),
+    diagnostics,
+    conflicts,
+    admission: {
+      status: status === 'passed' ? 'auto-merge-candidate' : 'blocked',
+      action: status === 'passed' ? 'accept-diagnostics' : 'human-review',
+      reviewRequired: status !== 'passed',
+      autoApplyCandidate: status === 'passed',
+      autoMergeClaim: false,
+      semanticEquivalenceClaim: false,
+      reasonCodes: uniqueStrings(conflicts.map((conflict) => conflict.code))
+    },
+    summary: diagnosticsSummary(diagnostics, conflicts, jsxComponentPropContracts),
+    metadata,
+    evidence: [{
+      id: `${id}_output_diagnostics_evidence`,
+      kind: 'js-ts-project-output-diagnostics',
+      status: status === 'passed' ? 'passed' : 'failed',
+      summary: status === 'passed'
+        ? `Validated ${outputFiles.length} JS/TS output file(s) with no blocking diagnostics.`
+        : `Blocked JS/TS project merge on ${conflicts.length} output diagnostic conflict(s).`,
+      metadata: {
+        diagnostics: diagnostics.length,
+        conflicts: conflicts.length,
+        diagnosticSource: metadata.diagnosticSource,
+        compilerOptions: metadata.compilerOptions,
+        compilerOptionSources: metadata.compilerOptionSources,
+        projectReferences: metadata.projectReferences,
+        projectReferenceCount: metadata.projectReferenceCount,
+        jsxComponentPropContractCandidates: jsxComponentPropContracts.length || undefined,
+        syntaxOnly,
+        autoMergeClaim: false,
+        semanticEquivalenceClaim: false
+      }
+    }, ...jsxComponentPropContractEvidence(id, status, diagnostics, conflicts, metadata.diagnosticSource, jsxComponentPropContracts)]
+  };
+  return { ...core, hash: hashSemanticValue(core) };
+}
+
+function suppliedDiagnosticsResult(input, diagnostics) {
+  return {
+    diagnostics,
+    metadata: {
+      ...describeJsTsProjectCompilerInputs(input),
+      diagnosticSource: diagnosticSource(input),
+      hasTypescriptCompilerApi: Boolean(input.typescript ?? input.ts ?? input.typescriptModule)
+    }
+  };
+}
+
+function unavailableGate(input, id, syntaxOnly = false, metadata = {}, outputFiles = [], jsxComponentPropContracts = []) {
+  const code = syntaxOnly ? projectOutputSyntaxDiagnosticsUnavailableCode : projectOutputDiagnosticsUnavailableCode;
+  const diagnosticConflict = {
+    code,
+    gateId: 'project-output-diagnostics',
+    message: syntaxOnly
+      ? 'Project output syntax diagnostics are required but no TypeScript compiler API or supplied syntax diagnostics were provided.'
+      : 'Project output diagnostics are required but no TypeScript compiler API or supplied diagnostics were provided.',
+    details: { required: input.requireOutputDiagnostics === true, syntaxRequired: requiresOutputSyntaxDiagnostics(input) }
+  };
+  const conflicts = [
+    ...(input.requireOutputDiagnostics === true || requiresOutputSyntaxDiagnostics(input) ? [diagnosticConflict] : []),
+    ...(jsxComponentPropContracts.length ? [jsxComponentPropContractConflict(jsxComponentPropContracts)] : [])
+  ];
+  const gateConflicts = conflicts.length ? conflicts : [diagnosticConflict];
+  const core = {
+    kind: 'frontier.lang.jsTsProjectMergeDiagnosticsGate',
+    version: 1,
+    schema: 'frontier.lang.jsTsProjectMergeDiagnosticsGate.v1',
+    id: `${id}_output_diagnostics`,
+    status: 'blocked',
+    sourcePaths: outputFiles.map((file) => file.sourcePath).filter(Boolean),
+    diagnostics: [],
+    conflicts: gateConflicts,
+    admission: {
+      status: 'blocked',
+      action: 'human-review',
+      reviewRequired: true,
+      autoApplyCandidate: false,
+      autoMergeClaim: false,
+      semanticEquivalenceClaim: false,
+      reasonCodes: uniqueStrings(gateConflicts.map((conflict) => conflict.code))
+    },
+    summary: diagnosticsSummary([], gateConflicts, jsxComponentPropContracts),
+    metadata,
+    evidence: [{
+      id: `${id}_output_diagnostics_evidence`,
+      kind: 'js-ts-project-output-diagnostics',
+      status: 'failed',
+      summary: gateConflicts.map((conflict) => conflict.message).join(' '),
+      metadata: {
+        diagnostics: 0,
+        conflicts: gateConflicts.length,
+        diagnosticSource: 'missing',
+        compilerOptions: metadata.compilerOptions,
+        compilerOptionSources: metadata.compilerOptionSources,
+        projectReferences: metadata.projectReferences,
+        projectReferenceCount: metadata.projectReferenceCount,
+        jsxComponentPropContractCandidates: jsxComponentPropContracts.length || undefined,
+        syntaxOnly
+      }
+    }, ...jsxComponentPropContractEvidence(id, 'blocked', [], gateConflicts, 'missing', jsxComponentPropContracts)]
+  };
+  return { ...core, hash: hashSemanticValue(core) };
+}
+
+function diagnosticConflict(input, diagnostic, jsxComponentPropContracts = []) {
+  const syntax = isSyntaxDiagnostic(diagnostic);
+  const matchingContracts = matchingJsxComponentPropContracts(diagnostic, jsxComponentPropContracts);
+  return compactRecord({
+    code: syntax ? projectOutputSyntaxDiagnosticCode : projectOutputDiagnosticCode,
+    gateId: 'project-output-diagnostics',
+    message: `${syntax ? 'Project output syntax diagnostic' : 'Project output diagnostic'} ${diagnostic.code}: ${diagnostic.message}`,
+    sourcePath: diagnostic.sourcePath,
+    details: {
+      diagnostic,
+      syntax,
+      projectRoot: input.projectRoot,
+      jsxComponentPropContracts: matchingContracts.length ? matchingContracts : undefined
+    }
+  });
+}
+
+function diagnosticsSummary(diagnostics, conflicts, jsxComponentPropContracts = []) {
+  const bySeverity = {};
+  const bySource = {};
+  const byPhase = {};
+  for (const diagnostic of diagnostics) {
+    bySeverity[diagnostic.severity] = (bySeverity[diagnostic.severity] ?? 0) + 1;
+    bySource[diagnostic.source ?? 'unknown'] = (bySource[diagnostic.source ?? 'unknown'] ?? 0) + 1;
+    byPhase[diagnostic.phase ?? 'unknown'] = (byPhase[diagnostic.phase ?? 'unknown'] ?? 0) + 1;
+  }
+  return {
+    diagnostics: diagnostics.length,
+    conflicts: conflicts.length,
+    errors: diagnostics.filter((diagnostic) => diagnostic.severity === 'error').length,
+    warnings: diagnostics.filter((diagnostic) => diagnostic.severity === 'warning').length,
+    syntaxErrors: diagnostics.filter((diagnostic) => diagnostic.severity === 'error' && isSyntaxDiagnostic(diagnostic)).length,
+    bySeverity,
+    bySource,
+    byPhase,
+    ...jsxComponentPropContractSummary(jsxComponentPropContracts)
+  };
+}
+
+function normalizeSuppliedOutputDiagnostics(input) {
+  const hasOutputDiagnostics = Object.hasOwn(input, 'outputDiagnostics');
+  const hasOutputSyntaxDiagnostics = Object.hasOwn(input, 'outputSyntaxDiagnostics')
+    || Object.hasOwn(input, 'mergedOutputSyntaxDiagnostics')
+    || input.syntaxDiagnostics?.output !== undefined
+    || input.syntaxDiagnostics?.merged !== undefined;
+  if (!hasOutputDiagnostics && !hasOutputSyntaxDiagnostics) return undefined;
+  return [
+    ...normalizeSuppliedDiagnosticsWithPhase(input.outputDiagnostics, undefined),
+    ...normalizeSuppliedDiagnosticsWithPhase(input.outputSyntaxDiagnostics, 'syntax'),
+    ...normalizeSuppliedDiagnosticsWithPhase(input.mergedOutputSyntaxDiagnostics, 'syntax'),
+    ...normalizeSuppliedDiagnosticsWithPhase(input.syntaxDiagnostics?.output, 'syntax'),
+    ...normalizeSuppliedDiagnosticsWithPhase(input.syntaxDiagnostics?.merged, 'syntax')
+  ];
+}
+
+function normalizeSuppliedDiagnosticsWithPhase(value, fallbackPhase) {
+  if (value === undefined) return [];
+  const rawDiagnostics = Array.isArray(value) ? value : [value].filter(Boolean);
+  const normalized = normalizeSuppliedDiagnostics(value);
+  return normalized.map((diagnostic, index) => withDiagnosticPhase(diagnostic, suppliedDiagnosticPhase(rawDiagnostics[index], fallbackPhase)));
+}
+
+function withDiagnosticPhase(diagnostic, phase) {
+  const normalizedPhase = normalizeDiagnosticPhase(phase);
+  const syntax = diagnostic.syntax === true || normalizedPhase === 'syntax' || isSyntaxDiagnostic(diagnostic);
+  return compactRecord({
+    ...diagnostic,
+    phase: normalizedPhase,
+    syntax: syntax ? true : undefined
+  });
+}
+
+function suppliedDiagnosticPhase(diagnostic, fallbackPhase) {
+  return diagnostic?.phase
+    ?? diagnostic?.diagnosticPhase
+    ?? diagnostic?.kind
+    ?? diagnostic?.type
+    ?? (diagnostic?.syntax === true ? 'syntax' : undefined)
+    ?? fallbackPhase;
+}
+
+function requiresOutputSyntaxDiagnostics(input) {
+  return input.requireOutputSyntaxDiagnostics === true
+    || input.requireOutputSyntaxGate === true
+    || input.requireMergedOutputSyntaxDiagnostics === true
+    || input.requireSyntaxGate === true;
+}
+
+function isSyntaxDiagnostic(diagnostic) {
+  if (diagnostic.syntax === true) return true;
+  const text = [
+    diagnostic.phase,
+    diagnostic.kind,
+    diagnostic.category,
+    diagnostic.type,
+    diagnostic.source,
+    diagnostic.ruleId,
+    diagnostic.name,
+    diagnostic.code
+  ].filter(Boolean).join(' ').toLowerCase();
+  return /\bsyntax\b|\bsyntactic\b|\bparse\b|\bparser\b/.test(text) || isTypeScriptSyntaxDiagnosticCode(diagnostic.code);
+}
+
+function isTypeScriptSyntaxDiagnosticCode(code) {
+  const match = /^TS(\d+)$/.exec(String(code ?? ''));
+  if (!match) return false;
+  const numeric = Number(match[1]);
+  return numeric >= 1000 && numeric < 2000;
+}
+
+function normalizeDiagnosticPhase(value) {
+  if (typeof value !== 'string') return undefined;
+  const lowered = value.toLowerCase();
+  if (lowered.includes('syntax') || lowered.includes('syntactic') || lowered.includes('parse')) return 'syntax';
+  if (lowered.includes('semantic') || lowered.includes('type')) return 'semantic';
+  return value;
+}
+
+function diagnosticSource(input) {
+  if (input.outputDiagnostics !== undefined && (input.outputSyntaxDiagnostics !== undefined || input.mergedOutputSyntaxDiagnostics !== undefined)) {
+    return 'supplied-mixed';
+  }
+  if (input.outputDiagnostics !== undefined) return 'supplied';
+  if (input.outputSyntaxDiagnostics !== undefined || input.mergedOutputSyntaxDiagnostics !== undefined || input.syntaxDiagnostics) return 'supplied-syntax';
+  return 'typescript-compiler-api';
+}
+
+export { createJsTsProjectMergeDiagnosticsGate };

package/dist/js-ts-safe-project-merge-evidence-routing.js

@@ -0,0 +1,38 @@
+function failedEvidenceMissingItems(evidence = []) {
+  return evidence
+    .filter((record) => record?.status === 'failed' && isPlainObject(record.metadata?.nextMissingEvidence))
+    .map((record) => {
+      const nextMissingEvidence = record.metadata.nextMissingEvidence;
+      const route = nextMissingEvidence.route;
+      return compactRecord({
+        ...nextMissingEvidence,
+        status: nextMissingEvidence.status ?? 'missing-or-failed',
+        evidenceId: record.id,
+        routeId: nextMissingEvidence.routeId ?? route?.id,
+        routeLane: nextMissingEvidence.routeLane ?? route?.lane,
+        routeNext: nextMissingEvidence.routeNext ?? route?.next,
+        autoMergeClaim: false,
+        semanticEquivalenceClaim: false
+      });
+    });
+}
+
+function fileAdmissionEvidenceRecords(files = []) {
+  return files.flatMap((file) => [
+    ...recordArraysWithSuffix(file.summary, 'AdmissionEvidence'),
+    ...recordArraysWithSuffix(file.metadata, 'Admissions')
+  ]);
+}
+
+function recordArraysWithSuffix(record, suffix) {
+  if (!isPlainObject(record)) return [];
+  return Object.entries(record)
+    .filter(([key, value]) => key.endsWith(suffix) && Array.isArray(value))
+    .flatMap(([, value]) => value)
+    .filter((value) => value?.kind && value?.id);
+}
+
+function isPlainObject(value) { return Boolean(value && typeof value === 'object' && !Array.isArray(value)); }
+function compactRecord(record) { return Object.fromEntries(Object.entries(record).filter(([, value]) => value !== undefined)); }
+
+export { failedEvidenceMissingItems, fileAdmissionEvidenceRecords };