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

package/dist/js-ts-safe-project-merge-graph-delta-module-declarations.js

@@ -0,0 +1,155 @@
+import { compactRecord } from './js-ts-safe-merge-context.js';
+import { globalAugmentationCompatibilityAssessment, sourceSpanHash } from './js-ts-safe-project-merge-global-augmentation-compatibility.js';
+
+function projectModuleDeclarationDeltaConflicts(projectGraphDelta, options = {}) {
+  return [
+    ...changedShapeConflicts({
+      code: 'project-module-declaration-shape-delta-conflict',
+      label: 'module declaration shape',
+      baseRecords: projectGraphDelta?.stages?.base?.projectSymbolGraph?.moduleDeclarationRecords,
+      workerRecords: projectGraphDelta?.stages?.worker?.projectSymbolGraph?.moduleDeclarationRecords,
+      headRecords: projectGraphDelta?.stages?.head?.projectSymbolGraph?.moduleDeclarationRecords,
+      outputRecords: projectGraphDelta?.stages?.output?.projectSymbolGraph?.moduleDeclarationRecords,
+      identityKey: moduleDeclarationIdentityKey,
+      details: moduleDeclarationDetails,
+      proofAssessment: (identityKey, baseRecord, workerRecord, headRecord, outputRecord) => globalAugmentationDeltaProofAssessment(identityKey, baseRecord, workerRecord, headRecord, outputRecord, options)
+    }),
+    ...changedShapeConflicts({
+      code: 'project-export-assignment-shape-delta-conflict',
+      label: 'export assignment shape',
+      baseRecords: projectGraphDelta?.stages?.base?.projectSymbolGraph?.exportAssignmentRecords,
+      workerRecords: projectGraphDelta?.stages?.worker?.projectSymbolGraph?.exportAssignmentRecords,
+      headRecords: projectGraphDelta?.stages?.head?.projectSymbolGraph?.exportAssignmentRecords,
+      outputRecords: projectGraphDelta?.stages?.output?.projectSymbolGraph?.exportAssignmentRecords,
+      identityKey: exportAssignmentIdentityKey,
+      details: exportAssignmentDetails
+    })
+  ];
+}
+
+function changedShapeConflicts(input) {
+  const base = recordsByIdentityKey(input.baseRecords, input.identityKey);
+  const worker = recordsByIdentityKey(input.workerRecords, input.identityKey);
+  const head = recordsByIdentityKey(input.headRecords, input.identityKey);
+  const output = recordsByIdentityKey(input.outputRecords, input.identityKey);
+  const keys = uniqueStrings([...base.keys(), ...worker.keys(), ...head.keys()]);
+  return keys.flatMap((identityKey) => {
+    const baseHash = base.get(identityKey)?.shapeHash;
+    const workerHash = worker.get(identityKey)?.shapeHash;
+    const headHash = head.get(identityKey)?.shapeHash;
+    if (baseHash === workerHash || baseHash === headHash || workerHash === headHash) return [];
+    const proof = input.proofAssessment?.(identityKey, base.get(identityKey), worker.get(identityKey), head.get(identityKey), output.get(identityKey));
+    if (proof?.status === 'passed') return [];
+    return [shapeConflict(input, identityKey, base.get(identityKey), worker.get(identityKey), head.get(identityKey), output.get(identityKey), proof)];
+  });
+}
+
+function shapeConflict(input, identityKey, baseRecord, workerRecord, headRecord, outputRecord, proof = undefined) {
+  const sourcePath = workerRecord?.sourcePath ?? headRecord?.sourcePath ?? baseRecord?.sourcePath;
+  const conflictKey = `project-graph-delta#${input.label.replace(/\s+/g, '-')}#${identityKey}`;
+  return {
+    code: input.code,
+    gateId: 'project-graph-delta',
+    message: `Worker and head both changed ${input.label} ${JSON.stringify(identityKey)} with incompatible static shape evidence.`,
+    sourcePath,
+    details: compactRecord({
+      reasonCode: input.code,
+      conflictKey,
+      identityKey,
+      sourcePath,
+      base: input.details(baseRecord),
+      worker: input.details(workerRecord),
+      head: input.details(headRecord),
+      output: input.details(outputRecord),
+      requiredProof: 'static-shape-evidence',
+      routeId: proof?.routeId,
+      routeLane: proof?.routeLane,
+      routeNext: proof?.routeNext,
+      reasonCodes: proof?.reasonCodes,
+      globalAugmentationCompatibilityProof: proof?.record,
+      semanticEquivalenceClaim: false
+    })
+  };
+}
+
+function globalAugmentationDeltaProofAssessment(identityKey, baseRecord, workerRecord, headRecord, outputRecord, options) {
+  const record = outputRecord ?? workerRecord ?? headRecord ?? baseRecord;
+  if (record?.surfaceKind !== 'global-augmentation') return undefined;
+  return globalAugmentationCompatibilityAssessment({
+    identityKey,
+    sourcePath: record.sourcePath,
+    sourceHash: record.sourceHash,
+    moduleName: record.moduleName,
+    surfaceKind: record.surfaceKind,
+    moduleDeclarationRecordId: record.id,
+    moduleDeclarationShapeHash: record.shapeHash,
+    moduleDeclarationSignatureHash: record.signatureHash,
+    sourceSpanHash: sourceSpanHash(record.sourceSpan),
+    declarationOutputHash: options.declarationEmitParityProof?.outputDeclarationBoundaryHash,
+    ...compatibilityGateContext(options)
+  }, options);
+}
+
+function compatibilityGateContext(options = {}) {
+  return compactRecord({
+    consumerDiagnosticsPassed: options.outputDiagnosticsGate ? options.outputDiagnosticsGate.status === 'passed' : undefined
+  });
+}
+
+function moduleDeclarationIdentityKey(record) {
+  return stableKey(['module-declaration', record?.sourcePath, record?.surfaceKind, record?.moduleName]);
+}
+
+function exportAssignmentIdentityKey(record) {
+  return stableKey(['export-assignment', record?.sourcePath, record?.exportKind, record?.exportedName]);
+}
+
+function moduleDeclarationDetails(record) {
+  if (!record) return undefined;
+  return compactRecord({
+    sourcePath: record.sourcePath,
+    moduleName: record.moduleName,
+    surfaceKind: record.surfaceKind,
+    declarationOnly: record.declarationOnly,
+    runtimeNamespace: record.runtimeNamespace,
+    shapeHash: record.shapeHash,
+    proofLevel: record.shapeProof?.proofLevel,
+    unsupportedSignals: record.shapeProof?.unsupportedSignals,
+    semanticEquivalenceClaim: false
+  });
+}
+
+function exportAssignmentDetails(record) {
+  if (!record) return undefined;
+  return compactRecord({
+    sourcePath: record.sourcePath,
+    exportedName: record.exportedName,
+    localName: record.localName,
+    exportKind: record.exportKind,
+    shapeHash: record.shapeHash,
+    proofLevel: record.shapeProof?.proofLevel,
+    unsupportedSignals: record.shapeProof?.unsupportedSignals,
+    semanticEquivalenceClaim: false
+  });
+}
+
+function recordsByIdentityKey(records, identityKey) {
+  const result = new Map();
+  for (const record of records ?? []) {
+    const key = identityKey(record);
+    if (!key || result.has(key)) continue;
+    result.set(key, record);
+  }
+  return result;
+}
+
+function stableKey(parts) {
+  const values = parts.map((part) => part === undefined || part === null ? '' : String(part));
+  return values.some(Boolean) ? values.join('#') : undefined;
+}
+
+function uniqueStrings(values) {
+  return [...new Set(values.filter((value) => typeof value === 'string' && value.length > 0))];
+}
+
+export { projectModuleDeclarationDeltaConflicts };

package/dist/js-ts-safe-project-merge-graph-limits.js

@@ -6,8 +6,13 @@ const PROJECT_GRAPH_INVALID_LIMIT_CODE = 'project-graph-limit-invalid';
 const LIMIT_FIELDS = [
   ['maxFiles', 'source-files'],
   ['maxSourceBytes', 'source-bytes'],
+  ['maxSourceSpans', 'source-spans'],
   ['maxImportEdges', 'import-edges'],
   ['maxExportEdges', 'export-edges'],
+  ['maxScopeBindings', 'scope-bindings'],
+  ['maxScopeReferences', 'scope-references'],
+  ['maxJsxElements', 'jsx-elements'],
+  ['maxJsxProps', 'jsx-props'],
   ['maxSerializedBytes', 'serialized-bytes']
 ];
 
@@ -58,10 +63,20 @@ function projectGraphInvalidLimitConflicts(limits, stage) {
 
 function projectGraphEdgeLimitConflicts(limits, stage, projectSymbolGraph) {
   const importEdges = Array.isArray(projectSymbolGraph?.importEdges) ? projectSymbolGraph.importEdges.length : 0;
+  const sourceSpans = Array.isArray(projectSymbolGraph?.sourceSpanRecords) ? projectSymbolGraph.sourceSpanRecords.length : 0;
   const exportEdges = Array.isArray(projectSymbolGraph?.exportEdges) ? projectSymbolGraph.exportEdges.length : 0;
+  const scopeBindings = Array.isArray(projectSymbolGraph?.scopeBindingRecords) ? projectSymbolGraph.scopeBindingRecords.length : 0;
+  const scopeReferences = Array.isArray(projectSymbolGraph?.scopeReferenceRecords) ? projectSymbolGraph.scopeReferenceRecords.length : 0;
+  const jsxElements = Array.isArray(projectSymbolGraph?.jsxElementRecords) ? projectSymbolGraph.jsxElementRecords.length : 0;
+  const jsxProps = Array.isArray(projectSymbolGraph?.jsxPropRecords) ? projectSymbolGraph.jsxPropRecords.length : 0;
   return [
     limitConflict(limits.maxImportEdges, stage, 'import-edges', importEdges),
-    limitConflict(limits.maxExportEdges, stage, 'export-edges', exportEdges)
+    limitConflict(limits.maxSourceSpans, stage, 'source-spans', sourceSpans),
+    limitConflict(limits.maxExportEdges, stage, 'export-edges', exportEdges),
+    limitConflict(limits.maxScopeBindings, stage, 'scope-bindings', scopeBindings),
+    limitConflict(limits.maxScopeReferences, stage, 'scope-references', scopeReferences),
+    limitConflict(limits.maxJsxElements, stage, 'jsx-elements', jsxElements),
+    limitConflict(limits.maxJsxProps, stage, 'jsx-props', jsxProps)
   ].filter(Boolean);
 }
 

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

@@ -32,10 +32,21 @@ function createJsTsProjectSafeMergeGraphDelta(input, files, outputFiles, mergeId
     summary: {
       stages: Object.keys(stages).length,
       sourceFiles: sumStageSummary(stageSummaries, 'sourceFiles'),
+      sourceFileRecords: sumStageSummary(stageSummaries, 'sourceFileRecords'),
+      sourceSpanRecords: sumStageSummary(stageSummaries, 'sourceSpanRecords'),
       publicContractRegions: sumStageSummary(stageSummaries, 'publicContractRegions'),
       reExportIdentities: sumStageSummary(stageSummaries, 'reExportIdentities'),
+      moduleDeclarationRecords: sumStageSummary(stageSummaries, 'moduleDeclarationRecords'),
+      exportAssignmentRecords: sumStageSummary(stageSummaries, 'exportAssignmentRecords'),
       importEdges: sumStageSummary(stageSummaries, 'importEdges'),
       exportEdges: sumStageSummary(stageSummaries, 'exportEdges'),
+      compilerSymbolRecords: sumStageSummary(stageSummaries, 'compilerSymbolRecords'),
+      compilerTypeRecords: sumStageSummary(stageSummaries, 'compilerTypeRecords'),
+      runtimeRegionRecords: sumStageSummary(stageSummaries, 'runtimeRegionRecords'),
+      scopeBindingRecords: sumStageSummary(stageSummaries, 'scopeBindingRecords'),
+      scopeReferenceRecords: sumStageSummary(stageSummaries, 'scopeReferenceRecords'),
+      jsxElementRecords: sumStageSummary(stageSummaries, 'jsxElementRecords'),
+      jsxPropRecords: sumStageSummary(stageSummaries, 'jsxPropRecords'),
       unresolvedImportEdges: sumStageSummary(stageSummaries, 'unresolvedImportEdges'),
       suppliedImports: sumStageSummary(stageSummaries, 'suppliedImports'),
       matchedSuppliedImports: sumStageSummary(stageSummaries, 'matchedSuppliedImports'),
@@ -68,6 +79,7 @@ function createProjectGraphStageArtifacts(input, files, mergeId, stageName, stag
     sourcePath: file.sourcePath,
     sourceText: file.sourceText,
     sourceHash: file.sourceHash,
+    parserTriviaEvidence: file.parserTriviaEvidence,
     metadata: { semanticImportExpected: true, projectSafeMergeStage: stageName, projectSafeMergeOutput: stageName === 'output' }
   }));
   const importSelections = sources.map((source) => {
@@ -164,10 +176,21 @@ function projectGraphStageSummary(stageName, projectSymbolGraph, importSource, s
     documents: projectSymbolGraph?.documentCount ?? 0,
     symbols: projectSymbolGraph?.symbolCount ?? 0,
     fileHashes: projectSymbolGraph?.fileHashes?.length ?? 0,
+    sourceFileRecords: projectSymbolGraph?.sourceFileRecords?.length ?? 0,
+    sourceSpanRecords: projectSymbolGraph?.sourceSpanRecords?.length ?? 0,
     importEdges: importEdges.length,
     exportEdges: projectSymbolGraph?.exportEdges?.length ?? 0,
     publicContractRegions: projectSymbolGraph?.publicContractRegions?.length ?? 0,
+    compilerSymbolRecords: projectSymbolGraph?.compilerSymbolRecords?.length ?? 0,
+    compilerTypeRecords: projectSymbolGraph?.compilerTypeRecords?.length ?? 0,
+    runtimeRegionRecords: projectSymbolGraph?.runtimeRegionRecords?.length ?? 0,
+    scopeBindingRecords: projectSymbolGraph?.scopeBindingRecords?.length ?? 0,
+    scopeReferenceRecords: projectSymbolGraph?.scopeReferenceRecords?.length ?? 0,
+    jsxElementRecords: projectSymbolGraph?.jsxElementRecords?.length ?? 0,
+    jsxPropRecords: projectSymbolGraph?.jsxPropRecords?.length ?? 0,
     reExportIdentities: projectSymbolGraph?.reExportIdentities?.length ?? 0,
+    moduleDeclarationRecords: projectSymbolGraph?.moduleDeclarationRecords?.length ?? 0,
+    exportAssignmentRecords: projectSymbolGraph?.exportAssignmentRecords?.length ?? 0,
     unresolvedImportEdges: importEdges.filter(isMissingProjectImportEdge).length,
     suppliedImports: importSource.suppliedImports,
     matchedSuppliedImports: importSource.matchedSuppliedImports,
@@ -188,13 +211,13 @@ function sumStageSummary(stageSummaries, field) {
 function projectGraphDeltaStageFiles(files, outputFiles, input) {
   return {
     base: files
-      .map((file) => stageFile(file, file.baseSourceText, input))
+      .map((file) => stageFile(file, file.baseSourceText, input, 'base'))
       .filter(Boolean),
     worker: files
-      .map((file) => stageFile(file, workerStageSourceText(file), input))
+      .map((file) => stageFile(file, workerStageSourceText(file), input, 'worker'))
       .filter(Boolean),
     head: files
-      .map((file) => stageFile(file, headStageSourceText(file), input))
+      .map((file) => stageFile(file, headStageSourceText(file), input, 'head'))
       .filter(Boolean),
     output: outputFiles
   };
@@ -210,16 +233,25 @@ function headStageSourceText(file) {
   return file.headSourceText ?? file.baseSourceText;
 }
 
-function stageFile(file, sourceText, input) {
+function stageFile(file, sourceText, input, stageName) {
   if (typeof sourceText !== 'string' || !file.sourcePath) return undefined;
   return compactRecord({
     sourcePath: file.sourcePath,
     language: file.language ?? input.language,
     sourceText,
-    sourceHash: hashText(sourceText)
+    sourceHash: hashText(sourceText),
+    parserTriviaEvidence: parserTriviaEvidenceForStage(file, stageName)
   });
 }
 
+function parserTriviaEvidenceForStage(file, stageName) {
+  if (stageName === 'base') return file.baseParserTriviaEvidence ?? file.parserTriviaEvidence;
+  if (stageName === 'worker') return file.workerParserTriviaEvidence ?? file.parserTriviaEvidence;
+  if (stageName === 'head') return file.headParserTriviaEvidence ?? file.parserTriviaEvidence;
+  if (stageName === 'output') return file.outputParserTriviaEvidence ?? file.parserTriviaEvidence;
+  return file.parserTriviaEvidence;
+}
+
 function attachProjectSymbolGraph(projectImport, projectSymbolGraph) {
   return {
     ...projectImport,

package/dist/js-ts-safe-project-merge-import-removal.js

@@ -0,0 +1,292 @@
+import { hashSemanticValue } from '@shapeshift-labs/frontier-lang-kernel';
+import { JsTsSafeMergeConflictCodes, JsTsSafeMergeStatuses, jsTsSafeMergeGateOrder } from './js-ts-safe-merge-constants.js';
+import { compactRecord, createMergeContext, sameStatementText, uniqueStrings } from './js-ts-safe-merge-context.js';
+import { scanJsTsTopLevelLedger } from './js-ts-safe-merge-ledger.js';
+import { analyzeImportRemovalUseDefEvidence, LexicalUseDefReasonCodes } from './js-ts-semantic-scope-use-def.js';
+
+const ImportRemovalUsageProofConflictCode = 'project-import-removal-usage-proof-unavailable';
+const ImportRemovalUsageProofGateId = 'project-import-removal-usage-proof';
+const ImportRemovalUsageProofOperation = 'merged-import-removal-usage-proof';
+const ImportRemovalLexicalUseDefConflictCode = 'project-import-removal-lexical-use-def-blocked';
+const ImportRemovalLexicalUseDefGateId = 'project-import-removal-lexical-use-def';
+
+function maybeMergeImportSpecifierRemovalFile(file, context, result, input) {
+  const usageProof = analyzeNarrowImportSpecifierRemoval(file, context, result);
+  if (!usageProof) return undefined;
+  if (usageProof.lexicalUseDefEvidence?.status === 'blocked') {
+    return blockedImportRemovalLexicalUseDefFile(file, context, result, usageProof);
+  }
+  if (!hasImportRemovalUsageProofInput(input)) return blockedImportRemovalUsageProofFile(file, context, result, usageProof);
+  const admission = admittedImportRemovalUsageProofAdmission();
+  const mergeResult = importRemovalUsageProofMergeResult(context, result, usageProof, input, admission);
+  return compactRecord({
+    kind: 'frontier.lang.jsTsProjectSafeMergeFile',
+    version: 1,
+    sourcePath: file.sourcePath,
+    language: context.language,
+    status: 'merged',
+    operation: ImportRemovalUsageProofOperation,
+    outputSourceText: usageProof.outputSourceText,
+    outputHash: hashText(usageProof.outputSourceText),
+    baseHash: hashText(file.baseSourceText),
+    workerHash: hashText(usageProof.outputSourceText),
+    headHash: hashText(file.headSourceText ?? file.baseSourceText),
+    result: mergeResult,
+    conflicts: [],
+    admission,
+    summary: mergeResult.summary,
+    conflictKeys: [`source#${file.sourcePath}`],
+    metadata: mergeResult.metadata
+  });
+}
+
+function analyzeNarrowImportSpecifierRemoval(file, context, result) {
+  const conflicts = result.conflicts ?? [];
+  const removalConflicts = conflicts.filter((conflict) => conflict.code === JsTsSafeMergeConflictCodes.importSpecifierRemoved);
+  if (result.status !== JsTsSafeMergeStatuses.blocked || conflicts.length !== 1 || removalConflicts.length !== 1) return undefined;
+  const conflict = removalConflicts[0];
+  const missing = Array.isArray(conflict.details?.missing) ? conflict.details.missing : [];
+  if (conflict.side !== 'worker' || missing.length !== 1) return undefined;
+  const baseSourceText = file.baseSourceText;
+  const workerSourceText = file.workerDeleted ? undefined : file.workerSourceText ?? baseSourceText;
+  const headSourceText = file.headDeleted ? undefined : file.headSourceText ?? baseSourceText;
+  if (typeof baseSourceText !== 'string' || typeof workerSourceText !== 'string' || typeof headSourceText !== 'string') return undefined;
+  if (headSourceText !== baseSourceText) return undefined;
+  return analyzeLedgers(file, context, result, baseSourceText, workerSourceText, headSourceText, conflict, missing[0]);
+}
+
+function analyzeLedgers(file, context, result, baseSourceText, workerSourceText, headSourceText, conflict, removedSpecifier) {
+  const scanContext = createMergeContext({
+    id: `${result.id}_import_removal_usage_probe`,
+    sourcePath: context.sourcePath,
+    language: context.language
+  });
+  const baseLedger = scanJsTsTopLevelLedger(baseSourceText, 'base', scanContext);
+  const workerLedger = scanJsTsTopLevelLedger(workerSourceText, 'worker', scanContext);
+  const headLedger = scanJsTsTopLevelLedger(headSourceText, 'head', scanContext);
+  if (scanContext.conflicts.length) return undefined;
+  if (baseLedger.entries.length !== workerLedger.entries.length || baseLedger.entries.length !== headLedger.entries.length) return undefined;
+  const importKey = conflict.details?.key;
+  let removal;
+  for (let index = 0; index < baseLedger.entries.length; index += 1) {
+    const baseEntry = baseLedger.entries[index];
+    const workerEntry = workerLedger.entries[index];
+    const headEntry = headLedger.entries[index];
+    if (!headEntryMatchesBase(baseEntry, headEntry) || baseEntry.kind !== workerEntry.kind || baseEntry.key !== workerEntry.key) return undefined;
+    if (baseEntry.kind === 'import' && baseEntry.key === importKey) {
+      removal = importSpecifierRemovalUsageProof(baseEntry, workerEntry, removedSpecifier);
+      if (!removal) return undefined;
+    } else if (!sameStatementText(baseEntry.text, workerEntry.text)) return undefined;
+  }
+  if (!removal) return undefined;
+  const lexicalUseDefEvidence = analyzeImportRemovalUseDefEvidence({
+    sourcePath: file.sourcePath,
+    sourceText: workerSourceText,
+    moduleSpecifier: removal.moduleSpecifier,
+    removedSpecifier: removal.removedSpecifier,
+    importedName: removal.importedName,
+    localName: removal.localName,
+    typeOnly: removal.typeOnly
+  });
+  return { ...removal, importKey, sourcePath: file.sourcePath, outputSourceText: workerSourceText, lexicalUseDefEvidence };
+}
+
+function importSpecifierRemovalUsageProof(baseEntry, workerEntry, removedSpecifier) {
+  const baseImport = baseEntry.importInfo;
+  const workerImport = workerEntry.importInfo;
+  if (!baseImport || !workerImport || baseImport.sideEffectOnly || workerImport.sideEffectOnly) return undefined;
+  if (baseImport.moduleSpecifier !== workerImport.moduleSpecifier
+    || baseImport.typeOnly !== workerImport.typeOnly
+    || baseImport.defaultLocalName !== workerImport.defaultLocalName
+    || baseImport.namespaceLocalName !== workerImport.namespaceLocalName) {
+    return undefined;
+  }
+  const baseSpecifiers = baseImport.specifiers.map((specifier) => specifier.canonical);
+  const workerSpecifiers = workerImport.specifiers.map((specifier) => specifier.canonical);
+  const expectedWorkerSpecifiers = baseSpecifiers.filter((specifier) => specifier !== removedSpecifier);
+  if (expectedWorkerSpecifiers.length !== baseSpecifiers.length - 1) return undefined;
+  if (!arraysEqual(workerSpecifiers, expectedWorkerSpecifiers)) return undefined;
+  const removed = baseImport.specifiers.find((specifier) => specifier.canonical === removedSpecifier);
+  if (!removed) return undefined;
+  return {
+    removedSpecifier,
+    importedName: removed.importedName,
+    localName: removed.localName,
+    moduleSpecifier: baseImport.moduleSpecifier,
+    typeOnly: baseImport.typeOnly || removed.typeOnly,
+    remainingSpecifiers: workerSpecifiers
+  };
+}
+
+function blockedImportRemovalLexicalUseDefFile(file, context, result, usageProof) {
+  const reasonCodes = usageProof.lexicalUseDefEvidence.reasonCodes
+    .filter((code) => code !== LexicalUseDefReasonCodes.noLiveReferences);
+  const conflict = {
+    code: ImportRemovalLexicalUseDefConflictCode,
+    gateId: ImportRemovalLexicalUseDefGateId,
+    message: 'Project import specifier removal has live lexical references or namespace conflicts.',
+    sourcePath: file.sourcePath,
+    details: compactRecord({
+      sourcePath: file.sourcePath,
+      importKey: usageProof.importKey,
+      moduleSpecifier: usageProof.moduleSpecifier,
+      removedSpecifier: usageProof.removedSpecifier,
+      localName: usageProof.localName,
+      reasonCodes,
+      lexicalUseDefEvidence: usageProof.lexicalUseDefEvidence,
+      originalReasonCodes: result.admission?.reasonCodes
+    })
+  };
+  const conflicts = [...(result.conflicts ?? []), conflict];
+  return compactRecord({
+    kind: 'frontier.lang.jsTsProjectSafeMergeFile',
+    version: 1,
+    sourcePath: file.sourcePath,
+    language: context.language,
+    status: 'blocked',
+    operation: 'blocked-import-removal-lexical-use-def',
+    result,
+    conflicts,
+    admission: {
+      status: 'blocked',
+      action: 'human-review',
+      reviewRequired: true,
+      autoApplyCandidate: false,
+      autoMergeClaim: false,
+      semanticEquivalenceClaim: false,
+      reasonCodes: uniqueStrings([...conflicts.map((item) => item.code), ...reasonCodes])
+    },
+    summary: importRemovalUsageProofSummary(usageProof, conflicts.length),
+    conflictKeys: [`source#${file.sourcePath}`],
+    metadata: importRemovalUsageProofMetadata({}, usageProof, 'blocked-lexical-use-def')
+  });
+}
+
+function blockedImportRemovalUsageProofFile(file, context, result, usageProof) {
+  const conflict = {
+    code: ImportRemovalUsageProofConflictCode,
+    gateId: ImportRemovalUsageProofGateId,
+    message: 'Project import specifier removal requires caller-supplied TypeScript output diagnostics before automatic merge.',
+    sourcePath: file.sourcePath,
+    details: compactRecord({
+      sourcePath: file.sourcePath,
+      importKey: usageProof.importKey,
+      moduleSpecifier: usageProof.moduleSpecifier,
+      removedSpecifier: usageProof.removedSpecifier,
+      requiredEvidence: 'project-output-diagnostics',
+      originalReasonCodes: result.admission?.reasonCodes
+    })
+  };
+  const conflicts = [...(result.conflicts ?? []), conflict];
+  return compactRecord({
+    kind: 'frontier.lang.jsTsProjectSafeMergeFile',
+    version: 1,
+    sourcePath: file.sourcePath,
+    language: context.language,
+    status: 'blocked',
+    operation: 'blocked-import-removal-usage-proof',
+    result,
+    conflicts,
+    admission: {
+      status: 'blocked',
+      action: 'human-review',
+      reviewRequired: true,
+      autoApplyCandidate: false,
+      autoMergeClaim: false,
+      semanticEquivalenceClaim: false,
+      reasonCodes: uniqueStrings(conflicts.map((item) => item.code))
+    },
+    summary: importRemovalUsageProofSummary(usageProof, conflicts.length),
+    conflictKeys: [`source#${file.sourcePath}`],
+    metadata: importRemovalUsageProofMetadata({}, usageProof, 'unavailable')
+  });
+}
+
+function importRemovalUsageProofMergeResult(context, result, usageProof, input, admission) {
+  return {
+    kind: 'frontier.lang.jsTsSafeMerge',
+    version: 1,
+    schema: 'frontier.lang.jsTsSafeMerge.v1',
+    id: result.id,
+    status: JsTsSafeMergeStatuses.merged,
+    sourcePath: context.sourcePath,
+    language: context.language,
+    mergedSourceText: usageProof.outputSourceText,
+    outputSourceText: usageProof.outputSourceText,
+    conflicts: [],
+    gates: jsTsSafeMergeGateOrder.map((id) => ({ id, status: 'passed', reasonCodes: [] })),
+    admission,
+    summary: importRemovalUsageProofSummary(usageProof, 0),
+    metadata: importRemovalUsageProofMetadata(input, usageProof, 'pending-project-output-diagnostics')
+  };
+}
+
+function hasImportRemovalUsageProofInput(input) {
+  if (input.outputDiagnostics !== undefined && input.outputDiagnostics !== null) return true;
+  const diagnosticOptions = input.diagnosticOptions ?? input.typescriptDiagnosticOptions ?? {};
+  if (diagnosticOptions.semantic === false) return false;
+  const ts = input.typescript ?? input.ts ?? input.typescriptModule;
+  return Boolean(ts?.createProgram && ts?.createSourceFile);
+}
+
+function admittedImportRemovalUsageProofAdmission() {
+  return {
+    status: 'auto-merge-candidate',
+    action: 'apply',
+    reviewRequired: false,
+    autoApplyCandidate: true,
+    autoMergeClaim: false,
+    semanticEquivalenceClaim: false,
+    reasonCodes: []
+  };
+}
+
+function importRemovalUsageProofSummary(usageProof, conflicts) {
+  return {
+    importSpecifierAdditions: 0,
+    importSpecifierRemovals: 1,
+    importDeclarationAdditions: 0,
+    topLevelDeclarationAdditions: 0,
+    changedExistingDeclarations: 0,
+    conflicts,
+    gatesPassed: conflicts ? 0 : jsTsSafeMergeGateOrder.length,
+    removedImportSpecifiers: [usageProof.removedSpecifier]
+  };
+}
+
+function importRemovalUsageProofMetadata(input, usageProof, status) {
+  return {
+    importRemovalUsageProof: compactRecord({
+      status,
+      proof: 'project-output-diagnostics',
+      diagnosticSource: diagnosticProofSource(input),
+      sourcePath: usageProof.sourcePath,
+      importKey: usageProof.importKey,
+      moduleSpecifier: usageProof.moduleSpecifier,
+      removedSpecifier: usageProof.removedSpecifier,
+      localName: usageProof.localName,
+      typeOnly: usageProof.typeOnly || undefined,
+      lexicalUseDefEvidence: usageProof.lexicalUseDefEvidence,
+      autoMergeClaim: false,
+      semanticEquivalenceClaim: false
+    })
+  };
+}
+
+function diagnosticProofSource(input) {
+  if (input.outputDiagnostics !== undefined && input.outputDiagnostics !== null) return 'supplied';
+  if (input.typescript || input.ts || input.typescriptModule) return 'typescript-compiler-api';
+  return undefined;
+}
+
+function headEntryMatchesBase(baseEntry, headEntry) {
+  return baseEntry.kind === headEntry.kind && baseEntry.key === headEntry.key && sameStatementText(baseEntry.text, headEntry.text);
+}
+
+function arraysEqual(left, right) {
+  return left.length === right.length && left.every((value, index) => value === right[index]);
+}
+
+function hashText(text) { return typeof text === 'string' ? hashSemanticValue(text) : undefined; }
+
+export { ImportRemovalUsageProofOperation, maybeMergeImportSpecifierRemovalFile };