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

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

@@ -0,0 +1,197 @@
+import { hashSemanticValue } from '@shapeshift-labs/frontier-lang-kernel';
+
+const DecoratorRuntimeExecutionProofSchema = 'frontier.lang.typescript.decoratorRuntimeExecutionProof.v1';
+const DecoratorRuntimeExecutionProofKind = 'frontier.lang.typescript.decoratorRuntimeExecutionProof';
+const DecoratorRuntimeExecutionBoundCode = 'decorator-runtime-execution-proof-bound';
+const DecoratorRuntimeExecutionRouteId = 'prove-decorator-runtime-execution-equivalence';
+const DecoratorRuntimeExecutionRouteLane = 'decorator-runtime-boundaries';
+const DecoratorRuntimeExecutionRouteNext = 'supply-decorator-runtime-execution-proof';
+const PassedStatuses = new Set(['passed', 'verified']);
+
+function decoratorRuntimeExecutionProjection(value, counts, source = {}) {
+  const metadataProof = objectRecord(value.decoratorMetadataProof);
+  if (!metadataProof || counts.decoratorMetadataCount <= 0) return { record: {} };
+  const binding = decoratorRuntimeExecutionProofBinding(value, counts, source);
+  return {
+    binding,
+    record: compactRecord({
+      decoratorMetadataProof: boundDecoratorMetadataProof(metadataProof, binding),
+      decoratorRuntimeExecutionHash: binding.decoratorRuntimeExecutionHash,
+      decoratorRuntimeExecutionProof: binding.proof,
+      decoratorRuntimeExecutionProofReasonCodes: binding.passed ? undefined : nonEmptyArray(binding.reasonCodes)
+    })
+  };
+}
+
+function decoratorRuntimeExecutionProofBinding(value, counts, source = {}) {
+  if (counts.decoratorMetadataCount <= 0) return { passed: false, evidenceIds: [], reasonCodes: [] };
+  const proof = decoratorRuntimeExecutionProofCandidate(value);
+  if (!proof) return {
+    passed: false,
+    evidenceIds: [],
+    reasonCodes: ['typescript-decorator-runtime-execution-proof-missing']
+  };
+  const expectedHash = decoratorRuntimeExecutionHash(value, counts, source, proof);
+  const reasonCodes = [];
+  reasonCodes.push(...missingDecoratorRuntimeTraceHashReasonCodes(proof));
+  if (!PassedStatuses.has(String(proof.status ?? ''))) reasonCodes.push('typescript-decorator-runtime-execution-proof-status-not-passed');
+  if (proof.schema !== DecoratorRuntimeExecutionProofSchema && proof.kind !== DecoratorRuntimeExecutionProofKind) {
+    reasonCodes.push('typescript-decorator-runtime-execution-proof-schema-missing');
+  }
+  if (proof.sourcePath !== source.sourcePath) reasonCodes.push('typescript-decorator-runtime-execution-proof-source-path-mismatch');
+  if (proof.sourceHash !== source.sourceHash) reasonCodes.push('typescript-decorator-runtime-execution-proof-source-hash-mismatch');
+  if (proof.decoratorMetadataHash !== value.decoratorMetadataHash) reasonCodes.push('typescript-decorator-runtime-execution-proof-metadata-hash-mismatch');
+  if (Number(proof.decoratorMetadataCount) !== Number(counts.decoratorMetadataCount)) {
+    reasonCodes.push('typescript-decorator-runtime-execution-proof-count-mismatch');
+  }
+  if (!proof.decoratorRuntimeExecutionHash) {
+    reasonCodes.push('typescript-decorator-runtime-execution-proof-execution-hash-missing');
+  } else if (expectedHash && proof.decoratorRuntimeExecutionHash !== expectedHash) {
+    reasonCodes.push('typescript-decorator-runtime-execution-proof-execution-hash-mismatch');
+  }
+  if (proof.autoMergeClaim !== false || proof.semanticEquivalenceClaim !== false || proof.runtimeEquivalenceClaim !== false
+    || proof.decoratorExecutionEquivalenceClaim !== false || proof.decoratorEmitRuntimeEquivalenceClaim !== false) {
+    reasonCodes.push('typescript-decorator-runtime-execution-proof-claim-flags-missing');
+  }
+  return {
+    passed: reasonCodes.length === 0,
+    evidenceIds: uniqueStrings([proof.id, proof.evidenceId, ...arrayValue(proof.evidenceIds)]),
+    reasonCodes: uniqueStrings(reasonCodes),
+    decoratorRuntimeExecutionHash: expectedHash,
+    proof: compactRecord({
+      id: proof.id,
+      evidenceId: proof.evidenceId,
+      schema: proof.schema,
+      kind: proof.kind,
+      status: proof.status,
+      sourcePath: proof.sourcePath,
+      sourceHash: proof.sourceHash,
+      decoratorMetadataHash: proof.decoratorMetadataHash,
+      decoratorMetadataCount: proof.decoratorMetadataCount,
+      decoratorRuntimeExecutionHash: proof.decoratorRuntimeExecutionHash,
+      ...decoratorRuntimeTraceHashes(proof),
+      command: proof.command,
+      traceHash: proof.traceHash,
+      evidenceHash: proof.evidenceHash,
+      autoMergeClaim: false,
+      semanticEquivalenceClaim: false,
+      runtimeEquivalenceClaim: false,
+      decoratorExecutionEquivalenceClaim: false,
+      decoratorEmitRuntimeEquivalenceClaim: false
+    })
+  };
+}
+
+function decoratorRuntimeExecutionHash(value, counts, source = {}, proof = {}) {
+  const traceHashes = decoratorRuntimeTraceHashes(proof);
+  if (requiredDecoratorRuntimeTraceHashKeys().some((key) => !traceHashes[key])) return undefined;
+  return hashSemanticValue({
+    kind: 'frontier.lang.typescript.decoratorRuntimeExecutionProof.values',
+    sourcePath: source.sourcePath,
+    sourceHash: source.sourceHash,
+    decoratorMetadataHash: value.decoratorMetadataHash,
+    decoratorMetadataCount: counts.decoratorMetadataCount,
+    classDecoratorCount: counts.classDecoratorCount || undefined,
+    memberDecoratorCount: counts.memberDecoratorCount || undefined,
+    parameterDecoratorCount: counts.parameterDecoratorCount || undefined,
+    traceHashes
+  });
+}
+
+function boundDecoratorMetadataProof(metadataProof, binding) {
+  if (!binding.passed) return compactRecord({
+    ...metadataProof,
+    decoratorRuntimeExecutionHash: binding.decoratorRuntimeExecutionHash,
+    decoratorRuntimeExecutionProof: binding.proof,
+    decoratorRuntimeExecutionProofReasonCodes: nonEmptyArray(binding.reasonCodes),
+    runtimeExecutionEquivalenceGap: boundDecoratorRuntimeExecutionGap(metadataProof.runtimeExecutionEquivalenceGap, binding)
+  });
+  const { runtimeExecutionEquivalenceGap: _gap, conflictRouting: _routing, ...baseProof } = metadataProof;
+  return compactRecord({
+    ...baseProof,
+    proofScope: 'static-decorator-metadata-and-source-bound-runtime-execution',
+    decoratorRuntimeExecutionHash: binding.decoratorRuntimeExecutionHash,
+    decoratorRuntimeExecutionProof: binding.proof,
+    conflictRouting: decoratorRuntimeProofRouting(binding, baseProof.decoratorMetadataHash),
+    autoMergeClaim: false,
+    semanticEquivalenceClaim: false,
+    runtimeEquivalenceClaim: false,
+    decoratorExecutionEquivalenceClaim: false
+  });
+}
+
+function boundDecoratorRuntimeExecutionGap(gap, binding) {
+  if (!gap) return undefined;
+  return compactRecord({
+    ...gap,
+    decoratorRuntimeExecutionHash: binding.decoratorRuntimeExecutionHash,
+    proofReasonCodes: nonEmptyArray(binding.reasonCodes),
+    proofEvidenceIds: nonEmptyArray(binding.evidenceIds)
+  });
+}
+
+function decoratorRuntimeProofRouting(binding, decoratorMetadataHash) {
+  return {
+    status: 'proof-bound',
+    conflictCode: 'project-public-compiler-type-delta-conflict',
+    reasonCode: DecoratorRuntimeExecutionBoundCode,
+    branchDivergenceSignal: 'decoratorMetadataHash',
+    routeId: DecoratorRuntimeExecutionRouteId,
+    routeLane: DecoratorRuntimeExecutionRouteLane,
+    routeNext: DecoratorRuntimeExecutionRouteNext,
+    decoratorMetadataHash,
+    decoratorRuntimeExecutionHash: binding.decoratorRuntimeExecutionHash,
+    proofEvidenceIds: nonEmptyArray(binding.evidenceIds),
+    failClosed: false,
+    autoMergeClaim: false,
+    semanticEquivalenceClaim: false,
+    runtimeEquivalenceClaim: false,
+    decoratorExecutionEquivalenceClaim: false
+  };
+}
+
+function decoratorRuntimeExecutionProofCandidate(value) {
+  return objectRecord(value.decoratorRuntimeExecutionProof)
+    ?? objectRecord(value.decoratorRuntimeExecutionEvidence)
+    ?? objectRecord(value.decoratorMetadataProof?.decoratorRuntimeExecutionProof)
+    ?? objectRecord(value.decoratorMetadataProof?.runtimeExecutionProof);
+}
+
+function missingDecoratorRuntimeTraceHashReasonCodes(proof) {
+  const hashes = decoratorRuntimeTraceHashes(proof);
+  return requiredDecoratorRuntimeTraceHashKeys()
+    .filter((key) => !hashes[key])
+    .map((key) => `typescript-decorator-runtime-execution-proof-${key.replace(/Hash$/, '').replace(/[A-Z]/g, (char) => `-${char.toLowerCase()}`)}-hash-missing`);
+}
+
+function requiredDecoratorRuntimeTraceHashKeys() {
+  return [
+    'decoratorFactoryCallOrderHash',
+    'decoratorInvocationOrderHash',
+    'decoratorSideEffectTraceHash',
+    'decoratorResultApplicationHash',
+    'decoratorEmitRuntimeEquivalenceHash'
+  ];
+}
+
+function decoratorRuntimeTraceHashes(proof) {
+  return compactRecord({
+    decoratorFactoryCallOrderHash: proof.decoratorFactoryCallOrderHash,
+    decoratorInvocationOrderHash: proof.decoratorInvocationOrderHash,
+    decoratorSideEffectTraceHash: proof.decoratorSideEffectTraceHash,
+    decoratorResultApplicationHash: proof.decoratorResultApplicationHash,
+    decoratorEmitRuntimeEquivalenceHash: proof.decoratorEmitRuntimeEquivalenceHash
+  });
+}
+
+function arrayValue(value) { return Array.isArray(value) ? value : []; }
+function objectRecord(value) { return value && typeof value === 'object' && !Array.isArray(value) ? value : undefined; }
+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 {
+  decoratorRuntimeExecutionHash,
+  decoratorRuntimeExecutionProjection,
+  decoratorRuntimeExecutionProofBinding
+};

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

@@ -0,0 +1,188 @@
+import { hashSemanticValue } from '@shapeshift-labs/frontier-lang-kernel';
+
+const EnumShapeTypeEquivalenceProofKind = 'typescript-checker-public-api-enum-runtime-shape-equivalence';
+const ComputedEnumRuntimeValueProofSchema = 'frontier.lang.typescript.computedEnumRuntimeValueProof.v1';
+const ComputedEnumRuntimeValueProofKind = 'frontier.lang.typescript.computedEnumRuntimeValueProof';
+const PassedStatuses = new Set(['passed', 'verified']);
+
+function enumRuntimeShapeHash(value, counts) {
+  return counts.enumMemberCount > 0 ? value.enumRuntimeShapeHash : undefined;
+}
+
+function enumUnsupportedReasonCodes(value, counts, source = {}) {
+  const reasonCodes = [];
+  if (counts.enumMemberCount > 0) reasonCodes.push('typescript-enum-runtime-shape-equivalence-unproven');
+  const computedProof = computedEnumRuntimeValueProofBinding(value, counts, source);
+  if (counts.enumComputedMemberCount > 0 && !computedProof.passed) {
+    reasonCodes.push('typescript-enum-computed-runtime-value-equivalence-unproven');
+    reasonCodes.push(...computedProof.reasonCodes);
+  }
+  return reasonCodes;
+}
+
+function enumProofKind(counts) {
+  return counts.enumMemberCount > 0 ? EnumShapeTypeEquivalenceProofKind : undefined;
+}
+
+function enumProofLevel(counts) {
+  return counts.enumMemberCount > 0 ? 'enum-runtime-shape' : undefined;
+}
+
+function enumCheckerInvariant(counts) {
+  return counts.enumMemberCount > 0 ? 'enum member names, order, initializer texts, and constant runtime values complete' : undefined;
+}
+
+function enumRequiredSignals(counts) {
+  if (counts.enumMemberCount <= 0) return [];
+  return [
+    'compiler-enum-member-count',
+    'compiler-enum-member-names',
+    'compiler-enum-member-value-texts',
+    'compiler-enum-member-initializer-texts',
+    counts.enumComputedMemberCount > 0 ? 'compiler-enum-computed-runtime-value-proof' : undefined
+  ].filter(Boolean);
+}
+
+function missingEnumEquivalenceSignals(value, counts) {
+  if (counts.enumMemberCount <= 0) return [];
+  const members = arrayValue(value.enumMembers);
+  const missing = [];
+  if (members.length !== counts.enumMemberCount) missing.push('compiler-enum-member-count');
+  if (members.length !== counts.enumMemberCount || members.some((member) => !member.name)) missing.push('compiler-enum-member-names');
+  if (members.length !== counts.enumMemberCount || members.some((member) => member.valueText === undefined && !member.computed)) missing.push('compiler-enum-member-value-texts');
+  if (!value.enumRuntimeShapeHash) missing.push('compiler-enum-runtime-shape-hash');
+  return missing;
+}
+
+function enumUnsupportedSignals(value, counts, source = {}) {
+  if (counts.enumComputedMemberCount <= 0) return [];
+  return computedEnumRuntimeValueProofBinding(value, counts, source).passed
+    ? []
+    : ['compiler-enum-computed-runtime-value'];
+}
+
+function enumCheckerEvidence(value, counts) {
+  if (counts.enumMemberCount <= 0) return {};
+  const members = arrayValue(value.enumMembers);
+  return compactRecord({
+    enumKind: value.enumKind,
+    constEnum: value.constEnum,
+    declareEnum: value.declareEnum,
+    enumDeclarationCount: value.enumDeclarationCount,
+    enumMemberCount: counts.enumMemberCount,
+    enumNumericMemberCount: counts.enumNumericMemberCount || undefined,
+    enumStringMemberCount: counts.enumStringMemberCount || undefined,
+    enumAutoMemberCount: counts.enumAutoMemberCount || undefined,
+    enumComputedMemberCount: counts.enumComputedMemberCount || undefined,
+    enumRuntimeShapeHash: value.enumRuntimeShapeHash,
+    enumMemberNames: members.map((member) => member.name),
+    enumMemberValueTexts: members.map((member) => member.valueText),
+    enumMemberInitializerTexts: members.map((member) => member.initializerText),
+    enumMembers: nonEmptyArray(members)
+  });
+}
+
+function computedEnumRuntimeValueProofBinding(value, counts, source = {}) {
+  if (counts.enumComputedMemberCount <= 0) return { passed: false, evidenceIds: [], reasonCodes: [] };
+  const proof = computedEnumRuntimeValueProofCandidate(value);
+  const expectedHash = computedEnumRuntimeValueHash(value, source);
+  if (!proof) return {
+    passed: false,
+    evidenceIds: [],
+    reasonCodes: ['typescript-computed-enum-runtime-value-proof-missing'],
+    computedEnumRuntimeValueHash: expectedHash
+  };
+  const reasonCodes = [];
+  if (!PassedStatuses.has(String(proof.status ?? ''))) reasonCodes.push('typescript-computed-enum-runtime-value-proof-status-not-passed');
+  if (proof.schema !== ComputedEnumRuntimeValueProofSchema && proof.kind !== ComputedEnumRuntimeValueProofKind) reasonCodes.push('typescript-computed-enum-runtime-value-proof-schema-missing');
+  if (proof.sourcePath !== source.sourcePath) reasonCodes.push('typescript-computed-enum-runtime-value-proof-source-path-mismatch');
+  if (proof.sourceHash !== source.sourceHash) reasonCodes.push('typescript-computed-enum-runtime-value-proof-source-hash-mismatch');
+  if (proof.enumRuntimeShapeHash !== value.enumRuntimeShapeHash) reasonCodes.push('typescript-computed-enum-runtime-value-proof-enum-shape-hash-mismatch');
+  if (value.enumEmittedRuntimeShapeHash && !proof.enumEmittedRuntimeShapeHash) reasonCodes.push('typescript-computed-enum-emitted-runtime-shape-proof-missing');
+  if (proof.enumEmittedRuntimeShapeHash && proof.enumEmittedRuntimeShapeHash !== value.enumEmittedRuntimeShapeHash) reasonCodes.push('typescript-computed-enum-emitted-runtime-shape-proof-mismatch');
+  if (Number(proof.enumComputedMemberCount) !== Number(counts.enumComputedMemberCount)) reasonCodes.push('typescript-computed-enum-runtime-value-proof-member-count-mismatch');
+  if (computedRuntimeValueMissing(value)) reasonCodes.push('typescript-computed-enum-runtime-value-proof-runtime-value-missing');
+  if (proof.computedEnumRuntimeValueHash !== expectedHash) reasonCodes.push('typescript-computed-enum-runtime-value-proof-value-hash-mismatch');
+  if (!proof.traceHash) reasonCodes.push('typescript-computed-enum-runtime-value-proof-trace-hash-missing');
+  if (!proof.evidenceHash) reasonCodes.push('typescript-computed-enum-runtime-value-proof-evidence-hash-missing');
+  if (proof.autoMergeClaim !== false || proof.semanticEquivalenceClaim !== false || proof.runtimeEquivalenceClaim !== false
+    || proof.computedEnumRuntimeEvaluationEquivalenceClaim !== false) {
+    reasonCodes.push('typescript-computed-enum-runtime-value-proof-claim-flags-missing');
+  }
+  return {
+    passed: reasonCodes.length === 0,
+    evidenceIds: uniqueStrings([proof.id, proof.evidenceId, ...arrayValue(proof.evidenceIds)]),
+    reasonCodes: uniqueStrings(reasonCodes),
+    computedEnumRuntimeValueHash: expectedHash,
+    proof: compactRecord({
+      id: proof.id,
+      evidenceId: proof.evidenceId,
+      status: proof.status,
+      sourcePath: proof.sourcePath,
+      sourceHash: proof.sourceHash,
+      enumRuntimeShapeHash: proof.enumRuntimeShapeHash,
+      enumEmittedRuntimeShapeHash: proof.enumEmittedRuntimeShapeHash,
+      enumComputedMemberCount: proof.enumComputedMemberCount,
+      computedMembers: nonEmptyArray(arrayValue(proof.computedMembers)),
+      computedEnumRuntimeValueHash: proof.computedEnumRuntimeValueHash,
+      command: proof.command,
+      traceHash: proof.traceHash,
+      evidenceHash: proof.evidenceHash,
+      autoMergeClaim: false,
+      semanticEquivalenceClaim: false,
+      runtimeEquivalenceClaim: false,
+      computedEnumRuntimeEvaluationEquivalenceClaim: false
+    })
+  };
+}
+
+function computedEnumRuntimeValueProofCandidate(value) {
+  return objectValue(value.computedEnumRuntimeValueProof)
+    ?? objectValue(value.computedEnumRuntimeValueEvidence)
+    ?? objectValue(value.enumRuntimeShapeProof?.computedEnumRuntimeValueProof);
+}
+
+function computedRuntimeValueMissing(value) {
+  return arrayValue(value.enumMembers)
+    .filter((member) => member?.computed === true)
+    .some((member) => member.runtimeValueText === undefined || member.runtimeValueKind === undefined);
+}
+
+function computedEnumRuntimeValueHash(value, source = {}) {
+  const computedMembers = arrayValue(value.enumMembers).filter((member) => member?.computed === true);
+  if (!computedMembers.length) return undefined;
+  return hashSemanticValue({
+    kind: 'frontier.lang.typescript.computedEnumRuntimeValueProof.values',
+    sourcePath: source.sourcePath,
+    sourceHash: source.sourceHash,
+    enumRuntimeShapeHash: value.enumRuntimeShapeHash,
+    computedMembers: computedMembers.map((member) => compactRecord({
+      name: member.name,
+      ordinal: member.ordinal,
+      declarationOrdinal: member.declarationOrdinal,
+      initializerText: member.initializerText,
+      runtimeValueText: member.runtimeValueText,
+      runtimeValueKind: member.runtimeValueKind
+    }))
+  });
+}
+
+function arrayValue(value) { return Array.isArray(value) ? value : []; }
+function objectValue(value) { return value && typeof value === 'object' && !Array.isArray(value) ? value : undefined; }
+function nonEmptyArray(value) { return Array.isArray(value) && value.length ? value : undefined; }
+function compactRecord(record) { return Object.fromEntries(Object.entries(record).filter(([, value]) => value !== undefined)); }
+function uniqueStrings(values) { return [...new Set(values.filter((value) => typeof value === 'string' && value.length > 0))]; }
+
+export {
+  computedEnumRuntimeValueHash,
+  computedEnumRuntimeValueProofBinding,
+  enumCheckerEvidence,
+  enumCheckerInvariant,
+  enumProofKind,
+  enumProofLevel,
+  enumRequiredSignals,
+  enumRuntimeShapeHash,
+  enumUnsupportedReasonCodes,
+  enumUnsupportedSignals,
+  missingEnumEquivalenceSignals
+};

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

@@ -0,0 +1,244 @@
+import { idFragment, uniqueStrings } from '../../native-import-utils.js';
+import { compilerAdvancedTypeMetadata } from './projectSymbolGraphCompilerAdvancedTypeMetadata.js';
+import { compilerCallableSignatureEquivalenceRecord } from './projectSymbolGraphCompilerCallableSignatureEquivalence.js';
+import {
+  compilerAssignabilityOracleMetadata,
+  compilerClassMemberShapeMetadata,
+  compilerDecoratorMetadata,
+  compilerEnumShapeMetadata,
+  compilerTypeInferenceSyntaxMetadata
+} from './projectSymbolGraphCompilerMetadata.js';
+import { compilerTypeEquivalenceRecord } from './projectSymbolGraphCompilerTypeEquivalence.js';
+
+function createProjectCompilerGraphRecords(semanticIndex, symbolsById, documentsById, publicContractRegions) {
+  const facts = semanticIndex?.facts ?? [];
+  const symbolDocuments = symbolSourceDocuments(semanticIndex?.relations ?? [], documentsById);
+  const publicSymbolIds = new Set((publicContractRegions ?? []).map((region) => region.symbolId).filter(Boolean));
+  const compilerSymbolBySubject = new Map(facts
+    .filter((fact) => fact.predicate === 'compilerSymbol')
+    .map((fact) => [fact.subjectId, compilerSymbolRecord(fact, symbolsById.get(fact.subjectId), symbolDocuments.get(fact.subjectId), publicSymbolIds)])
+    .filter(([, record]) => Boolean(record)));
+  return {
+    compilerSymbolRecords: uniqueRecords([...compilerSymbolBySubject.values()]),
+    compilerTypeRecords: uniqueRecords(facts
+      .filter((fact) => fact.predicate === 'compilerType')
+      .map((fact) => compilerTypeRecord(fact, symbolsById.get(fact.subjectId), symbolDocuments.get(fact.subjectId), publicSymbolIds, compilerSymbolBySubject.get(fact.subjectId)))
+      .filter(Boolean))
+  };
+}
+
+function compilerSymbolRecord(fact, symbol, document, publicSymbolIds) {
+  const value = objectValue(fact.value);
+  return compactRecord({
+    id: `compiler_symbol_${idFragment(fact.id)}`,
+    symbolId: fact.subjectId,
+    sourceDocumentId: document?.id,
+    sourcePath: document?.path,
+    sourceHash: document?.sourceHash,
+    symbolName: symbol?.name,
+    symbolKind: symbol?.kind,
+    identityHash: value.identityHash,
+    localName: value.localName,
+    targetName: value.targetName,
+    fullyQualifiedName: value.fullyQualifiedName,
+    flags: value.flags,
+    targetFlags: value.targetFlags,
+    declarations: value.declarations,
+    aliased: value.aliased,
+    publicContract: publicSymbolIds.has(fact.subjectId) || symbol?.metadata?.publicContract || undefined,
+    factId: fact.id,
+    evidenceIds: fact.evidenceIds
+  });
+}
+
+function compilerTypeRecord(fact, symbol, document, publicSymbolIds, compilerSymbol) {
+  const value = objectValue(fact.value);
+  const publicContract = publicSymbolIds.has(fact.subjectId) || symbol?.metadata?.publicContract || undefined;
+  const sourceBinding = { sourcePath: document?.path, sourceHash: document?.sourceHash, publicContract: publicContract === true };
+  const callSignatureCount = arrayLength(value.callSignatures);
+  const constructSignatureCount = arrayLength(value.constructSignatures);
+  const overloadSignatureCount = callSignatureCount + constructSignatureCount;
+  const declarationCount = numberValue(compilerSymbol?.declarations);
+  const typeParameterCount = numberValue(value.typeParameterCount) ?? arrayLength(value.typeParameters);
+  const typeParameterDefaultCount = numberValue(value.typeParameterDefaultCount) ?? compilerTypeParameterDefaultCount(value.typeParameters);
+  const typeParameterConstraintCount = numberValue(value.typeParameterConstraintCount) ?? compilerTypeParameterConstraintCount(value.typeParameters);
+  const propertyCount = arrayLength(value.properties);
+  const propertyOptionalCount = compilerPropertyOptionalCount(value.properties);
+  const propertyReadonlyCount = compilerPropertyReadonlyCount(value.properties);
+  const indexSignatureCount = numberValue(value.indexSignatureCount) ?? arrayLength(value.indexSignatures);
+  const indexSignatureReadonlyCount = numberValue(value.indexSignatureReadonlyCount) ?? compilerIndexSignatureReadonlyCount(value.indexSignatures);
+  const constructorSignatureCount = numberValue(value.constructorSignatureCount) ?? arrayLength(value.constructorSignatures);
+  const classHeritageCount = numberValue(value.classHeritageCount) ?? arrayLength(value.classHeritage);
+  const advancedType = compilerAdvancedTypeMetadata(value);
+  const enumShape = compilerEnumShapeMetadata(value);
+  const typeInferenceSyntax = compilerTypeInferenceSyntaxMetadata(value, sourceBinding);
+  const classMemberShape = compilerClassMemberShapeMetadata(value, sourceBinding);
+  const decoratorMetadata = compilerDecoratorMetadata(value, sourceBinding);
+  const assignabilityOracle = compilerAssignabilityOracleMetadata(value);
+  const callableEquivalence = compilerCallableSignatureEquivalenceRecord(value, { callSignatureCount, constructSignatureCount, evidenceIds: fact.evidenceIds }, sourceBinding);
+  const typeEquivalence = compilerTypeEquivalenceRecord(value, compilerSymbol, {
+    overloadSignatureCount,
+    callSignatureCount,
+    constructSignatureCount,
+    declarationCount,
+    typeParameterCount,
+    typeParameterDefaultCount,
+    typeParameterConstraintCount,
+    propertyCount,
+    propertyOptionalCount,
+    propertyReadonlyCount,
+    indexSignatureCount,
+    indexSignatureReadonlyCount,
+    constructorSignatureCount,
+    classHeritageCount,
+    ...assignabilityOracle.counts,
+    ...classMemberShape.counts,
+    ...decoratorMetadata.counts, ...enumShape.counts, ...advancedType.counts, evidenceIds: fact.evidenceIds
+  }, sourceBinding);
+  const typeEquivalenceStatus = typeEquivalence.status ?? callableEquivalence.status;
+  const typeEquivalenceProof = typeEquivalence.proof ?? callableEquivalence.proof;
+  const typeEquivalenceCheckerEvidence = typeEquivalence.checkerEvidence ?? callableEquivalence.checkerEvidence;
+  return compactRecord({
+    id: `compiler_type_${idFragment(fact.id)}`,
+    symbolId: fact.subjectId,
+    sourceDocumentId: document?.id,
+    sourcePath: document?.path,
+    sourceHash: document?.sourceHash,
+    symbolName: symbol?.name,
+    symbolKind: symbol?.kind,
+    compilerSymbolIdentityHash: compilerSymbol?.identityHash,
+    fullyQualifiedName: compilerSymbol?.fullyQualifiedName,
+    localName: compilerSymbol?.localName,
+    declarationCount,
+    identityHash: value.identityHash,
+    typeText: value.typeText,
+    apparentTypeText: value.apparentTypeText,
+    apiSignatureHash: value.apiSignatureHash,
+    callSignatureCount: callSignatureCount || undefined,
+    constructSignatureCount: constructSignatureCount || undefined,
+    overloadSignatureCount: overloadSignatureCount > 1 ? overloadSignatureCount : undefined,
+    typeParameterCount: typeParameterCount || undefined,
+    typeParameterDefaultCount: typeParameterDefaultCount || undefined,
+    typeParameterConstraintCount: typeParameterConstraintCount || undefined,
+    propertyCount: propertyCount || undefined,
+    propertyOptionalCount: propertyOptionalCount || undefined,
+    propertyReadonlyCount: propertyReadonlyCount || undefined,
+    indexSignatureCount: indexSignatureCount || undefined,
+    indexSignatureReadonlyCount: indexSignatureReadonlyCount || undefined,
+    constructorSignatureCount: constructorSignatureCount || undefined,
+    classHeritageCount: classHeritageCount || undefined,
+    ...assignabilityOracle.record,
+    ...classMemberShape.record,
+    ...decoratorMetadata.record,
+    ...enumShape.record,
+    ...advancedType.record,
+    ...typeInferenceSyntax.record,
+    typeEquivalenceStatus,
+    typeEquivalenceReasonCodes: nonEmptyArray(uniqueStrings([...(typeEquivalence.reasonCodes ?? []), ...(callableEquivalence.reasonCodes ?? [])])),
+    typeEquivalenceCallSignatureSetHash: callableEquivalence.callSignatureSetHash,
+    typeEquivalenceConstructSignatureSetHash: callableEquivalence.constructSignatureSetHash,
+    typeEquivalenceSignatureSetHash: typeEquivalence.signatureSetHash,
+    typeEquivalenceTypeParameterSetHash: typeEquivalence.typeParameterSetHash,
+    typeEquivalencePropertySetHash: typeEquivalence.propertySetHash,
+    typeEquivalenceIndexSignatureSetHash: typeEquivalence.indexSignatureSetHash,
+    typeEquivalenceConstructorSetHash: typeEquivalence.constructorSetHash,
+    typeEquivalenceClassHeritageHash: typeEquivalence.classHeritageHash,
+    typeEquivalenceAssignabilityOracleHash: typeEquivalence.assignabilityOracleHash,
+    typeEquivalencePrivateClassMemberSetHash: typeEquivalence.privateClassMemberSetHash,
+    typeEquivalenceAccessorFieldSetHash: typeEquivalence.accessorFieldSetHash,
+    classPrivateAccessorRuntimeHash: classMemberShape.record.classPrivateAccessorRuntimeHash,
+    classPrivateAccessorRuntimeProof: classMemberShape.record.classPrivateAccessorRuntimeProof,
+    classPrivateAccessorRuntimeProofReasonCodes: classMemberShape.record.classPrivateAccessorRuntimeProofReasonCodes,
+    typeEquivalenceEnumRuntimeShapeHash: typeEquivalence.enumRuntimeShapeHash,
+    typeEquivalenceEnumEmittedRuntimeShapeHash: typeEquivalence.enumEmittedRuntimeShapeHash,
+    typeEquivalenceConditionalTypeSetHash: typeEquivalence.conditionalTypeSetHash,
+    typeEquivalenceIndexedAccessTypeSetHash: typeEquivalence.indexedAccessTypeSetHash,
+    typeEquivalenceMappedTypeSetHash: typeEquivalence.mappedTypeSetHash,
+    typeEquivalenceKeyofTypeOperatorSetHash: typeEquivalence.keyofTypeOperatorSetHash,
+    typeEquivalenceTypeReferenceTargetSetHash: typeEquivalence.typeReferenceTargetSetHash,
+    typeEquivalenceTemplateLiteralTypeSetHash: typeEquivalence.templateLiteralTypeSetHash,
+    typeEquivalenceInferTypeSetHash: typeEquivalence.inferTypeSetHash,
+    typeEquivalenceUnionTypeSetHash: typeEquivalence.unionTypeSetHash,
+    typeEquivalenceIntersectionTypeSetHash: typeEquivalence.intersectionTypeSetHash,
+    typeEquivalenceTupleTypeSetHash: typeEquivalence.tupleTypeSetHash,
+    typeEquivalenceProof,
+    typeEquivalenceCheckerEvidence,
+    callableSignatureEquivalenceProof: callableEquivalence.proof,
+    typeParameters: value.typeParameters,
+    properties: value.properties,
+    indexSignatures: value.indexSignatures,
+    assignabilityOracle: value.assignabilityOracle,
+    callSignatures: value.callSignatures,
+    constructSignatures: value.constructSignatures,
+    constructorSignatures: value.constructorSignatures,
+    classHeritage: value.classHeritage,
+    privateClassMembers: value.privateClassMembers,
+    accessorFieldMembers: value.accessorFieldMembers,
+    classMemberShapeProof: classMemberShape.record.classMemberShapeProof,
+    decoratorMetadata: decoratorMetadata.record.decoratorMetadata,
+    decoratorMetadataProof: decoratorMetadata.record.decoratorMetadataProof,
+    decoratorRuntimeExecutionHash: decoratorMetadata.record.decoratorRuntimeExecutionHash,
+    decoratorRuntimeExecutionProof: decoratorMetadata.record.decoratorRuntimeExecutionProof,
+    decoratorRuntimeExecutionProofReasonCodes: decoratorMetadata.record.decoratorRuntimeExecutionProofReasonCodes,
+    enumMembers: value.enumMembers,
+    enumEmittedRuntimeShapeHash: value.enumEmittedRuntimeShapeHash,
+    enumRuntimeShapeProof: value.enumRuntimeShapeProof,
+    typeInferenceSyntax: value.typeInferenceSyntax,
+    typeInferenceSyntaxProof: typeInferenceSyntax.record.typeInferenceSyntaxProof,
+    typeReferenceTargets: value.typeReferenceTargets,
+    flags: value.flags,
+    objectFlags: value.objectFlags,
+    intrinsicName: value.intrinsicName,
+    publicContract,
+    factId: fact.id,
+    evidenceIds: fact.evidenceIds
+  });
+}
+
+function compilerTypeParameterDefaultCount(typeParameters) {
+  return arrayValue(typeParameters).filter((parameter) => parameter?.hasDefault).length;
+}
+
+function compilerTypeParameterConstraintCount(typeParameters) {
+  return arrayValue(typeParameters).filter((parameter) => parameter?.hasConstraint).length;
+}
+
+function compilerPropertyOptionalCount(properties) {
+  return arrayValue(properties).filter((property) => property?.optional === true).length;
+}
+
+function compilerPropertyReadonlyCount(properties) {
+  return arrayValue(properties).filter((property) => property?.readonly === true).length;
+}
+
+function compilerIndexSignatureReadonlyCount(signatures) {
+  return arrayValue(signatures).filter((signature) => signature?.readonly === true).length;
+}
+
+function symbolSourceDocuments(relations, documentsById) {
+  const result = new Map();
+  for (const relation of relations) {
+    if (!relation?.targetId || result.has(relation.targetId)) continue;
+    const document = documentsById.get(relation.sourceId);
+    if (document) result.set(relation.targetId, document);
+  }
+  return result;
+}
+
+function objectValue(value) { return value && typeof value === 'object' && !Array.isArray(value) ? value : {}; }
+function arrayValue(value) { return Array.isArray(value) ? value : []; }
+function compactRecord(record) { return Object.fromEntries(Object.entries(record).filter(([, value]) => value !== undefined)); }
+function arrayLength(value) { return Array.isArray(value) ? value.length : 0; }
+function numberValue(value) { return Number.isFinite(value) ? value : undefined; }
+function nonEmptyArray(value) { return Array.isArray(value) && value.length ? value : undefined; }
+function uniqueRecords(records) {
+  const seen = new Set();
+  return records.filter((record) => {
+    const key = record.id ?? JSON.stringify(record);
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+}
+
+export { createProjectCompilerGraphRecords };