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

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 };

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 };