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

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

@@ -0,0 +1,280 @@
+import { hashSemanticValue } from '@shapeshift-labs/frontier-lang-kernel';
+
+const ClassPrivateAccessorRuntimeProofSchema = 'frontier.lang.typescript.classPrivateAccessorRuntimeProof.v1';
+const ClassPrivateAccessorRuntimeProofKind = 'frontier.lang.typescript.classPrivateAccessorRuntimeProof';
+const ClassPrivateAccessorRuntimeBoundCode = 'class-private-accessor-runtime-proof-bound';
+const ClassPrivateAccessorRuntimeRouteId = 'prove-class-private-accessor-runtime-equivalence';
+const ClassPrivateAccessorRuntimeRouteLane = 'class-private-accessor-runtime-boundaries';
+const ClassPrivateAccessorRuntimeRouteNext = 'supply-class-private-accessor-runtime-proof';
+const PassedStatuses = new Set(['passed', 'verified']);
+const TraceHashSignalsByKey = Object.freeze({
+  classConstructionOrderTraceHash: 'typescript-class-construction-order-trace',
+  privateMemberInitializationTraceHash: 'typescript-private-member-initialization-trace',
+  privateMemberAccessTraceHash: 'typescript-private-member-access-trace',
+  privateBrandCheckTraceHash: 'typescript-private-brand-check-trace',
+  privateMethodCallTraceHash: 'typescript-private-method-call-trace',
+  privateAccessorGetSetTraceHash: 'typescript-private-accessor-get-set-trace',
+  staticPrivateMemberAccessTraceHash: 'typescript-static-private-member-access-trace',
+  subclassPrivateBrandBoundaryTraceHash: 'typescript-subclass-private-brand-boundary-trace',
+  accessorInitializationTraceHash: 'typescript-accessor-field-initialization-trace',
+  accessorGetSetTraceHash: 'typescript-accessor-field-get-set-trace',
+  accessorDescriptorTraceHash: 'typescript-accessor-field-descriptor-trace'
+});
+
+function classPrivateAccessorRuntimeProjection(value, counts, source = {}) {
+  const shapeProof = objectRecord(value.classMemberShapeProof);
+  if (!shapeProof || !classPrivateAccessorRuntimeRequired(counts)) return { record: {} };
+  const binding = classPrivateAccessorRuntimeProofBinding(value, counts, source);
+  return {
+    binding,
+    record: compactRecord({
+      classMemberShapeProof: boundClassMemberShapeProof(shapeProof, binding),
+      classPrivateAccessorRuntimeHash: binding.classPrivateAccessorRuntimeHash,
+      classPrivateAccessorRuntimeProof: binding.proof,
+      classPrivateAccessorRuntimeProofReasonCodes: binding.passed ? undefined : nonEmptyArray(binding.reasonCodes)
+    })
+  };
+}
+
+function classPrivateAccessorRuntimeProofBinding(value, counts, source = {}) {
+  if (!classPrivateAccessorRuntimeRequired(counts)) return { passed: false, evidenceIds: [], reasonCodes: [] };
+  const proof = classPrivateAccessorRuntimeProofCandidate(value);
+  if (!proof) return {
+    passed: false,
+    evidenceIds: [],
+    reasonCodes: ['typescript-class-private-accessor-runtime-proof-missing']
+  };
+  const expectedHash = classPrivateAccessorRuntimeHash(value, counts, source, proof);
+  const requiredSignals = classPrivateAccessorRuntimeRequiredSignals(value, counts);
+  const reasonCodes = [];
+  reasonCodes.push(...missingClassPrivateAccessorRuntimeTraceHashReasonCodes(proof, value, counts));
+  if (!PassedStatuses.has(String(proof.status ?? ''))) reasonCodes.push('typescript-class-private-accessor-runtime-proof-status-not-passed');
+  if (proof.schema !== ClassPrivateAccessorRuntimeProofSchema) reasonCodes.push('typescript-class-private-accessor-runtime-proof-schema-missing');
+  if (proof.kind !== ClassPrivateAccessorRuntimeProofKind) reasonCodes.push('typescript-class-private-accessor-runtime-proof-kind-missing');
+  if (!containsAllStrings(proof.requiredSignals, requiredSignals)) reasonCodes.push('typescript-class-private-accessor-runtime-proof-required-signals-missing');
+  if (proof.sourcePath !== source.sourcePath) reasonCodes.push('typescript-class-private-accessor-runtime-proof-source-path-mismatch');
+  if (proof.sourceHash !== source.sourceHash) reasonCodes.push('typescript-class-private-accessor-runtime-proof-source-hash-mismatch');
+  if (counts.privateClassMemberCount > 0 && proof.privateClassMemberShapeHash !== value.privateClassMemberShapeHash) {
+    reasonCodes.push('typescript-class-private-accessor-runtime-proof-private-shape-hash-mismatch');
+  }
+  if (counts.accessorFieldCount > 0 && proof.accessorFieldShapeHash !== value.accessorFieldShapeHash) {
+    reasonCodes.push('typescript-class-private-accessor-runtime-proof-accessor-shape-hash-mismatch');
+  }
+  if (Number(proof.privateClassMemberCount ?? 0) !== Number(counts.privateClassMemberCount ?? 0)) {
+    reasonCodes.push('typescript-class-private-accessor-runtime-proof-private-count-mismatch');
+  }
+  if (Number(proof.accessorFieldCount ?? 0) !== Number(counts.accessorFieldCount ?? 0)) {
+    reasonCodes.push('typescript-class-private-accessor-runtime-proof-accessor-count-mismatch');
+  }
+  if (!proof.classPrivateAccessorRuntimeHash) {
+    reasonCodes.push('typescript-class-private-accessor-runtime-proof-runtime-hash-missing');
+  } else if (expectedHash && proof.classPrivateAccessorRuntimeHash !== expectedHash) {
+    reasonCodes.push('typescript-class-private-accessor-runtime-proof-runtime-hash-mismatch');
+  }
+  if (!stringValue(proof.command)) reasonCodes.push('typescript-class-private-accessor-runtime-proof-command-missing');
+  if (!stringValue(proof.traceHash)) reasonCodes.push('typescript-class-private-accessor-runtime-proof-trace-hash-missing');
+  if (!stringValue(proof.evidenceHash)) reasonCodes.push('typescript-class-private-accessor-runtime-proof-evidence-hash-missing');
+  if (proof.autoMergeClaim !== false || proof.semanticEquivalenceClaim !== false || proof.runtimeEquivalenceClaim !== false
+    || proof.privateMemberRuntimeEquivalenceClaim !== false || proof.accessorRuntimeEquivalenceClaim !== false) {
+    reasonCodes.push('typescript-class-private-accessor-runtime-proof-claim-flags-missing');
+  }
+  return {
+    passed: reasonCodes.length === 0,
+    evidenceIds: uniqueStrings([proof.id, proof.evidenceId, ...arrayValue(proof.evidenceIds)]),
+    reasonCodes: uniqueStrings(reasonCodes),
+    classPrivateAccessorRuntimeHash: expectedHash,
+    proof: compactRecord({
+      id: proof.id,
+      evidenceId: proof.evidenceId,
+      schema: proof.schema,
+      kind: proof.kind,
+      status: proof.status,
+      sourcePath: proof.sourcePath,
+      sourceHash: proof.sourceHash,
+      privateClassMemberShapeHash: proof.privateClassMemberShapeHash,
+      accessorFieldShapeHash: proof.accessorFieldShapeHash,
+      privateClassMemberCount: proof.privateClassMemberCount,
+      accessorFieldCount: proof.accessorFieldCount,
+      requiredSignals,
+      classPrivateAccessorRuntimeHash: proof.classPrivateAccessorRuntimeHash,
+      ...classPrivateAccessorRuntimeTraceHashes(proof, value, counts),
+      command: proof.command,
+      traceHash: proof.traceHash,
+      evidenceHash: proof.evidenceHash,
+      autoMergeClaim: false,
+      semanticEquivalenceClaim: false,
+      runtimeEquivalenceClaim: false,
+      privateMemberRuntimeEquivalenceClaim: false,
+      accessorRuntimeEquivalenceClaim: false
+    })
+  };
+}
+
+function classPrivateAccessorRuntimeHash(value, counts, source = {}, proof = {}) {
+  const traceHashes = classPrivateAccessorRuntimeTraceHashes(proof, value, counts);
+  if (requiredClassPrivateAccessorRuntimeTraceHashKeys(value, counts).some((key) => !traceHashes[key])) return undefined;
+  return hashSemanticValue({
+    kind: 'frontier.lang.typescript.classPrivateAccessorRuntimeProof.values',
+    sourcePath: source.sourcePath,
+    sourceHash: source.sourceHash,
+    privateClassMemberShapeHash: counts.privateClassMemberCount > 0 ? value.privateClassMemberShapeHash : undefined,
+    accessorFieldShapeHash: counts.accessorFieldCount > 0 ? value.accessorFieldShapeHash : undefined,
+    privateClassMemberCount: counts.privateClassMemberCount || undefined,
+    accessorFieldCount: counts.accessorFieldCount || undefined,
+    requiredSignals: classPrivateAccessorRuntimeRequiredSignals(value, counts),
+    traceHashes
+  });
+}
+
+function boundClassMemberShapeProof(shapeProof, binding) {
+  if (!binding.passed) return compactRecord({
+    ...shapeProof,
+    proofScope: shapeProof.proofScope ?? 'static-private-accessor-shape-only',
+    classPrivateAccessorRuntimeHash: binding.classPrivateAccessorRuntimeHash,
+    classPrivateAccessorRuntimeProof: binding.proof,
+    classPrivateAccessorRuntimeProofReasonCodes: nonEmptyArray(binding.reasonCodes),
+    runtimeEquivalenceGap: boundClassPrivateAccessorRuntimeGap(shapeProof.runtimeEquivalenceGap, binding)
+  });
+  const { runtimeEquivalenceGap: _gap, conflictRouting: _routing, ...baseProof } = shapeProof;
+  return compactRecord({
+    ...baseProof,
+    proofScope: 'static-private-accessor-shape-and-source-bound-runtime',
+    classPrivateAccessorRuntimeHash: binding.classPrivateAccessorRuntimeHash,
+    classPrivateAccessorRuntimeProof: binding.proof,
+    conflictRouting: classPrivateAccessorRuntimeProofRouting(binding, baseProof),
+    autoMergeClaim: false,
+    semanticEquivalenceClaim: false,
+    runtimeEquivalenceClaim: false
+  });
+}
+
+function boundClassPrivateAccessorRuntimeGap(gap, binding) {
+  return compactRecord({
+    ...(gap ?? {
+      code: 'class-private-accessor-runtime-equivalence-not-claimed',
+      status: 'not-claimed',
+      summary: 'Private member initialization/access and accessor getter/setter runtime behavior remain unproved.',
+      routeId: ClassPrivateAccessorRuntimeRouteId,
+      routeLane: ClassPrivateAccessorRuntimeRouteLane,
+      routeNext: ClassPrivateAccessorRuntimeRouteNext,
+      failClosed: true,
+      blocksSemanticEquivalence: true
+    }),
+    classPrivateAccessorRuntimeHash: binding.classPrivateAccessorRuntimeHash,
+    proofReasonCodes: nonEmptyArray(binding.reasonCodes),
+    proofEvidenceIds: nonEmptyArray(binding.evidenceIds)
+  });
+}
+
+function classPrivateAccessorRuntimeProofRouting(binding, shapeProof = {}) {
+  return {
+    status: 'proof-bound',
+    conflictCode: 'project-public-compiler-type-delta-conflict',
+    reasonCode: ClassPrivateAccessorRuntimeBoundCode,
+    branchDivergenceSignal: 'classPrivateAccessorRuntimeHash',
+    routeId: ClassPrivateAccessorRuntimeRouteId,
+    routeLane: ClassPrivateAccessorRuntimeRouteLane,
+    routeNext: ClassPrivateAccessorRuntimeRouteNext,
+    privateClassMemberShapeHash: shapeProof.privateClassMemberShapeHash,
+    accessorFieldShapeHash: shapeProof.accessorFieldShapeHash,
+    classPrivateAccessorRuntimeHash: binding.classPrivateAccessorRuntimeHash,
+    proofEvidenceIds: nonEmptyArray(binding.evidenceIds),
+    failClosed: false,
+    autoMergeClaim: false,
+    semanticEquivalenceClaim: false,
+    runtimeEquivalenceClaim: false
+  };
+}
+
+function classPrivateAccessorRuntimeProofCandidate(value) {
+  return objectRecord(value.classPrivateAccessorRuntimeProof)
+    ?? objectRecord(value.classPrivateAccessorRuntimeEvidence)
+    ?? objectRecord(value.classMemberShapeProof?.classPrivateAccessorRuntimeProof)
+    ?? objectRecord(value.classMemberShapeProof?.runtimeProof);
+}
+
+function missingClassPrivateAccessorRuntimeTraceHashReasonCodes(proof, value, counts) {
+  const hashes = classPrivateAccessorRuntimeTraceHashes(proof, value, counts);
+  return requiredClassPrivateAccessorRuntimeTraceHashKeys(value, counts)
+    .filter((key) => !hashes[key])
+    .map((key) => `typescript-class-private-accessor-runtime-proof-${key.replace(/Hash$/, '').replace(/[A-Z]/g, (char) => `-${char.toLowerCase()}`)}-hash-missing`);
+}
+
+function requiredClassPrivateAccessorRuntimeTraceHashKeys(value, counts) {
+  const privateMembers = privateClassMembers(value);
+  const hasPrivateMembers = counts.privateClassMemberCount > 0;
+  const hasPrivateIdentifier = privateMembers.some((member) => member.privateIdentifier === true || stringValue(member.name)?.startsWith('#'));
+  const hasPrivateMethod = privateMembers.some((member) => member.kind === 'private-method');
+  const hasPrivateAccessor = privateMembers.some((member) => member.kind === 'private-get-accessor' || member.kind === 'private-set-accessor' || member.kind === 'private-accessor-field');
+  const hasStaticPrivate = privateMembers.some((member) => member.static === true);
+  const hasClassHeritage = (numberValue(value.classHeritageCount) ?? arrayValue(value.classHeritage).length) > 0;
+  return [
+    'classConstructionOrderTraceHash',
+    hasPrivateMembers ? 'privateMemberInitializationTraceHash' : undefined,
+    hasPrivateMembers ? 'privateMemberAccessTraceHash' : undefined,
+    hasPrivateIdentifier ? 'privateBrandCheckTraceHash' : undefined,
+    hasPrivateMethod ? 'privateMethodCallTraceHash' : undefined,
+    hasPrivateAccessor ? 'privateAccessorGetSetTraceHash' : undefined,
+    hasStaticPrivate ? 'staticPrivateMemberAccessTraceHash' : undefined,
+    hasPrivateIdentifier && hasClassHeritage ? 'subclassPrivateBrandBoundaryTraceHash' : undefined,
+    counts.accessorFieldCount > 0 ? 'accessorInitializationTraceHash' : undefined,
+    counts.accessorFieldCount > 0 ? 'accessorGetSetTraceHash' : undefined,
+    counts.accessorFieldCount > 0 ? 'accessorDescriptorTraceHash' : undefined
+  ].filter(Boolean);
+}
+
+function classPrivateAccessorRuntimeTraceHashes(proof, value, counts) {
+  const required = new Set(requiredClassPrivateAccessorRuntimeTraceHashKeys(value, counts));
+  return compactRecord({
+    classConstructionOrderTraceHash: proof.classConstructionOrderTraceHash,
+    privateMemberInitializationTraceHash: required.has('privateMemberInitializationTraceHash') ? proof.privateMemberInitializationTraceHash : undefined,
+    privateMemberAccessTraceHash: required.has('privateMemberAccessTraceHash') ? proof.privateMemberAccessTraceHash : undefined,
+    privateBrandCheckTraceHash: required.has('privateBrandCheckTraceHash') ? proof.privateBrandCheckTraceHash : undefined,
+    privateMethodCallTraceHash: required.has('privateMethodCallTraceHash') ? proof.privateMethodCallTraceHash : undefined,
+    privateAccessorGetSetTraceHash: required.has('privateAccessorGetSetTraceHash') ? proof.privateAccessorGetSetTraceHash : undefined,
+    staticPrivateMemberAccessTraceHash: required.has('staticPrivateMemberAccessTraceHash') ? proof.staticPrivateMemberAccessTraceHash : undefined,
+    subclassPrivateBrandBoundaryTraceHash: required.has('subclassPrivateBrandBoundaryTraceHash') ? proof.subclassPrivateBrandBoundaryTraceHash : undefined,
+    accessorInitializationTraceHash: required.has('accessorInitializationTraceHash') ? proof.accessorInitializationTraceHash : undefined,
+    accessorGetSetTraceHash: required.has('accessorGetSetTraceHash') ? proof.accessorGetSetTraceHash : undefined,
+    accessorDescriptorTraceHash: required.has('accessorDescriptorTraceHash') ? proof.accessorDescriptorTraceHash : undefined
+  });
+}
+
+function classPrivateAccessorRuntimeRequiredSignals(value, counts) {
+  return uniqueStrings([
+    'compiler-public-api-source-path',
+    'compiler-public-api-source-hash',
+    counts.privateClassMemberCount > 0 ? 'compiler-private-class-member-count' : undefined,
+    counts.privateClassMemberCount > 0 ? 'compiler-private-class-member-shape-hash' : undefined,
+    counts.accessorFieldCount > 0 ? 'compiler-accessor-field-count' : undefined,
+    counts.accessorFieldCount > 0 ? 'compiler-accessor-field-shape-hash' : undefined,
+    ...requiredClassPrivateAccessorRuntimeTraceHashKeys(value, counts).map((key) => TraceHashSignalsByKey[key]),
+    'runtime-command',
+    'runtime-trace-hash',
+    'runtime-evidence-hash'
+  ]);
+}
+
+function classPrivateAccessorRuntimeRequired(counts) {
+  return counts.privateClassMemberCount > 0 || counts.accessorFieldCount > 0;
+}
+
+function privateClassMembers(value) { return arrayValue(value.privateClassMembers); }
+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))]; }
+function numberValue(value) { return Number.isFinite(value) ? value : undefined; }
+function stringValue(value) { return value === undefined || value === null || value === '' ? undefined : String(value); }
+function containsAllStrings(actual, expected) {
+  const actualSet = new Set(arrayValue(actual).filter((value) => typeof value === 'string' && value.length > 0));
+  return expected.every((value) => actualSet.has(value));
+}
+
+export {
+  classPrivateAccessorRuntimeHash,
+  classPrivateAccessorRuntimeProjection,
+  classPrivateAccessorRuntimeProofBinding,
+  classPrivateAccessorRuntimeRequiredSignals
+};

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

@@ -0,0 +1,103 @@
+import { hashSemanticValue } from '@shapeshift-labs/frontier-lang-kernel';
+
+const ClassPrivateAccessorShapeProofKind = 'typescript-checker-public-api-class-private-accessor-shape-equivalence';
+
+function classShapeSetHashes(value, counts) {
+  return compactRecord({
+    privateClassMemberSetHash: counts.privateClassMemberCount > 0
+      ? hashSemanticValue({ kind: 'frontier.lang.typescript.compilerPrivateClassMemberSetEquivalence.v1', privateClassMembers: canonicalMemberRecords(value.privateClassMembers) })
+      : undefined,
+    accessorFieldSetHash: counts.accessorFieldCount > 0
+      ? hashSemanticValue({ kind: 'frontier.lang.typescript.compilerAccessorFieldSetEquivalence.v1', accessorFieldMembers: canonicalMemberRecords(value.accessorFieldMembers) })
+      : undefined
+  });
+}
+
+function classShapeUnsupportedReasonCodes(counts) {
+  return [
+    counts.privateClassMemberCount > 0 ? 'typescript-private-class-member-shape-equivalence-unproven' : undefined,
+    counts.accessorFieldCount > 0 ? 'typescript-accessor-field-shape-equivalence-unproven' : undefined
+  ].filter(Boolean);
+}
+
+function classShapeProofKind(counts) {
+  return counts.privateClassMemberCount > 0 || counts.accessorFieldCount > 0 ? ClassPrivateAccessorShapeProofKind : undefined;
+}
+
+function classShapeProofLevel(counts) {
+  const levels = [];
+  if (counts.privateClassMemberCount > 0) levels.push('private-class-member-set');
+  if (counts.accessorFieldCount > 0) levels.push('accessor-field-set');
+  return levels.length ? levels.join('-and-') : undefined;
+}
+
+function classShapeCheckerInvariant(counts) {
+  const invariants = [];
+  if (counts.privateClassMemberCount > 0) invariants.push('private class member names/kinds/types complete');
+  if (counts.accessorFieldCount > 0) invariants.push('accessor field names/types/modifiers complete');
+  return invariants.join('; ');
+}
+
+function classShapeRequiredSignals(counts) {
+  return [
+    counts.privateClassMemberCount > 0 ? 'compiler-private-class-member-count' : undefined,
+    counts.privateClassMemberCount > 0 ? 'compiler-private-class-member-names' : undefined,
+    counts.privateClassMemberCount > 0 ? 'compiler-private-class-member-type-or-signature-texts' : undefined,
+    counts.privateClassMemberCount > 0 ? 'compiler-private-class-member-shape-hash' : undefined,
+    counts.accessorFieldCount > 0 ? 'compiler-accessor-field-count' : undefined,
+    counts.accessorFieldCount > 0 ? 'compiler-accessor-field-names' : undefined,
+    counts.accessorFieldCount > 0 ? 'compiler-accessor-field-type-texts' : undefined,
+    counts.accessorFieldCount > 0 ? 'compiler-accessor-field-shape-hash' : undefined
+  ].filter(Boolean);
+}
+
+function missingClassShapeEquivalenceSignals(value, counts, checkerEvidence) {
+  const missing = [];
+  if (counts.privateClassMemberCount > 0 && checkerEvidence.privateClassMemberNames.length !== counts.privateClassMemberCount) missing.push('compiler-private-class-member-count');
+  if (counts.privateClassMemberCount > 0 && checkerEvidence.privateClassMemberNames.some((text) => !text)) missing.push('compiler-private-class-member-names');
+  if (counts.privateClassMemberCount > 0 && checkerEvidence.privateClassMemberTypeOrSignatureTexts.some((text) => !text)) missing.push('compiler-private-class-member-type-or-signature-texts');
+  if (counts.privateClassMemberCount > 0 && !value.privateClassMemberShapeHash) missing.push('compiler-private-class-member-shape-hash');
+  if (counts.accessorFieldCount > 0 && checkerEvidence.accessorFieldNames.length !== counts.accessorFieldCount) missing.push('compiler-accessor-field-count');
+  if (counts.accessorFieldCount > 0 && checkerEvidence.accessorFieldNames.some((text) => !text)) missing.push('compiler-accessor-field-names');
+  if (counts.accessorFieldCount > 0 && checkerEvidence.accessorFieldTypeTexts.some((text) => !text)) missing.push('compiler-accessor-field-type-texts');
+  if (counts.accessorFieldCount > 0 && !value.accessorFieldShapeHash) missing.push('compiler-accessor-field-shape-hash');
+  return uniqueStrings(missing);
+}
+
+function classShapeCheckerEvidence(value, counts) {
+  const privateClassMembers = arrayValue(value.privateClassMembers);
+  const accessorFieldMembers = arrayValue(value.accessorFieldMembers);
+  return compactRecord({
+    privateClassMemberCount: counts.privateClassMemberCount || undefined,
+    privateClassMemberNames: privateClassMembers.map((member) => member.name),
+    privateClassMemberKinds: privateClassMembers.map((member) => member.kind),
+    privateClassMemberTypeOrSignatureTexts: privateClassMembers.map((member) => member.typeText ?? member.signatureText),
+    privateClassMemberShapeHash: value.privateClassMemberShapeHash,
+    accessorFieldCount: counts.accessorFieldCount || undefined,
+    accessorFieldNames: accessorFieldMembers.map((member) => member.name),
+    accessorFieldTypeTexts: accessorFieldMembers.map((member) => member.typeText),
+    accessorFieldShapeHash: value.accessorFieldShapeHash,
+    privateClassMembers: nonEmptyArray(privateClassMembers),
+    accessorFieldMembers: nonEmptyArray(accessorFieldMembers)
+  });
+}
+
+function canonicalMemberRecords(records) {
+  return arrayValue(records).map(({ memberText: _memberText, ...record }) => record);
+}
+
+function arrayValue(value) { return 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 {
+  classShapeCheckerEvidence,
+  classShapeCheckerInvariant,
+  classShapeProofKind,
+  classShapeProofLevel,
+  classShapeRequiredSignals,
+  classShapeSetHashes,
+  classShapeUnsupportedReasonCodes,
+  missingClassShapeEquivalenceSignals
+};

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

@@ -0,0 +1,242 @@
+import { hashSemanticValue } from '@shapeshift-labs/frontier-lang-kernel';
+
+const AdvancedTypeShapeEquivalenceProofKind = 'typescript-checker-public-api-advanced-type-shape-unsupported';
+const AdvancedTypeShapeSetEquivalenceProofKind = 'typescript-checker-public-api-advanced-type-shape-set-equivalence';
+const ConditionalTypeEquivalenceProofKind = 'typescript-checker-public-api-conditional-type-shape-equivalence';
+const IndexedAccessTypeEquivalenceProofKind = 'typescript-checker-public-api-indexed-access-type-shape-equivalence';
+const InferTypeEquivalenceProofKind = 'typescript-checker-public-api-infer-type-shape-equivalence';
+const KeyofTypeOperatorEquivalenceProofKind = 'typescript-checker-public-api-keyof-type-operator-shape-equivalence';
+const MappedTypeEquivalenceProofKind = 'typescript-checker-public-api-mapped-type-shape-equivalence';
+const TemplateLiteralTypeEquivalenceProofKind = 'typescript-checker-public-api-template-literal-type-shape-equivalence';
+const UnionTypeEquivalenceProofKind = 'typescript-checker-public-api-union-type-shape-equivalence';
+const IntersectionTypeEquivalenceProofKind = 'typescript-checker-public-api-intersection-type-shape-equivalence';
+const TupleTypeEquivalenceProofKind = 'typescript-checker-public-api-tuple-type-shape-equivalence';
+
+const ShapeSpecs = [
+  shapeSpec('conditional-type', 'conditionalType', 'conditionalTypeCount', ConditionalTypeEquivalenceProofKind, 'conditional-type-set', 'conditional branch texts complete', 'conditionalTypeSetHash', 'frontier.lang.typescript.compilerConditionalTypeSetEquivalence.v1', 'conditionalTypes', [
+    field('nodeText', 'NodeTexts', 'compiler-conditional-type-node-texts'),
+    field('typeText', 'TypeTexts', 'compiler-conditional-type-type-texts'),
+    field('checkTypeText', 'CheckTypeTexts', 'compiler-conditional-type-check-type-texts'),
+    field('extendsTypeText', 'ExtendsTypeTexts', 'compiler-conditional-type-extends-type-texts'),
+    field('trueTypeText', 'TrueTypeTexts', 'compiler-conditional-type-true-type-texts'),
+    field('falseTypeText', 'FalseTypeTexts', 'compiler-conditional-type-false-type-texts')
+  ]),
+  shapeSpec('indexed-access-type', 'indexedAccessType', 'indexedAccessTypeCount', IndexedAccessTypeEquivalenceProofKind, 'indexed-access-type-set', 'indexed access texts complete', 'indexedAccessTypeSetHash', 'frontier.lang.typescript.compilerIndexedAccessTypeSetEquivalence.v1', 'indexedAccessTypes', [
+    field('nodeText', 'NodeTexts', 'compiler-indexed-access-type-node-texts'),
+    field('typeText', 'TypeTexts', 'compiler-indexed-access-type-type-texts'),
+    field('objectTypeText', 'ObjectTypeTexts', 'compiler-indexed-access-type-object-type-texts'),
+    field('indexTypeText', 'IndexTypeTexts', 'compiler-indexed-access-type-index-type-texts')
+  ]),
+  shapeSpec('mapped-type', 'mappedType', 'mappedTypeCount', MappedTypeEquivalenceProofKind, 'mapped-type-set', 'mapped type texts complete', 'mappedTypeSetHash', 'frontier.lang.typescript.compilerMappedTypeSetEquivalence.v1', 'mappedTypes', [
+    field('nodeText', 'NodeTexts', 'compiler-mapped-type-node-texts'),
+    field('typeText', 'TypeTexts', 'compiler-mapped-type-type-texts'),
+    field('mappedConstraintTypeText', 'ConstraintTypeTexts', 'compiler-mapped-type-constraint-type-texts'),
+    field('mappedValueTypeText', 'ValueTypeTexts', 'compiler-mapped-type-value-type-texts')
+  ]),
+  shapeSpec('keyof-type-operator', 'keyofTypeOperator', 'keyofTypeOperatorCount', KeyofTypeOperatorEquivalenceProofKind, 'keyof-type-operator-set', 'keyof target texts complete', 'keyofTypeOperatorSetHash', 'frontier.lang.typescript.compilerKeyofTypeOperatorSetEquivalence.v1', 'keyofTypeOperators', [
+    field('nodeText', 'NodeTexts', 'compiler-keyof-type-operator-node-texts'),
+    field('typeText', 'TypeTexts', 'compiler-keyof-type-operator-type-texts'),
+    field('keyofTargetTypeText', 'TargetTypeTexts', 'compiler-keyof-type-operator-target-type-texts')
+  ]),
+  shapeSpec('template-literal-type', 'templateLiteralType', 'templateLiteralTypeCount', TemplateLiteralTypeEquivalenceProofKind, 'template-literal-type-set', 'template literal type span texts complete', 'templateLiteralTypeSetHash', 'frontier.lang.typescript.compilerTemplateLiteralTypeSetEquivalence.v1', 'templateLiteralTypes', [
+    field('nodeText', 'NodeTexts', 'compiler-template-literal-type-node-texts'),
+    field('typeText', 'TypeTexts', 'compiler-template-literal-type-type-texts'),
+    field('templateHeadText', 'HeadTexts', 'compiler-template-literal-type-head-texts'),
+    field('templateSpanTexts', 'SpanTexts', 'compiler-template-literal-type-span-texts'),
+    field('templateSpanTypeTexts', 'SpanTypeTexts', 'compiler-template-literal-type-span-type-texts'),
+    field('templateLiteralTexts', 'LiteralTexts', 'compiler-template-literal-type-literal-texts')
+  ]),
+  shapeSpec('infer-type', 'inferType', 'inferTypeCount', InferTypeEquivalenceProofKind, 'infer-type-set', 'infer type parameter texts complete', 'inferTypeSetHash', 'frontier.lang.typescript.compilerInferTypeSetEquivalence.v1', 'inferTypes', [
+    field('nodeText', 'NodeTexts', 'compiler-infer-type-node-texts'),
+    field('typeText', 'TypeTexts', 'compiler-infer-type-type-texts'),
+    field('typeParameterText', 'TypeParameterTexts', 'compiler-infer-type-type-parameter-texts'),
+    field('typeParameterName', 'TypeParameterNames', 'compiler-infer-type-type-parameter-names')
+  ]),
+  shapeSpec('union-type', 'unionType', 'unionTypeCount', UnionTypeEquivalenceProofKind, 'union-type-set', 'union member type texts complete', 'unionTypeSetHash', 'frontier.lang.typescript.compilerUnionTypeSetEquivalence.v1', 'unionTypes', [
+    field('nodeText', 'NodeTexts', 'compiler-union-type-node-texts'),
+    field('typeText', 'TypeTexts', 'compiler-union-type-type-texts'),
+    field('memberTypeTexts', 'MemberTypeTexts', 'compiler-union-type-member-type-texts')
+  ]),
+  shapeSpec('intersection-type', 'intersectionType', 'intersectionTypeCount', IntersectionTypeEquivalenceProofKind, 'intersection-type-set', 'intersection member type texts complete', 'intersectionTypeSetHash', 'frontier.lang.typescript.compilerIntersectionTypeSetEquivalence.v1', 'intersectionTypes', [
+    field('nodeText', 'NodeTexts', 'compiler-intersection-type-node-texts'),
+    field('typeText', 'TypeTexts', 'compiler-intersection-type-type-texts'),
+    field('memberTypeTexts', 'MemberTypeTexts', 'compiler-intersection-type-member-type-texts')
+  ]),
+  shapeSpec('tuple-type', 'tupleType', 'tupleTypeCount', TupleTypeEquivalenceProofKind, 'tuple-type-set', 'tuple element texts complete', 'tupleTypeSetHash', 'frontier.lang.typescript.compilerTupleTypeSetEquivalence.v1', 'tupleTypes', [
+    field('nodeText', 'NodeTexts', 'compiler-tuple-type-node-texts'),
+    field('typeText', 'TypeTexts', 'compiler-tuple-type-type-texts'),
+    field('tupleElementTexts', 'ElementTexts', 'compiler-tuple-type-element-texts'),
+    field('tupleElementTypeTexts', 'ElementTypeTexts', 'compiler-tuple-type-element-type-texts')
+  ])
+];
+const ShapeSpecByKind = new Map(ShapeSpecs.map((spec) => [spec.kind, spec]));
+
+function advancedTypeSetHashes(value, counts) {
+  return compactRecord(Object.fromEntries(ShapeSpecs.map((spec) => [spec.hashKey, shapeSetHash(value, counts, spec)])));
+}
+
+function advancedTypeProofKind(counts) {
+  const spec = soleEligibleSpec(counts);
+  if (spec) return spec.proofKind;
+  if (counts.advancedTypeShapeCount > 0 && !advancedTypeUnsupportedReasonCodes(counts).length) return AdvancedTypeShapeSetEquivalenceProofKind;
+  return counts.advancedTypeShapeCount > 0 ? AdvancedTypeShapeEquivalenceProofKind : undefined;
+}
+
+function advancedTypeProofLevel(counts) {
+  const spec = soleEligibleSpec(counts);
+  if (spec) return spec.proofLevel;
+  if (counts.advancedTypeShapeCount > 0 && !advancedTypeUnsupportedReasonCodes(counts).length) return 'advanced-type-shape-set';
+  return counts.advancedTypeShapeCount > 0 ? 'advanced-type-shape-fail-closed' : undefined;
+}
+
+function advancedTypeCheckerInvariant(counts) {
+  const spec = soleEligibleSpec(counts);
+  if (spec) return spec.invariant;
+  if (counts.advancedTypeShapeCount > 0 && !advancedTypeUnsupportedReasonCodes(counts).length) return 'advanced type shape texts complete';
+  return counts.advancedTypeShapeCount > 0 ? 'unsupported shapes fail closed' : undefined;
+}
+
+function advancedTypeRequiredSignals(counts) { return ShapeSpecs.flatMap((spec) => shapeRequiredSignals(counts, spec)); }
+function missingAdvancedTypeEquivalenceSignals(value, counts) { return uniqueStrings(ShapeSpecs.flatMap((spec) => missingShapeEquivalenceSignals(value, counts, spec))); }
+function advancedTypeCheckerEvidence(value) { return compactRecord(Object.assign({}, ...ShapeSpecs.map((spec) => shapeEvidenceForSpec(value, spec)))); }
+function advancedTypeUnsupportedReasonCodes(counts) {
+  return counts.advancedTypeShapeCount > knownAdvancedTypeShapeCount(counts)
+    ? ['typescript-unknown-advanced-type-shape-public-api-equivalence-unsupported']
+    : [];
+}
+function advancedTypeUnsupportedSignals(counts) {
+  return advancedTypeUnsupportedReasonCodes(counts).map((reasonCode) => reasonCode.replace(/^typescript-/, '').replace(/-unsupported$/, ''));
+}
+
+function isConditionalTypeEquivalenceEligible(counts) { return soleEligibleKind(counts, 'conditional-type'); }
+function isIndexedAccessTypeEquivalenceEligible(counts) { return soleEligibleKind(counts, 'indexed-access-type'); }
+function isMappedTypeEquivalenceEligible(counts) { return soleEligibleKind(counts, 'mapped-type'); }
+function isKeyofTypeOperatorEquivalenceEligible(counts) { return soleEligibleKind(counts, 'keyof-type-operator'); }
+function isTemplateLiteralTypeEquivalenceEligible(counts) { return soleEligibleKind(counts, 'template-literal-type'); }
+function isInferTypeEquivalenceEligible(counts) { return soleEligibleKind(counts, 'infer-type'); }
+
+function conditionalTypeSetHash(value, counts) { return shapeSetHash(value, counts, specFor('conditional-type')); }
+function indexedAccessTypeSetHash(value, counts) { return shapeSetHash(value, counts, specFor('indexed-access-type')); }
+function mappedTypeSetHash(value, counts) { return shapeSetHash(value, counts, specFor('mapped-type')); }
+function keyofTypeOperatorSetHash(value, counts) { return shapeSetHash(value, counts, specFor('keyof-type-operator')); }
+function templateLiteralTypeSetHash(value, counts) { return shapeSetHash(value, counts, specFor('template-literal-type')); }
+function inferTypeSetHash(value, counts) { return shapeSetHash(value, counts, specFor('infer-type')); }
+
+function conditionalTypeRequiredSignals(counts) { return shapeRequiredSignals(counts, specFor('conditional-type')); }
+function indexedAccessTypeRequiredSignals(counts) { return shapeRequiredSignals(counts, specFor('indexed-access-type')); }
+function mappedTypeRequiredSignals(counts) { return shapeRequiredSignals(counts, specFor('mapped-type')); }
+function keyofTypeOperatorRequiredSignals(counts) { return shapeRequiredSignals(counts, specFor('keyof-type-operator')); }
+function templateLiteralTypeRequiredSignals(counts) { return shapeRequiredSignals(counts, specFor('template-literal-type')); }
+function inferTypeRequiredSignals(counts) { return shapeRequiredSignals(counts, specFor('infer-type')); }
+
+function missingConditionalTypeEquivalenceSignals(value, counts) { return missingShapeEquivalenceSignals(value, counts, specFor('conditional-type')); }
+function missingIndexedAccessTypeEquivalenceSignals(value, counts) { return missingShapeEquivalenceSignals(value, counts, specFor('indexed-access-type')); }
+function missingMappedTypeEquivalenceSignals(value, counts) { return missingShapeEquivalenceSignals(value, counts, specFor('mapped-type')); }
+function missingKeyofTypeOperatorEquivalenceSignals(value, counts) { return missingShapeEquivalenceSignals(value, counts, specFor('keyof-type-operator')); }
+function missingTemplateLiteralTypeEquivalenceSignals(value, counts) { return missingShapeEquivalenceSignals(value, counts, specFor('template-literal-type')); }
+function missingInferTypeEquivalenceSignals(value, counts) { return missingShapeEquivalenceSignals(value, counts, specFor('infer-type')); }
+
+function conditionalTypeCheckerEvidence(value) { return shapeEvidenceForSpec(value, specFor('conditional-type')); }
+function indexedAccessTypeCheckerEvidence(value) { return shapeEvidenceForSpec(value, specFor('indexed-access-type')); }
+function mappedTypeCheckerEvidence(value) { return shapeEvidenceForSpec(value, specFor('mapped-type')); }
+function keyofTypeOperatorCheckerEvidence(value) { return shapeEvidenceForSpec(value, specFor('keyof-type-operator')); }
+function templateLiteralTypeCheckerEvidence(value) { return shapeEvidenceForSpec(value, specFor('template-literal-type')); }
+function inferTypeCheckerEvidence(value) { return shapeEvidenceForSpec(value, specFor('infer-type')); }
+
+function shapeSetHash(value, counts, spec) {
+  if (!counts[spec.countKey] || missingShapeEquivalenceSignals(value, counts, spec).length) return undefined;
+  return hashSemanticValue({ kind: spec.hashKind, [spec.hashArrayKey]: shapesOfKind(value, spec.kind).map((shape) => canonicalShape(shape, spec)) });
+}
+function shapeRequiredSignals(counts, spec) { return counts[spec.countKey] ? [spec.countSignal, ...spec.fields.map((item) => item.signal)] : []; }
+function missingShapeEquivalenceSignals(value, counts, spec) {
+  if (!counts[spec.countKey]) return [];
+  return missingShapeSignals(shapesOfKind(value, spec.kind), counts[spec.countKey], spec.fields, spec.countSignal);
+}
+function missingShapeSignals(shapes, count, fields, countSignal) {
+  const missing = [];
+  if (shapes.length !== count) missing.push(countSignal);
+  for (const item of fields) if (shapes.some((shape) => fieldMissing(shape?.[item.key]))) missing.push(item.signal);
+  return uniqueStrings(missing);
+}
+function fieldMissing(value) {
+  if (Array.isArray(value)) return !value.length || value.some((item) => item === undefined || item === null);
+  return value === undefined || value === null;
+}
+function shapeEvidenceForSpec(value, spec) {
+  const shapes = shapesOfKind(value, spec.kind);
+  if (!shapes.length) return {};
+  return Object.fromEntries(spec.fields.map((item) => [
+    `${spec.evidencePrefix}${item.evidenceSuffix}`,
+    shapes.map((shape) => shape[item.key]).filter((fieldValue) => fieldValue !== undefined && fieldValue !== null)
+  ]));
+}
+function canonicalShape(shape, spec) { return Object.fromEntries(['kind', ...spec.fields.map((item) => item.key)].map((key) => [key, shape?.[key]])); }
+function soleEligibleSpec(counts) {
+  if (!counts.advancedTypeShapeCount) return undefined;
+  return ShapeSpecs.find((spec) => counts[spec.countKey] === counts.advancedTypeShapeCount && ShapeSpecs.every((other) => other === spec || !counts[other.countKey]));
+}
+function soleEligibleKind(counts, kind) { return soleEligibleSpec(counts)?.kind === kind; }
+function shapesOfKind(value, kind) { return arrayValue(value.advancedTypeShapes).filter((shape) => shape?.kind === kind); }
+function knownAdvancedTypeShapeCount(counts) { return ShapeSpecs.reduce((sum, spec) => sum + (counts[spec.countKey] || 0), 0); }
+function specFor(kind) { return ShapeSpecByKind.get(kind); }
+function shapeSpec(kind, evidencePrefix, countKey, proofKind, proofLevel, invariant, hashKey, hashKind, hashArrayKey, fields) {
+  return { kind, evidencePrefix, countKey, countSignal: countSignal(kind), proofKind, proofLevel, invariant, hashKey, hashKind, hashArrayKey, fields };
+}
+function countSignal(kind) { return `compiler-${kind}-count`; }
+function field(key, evidenceSuffix, signal) { return { key, evidenceSuffix, signal }; }
+function arrayValue(value) { return Array.isArray(value) ? value : []; }
+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 {
+  AdvancedTypeShapeEquivalenceProofKind,
+  AdvancedTypeShapeSetEquivalenceProofKind,
+  ConditionalTypeEquivalenceProofKind,
+  IndexedAccessTypeEquivalenceProofKind,
+  InferTypeEquivalenceProofKind,
+  KeyofTypeOperatorEquivalenceProofKind,
+  MappedTypeEquivalenceProofKind,
+  TemplateLiteralTypeEquivalenceProofKind,
+  TupleTypeEquivalenceProofKind,
+  UnionTypeEquivalenceProofKind,
+  IntersectionTypeEquivalenceProofKind,
+  advancedTypeCheckerEvidence,
+  advancedTypeCheckerInvariant,
+  advancedTypeProofKind,
+  advancedTypeProofLevel,
+  advancedTypeRequiredSignals,
+  advancedTypeSetHashes,
+  advancedTypeUnsupportedReasonCodes,
+  advancedTypeUnsupportedSignals,
+  conditionalTypeCheckerEvidence,
+  conditionalTypeRequiredSignals,
+  conditionalTypeSetHash,
+  indexedAccessTypeCheckerEvidence,
+  indexedAccessTypeRequiredSignals,
+  indexedAccessTypeSetHash,
+  inferTypeCheckerEvidence,
+  inferTypeRequiredSignals,
+  inferTypeSetHash,
+  isConditionalTypeEquivalenceEligible,
+  isIndexedAccessTypeEquivalenceEligible,
+  isInferTypeEquivalenceEligible,
+  isKeyofTypeOperatorEquivalenceEligible,
+  isMappedTypeEquivalenceEligible,
+  isTemplateLiteralTypeEquivalenceEligible,
+  keyofTypeOperatorCheckerEvidence,
+  keyofTypeOperatorRequiredSignals,
+  keyofTypeOperatorSetHash,
+  mappedTypeCheckerEvidence,
+  mappedTypeRequiredSignals,
+  mappedTypeSetHash,
+  missingAdvancedTypeEquivalenceSignals,
+  missingConditionalTypeEquivalenceSignals,
+  missingIndexedAccessTypeEquivalenceSignals,
+  missingInferTypeEquivalenceSignals,
+  missingKeyofTypeOperatorEquivalenceSignals,
+  missingMappedTypeEquivalenceSignals,
+  missingTemplateLiteralTypeEquivalenceSignals,
+  templateLiteralTypeCheckerEvidence,
+  templateLiteralTypeRequiredSignals,
+  templateLiteralTypeSetHash
+};