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

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

@@ -1,8 +1,32 @@
-import{idFragment}from'../../native-import-utils.js';
-import{declarationRecord}from'./declarationRecord.js';
+import {
+  commonJsExpressionStatementEntries,
+  commonJsExportAssignmentEntries,
+  commonJsRequireVariableEntries
+} from './syntaxCommonJsModuleDeclarationEntries.js';
+import { dynamicImportExpressionMetadata } from './dynamicImportExpressionMetadata.js';
+import { hostModuleDependencyMetadata } from './importMetaUrlDependencyMetadata.js';
+import { moduleImportAttributeMetadata } from './moduleImportAttributeMetadata.js';
+import {
+  declarationName,
+  declarationTypeOnly,
+  exportBindingEntry,
+  exportModuleEntries,
+  identifierName,
+  importModuleEntries,
+  sourceValue
+} from './syntaxModuleEntryRecords.js';
+
+const UNKNOWN_DYNAMIC_IMPORT_MODULE_SPECIFIER = '<dynamic-import>';
+
 export function syntaxModuleDeclarationEntries(node, nativeNodeId, input) {
   const kind = String(node.type ?? node.kind ?? '');
   if (kind === 'ImportDeclaration') return importDeclarationEntries(node, nativeNodeId, input);
+  if (kind === 'VariableDeclarator') return commonJsRequireVariableEntries(node, nativeNodeId, input);
+  if (kind === 'ExpressionStatement') return commonJsExpressionStatementEntries(node, nativeNodeId, input);
+  if (kind === 'AssignmentExpression') return commonJsExportAssignmentEntries(node, nativeNodeId, input);
+  if (kind === 'ImportExpression') return dynamicImportExpressionEntries(node, nativeNodeId, input);
+  if (kind === 'CallExpression' && isDynamicImportCall(node)) return dynamicImportExpressionEntries(node, nativeNodeId, input);
+  if (kind === 'CallExpression' || kind === 'NewExpression') return hostModuleDependencyEntries(node, nativeNodeId, input);
   if (kind === 'ExportNamedDeclaration') return exportNamedDeclarationEntries(node, nativeNodeId, input);
   if (kind === 'ExportAllDeclaration') return exportAllDeclarationEntries(node, nativeNodeId, input);
   if (kind === 'ExportDefaultDeclaration') return exportDefaultDeclarationEntries(node, nativeNodeId, input);
@@ -17,10 +41,28 @@ function importDeclarationEntries(node, nativeNodeId, input) {
   return importModuleEntries(input, nativeNodeId, moduleSpecifier, bindings, {
     typeOnly,
     sideEffectOnly: bindings.length === 0,
-    importKind: bindings.length === 0 ? 'side-effect' : 'module'
+    importKind: bindings.length === 0 ? 'side-effect' : 'module',
+    ...moduleImportAttributeMetadata(node)
   });
 }
 
+function dynamicImportExpressionEntries(node, nativeNodeId, input) {
+  const importArgument = node.source ?? (node.arguments ?? [])[0];
+  if (!importArgument) return [];
+  const moduleSpecifier = sourceValue(importArgument) ?? UNKNOWN_DYNAMIC_IMPORT_MODULE_SPECIFIER;
+  return importModuleEntries(input, nativeNodeId, moduleSpecifier, [], {
+    importKind: 'dynamic-import',
+    dynamicImport: true,
+    ...dynamicImportExpressionMetadata(importArgument, moduleSpecifier),
+    ...moduleImportAttributeMetadata(node)
+  });
+}
+
+function hostModuleDependencyEntries(node, nativeNodeId, input) {
+  return hostModuleDependencyMetadata(node, { kind: String(node.type ?? node.kind ?? '') }).flatMap((dependency) =>
+    importModuleEntries(input, nativeNodeId, dependency.moduleSpecifier, [], dependency.metadata));
+}
+
 function exportNamedDeclarationEntries(node, nativeNodeId, input) {
   const moduleSpecifier = sourceValue(node.source);
   const typeOnly = node.exportKind === 'type';
@@ -32,12 +74,14 @@ function exportNamedDeclarationEntries(node, nativeNodeId, input) {
     ...(moduleSpecifier ? importModuleEntries(input, nativeNodeId, moduleSpecifier, reExportImportBindings(bindings), {
       typeOnly,
       reexport: true,
-      importKind: 'reexport'
+      importKind: 'reexport',
+      ...moduleImportAttributeMetadata(node)
     }) : []),
     ...exportModuleEntries(input, nativeNodeId, moduleSpecifier, bindings, {
       typeOnly,
       reExport: Boolean(moduleSpecifier),
-      exportKind: typeOnly ? 'type-named' : 'named'
+      exportKind: typeOnly ? 'type-named' : 'named',
+      ...moduleImportAttributeMetadata(node)
     })
   ];
 }
@@ -62,13 +106,15 @@ function exportAllDeclarationEntries(node, nativeNodeId, input) {
       typeOnly,
       reexport: true,
       exportStar: !exportedName,
-      importKind: exportedName ? 'namespace-reexport' : 'reexport'
+      importKind: exportedName ? 'namespace-reexport' : 'reexport',
+      ...moduleImportAttributeMetadata(node)
     }),
     ...exportModuleEntries(input, nativeNodeId, moduleSpecifier, bindings, {
       typeOnly,
       reExport: true,
       exportStar: !exportedName,
-      exportKind: exportedName ? 'namespace-reexport' : 'export-star'
+      exportKind: exportedName ? 'namespace-reexport' : 'export-star',
+      ...moduleImportAttributeMetadata(node)
     })
   ];
 }
@@ -151,129 +197,7 @@ function reExportImportBindings(bindings) {
   }));
 }
 
-function importModuleEntries(input, nativeNodeId, moduleSpecifier, bindings, metadata) {
-  return [{
-    declaration: compactRecord({
-      ...declarationRecord(input, nativeNodeId, moduleSpecifier, 'module', 'import'),
-      importPath: moduleSpecifier,
-      moduleSpecifier,
-      importKind: metadata.importKind,
-      isTypeOnly: metadata.typeOnly,
-      exportStar: metadata.exportStar,
-      metadata: moduleMetadata('syntax-import', bindings, metadata)
-    })
-  }, ...bindings.map((binding) => importBindingEntry(input, nativeNodeId, moduleSpecifier, binding))];
-}
-
-function importBindingEntry(input, nativeNodeId, moduleSpecifier, binding) {
-  return {
-    declaration: compactRecord({
-      ...declarationRecord(input, nativeNodeId, binding.localName, 'import', 'import'),
-      symbolId: `symbol:${input.language}:import:${idFragment(`${moduleSpecifier}:${binding.localName}:${binding.importedName}`)}`,
-      importPath: moduleSpecifier,
-      moduleSpecifier,
-      localName: binding.localName,
-      importedName: binding.importedName,
-      exportedName: binding.exportedName,
-      namespace: binding.namespace,
-      importKind: binding.importKind,
-      isTypeOnly: binding.isTypeOnly,
-      metadata: bindingMetadata('syntax-import-binding', moduleSpecifier, binding)
-    })
-  };
-}
-
-function exportModuleEntries(input, nativeNodeId, moduleSpecifier, bindings, metadata) {
-  const statementName = metadata.exportStar
-    ? `* from ${moduleSpecifier}`
-    : moduleSpecifier ? `{${bindings.map((binding) => binding.exportedName).join(',')}} from ${moduleSpecifier}` : `{${bindings.map((binding) => binding.exportedName).join(',')}}`;
-  return [{
-    declaration: compactRecord({
-      ...declarationRecord(input, nativeNodeId, statementName, 'module', 'export'),
-      exportPath: moduleSpecifier,
-      moduleSpecifier,
-      exportKind: metadata.exportKind,
-      exportStar: metadata.exportStar,
-      isTypeOnly: metadata.typeOnly,
-      reExport: metadata.reExport,
-      publicContract: true,
-      metadata: moduleMetadata('syntax-export', bindings, metadata)
-    })
-  }, ...bindings.map((binding) => exportBindingEntry(input, nativeNodeId, moduleSpecifier, binding))];
-}
-
-function exportBindingEntry(input, nativeNodeId, moduleSpecifier, binding) {
-  return {
-    declaration: compactRecord({
-      ...declarationRecord(input, nativeNodeId, binding.exportedName, 'export', 'export'),
-      symbolId: `symbol:${input.language}:export:${idFragment(binding.exportedName)}`,
-      exportPath: moduleSpecifier,
-      moduleSpecifier,
-      localName: binding.localName,
-      importedName: binding.importedName,
-      exportedName: binding.exportedName,
-      namespace: binding.namespace,
-      exportKind: binding.exportKind,
-      isTypeOnly: binding.isTypeOnly,
-      reExport: binding.reExport,
-      publicContract: true,
-      metadata: bindingMetadata('syntax-export-binding', moduleSpecifier, binding, true)
-    })
-  };
-}
-
-function moduleMetadata(scan, bindings, metadata) {
-  return compactRecord({
-    scan,
-    moduleOnly: true,
-    bindingCount: bindings.length,
-    importKind: metadata.importKind,
-    exportKind: metadata.exportKind,
-    isTypeOnly: metadata.typeOnly,
-    typeOnly: metadata.typeOnly,
-    sideEffectOnly: metadata.sideEffectOnly,
-    reexport: metadata.reexport,
-    reExport: metadata.reExport,
-    exportStar: metadata.exportStar,
-    publicContract: metadata.reExport || metadata.exportKind
-  });
-}
-
-function bindingMetadata(scan, moduleSpecifier, binding, publicContract = false) {
-  return compactRecord({
-    scan,
-    moduleSpecifier,
-    importPath: moduleSpecifier,
-    exportPath: moduleSpecifier,
-    localName: binding.localName,
-    importedName: binding.importedName,
-    exportedName: binding.exportedName,
-    namespace: binding.namespace,
-    importKind: binding.importKind,
-    exportKind: binding.exportKind,
-    isTypeOnly: binding.isTypeOnly,
-    typeOnly: binding.isTypeOnly,
-    reExport: binding.reExport,
-    publicContract
-  });
-}
-
-function sourceValue(source) {
-  return typeof source?.value === 'string' ? source.value : undefined;
-}
-
-function identifierName(node) {
-  return typeof node?.name === 'string' ? node.name : typeof node?.value === 'string' ? node.value : undefined;
-}
-
-function declarationName(node) {
-  return identifierName(node?.id) ?? identifierName(node?.name);
-}
-
-function declarationTypeOnly(kind) {
-  return kind === 'TSInterfaceDeclaration' || kind === 'TSTypeAliasDeclaration' || kind === 'InterfaceDeclaration' || kind === 'TypeAliasDeclaration';
-}
-
-function compactRecord(record) {
-  return Object.fromEntries(Object.entries(record).filter(([, value]) => value !== undefined));
+function isDynamicImportCall(node) {
+  const calleeKind = String(node.callee?.type ?? node.callee?.kind ?? '');
+  return calleeKind === 'Import' || calleeKind === 'ImportKeyword' || identifierName(node.callee) === 'import';
 }

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

@@ -0,0 +1,160 @@
+import { idFragment } from '../../native-import-utils.js';
+import { declarationRecord } from './declarationRecord.js';
+
+export function importModuleEntries(input, nativeNodeId, moduleSpecifier, bindings, metadata) {
+  return [{
+    declaration: compactRecord({
+      ...declarationRecord(input, nativeNodeId, moduleSpecifier, 'module', 'import'),
+      importPath: moduleSpecifier,
+      moduleSpecifier,
+      importKind: metadata.importKind,
+      isTypeOnly: metadata.typeOnly,
+      exportStar: metadata.exportStar,
+      metadata: moduleMetadata('syntax-import', bindings, metadata)
+    })
+  }, ...bindings.map((binding) => importBindingEntry(input, nativeNodeId, moduleSpecifier, binding, metadata))];
+}
+
+export function importBindingEntry(input, nativeNodeId, moduleSpecifier, binding, metadata = {}) {
+  return {
+    declaration: compactRecord({
+      ...declarationRecord(input, nativeNodeId, binding.localName, 'import', 'import'),
+      symbolId: `symbol:${input.language}:import:${idFragment(`${moduleSpecifier}:${binding.localName}:${binding.importedName}`)}`,
+      importPath: moduleSpecifier,
+      moduleSpecifier,
+      localName: binding.localName,
+      importedName: binding.importedName,
+      exportedName: binding.exportedName,
+      namespace: binding.namespace,
+      importKind: binding.importKind,
+      isTypeOnly: binding.isTypeOnly,
+      commonJs: binding.commonJs,
+      metadata: bindingMetadata('syntax-import-binding', moduleSpecifier, binding, false, metadata)
+    })
+  };
+}
+
+export function exportModuleEntries(input, nativeNodeId, moduleSpecifier, bindings, metadata) {
+  const statementName = metadata.exportStar
+    ? `* from ${moduleSpecifier}`
+    : moduleSpecifier ? `{${bindings.map((binding) => binding.exportedName).join(',')}} from ${moduleSpecifier}` : `{${bindings.map((binding) => binding.exportedName).join(',')}}`;
+  return [{
+    declaration: compactRecord({
+      ...declarationRecord(input, nativeNodeId, statementName, 'module', 'export'),
+      exportPath: moduleSpecifier,
+      moduleSpecifier,
+      exportKind: metadata.exportKind,
+      exportStar: metadata.exportStar,
+      isTypeOnly: metadata.typeOnly,
+      reExport: metadata.reExport,
+      publicContract: true,
+      metadata: moduleMetadata('syntax-export', bindings, metadata)
+    })
+  }, ...bindings.map((binding) => exportBindingEntry(input, nativeNodeId, moduleSpecifier, binding, metadata))];
+}
+
+export function exportBindingEntry(input, nativeNodeId, moduleSpecifier, binding, metadata = {}) {
+  return {
+    declaration: compactRecord({
+      ...declarationRecord(input, nativeNodeId, binding.exportedName, 'export', 'export'),
+      symbolId: `symbol:${input.language}:export:${idFragment(binding.exportedName)}`,
+      exportPath: moduleSpecifier,
+      moduleSpecifier,
+      localName: binding.localName,
+      importedName: binding.importedName,
+      exportedName: binding.exportedName,
+      namespace: binding.namespace,
+      exportKind: binding.exportKind,
+      isTypeOnly: binding.isTypeOnly,
+      reExport: binding.reExport,
+      publicContract: true,
+      commonJs: binding.commonJs,
+      metadata: bindingMetadata('syntax-export-binding', moduleSpecifier, binding, true, metadata)
+    })
+  };
+}
+
+export function sourceValue(source) {
+  if (typeof source?.value === 'string') return source.value;
+  const kind = String(source?.type ?? source?.kind ?? '');
+  if (kind === 'TemplateLiteral' && (source.expressions ?? []).length === 0 && (source.quasis ?? []).length === 1) {
+    return source.quasis[0]?.value?.cooked ?? source.quasis[0]?.value?.raw;
+  }
+  return undefined;
+}
+
+export function identifierName(node) {
+  return typeof node?.name === 'string' ? node.name : typeof node?.value === 'string' ? node.value : undefined;
+}
+
+export function declarationName(node) {
+  return identifierName(node?.id) ?? identifierName(node?.name);
+}
+
+export function declarationTypeOnly(kind) {
+  return kind === 'TSInterfaceDeclaration' || kind === 'TSTypeAliasDeclaration' || kind === 'InterfaceDeclaration' || kind === 'TypeAliasDeclaration';
+}
+
+export function compactRecord(record) {
+  return Object.fromEntries(Object.entries(record).filter(([, value]) => value !== undefined));
+}
+
+function moduleMetadata(scan, bindings, metadata) {
+  return compactRecord({
+    scan,
+    moduleOnly: true,
+    bindingCount: bindings.length,
+    importKind: metadata.importKind,
+    exportKind: metadata.exportKind,
+    isTypeOnly: metadata.typeOnly,
+    typeOnly: metadata.typeOnly,
+    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,
+    commonJs: metadata.commonJs,
+    interopHelper: metadata.interopHelper,
+    reexport: metadata.reexport,
+    reExport: metadata.reExport,
+    exportStar: metadata.exportStar,
+    publicContract: metadata.reExport || metadata.exportKind
+  });
+}
+
+function bindingMetadata(scan, moduleSpecifier, binding, publicContract = false, metadata = {}) {
+  return compactRecord({
+    scan,
+    moduleSpecifier,
+    importPath: moduleSpecifier,
+    exportPath: moduleSpecifier,
+    localName: binding.localName,
+    importedName: binding.importedName,
+    exportedName: binding.exportedName,
+    namespace: binding.namespace,
+    importKind: binding.importKind,
+    exportKind: binding.exportKind,
+    isTypeOnly: binding.isTypeOnly,
+    typeOnly: binding.isTypeOnly,
+    reExport: binding.reExport,
+    publicContract, hasImportAttributes: metadata.hasImportAttributes, importAttributeCount: metadata.importAttributeCount, importAttributeKeys: metadata.importAttributeKeys, importAttributeHash: metadata.importAttributeHash, importAttributes: metadata.importAttributes,
+    commonJs: binding.commonJs,
+    interopHelper: binding.interopHelper ?? metadata.interopHelper
+  });
+}

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