@shapeshift-labs/frontier-lang-compiler 0.2.188 → 0.2.189

package/README.md

@@ -558,7 +558,7 @@ Current JS/TS semantic-merge status matrix:
 | CSS runtime descriptor evidence | bounded-evidence | CSS runtime descriptor proof uses `cssRuntimeDescriptorFiles`, `cssRuntimeDescriptorEvidenceFiles`, property/page descriptor counters, and the `css-runtime-descriptor-evidence` proof status for parser-backed `@property` syntax/inherits/initial-value evidence plus `@page` descriptor and margin-box records. It is source/shape-key evidence only; browser cascade, render, and runtime equivalence remain in the separate browser proof row. |
 | HTML/CSS browser runtime proof | bounded-evidence | HTML/CSS browser proof is an explicit separate row tracked by `htmlCssBrowserRuntimeProofs`, the `html-css-browser-runtime-proof` surface, and the `browser-runtime-proof` proof status. Structural source merges keep browser/render/cascade equivalence claims false unless a bounded browser proof bundle is attached; HTML runtime-boundary proofs and CSS cascade runtime proofs must include source hashes, a runtime command, probe id, evidence hash, and the required runtime signal. Missing proof routes to `prove-html-css-browser-runtime`. |
 | Parser/source-span/trivia evidence | Partial | Source preservation, source hashes, runtime directive-prologue entries, directives, comments/trivia summaries, project `sourceFileRecords` / `sourceSpanRecords`, protected-span hashes, shebang file-entrypoint directive ownership anchors, `sourceMappingURL` and `sourceURL` generated-boundary source-map spans, deterministic source-map generated-boundary ownership keys from supplied exact source/generated spans and hashes, generated-boundary position conflict evidence, deterministic ownership anchors, source-span/trivia ownership blockers, exact parser-trivia ownership records for directive prologues plus leading/trailing comments and JSDoc/block-comment spans when parser evidence matches the source hash, TypeScript `SourceFile` compiler-scanner exact token/trivia source-preservation evidence for JS/TS/JSX/TSX imports, ESTree/Babel parser token/comment range evidence when the supplied AST covers every non-whitespace byte of the current source, fail-closed scanner/ledger spoof blockers, source-span delta conflicts, parser roundtrip proof records, failed source-span roundtrip proof admission blockers, project-merge stage parser-trivia evidence from supplied parser-backed imports for base/worker/head/output, metadata-only exactness blockers for scanner fallbacks, and fixture corpus checks. Parser-backed exactness also requires contiguous current-source token/comment/trivia coverage with no gaps, overlaps, truncation, or text mismatches; truncated coverage blocks exact token/comment ownership. Adapters without token/comment ranges remain approximate/caller evidence, not exact parser trivia. |
-| Scope/use-def graph | Partial | Lightweight lexical scope/use-def scans, destructuring alias binding records, object/array/nested/rest/default-initializer parameter binding evidence for function and arrow parameters, default import alias reads through re-export chains when a stable default-export local binding is observed, fail-closed `lexical-scope-import-alias-target-unresolved` records when an alias target cannot be tied to a lexical binding, namespace import dot and literal/static-template computed member-read evidence, blocked evidence for ambiguous computed namespace reads and namespace member writes, `this`/`super` receiver member read/write evidence including computed string and static-template members, optional chaining markers, and TypeScript checker-backed receiver-member reference proof for full `this`/`super` access spans including private identifiers, template-literal interpolation live-reference records with expression hashes plus tagged-template site/tag root/member metadata, caller-supplied ESTree/scope-manager structural evidence normalization, closure-capture depth/owner/reference hashes, binding-level closure capture hashes, project `scopeBindingRecords` / `scopeReferenceRecords`, public owner use hashes, public scope-use and reference-site delta conflicts with alias target route/use-hash evidence, TypeScript compiler reference relations when a checker is supplied, exact compiler reference-site proof hashes on scope reference records, fail-closed `typescript-compiler-reference-site-ambiguous`, `typescript-compiler-reference-lexical-binding-mismatch`, and `typescript-compiler-reference-import-alias-target-mismatch` records when compiler alias evidence cannot be reconciled with the lexical route or re-export/import target, and dependency-sensitive fixture coverage. Full whole-program binding/control-flow resolution is still caller/compiler-evidence bounded. |
+| Scope/use-def graph | Partial | Lightweight lexical scope/use-def scans, destructuring alias binding records, object/array/nested/rest/default-initializer parameter binding evidence for function and arrow parameters, default import alias reads through re-export chains when a stable default-export local binding is observed, source-bound anonymous default export fallback evidence for resolved default re-export chains with source hash/span and source symbol hashes, fail-closed `lexical-scope-import-alias-target-unresolved` records when an alias target cannot be tied to either lexical binding or source-bound anonymous default evidence, namespace import dot and literal/static-template computed member-read evidence, blocked evidence for ambiguous computed namespace reads and namespace member writes, `this`/`super` receiver member read/write evidence including computed string and static-template members, optional chaining markers, and TypeScript checker-backed receiver-member reference proof for full `this`/`super` access spans including private identifiers, template-literal interpolation live-reference records with expression hashes plus tagged-template site/tag root/member metadata, caller-supplied ESTree/scope-manager structural evidence normalization, closure-capture depth/owner/reference hashes, binding-level closure capture hashes, project `scopeBindingRecords` / `scopeReferenceRecords`, public owner use hashes, public scope-use and reference-site delta conflicts with alias target route/use-hash evidence, TypeScript compiler reference relations when a checker is supplied, exact compiler reference-site proof hashes on scope reference records, fail-closed `typescript-compiler-reference-site-ambiguous`, `typescript-compiler-reference-lexical-binding-mismatch`, and `typescript-compiler-reference-import-alias-target-mismatch` records when compiler alias evidence cannot be reconciled with the lexical route or re-export/import target, and dependency-sensitive fixture coverage. Full whole-program binding/control-flow resolution is still caller/compiler-evidence bounded. |
 | Module/export/import graph | Partial | Project graph stages, module resolution, runtime-neutral package manifest conversion from in-memory `package.json` objects/text, duplicate workspace-root package-name ambiguity diagnostics and fail-closed `package-workspace-root-ambiguous-missing` edges with `packageWorkspaceRoots` evidence, package exports/imports including wildcard package export key/target evidence, fail-closed package `imports` condition misses, runtime-ambiguous `import`/`require` condition blockers, caller-supplied package type runtime-condition evidence for `.js`/`.ts` package exports/imports, caller-supplied package environment-condition evidence such as `browser`, fail-closed `package-export-environment-ambiguous-missing` / `package-import-environment-ambiguous-missing` blockers with condition candidates when environment targets such as `browser` and `node` diverge without explicit evidence, and fail-closed host-runtime ambiguity blockers for non-resolver host package specifiers with divergent `import`/`require` targets, re-export identities including static TypeScript-style CommonJS bare and `tslib_1.__...` member-form `__exportStar(require("./dep"), exports)` fanout and `__createBinding(exports, require("./dep"), "name", "alias")` named re-export fanout, same-document CommonJS require-alias getter re-export identities for descriptor `get: function () { return dep.name; }`, named descriptor `get: function getName() { return dep.name; }`, shorthand `get() { return dep.name; }`, and block-bodied arrow `get: () => { return dep.name; }`, TypeScript-style CommonJS bare and `tslib_1.__...` member-form `__importDefault(require("./dep"))` and `__importStar(require("./dep"))` helper import edges, CommonJS `module.exports` default-import interop when no direct `default` export exists, literal computed CommonJS export properties such as `exports["default"]`, static `module.exports = { named }`, `Object.assign(exports, { named })`, `Object.defineProperty(exports, "named", { value/get })`, and `Object.defineProperties(exports, { named: { value/get } })` export maps in lightweight and AST-backed imports, ESTree/Babel no-expression `TemplateLiteral` normalization for CommonJS `require`, computed export keys, descriptor export specifiers, dynamic `import()`, CommonJS helper re-export specifiers, and host dependency specifiers while expression-bearing templates stay unresolved, TypeScript compiler no-substitution dynamic import and host dependency template evidence, `exports.__esModule` marker filtering, import-target deltas for head-introduced CommonJS export assignments, namespace/ambient module/global augmentation/export-assignment static shape records with proof hashes and no runtime-equivalence claim, fail-closed namespace/export-assignment shape delta conflicts, non-literal dynamic `import()` pseudo-specifiers with expression kind/text/hash evidence and fail-closed resolution evidence, static `new URL(specifier, import.meta.url)`, `Worker`, `SharedWorker`, `serviceWorker.register`, worklet `addModule`, `importScripts`, `import.meta.resolve`, and `require.resolve` host dependency edges with expression hashes and no runtime-resolution claim, dynamic host dependency targets emitted as `<host-dependency>` with expression hashes, `hostDependencyStaticSpecifierEvidence: false`, and proof-required unresolved evidence, import-attribute/import-assertion normalized key/value/count/hash evidence on static imports, dynamic imports, and re-exports, import-attribute delta conflicts, output graph unresolved-module conflicts that preserve edge-level fail-closed package, host, dynamic import, and import-attribute value evidence, and output graph resolved-module missing-export conflicts that preserve edge-level package and import-attribute evidence. Host filesystem/package graph crawling, namespace runtime evaluation, ambient/global compatibility, and CommonJS runtime interop equivalence remain out of the root API. |
 | Type/public API graph | Partial | Public-contract regions, signature/contract hashes, TypeScript compiler symbol/type records, source-bound checker proof source path/hash requirements, compiler-backed type-reference target proof that binds public API type references to resolved target symbols, declaration spans, and declaration source text hashes, inferred exported factory call-signature evidence, compiler-backed public call/construct signature shape evidence and proof hashes, exported overload declaration/signature counts, compiler-backed overload signature-set proof, compiler-backed generic type-parameter/default proof, compiler-backed public member property/method property-set proof, compiler-backed public index-signature key/value/readonly evidence and proof hashes, stable public-surface hashes that ignore transient TypeScript symbol flags, compiler-backed class heritage and constructor-signature evidence/proof hashes, compiler-backed private class member and accessor-field static shape records/proof hashes plus source- and required-signal-bound private/accessor runtime proof binding with command/trace/evidence hashes, private brand, private method, private accessor, static private, subclass brand-boundary, and accessor descriptor trace slots, and false claim flags, compiler-backed class/member/parameter decorator target and expression static metadata records/proof hashes plus source-bound decorator runtime execution proof binding with trace hashes and false claim flags, compiler-backed enum runtime-shape/member-value evidence and proof hashes, TypeScript compiler importer support for source-bound computed enum evaluated-value traces with emitted-shape hashes, trace/evidence hashes, and false claim flags, compiler-backed conditional, indexed-access, mapped, `keyof`, template-literal, `infer`, union, intersection, tuple, and mixed known advanced/composite type-shape proof hashes, static compiler-backed inference syntax evidence/proof hashes for `satisfies`, `as const`, and const type parameters, bounded TypeChecker `isTypeAssignableTo` oracle proof for simple public type aliases with source path/hash binding and fail-closed `typescript-public-api-type-equivalence-proof-missing` for missing or ambiguous oracle evidence, class private/accessor/decorator/class/enum/advanced-shape/composite-shape/inference-syntax/index-signature/callable-signature/type-reference-target hashes in public compiler-type delta fingerprints, fail-closed missing-proof blockers for missing public API source hashes, type-reference target proof hashes, call/construct signature return/parameter evidence, constructor/class-heritage/private-class-member/accessor-field/index-signature value-type/enum runtime-shape/conditional-branch/indexed-access object-index-result/mapped constraint-value/`keyof` target/template-literal span/`infer` type-parameter/union member/intersection member/tuple element evidence, fail-closed computed enum runtime-value blockers when source-bound evaluated-value proof is missing, stale, trace-incomplete, value-incomplete, or claim-bearing, fail-closed private/accessor and decorator runtime execution blockers when source-bound trace proof is missing, stale, trace-incomplete, schema/kind-mismatched, required-signal-incomplete, commandless, or claim-bearing, fail-closed unknown advanced type-shape evidence, unsupported type-equivalence reason codes, public compiler-type delta conflicts, declaration-output gate, TypeScript declaration emit parity proof for worker/head/output public boundaries, and project graph delta conflicts. Full type-equivalence, broad decorator execution equivalence beyond source-bound trace proofs, broad enum runtime evaluation beyond source-bound computed-value traces, broad runtime equivalence for private/accessor execution beyond source-bound trace proofs, or broad inference-semantics proof beyond these focused compiler-backed cases is not claimed. |
 | JSX/TSX element and prop graph | Partial | JSX attribute/child-expression safe-merge fallbacks, conditional child-expression blockers, keyed-child insertion evidence, keyed named Fragment insertion evidence, planned-output duplicate-key checks, top-level `key` attribute scanning that does not treat `data-key` as stable identity, deterministic shorthand-fragment/spread/reorder/same-gap blockers, spread-attribute records/expression hashes, spread/explicit prop precedence blockers, component prop diagnostic gates, project `jsxElementRecords` / `jsxPropRecords`, public owner prop and keyed child-order hashes, typed public key/fragment evidence, literal/shorthand/reference/static optional-chain JSX prop-value callsite records/hashes with `jsx-render-prop-value-literal-evidence`, `jsx-render-prop-value-static-reference-evidence`, and `jsx-render-prop-value-static-optional-reference-evidence`, dynamic prop-value blockers such as `jsx-render-prop-value-computed-reference-unsupported`, `jsx-render-prop-value-call-expression-unsupported`, and `jsx-render-prop-value-optional-reference-unsupported`, same-file plain/member and project-local named/default/barrel-import plain/member static component prop passthrough evidence with `jsx-render-component-prop-flow-static-passthrough-evidence`, dynamic component prop passthrough blockers with `jsx-render-component-prop-flow-dynamic-value-unsupported`, component prop render-flow blockers with `jsx-render-component-prop-flow-unsupported`, provider ancestor path/count/hash evidence for context-provider nesting, context provider value prop records/hashes with literal provider value evidence, static identifier/member reference-binding evidence, static optional-chain reference-binding evidence, static call-free object/array value evidence, or `jsx-render-context-provider-value-unsupported` plus provider-value dynamic blocker metadata (`dynamicBlockerReasonCode` values such as `jsx-render-context-provider-value-call-expression-unsupported` and `jsx-render-context-provider-value-computed-reference-unsupported`) for call/computed/optional/spread values, context consumer target records/hashes with static identifier/member target evidence, static optional target evidence, or `jsx-render-context-consumer-target-unsupported` plus dynamic-target blockers for computed/call targets, static lexical provider-ancestor lookup records/hashes for matching context consumers with `jsx-render-context-consumer-provider-lookup-static-evidence`, same-file direct component provider lookup evidence for plain identifier callsites and same-file member component provider lookup evidence for static object-literal callsites such as `UI.Child` with `jsx-render-context-consumer-provider-component-lookup-static-evidence`, same-file `{children}` / `props.children` / `this.props.children` provider-flow evidence for components that render children directly inside a static provider with `jsx-render-context-consumer-provider-component-flow-static-evidence`, project-local named/aliased named/default component-import and member-object provider lookup evidence plus explicit named/default, member-object, and unique star barrel re-export component evidence with `jsx-render-context-consumer-provider-project-component-lookup-static-evidence`, project-import children-flow evidence with `jsx-render-context-consumer-provider-project-component-flow-static-evidence`, while dynamic/ambiguous member, unresolved, external-runtime, and ambiguous-star component targets emit `jsx-render-context-consumer-provider-component-target-unsupported`, hook call-order/count/hash render-risk evidence, hook dependency-array records/counts/hashes with per-item literal/reference/static optional-reference evidence, dynamic computed/call blocker reason codes, static dependency-set evidence, or `jsx-render-hook-dependency-array-unsupported` for dynamic dependency expressions, effect-hook callback/cleanup records/counts/hashes with static callback/cleanup source evidence, callback reference-path metadata, static optional callback/cleanup evidence, dynamic callback/cleanup blocker reason codes, runtime-equivalence-unproved evidence, or `jsx-render-hook-effect-unsupported` for dynamic effect factories and cleanup returns, public component render-return records/counts/hashes with static return-expression evidence, static array/fragment return collection child records/hashes, plus `jsx-render-return-branch-unsupported` for branchy/conditional returns, static `memo` / `forwardRef` / `observer` / `React.lazy` component-wrapper render-risk records including lazy import-factory evidence and lazy-load/runtime proof gaps, event-handler prop records/counts/hashes with static handler-reference evidence, static optional handler-reference evidence, static inline handler expression evidence, same-owner local handler declaration hashes via `jsx-render-event-handler-local-declaration-evidence`, or `jsx-render-event-handler-prop-unsupported` with computed/call blocker metadata for handler factory/call expressions, and public JSX prop/spread/child-order/render-risk delta conflicts produce review/blocking evidence with reason codes such as `jsx-render-context-provider-nesting-unsupported`, `jsx-render-prop-value-literal-evidence`, `jsx-render-prop-value-static-reference-evidence`, `jsx-render-prop-value-static-optional-reference-evidence`, `jsx-render-prop-value-unsupported`, `jsx-render-component-prop-flow-static-passthrough-evidence`, `jsx-render-component-prop-flow-dynamic-value-unsupported`, `jsx-render-component-prop-flow-unsupported`, `jsx-render-context-provider-value-literal-evidence`, `jsx-render-context-provider-value-static-reference-evidence`, `jsx-render-context-provider-value-static-optional-reference-evidence`, `jsx-render-context-provider-value-static-data-evidence`, `jsx-render-context-provider-value-unsupported`, `jsx-render-context-consumer-target-static-evidence`, `jsx-render-context-consumer-target-static-optional-reference-evidence`, `jsx-render-context-consumer-provider-lookup-static-evidence`, `jsx-render-context-consumer-provider-component-lookup-static-evidence`, `jsx-render-context-consumer-provider-component-flow-static-evidence`, `jsx-render-context-consumer-provider-project-component-lookup-static-evidence`, `jsx-render-context-consumer-provider-project-component-flow-static-evidence`, `jsx-render-context-consumer-provider-component-target-unsupported`, `jsx-render-context-consumer-target-unsupported`, `jsx-render-hook-call-order-unsupported`, `jsx-render-hook-dependency-array-static-evidence`, `jsx-render-hook-dependency-array-unsupported`, `jsx-render-hook-effect-static-callback-evidence`, `jsx-render-hook-effect-static-optional-callback-evidence`, `jsx-render-hook-effect-static-cleanup-evidence`, `jsx-render-hook-effect-static-optional-cleanup-evidence`, `jsx-render-hook-effect-runtime-equivalence-unproved`, `jsx-render-hook-effect-unsupported`, `jsx-render-return-static-evidence`, `jsx-render-return-array-static-evidence`, `jsx-render-return-fragment-static-evidence`, `jsx-render-return-branch-unsupported`, `jsx-render-component-wrapper-lazy-boundary-evidence`, `jsx-render-component-wrapper-lazy-runtime-equivalence-unproved`, `jsx-render-event-handler-prop-static-evidence`, `jsx-render-event-handler-prop-static-optional-reference-evidence`, `jsx-render-event-handler-prop-static-inline-evidence`, `jsx-render-event-handler-local-declaration-evidence`, and `jsx-render-event-handler-prop-unsupported`. Full component render equivalence, lazy-load/runtime equivalence, dynamic context value semantics beyond value-expression identity, provider lookup across external/runtime/ambiguous imported component boundaries, arbitrary prop/render flow beyond bounded static passthrough evidence, optional-chain render equivalence beyond callsite identity evidence, executable hook effect equivalence, and framework template semantics are not proved. |

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

@@ -0,0 +1,111 @@
+import { idFragment } from '../../native-import-utils.js';
+import { resolveRelativeProjectModule } from './projectSymbolGraphModuleResolution.js';
+
+function importAliasRecords(semanticIndex, documentsByPath) {
+  return (semanticIndex?.symbols ?? []).flatMap((symbol) => {
+    if (symbol?.kind !== 'import') return [];
+    const metadata = objectValue(symbol.metadata);
+    const sourcePath = symbol.definitionSpan?.path ?? metadata.sourcePath;
+    const moduleSpecifier = firstString(metadata.moduleSpecifier, metadata.importPath, metadata.source);
+    const localName = firstString(metadata.localName, symbol.name);
+    if (!sourcePath || !localName || !moduleSpecifier) return [];
+    const importedName = firstString(metadata.importedName, metadata.exportedName, localName);
+    const resolved = moduleSpecifier.startsWith('.')
+      ? resolveRelativeProjectModule(sourcePath, moduleSpecifier, documentsByPath)
+      : undefined;
+    return [compactRecord({
+      symbolId: symbol.id,
+      sourcePath,
+      localName,
+      importedName,
+      exportedName: firstString(metadata.exportedName),
+      moduleSpecifier,
+      importKind: firstString(metadata.importKind),
+      isTypeOnly: metadata.isTypeOnly === true || metadata.typeOnly === true || undefined,
+      resolvedSourcePath: resolved?.path,
+      targetDocumentId: resolved?.documentId,
+      resolutionKind: resolved?.kind,
+      resolutionPathVariant: resolved?.resolutionPathVariant
+    })];
+  });
+}
+
+function exportAliasRecords(semanticIndex, documentsByPath, sourceTextsByPath) {
+  const symbols = semanticIndex?.symbols ?? [];
+  const declarationsByLocalKey = groupFirst(
+    symbols.filter((symbol) => symbol?.kind !== 'import' && symbol?.kind !== 'export' && symbol?.name),
+    (symbol) => localKey(symbol.definitionSpan?.path ?? symbol.metadata?.sourcePath, symbol.name)
+  );
+  return symbols.flatMap((symbol) => {
+    if (symbol?.kind !== 'export') return [];
+    const metadata = objectValue(symbol.metadata);
+    const sourcePath = symbol.definitionSpan?.path ?? metadata.sourcePath;
+    const exportedName = firstString(metadata.exportedName, symbol.name);
+    if (!sourcePath || !exportedName || exportedName.startsWith('{')) return [];
+    const moduleSpecifier = firstString(metadata.moduleSpecifier, metadata.importPath, metadata.exportPath, metadata.source);
+    const resolved = moduleSpecifier?.startsWith('.')
+      ? resolveRelativeProjectModule(sourcePath, moduleSpecifier, documentsByPath)
+      : undefined;
+    const localName = firstString(metadata.localName, defaultExportLocalName(sourceTextsByPath.get(sourcePath), exportedName, moduleSpecifier), exportedName);
+    const declaration = declarationsByLocalKey.get(localKey(sourcePath, localName));
+    const document = documentsByPath.get(sourcePath);
+    return [compactRecord({
+      symbolId: symbol.id,
+      sourcePath,
+      sourceHash: document?.sourceHash ?? symbol.definitionSpan?.sourceId ?? declaration?.definitionSpan?.sourceId,
+      sourceSpan: declaration?.definitionSpan ?? symbol.definitionSpan,
+      signatureHash: symbol.signatureHash,
+      sourceSymbolId: declaration?.id,
+      sourceSymbolKind: declaration?.kind,
+      sourceSymbolSignatureHash: declaration?.signatureHash,
+      localName,
+      importedName: firstString(metadata.importedName, metadata.localName, exportedName),
+      exportedName,
+      exportKind: firstString(metadata.exportKind),
+      moduleSpecifier,
+      resolvedSourcePath: resolved?.path,
+      targetDocumentId: resolved?.documentId,
+      resolutionKind: resolved?.kind,
+      resolutionPathVariant: resolved?.resolutionPathVariant,
+      isTypeOnly: metadata.isTypeOnly === true || metadata.typeOnly === true || undefined
+    })];
+  });
+}
+
+function defaultExportLocalName(sourceText, exportedName, moduleSpecifier) {
+  if (exportedName !== 'default' || moduleSpecifier || typeof sourceText !== 'string') return undefined;
+  return firstString(
+    sourceText.match(/\bexport\s+default\s+(?:async\s+)?function\*?\s+([A-Za-z_$][\w$]*)/)?.[1],
+    sourceText.match(/\bexport\s+default\s+(?:abstract\s+)?class\s+([A-Za-z_$][\w$]*)/)?.[1],
+    sourceText.match(/\bexport\s+default\s+([A-Za-z_$][\w$]*)\s*;(?=\s*(?:$|\n))/)?.[1],
+    sourceText.match(/\bexport\s+default\s+([A-Za-z_$][\w$]*)\s*(?=$)/)?.[1]
+  );
+}
+
+function nativeImportSourceText(imported) {
+  return imported?.metadata?.sourcePreservation?.sourceText
+    ?? imported?.nativeSource?.metadata?.sourcePreservation?.sourceText
+    ?? imported?.nativeAst?.metadata?.sourcePreservation?.sourceText
+    ?? imported?.universalAst?.metadata?.sourcePreservation?.sourceText
+    ?? imported?.sourceText;
+}
+
+function localKey(sourcePath, name) { return sourcePath && name ? `${sourcePath}\0${name}` : undefined; }
+function compactRecord(record) { return Object.fromEntries(Object.entries(record).filter(([, value]) => value !== undefined)); }
+function objectValue(value) { return value && typeof value === 'object' && !Array.isArray(value) ? value : {}; }
+
+function firstString(...values) {
+  for (const value of values) if (value !== undefined && value !== null && String(value)) return String(value);
+  return undefined;
+}
+
+function groupFirst(records, keyFn) {
+  const result = new Map();
+  for (const record of records) {
+    const key = keyFn(record);
+    if (key && !result.has(key)) result.set(key, record);
+  }
+  return result;
+}
+
+export { exportAliasRecords, importAliasRecords, nativeImportSourceText };

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

@@ -1,7 +1,11 @@
 import { hashSemanticValue } from '@shapeshift-labs/frontier-lang-kernel';
 import { idFragment } from '../../native-import-utils.js';
 import { LexicalUseDefReasonCodes } from '../../js-ts-semantic-scope-use-def-utils.js';
-import { resolveRelativeProjectModule } from './projectSymbolGraphModuleResolution.js';
+import {
+  exportAliasRecords,
+  importAliasRecords,
+  nativeImportSourceText
+} from './projectSymbolGraphScopeUseDefAliasRecords.js';
 
 function createScopeGraphContext(semanticIndex, imports, publicKeys) {
   const sourceTextsByPath = new Map(imports
@@ -32,63 +36,6 @@ function createScopeGraphContext(semanticIndex, imports, publicKeys) {
   };
 }
 
-function importAliasRecords(semanticIndex, documentsByPath) {
-  return (semanticIndex?.symbols ?? []).flatMap((symbol) => {
-    if (symbol?.kind !== 'import') return [];
-    const metadata = objectValue(symbol.metadata);
-    const sourcePath = symbol.definitionSpan?.path ?? metadata.sourcePath;
-    const moduleSpecifier = firstString(metadata.moduleSpecifier, metadata.importPath, metadata.source);
-    const localName = firstString(metadata.localName, symbol.name);
-    if (!sourcePath || !localName || !moduleSpecifier) return [];
-    const importedName = firstString(metadata.importedName, metadata.exportedName, localName);
-    const resolved = moduleSpecifier.startsWith('.')
-      ? resolveRelativeProjectModule(sourcePath, moduleSpecifier, documentsByPath)
-      : undefined;
-    return [compactRecord({
-      symbolId: symbol.id,
-      sourcePath,
-      localName,
-      importedName,
-      exportedName: firstString(metadata.exportedName),
-      moduleSpecifier,
-      importKind: firstString(metadata.importKind),
-      isTypeOnly: metadata.isTypeOnly === true || metadata.typeOnly === true || undefined,
-      resolvedSourcePath: resolved?.path,
-      targetDocumentId: resolved?.documentId,
-      resolutionKind: resolved?.kind,
-      resolutionPathVariant: resolved?.resolutionPathVariant
-    })];
-  });
-}
-
-function exportAliasRecords(semanticIndex, documentsByPath, sourceTextsByPath) {
-  return (semanticIndex?.symbols ?? []).flatMap((symbol) => {
-    if (symbol?.kind !== 'export') return [];
-    const metadata = objectValue(symbol.metadata);
-    const sourcePath = symbol.definitionSpan?.path ?? metadata.sourcePath;
-    const exportedName = firstString(metadata.exportedName, symbol.name);
-    if (!sourcePath || !exportedName || exportedName.startsWith('{')) return [];
-    const moduleSpecifier = firstString(metadata.moduleSpecifier, metadata.importPath, metadata.exportPath, metadata.source);
-    const resolved = moduleSpecifier?.startsWith('.')
-      ? resolveRelativeProjectModule(sourcePath, moduleSpecifier, documentsByPath)
-      : undefined;
-    return [compactRecord({
-      symbolId: symbol.id,
-      sourcePath,
-      localName: firstString(metadata.localName, defaultExportLocalName(sourceTextsByPath.get(sourcePath), exportedName, moduleSpecifier), exportedName),
-      importedName: firstString(metadata.importedName, metadata.localName, exportedName),
-      exportedName,
-      exportKind: firstString(metadata.exportKind),
-      moduleSpecifier,
-      resolvedSourcePath: resolved?.path,
-      targetDocumentId: resolved?.documentId,
-      resolutionKind: resolved?.kind,
-      resolutionPathVariant: resolved?.resolutionPathVariant,
-      isTypeOnly: metadata.isTypeOnly === true || metadata.typeOnly === true || undefined
-    })];
-  });
-}
-
 function attachAliasMetadata(bindings, directUseHashes, context) {
   const bindingsByLocal = groupFirst(bindings, (binding) => localKey(binding.sourcePath, binding.name));
   return bindings.map((binding) => {
@@ -107,13 +54,20 @@ function attachAliasMetadata(bindings, directUseHashes, context) {
       importAlias: aliasHashRecord(importAlias),
       exportAliases: exportAliases.map(aliasHashRecord).sort(compareJson)
     }) : undefined;
-    const resolvedUseHash = resolved?.resolvedBindingUseHash ? hashSemanticValue({
+    const resolvedUseEvidenceHash = resolved?.resolvedBindingUseHash ?? resolved?.resolvedExportUseHash;
+    const resolvedUseHash = resolvedUseEvidenceHash ? hashSemanticValue({
       kind: 'frontier.lang.projectScopeImportResolvedUseHash',
       binding: binding.signatureHash,
       moduleSpecifier: importAlias.moduleSpecifier,
       importedName: importAlias.importedName,
       resolvedBinding: resolved.resolvedBindingSignatureHash,
-      resolvedUseHash: resolved.resolvedBindingUseHash
+      resolvedBindingUseHash: resolved.resolvedBindingUseHash,
+      resolvedExportUseHash: resolved.resolvedExportUseHash,
+      resolvedUseHash: resolvedUseEvidenceHash,
+      originSourcePath: resolved.originSourcePath,
+      originSourceHash: resolved.originSourceHash,
+      originExportedName: resolved.originExportedName,
+      aliasResolutionEvidenceKind: resolved.aliasResolutionEvidenceKind
     }) : undefined;
     return compactRecord({
       ...binding,
@@ -145,6 +99,8 @@ function resolveImportAliasBinding(importAlias, bindingsByLocal, directUseHashes
   if (!importAlias.resolvedSourcePath || !importAlias.importedName || importAlias.importedName === '*') return undefined;
   const origin = resolveExportOrigin(context, importAlias.resolvedSourcePath, importAlias.importedName);
   const target = bindingsByLocal.get(localKey(origin?.sourcePath ?? importAlias.resolvedSourcePath, origin?.localName ?? importAlias.importedName));
+  const sourceBoundOrigin = target ? undefined : sourceBoundDefaultExportOrigin(origin, importAlias);
+  if (sourceBoundOrigin) return sourceBoundOrigin;
   if (!target) return compactRecord({
     resolvedExportName: importAlias.importedName,
     originSourcePath: origin?.sourcePath,
@@ -167,6 +123,40 @@ function resolveImportAliasBinding(importAlias, bindingsByLocal, directUseHashes
   });
 }
 
+function sourceBoundDefaultExportOrigin(origin, importAlias) {
+  if (importAlias.importedName !== 'default' || origin?.exportedName !== 'default') return undefined;
+  if (!origin.sourcePath || !origin.sourceHash || !origin.sourceSpan || !origin.sourceSymbolId || !origin.sourceSymbolSignatureHash) return undefined;
+  const resolvedExportUseHash = hashSemanticValue({
+    kind: 'frontier.lang.projectScopeImportResolvedSourceBoundDefaultExportUseHash',
+    moduleSpecifier: importAlias.moduleSpecifier,
+    importedName: importAlias.importedName,
+    resolvedSourcePath: importAlias.resolvedSourcePath,
+    originSourcePath: origin.sourcePath,
+    originSourceHash: origin.sourceHash,
+    originExportedName: origin.exportedName,
+    originSymbolId: origin.symbolId,
+    originSignatureHash: origin.signatureHash,
+    originSourceSymbolId: origin.sourceSymbolId,
+    originSourceSymbolKind: origin.sourceSymbolKind,
+    originSourceSymbolSignatureHash: origin.sourceSymbolSignatureHash,
+    originSourceSpan: semanticSourceSpanForHash(origin.sourceSpan)
+  });
+  return compactRecord({
+    resolvedExportName: importAlias.importedName,
+    originSourcePath: origin.sourcePath,
+    originSourceHash: origin.sourceHash,
+    originSourceSpan: origin.sourceSpan,
+    originExportedName: origin.exportedName,
+    originSymbolId: origin.symbolId,
+    originSignatureHash: origin.signatureHash,
+    originSourceSymbolId: origin.sourceSymbolId,
+    originSourceSymbolKind: origin.sourceSymbolKind,
+    originSourceSymbolSignatureHash: origin.sourceSymbolSignatureHash,
+    aliasResolutionEvidenceKind: 'source-bound-default-export',
+    resolvedExportUseHash
+  });
+}
+
 function exportAliasesForBinding(binding, context) {
   const directAliases = context.exportAliasesByLocalKey.get(localKey(binding.sourcePath, binding.name)) ?? [];
   const reExportAliases = context.exportAliases
@@ -194,7 +184,18 @@ function resolveExportOrigin(context, sourcePath, exportedName, seen = new Set()
   if (alias.moduleSpecifier && alias.resolvedSourcePath) {
     return resolveExportOrigin(context, alias.resolvedSourcePath, alias.importedName ?? alias.localName, seen);
   }
-  return { sourcePath, localName: alias.localName ?? alias.exportedName, exportedName: alias.exportedName, symbolId: alias.symbolId };
+  return {
+    sourcePath,
+    sourceHash: alias.sourceHash,
+    sourceSpan: alias.sourceSpan,
+    localName: alias.localName ?? alias.exportedName,
+    exportedName: alias.exportedName,
+    symbolId: alias.symbolId,
+    signatureHash: alias.signatureHash,
+    sourceSymbolId: alias.sourceSymbolId,
+    sourceSymbolKind: alias.sourceSymbolKind,
+    sourceSymbolSignatureHash: alias.sourceSymbolSignatureHash
+  };
 }
 
 function attachReferenceAliasMetadata(references, bindings) {
@@ -215,11 +216,19 @@ function attachReferenceAliasMetadata(references, bindings) {
       importedName: binding?.importedName,
       resolvedSourcePath: binding?.resolvedSourcePath,
       originSourcePath: binding?.originSourcePath,
+      originSourceHash: binding?.originSourceHash,
+      originSourceSpan: binding?.originSourceSpan,
+      originSignatureHash: binding?.originSignatureHash,
+      originSourceSymbolId: binding?.originSourceSymbolId,
+      originSourceSymbolKind: binding?.originSourceSymbolKind,
+      originSourceSymbolSignatureHash: binding?.originSourceSymbolSignatureHash,
       resolvedExportName: binding?.resolvedExportName,
+      resolvedExportUseHash: binding?.resolvedExportUseHash,
       resolvedBindingId: binding?.resolvedBindingId,
       resolvedBindingName: binding?.resolvedBindingName,
       resolvedBindingUseHash: binding?.resolvedBindingUseHash,
       aliasResolutionStatus: binding?.aliasResolutionStatus,
+      aliasResolutionEvidenceKind: binding?.aliasResolutionEvidenceKind,
       aliasResolutionReasonCodes: binding?.aliasResolutionReasonCodes,
       status: binding?.aliasResolutionStatus ?? reference.status,
       reasonCodes: reasonCodes.length ? reasonCodes : undefined,
@@ -228,24 +237,6 @@ function attachReferenceAliasMetadata(references, bindings) {
   });
 }
 
-function defaultExportLocalName(sourceText, exportedName, moduleSpecifier) {
-  if (exportedName !== 'default' || moduleSpecifier || typeof sourceText !== 'string') return undefined;
-  return firstString(
-    sourceText.match(/\bexport\s+default\s+(?:async\s+)?function\*?\s+([A-Za-z_$][\w$]*)/)?.[1],
-    sourceText.match(/\bexport\s+default\s+(?:abstract\s+)?class\s+([A-Za-z_$][\w$]*)/)?.[1],
-    sourceText.match(/\bexport\s+default\s+([A-Za-z_$][\w$]*)\s*;(?=\s*(?:$|\n))/)?.[1],
-    sourceText.match(/\bexport\s+default\s+([A-Za-z_$][\w$]*)\s*(?=$)/)?.[1]
-  );
-}
-
-function nativeImportSourceText(imported) {
-  return imported?.metadata?.sourcePreservation?.sourceText
-    ?? imported?.nativeSource?.metadata?.sourcePreservation?.sourceText
-    ?? imported?.nativeAst?.metadata?.sourcePreservation?.sourceText
-    ?? imported?.universalAst?.metadata?.sourcePreservation?.sourceText
-    ?? imported?.sourceText;
-}
-
 function aliasHashRecord(alias) {
   return alias ? JSON.stringify(compactRecord({
     sourcePath: alias.sourcePath,
@@ -258,18 +249,24 @@ function aliasHashRecord(alias) {
   })) : undefined;
 }
 
+function semanticSourceSpanForHash(span) {
+  return span ? compactRecord({
+    path: span.path,
+    start: span.start,
+    end: span.end,
+    startLine: span.startLine,
+    startColumn: span.startColumn,
+    endLine: span.endLine,
+    endColumn: span.endColumn
+  }) : undefined;
+}
+
 function localKey(sourcePath, name) { return sourcePath && name ? `${sourcePath}\0${name}` : undefined; }
 function exportKey(sourcePath, name) { return sourcePath && name ? `${sourcePath}\0${name}` : undefined; }
 function compactRecord(record) { return Object.fromEntries(Object.entries(record).filter(([, value]) => value !== undefined)); }
-function objectValue(value) { return value && typeof value === 'object' && !Array.isArray(value) ? value : {}; }
 function compareJson(left, right) { return left < right ? -1 : left > right ? 1 : 0; }
 function uniqueStrings(values) { return [...new Set(values.filter((value) => typeof value === 'string' && value.length > 0))]; }
 
-function firstString(...values) {
-  for (const value of values) if (value !== undefined && value !== null && String(value)) return String(value);
-  return undefined;
-}
-
 function groupByKey(records, keyFn) {
   const result = new Map();
   for (const record of records) {

package/dist/js-ts-safe-project-merge-scope-use-def-conflicts.js

@@ -171,6 +171,7 @@ function scopeReferenceFingerprint(record) {
     record.signatureHash,
     record.resolvedUseHash,
     record.resolvedBindingUseHash,
+    record.resolvedExportUseHash,
     record.moduleSpecifier,
     record.importedName,
     record.resolvedSourcePath,
@@ -189,7 +190,11 @@ function scopeReferenceFingerprint(record) {
     record.status,
     record.reasonCodes?.join('|'),
     record.aliasResolutionStatus,
+    record.aliasResolutionEvidenceKind,
     record.originSourcePath,
+    record.originSourceHash,
+    record.originSourceSymbolId,
+    record.originSourceSymbolSignatureHash,
     record.resolvedBindingName,
     record.compilerReferenceStatus,
     record.compilerReferenceReasonCodes?.join('|'),
@@ -223,8 +228,15 @@ function scopeDetails(record) {
     moduleSpecifier: record.moduleSpecifier,
     resolvedSourcePath: record.resolvedSourcePath,
     originSourcePath: record.originSourcePath,
+    originSourceHash: record.originSourceHash,
+    originSignatureHash: record.originSignatureHash,
+    originSourceSymbolId: record.originSourceSymbolId,
+    originSourceSymbolKind: record.originSourceSymbolKind,
+    originSourceSymbolSignatureHash: record.originSourceSymbolSignatureHash,
     resolvedBindingName: record.resolvedBindingName,
     resolvedBindingUseHash: record.resolvedBindingUseHash,
+    resolvedExportUseHash: record.resolvedExportUseHash,
+    aliasResolutionEvidenceKind: record.aliasResolutionEvidenceKind,
     exportedNames: record.exportedNames,
     reExportedNames: record.reExportedNames,
     sourceHash: record.sourceHash
@@ -267,8 +279,15 @@ function scopeReferenceDetails(record) {
     status: record.status,
     reasonCodes: record.reasonCodes,
     aliasResolutionStatus: record.aliasResolutionStatus,
+    aliasResolutionEvidenceKind: record.aliasResolutionEvidenceKind,
     originSourcePath: record.originSourcePath,
+    originSourceHash: record.originSourceHash,
+    originSignatureHash: record.originSignatureHash,
+    originSourceSymbolId: record.originSourceSymbolId,
+    originSourceSymbolKind: record.originSourceSymbolKind,
+    originSourceSymbolSignatureHash: record.originSourceSymbolSignatureHash,
     resolvedBindingName: record.resolvedBindingName,
+    resolvedExportUseHash: record.resolvedExportUseHash,
     compilerReferenceStatus: record.compilerReferenceStatus,
     compilerReferenceReasonCodes: record.compilerReferenceReasonCodes,
     compilerReferenceSymbolId: record.compilerReferenceSymbolId,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shapeshift-labs/frontier-lang-compiler",
-  "version": "0.2.188",
+  "version": "0.2.189",
   "description": "Compiler facade for Frontier Lang source documents and language projection adapters.",
   "type": "module",
   "main": "./dist/index.js",