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

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

@@ -0,0 +1,160 @@
+function compilerAdvancedTypeShapes(checker, identitySymbol, location, ts) {
+  const declarations = Array.isArray(identitySymbol?.declarations) ? identitySymbol.declarations : [];
+  const records = [];
+  for (const declaration of declarations) {
+    visitTypeNodes(ts, declaration, (node) => {
+      const record = advancedTypeShapeRecord(checker, node, location, ts);
+      if (record) records.push(record);
+    });
+  }
+  return uniqueRecords(records, (record) => [record.kind, record.nodeText, record.typeText].join('\0'));
+}
+
+function advancedTypeShapeRecord(checker, node, location, ts) {
+  if (isSyntaxKind(ts, node, 'ConditionalType')) {
+    return compactRecord({
+      kind: 'conditional-type',
+      syntaxKind: syntaxKindName(ts, node.kind),
+      nodeText: nodeText(node),
+      typeText: typeTextFromTypeNode(checker, node, location),
+      checkTypeText: typeTextFromTypeNode(checker, node.checkType, location),
+      extendsTypeText: typeTextFromTypeNode(checker, node.extendsType, location),
+      trueTypeText: typeTextFromTypeNode(checker, node.trueType, location),
+      falseTypeText: typeTextFromTypeNode(checker, node.falseType, location)
+    });
+  }
+  if (isSyntaxKind(ts, node, 'MappedType')) {
+    return compactRecord({
+      kind: 'mapped-type',
+      syntaxKind: syntaxKindName(ts, node.kind),
+      nodeText: nodeText(node),
+      typeText: typeTextFromTypeNode(checker, node, location),
+      mappedConstraintTypeText: typeTextFromTypeNode(checker, node.typeParameter?.constraint, location),
+      mappedValueTypeText: typeTextFromTypeNode(checker, node.type, location)
+    });
+  }
+  if (isSyntaxKind(ts, node, 'IndexedAccessType')) {
+    return compactRecord({
+      kind: 'indexed-access-type',
+      syntaxKind: syntaxKindName(ts, node.kind),
+      nodeText: nodeText(node),
+      typeText: typeTextFromTypeNode(checker, node, location),
+      objectTypeText: typeTextFromTypeNode(checker, node.objectType, location),
+      indexTypeText: typeTextFromTypeNode(checker, node.indexType, location)
+    });
+  }
+  if (isSyntaxKind(ts, node, 'TypeOperator') && node.operator === syntaxKind(ts, 'KeyOfKeyword')) {
+    return compactRecord({
+      kind: 'keyof-type-operator',
+      syntaxKind: syntaxKindName(ts, node.kind),
+      nodeText: nodeText(node),
+      typeText: typeTextFromTypeNode(checker, node, location),
+      keyofTargetTypeText: typeTextFromTypeNode(checker, node.type, location)
+    });
+  }
+  if (isSyntaxKind(ts, node, 'TemplateLiteralType')) {
+    return compactRecord({
+      kind: 'template-literal-type',
+      syntaxKind: syntaxKindName(ts, node.kind),
+      nodeText: nodeText(node),
+      typeText: typeTextFromTypeNode(checker, node, location),
+      templateHeadText: literalText(node.head?.text) ?? nodeText(node.head),
+      templateSpanCount: arrayValue(node.templateSpans).length || undefined,
+      templateSpanTexts: nonEmptyArray(arrayValue(node.templateSpans).map((span) => nodeText(span))),
+      templateSpanTypeTexts: nonEmptyArray(arrayValue(node.templateSpans).map((span) => typeTextFromTypeNode(checker, span.type, location))),
+      templateLiteralTexts: nonEmptyArray([
+        literalText(node.head?.text) ?? nodeText(node.head),
+        ...arrayValue(node.templateSpans).map((span) => literalText(span.literal?.text) ?? nodeText(span.literal))
+      ].filter((value) => value !== undefined))
+    });
+  }
+  if (isSyntaxKind(ts, node, 'InferType')) {
+    return compactRecord({
+      kind: 'infer-type',
+      syntaxKind: syntaxKindName(ts, node.kind),
+      nodeText: nodeText(node),
+      typeText: typeTextFromTypeNode(checker, node, location),
+      typeParameterText: nodeText(node.typeParameter),
+      typeParameterName: stringValue(node.typeParameter?.name?.escapedText ?? node.typeParameter?.name?.text),
+      constraintTypeText: typeTextFromTypeNode(checker, node.typeParameter?.constraint, location)
+    });
+  }
+  if ((isSyntaxKind(ts, node, 'UnionType') || isSyntaxKind(ts, node, 'IntersectionType')) && isTopLevelTypeAliasShape(ts, node)) {
+    const shapeKind = isSyntaxKind(ts, node, 'UnionType') ? 'union-type' : 'intersection-type';
+    return compactRecord({
+      kind: shapeKind,
+      syntaxKind: syntaxKindName(ts, node.kind),
+      nodeText: nodeText(node),
+      typeText: typeTextFromTypeNode(checker, node, location),
+      memberTypeTexts: nonEmptyArray(arrayValue(node.types).map((typeNode) => typeTextFromTypeNode(checker, typeNode, location))),
+      memberNodeTexts: nonEmptyArray(arrayValue(node.types).map((typeNode) => nodeText(typeNode)))
+    });
+  }
+  if (isSyntaxKind(ts, node, 'TupleType') && isTopLevelTypeAliasShape(ts, node)) {
+    return compactRecord({
+      kind: 'tuple-type',
+      syntaxKind: syntaxKindName(ts, node.kind),
+      nodeText: nodeText(node),
+      typeText: typeTextFromTypeNode(checker, node, location),
+      tupleElementTexts: nonEmptyArray(arrayValue(node.elements).map((element) => nodeText(element))),
+      tupleElementTypeTexts: nonEmptyArray(arrayValue(node.elements).map((element) => tupleElementTypeText(checker, element, location, ts)))
+    });
+  }
+  return undefined;
+}
+
+function tupleElementTypeText(checker, element, location, ts) {
+  if (isSyntaxKind(ts, element, 'NamedTupleMember')) return typeTextFromTypeNode(checker, element.type, location);
+  if (isSyntaxKind(ts, element, 'OptionalType')) return typeTextFromTypeNode(checker, element.type, location);
+  if (isSyntaxKind(ts, element, 'RestType')) return typeTextFromTypeNode(checker, element.type, location);
+  return typeTextFromTypeNode(checker, element, location);
+}
+
+function visitTypeNodes(ts, node, visit) {
+  if (!node || typeof node !== 'object') return;
+  visit(node);
+  if (typeof ts?.forEachChild === 'function') {
+    ts.forEachChild(node, (child) => visitTypeNodes(ts, child, visit));
+    return;
+  }
+  for (const value of Object.values(node)) {
+    if (Array.isArray(value)) value.forEach((child) => visitTypeNodes(ts, child, visit));
+    else if (value && typeof value === 'object' && Number.isFinite(value.kind)) visitTypeNodes(ts, value, visit);
+  }
+}
+
+function typeTextFromTypeNode(checker, node, location) {
+  const type = safeCall(checker?.getTypeFromTypeNode, checker, node) ?? 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 isSyntaxKind(ts, node, name) { return node?.kind === syntaxKind(ts, name); }
+function isTopLevelTypeAliasShape(ts, node) {
+  const parent = node?.parent;
+  return isSyntaxKind(ts, parent, 'TypeAliasDeclaration')
+    || (isSyntaxKind(ts, parent, 'TypeOperator') && isSyntaxKind(ts, parent?.parent, 'TypeAliasDeclaration'));
+}
+function syntaxKindName(ts, kind) { return stringValue(ts?.SyntaxKind?.[kind]) ?? (Number.isFinite(kind) ? String(kind) : undefined); }
+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 stringValue(value) { return value === undefined || value === null || value === '' ? undefined : String(value); }
+function literalText(value) { return value === undefined || value === null ? undefined : String(value); }
+function numberValue(value) { return Number.isFinite(value) ? value : undefined; }
+function arrayValue(value) { return Array.isArray(value) ? value : []; }
+function nonEmptyArray(value) { return Array.isArray(value) && value.length ? value : undefined; }
+function uniqueRecords(records, keyFn) {
+  const seen = new Set();
+  return records.filter((record) => {
+    const key = keyFn(record);
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+}
+function compactRecord(record) { return Object.fromEntries(Object.entries(record).filter(([, value]) => value !== undefined)); }
+
+export { compilerAdvancedTypeShapes };

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

@@ -0,0 +1,97 @@
+function compilerAssignabilityOracleRecord(checker, type, apparentType, identitySymbol, location, ts) {
+  const declaration = boundedAssignabilityAliasDeclaration(identitySymbol, ts);
+  if (!declaration || typeof checker?.isTypeAssignableTo !== 'function' || !type || !apparentType) return undefined;
+  const directions = [
+    compilerAssignabilityOracleDirection(checker, 'declared-to-apparent', type, apparentType),
+    compilerAssignabilityOracleDirection(checker, 'apparent-to-declared', apparentType, type)
+  ].filter(Boolean);
+  const complete = directions.length === 2 && directions.every((direction) => typeof direction.assignable === 'boolean');
+  return compactRecord({
+    kind: 'typescript-checker-public-api-declared-apparent-assignability-oracle',
+    scope: 'public-type-alias-declared-apparent',
+    oracle: 'TypeChecker.isTypeAssignableTo',
+    declarationKind: 'type-alias',
+    declarationCount: Array.isArray(identitySymbol?.declarations) ? identitySymbol.declarations.length : undefined,
+    typeNodeText: nodeText(declaration.type),
+    declaredTypeText: typeText(checker, type),
+    apparentTypeText: typeText(checker, apparentType),
+    directions: nonEmptyArray(directions),
+    directionCount: directions.length || undefined,
+    equivalentByBidirectionalAssignability: complete ? directions.every((direction) => direction.assignable === true) : undefined,
+    ambiguous: complete ? undefined : true,
+    autoMergeClaim: false,
+    semanticEquivalenceClaim: false,
+    runtimeEquivalenceClaim: false
+  });
+}
+
+function compilerAssignabilityOracleDirection(checker, direction, fromType, toType) {
+  const assignable = safeCall(checker.isTypeAssignableTo, checker, fromType, toType);
+  return compactRecord({
+    direction,
+    fromTypeText: typeText(checker, fromType),
+    toTypeText: typeText(checker, toType),
+    assignable: typeof assignable === 'boolean' ? assignable : undefined
+  });
+}
+
+function boundedAssignabilityAliasDeclaration(identitySymbol, ts) {
+  const declarations = Array.isArray(identitySymbol?.declarations) ? identitySymbol.declarations : [];
+  return declarations.find((declaration) => (
+    isSyntaxKind(ts, declaration, 'TypeAliasDeclaration')
+      && isBoundedAssignabilityTypeAliasNode(declaration.type, ts)
+  ));
+}
+
+function isBoundedAssignabilityTypeAliasNode(node, ts) {
+  if (!node) return false;
+  const excludedKinds = [
+    'ConditionalType',
+    'ConstructorType',
+    'FunctionType',
+    'IndexedAccessType',
+    'InferType',
+    'IntersectionType',
+    'MappedType',
+    'TemplateLiteralType',
+    'TupleType',
+    'TypeLiteral',
+    'TypeOperator',
+    'UnionType'
+  ];
+  return !excludedKinds.some((kind) => isSyntaxKind(ts, node, kind));
+}
+
+function hasFocusedCompilerApiShape(record) {
+  return arrayValue(record.typeParameters).length > 0
+    || arrayValue(record.callSignatures).length > 0
+    || arrayValue(record.constructSignatures).length > 0
+    || arrayValue(record.properties).length > 0
+    || arrayValue(record.indexSignatures).length > 0
+    || arrayValue(record.advancedTypeShapes).length > 0
+    || arrayValue(record.typeReferenceTargets).length > 0
+    || objectHasValues(record.classApi)
+    || objectHasValues(record.enumShape)
+    || objectHasValues(record.typeInferenceSyntax);
+}
+
+function safeCall(fn, receiver, ...args) {
+  if (typeof fn !== 'function') return undefined;
+  try { return fn.apply(receiver, args); } catch { return undefined; }
+}
+
+function stringValue(value) {
+  return value === undefined || value === null || value === '' ? undefined : String(value);
+}
+
+function numberValue(value) { return Number.isFinite(value) ? value : undefined; }
+function syntaxKind(ts, name) { return numberValue(ts?.SyntaxKind?.[name]); }
+function isSyntaxKind(ts, node, name) { return node?.kind === syntaxKind(ts, name); }
+function typeText(checker, type) { return type ? stringValue(safeCall(checker?.typeToString, checker, type)) : undefined; }
+function nonEmptyArray(value) { return Array.isArray(value) && value.length ? value : undefined; }
+function arrayValue(value) { return Array.isArray(value) ? value : []; }
+function nodeText(node) { return stringValue(safeCall(node?.getText, node)); }
+function objectHasValues(value) { return value && typeof value === 'object' && !Array.isArray(value) && Object.keys(value).length > 0; }
+function compactRecord(record) { return Object.fromEntries(Object.entries(record).filter(([, value]) => value !== undefined)); }
+
+export { compilerAssignabilityOracleRecord, hasFocusedCompilerApiShape };

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

@@ -0,0 +1,238 @@
+import { hashSemanticValue } from '@shapeshift-labs/frontier-lang-kernel';
+import { compilerDecoratorMetadataRecord } from './typeScriptCompilerDecoratorMetadata.js';
+
+function compilerClassApiRecord(checker, identitySymbol, location, ts) {
+  const declarations = Array.isArray(identitySymbol?.declarations) ? identitySymbol.declarations : [];
+  const classHeritage = uniqueRecords(
+    declarations.flatMap((declaration) => compilerClassHeritageRecords(checker, declaration, location, ts)),
+    (record) => [record.kind, record.expressionText, record.typeText].join('\0')
+  );
+  const constructorSignatures = uniqueRecords(
+    declarations.flatMap((declaration) => compilerConstructorSignatureRecords(checker, declaration, location, ts)),
+    (record) => [record.signatureText, record.parameters?.map((parameter) => parameter.typeText).join(',')].join('\0')
+  );
+  const privateClassMembers = uniqueRecords(
+    declarations.flatMap((declaration) => compilerClassPrivateMemberRecords(checker, declaration, location, ts)),
+    (record) => [record.kind, record.name, record.static, record.typeText, record.signatureText].join('\0')
+  );
+  const accessorFieldMembers = uniqueRecords(
+    declarations.flatMap((declaration) => compilerAccessorFieldRecords(checker, declaration, location, ts)),
+    (record) => [record.name, record.static, record.typeText, record.memberText].join('\0')
+  );
+  const decoratorMetadata = compilerDecoratorMetadataRecord(checker, identitySymbol, location, ts);
+  return compactRecord({
+    classHeritage: nonEmptyArray(classHeritage),
+    classHeritageCount: classHeritage.length || undefined,
+    constructorSignatures: nonEmptyArray(constructorSignatures),
+    constructorSignatureCount: constructorSignatures.length || undefined,
+    privateClassMembers: nonEmptyArray(privateClassMembers),
+    privateClassMemberCount: privateClassMembers.length || undefined,
+    privateClassMemberShapeHash: privateClassMembers.length ? hashSemanticValue({ kind: 'frontier.lang.typescript.compilerPrivateClassMemberShape.v1', privateClassMembers }) : undefined,
+    accessorFieldMembers: nonEmptyArray(accessorFieldMembers),
+    accessorFieldCount: accessorFieldMembers.length || undefined,
+    accessorFieldShapeHash: accessorFieldMembers.length ? hashSemanticValue({ kind: 'frontier.lang.typescript.compilerAccessorFieldShape.v1', accessorFieldMembers }) : undefined,
+    classMemberShapeProof: privateClassMembers.length || accessorFieldMembers.length ? compilerClassMemberShapeProof(privateClassMembers, accessorFieldMembers) : undefined,
+    ...decoratorMetadata
+  });
+}
+
+function compilerClassHeritageRecords(checker, declaration, location, ts) {
+  const clauses = Array.isArray(declaration?.heritageClauses) ? declaration.heritageClauses : [];
+  const records = [];
+  clauses.forEach((clause, clauseOrdinal) => {
+    const kind = heritageKind(ts, clause);
+    const types = Array.isArray(clause.types) ? clause.types : [];
+    types.forEach((entry, ordinal) => records.push(compactRecord({
+      kind,
+      syntaxKind: syntaxKindName(ts, clause.token),
+      clauseOrdinal,
+      ordinal,
+      expressionText: nodeText(entry.expression ?? entry),
+      typeText: heritageTypeText(checker, entry, location),
+      typeArguments: nonEmptyArray((entry.typeArguments ?? []).map((argument) => typeTextFromTypeNode(checker, argument, location)))
+    })));
+  });
+  return records;
+}
+
+function compilerConstructorSignatureRecords(checker, declaration, location, ts) {
+  const members = Array.isArray(declaration?.members) ? declaration.members : [];
+  return members
+    .filter((member) => isSyntaxKind(ts, member, 'Constructor'))
+    .map((member, ordinal) => {
+      const signature = safeCall(checker?.getSignatureFromDeclaration, checker, member);
+      return compactRecord({
+        ordinal,
+        signatureText: stringValue(safeCall(checker?.signatureToString, checker, signature)) ?? nodeText(member),
+        accessibility: accessibilityModifier(member, ts),
+        parameterCount: Array.isArray(member.parameters) ? member.parameters.length : undefined,
+        parameters: nonEmptyArray((member.parameters ?? []).map((parameter, parameterOrdinal) => compilerConstructorParameterRecord(checker, parameter, location, ts, parameterOrdinal)))
+      });
+    });
+}
+
+function compilerConstructorParameterRecord(checker, parameter, location, ts, ordinal) {
+  const type = parameter.type
+    ? safeCall(checker?.getTypeFromTypeNode, checker, parameter.type)
+    : safeCall(checker?.getTypeAtLocation, checker, parameter);
+  return compactRecord({
+    name: nodeText(parameter.name),
+    ordinal,
+    typeText: type ? stringValue(safeCall(checker?.typeToString, checker, type)) : typeTextFromTypeNode(checker, parameter.type, location),
+    optional: Boolean(parameter.questionToken || parameter.initializer) || undefined,
+    rest: Boolean(parameter.dotDotDotToken) || undefined,
+    accessibility: accessibilityModifier(parameter, ts),
+    parameterProperty: isParameterProperty(parameter, ts) || undefined
+  });
+}
+
+function compilerClassPrivateMemberRecords(checker, declaration, location, ts) {
+  const members = Array.isArray(declaration?.members) ? declaration.members : [];
+  return members.flatMap((member, ordinal) => {
+    if (!isPrivateClassMember(member, ts)) return [];
+    return [compilerClassMemberRecord(checker, member, location, ts, ordinal, true)];
+  });
+}
+
+function compilerAccessorFieldRecords(checker, declaration, location, ts) {
+  const members = Array.isArray(declaration?.members) ? declaration.members : [];
+  return members.flatMap((member, ordinal) => {
+    if (!isAccessorField(member, ts)) return [];
+    return [compilerClassMemberRecord(checker, member, location, ts, ordinal, false)];
+  });
+}
+
+function compilerClassMemberRecord(checker, member, location, ts, ordinal, privateMember) {
+  const type = compilerClassMemberType(checker, member, location);
+  const signature = safeCall(checker?.getSignatureFromDeclaration, checker, member);
+  return compactRecord({
+    kind: compilerClassMemberKind(member, ts, privateMember),
+    syntaxKind: syntaxKindName(ts, member?.kind),
+    name: compilerClassMemberName(member),
+    ordinal,
+    static: hasModifier(member?.modifiers, ts, 'StaticKeyword') || undefined,
+    readonly: hasModifier(member?.modifiers, ts, 'ReadonlyKeyword') || undefined,
+    accessibility: accessibilityModifier(member, ts),
+    privateIdentifier: isPrivateIdentifier(member?.name, ts) || undefined,
+    accessorField: isAccessorField(member, ts) || undefined,
+    typeText: type ? stringValue(safeCall(checker?.typeToString, checker, type)) : typeTextFromTypeNode(checker, member?.type, location),
+    signatureText: signature ? stringValue(safeCall(checker?.signatureToString, checker, signature)) : undefined,
+    parameterCount: Array.isArray(member?.parameters) ? member.parameters.length : undefined,
+    memberText: nodeText(member)
+  });
+}
+
+function compilerClassMemberShapeProof(privateClassMembers, accessorFieldMembers) {
+  return compactRecord({
+    kind: 'typescript-checker-class-private-accessor-shape-evidence',
+    status: 'passed',
+    proofLevel: 'typescript-checker-class-private-accessor-static-shape',
+    checkerInvariant: 'private/accessor member names, kinds, modifiers, types, and source texts complete',
+    requiredSignals: [
+      'compiler-private-class-member-count',
+      'compiler-private-class-member-names',
+      'compiler-private-class-member-type-texts',
+      'compiler-accessor-field-count',
+      'compiler-accessor-field-names',
+      'compiler-accessor-field-type-texts'
+    ],
+    privateClassMemberCount: privateClassMembers.length || undefined,
+    accessorFieldCount: accessorFieldMembers.length || undefined,
+    privateClassMemberShapeHash: privateClassMembers.length ? hashSemanticValue({ kind: 'frontier.lang.typescript.compilerPrivateClassMemberShape.v1', privateClassMembers }) : undefined,
+    accessorFieldShapeHash: accessorFieldMembers.length ? hashSemanticValue({ kind: 'frontier.lang.typescript.compilerAccessorFieldShape.v1', accessorFieldMembers }) : undefined,
+    autoMergeClaim: false,
+    semanticEquivalenceClaim: false,
+    runtimeEquivalenceClaim: false
+  });
+}
+
+function compilerClassMemberType(checker, member, location) {
+  return member?.type
+    ? safeCall(checker?.getTypeFromTypeNode, checker, member.type)
+    : safeCall(checker?.getTypeAtLocation, checker, member?.name ?? member ?? location);
+}
+
+function compilerClassMemberKind(member, ts, privateMember) {
+  if (isSyntaxKind(ts, member, 'MethodDeclaration')) return privateMember ? 'private-method' : 'method';
+  if (isSyntaxKind(ts, member, 'GetAccessor')) return privateMember ? 'private-get-accessor' : 'get-accessor';
+  if (isSyntaxKind(ts, member, 'SetAccessor')) return privateMember ? 'private-set-accessor' : 'set-accessor';
+  if (isAccessorField(member, ts)) return privateMember ? 'private-accessor-field' : 'accessor-field';
+  return privateMember ? 'private-field' : 'field';
+}
+
+function compilerClassMemberName(member) {
+  const name = member?.name;
+  return stringValue(name?.escapedText ?? name?.text ?? nodeText(name));
+}
+
+function isPrivateClassMember(member, ts) {
+  return isPrivateIdentifier(member?.name, ts) || accessibilityModifier(member, ts) === 'private';
+}
+
+function isPrivateIdentifier(node, ts) {
+  return node?.kind === syntaxKind(ts, 'PrivateIdentifier');
+}
+
+function isAccessorField(member, ts) {
+  return isSyntaxKind(ts, member, 'PropertyDeclaration') && hasModifier(member?.modifiers, ts, 'AccessorKeyword');
+}
+
+function heritageKind(ts, clause) {
+  if (clause?.token === syntaxKind(ts, 'ExtendsKeyword')) return 'extends';
+  if (clause?.token === syntaxKind(ts, 'ImplementsKeyword')) return 'implements';
+  return syntaxKindName(ts, clause?.token) ?? 'heritage';
+}
+
+function heritageTypeText(checker, entry, location) {
+  const type = safeCall(checker?.getTypeAtLocation, checker, entry) ?? safeCall(checker?.getTypeAtLocation, checker, entry?.expression);
+  return type ? stringValue(safeCall(checker?.typeToString, checker, type)) : nodeText(entry) ?? typeTextFromTypeNode(checker, entry, location);
+}
+
+function typeTextFromTypeNode(checker, node, location) {
+  if (!node) return undefined;
+  const type = safeCall(checker?.getTypeFromTypeNode, checker, node) ?? safeCall(checker?.getTypeAtLocation, checker, node ?? location);
+  return type ? stringValue(safeCall(checker?.typeToString, checker, type)) : nodeText(node);
+}
+
+function accessibilityModifier(node, ts) {
+  const modifiers = Array.isArray(node?.modifiers) ? 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 = Array.isArray(parameter?.modifiers) ? parameter.modifiers : [];
+  return ['PrivateKeyword', 'ProtectedKeyword', 'PublicKeyword', 'ReadonlyKeyword'].some((kind) => hasModifier(modifiers, ts, kind));
+}
+
+function hasModifier(modifiers, ts, kind) {
+  if (!Array.isArray(modifiers)) return false;
+  const expected = syntaxKind(ts, kind);
+  return expected !== undefined && modifiers.some((modifier) => modifier.kind === expected);
+}
+
+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 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 compactRecord(record) { return Object.fromEntries(Object.entries(record).filter(([, value]) => value !== undefined)); }
+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 uniqueRecords(records, keyFn) {
+  const seen = new Set();
+  return records.filter((record) => {
+    const key = keyFn(record);
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+}
+
+export { compilerClassApiRecord };