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

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

@@ -0,0 +1,294 @@
+import { hashSemanticValue } from '@shapeshift-labs/frontier-lang-kernel';
+import { idFragment } from '../../native-import-utils.js';
+import { compilerAdvancedTypeShapes } from './typeScriptCompilerAdvancedTypeShapes.js';
+import { compilerAssignabilityOracleRecord, hasFocusedCompilerApiShape } from './typeScriptCompilerAssignabilityOracle.js';
+import { compilerClassApiRecord } from './typeScriptCompilerClassApi.js';
+import { compilerEnumShapeRecord } from './typeScriptCompilerEnumShape.js';
+import { compilerTypeInferenceSyntaxRecord } from './typeScriptCompilerInferenceSyntax.js';
+import { compilerTypeReferenceTargets } from './typeScriptCompilerTypeReferenceTargets.js';
+
+function typeScriptCompilerSymbolRecordForNode(node, input, options = {}, fallbackNode = undefined, idOptions = {}) {
+  const checker = options.typeChecker ?? options.checker ?? options.program?.getTypeChecker?.();
+  const symbol = safeCall(checker?.getSymbolAtLocation, checker, node) ?? safeCall(checker?.getSymbolAtLocation, checker, fallbackNode);
+  if (!symbol) return undefined;
+  const aliasedSymbol = safeCall(checker?.getAliasedSymbol, checker, symbol);
+  const targetSymbol = aliasedSymbol && aliasedSymbol !== symbol ? aliasedSymbol : undefined;
+  const identitySymbol = targetSymbol ?? symbol;
+  const fullyQualifiedName = stringValue(safeCall(checker?.getFullyQualifiedName, checker, identitySymbol));
+  const localName = compilerSymbolLocalName(symbol, node, options.ts);
+  const targetName = targetSymbol ? stringValue(targetSymbol.escapedName ?? targetSymbol.name) : undefined;
+  const identity = fullyQualifiedName ?? targetName ?? localName;
+  if (!identity) return undefined;
+  const compilerSymbol = compactRecord({
+    parser: options.parser,
+    localName,
+    targetName,
+    fullyQualifiedName,
+    flags: numberValue(symbol.flags),
+    targetFlags: numberValue(targetSymbol?.flags),
+    declarations: Array.isArray(identitySymbol.declarations) ? identitySymbol.declarations.length : undefined,
+    aliased: Boolean(targetSymbol)
+  });
+  const compilerType = typeScriptCompilerTypeRecordForNode(node, {
+    ...options,
+    sourcePath: input.sourcePath,
+    sourceHash: input.sourceHash
+  }, fallbackNode, identitySymbol);
+  return {
+    identity,
+    compilerSymbol,
+    compilerSymbolIdentityHash: hashSemanticValue(compilerSymbol),
+    compilerType,
+    compilerTypeIdentityHash: compilerType ? hashSemanticValue(compilerType) : undefined,
+    symbolId: `symbol:${input.language}:compiler:${idOptions.importRole ? 'import:' : ''}${idFragment(identity)}`
+  };
+}
+
+function typeScriptCompilerTypeRecordForNode(node, options = {}, fallbackNode = undefined, identitySymbol = undefined) {
+  const checker = options.typeChecker ?? options.checker ?? options.program?.getTypeChecker?.();
+  const type = safeCall(checker?.getTypeAtLocation, checker, node) ?? safeCall(checker?.getTypeAtLocation, checker, fallbackNode);
+  if (!type) return undefined;
+  const apparentType = safeCall(checker?.getApparentType, checker, type);
+  const typeText = stringValue(safeCall(checker?.typeToString, checker, type));
+  const apparentTypeText = stringValue(apparentType ? safeCall(checker?.typeToString, checker, apparentType) : undefined);
+  const apiSignature = compilerApiSignatureRecord(checker, type, apparentType, node, fallbackNode, options, identitySymbol);
+  return compactRecord({
+    parser: options.parser,
+    typeText,
+    apparentTypeText,
+    flags: numberValue(type.flags),
+    objectFlags: numberValue(type.objectFlags),
+    intrinsicName: stringValue(type.intrinsicName),
+    ...apiSignature,
+    apiSignatureHash: hashSemanticValue({
+      kind: 'frontier.lang.typescript.compilerPublicApiSignature.v1',
+      parser: options.parser,
+      typeText,
+      apparentTypeText,
+      ...canonicalApiSignatureRecord(apiSignature)
+    })
+  });
+}
+
+function compilerApiSignatureRecord(checker, type, apparentType, node, fallbackNode, options, identitySymbol) {
+  const location = fallbackNode ?? node;
+  const signatureType = type ?? apparentType;
+  const propertyType = apparentType ?? type;
+  const typeParameters = compilerTypeParameterRecords(checker, identitySymbol, location, options.ts);
+  const callSignatures = compilerSignatureRecords(checker, signatureType, signatureKind(options.ts, 'Call', 0), location, options.ts);
+  const constructSignatures = compilerSignatureRecords(checker, signatureType, signatureKind(options.ts, 'Construct', 1), location, options.ts);
+  const properties = compilerPropertyRecords(checker, propertyType, location, options.ts);
+  const indexSignatures = compilerIndexSignatureRecords(checker, propertyType);
+  const advancedTypeShapes = compilerAdvancedTypeShapes(checker, identitySymbol, location, options.ts);
+  const typeReferenceTargets = compilerTypeReferenceTargets(checker, identitySymbol, location, options.ts);
+  const classApi = compilerClassApiRecord(checker, identitySymbol, location, options.ts);
+  const enumShape = compilerEnumShapeRecord(checker, identitySymbol, location, options.ts, options);
+  const typeInferenceSyntax = compilerTypeInferenceSyntaxRecord(checker, identitySymbol, location, options.ts);
+  const assignabilityOracle = hasFocusedCompilerApiShape({ typeParameters, callSignatures, constructSignatures, properties, indexSignatures, advancedTypeShapes, typeReferenceTargets, classApi, enumShape, typeInferenceSyntax })
+    ? undefined
+    : compilerAssignabilityOracleRecord(checker, type, apparentType, identitySymbol, location, options.ts);
+  return compactRecord({
+    typeParameters: nonEmptyArray(typeParameters),
+    typeParameterCount: typeParameters.length || undefined,
+    typeParameterDefaultCount: typeParameters.filter((parameter) => parameter.hasDefault).length || undefined,
+    typeParameterConstraintCount: typeParameters.filter((parameter) => parameter.hasConstraint).length || undefined,
+    callSignatures: nonEmptyArray(callSignatures),
+    constructSignatures: nonEmptyArray(constructSignatures),
+    properties: nonEmptyArray(properties),
+    indexSignatures: nonEmptyArray(indexSignatures),
+    indexSignatureCount: indexSignatures.length || undefined,
+    indexSignatureReadonlyCount: indexSignatures.filter((signature) => signature.readonly === true).length || undefined,
+    advancedTypeShapes: nonEmptyArray(advancedTypeShapes),
+    advancedTypeShapeKinds: nonEmptyArray(uniqueStrings(advancedTypeShapes.map((shape) => shape.kind))),
+    advancedTypeShapeCount: advancedTypeShapes.length || undefined,
+    typeReferenceTargets: nonEmptyArray(typeReferenceTargets),
+    typeReferenceTargetCount: typeReferenceTargets.length || undefined,
+    conditionalTypeCount: countAdvancedTypeShapeKind(advancedTypeShapes, 'conditional-type') || undefined,
+    mappedTypeCount: countAdvancedTypeShapeKind(advancedTypeShapes, 'mapped-type') || undefined,
+    indexedAccessTypeCount: countAdvancedTypeShapeKind(advancedTypeShapes, 'indexed-access-type') || undefined,
+    keyofTypeOperatorCount: countAdvancedTypeShapeKind(advancedTypeShapes, 'keyof-type-operator') || undefined,
+    templateLiteralTypeCount: countAdvancedTypeShapeKind(advancedTypeShapes, 'template-literal-type') || undefined,
+    inferTypeCount: countAdvancedTypeShapeKind(advancedTypeShapes, 'infer-type') || undefined,
+    ...enumShape,
+    ...typeInferenceSyntax,
+    assignabilityOracleCount: assignabilityOracle ? 1 : undefined,
+    assignabilityOracleDirectionCount: assignabilityOracle?.directionCount,
+    assignabilityOracleHash: assignabilityOracle ? hashSemanticValue({ kind: 'frontier.lang.typescript.compilerPublicApiAssignabilityOracle.v1', assignabilityOracle }) : undefined,
+    assignabilityOracle,
+    ...classApi
+  });
+}
+
+function compilerTypeParameterRecords(checker, identitySymbol, location, ts) {
+  const declaration = (Array.isArray(identitySymbol?.declarations) ? identitySymbol.declarations : [])
+    .find((item) => Array.isArray(item?.typeParameters) && item.typeParameters.length > 0);
+  if (!declaration) return [];
+  return declaration.typeParameters.map((parameter, ordinal) => {
+    const parameterSymbol = safeCall(checker?.getSymbolAtLocation, checker, parameter.name) ?? parameter.symbol;
+    const parameterType = safeCall(checker?.getTypeAtLocation, checker, parameter.name ?? parameter);
+    const constraintType = parameter.constraint ? safeCall(checker?.getTypeFromTypeNode, checker, parameter.constraint) : undefined;
+    const defaultType = parameter.default ? safeCall(checker?.getTypeFromTypeNode, checker, parameter.default) : undefined;
+    return compactRecord({
+      name: stringValue(parameter.name?.escapedText ?? parameter.name?.text),
+      ordinal,
+      typeText: parameterType ? stringValue(safeCall(checker?.typeToString, checker, parameterType)) : undefined,
+      constraintTypeText: constraintType ? stringValue(safeCall(checker?.typeToString, checker, constraintType)) : undefined,
+      defaultTypeText: defaultType ? stringValue(safeCall(checker?.typeToString, checker, defaultType)) : undefined,
+      flags: numberValue(parameterSymbol?.flags),
+      hasConstraint: parameter.constraint ? true : undefined,
+      hasDefault: parameter.default ? true : undefined,
+      variance: typeParameterVariance(ts, parameter)
+    });
+  });
+}
+
+function compilerSignatureRecords(checker, type, kind, location, ts) {
+  const signatures = safeCall(checker?.getSignaturesOfType, checker, type, kind);
+  if (!Array.isArray(signatures) || !signatures.length) return [];
+  return signatures.map((signature) => compactRecord({
+    signatureText: stringValue(safeCall(checker?.signatureToString, checker, signature)),
+    returnTypeText: compilerReturnTypeText(checker, signature),
+    parameters: nonEmptyArray(compilerSignatureParameterRecords(checker, signature, location, ts))
+  }));
+}
+
+function compilerSignatureParameterRecords(checker, signature, location, ts) {
+  const parameters = Array.isArray(signature?.parameters)
+    ? signature.parameters
+    : safeCall(signature?.getParameters, signature);
+  if (!Array.isArray(parameters)) return [];
+  return parameters.map((parameter) => {
+    const parameterType = safeCall(checker?.getTypeOfSymbolAtLocation, checker, parameter, location);
+    return compactRecord({
+      name: stringValue(parameter.escapedName ?? parameter.name),
+      typeText: parameterType ? stringValue(safeCall(checker?.typeToString, checker, parameterType)) : undefined,
+      flags: numberValue(parameter.flags),
+      optional: hasSymbolFlag(parameter, ts, 'Optional')
+    });
+  });
+}
+
+function compilerReturnTypeText(checker, signature) {
+  const returnType = safeCall(checker?.getReturnTypeOfSignature, checker, signature);
+  return returnType ? stringValue(safeCall(checker?.typeToString, checker, returnType)) : undefined;
+}
+
+function compilerPropertyRecords(checker, type, location, ts) {
+  const properties = safeCall(checker?.getPropertiesOfType, checker, type);
+  if (!Array.isArray(properties) || !properties.length) return [];
+  return properties
+    .map((property) => {
+      const declaration = Array.isArray(property.declarations) ? property.declarations[0] : undefined;
+      const propertyType = safeCall(checker?.getTypeOfSymbolAtLocation, checker, property, declaration ?? location);
+      return compactRecord({
+        name: stringValue(property.escapedName ?? property.name),
+        typeText: propertyType ? stringValue(safeCall(checker?.typeToString, checker, propertyType)) : undefined,
+        flags: numberValue(property.flags),
+        optional: hasSymbolFlag(property, ts, 'Optional'),
+        readonly: compilerPropertyReadonly(property, ts),
+        declarations: Array.isArray(property.declarations) ? property.declarations.length : undefined
+      });
+    })
+    .sort((left, right) => String(left.name ?? '').localeCompare(String(right.name ?? '')));
+}
+
+function compilerIndexSignatureRecords(checker, type) {
+  const indexInfos = safeCall(checker?.getIndexInfosOfType, checker, type);
+  if (!Array.isArray(indexInfos) || !indexInfos.length) return [];
+  return indexInfos.map((info, ordinal) => compactRecord({
+    ordinal,
+    keyTypeText: info?.keyType ? stringValue(safeCall(checker?.typeToString, checker, info.keyType)) : undefined,
+    valueTypeText: info?.type ? stringValue(safeCall(checker?.typeToString, checker, info.type)) : undefined,
+    readonly: typeof info?.isReadonly === 'boolean' ? info.isReadonly : undefined,
+    declarationText: nodeText(info?.declaration)
+  })).sort((left, right) => String(left.keyTypeText ?? '').localeCompare(String(right.keyTypeText ?? '')));
+}
+
+function countAdvancedTypeShapeKind(records, kind) { return records.filter((record) => record.kind === kind).length; }
+
+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 compilerSymbolLocalName(symbol, node, ts) {
+  return isPrivateIdentifier(node, ts)
+    ? nodeText(node)
+    : stringValue(symbol.escapedName ?? symbol.name);
+}
+function signatureKind(ts, name, fallback) { return numberValue(ts?.SignatureKind?.[name]) ?? fallback; }
+function typeParameterVariance(ts, parameter) {
+  const modifiers = Array.isArray(parameter?.modifiers) ? parameter.modifiers : [];
+  const inKeyword = numberValue(ts?.SyntaxKind?.InKeyword);
+  const outKeyword = numberValue(ts?.SyntaxKind?.OutKeyword);
+  const hasIn = inKeyword !== undefined && modifiers.some((modifier) => modifier.kind === inKeyword);
+  const hasOut = outKeyword !== undefined && modifiers.some((modifier) => modifier.kind === outKeyword);
+  if (hasIn && hasOut) return 'in out';
+  if (hasIn) return 'in';
+  if (hasOut) return 'out';
+  return undefined;
+}
+function compilerPropertyReadonly(property, ts) {
+  const readonlyFlag = numberValue(ts?.ModifierFlags?.Readonly);
+  const modifierFlags = numberValue(safeCall(ts?.getDeclarationModifierFlagsFromSymbol, ts, property));
+  if (readonlyFlag !== undefined && modifierFlags !== undefined) return Boolean(modifierFlags & readonlyFlag);
+  const declarations = Array.isArray(property?.declarations) ? property.declarations : [];
+  const readonlyKeyword = numberValue(ts?.SyntaxKind?.ReadonlyKeyword);
+  if (readonlyKeyword === undefined || !declarations.length) return undefined;
+  return declarations.some((declaration) => (
+    Array.isArray(declaration?.modifiers)
+      && declaration.modifiers.some((modifier) => modifier.kind === readonlyKeyword)
+  ));
+}
+function hasSymbolFlag(symbol, ts, flagName) {
+  const flag = numberValue(ts?.SymbolFlags?.[flagName]);
+  return flag !== undefined && numberValue(symbol?.flags) !== undefined ? Boolean(symbol.flags & flag) : undefined;
+}
+function canonicalApiSignatureRecord(record) {
+  return compactRecord({
+    ...record,
+    typeParameters: nonEmptyArray(arrayValue(record.typeParameters).map(({ flags: _flags, ...parameter }) => parameter)),
+    callSignatures: nonEmptyArray(arrayValue(record.callSignatures).map(canonicalSignatureRecord)),
+    constructSignatures: nonEmptyArray(arrayValue(record.constructSignatures).map(canonicalSignatureRecord)),
+    properties: nonEmptyArray(arrayValue(record.properties).map(({ flags: _flags, ...property }) => property)),
+    indexSignatures: nonEmptyArray(arrayValue(record.indexSignatures)),
+    typeReferenceTargets: nonEmptyArray(arrayValue(record.typeReferenceTargets).map(canonicalTypeReferenceTargetRecord))
+  });
+}
+function canonicalTypeReferenceTargetRecord(target) {
+  return compactRecord({
+    kind: target.kind,
+    typeReferenceName: target.typeReferenceName,
+    targetStatus: target.targetStatus,
+    targetAliased: target.targetAliased,
+    targetSymbolName: target.targetSymbolName,
+    targetFullyQualifiedName: target.targetFullyQualifiedName,
+    targetSymbolFlags: target.targetSymbolFlags,
+    targetDeclarationKind: target.targetDeclarationKind,
+    typeArgumentCount: target.typeArgumentCount
+  });
+}
+function canonicalSignatureRecord(signature) {
+  return compactRecord({
+    ...signature,
+    parameters: nonEmptyArray(arrayValue(signature.parameters).map(({ flags: _flags, ...parameter }) => parameter))
+  });
+}
+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 isPrivateIdentifier(node, ts) {
+  const privateIdentifier = numberValue(ts?.SyntaxKind?.PrivateIdentifier);
+  return privateIdentifier !== undefined
+    ? node?.kind === privateIdentifier
+    : nodeText(node)?.startsWith('#') === true;
+}
+function uniqueStrings(values) { return [...new Set(values.filter((value) => typeof value === 'string' && value.length > 0))]; }
+function compactRecord(record) { return Object.fromEntries(Object.entries(record).filter(([, value]) => value !== undefined)); }
+
+export { typeScriptCompilerSymbolRecordForNode };

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

@@ -0,0 +1,142 @@
+import { hashSemanticValue } from '@shapeshift-labs/frontier-lang-kernel';
+import { spanFromTypeScriptNode } from './spanFromTypeScriptNode.js';
+
+function compilerTypeReferenceTargets(checker, identitySymbol, location, ts) {
+  const declarations = Array.isArray(identitySymbol?.declarations) ? identitySymbol.declarations : [];
+  const records = [];
+  for (const declaration of declarations) {
+    visitTypeNodes(ts, declaration, (node) => {
+      if (!isSyntaxKind(ts, node, 'TypeReference')) return;
+      const record = typeReferenceTargetRecord(checker, node, location, ts);
+      if (record) records.push(record);
+    });
+  }
+  return uniqueRecords(records, (record) => [
+    record.typeReferenceName,
+    record.nodeText,
+    record.targetFullyQualifiedName,
+    record.targetDeclarationTextHash
+  ].join('\0'));
+}
+
+function typeReferenceTargetRecord(checker, node, location, ts) {
+  const symbol = safeCall(checker?.getSymbolAtLocation, checker, node.typeName);
+  const aliasedSymbol = safeCall(checker?.getAliasedSymbol, checker, symbol);
+  const targetSymbol = aliasedSymbol && aliasedSymbol !== symbol ? aliasedSymbol : symbol;
+  const declaration = targetDeclaration(targetSymbol);
+  if (!targetSymbol || !declaration) return undefined;
+  const referenceSpan = spanForNode(node, location);
+  const declarationSpan = spanForNode(declaration, location);
+  const declarationTextHash = declarationSourceHash(declaration, declarationSpan);
+  const targetSymbolIdentityHash = targetSymbol ? hashSemanticValue({
+    kind: 'frontier.lang.typescript.compilerTypeReferenceTargetSymbol.v1',
+    name: stringValue(targetSymbol.escapedName ?? targetSymbol.name),
+    fullyQualifiedName: stringValue(safeCall(checker?.getFullyQualifiedName, checker, targetSymbol)),
+    flags: numberValue(targetSymbol.flags),
+    declarationKind: syntaxKindName(ts, declaration?.kind),
+    declarationSpan,
+    declarationTextHash
+  }) : undefined;
+  const targetProof = compactRecord({
+    kind: 'frontier.lang.typescript.compilerPublicApiTypeReferenceTargetProof.v1',
+    typeReferenceName: nodeText(node.typeName),
+    targetSymbolName: stringValue(targetSymbol?.escapedName ?? targetSymbol?.name),
+    targetFullyQualifiedName: stringValue(targetSymbol ? safeCall(checker?.getFullyQualifiedName, checker, targetSymbol) : undefined),
+    targetSymbolFlags: numberValue(targetSymbol?.flags),
+    targetDeclarationKind: syntaxKindName(ts, declaration?.kind),
+    targetDeclarationSourcePath: declarationSpan?.path ?? sourcePathForNode(declaration),
+    targetDeclarationSpan: declarationSpan,
+    targetDeclarationTextHash: declarationTextHash,
+    targetSymbolIdentityHash
+  });
+  return compactRecord({
+    kind: 'type-reference-target',
+    syntaxKind: syntaxKindName(ts, node.kind),
+    nodeText: nodeText(node),
+    typeText: typeTextFromTypeNode(checker, node, location),
+    typeReferenceName: nodeText(node.typeName),
+    sourceSpan: referenceSpan,
+    typeArgumentCount: arrayValue(node.typeArguments).length || undefined,
+    targetStatus: 'resolved',
+    targetAliased: aliasedSymbol && aliasedSymbol !== symbol ? true : undefined,
+    targetSymbolName: targetProof.targetSymbolName,
+    targetFullyQualifiedName: targetProof.targetFullyQualifiedName,
+    targetSymbolFlags: targetProof.targetSymbolFlags,
+    targetSymbolIdentityHash,
+    targetDeclarationKind: targetProof.targetDeclarationKind,
+    targetDeclarationSourcePath: targetProof.targetDeclarationSourcePath,
+    targetDeclarationSpan: declarationSpan,
+    targetDeclarationTextHash: declarationTextHash,
+    typeReferenceTargetProofHash: hashSemanticValue(targetProof),
+    autoMergeClaim: false,
+    semanticEquivalenceClaim: false,
+    runtimeEquivalenceClaim: false
+  });
+}
+
+function targetDeclaration(symbol) {
+  return symbol?.valueDeclaration ?? arrayValue(symbol?.declarations)[0];
+}
+
+function declarationSourceHash(node, span) {
+  const text = nodeText(node);
+  if (!text) return undefined;
+  return hashSemanticValue({
+    kind: 'frontier.lang.typescript.compilerTypeReferenceTargetDeclarationSource.v1',
+    sourcePath: span?.path ?? sourcePathForNode(node),
+    span,
+    text
+  });
+}
+
+function spanForNode(node, fallback) {
+  if (!node || typeof node !== 'object') return undefined;
+  const sourceFile = safeCall(node.getSourceFile, node) ?? safeCall(fallback?.getSourceFile, fallback);
+  return sourceFile ? spanFromTypeScriptNode(node, sourceFile) : undefined;
+}
+
+function sourcePathForNode(node) {
+  return stringValue(safeCall(node?.getSourceFile, node)?.fileName);
+}
+
+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 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 numberValue(value) { return Number.isFinite(value) ? value : undefined; }
+function arrayValue(value) { return Array.isArray(value) ? value : []; }
+function compactRecord(record) { return Object.fromEntries(Object.entries(record).filter(([, value]) => 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;
+  });
+}
+
+export { compilerTypeReferenceTargets };

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

@@ -1,5 +1,6 @@
-import{hashSemanticValue}from'@shapeshift-labs/frontier-lang-kernel';import{idFragment}from'../../native-import-utils.js';
+import{hashSemanticValue}from'@shapeshift-labs/frontier-lang-kernel';
 import{declarationRecord}from'./declarationRecord.js';import{namedDeclaration}from'./namedDeclaration.js';import{stringFromTsExpression}from'./stringFromTsExpression.js';import{typeScriptExportedDeclarationEntries}from'./typeScriptExportedDeclarationEntries.js';import{typeScriptModuleDeclarationEntries}from'./typeScriptModuleDeclarationEntries.js';
+import{typeScriptCompilerSymbolRecordForNode}from'./typeScriptCompilerSymbolIdentity.js';
 export function typeScriptDeclaration(node, kind, nativeNodeId, input, options = {}) {
   const enrich = (declaration, symbolNode = node.name ?? node) => enrichTypeScriptDeclaration(node, symbolNode, declaration, input, options);
   const moduleEntries = typeScriptModuleDeclarationEntries(node, kind, nativeNodeId, input);
@@ -41,51 +42,22 @@ function moduleDeclaration(input, nativeNodeId, node) {
 
 function enrichTypeScriptDeclaration(node, symbolNode, declaration, input, options) {
   if (!declaration) return declaration;
-  const checker = options.typeChecker ?? options.checker ?? options.program?.getTypeChecker?.();
-  const symbol = safeCall(checker?.getSymbolAtLocation, checker, symbolNode) ?? safeCall(checker?.getSymbolAtLocation, checker, node.name);
-  if (!symbol) return declaration;
-  const aliasedSymbol = safeCall(checker?.getAliasedSymbol, checker, symbol);
-  const targetSymbol = aliasedSymbol && aliasedSymbol !== symbol ? aliasedSymbol : undefined;
-  const identitySymbol = targetSymbol ?? symbol;
-  const fullyQualifiedName = stringValue(safeCall(checker?.getFullyQualifiedName, checker, identitySymbol));
-  const localName = stringValue(symbol.escapedName ?? symbol.name) ?? declaration.name;
-  const targetName = targetSymbol ? stringValue(targetSymbol.escapedName ?? targetSymbol.name) : undefined;
-  const identity = fullyQualifiedName ?? targetName ?? localName;
-  const compilerSymbol = compactRecord({
-    parser: options.parser,
-    localName,
-    targetName,
-    fullyQualifiedName,
-    flags: numberValue(symbol.flags),
-    targetFlags: numberValue(targetSymbol?.flags),
-    declarations: Array.isArray(identitySymbol.declarations) ? identitySymbol.declarations.length : undefined,
-    aliased: Boolean(targetSymbol)
-  });
+  const compiler = typeScriptCompilerSymbolRecordForNode(symbolNode, input, options, node.name, { importRole: declaration.role === 'import' });
+  if (!compiler) return declaration;
   return {
     ...declaration,
-    symbolId: `symbol:${input.language}:compiler:${declaration.role === 'import' ? 'import:' : ''}${idFragment(identity)}`,
-    signatureHash: hashSemanticValue([input.language, declaration.symbolKind, identity, compilerSymbol]),
+    symbolId: compiler.symbolId,
+    signatureHash: hashSemanticValue([input.language, declaration.symbolKind, compiler.identity, compiler.compilerSymbol, compiler.compilerType]),
     metadata: {
       ...declaration.metadata,
-      compilerSymbol,
-      compilerSymbolIdentityHash: hashSemanticValue(compilerSymbol)
+      compilerSymbol: compiler.compilerSymbol,
+      compilerSymbolIdentityHash: compiler.compilerSymbolIdentityHash,
+      compilerType: compiler.compilerType,
+      compilerTypeIdentityHash: compiler.compilerTypeIdentityHash
     }
   };
 }
 
-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 compactRecord(record) {
   return Object.fromEntries(Object.entries(record).filter(([, value]) => value !== undefined));
 }

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

@@ -1,10 +1,11 @@
 import{idFragment}from'../../native-import-utils.js';
-import{declarationRecord}from'./declarationRecord.js';import{identifierName}from'./identifierName.js';import{stringFromTsExpression}from'./stringFromTsExpression.js';
+import{declarationRecord}from'./declarationRecord.js';import{dynamicImportExpressionMetadata}from'./dynamicImportExpressionMetadata.js';import{identifierName}from'./identifierName.js';import{hostModuleDependencyMetadata}from'./importMetaUrlDependencyMetadata.js';import{moduleImportAttributeMetadata}from'./moduleImportAttributeMetadata.js';import{stringFromTsExpression}from'./stringFromTsExpression.js';
 export function typeScriptModuleDeclarationEntries(node, kind, nativeNodeId, input) {
   if (kind === 'ImportDeclaration') return importDeclarationEntries(node, nativeNodeId, input);
   if (kind === 'ImportEqualsDeclaration') return importEqualsDeclarationEntries(node, nativeNodeId, input);
-  if (kind === 'ExportDeclaration') return exportDeclarationEntries(node, nativeNodeId, input);
-  if (kind === 'ExportAssignment') return exportAssignmentEntries(node, nativeNodeId, input);
+  if (kind === 'CallExpression' && isDynamicImportCall(node)) return dynamicImportExpressionEntries(node, nativeNodeId, input);
+  if (kind === 'CallExpression' || kind === 'NewExpression') { const dependencies = hostModuleDependencyMetadata(node, { kind }); if (dependencies.length) return dependencies.flatMap((dependency) => importModuleEntries(input, nativeNodeId, dependency.moduleSpecifier, 'HostModuleDependency', [], dependency.metadata)); }
+  if (kind === 'ExportDeclaration') return exportDeclarationEntries(node, nativeNodeId, input); if (kind === 'ExportAssignment') return exportAssignmentEntries(node, nativeNodeId, input);
   return undefined;
 }
 
@@ -16,7 +17,8 @@ function importDeclarationEntries(node, nativeNodeId, input) {
   return importModuleEntries(input, nativeNodeId, moduleSpecifier, 'ImportDeclaration', bindings, {
     typeOnly,
     sideEffectOnly: bindings.length === 0,
-    importKind: bindings.length === 0 ? 'side-effect' : 'module'
+    importKind: bindings.length === 0 ? 'side-effect' : 'module',
+    ...moduleImportAttributeMetadata(node)
   });
 }
 
@@ -34,6 +36,16 @@ function importEqualsDeclarationEntries(node, nativeNodeId, input) {
   }], { typeOnly, importKind: 'commonjs-require' });
 }
 
+function dynamicImportExpressionEntries(node, nativeNodeId, input) {
+  const firstArgument = node.arguments?.[0], moduleSpecifier = firstArgument ? stringLiteralFromTsExpression(firstArgument) ?? '<dynamic-import>' : undefined;
+  if (!moduleSpecifier) return [];
+  return importModuleEntries(input, nativeNodeId, moduleSpecifier, 'DynamicImportExpression', [], {
+    importKind: 'dynamic-import',
+    dynamicImport: true, ...dynamicImportExpressionMetadata(firstArgument, moduleSpecifier),
+    ...moduleImportAttributeMetadata(node)
+  });
+}
+
 function exportDeclarationEntries(node, nativeNodeId, input) {
   const moduleSpecifier = stringFromTsExpression(node.moduleSpecifier);
   const typeOnly = Boolean(node.isTypeOnly);
@@ -46,14 +58,16 @@ function exportDeclarationEntries(node, nativeNodeId, input) {
       reexport: true,
       exportStar,
       namespaceReExport,
-      importKind: exportStar ? 'reexport' : 'reexport'
+      importKind: exportStar ? 'reexport' : 'reexport',
+      ...moduleImportAttributeMetadata(node)
     }) : []),
     ...exportModuleEntries(input, nativeNodeId, moduleSpecifier, bindings, {
       typeOnly,
       exportStar,
       reExport: Boolean(moduleSpecifier),
       namespaceReExport,
-      exportKind: exportStar ? 'export-star' : 'named'
+      exportKind: exportStar ? 'export-star' : 'named',
+      ...moduleImportAttributeMetadata(node)
     })
   ];
 }
@@ -177,10 +191,10 @@ function importModuleEntries(input, nativeNodeId, moduleSpecifier, _languageKind
       metadata: moduleMetadata('typescript-import', bindings, metadata)
     })
   };
-  return [moduleEntry, ...bindings.map((binding) => importBindingEntry(input, nativeNodeId, moduleSpecifier, binding))];
+  return [moduleEntry, ...bindings.map((binding) => importBindingEntry(input, nativeNodeId, moduleSpecifier, binding, metadata))];
 }
 
-function importBindingEntry(input, nativeNodeId, moduleSpecifier, binding) {
+function importBindingEntry(input, nativeNodeId, moduleSpecifier, binding, metadata = {}) {
   const declaration = compactRecord({
     ...declarationRecord(input, nativeNodeId, binding.localName, 'import', 'import'),
     symbolId: `symbol:${input.language}:import:${idFragment(`${moduleSpecifier}:${binding.localName}:${binding.importedName}`)}`,
@@ -202,7 +216,7 @@ function importBindingEntry(input, nativeNodeId, moduleSpecifier, binding) {
       namespace: binding.namespace,
       importKind: binding.importKind,
       isTypeOnly: binding.isTypeOnly,
-      typeOnly: binding.isTypeOnly
+      typeOnly: binding.isTypeOnly, hasImportAttributes: metadata.hasImportAttributes, importAttributeCount: metadata.importAttributeCount, importAttributeKeys: metadata.importAttributeKeys, importAttributeHash: metadata.importAttributeHash, importAttributes: metadata.importAttributes
     })
   });
   return { declaration, symbolNode: binding.symbolNode };
@@ -225,10 +239,10 @@ function exportModuleEntries(input, nativeNodeId, moduleSpecifier, bindings, met
       metadata: moduleMetadata('typescript-export', bindings, metadata)
     })
   };
-  return [statement, ...bindings.map((binding) => exportBindingEntry(input, nativeNodeId, moduleSpecifier, binding))];
+  return [statement, ...bindings.map((binding) => exportBindingEntry(input, nativeNodeId, moduleSpecifier, binding, metadata))];
 }
 
-function exportBindingEntry(input, nativeNodeId, moduleSpecifier, binding) {
+function exportBindingEntry(input, nativeNodeId, moduleSpecifier, binding, metadata = {}) {
   const declaration = compactRecord({
     ...declarationRecord(input, nativeNodeId, binding.exportedName, 'export', 'export'),
     symbolId: `symbol:${input.language}:export:${idFragment(`${moduleSpecifier ?? 'local'}:${binding.exportedName}:${binding.localName}`)}`,
@@ -254,7 +268,7 @@ function exportBindingEntry(input, nativeNodeId, moduleSpecifier, binding) {
       isTypeOnly: binding.isTypeOnly,
       typeOnly: binding.isTypeOnly,
       reExport: binding.reExport,
-      publicContract: true
+      publicContract: true, hasImportAttributes: metadata.hasImportAttributes, importAttributeCount: metadata.importAttributeCount, importAttributeKeys: metadata.importAttributeKeys, importAttributeHash: metadata.importAttributeHash, importAttributes: metadata.importAttributes
     })
   });
   return { declaration, symbolNode: binding.symbolNode };
@@ -269,7 +283,13 @@ function moduleMetadata(scan, bindings, metadata) {
     exportKind: metadata.exportKind,
     isTypeOnly: metadata.typeOnly,
     typeOnly: metadata.typeOnly,
-    sideEffectOnly: metadata.sideEffectOnly,
+    sideEffectOnly: metadata.sideEffectOnly, dynamicImport: metadata.dynamicImport,
+    dynamicImportSpecifierKind: metadata.dynamicImportSpecifierKind, dynamicImportExpressionText: metadata.dynamicImportExpressionText, dynamicImportExpressionHash: metadata.dynamicImportExpressionHash, dynamicImportStaticSpecifierEvidence: metadata.dynamicImportStaticSpecifierEvidence, dynamicImportRuntimeResolutionClaim: metadata.dynamicImportRuntimeResolutionClaim, dynamicImportResolutionProofRequired: metadata.dynamicImportResolutionProofRequired, hostDependency: metadata.hostDependency, hostDependencyKind: metadata.hostDependencyKind, hostDependencyBase: metadata.hostDependencyBase, hostDependencyExpressionText: metadata.hostDependencyExpressionText, hostDependencyExpressionHash: metadata.hostDependencyExpressionHash, hostDependencyStaticSpecifierEvidence: metadata.hostDependencyStaticSpecifierEvidence, hostDependencyRuntimeResolutionClaim: metadata.hostDependencyRuntimeResolutionClaim, hostDependencyResolutionProofRequired: metadata.hostDependencyResolutionProofRequired,
+    hasImportAttributes: metadata.hasImportAttributes,
+    importAttributeCount: metadata.importAttributeCount,
+    importAttributeKeys: metadata.importAttributeKeys,
+    importAttributeHash: metadata.importAttributeHash,
+    importAttributes: metadata.importAttributes,
     reexport: metadata.reexport,
     reExport: metadata.reExport,
     namespaceReExport: metadata.namespaceReExport,
@@ -278,6 +298,23 @@ function moduleMetadata(scan, bindings, metadata) {
   });
 }
 
-function compactRecord(record) {
-  return Object.fromEntries(Object.entries(record).filter(([, value]) => value !== undefined));
+function compactRecord(record) { return Object.fromEntries(Object.entries(record).filter(([, value]) => value !== undefined)); }
+
+function isDynamicImportCall(node) {
+  return Array.isArray(node?.arguments) && node.arguments.length > 0 && typeScriptExpressionText(node.expression) === 'import';
+}
+
+function typeScriptExpressionText(node) {
+  if (!node) return undefined;
+  if (typeof node.getText === 'function') {
+    try { return node.getText(); } catch {}
+  }
+  if (typeof node.kindName === 'string') return node.kindName === 'ImportKeyword' ? 'import' : node.kindName;
+  if (node.kind === 'ImportKeyword') return 'import';
+  return undefined;
+}
+
+function stringLiteralFromTsExpression(node) {
+  if (!node) return undefined; if (typeof node.value === 'string') return node.value;
+  const rawText = typeof node.text === 'string' && typeof node.escapedText !== 'string' ? typeScriptExpressionText(node) : undefined; return rawText && /^['"`]/.test(rawText) ? node.text : undefined;
 }