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

package/dist/js-ts-safe-project-merge-graph-delta-identity-conflicts.js

@@ -0,0 +1,202 @@
+import { hashSemanticValue } from '@shapeshift-labs/frontier-lang-kernel';
+import { compactRecord } from './js-ts-safe-merge-context.js';
+
+function projectPublicContractDeltaConflicts(baseGraph, workerGraph, headGraph, outputGraph) {
+  return changedIdentityConflicts({
+    code: 'project-public-contract-delta-conflict',
+    label: 'public contract',
+    baseRecords: baseGraph.publicContractRegions,
+    workerRecords: workerGraph.publicContractRegions,
+    headRecords: headGraph.publicContractRegions,
+    outputRecords: outputGraph?.publicContractRegions,
+    identityKey: publicContractIdentityKey,
+    fingerprint: publicContractFingerprint,
+    details: publicContractDetails
+  });
+}
+
+function projectReExportIdentityDeltaConflicts(baseGraph, workerGraph, headGraph, outputGraph) {
+  return changedIdentityConflicts({
+    code: 'project-re-export-identity-delta-conflict',
+    label: 're-export identity',
+    baseRecords: baseGraph.reExportIdentities,
+    workerRecords: workerGraph.reExportIdentities,
+    headRecords: headGraph.reExportIdentities,
+    outputRecords: outputGraph?.reExportIdentities,
+    identityKey: reExportIdentityKey,
+    fingerprint: reExportIdentityFingerprint,
+    details: reExportIdentityDetails
+  });
+}
+
+function projectImportAttributeDeltaConflicts(baseGraph, workerGraph, headGraph, outputGraph) {
+  return changedIdentityConflicts({
+    code: 'project-import-attribute-delta-conflict',
+    label: 'import attributes',
+    baseRecords: attributedEdges(baseGraph),
+    workerRecords: attributedEdges(workerGraph),
+    headRecords: attributedEdges(headGraph),
+    outputRecords: attributedEdges(outputGraph),
+    identityKey: importAttributeIdentityKey,
+    fingerprint: importAttributeFingerprint,
+    details: importAttributeDetails
+  });
+}
+
+function changedIdentityConflicts(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 baseRecord = base.get(identityKey);
+    const workerRecord = worker.get(identityKey);
+    const headRecord = head.get(identityKey);
+    const baseFingerprint = optionalFingerprint(baseRecord, input.fingerprint);
+    const workerFingerprint = optionalFingerprint(workerRecord, input.fingerprint);
+    const headFingerprint = optionalFingerprint(headRecord, input.fingerprint);
+    if (baseFingerprint === workerFingerprint || baseFingerprint === headFingerprint || workerFingerprint === headFingerprint) return [];
+    return [projectGraphDeltaConflict({
+      code: input.code,
+      label: input.label,
+      identityKey,
+      baseRecord,
+      workerRecord,
+      headRecord,
+      outputRecord: output.get(identityKey),
+      details: input.details
+    })];
+  });
+}
+
+function projectGraphDeltaConflict(input) {
+  const sourcePath = input.workerRecord?.sourcePath ?? input.headRecord?.sourcePath ?? input.baseRecord?.sourcePath;
+  const conflictKey = `project-graph-delta#${input.label.replace(/\s+/g, '-')}#${input.identityKey}`;
+  return {
+    code: input.code,
+    gateId: 'project-graph-delta',
+    message: `Worker and head both changed ${input.label} ${JSON.stringify(input.identityKey)} in incompatible ways.`,
+    sourcePath,
+    details: compactRecord({
+      reasonCode: input.code,
+      conflictKey,
+      identityKey: input.identityKey,
+      sourcePath,
+      base: input.details(input.baseRecord),
+      worker: input.details(input.workerRecord),
+      head: input.details(input.headRecord),
+      output: input.details(input.outputRecord)
+    })
+  };
+}
+
+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 publicContractIdentityKey(record) {
+  return firstString(
+    record?.key,
+    stableKey(['public-contract', record?.sourcePath, record?.apiSurfaceKind, record?.edgeKind, record?.moduleSpecifier, record?.exportedName ?? record?.symbolName ?? record?.symbolId])
+  );
+}
+
+function publicContractFingerprint(record) {
+  return hashSemanticValue({
+    kind: 'frontier.lang.projectGraphDelta.publicContractFingerprint',
+    signatureHash: record.signatureHash,
+    symbolName: record.symbolName,
+    symbolKind: record.symbolKind,
+    apiSurfaceKind: record.apiSurfaceKind,
+    exportedName: record.exportedName,
+    moduleSpecifier: record.moduleSpecifier,
+    edgeKind: record.edgeKind
+  });
+}
+
+function publicContractDetails(record) {
+  if (!record) return undefined;
+  return compactRecord({
+    sourcePath: record.sourcePath,
+    key: publicContractIdentityKey(record),
+    symbolName: record.symbolName,
+    symbolKind: record.symbolKind,
+    apiSurfaceKind: record.apiSurfaceKind,
+    exportedName: record.exportedName,
+    moduleSpecifier: record.moduleSpecifier,
+    edgeKind: record.edgeKind,
+    signatureHash: record.signatureHash,
+    contractHash: record.contractHash,
+    sourceHash: record.sourceHash
+  });
+}
+
+function reExportIdentityKey(record) {
+  return stableKey(['re-export-identity', record?.sourcePath, record?.exportedName ?? record?.localName ?? record?.namespace ?? (record?.exportStar || record?.isExportStar ? '*' : undefined)]);
+}
+
+function reExportIdentityFingerprint(record) {
+  return hashSemanticValue({
+    kind: 'frontier.lang.projectGraphDelta.reExportIdentityFingerprint',
+    sourcePath: record.sourcePath,
+    moduleSpecifier: record.moduleSpecifier,
+    hasImportAttributes: record.hasImportAttributes,
+    importAttributeCount: record.importAttributeCount,
+    importAttributeKeys: record.importAttributeKeys, importAttributeHash: record.importAttributeHash, importAttributes: record.importAttributes,
+    exportedName: record.exportedName,
+    importedName: record.importedName,
+    localName: record.localName,
+    namespace: record.namespace,
+    isTypeOnly: record.isTypeOnly,
+    exportStar: record.exportStar,
+    isExportStar: record.isExportStar,
+    originSymbolId: record.originSymbolId,
+    exportedSymbolId: record.exportedSymbolId,
+    localSymbolId: record.localSymbolId
+  });
+}
+
+function reExportIdentityDetails(record) {
+  if (!record) return undefined;
+  return compactRecord({
+    sourcePath: record.sourcePath,
+    key: reExportIdentityKey(record),
+    moduleSpecifier: record.moduleSpecifier,
+    hasImportAttributes: record.hasImportAttributes,
+    importAttributeCount: record.importAttributeCount,
+    importAttributeKeys: record.importAttributeKeys, importAttributeHash: record.importAttributeHash, importAttributes: record.importAttributes,
+    exportedName: record.exportedName,
+    importedName: record.importedName,
+    localName: record.localName,
+    namespace: record.namespace,
+    isTypeOnly: record.isTypeOnly,
+    exportStar: record.exportStar,
+    isExportStar: record.isExportStar,
+    originSymbolId: record.originSymbolId,
+    exportedSymbolId: record.exportedSymbolId,
+    localSymbolId: record.localSymbolId,
+    sourceHash: record.sourceHash
+  });
+}
+
+function attributedEdges(graph) { return [...(graph?.importEdges ?? []), ...(graph?.exportEdges ?? [])].filter((edge) => edge?.hasImportAttributes || edge?.importAttributeHash); }
+function importAttributeIdentityKey(edge) { return stableKey(['import-attribute', edge?.predicate, edge?.edgeKind, edge?.sourcePath, edge?.moduleSpecifier, edge?.isTypeOnly]); }
+function importAttributeFingerprint(edge) { return hashSemanticValue({ kind: 'frontier.lang.projectGraphDelta.importAttributeFingerprint', hasImportAttributes: edge.hasImportAttributes, importAttributeCount: edge.importAttributeCount, importAttributeKeys: edge.importAttributeKeys, importAttributeHash: edge.importAttributeHash, importAttributes: edge.importAttributes }); }
+function importAttributeDetails(edge) { if (!edge) return undefined; return compactRecord({ sourcePath: edge.sourcePath, key: importAttributeIdentityKey(edge), predicate: edge.predicate, moduleSpecifier: edge.moduleSpecifier, importedName: edge.importedName, exportedName: edge.exportedName, localName: edge.localName, importKind: edge.importKind, exportKind: edge.exportKind, isTypeOnly: edge.isTypeOnly, hasImportAttributes: edge.hasImportAttributes, importAttributeCount: edge.importAttributeCount, importAttributeKeys: edge.importAttributeKeys, importAttributeHash: edge.importAttributeHash, importAttributes: edge.importAttributes }); }
+function optionalFingerprint(record, fingerprint) { return record ? fingerprint(record) : undefined; }
+function stableKey(parts) { const values = parts.map((part) => part === undefined || part === null ? '' : String(part)); return values.some(Boolean) ? values.join('#') : undefined; }
+function firstString(...values) { for (const value of values) if (value !== undefined && value !== null && String(value)) return String(value); return undefined; }
+function uniqueStrings(values) { return [...new Set(values.filter((value) => typeof value === 'string' && value.length > 0))]; }
+
+export {
+  projectImportAttributeDeltaConflicts,
+  projectPublicContractDeltaConflicts,
+  projectReExportIdentityDeltaConflicts
+};

package/dist/js-ts-safe-project-merge-graph-delta-inference-syntax.js

@@ -0,0 +1,80 @@
+import { compactRecord } from './js-ts-safe-merge-context.js';
+
+function missingSharedCompilerTypeInferenceSyntaxEvidence(workerRecord, headRecord) {
+  const missing = [workerRecord, headRecord].filter((record) => (
+    requiresCompilerTypeInferenceSyntaxProof(record) && !hasPassedCompilerTypeInferenceSyntaxProof(record)
+  ));
+  if (!missing.length) return undefined;
+  return {
+    reasonCode: 'typescript-public-api-type-inference-syntax-proof-missing',
+    requiredEvidence: 'typescript-checker-public-api-type-inference-syntax-evidence',
+    semanticEquivalenceClaim: false,
+    missingRecords: missing.map(typeInferenceSyntaxMissingProofRecord)
+  };
+}
+
+function typeInferenceSyntaxMissingProofRecord(record) {
+  const proof = record?.typeInferenceSyntaxProof;
+  return compactRecord({
+    sourcePath: record.sourcePath,
+    sourceHash: record.sourceHash,
+    symbolId: record.symbolId,
+    symbolName: record.symbolName,
+    fullyQualifiedName: record.fullyQualifiedName,
+    typeInferenceSyntaxHash: record.typeInferenceSyntaxHash,
+    typeInferenceSyntaxProofStatus: proof?.status,
+    proofTypeInferenceSyntaxHash: proof?.typeInferenceSyntaxHash,
+    typeInferenceSyntaxProofSourcePath: proof?.sourcePath,
+    typeInferenceSyntaxProofSourceHash: proof?.sourceHash,
+    missingSignals: proof?.missingSignals,
+    reasonCodes: typeInferenceSyntaxProofReasonCodes(record, proof),
+    semanticEquivalenceClaim: proof?.semanticEquivalenceClaim ?? false,
+    evidenceIds: record.evidenceIds
+  });
+}
+
+function requiresCompilerTypeInferenceSyntaxProof(record) {
+  return Boolean(record && (
+    record.typeInferenceSyntaxCount > 0
+      || record.satisfiesExpressionCount > 0
+      || record.asConstAssertionCount > 0
+      || record.constTypeParameterCount > 0
+      || record.typeInferenceSyntaxHash
+      || record.typeInferenceSyntaxProof
+  ));
+}
+
+function hasPassedCompilerTypeInferenceSyntaxProof(record) {
+  const proof = record?.typeInferenceSyntaxProof;
+  return Boolean(
+    record?.typeInferenceSyntaxHash
+      && proof?.status === 'passed'
+      && proof?.typeInferenceSyntaxHash === record.typeInferenceSyntaxHash
+      && record?.sourcePath
+      && record?.sourceHash
+      && proof?.sourcePath === record.sourcePath
+      && proof?.sourceHash === record.sourceHash
+      && !arrayValue(proof?.missingSignals).length
+      && !arrayValue(proof?.reasonCodes).length
+      && proof.autoMergeClaim === false
+      && proof.semanticEquivalenceClaim === false
+  );
+}
+
+function typeInferenceSyntaxProofReasonCodes(record, proof) {
+  const reasonCodes = ['typescript-public-api-type-inference-syntax-proof-missing'];
+  if (!proof) return reasonCodes;
+  if (proof.status !== 'passed') reasonCodes.push('typescript-type-inference-syntax-proof-status-not-passed');
+  if (proof.typeInferenceSyntaxHash !== record?.typeInferenceSyntaxHash) reasonCodes.push('typescript-type-inference-syntax-proof-hash-mismatch');
+  if (!record?.sourcePath) reasonCodes.push('typescript-type-inference-syntax-record-source-path-missing');
+  if (!record?.sourceHash) reasonCodes.push('typescript-type-inference-syntax-record-source-hash-missing');
+  if (proof.sourcePath !== record?.sourcePath) reasonCodes.push('typescript-type-inference-syntax-proof-source-path-mismatch');
+  if (proof.sourceHash !== record?.sourceHash) reasonCodes.push('typescript-type-inference-syntax-proof-source-hash-mismatch');
+  if (proof.autoMergeClaim !== false || proof.semanticEquivalenceClaim !== false) reasonCodes.push('typescript-type-inference-syntax-proof-claim-flags-missing');
+  return uniqueStrings([...reasonCodes, ...arrayValue(proof.reasonCodes), ...arrayValue(proof.missingSignals).map((signal) => `typescript-${signal}-missing`)]);
+}
+
+function arrayValue(value) { return Array.isArray(value) ? value : []; }
+function uniqueStrings(values) { return [...new Set(values.filter((value) => typeof value === 'string' && value.length > 0))]; }
+
+export { missingSharedCompilerTypeInferenceSyntaxEvidence };

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,