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

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

@@ -0,0 +1,290 @@
+import { hashSemanticValue } from '@shapeshift-labs/frontier-lang-kernel';
+import { spanFromTypeScriptNode } from './spanFromTypeScriptNode.js';
+
+const DecoratorMetadataProofKind = 'typescript-checker-decorator-static-metadata-evidence';
+const DecoratorRuntimeExecutionGapKind = 'typescript-checker-decorator-runtime-execution-equivalence-gap';
+const DecoratorRuntimeExecutionGapCode = 'decorator-execution-equivalence-not-claimed';
+const DecoratorRuntimeExecutionRouteId = 'prove-decorator-runtime-execution-equivalence';
+const DecoratorRuntimeExecutionRouteLane = 'decorator-runtime-boundaries';
+const DecoratorRuntimeExecutionRouteNext = 'supply-decorator-runtime-execution-proof';
+
+function compilerDecoratorMetadataRecord(_checker, identitySymbol, location, ts) {
+  const declarations = classDeclarations(identitySymbol, location, ts);
+  const decoratorMetadata = declarations.flatMap((declaration, declarationOrdinal) => [
+    ...decoratorRecordsForTarget({
+      node: declaration,
+      ts,
+      declarationOrdinal,
+      targetKind: 'class',
+      className: declarationName(declaration),
+      recordKind: 'class-decorator'
+    }),
+    ...classMemberDecoratorRecords(declaration, declarationOrdinal, ts)
+  ]);
+  const decoratorMetadataHash = decoratorMetadata.length
+    ? hashSemanticValue({
+      kind: 'frontier.lang.typescript.compilerDecoratorStaticMetadata.v1',
+      decoratorMetadata: decoratorMetadata.map(canonicalDecoratorRecord)
+    })
+    : undefined;
+  const counts = decoratorMetadataCounts(decoratorMetadata);
+  return compactRecord({
+    decoratorMetadata: nonEmptyArray(decoratorMetadata),
+    decoratorMetadataCount: counts.decoratorMetadataCount || undefined,
+    classDecoratorCount: counts.classDecoratorCount || undefined,
+    memberDecoratorCount: counts.memberDecoratorCount || undefined,
+    parameterDecoratorCount: counts.parameterDecoratorCount || undefined,
+    decoratorMetadataHash,
+    decoratorMetadataProof: decoratorMetadata.length ? decoratorMetadataProof(counts, decoratorMetadataHash) : undefined
+  });
+}
+
+function classMemberDecoratorRecords(declaration, declarationOrdinal, ts) {
+  const className = declarationName(declaration);
+  return arrayValue(declaration?.members).flatMap((member, memberOrdinal) => {
+    const targetKind = memberTargetKind(member, ts);
+    return [
+      ...decoratorRecordsForTarget({
+        node: member,
+        ts,
+        declarationOrdinal,
+        memberOrdinal,
+        targetKind,
+        className,
+        memberName: memberName(member, ts),
+        memberKind: targetKind,
+        recordKind: 'member-decorator',
+        static: hasModifier(member?.modifiers, ts, 'StaticKeyword') || undefined,
+        accessibility: accessibilityModifier(member, ts)
+      }),
+      ...parameterDecoratorRecords(member, declarationOrdinal, memberOrdinal, className, ts)
+    ];
+  });
+}
+
+function parameterDecoratorRecords(member, declarationOrdinal, memberOrdinal, className, ts) {
+  const targetKind = memberTargetKind(member, ts);
+  return arrayValue(member?.parameters).flatMap((parameter, parameterOrdinal) => decoratorRecordsForTarget({
+    node: parameter,
+    ts,
+    declarationOrdinal,
+    memberOrdinal,
+    parameterOrdinal,
+    targetKind: `${targetKind}-parameter`,
+    className,
+    memberName: memberName(member, ts),
+    memberKind: targetKind,
+    parameterName: nodeText(parameter?.name, sourceFileFor(parameter)),
+    recordKind: 'parameter-decorator',
+    accessibility: accessibilityModifier(parameter, ts),
+    parameterProperty: isParameterProperty(parameter, ts) || undefined
+  }));
+}
+
+function decoratorRecordsForTarget(input) {
+  const decorators = decoratorsForNode(input.node, input.ts);
+  const sourceFile = sourceFileFor(input.node);
+  return decorators.map((decorator, decoratorOrdinal) => {
+    const expressionText = nodeText(decorator.expression, sourceFile);
+    return compactRecord({
+      kind: input.recordKind,
+      targetKind: input.targetKind,
+      className: input.className,
+      memberKind: input.memberKind,
+      memberName: input.memberName,
+      parameterName: input.parameterName,
+      declarationOrdinal: input.declarationOrdinal,
+      memberOrdinal: input.memberOrdinal,
+      parameterOrdinal: input.parameterOrdinal,
+      decoratorOrdinal,
+      targetStatic: input.static,
+      targetAccessibility: input.accessibility,
+      parameterProperty: input.parameterProperty,
+      syntaxKind: syntaxKindName(input.ts, decorator.kind),
+      expressionKind: syntaxKindName(input.ts, decorator.expression?.kind),
+      decoratorText: nodeText(decorator, sourceFile),
+      expressionText,
+      expressionHash: expressionText ? hashSemanticValue(expressionText) : undefined,
+      sourceSpan: spanFromTypeScriptNode(decorator, sourceFile),
+      staticDecoratorMetadataEvidence: true,
+      decoratorExecutionEquivalenceClaim: false,
+      runtimeEquivalenceClaim: false,
+      semanticEquivalenceClaim: false
+    });
+  });
+}
+
+function decoratorMetadataProof(counts, decoratorMetadataHash) {
+  return {
+    kind: DecoratorMetadataProofKind,
+    status: 'passed',
+    proofLevel: 'typescript-checker-decorator-static-metadata',
+    proofScope: 'static-decorator-metadata-only',
+    checkerInvariant: 'decorator targets, expression texts, declaration order, and source spans complete; decorator execution semantics are not evaluated',
+    requiredSignals: [
+      'typescript-get-decorators-api',
+      'compiler-decorator-target-kind',
+      'compiler-decorator-expression-text',
+      'compiler-decorator-source-span',
+      'compiler-decorator-declaration-order'
+    ],
+    decoratorMetadataHash,
+    ...counts,
+    runtimeExecutionEquivalenceGap: decoratorRuntimeExecutionGap(counts, decoratorMetadataHash),
+    conflictRouting: decoratorConflictRouting(decoratorMetadataHash),
+    staticDecoratorMetadataEvidence: true,
+    autoMergeClaim: false,
+    semanticEquivalenceClaim: false,
+    runtimeEquivalenceClaim: false,
+    decoratorExecutionEquivalenceClaim: false
+  };
+}
+
+function decoratorRuntimeExecutionGap(counts, decoratorMetadataHash) {
+  return {
+    kind: DecoratorRuntimeExecutionGapKind,
+    status: 'blocked',
+    proofLevel: 'decorator-runtime-execution-equivalence',
+    reasonCode: DecoratorRuntimeExecutionGapCode,
+    summary: 'Static decorator metadata records targets and expression text only; decorator factory calls, invocation order, side effects, returned replacements, and emitted runtime behavior are not evaluated.',
+    requiredEvidence: 'decorator-runtime-execution-trace-or-equivalence-proof',
+    missingSignals: [
+      'decorator-factory-call-order',
+      'decorator-invocation-order',
+      'decorator-side-effect-trace',
+      'decorator-result-application-proof',
+      'decorator-emit-runtime-equivalence'
+    ],
+    routeId: DecoratorRuntimeExecutionRouteId,
+    routeLane: DecoratorRuntimeExecutionRouteLane,
+    routeNext: DecoratorRuntimeExecutionRouteNext,
+    failClosed: true,
+    blocksSemanticEquivalence: true,
+    decoratorMetadataHash,
+    ...counts,
+    staticDecoratorMetadataEvidence: true,
+    proofClaim: false,
+    autoMergeClaim: false,
+    semanticEquivalenceClaim: false,
+    runtimeEquivalenceClaim: false,
+    decoratorExecutionEquivalenceClaim: false
+  };
+}
+
+function decoratorConflictRouting(decoratorMetadataHash) {
+  return {
+    status: 'fail-closed',
+    conflictCode: 'project-public-compiler-type-delta-conflict',
+    reasonCode: DecoratorRuntimeExecutionGapCode,
+    branchDivergenceSignal: 'decoratorMetadataHash',
+    routeId: DecoratorRuntimeExecutionRouteId,
+    routeLane: DecoratorRuntimeExecutionRouteLane,
+    routeNext: DecoratorRuntimeExecutionRouteNext,
+    decoratorMetadataHash,
+    autoMergeClaim: false,
+    semanticEquivalenceClaim: false,
+    runtimeEquivalenceClaim: false,
+    decoratorExecutionEquivalenceClaim: false
+  };
+}
+
+function decoratorsForNode(node, ts) {
+  const apiDecorators = safeCall(ts?.canHaveDecorators, ts, node)
+    ? safeCall(ts?.getDecorators, ts, node)
+    : undefined;
+  if (Array.isArray(apiDecorators)) return apiDecorators;
+  const decoratorKind = syntaxKind(ts, 'Decorator');
+  return decoratorKind === undefined ? [] : arrayValue(node?.modifiers).filter((modifier) => modifier.kind === decoratorKind);
+}
+
+function classDeclarations(identitySymbol, location, ts) {
+  const declarations = arrayValue(identitySymbol?.declarations).filter((declaration) => isSyntaxKind(ts, declaration, 'ClassDeclaration'));
+  if (declarations.length) return declarations;
+  return isSyntaxKind(ts, location, 'ClassDeclaration') ? [location] : [];
+}
+
+function decoratorMetadataCounts(records) {
+  return {
+    decoratorMetadataCount: records.length,
+    classDecoratorCount: records.filter((record) => record.kind === 'class-decorator').length,
+    memberDecoratorCount: records.filter((record) => record.kind === 'member-decorator').length,
+    parameterDecoratorCount: records.filter((record) => record.kind === 'parameter-decorator').length
+  };
+}
+
+function canonicalDecoratorRecord(record) {
+  return compactRecord({
+    kind: record.kind,
+    targetKind: record.targetKind,
+    className: record.className,
+    memberKind: record.memberKind,
+    memberName: record.memberName,
+    parameterName: record.parameterName,
+    declarationOrdinal: record.declarationOrdinal,
+    memberOrdinal: record.memberOrdinal,
+    parameterOrdinal: record.parameterOrdinal,
+    decoratorOrdinal: record.decoratorOrdinal,
+    targetStatic: record.targetStatic,
+    targetAccessibility: record.targetAccessibility,
+    parameterProperty: record.parameterProperty,
+    expressionKind: record.expressionKind,
+    expressionText: record.expressionText,
+    sourceSpan: record.sourceSpan
+  });
+}
+
+function memberTargetKind(member, ts) {
+  if (isSyntaxKind(ts, member, 'Constructor')) return 'constructor';
+  if (isSyntaxKind(ts, member, 'MethodDeclaration')) return 'method';
+  if (isSyntaxKind(ts, member, 'GetAccessor')) return 'get-accessor';
+  if (isSyntaxKind(ts, member, 'SetAccessor')) return 'set-accessor';
+  if (isSyntaxKind(ts, member, 'PropertyDeclaration') && hasModifier(member?.modifiers, ts, 'AccessorKeyword')) return 'accessor-field';
+  if (isSyntaxKind(ts, member, 'PropertyDeclaration')) return 'field';
+  return syntaxKindName(ts, member?.kind) ?? 'class-member';
+}
+
+function memberName(member, ts) {
+  if (isSyntaxKind(ts, member, 'Constructor')) return 'constructor';
+  const name = member?.name;
+  return stringValue(name?.escapedText ?? name?.text ?? nodeText(name, sourceFileFor(member)));
+}
+
+function declarationName(declaration) {
+  const name = declaration?.name;
+  return stringValue(name?.escapedText ?? name?.text ?? nodeText(name, sourceFileFor(declaration)));
+}
+
+function accessibilityModifier(node, ts) {
+  const modifiers = arrayValue(node?.modifiers);
+  if (hasModifier(modifiers, ts, 'PrivateKeyword')) return 'private';
+  if (hasModifier(modifiers, ts, 'ProtectedKeyword')) return 'protected';
+  if (hasModifier(modifiers, ts, 'PublicKeyword')) return 'public';
+  return undefined;
+}
+
+function isParameterProperty(parameter, ts) {
+  const modifiers = arrayValue(parameter?.modifiers);
+  return ['PrivateKeyword', 'ProtectedKeyword', 'PublicKeyword', 'ReadonlyKeyword'].some((kind) => hasModifier(modifiers, ts, kind));
+}
+
+function hasModifier(modifiers, ts, kind) {
+  const expected = syntaxKind(ts, kind);
+  return expected !== undefined && arrayValue(modifiers).some((modifier) => modifier.kind === expected);
+}
+
+function sourceFileFor(node) { return safeCall(node?.getSourceFile, node); }
+function nodeText(node, sourceFile) { return stringValue(safeCall(node?.getText, node, sourceFile)); }
+function syntaxKind(ts, name) { return numberValue(ts?.SyntaxKind?.[name]); }
+function isSyntaxKind(ts, node, name) { return node?.kind === syntaxKind(ts, name); }
+function syntaxKindName(ts, kind) { return stringValue(ts?.SyntaxKind?.[kind]) ?? (Number.isFinite(kind) ? String(kind) : undefined); }
+function safeCall(fn, receiver, ...args) {
+  if (typeof fn !== 'function') return undefined;
+  try { return fn.apply(receiver, args); } catch { return undefined; }
+}
+function arrayValue(value) { return Array.isArray(value) ? value : []; }
+function nonEmptyArray(value) { return Array.isArray(value) && value.length ? value : undefined; }
+function numberValue(value) { return Number.isFinite(value) ? value : undefined; }
+function stringValue(value) { return value === undefined || value === null || value === '' ? undefined : String(value); }
+function compactRecord(record) { return Object.fromEntries(Object.entries(record).filter(([, value]) => value !== undefined)); }
+
+export { compilerDecoratorMetadataRecord };

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

@@ -0,0 +1,279 @@
+import { hashSemanticValue } from '@shapeshift-labs/frontier-lang-kernel';
+import { computedEnumRuntimeValueHash } from './projectSymbolGraphCompilerEnumEquivalence.js';
+
+const EnumRuntimeShapeProofKind = 'typescript-checker-public-api-enum-runtime-shape-evidence';
+
+function compilerEnumShapeRecord(checker, identitySymbol, location, ts, options = {}) {
+  const declarations = enumDeclarations(identitySymbol, ts);
+  if (!declarations.length) return {};
+  const baseMembers = declarations.flatMap((declaration, declarationOrdinal) => enumMemberRecords(checker, declaration, location, ts, declarationOrdinal));
+  if (!baseMembers.length) return {};
+  const constEnum = declarations.some((declaration) => hasModifier(declaration, ts, 'ConstKeyword'));
+  const declareEnum = declarations.some((declaration) => hasModifier(declaration, ts, 'DeclareKeyword'));
+  const enumRuntimeShapeHash = hashSemanticValue({
+    kind: 'frontier.lang.typescript.compilerEnumRuntimeShapeEvidence.v1',
+    constEnum,
+    declareEnum,
+    enumMembers: baseMembers.map(canonicalEnumMemberRecord)
+  });
+  const computedMemberCount = baseMembers.filter((member) => member.computed === true).length;
+  const proofBridge = computedEnumRuntimeValueProofBridge(baseMembers, {
+    sourcePath: options.sourcePath,
+    sourceHash: options.sourceHash,
+    enumName: stringValue(identitySymbol?.escapedName ?? identitySymbol?.name),
+    enumRuntimeShapeHash,
+    enumComputedMemberCount: computedMemberCount,
+    constEnum,
+    declareEnum
+  }, options);
+  const enumMembers = proofBridge.enumMembers;
+  const counts = enumShapeCounts(enumMembers);
+  const enumEmittedRuntimeShapeHash = emittedRuntimeShapeHash(enumMembers, { constEnum, declareEnum });
+  return compactRecord({
+    enumKind: constEnum ? 'const-enum' : 'enum',
+    constEnum: constEnum || undefined,
+    declareEnum: declareEnum || undefined,
+    enumDeclarationCount: declarations.length || undefined,
+    enumMemberCount: enumMembers.length,
+    enumNumericMemberCount: counts.enumNumericMemberCount || undefined,
+    enumStringMemberCount: counts.enumStringMemberCount || undefined,
+    enumAutoMemberCount: counts.enumAutoMemberCount || undefined,
+    enumComputedMemberCount: counts.enumComputedMemberCount || undefined,
+    enumRuntimeShapeHash,
+    enumEmittedRuntimeShapeHash,
+    enumMembers,
+    enumRuntimeShapeProof: {
+      kind: EnumRuntimeShapeProofKind,
+      status: 'passed',
+      proofLevel: 'typescript-checker-public-api-enum-runtime-shape',
+      checkerInvariant: 'enum member names, declaration order, initializer texts, and constant runtime values complete',
+      requiredSignals: [
+        'compiler-enum-member-count',
+        'compiler-enum-member-names',
+        'compiler-enum-member-value-texts',
+        'compiler-enum-member-initializer-texts'
+      ],
+      enumRuntimeShapeHash,
+      enumEmittedRuntimeShapeHash,
+      enumMemberCount: enumMembers.length,
+      computedEnumRuntimeValueHash: proofBridge.computedEnumRuntimeValueHash,
+      computedEnumRuntimeValueProof: proofBridge.computedEnumRuntimeValueProof,
+      ...counts,
+      autoMergeClaim: false,
+      semanticEquivalenceClaim: false,
+      runtimeEquivalenceClaim: false
+    }
+  });
+}
+
+function computedEnumRuntimeValueProofBridge(enumMembers, context, options) {
+  const computedMembers = enumMembers.filter((member) => member.computed === true);
+  if (!computedMembers.length) return { enumMembers };
+  const candidate = computedEnumRuntimeValueCandidate({ ...context, enumMembers, computedMembers }, options);
+  if (!candidate) return { enumMembers };
+  const provedMembers = enumMembers.map((member) => member.computed === true
+    ? { ...member, ...runtimeValueForMember(member, candidate) }
+    : member);
+  const computedValueHash = computedEnumRuntimeValueHash({
+    enumRuntimeShapeHash: context.enumRuntimeShapeHash,
+    enumMembers: provedMembers
+  }, context);
+  const emittedHash = emittedRuntimeShapeHash(provedMembers, context);
+  const proof = compactRecord({
+    id: candidate.id,
+    evidenceId: candidate.evidenceId,
+    evidenceIds: nonEmptyArray(arrayValue(candidate.evidenceIds)),
+    schema: candidate.schema ?? 'frontier.lang.typescript.computedEnumRuntimeValueProof.v1',
+    kind: candidate.kind,
+    status: candidate.status,
+    sourcePath: candidate.sourcePath ?? context.sourcePath,
+    sourceHash: candidate.sourceHash ?? context.sourceHash,
+    enumName: candidate.enumName ?? context.enumName,
+    enumRuntimeShapeHash: candidate.enumRuntimeShapeHash ?? context.enumRuntimeShapeHash,
+    enumEmittedRuntimeShapeHash: candidate.enumEmittedRuntimeShapeHash ?? emittedHash,
+    enumComputedMemberCount: candidate.enumComputedMemberCount ?? computedMembers.length,
+    computedMembers: nonEmptyArray(provedMembers.filter((member) => member.computed === true).map(runtimeValueProofMember)),
+    computedEnumRuntimeValueHash: candidate.computedEnumRuntimeValueHash ?? computedValueHash,
+    command: candidate.command,
+    traceHash: candidate.traceHash,
+    evidenceHash: candidate.evidenceHash,
+    autoMergeClaim: candidate.autoMergeClaim ?? false,
+    semanticEquivalenceClaim: candidate.semanticEquivalenceClaim ?? false,
+    runtimeEquivalenceClaim: candidate.runtimeEquivalenceClaim ?? false,
+    computedEnumRuntimeEvaluationEquivalenceClaim: candidate.computedEnumRuntimeEvaluationEquivalenceClaim ?? false
+  });
+  return {
+    enumMembers: provedMembers,
+    computedEnumRuntimeValueHash: computedValueHash,
+    computedEnumRuntimeValueProof: proof
+  };
+}
+
+function computedEnumRuntimeValueCandidate(context, options) {
+  const provider = options.computedEnumRuntimeValueProofProvider ?? options.computedEnumRuntimeValueTraceProvider;
+  const provided = typeof provider === 'function' ? safeCall(provider, undefined, {
+    ...context,
+    proofKind: 'frontier.lang.typescript.computedEnumRuntimeValueProof'
+  }) : undefined;
+  const candidates = [
+    ...candidateList(provided),
+    ...candidateList(options.computedEnumRuntimeValueProofs),
+    ...candidateList(options.computedEnumRuntimeValueProof),
+    ...candidateList(options.computedEnumRuntimeValueTraces)
+  ];
+  return candidates.find((candidate) => candidateMatches(candidate, context));
+}
+
+function candidateMatches(candidate, context) {
+  if (!candidate || typeof candidate !== 'object') return false;
+  if (candidate.sourcePath !== undefined && candidate.sourcePath !== context.sourcePath) return false;
+  const candidateName = candidate.enumName ?? candidate.publicOwnerName ?? candidate.symbolName;
+  if (candidateName !== undefined && candidateName !== context.enumName) return false;
+  return true;
+}
+
+function candidateList(value) {
+  if (Array.isArray(value)) return value.filter(objectValue);
+  const object = objectValue(value);
+  if (!object) return [];
+  if (object.status || object.schema || object.kind || object.computedMembers || object.runtimeValues || object.enumMembers) return [object];
+  return Object.values(object).filter(objectValue);
+}
+
+function runtimeValueForMember(member, candidate) {
+  const runtimeValues = objectValue(candidate.runtimeValues);
+  const directValue = runtimeValues?.[member.name];
+  const record = candidateMemberRecords(candidate).find((item) => memberRecordMatches(item, member));
+  return runtimeValueRecord(record ?? directValue);
+}
+
+function candidateMemberRecords(candidate) {
+  return [
+    ...arrayValue(candidate.computedMembers),
+    ...arrayValue(candidate.members),
+    ...arrayValue(candidate.enumMembers),
+    ...arrayValue(candidate.values)
+  ].filter((value) => value !== undefined && value !== null);
+}
+
+function memberRecordMatches(record, member) {
+  if (!objectValue(record)) return false;
+  if (record.declarationOrdinal !== undefined && record.ordinal !== undefined) {
+    return Number(record.declarationOrdinal) === Number(member.declarationOrdinal)
+      && Number(record.ordinal) === Number(member.ordinal);
+  }
+  if (record.ordinal !== undefined && Number(record.ordinal) === Number(member.ordinal)) return true;
+  return record.name !== undefined && String(record.name) === String(member.name);
+}
+
+function runtimeValueRecord(value) {
+  if (value === undefined || value === null) return {};
+  const record = objectValue(value);
+  if (!record) return { runtimeValueText: String(value), runtimeValueKind: typeof value };
+  const raw = record.runtimeValue ?? record.value;
+  return compactRecord({
+    runtimeValueText: stringValue(record.runtimeValueText ?? record.valueText ?? (raw === undefined ? undefined : String(raw))),
+    runtimeValueKind: stringValue(record.runtimeValueKind ?? record.valueKind ?? (raw === undefined ? undefined : typeof raw))
+  });
+}
+
+function runtimeValueProofMember(member) {
+  return compactRecord({
+    name: member.name,
+    ordinal: member.ordinal,
+    declarationOrdinal: member.declarationOrdinal,
+    initializerText: member.initializerText,
+    runtimeValueText: member.runtimeValueText,
+    runtimeValueKind: member.runtimeValueKind
+  });
+}
+
+function emittedRuntimeShapeHash(enumMembers, context) {
+  const erased = context.constEnum === true || context.declareEnum === true;
+  return hashSemanticValue({
+    kind: 'frontier.lang.typescript.enumEmittedRuntimeShape.v1',
+    erased,
+    entries: erased ? [] : enumMembers.flatMap(emittedRuntimeEntries)
+  });
+}
+
+function emittedRuntimeEntries(member) {
+  const valueText = member.runtimeValueText ?? member.valueText;
+  const valueKind = member.runtimeValueKind ?? member.valueKind;
+  const forward = compactRecord({ direction: 'forward', name: member.name, valueText, valueKind });
+  const reverse = valueKind === 'number' ? compactRecord({ direction: 'reverse', valueText, name: member.name }) : undefined;
+  return [forward, reverse].filter(Boolean);
+}
+
+function enumMemberRecords(checker, declaration, location, ts, declarationOrdinal) {
+  return arrayValue(declaration.members).map((member, ordinal) => {
+    const constantValue = safeCall(checker?.getConstantValue, checker, member);
+    const initializerText = nodeText(member.initializer);
+    const valueKind = constantValue === undefined ? undefined : typeof constantValue;
+    return compactRecord({
+      name: stringValue(member.name?.escapedText ?? member.name?.text ?? nodeText(member.name)),
+      ordinal,
+      declarationOrdinal,
+      initializerText,
+      valueText: constantValue === undefined ? undefined : String(constantValue),
+      valueKind,
+      auto: member.initializer ? undefined : true,
+      computed: member.initializer && constantValue === undefined ? true : undefined,
+      memberText: nodeText(member),
+      memberTypeText: typeTextAt(checker, member.name ?? member, location)
+    });
+  });
+}
+
+function enumShapeCounts(records) {
+  return {
+    enumNumericMemberCount: records.filter((record) => record.valueKind === 'number').length,
+    enumStringMemberCount: records.filter((record) => record.valueKind === 'string').length,
+    enumAutoMemberCount: records.filter((record) => record.auto).length,
+    enumComputedMemberCount: records.filter((record) => record.computed).length
+  };
+}
+
+function enumDeclarations(identitySymbol, ts) {
+  return arrayValue(identitySymbol?.declarations).filter((declaration) => declaration.kind === syntaxKind(ts, 'EnumDeclaration'));
+}
+
+function canonicalEnumMemberRecord(record) {
+  return compactRecord({
+    name: record.name,
+    ordinal: record.ordinal,
+    declarationOrdinal: record.declarationOrdinal,
+    initializerText: record.initializerText,
+    valueText: record.valueText,
+    valueKind: record.valueKind,
+    runtimeValueText: record.runtimeValueText,
+    runtimeValueKind: record.runtimeValueKind,
+    auto: record.auto,
+    computed: record.computed
+  });
+}
+
+function hasModifier(node, ts, kindName) {
+  const kind = syntaxKind(ts, kindName);
+  return kind !== undefined && arrayValue(node.modifiers).some((modifier) => modifier.kind === kind);
+}
+
+function typeTextAt(checker, node, location) {
+  const type = safeCall(checker?.getTypeAtLocation, checker, node ?? location);
+  return type ? stringValue(safeCall(checker?.typeToString, checker, type)) : nodeText(node);
+}
+
+function syntaxKind(ts, name) { return numberValue(ts?.SyntaxKind?.[name]); }
+function nodeText(node) { return stringValue(safeCall(node?.getText, node)); }
+function safeCall(fn, receiver, ...args) {
+  if (typeof fn !== 'function') return undefined;
+  try { return fn.apply(receiver, args); } catch { return undefined; }
+}
+function arrayValue(value) { return Array.isArray(value) ? value : []; }
+function objectValue(value) { return value && typeof value === 'object' && !Array.isArray(value) ? value : undefined; }
+function stringValue(value) { return value === undefined || value === null || value === '' ? undefined : String(value); }
+function numberValue(value) { return Number.isFinite(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)); }
+
+export { compilerEnumShapeRecord };