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

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

@@ -0,0 +1,232 @@
+import { hashSemanticValue } from '@shapeshift-labs/frontier-lang-kernel';
+
+export function moduleImportAttributeMetadata(node) {
+  const entries = [
+    ...attributeListEntries(node?.attributes),
+    ...attributeListEntries(node?.assertions),
+    ...assertClauseEntries(node?.assertClause),
+    ...importCallOptionEntries(node?.options),
+    ...importCallOptionEntries(Array.isArray(node?.arguments) ? node.arguments[1] : undefined)
+  ];
+  return importAttributeMetadataFromEntries(entries, hasImportAttributeSyntax(node));
+}
+
+export function importAttributeMetadataFromSource(source) {
+  const scan = scanImportAttributeSource(source);
+  return importAttributeMetadataFromEntries(scan.entries, scan.syntaxPresent);
+}
+
+function importAttributeMetadataFromEntries(entries, syntaxPresent) {
+  const normalized = normalizeEntries(entries);
+  if (!normalized.length && syntaxPresent) return { hasImportAttributes: true };
+  if (!normalized.length) return {};
+  const keys = [...new Set(normalized.map((entry) => entry.key))].sort();
+  return {
+    hasImportAttributes: true,
+    importAttributeCount: normalized.length,
+    importAttributeKeys: keys,
+    importAttributeHash: hashSemanticValue(normalized.map((entry) => [entry.key, entry.value])),
+    importAttributes: normalized
+  };
+}
+
+function scanImportAttributeSource(source) {
+  const text = String(source ?? '');
+  const clauseBodies = attributeClauseBodies(text);
+  const optionBodies = ['with', 'assert'].flatMap((key) => attributeOptionBodies(text, key));
+  return {
+    syntaxPresent: clauseBodies.length > 0 || optionBodies.length > 0,
+    entries: [...clauseBodies, ...optionBodies].flatMap((body) => sourceAttributeEntries(body))
+  };
+}
+
+function attributeClauseBodies(source) {
+  const bodies = [];
+  const pattern = /\b(?:with|assert)\s*\{/g;
+  for (let match = pattern.exec(source); match; match = pattern.exec(source)) {
+    const open = source.indexOf('{', match.index);
+    const close = matchingBraceIndex(source, open);
+    if (close >= 0) {
+      bodies.push(source.slice(open + 1, close));
+      pattern.lastIndex = close + 1;
+    }
+  }
+  return bodies;
+}
+
+function attributeOptionBodies(source, key) {
+  const bodies = [];
+  const pattern = new RegExp(`(?:^|[,{])\\s*(?:${key}|["']${key}["'])\\s*:\\s*\\{`, 'g');
+  for (let match = pattern.exec(source); match; match = pattern.exec(source)) {
+    const open = pattern.lastIndex - 1;
+    const close = matchingBraceIndex(source, open);
+    if (close >= 0) {
+      bodies.push(source.slice(open + 1, close));
+      pattern.lastIndex = close + 1;
+    }
+  }
+  return bodies;
+}
+
+function matchingBraceIndex(source, open) {
+  if (open < 0) return -1;
+  let depth = 0, quote = '', escaped = false;
+  for (let index = open; index < source.length; index += 1) {
+    const char = source[index];
+    if (quote) {
+      if (escaped) escaped = false;
+      else if (char === '\\') escaped = true;
+      else if (char === quote) quote = '';
+    } else if (char === '"' || char === "'") quote = char;
+    else if (char === '{') depth += 1;
+    else if (char === '}' && --depth === 0) return index;
+  }
+  return -1;
+}
+
+function sourceAttributeEntries(body) {
+  return splitTopLevelCommas(body).map((part) => {
+    const colon = part.indexOf(':');
+    if (colon < 0) return undefined;
+    const key = sourcePropertyKey(part.slice(0, colon).trim());
+    const value = sourceStringLiteral(part.slice(colon + 1).trim());
+    return key && value !== undefined ? { key, value } : undefined;
+  }).filter(Boolean);
+}
+
+function splitTopLevelCommas(source) {
+  const parts = [];
+  let start = 0, quote = '', escaped = false;
+  for (let index = 0; index < source.length; index += 1) {
+    const char = source[index];
+    if (quote) {
+      if (escaped) escaped = false;
+      else if (char === '\\') escaped = true;
+      else if (char === quote) quote = '';
+    } else if (char === '"' || char === "'") quote = char;
+    else if (char === ',') {
+      parts.push(source.slice(start, index));
+      start = index + 1;
+    }
+  }
+  parts.push(source.slice(start));
+  return parts;
+}
+
+function sourcePropertyKey(text) {
+  return sourceStringLiteral(text) ?? text.match(/^[A-Za-z_$][\w$]*$/)?.[0];
+}
+
+function sourceStringLiteral(text) {
+  const quote = text[0];
+  if (quote !== '"' && quote !== "'") return undefined;
+  let value = '', escaped = false;
+  for (let index = 1; index < text.length; index += 1) {
+    const char = text[index];
+    if (escaped) {
+      value += decodeEscape(char);
+      escaped = false;
+    } else if (char === '\\') escaped = true;
+    else if (char === quote) return value;
+    else value += char;
+  }
+  return undefined;
+}
+
+function decodeEscape(char) {
+  return ({ n: '\n', r: '\r', t: '\t', b: '\b', f: '\f', v: '\v', 0: '\0' })[char] ?? char;
+}
+
+export function moduleImportAttributeEdgeFields(metadata) {
+  return compactRecord({
+    hasImportAttributes: metadata?.hasImportAttributes,
+    importAttributeCount: metadata?.importAttributeCount,
+    importAttributeKeys: metadata?.importAttributeKeys,
+    importAttributeHash: metadata?.importAttributeHash,
+    importAttributes: metadata?.importAttributes
+  });
+}
+
+function attributeListEntries(list) {
+  const entries = Array.isArray(list) ? list : Array.isArray(list?.elements) ? list.elements : [];
+  return entries.map((entry) => attributeEntry(entry)).filter(Boolean);
+}
+
+function assertClauseEntries(assertClause) {
+  return attributeListEntries(assertClause?.elements);
+}
+
+function attributeEntry(entry) {
+  const key = propertyKeyName(entry?.key ?? entry?.name);
+  const value = literalString(entry?.value ?? entry?.initializer);
+  return key && value !== undefined ? { key, value } : undefined;
+}
+
+function importCallOptionEntries(options) {
+  const object = objectProperties(options);
+  if (!object.length) return [];
+  const attributes = [];
+  for (const property of object) {
+    const key = propertyKeyName(property.key ?? property.name);
+    if (key !== 'with' && key !== 'assert') continue;
+    for (const nested of objectProperties(property.value ?? property.initializer)) {
+      const nestedKey = propertyKeyName(nested.key ?? nested.name);
+      const nestedValue = literalString(nested.value ?? nested.initializer);
+      if (nestedKey && nestedValue !== undefined) attributes.push({ key: nestedKey, value: nestedValue });
+    }
+  }
+  return attributes;
+}
+
+function objectProperties(node) {
+  if (!node) return [];
+  if (Array.isArray(node.properties)) return node.properties;
+  if (typeof node.with === 'object') return [{ key: { name: 'with' }, value: node.with }];
+  if (typeof node.assert === 'object') return [{ key: { name: 'assert' }, value: node.assert }];
+  return [];
+}
+
+function propertyKeyName(node) {
+  if (!node) return undefined;
+  if (typeof node.name === 'string') return node.name;
+  if (typeof node.text === 'string') return node.text;
+  if (typeof node.value === 'string') return node.value;
+  if (typeof node.escapedText === 'string') return node.escapedText;
+  return undefined;
+}
+
+function literalString(node) {
+  if (!node) return undefined;
+  if (typeof node.value === 'string') return node.value;
+  if (typeof node.text === 'string') return node.text;
+  if (typeof node.escapedText === 'string') return node.escapedText;
+  return undefined;
+}
+
+function normalizeEntries(entries) {
+  const seen = new Set();
+  return entries
+    .filter((entry) => entry?.key && entry.value !== undefined)
+    .map((entry) => ({ key: entry.key, value: entry.value }))
+    .sort((left, right) => left.key.localeCompare(right.key) || left.value.localeCompare(right.value))
+    .filter((entry) => {
+      const id = `${entry.key}\0${entry.value}`;
+      if (seen.has(id)) return false;
+      seen.add(id);
+      return true;
+    });
+}
+
+function hasImportAttributeSyntax(node) {
+  return Boolean(
+    node?.attributes
+    || node?.assertions
+    || node?.assertClause
+    || node?.options
+    || (Array.isArray(node?.arguments) && node.arguments.length > 1)
+  );
+}
+
+function compactRecord(record) {
+  return Object.fromEntries(Object.entries(record).filter(([, value]) => value !== undefined));
+}

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

@@ -86,6 +86,9 @@ export function projectSemanticEditScriptToSource(input = {}) {
       alreadyAppliedEditCount: deduped.edits.filter((edit) => edit.alreadyApplied).length,
       dedupedEditCount: deduped.skippedOperationIds.length,
       anchorMode: headSymbols.length ? 'javascript-like-symbols' : 'offsets',
+      structuralDiffId: script.structuralDiff?.id,
+      structuralDiffStatus: script.structuralDiff?.admission?.status,
+      structuralDiffSummary: script.structuralDiff?.summary,
       ...input.metadata
     })
   };
@@ -291,7 +294,11 @@ function semanticEditIdentity(operation) {
     semanticKey: operation.semanticKey,
     semanticIdentityHash: operation.semanticIdentityHash,
     sourceIdentityHash: operation.sourceIdentityHash,
-    operationContentHash: operation.operationContentHash
+    operationContentHash: operation.operationContentHash,
+    structuralEditId: operation.structuralEdit?.id,
+    structuralEditHash: operation.structuralEdit?.hash,
+    structuralKind: operation.structuralEdit?.structuralKind,
+    structuralActions: operation.structuralEdit?.actions
   });
 }
 

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

@@ -0,0 +1,148 @@
+import { hashSemanticValue } from '@shapeshift-labs/frontier-lang-kernel';
+import { idFragment, uniqueStrings } from '../../native-import-utils.js';
+import { maskNonCode } from '../../js-ts-semantic-scope-use-def-scan.js';
+
+function classStaticBlockRuntimeRecordsForImport(imported, semanticIndex, publicKeys = new Set()) {
+  const sourceText = nativeImportSourceText(imported);
+  if (typeof sourceText !== 'string' || !sourceText.includes('static')) return [];
+  const sourcePath = imported?.sourcePath ?? imported?.nativeSource?.sourcePath ?? imported?.nativeAst?.sourcePath;
+  const sourceHash = imported?.nativeSource?.sourceHash ?? imported?.nativeAst?.sourceHash ?? imported?.sourceHash;
+  const language = imported?.language ?? imported?.nativeSource?.language ?? imported?.nativeAst?.language;
+  const publicNames = new Set((semanticIndex?.symbols ?? []).filter((symbol) => symbol?.kind === 'export').map((symbol) => symbol.name));
+  return classStaticBlockRecords(sourceText, sourcePath).map((block) => {
+    const publicContract = block.exported || publicNames.has(block.className) || publicKeys.has(runtimePublicKey(sourcePath, block.className)) || undefined;
+    const runtimeOrderEvidence = classStaticBlockRuntimeOrderEvidence(block);
+    const signatureHash = hashSemanticValue({
+      kind: 'frontier.lang.projectClassStaticBlockRuntimeRegionSignature.v1',
+      className: block.className,
+      ordinal: block.ordinal,
+      runtimeOrderEvidence,
+      text: block.text
+    });
+    const id = `runtime_region_class_static_${idFragment(hashSemanticValue([sourcePath, block.className, block.ordinal, block.start, block.end]))}`;
+    return compactRecord({
+      id,
+      key: ['class-static-block', sourcePath ?? 'memory', block.className, block.ordinal].join('#'),
+      regionKind: 'effect',
+      runtimeKind: 'class-static-block',
+      runtimeKinds: ['class-static-block'],
+      sourcePath,
+      sourceHash,
+      sourceSpan: sourceSpanForBlock(block, sourcePath, sourceHash),
+      precision: 'block',
+      spanKind: 'class-static-block',
+      symbolName: block.className,
+      symbolKind: 'class',
+      line: block.line,
+      ordinal: block.ordinal,
+      runtimeOrderEvidence,
+      signatureHash,
+      publicContract,
+      evidenceIds: uniqueStrings([`class-static-block:${sourcePath}:${block.className}:${block.ordinal}`])
+    });
+  });
+}
+
+function classStaticBlockRecords(sourceText, sourcePath) {
+  const masked = maskNonCode(sourceText).code;
+  const lineStarts = lineStartsFor(sourceText);
+  const records = [];
+  const classPattern = /\b(export\s+)?(?:abstract\s+)?class\s+([A-Za-z_$][\w$]*)[^{]*\{/g;
+  for (const match of masked.matchAll(classPattern)) {
+    const classOpen = masked.indexOf('{', match.index);
+    const classClose = matchingBraceIndex(masked, classOpen);
+    if (classOpen < 0 || classClose === undefined) continue;
+    const body = masked.slice(classOpen + 1, classClose);
+    let ordinal = 0;
+    for (const staticMatch of body.matchAll(/\bstatic\s*\{/g)) {
+      const start = classOpen + 1 + staticMatch.index;
+      const open = masked.indexOf('{', start);
+      const end = matchingBraceIndex(masked, open);
+      if (open < 0 || end === undefined || end > classClose) continue;
+      ordinal += 1;
+      const location = lineColumnAt(lineStarts, start);
+      records.push(compactRecord({
+        sourcePath,
+        className: match[2],
+        exported: Boolean(match[1]),
+        ordinal,
+        start,
+        end: end + 1,
+        line: location.line,
+        column: location.column,
+        text: sourceText.slice(start, end + 1),
+        statementCount: classStaticBlockStatementCount(sourceText.slice(open + 1, end))
+      }));
+    }
+  }
+  return records;
+}
+
+function classStaticBlockRuntimeOrderEvidence(block) {
+  return compactRecord({
+    schema: 'frontier.lang.runtimeOrderEvidence.v1',
+    source: 'lexical-source-scan',
+    runtimeScope: 'class-static-initialization',
+    regionKind: 'effect',
+    runtimeKinds: ['class-static-block'],
+    line: block.line,
+    runtimeOrderIndex: block.ordinal,
+    classStaticBlockOrder: [compactRecord({
+      kind: 'class-static-block',
+      className: block.className,
+      ordinal: block.ordinal,
+      line: block.line,
+      statementCount: block.statementCount,
+      text: normalizeText(block.text)
+    })]
+  });
+}
+
+function sourceSpanForBlock(block, sourcePath, sourceHash) {
+  const starts = lineStartsFor(block.text);
+  const endLine = block.line + starts.length - 1;
+  const lastLineStart = starts[starts.length - 1] ?? 0;
+  return {
+    sourceId: sourceHash,
+    path: sourcePath,
+    startLine: block.line,
+    endLine,
+    startColumn: block.column,
+    endColumn: endLine === block.line ? block.column + block.text.length : block.text.length - lastLineStart + 1
+  };
+}
+
+function classStaticBlockStatementCount(body) {
+  return String(body ?? '').split(';').map((part) => part.trim()).filter(Boolean).length;
+}
+
+function matchingBraceIndex(text, open) {
+  if (open < 0) return undefined;
+  let depth = 0;
+  for (let index = open; index < text.length; index += 1) {
+    if (text[index] === '{') depth += 1;
+    else if (text[index] === '}' && --depth === 0) return index;
+  }
+  return undefined;
+}
+
+function lineStartsFor(sourceText) {
+  const starts = [0];
+  for (let index = 0; index < String(sourceText).length; index += 1) {
+    if (sourceText[index] === '\n') starts.push(index + 1);
+  }
+  return starts;
+}
+
+function lineColumnAt(lineStarts, offset) {
+  let lineIndex = 0;
+  while (lineIndex + 1 < lineStarts.length && lineStarts[lineIndex + 1] <= offset) lineIndex += 1;
+  return { line: lineIndex + 1, column: offset - lineStarts[lineIndex] + 1 };
+}
+
+function runtimePublicKey(sourcePath, symbolName) { return sourcePath && symbolName ? `${sourcePath}\0${symbolName}` : undefined; }
+function nativeImportSourceText(imported) { return imported?.metadata?.sourcePreservation?.sourceText ?? imported?.nativeSource?.metadata?.sourcePreservation?.sourceText ?? imported?.nativeAst?.metadata?.sourcePreservation?.sourceText ?? imported?.sourceText; }
+function normalizeText(value) { return String(value ?? '').replace(/\s+/g, ' ').trim(); }
+function compactRecord(record) { return Object.fromEntries(Object.entries(record).filter(([, value]) => value !== undefined)); }
+
+export { classStaticBlockRuntimeRecordsForImport };

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

@@ -0,0 +1,45 @@
+function compilerAdvancedTypeMetadata(value) {
+  const advancedTypeShapes = arrayValue(value.advancedTypeShapes);
+  const typeReferenceTargets = arrayValue(value.typeReferenceTargets);
+  const counts = {
+    advancedTypeShapeCount: numberValue(value.advancedTypeShapeCount) ?? advancedTypeShapes.length,
+    typeReferenceTargetCount: numberValue(value.typeReferenceTargetCount) ?? typeReferenceTargets.length,
+    conditionalTypeCount: numberValue(value.conditionalTypeCount) ?? countKind(advancedTypeShapes, 'conditional-type'),
+    mappedTypeCount: numberValue(value.mappedTypeCount) ?? countKind(advancedTypeShapes, 'mapped-type'),
+    indexedAccessTypeCount: numberValue(value.indexedAccessTypeCount) ?? countKind(advancedTypeShapes, 'indexed-access-type'),
+    keyofTypeOperatorCount: numberValue(value.keyofTypeOperatorCount) ?? countKind(advancedTypeShapes, 'keyof-type-operator'),
+    templateLiteralTypeCount: numberValue(value.templateLiteralTypeCount) ?? countKind(advancedTypeShapes, 'template-literal-type'),
+    inferTypeCount: numberValue(value.inferTypeCount) ?? countKind(advancedTypeShapes, 'infer-type'),
+    unionTypeCount: numberValue(value.unionTypeCount) ?? countKind(advancedTypeShapes, 'union-type'),
+    intersectionTypeCount: numberValue(value.intersectionTypeCount) ?? countKind(advancedTypeShapes, 'intersection-type'),
+    tupleTypeCount: numberValue(value.tupleTypeCount) ?? countKind(advancedTypeShapes, 'tuple-type')
+  };
+  return {
+    counts,
+    record: compactRecord({
+      advancedTypeShapeCount: counts.advancedTypeShapeCount || undefined,
+      advancedTypeShapeKinds: value.advancedTypeShapeKinds ?? nonEmptyArray(uniqueStrings(advancedTypeShapes.map((shape) => shape.kind))),
+      typeReferenceTargetCount: counts.typeReferenceTargetCount || undefined,
+      conditionalTypeCount: counts.conditionalTypeCount || undefined,
+      mappedTypeCount: counts.mappedTypeCount || undefined,
+      indexedAccessTypeCount: counts.indexedAccessTypeCount || undefined,
+      keyofTypeOperatorCount: counts.keyofTypeOperatorCount || undefined,
+      templateLiteralTypeCount: counts.templateLiteralTypeCount || undefined,
+      inferTypeCount: counts.inferTypeCount || undefined,
+      unionTypeCount: counts.unionTypeCount || undefined,
+      intersectionTypeCount: counts.intersectionTypeCount || undefined,
+      tupleTypeCount: counts.tupleTypeCount || undefined,
+      advancedTypeShapes: nonEmptyArray(advancedTypeShapes),
+      typeReferenceTargets: nonEmptyArray(typeReferenceTargets)
+    })
+  };
+}
+
+function countKind(records, kind) { return records.filter((record) => record.kind === kind).length; }
+function arrayValue(value) { return Array.isArray(value) ? value : []; }
+function compactRecord(record) { return Object.fromEntries(Object.entries(record).filter(([, value]) => value !== undefined)); }
+function numberValue(value) { return Number.isFinite(value) ? value : undefined; }
+function nonEmptyArray(value) { return Array.isArray(value) && value.length ? value : undefined; }
+function uniqueStrings(values) { return [...new Set(values.filter((value) => typeof value === 'string' && value.length > 0))]; }
+
+export { compilerAdvancedTypeMetadata };

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

@@ -0,0 +1,107 @@
+import { hashSemanticValue } from '@shapeshift-labs/frontier-lang-kernel';
+
+function compilerCallableSignatureEquivalenceRecord(value, counts, sourceBinding = {}) {
+  if (!requiresCallableSignatureProof(counts)) return { reasonCodes: [] };
+  const checkerEvidence = callableSignatureCheckerEvidence(value, counts, sourceBinding);
+  const missingSignals = missingCallableSignatureEquivalenceSignals(value, counts, checkerEvidence, sourceBinding);
+  const reasonCodes = callableSignatureReasonCodes(counts, missingSignals);
+  const canProve = missingSignals.length === 0;
+  const callSignatureSetHash = canProve && counts.callSignatureCount > 0 ? hashSemanticValue({ kind: 'frontier.lang.typescript.compilerCallSignatureSetEquivalence.v1', callSignatures: canonicalSignatureRecords(value.callSignatures) }) : undefined;
+  const constructSignatureSetHash = canProve && counts.constructSignatureCount > 0 ? hashSemanticValue({ kind: 'frontier.lang.typescript.compilerConstructSignatureSetEquivalence.v1', constructSignatures: canonicalSignatureRecords(value.constructSignatures) }) : undefined;
+  const proof = compactRecord({
+    kind: callableSignatureProofKind(counts),
+    status: canProve ? 'passed' : 'failed',
+    proofLevel: callableSignatureProofLevel(counts),
+    checkerInvariant: callableSignatureCheckerInvariant(counts, sourceBinding),
+    requiredSignals: callableSignatureRequiredSignals(counts, sourceBinding),
+    missingSignals: nonEmptyArray(missingSignals),
+    reasonCodes: nonEmptyArray(reasonCodes),
+    callSignatureSetHash,
+    constructSignatureSetHash,
+    sourcePath: sourceBinding.sourcePath,
+    sourceHash: sourceBinding.sourceHash,
+    sourceBoundPublicApi: sourceBinding.publicContract === true || undefined,
+    callSignatureCount: counts.callSignatureCount || undefined,
+    constructSignatureCount: counts.constructSignatureCount || undefined,
+    evidenceIds: counts.evidenceIds,
+    autoMergeClaim: false,
+    semanticEquivalenceClaim: false
+  });
+  return { status: canProve ? 'compiler-backed-equivalent' : 'unsupported', reasonCodes: canProve ? [] : reasonCodes, callSignatureSetHash, constructSignatureSetHash, proof, checkerEvidence };
+}
+
+function requiresCallableSignatureProof(counts) { return counts.callSignatureCount > 0 || counts.constructSignatureCount > 0; }
+function callableSignatureProofKind(counts) {
+  if (counts.callSignatureCount > 0 && counts.constructSignatureCount > 0) return 'typescript-checker-public-api-callable-and-construct-signature-shape-equivalence';
+  return counts.constructSignatureCount > 0 ? 'typescript-checker-public-api-construct-signature-shape-equivalence' : 'typescript-checker-public-api-call-signature-shape-equivalence';
+}
+function callableSignatureProofLevel(counts) {
+  const levels = [counts.callSignatureCount > 0 ? 'call-signature-set' : undefined, counts.constructSignatureCount > 0 ? 'construct-signature-set' : undefined].filter(Boolean);
+  return `typescript-checker-public-api-${levels.join('-and-')}`;
+}
+function callableSignatureCheckerInvariant(counts, sourceBinding = {}) {
+  return [
+    sourceBinding.publicContract === true ? 'public API source path/hash bound' : undefined,
+    counts.callSignatureCount > 0 ? 'call signatures/returns/parameters complete' : undefined,
+    counts.constructSignatureCount > 0 ? 'construct signatures/returns/parameters complete' : undefined
+  ].filter(Boolean).join('; ');
+}
+function callableSignatureRequiredSignals(counts, sourceBinding = {}) {
+  return [
+    sourceBinding.publicContract === true ? 'compiler-public-api-source-path' : undefined,
+    sourceBinding.publicContract === true ? 'compiler-public-api-source-hash' : undefined,
+    counts.callSignatureCount > 0 ? 'compiler-call-signature-count' : undefined,
+    counts.callSignatureCount > 0 ? 'compiler-call-signature-texts' : undefined,
+    counts.callSignatureCount > 0 ? 'compiler-call-signature-return-type-texts' : undefined,
+    counts.callSignatureCount > 0 ? 'compiler-call-signature-parameter-type-texts' : undefined,
+    counts.constructSignatureCount > 0 ? 'compiler-construct-signature-count' : undefined,
+    counts.constructSignatureCount > 0 ? 'compiler-construct-signature-texts' : undefined,
+    counts.constructSignatureCount > 0 ? 'compiler-construct-signature-return-type-texts' : undefined,
+    counts.constructSignatureCount > 0 ? 'compiler-construct-signature-parameter-type-texts' : undefined
+  ].filter(Boolean);
+}
+function callableSignatureReasonCodes(counts, missingSignals = []) {
+  return uniqueStrings([
+    counts.callSignatureCount > 0 ? 'typescript-public-call-signature-shape-equivalence-unproven' : undefined,
+    counts.constructSignatureCount > 0 ? 'typescript-public-construct-signature-shape-equivalence-unproven' : undefined,
+    ...missingSignals.map((signal) => `typescript-${signal}-missing`)
+  ]);
+}
+function missingCallableSignatureEquivalenceSignals(value, counts, checkerEvidence = callableSignatureCheckerEvidence(value, counts), sourceBinding = {}) {
+  const missing = [];
+  if (sourceBinding.publicContract === true && !checkerEvidence.sourcePath) missing.push('compiler-public-api-source-path');
+  if (sourceBinding.publicContract === true && !checkerEvidence.sourceHash) missing.push('compiler-public-api-source-hash');
+  if (counts.callSignatureCount > 0 && checkerEvidence.callSignatureTexts.length !== counts.callSignatureCount) missing.push('compiler-call-signature-count');
+  if (counts.callSignatureCount > 0 && checkerEvidence.callSignatureTexts.some((text) => !text)) missing.push('compiler-call-signature-texts');
+  if (counts.callSignatureCount > 0 && checkerEvidence.callReturnTypeTexts.some((text) => !text)) missing.push('compiler-call-signature-return-type-texts');
+  if (counts.callSignatureCount > 0 && !signaturesHaveParameterTypes(value.callSignatures)) missing.push('compiler-call-signature-parameter-type-texts');
+  if (counts.constructSignatureCount > 0 && checkerEvidence.constructSignatureTexts.length !== counts.constructSignatureCount) missing.push('compiler-construct-signature-count');
+  if (counts.constructSignatureCount > 0 && checkerEvidence.constructSignatureTexts.some((text) => !text)) missing.push('compiler-construct-signature-texts');
+  if (counts.constructSignatureCount > 0 && checkerEvidence.constructReturnTypeTexts.some((text) => !text)) missing.push('compiler-construct-signature-return-type-texts');
+  if (counts.constructSignatureCount > 0 && !signaturesHaveParameterTypes(value.constructSignatures)) missing.push('compiler-construct-signature-parameter-type-texts');
+  return uniqueStrings(missing);
+}
+function callableSignatureCheckerEvidence(value, counts, sourceBinding = {}) {
+  const callSignatures = arrayValue(value.callSignatures), constructSignatures = arrayValue(value.constructSignatures);
+  return compactRecord({
+    sourcePath: sourceBinding.sourcePath,
+    sourceHash: sourceBinding.sourceHash,
+    sourceBoundPublicApi: sourceBinding.publicContract === true || undefined,
+    callSignatureCount: counts.callSignatureCount || undefined,
+    constructSignatureCount: counts.constructSignatureCount || undefined,
+    callSignatureTexts: callSignatures.map((signature) => signature.signatureText),
+    callReturnTypeTexts: callSignatures.map((signature) => signature.returnTypeText),
+    callParameterTypeTexts: callSignatures.map((signature) => arrayValue(signature.parameters).map((parameter) => parameter.typeText)),
+    constructSignatureTexts: constructSignatures.map((signature) => signature.signatureText),
+    constructReturnTypeTexts: constructSignatures.map((signature) => signature.returnTypeText),
+    constructParameterTypeTexts: constructSignatures.map((signature) => arrayValue(signature.parameters).map((parameter) => parameter.typeText))
+  });
+}
+function signaturesHaveParameterTypes(signatures) { return arrayValue(signatures).every((signature) => arrayValue(signature.parameters).every((parameter) => Boolean(parameter.typeText))); }
+function canonicalSignatureRecords(signatures) { return arrayValue(signatures).map((signature) => compactRecord({ ...signature, parameters: nonEmptyArray(arrayValue(signature.parameters).map(({ flags: _flags, ...parameter }) => parameter)) })); }
+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 { callableSignatureCheckerEvidence, callableSignatureProofKind, callableSignatureReasonCodes, callableSignatureRequiredSignals, compilerCallableSignatureEquivalenceRecord, missingCallableSignatureEquivalenceSignals, requiresCallableSignatureProof };