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

package/dist/internal/index-impl/projectSymbolGraphCompilerIndexSignatureEquivalence.js

@@ -0,0 +1,58 @@
+import { hashSemanticValue } from '@shapeshift-labs/frontier-lang-kernel';
+
+const IndexSignatureTypeEquivalenceProofKind = 'typescript-checker-public-api-index-signature-equivalence';
+
+function indexSignatureSetHash(value, counts) {
+  return counts.indexSignatureCount > 0 ? hashSemanticValue({ kind: 'frontier.lang.typescript.compilerPublicIndexSignatureSetEquivalence.v1', indexSignatures: arrayValue(value.indexSignatures) }) : undefined;
+}
+
+function indexSignatureProofKind(counts) { return counts.indexSignatureCount > 0 ? IndexSignatureTypeEquivalenceProofKind : undefined; }
+function indexSignatureUnsupportedReasonCodes(counts) { return counts.indexSignatureCount > 0 ? ['typescript-public-index-signature-equivalence-unproven'] : []; }
+function indexSignatureProofLevel(counts) { return counts.indexSignatureCount > 0 ? 'index-signature-set' : undefined; }
+function indexSignatureCheckerInvariant(counts) { return counts.indexSignatureCount > 0 ? 'index signature key/value/modifiers complete' : undefined; }
+function indexSignatureRequiredSignals(counts) {
+  return counts.indexSignatureCount > 0 ? [
+    'compiler-index-signature-count',
+    'compiler-index-signature-key-type-texts',
+    'compiler-index-signature-value-type-texts',
+    'compiler-index-signature-readonly'
+  ] : [];
+}
+
+function missingIndexSignatureEquivalenceSignals(_value, counts, checkerEvidence) {
+  const missing = [];
+  if (counts.indexSignatureCount > 0 && checkerEvidence.indexSignatureKeyTypeTexts.length !== counts.indexSignatureCount) missing.push('compiler-index-signature-count');
+  if (counts.indexSignatureCount > 0 && (checkerEvidence.indexSignatureKeyTypeTexts.length !== counts.indexSignatureCount || checkerEvidence.indexSignatureKeyTypeTexts.some((text) => !text))) missing.push('compiler-index-signature-key-type-texts');
+  if (counts.indexSignatureCount > 0 && (checkerEvidence.indexSignatureValueTypeTexts.length !== counts.indexSignatureCount || checkerEvidence.indexSignatureValueTypeTexts.some((text) => !text))) missing.push('compiler-index-signature-value-type-texts');
+  if (counts.indexSignatureCount > 0 && !compilerBooleanSignalsCovered(checkerEvidence.indexSignatureReadonly, counts.indexSignatureCount)) missing.push('compiler-index-signature-readonly');
+  return missing;
+}
+
+function indexSignatureCheckerEvidence(value, counts) {
+  const indexSignatures = arrayValue(value.indexSignatures);
+  return compactRecord({
+    indexSignatureCount: counts.indexSignatureCount || undefined,
+    indexSignatureReadonlyCount: counts.indexSignatureReadonlyCount || undefined,
+    indexSignatureKeyTypeTexts: indexSignatures.map((signature) => signature.keyTypeText),
+    indexSignatureValueTypeTexts: indexSignatures.map((signature) => signature.valueTypeText),
+    indexSignatureReadonly: indexSignatures.map((signature) => signature.readonly),
+    indexSignatureDeclarationTexts: indexSignatures.map((signature) => signature.declarationText),
+    indexSignatures: nonEmptyArray(indexSignatures)
+  });
+}
+
+function compilerBooleanSignalsCovered(values, count) { return Array.isArray(values) && values.length === count && values.every((value) => typeof value === 'boolean'); }
+function arrayValue(value) { return Array.isArray(value) ? value : []; }
+function nonEmptyArray(value) { return Array.isArray(value) && value.length ? value : undefined; }
+function compactRecord(record) { return Object.fromEntries(Object.entries(record).filter(([, value]) => value !== undefined)); }
+
+export {
+  indexSignatureCheckerEvidence,
+  indexSignatureCheckerInvariant,
+  indexSignatureProofKind,
+  indexSignatureProofLevel,
+  indexSignatureRequiredSignals,
+  indexSignatureSetHash,
+  indexSignatureUnsupportedReasonCodes,
+  missingIndexSignatureEquivalenceSignals
+};

package/dist/internal/index-impl/projectSymbolGraphCompilerMetadata.js

@@ -0,0 +1,168 @@
+function compilerClassMemberShapeMetadata(value, source = {}) {
+  const privateClassMembers = arrayValue(value.privateClassMembers);
+  const accessorFieldMembers = arrayValue(value.accessorFieldMembers);
+  const counts = {
+    privateClassMemberCount: numberValue(value.privateClassMemberCount) ?? privateClassMembers.length,
+    accessorFieldCount: numberValue(value.accessorFieldCount) ?? accessorFieldMembers.length
+  };
+  const runtimeProof = classPrivateAccessorRuntimeProjection(value, counts, source);
+  return {
+    counts,
+    record: compactRecord({
+      privateClassMemberCount: counts.privateClassMemberCount || undefined,
+      privateClassMemberShapeHash: value.privateClassMemberShapeHash,
+      privateClassMembers: nonEmptyArray(privateClassMembers),
+      accessorFieldCount: counts.accessorFieldCount || undefined,
+      accessorFieldShapeHash: value.accessorFieldShapeHash,
+      accessorFieldMembers: nonEmptyArray(accessorFieldMembers),
+      classMemberShapeProof: value.classMemberShapeProof,
+      ...runtimeProof.record
+    })
+  };
+}
+
+function compilerAssignabilityOracleMetadata(value) {
+  const record = objectRecord(value.assignabilityOracle);
+  const directions = arrayValue(record?.directions);
+  const counts = {
+    assignabilityOracleCount: record ? 1 : 0,
+    assignabilityOracleDirectionCount: numberValue(value.assignabilityOracleDirectionCount) ?? directions.length
+  };
+  return {
+    counts,
+    record: compactRecord({
+      assignabilityOracleCount: counts.assignabilityOracleCount || undefined,
+      assignabilityOracleDirectionCount: counts.assignabilityOracleDirectionCount || undefined,
+      assignabilityOracleHash: value.assignabilityOracleHash,
+      assignabilityOracle: record
+    })
+  };
+}
+
+function compilerDecoratorMetadata(value, source = {}) {
+  const records = arrayValue(value.decoratorMetadata);
+  const counts = {
+    decoratorMetadataCount: numberValue(value.decoratorMetadataCount) ?? records.length,
+    classDecoratorCount: numberValue(value.classDecoratorCount) ?? countKind(records, 'class-decorator'),
+    memberDecoratorCount: numberValue(value.memberDecoratorCount) ?? countKind(records, 'member-decorator'),
+    parameterDecoratorCount: numberValue(value.parameterDecoratorCount) ?? countKind(records, 'parameter-decorator')
+  };
+  const runtimeExecution = decoratorRuntimeExecutionProjection(value, counts, source);
+  return {
+    counts,
+    record: compactRecord({
+      decoratorMetadataCount: counts.decoratorMetadataCount || undefined,
+      classDecoratorCount: counts.classDecoratorCount || undefined,
+      memberDecoratorCount: counts.memberDecoratorCount || undefined,
+      parameterDecoratorCount: counts.parameterDecoratorCount || undefined,
+      decoratorMetadataHash: value.decoratorMetadataHash,
+      decoratorMetadataProof: value.decoratorMetadataProof,
+      ...runtimeExecution.record,
+      decoratorMetadata: nonEmptyArray(records)
+    })
+  };
+}
+
+function compilerEnumShapeMetadata(value) {
+  const enumMembers = arrayValue(value.enumMembers);
+  const counts = {
+    enumMemberCount: numberValue(value.enumMemberCount) ?? enumMembers.length,
+    enumNumericMemberCount: numberValue(value.enumNumericMemberCount) ?? countKind(enumMembers, 'number', 'valueKind'),
+    enumStringMemberCount: numberValue(value.enumStringMemberCount) ?? countKind(enumMembers, 'string', 'valueKind'),
+    enumAutoMemberCount: numberValue(value.enumAutoMemberCount) ?? enumMembers.filter((member) => member?.auto === true).length,
+    enumComputedMemberCount: numberValue(value.enumComputedMemberCount) ?? enumMembers.filter((member) => member?.computed === true).length
+  };
+  return {
+    counts,
+    record: compactRecord({
+      enumKind: value.enumKind,
+      constEnum: value.constEnum,
+      declareEnum: value.declareEnum,
+      enumDeclarationCount: value.enumDeclarationCount,
+      enumMemberCount: counts.enumMemberCount || undefined,
+      enumNumericMemberCount: counts.enumNumericMemberCount || undefined,
+      enumStringMemberCount: counts.enumStringMemberCount || undefined,
+      enumAutoMemberCount: counts.enumAutoMemberCount || undefined,
+      enumComputedMemberCount: counts.enumComputedMemberCount || undefined,
+      enumRuntimeShapeHash: value.enumRuntimeShapeHash,
+      enumEmittedRuntimeShapeHash: value.enumEmittedRuntimeShapeHash,
+      enumRuntimeShapeProof: value.enumRuntimeShapeProof,
+      computedEnumRuntimeValueProof: value.computedEnumRuntimeValueProof,
+      enumMembers: nonEmptyArray(enumMembers)
+    })
+  };
+}
+
+function compilerTypeInferenceSyntaxMetadata(value, source = {}) {
+  const records = arrayValue(value.typeInferenceSyntax);
+  const counts = {
+    typeInferenceSyntaxCount: numberValue(value.typeInferenceSyntaxCount) ?? records.length,
+    satisfiesExpressionCount: numberValue(value.satisfiesExpressionCount) ?? countKind(records, 'satisfies-expression'),
+    asConstAssertionCount: numberValue(value.asConstAssertionCount) ?? countKind(records, 'as-const-assertion'),
+    constTypeParameterCount: numberValue(value.constTypeParameterCount) ?? countKind(records, 'const-type-parameter')
+  };
+  const proof = compilerTypeInferenceSyntaxProof(value, counts, source);
+  return {
+    counts,
+    record: compactRecord({
+      typeInferenceSyntaxCount: counts.typeInferenceSyntaxCount || undefined,
+      typeInferenceSyntaxKinds: value.typeInferenceSyntaxKinds ?? nonEmptyArray(uniqueStrings(records.map((record) => record.kind))),
+      satisfiesExpressionCount: counts.satisfiesExpressionCount || undefined,
+      asConstAssertionCount: counts.asConstAssertionCount || undefined,
+      constTypeParameterCount: counts.constTypeParameterCount || undefined,
+      typeInferenceSyntaxHash: value.typeInferenceSyntaxHash,
+      typeInferenceSyntaxProof: proof,
+      typeInferenceSyntax: nonEmptyArray(records)
+    })
+  };
+}
+
+function compilerTypeInferenceSyntaxProof(value, counts, source = {}) {
+  const proof = objectRecord(value.typeInferenceSyntaxProof);
+  if (!proof || counts.typeInferenceSyntaxCount <= 0) return proof;
+  const reasonCodes = [];
+  const missingSignals = [];
+  if (proof.status !== 'passed') reasonCodes.push('typescript-type-inference-syntax-proof-status-not-passed');
+  if (proof.kind !== 'typescript-checker-public-api-type-inference-syntax-evidence') reasonCodes.push('typescript-type-inference-syntax-proof-kind-missing');
+  if (proof.typeInferenceSyntaxHash !== value.typeInferenceSyntaxHash) reasonCodes.push('typescript-type-inference-syntax-proof-hash-mismatch');
+  if (proof.autoMergeClaim !== false || proof.semanticEquivalenceClaim !== false) reasonCodes.push('typescript-type-inference-syntax-proof-claim-flags-missing');
+  if (source.publicContract === true && !source.sourcePath) missingSignals.push('compiler-public-api-source-path');
+  if (source.publicContract === true && !source.sourceHash) missingSignals.push('compiler-public-api-source-hash');
+  if (proof.sourcePath !== undefined && proof.sourcePath !== source.sourcePath) reasonCodes.push('typescript-type-inference-syntax-proof-source-path-mismatch');
+  if (proof.sourceHash !== undefined && proof.sourceHash !== source.sourceHash) reasonCodes.push('typescript-type-inference-syntax-proof-source-hash-mismatch');
+  const failed = reasonCodes.length > 0 || missingSignals.length > 0;
+  return compactRecord({
+    ...proof,
+    status: failed ? 'failed' : proof.status,
+    sourcePath: proof.sourcePath ?? source.sourcePath,
+    sourceHash: proof.sourceHash ?? source.sourceHash,
+    sourceBoundPublicApi: source.publicContract === true || undefined,
+    requiredSignals: uniqueStrings([
+      ...arrayValue(proof.requiredSignals),
+      source.publicContract === true ? 'compiler-public-api-source-path' : undefined,
+      source.publicContract === true ? 'compiler-public-api-source-hash' : undefined
+    ]),
+    missingSignals: nonEmptyArray(uniqueStrings([...(proof.missingSignals ?? []), ...missingSignals])),
+    reasonCodes: nonEmptyArray(uniqueStrings([...(proof.reasonCodes ?? []), ...reasonCodes])),
+    autoMergeClaim: false,
+    semanticEquivalenceClaim: false
+  });
+}
+
+function countKind(records, kind, field = 'kind') { return records.filter((record) => record?.[field] === kind).length; }
+function objectRecord(value) { return value && typeof value === 'object' && !Array.isArray(value) ? value : undefined; }
+function arrayValue(value) { return Array.isArray(value) ? value : []; }
+function compactRecord(record) { return Object.fromEntries(Object.entries(record).filter(([, value]) => value !== undefined)); }
+function numberValue(value) { return Number.isFinite(value) ? value : undefined; }
+function nonEmptyArray(value) { return Array.isArray(value) && value.length ? value : undefined; }
+function uniqueStrings(values) { return [...new Set(values.filter((value) => typeof value === 'string' && value.length > 0))]; }
+
+export {
+  compilerAssignabilityOracleMetadata,
+  compilerClassMemberShapeMetadata,
+  compilerDecoratorMetadata,
+  compilerEnumShapeMetadata,
+  compilerTypeInferenceSyntaxMetadata
+};
+import { decoratorRuntimeExecutionProjection } from './projectSymbolGraphCompilerDecoratorRuntimeProof.js';
+import { classPrivateAccessorRuntimeProjection } from './projectSymbolGraphCompilerClassPrivateAccessorRuntimeProof.js';

package/dist/internal/index-impl/projectSymbolGraphCompilerTypeEquivalence.js

@@ -0,0 +1,199 @@
+import { hashSemanticValue } from '@shapeshift-labs/frontier-lang-kernel';
+import * as advancedTypes from './projectSymbolGraphCompilerConditionalTypeEquivalence.js';
+import * as cls from './projectSymbolGraphCompilerClassShapeEquivalence.js';
+import * as enumTypes from './projectSymbolGraphCompilerEnumEquivalence.js';
+import * as indexSigs from './projectSymbolGraphCompilerIndexSignatureEquivalence.js';
+import * as typeRefs from './projectSymbolGraphCompilerTypeReferenceTargetEquivalence.js';
+import {
+  missingTypeEquivalenceSignals,
+  requiresTypeEquivalenceProof,
+  typeEquivalenceCheckerInvariant,
+  typeEquivalenceProofKind,
+  typeEquivalenceProofLevel,
+  typeEquivalenceRequiredSignals,
+  unsupportedTypeEquivalenceReasonCodes,
+  unsupportedTypeEquivalenceSignals
+} from './projectSymbolGraphCompilerTypeEquivalenceProof.js';
+
+function compilerTypeEquivalenceRecord(value, compilerSymbol, counts, source = {}) {
+  if (!requiresTypeEquivalenceProof(counts)) return { reasonCodes: [] };
+  const evidence = typeEquivalenceCheckerEvidence(value, compilerSymbol, counts);
+  const missingSignals = missingTypeEquivalenceSignals(value, compilerSymbol, evidence, counts, source);
+  const enumComputedValueProof = enumTypes.computedEnumRuntimeValueProofBinding(value, counts, source);
+  const unsupportedSignals = unsupportedTypeEquivalenceSignals(counts, value, source);
+  const reasonCodes = unsupportedTypeEquivalenceReasonCodes(counts, missingSignals, value, source);
+  const canProve = !missingSignals.length && !unsupportedSignals.length;
+  const signatureSetHash = canProve ? hashSemanticValue({ kind: 'frontier.lang.typescript.compilerSignatureSetEquivalence.v1', callSignatures: canonicalSignatureRecords(value.callSignatures), constructSignatures: canonicalSignatureRecords(value.constructSignatures), properties: canonicalPropertyRecords(value.properties) }) : undefined;
+  const typeParameterSetHash = canProve && counts.typeParameterCount > 0 ? hashSemanticValue({ kind: 'frontier.lang.typescript.compilerGenericParameterSetEquivalence.v1', typeParameters: value.typeParameters }) : undefined;
+  const propertySetHash = canProve && counts.propertyCount > 0 ? hashSemanticValue({ kind: 'frontier.lang.typescript.compilerPublicMemberPropertySetEquivalence.v1', properties: canonicalPropertyRecords(value.properties) }) : undefined;
+  const indexSignatureSetHash = canProve ? indexSigs.indexSignatureSetHash(value, counts) : undefined;
+  const constructorSetHash = canProve && counts.constructorSignatureCount > 0 ? hashSemanticValue({ kind: 'frontier.lang.typescript.compilerConstructorSetEquivalence.v1', constructorSignatures: value.constructorSignatures }) : undefined;
+  const classHeritageHash = canProve && counts.classHeritageCount > 0 ? hashSemanticValue({ kind: 'frontier.lang.typescript.compilerClassHeritageEquivalence.v1', classHeritage: value.classHeritage }) : undefined;
+  const classHashes = canProve ? cls.classShapeSetHashes(value, counts) : {};
+  const enumRuntimeShapeHash = canProve ? enumTypes.enumRuntimeShapeHash(value, counts) : undefined;
+  const advancedTypeHashes = canProve ? advancedTypes.advancedTypeSetHashes(value, counts) : {};
+  const typeReferenceTargetSetHash = canProve ? typeRefs.typeReferenceTargetSetHash(value, counts) : undefined;
+  const assignabilityOracleHash = canProve && counts.assignabilityOracleCount > 0 ? value.assignabilityOracleHash : undefined;
+  const proof = compactRecord({
+    kind: typeEquivalenceProofKind(counts),
+    status: canProve ? 'passed' : 'failed',
+    proofLevel: typeEquivalenceProofLevel(counts),
+    checkerInvariant: typeEquivalenceCheckerInvariant(counts, source),
+    requiredSignals: typeEquivalenceRequiredSignals(counts, source),
+    missingSignals: nonEmptyArray(missingSignals),
+    unsupportedSignals: nonEmptyArray(unsupportedSignals),
+    reasonCodes: nonEmptyArray(reasonCodes),
+    signatureSetHash,
+    typeParameterSetHash,
+    propertySetHash,
+    indexSignatureSetHash,
+    constructorSetHash,
+    classHeritageHash,
+    ...classHashes,
+    enumRuntimeShapeHash,
+    enumEmittedRuntimeShapeHash: value.enumEmittedRuntimeShapeHash,
+    computedEnumRuntimeValueHash: enumComputedValueProof.computedEnumRuntimeValueHash,
+    computedEnumRuntimeValueProof: enumComputedValueProof.proof,
+    ...advancedTypeHashes,
+    typeReferenceTargetSetHash,
+    assignabilityOracleHash,
+    assignabilityOracleScope: counts.assignabilityOracleCount > 0 ? 'declared-apparent-type-only' : undefined,
+    apiSignatureHash: value.apiSignatureHash,
+    compilerSymbolIdentityHash: compilerSymbol?.identityHash,
+    typeIdentityHash: value.identityHash,
+    sourcePath: source.sourcePath,
+    sourceHash: source.sourceHash,
+    callSignatureCount: counts.callSignatureCount || undefined,
+    constructSignatureCount: counts.constructSignatureCount || undefined,
+    overloadSignatureCount: counts.overloadSignatureCount || undefined,
+    declarationCount: counts.declarationCount,
+    typeParameterCount: counts.typeParameterCount || undefined,
+    typeParameterDefaultCount: counts.typeParameterDefaultCount || undefined,
+    typeParameterConstraintCount: counts.typeParameterConstraintCount || undefined,
+    propertyCount: counts.propertyCount || undefined,
+    propertyOptionalCount: counts.propertyOptionalCount || undefined,
+    propertyReadonlyCount: counts.propertyReadonlyCount || undefined,
+    indexSignatureCount: counts.indexSignatureCount || undefined,
+    indexSignatureReadonlyCount: counts.indexSignatureReadonlyCount || undefined,
+    constructorSignatureCount: counts.constructorSignatureCount || undefined,
+    classHeritageCount: counts.classHeritageCount || undefined,
+    privateClassMemberCount: counts.privateClassMemberCount || undefined,
+    accessorFieldCount: counts.accessorFieldCount || undefined,
+    enumMemberCount: counts.enumMemberCount || undefined,
+    enumComputedMemberCount: counts.enumComputedMemberCount || undefined,
+    advancedTypeShapeCount: counts.advancedTypeShapeCount || undefined,
+    typeReferenceTargetCount: counts.typeReferenceTargetCount || undefined,
+    conditionalTypeCount: counts.conditionalTypeCount || undefined,
+    mappedTypeCount: counts.mappedTypeCount || undefined,
+    indexedAccessTypeCount: counts.indexedAccessTypeCount || undefined,
+    keyofTypeOperatorCount: counts.keyofTypeOperatorCount || undefined,
+    templateLiteralTypeCount: counts.templateLiteralTypeCount || undefined,
+    inferTypeCount: counts.inferTypeCount || undefined,
+    assignabilityOracleCount: counts.assignabilityOracleCount || undefined,
+    assignabilityOracleDirectionCount: counts.assignabilityOracleDirectionCount || undefined,
+    evidenceIds: uniqueStrings([...(counts.evidenceIds ?? []), ...enumComputedValueProof.evidenceIds]),
+    autoMergeClaim: false,
+    semanticEquivalenceClaim: false
+  });
+  return {
+    status: canProve ? 'compiler-backed-equivalent' : 'unsupported',
+    reasonCodes: canProve ? [] : reasonCodes,
+    signatureSetHash,
+    typeParameterSetHash,
+    propertySetHash,
+    indexSignatureSetHash,
+    constructorSetHash,
+    classHeritageHash,
+    ...classHashes,
+    enumRuntimeShapeHash,
+    enumEmittedRuntimeShapeHash: value.enumEmittedRuntimeShapeHash,
+    ...advancedTypeHashes,
+    typeReferenceTargetSetHash,
+    assignabilityOracleHash,
+    proof,
+    checkerEvidence: evidence
+  };
+}
+
+function typeEquivalenceCheckerEvidence(value, compilerSymbol, counts) {
+  const signatures = [...arrayValue(value.callSignatures), ...arrayValue(value.constructSignatures)];
+  const typeParameters = arrayValue(value.typeParameters);
+  const properties = arrayValue(value.properties);
+  const constructorSignatures = arrayValue(value.constructorSignatures);
+  const classHeritage = arrayValue(value.classHeritage);
+  const advancedShapes = arrayValue(value.advancedTypeShapes);
+  const typeReferenceTargets = arrayValue(value.typeReferenceTargets);
+  const assignabilityOracle = objectValue(value.assignabilityOracle);
+  const assignabilityDirections = arrayValue(assignabilityOracle.directions);
+  return compactRecord({
+    parser: value.parser,
+    compilerSymbolIdentityHash: compilerSymbol?.identityHash,
+    typeIdentityHash: value.identityHash,
+    apiSignatureHash: value.apiSignatureHash,
+    declarationCount: counts.declarationCount,
+    callSignatureCount: counts.callSignatureCount || undefined,
+    constructSignatureCount: counts.constructSignatureCount || undefined,
+    overloadSignatureCount: counts.overloadSignatureCount || undefined,
+    typeParameterCount: counts.typeParameterCount || undefined,
+    typeParameterDefaultCount: counts.typeParameterDefaultCount || undefined,
+    typeParameterConstraintCount: counts.typeParameterConstraintCount || undefined,
+    propertyCount: counts.propertyCount || undefined,
+    propertyOptionalCount: counts.propertyOptionalCount || undefined,
+    propertyReadonlyCount: counts.propertyReadonlyCount || undefined,
+    ...indexSigs.indexSignatureCheckerEvidence(value, counts),
+    constructorSignatureCount: counts.constructorSignatureCount || undefined,
+    classHeritageCount: counts.classHeritageCount || undefined,
+    ...cls.classShapeCheckerEvidence(value, counts),
+    ...enumTypes.enumCheckerEvidence(value, counts),
+    advancedTypeShapeCount: counts.advancedTypeShapeCount || undefined,
+    advancedTypeShapeKinds: nonEmptyArray(uniqueStrings(advancedShapes.map((shape) => shape.kind))),
+    advancedTypeShapeNodeTexts: advancedShapes.map((shape) => shape.nodeText).filter(Boolean),
+    advancedTypeShapeTypeTexts: advancedShapes.map((shape) => shape.typeText).filter(Boolean),
+    ...advancedTypes.advancedTypeCheckerEvidence(value),
+    typeReferenceTargetCount: counts.typeReferenceTargetCount || undefined,
+    typeReferenceTargets: nonEmptyArray(typeReferenceTargets),
+    ...typeRefs.typeReferenceTargetCheckerEvidence(value, counts),
+    assignabilityOracleHash: value.assignabilityOracleHash,
+    assignabilityOracleCount: counts.assignabilityOracleCount || undefined,
+    assignabilityOracleDirectionCount: counts.assignabilityOracleDirectionCount || undefined,
+    assignabilityOracleScope: counts.assignabilityOracleCount > 0 ? 'declared-apparent-type-only' : undefined,
+    assignabilityOracleDeclaredTypeText: assignabilityOracle.declaredTypeText,
+    assignabilityOracleApparentTypeText: assignabilityOracle.apparentTypeText,
+    assignabilityOracleResults: assignabilityDirections.map((direction) => direction.assignable),
+    assignabilityOracleDirections: assignabilityDirections,
+    assignabilityOracleEquivalentByBidirectionalAssignability: assignabilityOracle.equivalentByBidirectionalAssignability,
+    assignabilityOracleAmbiguous: assignabilityOracle.ambiguous,
+    assignabilityOracle: counts.assignabilityOracleCount > 0 ? assignabilityOracle : undefined,
+    typeParameterNames: typeParameters.map((parameter) => parameter.name),
+    typeParameterDefaultTypeTexts: typeParameters.filter((parameter) => parameter.hasDefault).map((parameter) => parameter.defaultTypeText),
+    typeParameterConstraintTypeTexts: typeParameters.filter((parameter) => parameter.hasConstraint).map((parameter) => parameter.constraintTypeText),
+    propertyNames: properties.map((property) => property.name),
+    propertyTypeTexts: properties.map((property) => property.typeText),
+    propertyOptionality: properties.map((property) => property.optional),
+    propertyReadonly: properties.map((property) => property.readonly),
+    propertyDeclarationCounts: properties.map((property) => property.declarations),
+    constructorSignatureTexts: constructorSignatures.map((signature) => signature.signatureText),
+    constructorParameterTypeTexts: constructorSignatures.map((signature) => (signature.parameters ?? []).map((parameter) => parameter.typeText)),
+    classHeritageKinds: classHeritage.map((heritage) => heritage.kind),
+    classHeritageTypeTexts: classHeritage.map((heritage) => heritage.typeText),
+    classHeritageExpressionTexts: classHeritage.map((heritage) => heritage.expressionText),
+    typeParameters: nonEmptyArray(typeParameters),
+    properties: nonEmptyArray(properties),
+    constructorSignatures: nonEmptyArray(constructorSignatures),
+    classHeritage: nonEmptyArray(classHeritage),
+    advancedTypeShapes: nonEmptyArray(advancedShapes),
+    signatureTexts: signatures.map((signature) => signature.signatureText),
+    returnTypeTexts: signatures.map((signature) => signature.returnTypeText),
+    parameterTypeTexts: signatures.map((signature) => (signature.parameters ?? []).map((parameter) => parameter.typeText))
+  });
+}
+
+function canonicalSignatureRecords(signatures) { return arrayValue(signatures).map((signature) => compactRecord({ ...signature, parameters: nonEmptyArray(arrayValue(signature.parameters).map(({ flags: _flags, ...parameter }) => parameter)) })); }
+function canonicalPropertyRecords(properties) { return arrayValue(properties).map(({ flags: _flags, ...property }) => property); }
+function arrayValue(value) { return Array.isArray(value) ? value : []; }
+function objectValue(value) { return value && typeof value === 'object' && !Array.isArray(value) ? value : {}; }
+function compactRecord(record) { return Object.fromEntries(Object.entries(record).filter(([, value]) => value !== undefined)); }
+function nonEmptyArray(value) { return Array.isArray(value) && value.length ? value : undefined; }
+function uniqueStrings(values) { return [...new Set(values.filter((value) => typeof value === 'string' && value.length > 0))]; }
+
+export { compilerTypeEquivalenceRecord };

package/dist/internal/index-impl/projectSymbolGraphCompilerTypeEquivalenceProof.js

@@ -0,0 +1,204 @@
+import * as advancedTypes from './projectSymbolGraphCompilerConditionalTypeEquivalence.js';
+import * as cls from './projectSymbolGraphCompilerClassShapeEquivalence.js';
+import * as enumTypes from './projectSymbolGraphCompilerEnumEquivalence.js';
+import * as indexSigs from './projectSymbolGraphCompilerIndexSignatureEquivalence.js';
+import * as typeRefs from './projectSymbolGraphCompilerTypeReferenceTargetEquivalence.js';
+
+const GenericTypeEquivalenceProofKind = 'typescript-checker-public-api-generic-parameter-equivalence';
+const SignatureAndGenericTypeEquivalenceProofKind = 'typescript-checker-public-api-signature-set-and-generic-parameter-equivalence';
+const MemberPropertyTypeEquivalenceProofKind = 'typescript-checker-public-api-member-property-signature-equivalence';
+const AssignabilityOracleEquivalenceProofKind = 'typescript-checker-public-api-assignability-oracle-equivalence';
+
+function requiresTypeEquivalenceProof(counts) {
+  return counts.overloadSignatureCount > 1 || counts.declarationCount > 1 || counts.typeParameterCount > 0 || counts.propertyCount > 0
+    || counts.indexSignatureCount > 0 || counts.constructorSignatureCount > 0 || counts.classHeritageCount > 0 || counts.privateClassMemberCount > 0 || counts.accessorFieldCount > 0 || counts.enumMemberCount > 0 || counts.advancedTypeShapeCount > 0 || counts.typeReferenceTargetCount > 0 || counts.assignabilityOracleCount > 0;
+}
+
+function unsupportedTypeEquivalenceReasonCodes(counts, missingSignals = [], value = {}, source = {}) {
+  const reasonCodes = [];
+  if (counts.overloadSignatureCount > 1) reasonCodes.push('typescript-overload-signature-set-equivalence-unproven');
+  if (counts.declarationCount > 1) reasonCodes.push('typescript-exported-declaration-equivalence-unproven');
+  if (counts.typeParameterCount > 0) reasonCodes.push('typescript-generic-type-parameter-equivalence-unproven');
+  if (counts.typeParameterDefaultCount > 0) reasonCodes.push('typescript-generic-type-parameter-default-equivalence-unproven');
+  if (counts.typeParameterConstraintCount > 0) reasonCodes.push('typescript-generic-type-parameter-constraint-equivalence-unproven');
+  if (counts.propertyCount > 0) reasonCodes.push('typescript-public-member-property-signature-equivalence-unproven');
+  reasonCodes.push(...indexSigs.indexSignatureUnsupportedReasonCodes(counts));
+  if (counts.constructorSignatureCount > 0) reasonCodes.push('typescript-public-constructor-signature-equivalence-unproven');
+  if (counts.classHeritageCount > 0) reasonCodes.push('typescript-public-class-heritage-equivalence-unproven');
+  reasonCodes.push(...cls.classShapeUnsupportedReasonCodes(counts));
+  reasonCodes.push(...enumTypes.enumUnsupportedReasonCodes(value, counts, source));
+  reasonCodes.push(...advancedTypes.advancedTypeUnsupportedReasonCodes(counts));
+  if (counts.typeReferenceTargetCount > 0) reasonCodes.push('typescript-public-api-type-reference-target-proof-unproven');
+  if (counts.assignabilityOracleCount > 0) reasonCodes.push('typescript-public-api-assignability-oracle-equivalence-unproven');
+  for (const signal of missingSignals) reasonCodes.push(`typescript-${signal}-missing`);
+  return reasonCodes;
+}
+
+function typeEquivalenceProofKind(counts) {
+  const advancedTypeProofKind = advancedTypes.advancedTypeProofKind(counts);
+  if (advancedTypeProofKind) return advancedTypeProofKind;
+  const enumProofKind = enumTypes.enumProofKind(counts);
+  const typeReferenceTargetProofKind = typeRefs.typeReferenceTargetProofKind(counts);
+  const indexSignatureProofKind = indexSigs.indexSignatureProofKind(counts);
+  const hasSignatureProof = counts.overloadSignatureCount > 1 || counts.declarationCount > 1;
+  const hasGenericProof = counts.typeParameterCount > 0;
+  const hasPropertyProof = counts.propertyCount > 0;
+  const hasClassProof = counts.constructorSignatureCount > 0 || counts.classHeritageCount > 0 || counts.privateClassMemberCount > 0 || counts.accessorFieldCount > 0;
+  const hasAssignabilityProof = counts.assignabilityOracleCount > 0;
+  if (enumProofKind && !hasSignatureProof && !hasGenericProof && !hasPropertyProof && !indexSignatureProofKind && !hasClassProof) return enumProofKind;
+  if (typeReferenceTargetProofKind && !hasSignatureProof && !hasGenericProof && !hasPropertyProof && !indexSignatureProofKind && !hasClassProof && !enumProofKind) return typeReferenceTargetProofKind;
+  if (hasSignatureProof && hasGenericProof) return SignatureAndGenericTypeEquivalenceProofKind;
+  if (hasGenericProof) return GenericTypeEquivalenceProofKind;
+  if (hasClassProof && !hasPropertyProof) return 'typescript-checker-public-api-class-shape-equivalence';
+  if (indexSignatureProofKind && !hasPropertyProof) return indexSignatureProofKind;
+  if (hasPropertyProof) return MemberPropertyTypeEquivalenceProofKind;
+  if (hasAssignabilityProof) return AssignabilityOracleEquivalenceProofKind;
+  return 'typescript-checker-public-api-signature-set-equivalence';
+}
+
+function typeEquivalenceProofLevel(counts) {
+  const levels = [];
+  if (counts.overloadSignatureCount > 1 || counts.declarationCount > 1) levels.push('signature-set');
+  if (counts.typeParameterCount > 0) levels.push('generic-parameter-set');
+  if (counts.propertyCount > 0) levels.push('member-property-set');
+  const indexSignatureLevel = indexSigs.indexSignatureProofLevel(counts);
+  if (indexSignatureLevel) levels.push(indexSignatureLevel);
+  if (counts.constructorSignatureCount > 0) levels.push('constructor-signature-set');
+  if (counts.classHeritageCount > 0) levels.push('class-heritage-set');
+  const clsLevel = cls.classShapeProofLevel(counts);
+  if (clsLevel) levels.push(clsLevel);
+  const enumLevel = enumTypes.enumProofLevel(counts);
+  if (enumLevel) levels.push(enumLevel);
+  const advancedTypeLevel = advancedTypes.advancedTypeProofLevel(counts);
+  if (advancedTypeLevel) levels.push(advancedTypeLevel);
+  const typeReferenceTargetLevel = typeRefs.typeReferenceTargetProofLevel(counts);
+  if (typeReferenceTargetLevel) levels.push(typeReferenceTargetLevel);
+  if (counts.assignabilityOracleCount > 0) levels.push('declared-apparent-assignability-oracle');
+  return `typescript-checker-public-api-${levels.length ? levels.join('-and-') : 'signature-set'}`;
+}
+
+function typeEquivalenceCheckerInvariant(counts, source = {}) {
+  const invariants = [];
+  if (source.publicContract) invariants.push('public API source path/hash bound');
+  if (counts.overloadSignatureCount > 1 || counts.declarationCount > 1) invariants.push('signature/return/parameter texts complete');
+  if (counts.typeParameterCount > 0) invariants.push('generic defaults/constraints complete');
+  if (counts.propertyCount > 0) invariants.push('member names/types/modifiers complete');
+  const indexSignatureInvariant = indexSigs.indexSignatureCheckerInvariant(counts);
+  if (indexSignatureInvariant) invariants.push(indexSignatureInvariant);
+  if (counts.constructorSignatureCount > 0) invariants.push('constructor signatures complete');
+  if (counts.classHeritageCount > 0) invariants.push('heritage type texts complete');
+  const clsInvariant = cls.classShapeCheckerInvariant(counts);
+  if (clsInvariant) invariants.push(clsInvariant);
+  const enumInvariant = enumTypes.enumCheckerInvariant(counts);
+  if (enumInvariant) invariants.push(enumInvariant);
+  const advancedTypeInvariant = advancedTypes.advancedTypeCheckerInvariant(counts);
+  if (advancedTypeInvariant) invariants.push(advancedTypeInvariant);
+  const typeReferenceTargetInvariant = typeRefs.typeReferenceTargetCheckerInvariant(counts);
+  if (typeReferenceTargetInvariant) invariants.push(typeReferenceTargetInvariant);
+  if (counts.assignabilityOracleCount > 0) invariants.push('declared/apparent type texts and bidirectional checker assignability complete');
+  return invariants.join('; ');
+}
+
+function typeEquivalenceRequiredSignals(counts, source = {}) {
+  return [
+    source.publicContract ? 'compiler-public-api-source-path' : undefined,
+    source.publicContract ? 'compiler-public-api-source-hash' : undefined,
+    'compiler-symbol-identity-hash', 'compiler-symbol-declaration-count', 'compiler-type-identity-hash', 'compiler-api-signature-hash',
+    counts.overloadSignatureCount > 1 || counts.declarationCount > 1 ? 'compiler-overload-signature-count' : undefined,
+    counts.typeParameterCount > 0 ? 'compiler-type-parameter-count' : undefined,
+    counts.typeParameterCount > 0 ? 'compiler-type-parameter-names' : undefined,
+    counts.typeParameterDefaultCount > 0 ? 'compiler-type-parameter-default-type-texts' : undefined,
+    counts.typeParameterConstraintCount > 0 ? 'compiler-type-parameter-constraint-type-texts' : undefined,
+    counts.propertyCount > 0 ? 'compiler-member-property-count' : undefined,
+    counts.propertyCount > 0 ? 'compiler-member-property-names' : undefined,
+    counts.propertyCount > 0 ? 'compiler-member-property-type-texts' : undefined,
+    counts.propertyCount > 0 ? 'compiler-member-property-optionality' : undefined,
+    counts.propertyCount > 0 ? 'compiler-member-property-readonly' : undefined,
+    ...indexSigs.indexSignatureRequiredSignals(counts),
+    counts.constructorSignatureCount > 0 ? 'compiler-constructor-signature-count' : undefined,
+    counts.constructorSignatureCount > 0 ? 'compiler-constructor-signature-texts' : undefined,
+    counts.constructorSignatureCount > 0 ? 'compiler-constructor-parameter-type-texts' : undefined,
+    counts.classHeritageCount > 0 ? 'compiler-class-heritage-count' : undefined,
+    counts.classHeritageCount > 0 ? 'compiler-class-heritage-type-texts' : undefined,
+    ...cls.classShapeRequiredSignals(counts),
+    ...enumTypes.enumRequiredSignals(counts),
+    ...advancedTypes.advancedTypeRequiredSignals(counts),
+    ...typeRefs.typeReferenceTargetRequiredSignals(counts),
+    counts.advancedTypeShapeCount > 0 ? 'compiler-advanced-type-shape-node-texts' : undefined,
+    counts.advancedTypeShapeCount > 0 ? 'compiler-advanced-type-shape-type-texts' : undefined,
+    counts.assignabilityOracleCount > 0 ? 'compiler-assignability-oracle-hash' : undefined,
+    counts.assignabilityOracleCount > 0 ? 'compiler-assignability-oracle-direction-count' : undefined,
+    counts.assignabilityOracleCount > 0 ? 'compiler-assignability-oracle-directions' : undefined,
+    counts.assignabilityOracleCount > 0 ? 'compiler-assignability-oracle-type-texts' : undefined,
+    counts.assignabilityOracleCount > 0 ? 'compiler-assignability-oracle-result' : undefined,
+    counts.assignabilityOracleCount > 0 ? 'compiler-assignability-oracle-unambiguous-result' : undefined,
+    'compiler-signature-texts', 'compiler-return-type-texts', 'compiler-parameter-type-texts'
+  ].filter(Boolean);
+}
+
+function missingTypeEquivalenceSignals(value, compilerSymbol, evidence, counts, source = {}) {
+  const missing = [];
+  if (source.publicContract && !source.sourcePath) missing.push('compiler-public-api-source-path');
+  if (source.publicContract && !source.sourceHash) missing.push('compiler-public-api-source-hash');
+  if (!compilerSymbol?.identityHash) missing.push('compiler-symbol-identity-hash');
+  if (!Number.isFinite(counts.declarationCount)) missing.push('compiler-symbol-declaration-count');
+  if (!value.identityHash) missing.push('compiler-type-identity-hash');
+  if (!value.apiSignatureHash) missing.push('compiler-api-signature-hash');
+  if (counts.declarationCount > 1 && counts.overloadSignatureCount <= 1) missing.push('compiler-overload-signature-count');
+  if (counts.overloadSignatureCount > 1 && evidence.signatureTexts.length !== counts.overloadSignatureCount) missing.push('compiler-overload-signature-count');
+  if (evidence.signatureTexts.length !== counts.overloadSignatureCount || evidence.signatureTexts.some((text) => !text)) missing.push('compiler-signature-texts');
+  if (evidence.returnTypeTexts.length !== counts.overloadSignatureCount || evidence.returnTypeTexts.some((text) => !text)) missing.push('compiler-return-type-texts');
+  if (!compilerSignatureParametersCovered(value.callSignatures) || !compilerSignatureParametersCovered(value.constructSignatures)) missing.push('compiler-parameter-type-texts');
+  if (counts.typeParameterCount > 0 && (evidence.typeParameterNames.length !== counts.typeParameterCount || evidence.typeParameterNames.some((text) => !text))) missing.push('compiler-type-parameter-names');
+  if (counts.typeParameterDefaultCount > 0 && (evidence.typeParameterDefaultTypeTexts.length !== counts.typeParameterDefaultCount || evidence.typeParameterDefaultTypeTexts.some((text) => !text))) missing.push('compiler-type-parameter-default-type-texts');
+  if (counts.typeParameterConstraintCount > 0 && (evidence.typeParameterConstraintTypeTexts.length !== counts.typeParameterConstraintCount || evidence.typeParameterConstraintTypeTexts.some((text) => !text))) missing.push('compiler-type-parameter-constraint-type-texts');
+  if (counts.propertyCount > 0 && evidence.propertyNames.length !== counts.propertyCount) missing.push('compiler-member-property-count');
+  if (counts.propertyCount > 0 && (evidence.propertyNames.length !== counts.propertyCount || evidence.propertyNames.some((text) => !text))) missing.push('compiler-member-property-names');
+  if (counts.propertyCount > 0 && (evidence.propertyTypeTexts.length !== counts.propertyCount || evidence.propertyTypeTexts.some((text) => !text))) missing.push('compiler-member-property-type-texts');
+  if (counts.propertyCount > 0 && !compilerBooleanSignalsCovered(evidence.propertyOptionality, counts.propertyCount)) missing.push('compiler-member-property-optionality');
+  if (counts.propertyCount > 0 && !compilerBooleanSignalsCovered(evidence.propertyReadonly, counts.propertyCount)) missing.push('compiler-member-property-readonly');
+  missing.push(...indexSigs.missingIndexSignatureEquivalenceSignals(value, counts, evidence));
+  if (counts.constructorSignatureCount > 0 && evidence.constructorSignatureTexts.length !== counts.constructorSignatureCount) missing.push('compiler-constructor-signature-count');
+  if (counts.constructorSignatureCount > 0 && (evidence.constructorSignatureTexts.length !== counts.constructorSignatureCount || evidence.constructorSignatureTexts.some((text) => !text))) missing.push('compiler-constructor-signature-texts');
+  if (counts.constructorSignatureCount > 0 && !compilerConstructorParametersCovered(value.constructorSignatures)) missing.push('compiler-constructor-parameter-type-texts');
+  if (counts.classHeritageCount > 0 && evidence.classHeritageTypeTexts.length !== counts.classHeritageCount) missing.push('compiler-class-heritage-count');
+  if (counts.classHeritageCount > 0 && (evidence.classHeritageTypeTexts.length !== counts.classHeritageCount || evidence.classHeritageTypeTexts.some((text) => !text))) missing.push('compiler-class-heritage-type-texts');
+  missing.push(...cls.missingClassShapeEquivalenceSignals(value, counts, evidence));
+  missing.push(...enumTypes.missingEnumEquivalenceSignals(value, counts));
+  if (counts.advancedTypeShapeCount > 0 && evidence.advancedTypeShapeNodeTexts.length !== counts.advancedTypeShapeCount) missing.push('compiler-advanced-type-shape-node-texts');
+  if (counts.advancedTypeShapeCount > 0 && evidence.advancedTypeShapeTypeTexts.length !== counts.advancedTypeShapeCount) missing.push('compiler-advanced-type-shape-type-texts');
+  missing.push(...advancedTypes.missingAdvancedTypeEquivalenceSignals(value, counts));
+  missing.push(...typeRefs.missingTypeReferenceTargetSignals(value, counts));
+  if (counts.assignabilityOracleCount > 0) {
+    const oracle = objectValue(value.assignabilityOracle);
+    const directions = arrayValue(oracle.directions);
+    if (!value.assignabilityOracleHash) missing.push('compiler-assignability-oracle-hash');
+    if (directions.length !== counts.assignabilityOracleDirectionCount || directions.length !== 2) missing.push('compiler-assignability-oracle-direction-count');
+    if (directions.length !== 2 || directions.some((direction) => !direction.direction || !direction.fromTypeText || !direction.toTypeText)) missing.push('compiler-assignability-oracle-directions');
+    if (!oracle.declaredTypeText || !oracle.apparentTypeText) missing.push('compiler-assignability-oracle-type-texts');
+    if (directions.some((direction) => typeof direction.assignable !== 'boolean')) missing.push('compiler-assignability-oracle-result');
+    if (oracle.ambiguous === true || oracle.equivalentByBidirectionalAssignability !== true) missing.push('compiler-assignability-oracle-unambiguous-result');
+  }
+  return uniqueStrings(missing);
+}
+
+function unsupportedTypeEquivalenceSignals(counts, value = {}, source = {}) {
+  return [...enumTypes.enumUnsupportedSignals(value, counts, source), ...advancedTypes.advancedTypeUnsupportedSignals(counts)];
+}
+function compilerSignatureParametersCovered(signatures) { return arrayValue(signatures).every((signature) => arrayValue(signature.parameters).every((parameter) => Boolean(parameter.typeText))); }
+function compilerConstructorParametersCovered(signatures) { return arrayValue(signatures).every((signature) => arrayValue(signature.parameters).every((parameter) => Boolean(parameter.typeText))); }
+function compilerBooleanSignalsCovered(values, count) { return Array.isArray(values) && values.length === count && values.every((value) => typeof value === 'boolean'); }
+function arrayValue(value) { return Array.isArray(value) ? value : []; }
+function objectValue(value) { return value && typeof value === 'object' && !Array.isArray(value) ? value : {}; }
+function uniqueStrings(values) { return [...new Set(values.filter((value) => typeof value === 'string' && value.length > 0))]; }
+
+export {
+  missingTypeEquivalenceSignals,
+  requiresTypeEquivalenceProof,
+  typeEquivalenceCheckerInvariant,
+  typeEquivalenceProofKind,
+  typeEquivalenceProofLevel,
+  typeEquivalenceRequiredSignals,
+  unsupportedTypeEquivalenceReasonCodes,
+  unsupportedTypeEquivalenceSignals
+};