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

package/dist/js-ts-safe-project-merge-graph-delta-commonjs-interop.js

@@ -0,0 +1,108 @@
+import { compactRecord } from './js-ts-safe-merge-context.js';
+
+function commonJsRuntimeInteropDelta(identityKey, edge, workerEdge, outputGraph) {
+  if (!isDefaultModuleExportsTarget(edge)) return undefined;
+  const exportShape = (outputGraph?.exportAssignmentRecords ?? [])
+    .find((record) => record.sourcePath === edge.resolvedModulePath && record.exportedName === 'module.exports');
+  return compactRecord({
+    schema: 'frontier.lang.commonJsRuntimeInteropDelta.v1',
+    identityKey,
+    sourcePath: edge.sourcePath,
+    sourceHash: edge.sourceHash,
+    moduleSpecifier: edge.moduleSpecifier,
+    importedName: edge.importedName,
+    localName: edge.localName,
+    importKind: edge.importKind,
+    commonJs: edge.commonJs,
+    interopHelper: edge.interopHelper,
+    packageRuntimeCondition: edge.packageRuntimeCondition,
+    packageRuntimeConditionEdgeKind: edge.packageRuntimeConditionEdgeKind,
+    resolvedModulePath: edge.resolvedModulePath,
+    outputTargetSymbolId: edge.resolvedTargetSymbolId,
+    workerTargetSymbolId: workerEdge.resolvedTargetSymbolId,
+    exportAssignmentShapeHash: exportShape?.shapeHash,
+    autoMergeClaim: false,
+    semanticEquivalenceClaim: false,
+    runtimeEquivalenceClaim: false,
+    runtimeInteropEquivalenceClaim: false
+  });
+}
+
+function commonJsRuntimeInteropProofAssessment(delta, options = {}) {
+  const proof = commonJsRuntimeInteropProofFor(delta, options);
+  const reasonCodes = [];
+  if (!proof) reasonCodes.push('commonjs-runtime-interop-proof-missing');
+  else {
+    if (proof.status !== 'passed') reasonCodes.push('commonjs-runtime-interop-proof-status-not-passed');
+    if (proof.schema !== 'frontier.lang.commonJsRuntimeInteropProof.v1' && proof.kind !== 'frontier.lang.commonJsRuntimeInteropProof') reasonCodes.push('commonjs-runtime-interop-proof-schema-missing');
+    if (proof.sourcePath !== delta.sourcePath) reasonCodes.push('commonjs-runtime-interop-proof-source-path-mismatch');
+    if (proof.sourceHash !== delta.sourceHash) reasonCodes.push('commonjs-runtime-interop-proof-source-hash-mismatch');
+    if (proof.identityKey !== undefined && proof.identityKey !== delta.identityKey) reasonCodes.push('commonjs-runtime-interop-proof-import-edge-mismatch');
+    if (proof.moduleSpecifier !== delta.moduleSpecifier || proof.importedName !== delta.importedName || proof.localName !== delta.localName || proof.importKind !== delta.importKind) reasonCodes.push('commonjs-runtime-interop-proof-import-edge-mismatch');
+    if ((delta.interopHelper || proof.interopHelper) && proof.interopHelper !== delta.interopHelper) reasonCodes.push('commonjs-runtime-interop-proof-helper-identity-mismatch');
+    if ((delta.packageRuntimeCondition || proof.packageRuntimeCondition) && proof.packageRuntimeCondition !== delta.packageRuntimeCondition) reasonCodes.push('commonjs-runtime-interop-proof-package-runtime-condition-mismatch');
+    if ((delta.packageRuntimeConditionEdgeKind || proof.packageRuntimeConditionEdgeKind) && proof.packageRuntimeConditionEdgeKind !== delta.packageRuntimeConditionEdgeKind) reasonCodes.push('commonjs-runtime-interop-proof-package-runtime-condition-mismatch');
+    if (proof.outputTargetSymbolId !== delta.outputTargetSymbolId) reasonCodes.push('commonjs-runtime-interop-proof-resolved-target-symbol-mismatch');
+    if ((delta.exportAssignmentShapeHash || proof.exportAssignmentShapeHash) && proof.exportAssignmentShapeHash !== delta.exportAssignmentShapeHash) reasonCodes.push('commonjs-runtime-interop-proof-export-assignment-shape-hash-mismatch');
+    if (!proof.runtimeTraceHash && !proof.helperTraceHash) reasonCodes.push('commonjs-runtime-interop-proof-trace-hash-missing');
+    if (!proof.evidenceHash) reasonCodes.push('commonjs-runtime-interop-proof-evidence-hash-missing');
+    if (proof.autoMergeClaim !== false || proof.semanticEquivalenceClaim !== false || proof.runtimeEquivalenceClaim !== false || proof.runtimeInteropEquivalenceClaim !== false) reasonCodes.push('commonjs-runtime-interop-proof-claim-flags-missing');
+  }
+  const status = proof && reasonCodes.length === 0 ? 'passed' : proof ? 'failed' : 'missing';
+  return {
+    status,
+    routeId: 'prove-commonjs-runtime-interop-equivalence',
+    routeLane: 'module-runtime-interop',
+    routeNext: 'supply-commonjs-runtime-interop-proof',
+    reasonCodes: uniqueStrings(reasonCodes),
+    record: compactRecord({
+      schema: 'frontier.lang.commonJsRuntimeInteropProofAssessment.v1',
+      status,
+      proofStatus: proof?.status,
+      proofId: proof?.id,
+      proofHash: proof?.proofHash,
+      routeId: 'prove-commonjs-runtime-interop-equivalence',
+      routeLane: 'module-runtime-interop',
+      routeNext: 'supply-commonjs-runtime-interop-proof',
+      reasonCodes: uniqueStrings(reasonCodes),
+      delta,
+      autoMergeClaim: false,
+      semanticEquivalenceClaim: false,
+      runtimeEquivalenceClaim: false,
+      runtimeInteropEquivalenceClaim: false
+    })
+  };
+}
+
+function commonJsRuntimeInteropProofFor(delta, options = {}) {
+  const proofs = [
+    options.commonJsRuntimeInteropProof,
+    ...(Array.isArray(options.commonJsRuntimeInteropProofs) ? options.commonJsRuntimeInteropProofs : [])
+  ].filter(Boolean);
+  return proofs.find((proof) => (
+    proof.identityKey === delta.identityKey
+      || proof.sourcePath === delta.sourcePath
+        && proof.moduleSpecifier === delta.moduleSpecifier
+        && proof.importedName === delta.importedName
+        && proof.localName === delta.localName
+        && proof.importKind === delta.importKind
+  ));
+}
+
+function isDefaultModuleExportsTarget(edge) {
+  return projectImportTargetName(edge) === 'default'
+    && /:export:module_exports$/.test(String(edge?.resolvedTargetSymbolId ?? ''));
+}
+
+function projectImportTargetName(edge) {
+  if (edge?.importKind === 'side-effect' || edge?.importKind === 'namespace') return undefined;
+  const name = edge?.importedName ?? edge?.localName ?? edge?.exportedName;
+  if (!name || name === '*') return undefined;
+  return String(name);
+}
+
+function uniqueStrings(values) {
+  return [...new Set(values.filter((value) => typeof value === 'string' && value.length > 0))];
+}
+
+export { commonJsRuntimeInteropDelta, commonJsRuntimeInteropProofAssessment };

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

@@ -0,0 +1,179 @@
+import { compactRecord } from './js-ts-safe-merge-context.js';
+import { missingDeclarationEmitParityEvidence } from './js-ts-safe-project-merge-declaration-emit-parity.js';
+import { compilerTypeDetails, compilerTypeFingerprint } from './js-ts-safe-project-merge-graph-delta-compiler-details.js';
+import { missingSharedCompilerTypeInferenceSyntaxEvidence } from './js-ts-safe-project-merge-graph-delta-inference-syntax.js';
+
+function publicCompilerTypeDeltaConflicts(baseGraph, workerGraph, headGraph, outputGraph, options = {}) {
+  return changedIdentityConflicts({
+    code: 'project-public-compiler-type-delta-conflict',
+    label: 'public compiler type',
+    baseRecords: publicCompilerTypeRecords(baseGraph.compilerTypeRecords),
+    workerRecords: publicCompilerTypeRecords(workerGraph.compilerTypeRecords),
+    headRecords: publicCompilerTypeRecords(headGraph.compilerTypeRecords),
+    outputRecords: publicCompilerTypeRecords(outputGraph?.compilerTypeRecords),
+    identityKey: compilerTypeIdentityKey,
+    fingerprint: compilerTypeFingerprint,
+    details: compilerTypeDetails,
+    declarationEmitParityProof: options.declarationEmitParityProof, requireDeclarationEmitParity: options.requireDeclarationEmitParity === true || Boolean(options.declarationEmitParityProof)
+  });
+}
+
+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) return [];
+    if (workerFingerprint === headFingerprint) {
+      const missingTypeEvidence = missingSharedCompilerTypeEquivalenceEvidence(workerRecord, headRecord);
+      const missingInferenceSyntaxEvidence = missingSharedCompilerTypeInferenceSyntaxEvidence(workerRecord, headRecord);
+      const missingDeclarationEvidence = missingDeclarationEmitParityEvidence(input.declarationEmitParityProof, input);
+      if (!missingTypeEvidence && !missingInferenceSyntaxEvidence && !missingDeclarationEvidence) return [];
+      const missingEvidence = missingDeclarationEvidence ?? missingTypeEvidence ?? missingInferenceSyntaxEvidence;
+      return [projectGraphDeltaConflict({
+        ...input,
+        identityKey,
+        baseRecord,
+        workerRecord,
+        headRecord,
+        outputRecord: output.get(identityKey),
+        reasonCode: missingEvidence.reasonCode,
+        typeEquivalenceEvidence: missingTypeEvidence,
+        typeInferenceSyntaxEvidence: missingInferenceSyntaxEvidence,
+        declarationEmitParityEvidence: missingDeclarationEvidence,
+        message: `Worker and head both changed ${input.label} ${JSON.stringify(identityKey)} to the same compiler public API fingerprint, but required public API evidence is missing.`
+      })];
+    }
+    return [projectGraphDeltaConflict({ ...input, identityKey, baseRecord, workerRecord, headRecord, outputRecord: output.get(identityKey) })];
+  });
+}
+
+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: input.message ?? `Worker and head both changed ${input.label} ${JSON.stringify(input.identityKey)} in incompatible ways.`,
+    sourcePath,
+    details: compactRecord({
+      reasonCode: input.reasonCode ?? input.code,
+      conflictCode: input.reasonCode ? input.code : undefined,
+      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),
+      typeEquivalenceEvidence: input.typeEquivalenceEvidence,
+      typeInferenceSyntaxEvidence: input.typeInferenceSyntaxEvidence,
+      declarationEmitParityEvidence: input.declarationEmitParityEvidence
+    })
+  };
+}
+
+function publicCompilerTypeRecords(records) { return (records ?? []).filter((record) => record?.publicContract); }
+function compilerTypeIdentityKey(record) { return stableKey(['compiler-public-type', record?.fullyQualifiedName ?? record?.localName ?? record?.symbolName ?? record?.symbolId]); }
+
+function missingSharedCompilerTypeEquivalenceEvidence(workerRecord, headRecord) {
+  const requiringProof = [workerRecord, headRecord].filter(requiresCompilerTypeEquivalenceProof);
+  if (!requiringProof.length) return undefined;
+  const missing = requiringProof.filter((record) => !hasPassedCompilerTypeEquivalenceProof(record));
+  if (!missing.length) return undefined;
+  return {
+    reasonCode: 'typescript-public-api-type-equivalence-proof-missing',
+    requiredEvidence: 'typescript-checker-public-api-type-equivalence',
+    missingRecords: missing.map((record) => compactRecord({
+      sourcePath: record.sourcePath, sourceHash: record.sourceHash,
+      symbolId: record.symbolId,
+      symbolName: record.symbolName,
+      fullyQualifiedName: record.fullyQualifiedName,
+      typeEquivalenceStatus: record.typeEquivalenceStatus,
+      typeEquivalenceReasonCodes: record.typeEquivalenceReasonCodes,
+      propertyCount: record.propertyCount, propertyOptionalCount: record.propertyOptionalCount,
+      propertyReadonlyCount: record.propertyReadonlyCount, indexSignatureCount: record.indexSignatureCount,
+      indexSignatureReadonlyCount: record.indexSignatureReadonlyCount,
+      constructorSignatureCount: record.constructorSignatureCount,
+      classHeritageCount: record.classHeritageCount,
+      assignabilityOracleCount: record.assignabilityOracleCount,
+      assignabilityOracleDirectionCount: record.assignabilityOracleDirectionCount,
+      typeEquivalenceAssignabilityOracleHash: record.typeEquivalenceAssignabilityOracleHash,
+      privateClassMemberCount: record.privateClassMemberCount,
+      accessorFieldCount: record.accessorFieldCount,
+      classPrivateAccessorRuntimeHash: record.classPrivateAccessorRuntimeHash,
+      classPrivateAccessorRuntimeProofStatus: record.classPrivateAccessorRuntimeProof?.status,
+      classPrivateAccessorRuntimeProofSourcePath: record.classPrivateAccessorRuntimeProof?.sourcePath,
+      classPrivateAccessorRuntimeProofSourceHash: record.classPrivateAccessorRuntimeProof?.sourceHash,
+      classPrivateAccessorRuntimeProofReasonCodes: record.classPrivateAccessorRuntimeProofReasonCodes,
+      enumMemberCount: record.enumMemberCount,
+      enumComputedMemberCount: record.enumComputedMemberCount,
+      typeEquivalenceEnumRuntimeShapeHash: record.typeEquivalenceEnumRuntimeShapeHash,
+      typeEquivalenceSignatureSetHash: record.typeEquivalenceSignatureSetHash,
+      typeEquivalenceCallSignatureSetHash: record.typeEquivalenceCallSignatureSetHash, typeEquivalenceConstructSignatureSetHash: record.typeEquivalenceConstructSignatureSetHash,
+      typeEquivalenceTypeParameterSetHash: record.typeEquivalenceTypeParameterSetHash,
+      typeEquivalencePropertySetHash: record.typeEquivalencePropertySetHash,
+      typeEquivalenceConstructorSetHash: record.typeEquivalenceConstructorSetHash,
+      typeEquivalenceClassHeritageHash: record.typeEquivalenceClassHeritageHash,
+      typeEquivalencePrivateClassMemberSetHash: record.typeEquivalencePrivateClassMemberSetHash,
+      typeEquivalenceAccessorFieldSetHash: record.typeEquivalenceAccessorFieldSetHash,
+      typeEquivalenceIndexSignatureSetHash: record.typeEquivalenceIndexSignatureSetHash,
+      typeEquivalenceConditionalTypeSetHash: record.typeEquivalenceConditionalTypeSetHash, typeEquivalenceIndexedAccessTypeSetHash: record.typeEquivalenceIndexedAccessTypeSetHash,
+      typeEquivalenceMappedTypeSetHash: record.typeEquivalenceMappedTypeSetHash, typeEquivalenceKeyofTypeOperatorSetHash: record.typeEquivalenceKeyofTypeOperatorSetHash,
+      typeReferenceTargetCount: record.typeReferenceTargetCount,
+      typeEquivalenceTypeReferenceTargetSetHash: record.typeEquivalenceTypeReferenceTargetSetHash,
+      typeEquivalenceTemplateLiteralTypeSetHash: record.typeEquivalenceTemplateLiteralTypeSetHash, typeEquivalenceInferTypeSetHash: record.typeEquivalenceInferTypeSetHash,
+      typeEquivalenceUnionTypeSetHash: record.typeEquivalenceUnionTypeSetHash, typeEquivalenceIntersectionTypeSetHash: record.typeEquivalenceIntersectionTypeSetHash, typeEquivalenceTupleTypeSetHash: record.typeEquivalenceTupleTypeSetHash,
+      typeEquivalenceProofStatus: record.typeEquivalenceProof?.status, typeEquivalenceProofSourcePath: record.typeEquivalenceProof?.sourcePath, typeEquivalenceProofSourceHash: record.typeEquivalenceProof?.sourceHash,
+      semanticEquivalenceClaim: record.typeEquivalenceProof?.semanticEquivalenceClaim,
+      assignabilityOracle: record.assignabilityOracle,
+      missingSignals: record.typeEquivalenceProof?.missingSignals,
+      unsupportedSignals: record.typeEquivalenceProof?.unsupportedSignals,
+      checkerEvidence: record.typeEquivalenceCheckerEvidence,
+      evidenceIds: record.evidenceIds
+    }))
+  };
+}
+
+function requiresCompilerTypeEquivalenceProof(record) { return Boolean(record && (record.callSignatureCount > 0 || record.constructSignatureCount > 0 || record.overloadSignatureCount > 1 || record.declarationCount > 1 || record.typeParameterCount > 0 || record.propertyCount > 0 || record.indexSignatureCount > 0 || record.constructorSignatureCount > 0 || record.classHeritageCount > 0 || record.assignabilityOracleCount > 0 || record.privateClassMemberCount > 0 || record.accessorFieldCount > 0 || record.enumMemberCount > 0 || record.advancedTypeShapeCount > 0 || record.typeReferenceTargetCount > 0 || record.typeEquivalenceStatus === 'unsupported')); }
+function hasPassedCompilerTypeEquivalenceProof(record) {
+  const requiredHashes = [
+    [record?.callSignatureCount > 0, record?.typeEquivalenceCallSignatureSetHash],
+    [record?.constructSignatureCount > 0, record?.typeEquivalenceConstructSignatureSetHash],
+    [record?.overloadSignatureCount > 1 || record?.declarationCount > 1, record?.typeEquivalenceSignatureSetHash],
+    [record?.typeParameterCount > 0, record?.typeEquivalenceTypeParameterSetHash],
+    [record?.propertyCount > 0, record?.typeEquivalencePropertySetHash],
+    [record?.indexSignatureCount > 0, record?.typeEquivalenceIndexSignatureSetHash],
+    [record?.constructorSignatureCount > 0, record?.typeEquivalenceConstructorSetHash],
+    [record?.classHeritageCount > 0, record?.typeEquivalenceClassHeritageHash],
+    [record?.assignabilityOracleCount > 0, record?.typeEquivalenceAssignabilityOracleHash],
+    [record?.privateClassMemberCount > 0, record?.typeEquivalencePrivateClassMemberSetHash],
+    [record?.accessorFieldCount > 0, record?.typeEquivalenceAccessorFieldSetHash],
+    [record?.enumMemberCount > 0, record?.typeEquivalenceEnumRuntimeShapeHash],
+    [record?.conditionalTypeCount > 0, record?.typeEquivalenceConditionalTypeSetHash],
+    [record?.indexedAccessTypeCount > 0, record?.typeEquivalenceIndexedAccessTypeSetHash],
+    [record?.mappedTypeCount > 0, record?.typeEquivalenceMappedTypeSetHash],
+    [record?.keyofTypeOperatorCount > 0, record?.typeEquivalenceKeyofTypeOperatorSetHash],
+    [record?.typeReferenceTargetCount > 0, record?.typeEquivalenceTypeReferenceTargetSetHash],
+    [record?.templateLiteralTypeCount > 0, record?.typeEquivalenceTemplateLiteralTypeSetHash],
+    [record?.inferTypeCount > 0, record?.typeEquivalenceInferTypeSetHash], [record?.unionTypeCount > 0, record?.typeEquivalenceUnionTypeSetHash],
+    [record?.intersectionTypeCount > 0, record?.typeEquivalenceIntersectionTypeSetHash], [record?.tupleTypeCount > 0, record?.typeEquivalenceTupleTypeSetHash]
+  ];
+  return Boolean(record?.typeEquivalenceStatus === 'compiler-backed-equivalent'
+    && record?.typeEquivalenceProof?.status === 'passed'
+    && requiredHashes.every(([required, hash]) => !required || hash)
+    && record?.apiSignatureHash);
+}
+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 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 uniqueStrings(values) { return [...new Set(values.filter((value) => typeof value === 'string' && value.length > 0))]; }
+export { publicCompilerTypeDeltaConflicts };

package/dist/js-ts-safe-project-merge-graph-delta-compiler-details.js

@@ -0,0 +1,189 @@
+import { hashSemanticValue } from '@shapeshift-labs/frontier-lang-kernel';
+import { compactRecord } from './js-ts-safe-merge-context.js';
+
+function compilerTypeFingerprint(record) {
+  return hashSemanticValue({
+    kind: 'frontier.lang.projectGraphDelta.compilerPublicApiFingerprint',
+    compilerSymbolIdentityHash: record.compilerSymbolIdentityHash,
+    identityHash: record.identityHash,
+    apiSignatureHash: record.apiSignatureHash,
+    typeParameters: record.typeParameters,
+    typeParameterCount: record.typeParameterCount,
+    typeParameterDefaultCount: record.typeParameterDefaultCount,
+    typeParameterConstraintCount: record.typeParameterConstraintCount,
+    propertyCount: record.propertyCount, propertyOptionalCount: record.propertyOptionalCount,
+    propertyReadonlyCount: record.propertyReadonlyCount, indexSignatureCount: record.indexSignatureCount,
+    indexSignatureReadonlyCount: record.indexSignatureReadonlyCount,
+    constructorSignatureCount: record.constructorSignatureCount,
+    classHeritageCount: record.classHeritageCount,
+    assignabilityOracleCount: record.assignabilityOracleCount,
+    assignabilityOracleDirectionCount: record.assignabilityOracleDirectionCount,
+    assignabilityOracleHash: record.assignabilityOracleHash,
+    assignabilityOracle: record.assignabilityOracle,
+    privateClassMemberCount: record.privateClassMemberCount,
+    accessorFieldCount: record.accessorFieldCount,
+    privateClassMemberShapeHash: record.privateClassMemberShapeHash,
+    accessorFieldShapeHash: record.accessorFieldShapeHash,
+    classPrivateAccessorRuntimeHash: record.classPrivateAccessorRuntimeHash,
+    classPrivateAccessorRuntimeProof: record.classPrivateAccessorRuntimeProof,
+    classPrivateAccessorRuntimeProofReasonCodes: record.classPrivateAccessorRuntimeProofReasonCodes,
+    decoratorMetadataCount: record.decoratorMetadataCount,
+    decoratorMetadataHash: record.decoratorMetadataHash,
+    decoratorMetadata: record.decoratorMetadata,
+    enumMemberCount: record.enumMemberCount,
+    enumComputedMemberCount: record.enumComputedMemberCount,
+    enumRuntimeShapeHash: record.enumRuntimeShapeHash,
+    enumEmittedRuntimeShapeHash: record.enumEmittedRuntimeShapeHash,
+    advancedTypeShapeCount: record.advancedTypeShapeCount,
+    advancedTypeShapeKinds: record.advancedTypeShapeKinds,
+    typeReferenceTargetCount: record.typeReferenceTargetCount,
+    typeInferenceSyntaxCount: record.typeInferenceSyntaxCount,
+    typeInferenceSyntaxKinds: record.typeInferenceSyntaxKinds,
+    satisfiesExpressionCount: record.satisfiesExpressionCount,
+    asConstAssertionCount: record.asConstAssertionCount,
+    constTypeParameterCount: record.constTypeParameterCount,
+    typeInferenceSyntaxHash: record.typeInferenceSyntaxHash,
+    conditionalTypeCount: record.conditionalTypeCount, mappedTypeCount: record.mappedTypeCount,
+    indexedAccessTypeCount: record.indexedAccessTypeCount, keyofTypeOperatorCount: record.keyofTypeOperatorCount,
+    templateLiteralTypeCount: record.templateLiteralTypeCount, inferTypeCount: record.inferTypeCount,
+    unionTypeCount: record.unionTypeCount, intersectionTypeCount: record.intersectionTypeCount, tupleTypeCount: record.tupleTypeCount,
+    advancedTypeShapes: record.advancedTypeShapes,
+    typeText: record.typeText, apparentTypeText: record.apparentTypeText,
+    properties: record.properties, indexSignatures: record.indexSignatures,
+    callSignatures: record.callSignatures,
+    constructSignatures: record.constructSignatures,
+    typeEquivalenceCallSignatureSetHash: record.typeEquivalenceCallSignatureSetHash, typeEquivalenceConstructSignatureSetHash: record.typeEquivalenceConstructSignatureSetHash,
+    constructorSignatures: record.constructorSignatures,
+    classHeritage: record.classHeritage,
+    privateClassMembers: record.privateClassMembers,
+    accessorFieldMembers: record.accessorFieldMembers,
+    classMemberShapeProof: record.classMemberShapeProof,
+    enumMembers: record.enumMembers,
+    enumRuntimeShapeProof: record.enumRuntimeShapeProof,
+    typeEquivalenceConstructorSetHash: record.typeEquivalenceConstructorSetHash,
+    typeEquivalenceClassHeritageHash: record.typeEquivalenceClassHeritageHash,
+    typeEquivalenceAssignabilityOracleHash: record.typeEquivalenceAssignabilityOracleHash,
+    typeEquivalencePrivateClassMemberSetHash: record.typeEquivalencePrivateClassMemberSetHash,
+    typeEquivalenceAccessorFieldSetHash: record.typeEquivalenceAccessorFieldSetHash,
+    typeEquivalenceIndexSignatureSetHash: record.typeEquivalenceIndexSignatureSetHash,
+    typeEquivalenceEnumRuntimeShapeHash: record.typeEquivalenceEnumRuntimeShapeHash,
+    typeEquivalenceEnumEmittedRuntimeShapeHash: record.typeEquivalenceEnumEmittedRuntimeShapeHash,
+    typeEquivalenceConditionalTypeSetHash: record.typeEquivalenceConditionalTypeSetHash, typeEquivalenceIndexedAccessTypeSetHash: record.typeEquivalenceIndexedAccessTypeSetHash,
+    typeEquivalenceMappedTypeSetHash: record.typeEquivalenceMappedTypeSetHash, typeEquivalenceKeyofTypeOperatorSetHash: record.typeEquivalenceKeyofTypeOperatorSetHash,
+    typeEquivalenceTypeReferenceTargetSetHash: record.typeEquivalenceTypeReferenceTargetSetHash,
+    typeEquivalenceTemplateLiteralTypeSetHash: record.typeEquivalenceTemplateLiteralTypeSetHash, typeEquivalenceInferTypeSetHash: record.typeEquivalenceInferTypeSetHash,
+    typeEquivalenceUnionTypeSetHash: record.typeEquivalenceUnionTypeSetHash, typeEquivalenceIntersectionTypeSetHash: record.typeEquivalenceIntersectionTypeSetHash, typeEquivalenceTupleTypeSetHash: record.typeEquivalenceTupleTypeSetHash,
+    typeInferenceSyntax: record.typeInferenceSyntax,
+    flags: record.flags,
+    objectFlags: record.objectFlags,
+    intrinsicName: record.intrinsicName
+  });
+}
+
+function compilerTypeDetails(record) {
+  if (!record) return undefined;
+  return compactRecord({
+    sourcePath: record.sourcePath,
+    key: compilerTypeIdentityKey(record),
+    symbolId: record.symbolId,
+    symbolName: record.symbolName,
+    symbolKind: record.symbolKind,
+    fullyQualifiedName: record.fullyQualifiedName,
+    compilerSymbolIdentityHash: record.compilerSymbolIdentityHash,
+    typeIdentityHash: record.identityHash,
+    apiSignatureHash: record.apiSignatureHash,
+    typeText: record.typeText,
+    apparentTypeText: record.apparentTypeText,
+    typeParameters: record.typeParameters,
+    typeParameterCount: record.typeParameterCount,
+    typeParameterDefaultCount: record.typeParameterDefaultCount,
+    typeParameterConstraintCount: record.typeParameterConstraintCount,
+    propertyCount: record.propertyCount, propertyOptionalCount: record.propertyOptionalCount,
+    propertyReadonlyCount: record.propertyReadonlyCount, indexSignatureCount: record.indexSignatureCount,
+    indexSignatureReadonlyCount: record.indexSignatureReadonlyCount,
+    constructorSignatureCount: record.constructorSignatureCount,
+    classHeritageCount: record.classHeritageCount,
+    assignabilityOracleCount: record.assignabilityOracleCount,
+    assignabilityOracleDirectionCount: record.assignabilityOracleDirectionCount,
+    assignabilityOracleHash: record.assignabilityOracleHash,
+    assignabilityOracle: record.assignabilityOracle,
+    privateClassMemberCount: record.privateClassMemberCount,
+    accessorFieldCount: record.accessorFieldCount,
+    privateClassMemberShapeHash: record.privateClassMemberShapeHash,
+    accessorFieldShapeHash: record.accessorFieldShapeHash,
+    decoratorMetadataCount: record.decoratorMetadataCount,
+    decoratorMetadataHash: record.decoratorMetadataHash,
+    decoratorRuntimeExecutionHash: record.decoratorRuntimeExecutionHash,
+    decoratorRuntimeExecutionProof: record.decoratorRuntimeExecutionProof,
+    decoratorRuntimeExecutionProofReasonCodes: record.decoratorRuntimeExecutionProofReasonCodes,
+    enumKind: record.enumKind,
+    constEnum: record.constEnum,
+    enumMemberCount: record.enumMemberCount,
+    enumNumericMemberCount: record.enumNumericMemberCount,
+    enumStringMemberCount: record.enumStringMemberCount,
+    enumAutoMemberCount: record.enumAutoMemberCount,
+    enumComputedMemberCount: record.enumComputedMemberCount,
+    enumRuntimeShapeHash: record.enumRuntimeShapeHash,
+    enumEmittedRuntimeShapeHash: record.enumEmittedRuntimeShapeHash,
+    advancedTypeShapeCount: record.advancedTypeShapeCount,
+    advancedTypeShapeKinds: record.advancedTypeShapeKinds,
+    typeReferenceTargetCount: record.typeReferenceTargetCount,
+    typeReferenceTargets: record.typeReferenceTargets,
+    typeInferenceSyntaxCount: record.typeInferenceSyntaxCount,
+    typeInferenceSyntaxKinds: record.typeInferenceSyntaxKinds,
+    satisfiesExpressionCount: record.satisfiesExpressionCount,
+    asConstAssertionCount: record.asConstAssertionCount,
+    constTypeParameterCount: record.constTypeParameterCount,
+    typeInferenceSyntaxHash: record.typeInferenceSyntaxHash,
+    conditionalTypeCount: record.conditionalTypeCount, mappedTypeCount: record.mappedTypeCount,
+    indexedAccessTypeCount: record.indexedAccessTypeCount, keyofTypeOperatorCount: record.keyofTypeOperatorCount,
+    templateLiteralTypeCount: record.templateLiteralTypeCount, inferTypeCount: record.inferTypeCount,
+    unionTypeCount: record.unionTypeCount, intersectionTypeCount: record.intersectionTypeCount, tupleTypeCount: record.tupleTypeCount,
+    advancedTypeShapes: record.advancedTypeShapes,
+    properties: record.properties, indexSignatures: record.indexSignatures,
+    callSignatures: record.callSignatures,
+    constructSignatures: record.constructSignatures,
+    typeEquivalenceStatus: record.typeEquivalenceStatus,
+    typeEquivalenceReasonCodes: record.typeEquivalenceReasonCodes,
+    typeEquivalenceSignatureSetHash: record.typeEquivalenceSignatureSetHash,
+    typeEquivalenceCallSignatureSetHash: record.typeEquivalenceCallSignatureSetHash, typeEquivalenceConstructSignatureSetHash: record.typeEquivalenceConstructSignatureSetHash,
+    typeEquivalenceTypeParameterSetHash: record.typeEquivalenceTypeParameterSetHash,
+    typeEquivalencePropertySetHash: record.typeEquivalencePropertySetHash,
+    typeEquivalenceConstructorSetHash: record.typeEquivalenceConstructorSetHash,
+    typeEquivalenceClassHeritageHash: record.typeEquivalenceClassHeritageHash,
+    typeEquivalenceAssignabilityOracleHash: record.typeEquivalenceAssignabilityOracleHash,
+    typeEquivalencePrivateClassMemberSetHash: record.typeEquivalencePrivateClassMemberSetHash,
+    typeEquivalenceAccessorFieldSetHash: record.typeEquivalenceAccessorFieldSetHash,
+    typeEquivalenceIndexSignatureSetHash: record.typeEquivalenceIndexSignatureSetHash,
+    typeEquivalenceEnumRuntimeShapeHash: record.typeEquivalenceEnumRuntimeShapeHash,
+    typeEquivalenceEnumEmittedRuntimeShapeHash: record.typeEquivalenceEnumEmittedRuntimeShapeHash,
+    typeEquivalenceConditionalTypeSetHash: record.typeEquivalenceConditionalTypeSetHash, typeEquivalenceIndexedAccessTypeSetHash: record.typeEquivalenceIndexedAccessTypeSetHash,
+    typeEquivalenceMappedTypeSetHash: record.typeEquivalenceMappedTypeSetHash, typeEquivalenceKeyofTypeOperatorSetHash: record.typeEquivalenceKeyofTypeOperatorSetHash,
+    typeEquivalenceTypeReferenceTargetSetHash: record.typeEquivalenceTypeReferenceTargetSetHash,
+    typeEquivalenceTemplateLiteralTypeSetHash: record.typeEquivalenceTemplateLiteralTypeSetHash, typeEquivalenceInferTypeSetHash: record.typeEquivalenceInferTypeSetHash,
+    typeEquivalenceUnionTypeSetHash: record.typeEquivalenceUnionTypeSetHash, typeEquivalenceIntersectionTypeSetHash: record.typeEquivalenceIntersectionTypeSetHash, typeEquivalenceTupleTypeSetHash: record.typeEquivalenceTupleTypeSetHash,
+    typeInferenceSyntax: record.typeInferenceSyntax,
+    typeInferenceSyntaxProof: record.typeInferenceSyntaxProof,
+    enumMembers: record.enumMembers,
+    enumRuntimeShapeProof: record.enumRuntimeShapeProof,
+    typeEquivalenceProof: record.typeEquivalenceProof,
+    typeEquivalenceCheckerEvidence: record.typeEquivalenceCheckerEvidence,
+    constructorSignatures: record.constructorSignatures,
+    classHeritage: record.classHeritage,
+    privateClassMembers: record.privateClassMembers,
+    accessorFieldMembers: record.accessorFieldMembers,
+    classMemberShapeProof: record.classMemberShapeProof,
+    decoratorMetadata: record.decoratorMetadata,
+    decoratorMetadataProof: record.decoratorMetadataProof,
+    sourceHash: record.sourceHash,
+    evidenceIds: record.evidenceIds
+  });
+}
+
+function compilerTypeIdentityKey(record) { return stableKey(['compiler-public-type', record?.fullyQualifiedName ?? record?.localName ?? record?.symbolName ?? record?.symbolId]); }
+function stableKey(parts) {
+  const values = parts.map((part) => part === undefined || part === null ? '' : String(part));
+  return values.some(Boolean) ? values.join('#') : undefined;
+}
+
+export { compilerTypeDetails, compilerTypeFingerprint };