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

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

@@ -0,0 +1,307 @@
+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';
+
+function createScopeGraphContext(semanticIndex, imports, publicKeys) {
+  const sourceTextsByPath = new Map(imports
+    .map((imported) => [imported?.sourcePath ?? imported?.nativeSource?.sourcePath, nativeImportSourceText(imported)])
+    .filter(([sourcePath, sourceText]) => sourcePath && sourceText));
+  const documentsByPath = new Map((semanticIndex?.documents ?? [])
+    .filter((document) => document?.path)
+    .map((document) => [document.path, document]));
+  for (const imported of imports ?? []) {
+    const sourcePath = imported?.sourcePath ?? imported?.nativeSource?.sourcePath;
+    if (!sourcePath || documentsByPath.has(sourcePath)) continue;
+    documentsByPath.set(sourcePath, {
+      id: `doc_${idFragment(sourcePath)}`,
+      path: sourcePath,
+      sourceHash: imported?.nativeSource?.sourceHash ?? imported?.metadata?.sourceHash
+    });
+  }
+  const importAliases = importAliasRecords(semanticIndex, documentsByPath);
+  const exportAliases = exportAliasRecords(semanticIndex, documentsByPath, sourceTextsByPath);
+  return {
+    publicKeys,
+    sourceTextsByPath,
+    importAliases,
+    exportAliases,
+    importAliasesByLocalKey: groupFirst(importAliases, (alias) => localKey(alias.sourcePath, alias.localName)),
+    exportAliasesByExportKey: groupFirst(exportAliases, (alias) => exportKey(alias.sourcePath, alias.exportedName)),
+    exportAliasesByLocalKey: groupByKey(exportAliases.filter((alias) => !alias.moduleSpecifier), (alias) => localKey(alias.sourcePath, alias.localName))
+  };
+}
+
+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) => {
+    const localUseHash = directUseHashes.get(binding.id);
+    const exportAliases = exportAliasesForBinding(binding, context);
+    const importAlias = binding.bindingKind === 'import'
+      ? context.importAliasesByLocalKey.get(localKey(binding.sourcePath, binding.name))
+      : undefined;
+    const resolved = importAlias ? resolveImportAliasBinding(importAlias, bindingsByLocal, directUseHashes, context) : undefined;
+    const exportedNames = uniqueStrings(exportAliases.filter((alias) => alias.sourcePath === binding.sourcePath).map((alias) => alias.exportedName));
+    const reExportedNames = uniqueStrings(exportAliases.filter((alias) => alias.sourcePath !== binding.sourcePath).map((alias) => alias.exportedName));
+    const scopeUseDefReasonCodes = uniqueStrings([...(binding.scopeUseDefReasonCodes ?? []), ...(resolved?.aliasResolutionReasonCodes ?? [])]);
+    const aliasHash = exportAliases.length || importAlias ? hashSemanticValue({
+      kind: 'frontier.lang.projectScopeAliasHash',
+      binding: binding.signatureHash,
+      importAlias: aliasHashRecord(importAlias),
+      exportAliases: exportAliases.map(aliasHashRecord).sort(compareJson)
+    }) : undefined;
+    const resolvedUseHash = resolved?.resolvedBindingUseHash ? hashSemanticValue({
+      kind: 'frontier.lang.projectScopeImportResolvedUseHash',
+      binding: binding.signatureHash,
+      moduleSpecifier: importAlias.moduleSpecifier,
+      importedName: importAlias.importedName,
+      resolvedBinding: resolved.resolvedBindingSignatureHash,
+      resolvedUseHash: resolved.resolvedBindingUseHash
+    }) : undefined;
+    return compactRecord({
+      ...binding,
+      localUseHash,
+      exportedNames: exportedNames.length ? exportedNames : undefined,
+      reExportedNames: reExportedNames.length ? reExportedNames : undefined,
+      aliasHash,
+      importAlias: importAlias ? true : undefined,
+      moduleSpecifier: importAlias?.moduleSpecifier,
+      importedName: importAlias?.importedName,
+      localName: importAlias?.localName,
+      importKind: importAlias?.importKind,
+      isTypeOnly: importAlias?.isTypeOnly,
+      resolvedSourcePath: importAlias?.resolvedSourcePath,
+      targetDocumentId: importAlias?.targetDocumentId,
+      resolutionKind: importAlias?.resolutionKind,
+      resolutionPathVariant: importAlias?.resolutionPathVariant,
+      ...resolved,
+      aliasResolutionStatus: resolved?.aliasResolutionStatus,
+      aliasResolutionReasonCodes: resolved?.aliasResolutionReasonCodes,
+      scopeUseDefStatus: resolved?.aliasResolutionStatus === 'blocked' ? 'blocked' : binding.scopeUseDefStatus,
+      scopeUseDefReasonCodes: scopeUseDefReasonCodes.length ? scopeUseDefReasonCodes : undefined,
+      resolvedUseHash
+    });
+  });
+}
+
+function resolveImportAliasBinding(importAlias, bindingsByLocal, directUseHashes, context) {
+  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));
+  if (!target) return compactRecord({
+    resolvedExportName: importAlias.importedName,
+    originSourcePath: origin?.sourcePath,
+    originExportedName: origin?.exportedName,
+    originSymbolId: origin?.symbolId,
+    aliasResolutionStatus: 'blocked',
+    aliasResolutionReasonCodes: [LexicalUseDefReasonCodes.importAliasTargetUnresolved]
+  });
+  return compactRecord({
+    resolvedExportName: importAlias.importedName,
+    originSourcePath: target.sourcePath,
+    originExportedName: origin?.exportedName,
+    originSymbolId: origin?.symbolId,
+    resolvedBindingId: target.id,
+    resolvedBindingName: target.name,
+    resolvedBindingKind: target.bindingKind,
+    resolvedBindingSignatureHash: target.signatureHash,
+    resolvedBindingUseHash: directUseHashes.get(target.id),
+    resolvedPublicOwnerName: target.publicOwnerName
+  });
+}
+
+function exportAliasesForBinding(binding, context) {
+  const directAliases = context.exportAliasesByLocalKey.get(localKey(binding.sourcePath, binding.name)) ?? [];
+  const reExportAliases = context.exportAliases
+    .filter((alias) => alias.moduleSpecifier && alias.resolvedSourcePath)
+    .filter((alias) => {
+      const origin = resolveExportOrigin(context, alias.resolvedSourcePath, alias.importedName ?? alias.localName);
+      return origin?.sourcePath === binding.sourcePath && origin?.localName === binding.name;
+    });
+  const reExportImportAliases = context.importAliases
+    .filter((alias) => alias.exportedName && alias.resolvedSourcePath)
+    .filter((alias) => {
+      const origin = resolveExportOrigin(context, alias.resolvedSourcePath, alias.importedName ?? alias.localName);
+      return origin?.sourcePath === binding.sourcePath && origin?.localName === binding.name;
+    });
+  return uniqueAliasRecords([...directAliases, ...reExportAliases, ...reExportImportAliases]);
+}
+
+function resolveExportOrigin(context, sourcePath, exportedName, seen = new Set()) {
+  if (!sourcePath || !exportedName || exportedName === '*') return undefined;
+  const key = exportKey(sourcePath, exportedName);
+  if (seen.has(key)) return { sourcePath, localName: exportedName, exportedName };
+  seen.add(key);
+  const alias = context.exportAliasesByExportKey.get(key);
+  if (!alias) return { sourcePath, localName: exportedName, exportedName };
+  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 };
+}
+
+function attachReferenceAliasMetadata(references, bindings) {
+  const bindingsById = new Map(bindings.map((binding) => [binding.id, binding]));
+  return references.map((reference) => {
+    const binding = bindingsById.get(reference.bindingId);
+    const reasonCodes = uniqueStrings([...(reference.reasonCodes ?? []), ...(binding?.aliasResolutionReasonCodes ?? [])]);
+    const resolvedUseHash = binding?.resolvedUseHash ? hashSemanticValue({
+      kind: 'frontier.lang.projectScopeReferenceResolvedUseHash',
+      reference: reference.signatureHash,
+      resolvedUseHash: binding.resolvedUseHash,
+      resolvedBindingUseHash: binding.resolvedBindingUseHash
+    }) : undefined;
+    return compactRecord({
+      ...reference,
+      importAlias: binding?.importAlias,
+      moduleSpecifier: binding?.moduleSpecifier,
+      importedName: binding?.importedName,
+      resolvedSourcePath: binding?.resolvedSourcePath,
+      originSourcePath: binding?.originSourcePath,
+      resolvedExportName: binding?.resolvedExportName,
+      resolvedBindingId: binding?.resolvedBindingId,
+      resolvedBindingName: binding?.resolvedBindingName,
+      resolvedBindingUseHash: binding?.resolvedBindingUseHash,
+      aliasResolutionStatus: binding?.aliasResolutionStatus,
+      aliasResolutionReasonCodes: binding?.aliasResolutionReasonCodes,
+      status: binding?.aliasResolutionStatus ?? reference.status,
+      reasonCodes: reasonCodes.length ? reasonCodes : undefined,
+      resolvedUseHash
+    });
+  });
+}
+
+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,
+    moduleSpecifier: alias.moduleSpecifier,
+    localName: alias.localName,
+    importedName: alias.importedName,
+    exportedName: alias.exportedName,
+    symbolId: alias.symbolId,
+    resolvedSourcePath: alias.resolvedSourcePath
+  })) : 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) {
+    const key = keyFn(record);
+    if (key) result.set(key, [...(result.get(key) ?? []), record]);
+  }
+  return result;
+}
+
+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;
+}
+
+function uniqueAliasRecords(records) {
+  const seen = new Set();
+  return records.filter((record) => {
+    const key = aliasHashRecord(record);
+    if (!key || seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+}
+
+export {
+  attachAliasMetadata,
+  attachReferenceAliasMetadata,
+  compactRecord,
+  createScopeGraphContext,
+  nativeImportSourceText
+};

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

@@ -0,0 +1,320 @@
+import { hashSemanticValue } from '@shapeshift-labs/frontier-lang-kernel';
+import { idFragment } from '../../native-import-utils.js';
+import { collectBindings } from '../../js-ts-semantic-scope-use-def-bindings.js';
+import { createBraceDepthIndex, isPropertyAccess, likelyTypeReference, maskNonCode, tokenize } from '../../js-ts-semantic-scope-use-def-scan.js';
+import { LexicalUseDefReasonCodes, identifierRegExp, namespaceOverlap, rangeKey } from '../../js-ts-semantic-scope-use-def-utils.js';
+import { bindingRecords, closureCaptureEvidence, compactRecord, semanticSpanForHash, sourceSpanForRange } from './projectSymbolGraphScopeUseDefRecordBuilders.js';
+import { nearestPublicOwnerForOffset } from './projectSymbolGraphScopeUseDefOwners.js';
+import { readStaticMemberLiteral } from './staticMemberLiteral.js';
+
+const jsTsKeywords = new Set('abstract as async await break case catch class const continue debugger declare default delete do else enum export extends false finally for from function if implements import in infer instanceof interface keyof let module namespace new null of package private protected public readonly return satisfies static super switch this throw true try type typeof undefined unique unknown var void while with yield'.split(' '));
+
+function lexicalScopeRecordsForImport(sourceText, context) {
+  const masked = maskNonCode(sourceText);
+  const tokens = tokenize(masked.code).map((token, index) => ({ ...token, index, depth: 0 }));
+  const depthAt = createBraceDepthIndex(masked.code);
+  for (const token of tokens) token.depth = depthAt[token.start] ?? 0;
+  const rawBindings = collectBindings(masked.code, tokens, depthAt);
+  const bindings = bindingRecords(rawBindings, context);
+  const references = [
+    ...referenceRecords(tokens, masked, bindings, context),
+    ...receiverMemberReferenceRecords(masked, context)
+  ];
+  return {
+    scopeBindingRecords: bindings,
+    scopeReferenceRecords: references
+  };
+}
+
+function receiverMemberReferenceRecords(masked, context) {
+  const code = masked.code;
+  const records = [];
+  for (const match of code.matchAll(/\b(this|super)\b/g)) {
+    const receiver = match[1];
+    if (isPropertyAccess(code, match.index)) continue;
+    const access = receiverMemberAccess(context.sourceText ?? code, code, match.index + receiver.length);
+    if (!access) continue;
+    const publicOwner = nearestPublicOwnerForOffset(context.publicOwners, match.index);
+    if (!publicOwner) continue;
+    const writeOperation = namespaceMemberWriteOperation(code, match.index, access.accessEnd);
+    const sourceSpan = sourceSpanForRange(context, match.index, access.accessEnd);
+    const referenceKind = `${receiver}-member-${writeOperation ? 'write' : 'read'}`;
+    records.push(compactRecord({
+      id: `scope_ref_${idFragment(context.sourcePath)}_receiver_${records.length + 1}`,
+      name: receiver,
+      namespace: 'value',
+      namespaces: ['value'],
+      sourcePath: context.sourcePath,
+      sourceHash: context.sourceHash,
+      sourceSpan,
+      start: match.index,
+      end: access.accessEnd,
+      depth: 0,
+      referenceKind,
+      receiverKind: receiver,
+      memberName: access.memberName,
+      memberStart: access.memberStart,
+      memberEnd: access.memberEnd,
+      memberComputed: access.memberComputed,
+      memberLiteralKind: access.memberLiteralKind,
+      memberStaticTemplateLiteral: access.memberLiteralKind === 'static-template-literal' ? true : undefined,
+      memberOptional: access.memberOptional,
+      writeOperation,
+      publicContract: true,
+      publicOwnerName: publicOwner.name,
+      signatureHash: hashSemanticValue({
+        kind: 'frontier.lang.projectScopeReceiverMemberReference',
+        receiver,
+        memberName: access.memberName,
+        memberComputed: access.memberComputed,
+        memberOptional: access.memberOptional,
+        writeOperation,
+        publicOwnerName: publicOwner.name,
+        sourceSpan: semanticSpanForHash(sourceSpan)
+      })
+    }));
+  }
+  return records;
+}
+
+function receiverMemberAccess(sourceText, code, receiverEnd) {
+  let index = receiverEnd;
+  while (index < code.length && /\s/.test(code[index])) index += 1;
+  let memberOptional;
+  if (code[index] === '?' && code[index + 1] === '.') {
+    memberOptional = true;
+    index += 2;
+  }
+  if (memberOptional && code[index] !== '[') return receiverDotMemberAccess(code, index, memberOptional);
+  if (code[index] === '.') return receiverDotMemberAccess(code, index + 1, memberOptional);
+  if (code[index] !== '[') return undefined;
+  return receiverComputedMemberAccess(sourceText, code, index, memberOptional);
+}
+
+function receiverDotMemberAccess(code, memberOffset, memberOptional) {
+  let index = memberOffset;
+  while (index < code.length && /\s/.test(code[index])) index += 1;
+  const match = /^#?[A-Za-z_$][\w$]*/.exec(code.slice(index));
+  if (!match) return undefined;
+  return { memberName: match[0], memberStart: index, memberEnd: index + match[0].length, memberOptional, accessEnd: index + match[0].length };
+}
+
+function receiverComputedMemberAccess(sourceText, code, open, memberOptional) {
+  const close = findMatchingBracket(code, open);
+  if (close === -1) return undefined;
+  let index = open + 1;
+  while (index < close && /\s/.test(sourceText[index])) index += 1;
+  const literal = readStaticMemberLiteral(sourceText, index, close);
+  if (!literal || !identifierRegExp.test(literal.value)) return undefined;
+  return { memberName: literal.value, memberStart: literal.start, memberEnd: literal.end, memberComputed: true, memberLiteralKind: literal.literalKind, memberOptional, accessEnd: close + 1 };
+}
+
+function referenceRecords(tokens, masked, bindings, context) {
+  const code = masked.code;
+  const bindingKeys = new Set(bindings.map((binding) => `${binding.start}:${binding.end}`));
+  return tokens.flatMap((token, index) => {
+    if (jsTsKeywords.has(token.value) || bindingKeys.has(rangeKey(token)) || isPropertyAccess(code, token.start)) return [];
+    const namespace = likelyTypeReference(code, tokens, index) ? 'type' : 'value';
+    const binding = nearestBinding(bindings, token, namespace);
+    if (!binding) return [];
+    const namespaceProperty = namespacePropertyAccess(code, token, binding, context);
+    const sourceSpan = sourceSpanForRange(context, token.start, token.end);
+    const semanticSpan = semanticSpanForHash(sourceSpan);
+    const publicOwner = nearestPublicOwnerForOffset(context.publicOwners, token.start);
+    const publicOwnerName = binding.publicOwnerName ?? publicOwner?.name;
+    const closureCapture = closureCaptureEvidence(token.depth, binding, publicOwnerName);
+    const templateExpression = templateExpressionRangeForOffset(masked.templateExpressionRanges, token.start);
+    const templateExpressionHash = templateExpression ? hashSemanticValue({
+      kind: 'frontier.lang.projectScopeReferenceTemplateExpression',
+      sourcePath: context.sourcePath,
+      sourceHash: context.sourceHash,
+      start: templateExpression.start,
+      end: templateExpression.end,
+      templateKind: templateExpression.templateKind,
+      templateTagText: templateExpression.templateTagText
+    }) : undefined;
+    return [compactRecord({
+      id: `scope_ref_${idFragment(context.sourcePath)}_${index + 1}`,
+      name: token.value,
+      namespace,
+      namespaces: [namespace],
+      sourcePath: context.sourcePath,
+      sourceHash: context.sourceHash,
+      sourceSpan,
+      start: token.start,
+      end: token.end,
+      depth: token.depth,
+      referenceKind: namespaceProperty?.referenceKind ?? (templateExpression ? 'template-literal-interpolation' : undefined),
+      templateLiteralInterpolation: templateExpression ? true : undefined,
+      templateExpressionStart: templateExpression?.start,
+      templateExpressionEnd: templateExpression?.end,
+      templateExpressionHash,
+      templateLiteralKind: templateExpression?.templateKind,
+      taggedTemplate: templateExpression?.templateKind === 'tagged-template' ? true : undefined,
+      templateTagText: templateExpression?.templateTagText,
+      templateTagRoot: templateExpression?.templateTagRoot,
+      templateTagMemberName: templateExpression?.templateTagMemberName,
+      templateTagStart: templateExpression?.templateTagStart,
+      templateTagEnd: templateExpression?.templateTagEnd,
+      memberName: namespaceProperty?.memberName,
+      memberStart: namespaceProperty?.memberStart,
+      memberEnd: namespaceProperty?.memberEnd,
+      memberComputed: namespaceProperty?.memberComputed,
+      memberLiteralKind: namespaceProperty?.memberLiteralKind,
+      memberStaticTemplateLiteral: namespaceProperty?.memberLiteralKind === 'static-template-literal' ? true : undefined,
+      writeOperation: namespaceProperty?.writeOperation,
+      bindingId: binding.id,
+      bindingName: binding.name,
+      bindingKind: binding.bindingKind,
+      bindingOrdinal: binding.ordinal,
+      closure: Boolean(closureCapture) || undefined,
+      closureDepthDelta: closureCapture?.closureDepthDelta,
+      closureBindingDepth: closureCapture?.closureBindingDepth,
+      closureOwnerName: closureCapture?.closureOwnerName,
+      closureCaptureHash: closureCapture?.closureCaptureHash,
+      publicContract: (binding.publicContract || Boolean(publicOwnerName)) || undefined,
+      publicOwnerName,
+      status: namespaceProperty?.status,
+      reasonCodes: namespaceProperty?.reasonCodes,
+      signatureHash: hashSemanticValue({
+        kind: 'frontier.lang.projectScopeReferenceSignature',
+        name: token.value,
+        namespace,
+        bindingId: binding.id,
+        sourceSpan: semanticSpan,
+        referenceKind: namespaceProperty?.referenceKind ?? (templateExpression ? 'template-literal-interpolation' : undefined),
+        templateExpressionHash,
+        templateKind: templateExpression?.templateKind,
+        templateTagText: templateExpression?.templateTagText,
+        memberName: namespaceProperty?.memberName,
+        memberComputed: namespaceProperty?.memberComputed,
+        writeOperation: namespaceProperty?.writeOperation,
+        closureCaptureHash: closureCapture?.closureCaptureHash,
+        closureDepthDelta: closureCapture?.closureDepthDelta,
+        closureOwnerName: closureCapture?.closureOwnerName,
+        status: namespaceProperty?.status,
+        reasonCodes: namespaceProperty?.reasonCodes
+      })
+    })];
+  });
+}
+
+function templateExpressionRangeForOffset(ranges = [], offset) {
+  return ranges.filter((range) => offset >= range.start && offset < range.end).sort((left, right) => (left.end - left.start) - (right.end - right.start))[0];
+}
+
+function nearestBinding(bindings, token, namespace) {
+  return bindings
+    .filter((binding) => binding.name === token.value && binding.start < token.start && namespaceOverlap(binding.namespaces, [namespace]))
+    .sort((left, right) => right.start - left.start || right.depth - left.depth)[0];
+}
+
+function namespacePropertyAccess(code, token, binding, context) {
+  const importAlias = context.importAliasesByLocalKey?.get(context.sourcePath && token.value ? `${context.sourcePath}\0${token.value}` : undefined);
+  if (binding.bindingKind !== 'import' || importAlias?.importKind !== 'namespace') return undefined;
+  let index = token.end;
+  while (index < code.length && /\s/.test(code[index])) index += 1;
+  if (code[index] === '.') {
+    const match = /^[A-Za-z_$][\w$]*/.exec(code.slice(index + 1).trimStart());
+    const memberStart = match ? code.indexOf(match[0], index + 1) : -1;
+    if (!match) return undefined;
+    const memberEnd = memberStart + match[0].length;
+    const writeOperation = namespaceMemberWriteOperation(code, token.start, memberEnd);
+    return writeOperation
+      ? blockedNamespaceMemberWrite('namespace-property-write', { memberName: match[0], memberStart, memberEnd, writeOperation })
+      : { referenceKind: 'namespace-property-read', memberName: match[0], memberStart, memberEnd };
+  }
+  if (code[index] === '[') return namespaceComputedPropertyAccess(context.sourceText ?? code, code, token.start, index);
+  return undefined;
+}
+
+function namespaceComputedPropertyAccess(sourceText, code, tokenStart, open) {
+  const close = findMatchingBracket(code, open);
+  if (close === -1) return blockedNamespaceComputedPropertyAccess();
+  const writeOperation = namespaceMemberWriteOperation(code, tokenStart, close + 1);
+  let index = open + 1;
+  while (index < close && /\s/.test(sourceText[index])) index += 1;
+  const literal = readStaticMemberLiteral(sourceText, index, close);
+  if (!literal) return blockedNamespaceComputedPropertyAccess(writeOperation);
+  let afterLiteral = literal.end + 1;
+  while (afterLiteral < close && /\s/.test(sourceText[afterLiteral])) afterLiteral += 1;
+  if (afterLiteral !== close || !identifierRegExp.test(literal.value)) return blockedNamespaceComputedPropertyAccess(writeOperation);
+  if (writeOperation) {
+    return blockedNamespaceMemberWrite('namespace-computed-property-write', {
+      memberName: literal.value,
+      memberStart: literal.start,
+      memberEnd: literal.end,
+      memberComputed: true,
+      memberLiteralKind: literal.literalKind,
+      writeOperation
+    });
+  }
+  return { referenceKind: 'namespace-computed-property-read', memberName: literal.value, memberStart: literal.start, memberEnd: literal.end, memberComputed: true, memberLiteralKind: literal.literalKind };
+}
+
+function blockedNamespaceComputedPropertyAccess(writeOperation) {
+  return {
+    referenceKind: writeOperation ? 'namespace-computed-property-write' : 'namespace-computed-property-read',
+    memberComputed: true,
+    writeOperation,
+    status: 'blocked',
+    reasonCodes: [
+      LexicalUseDefReasonCodes.namespaceComputedMemberUnsupported,
+      ...(writeOperation ? [LexicalUseDefReasonCodes.namespaceMemberWriteUnsupported] : [])
+    ]
+  };
+}
+
+function blockedNamespaceMemberWrite(referenceKind, fields = {}) {
+  return {
+    referenceKind,
+    memberName: fields.memberName,
+    memberStart: fields.memberStart,
+    memberEnd: fields.memberEnd,
+    memberComputed: fields.memberComputed,
+    memberLiteralKind: fields.memberLiteralKind,
+    status: 'blocked',
+    reasonCodes: [LexicalUseDefReasonCodes.namespaceMemberWriteUnsupported],
+    writeOperation: fields.writeOperation
+  };
+}
+
+function namespaceMemberWriteOperation(code, tokenStart, accessEnd) {
+  if (hasPrefixUpdateOperator(code, tokenStart)) return 'update';
+  let index = accessEnd;
+  while (index < code.length && /\s/.test(code[index])) index += 1;
+  if (code.slice(index, index + 2) === '++' || code.slice(index, index + 2) === '--') return 'update';
+  const operator = assignmentOperatorAt(code, index);
+  return operator ? 'assignment' : undefined;
+}
+
+function assignmentOperatorAt(code, index) {
+  for (const operator of ['>>>=', '**=', '<<=', '>>=', '&&=', '||=', '??=', '+=', '-=', '*=', '/=', '%=', '&=', '|=', '^=', '=']) {
+    if (!code.startsWith(operator, index)) continue;
+    if (operator === '=' && (code[index + 1] === '=' || code[index + 1] === '>')) return undefined;
+    return operator;
+  }
+  return undefined;
+}
+
+function hasPrefixUpdateOperator(code, tokenStart) {
+  let index = tokenStart - 1;
+  while (index >= 0 && /\s/.test(code[index])) index -= 1;
+  const operatorStart = index - 1;
+  const operator = code.slice(operatorStart, index + 1);
+  if (operator !== '++' && operator !== '--') return false;
+  let before = operatorStart - 1;
+  while (before >= 0 && /\s/.test(code[before])) before -= 1;
+  return before < 0 || !/[A-Za-z0-9_$)\]]/.test(code[before]);
+}
+
+function findMatchingBracket(code, open) {
+  let depth = 0;
+  for (let index = open; index < code.length; index += 1) {
+    if (code[index] === '[') depth += 1;
+    else if (code[index] === ']' && --depth === 0) return index;
+  }
+  return -1;
+}
+
+export { lexicalScopeRecordsForImport };

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

@@ -0,0 +1,50 @@
+function publicOwnerRanges(context, sourcePath, sourceText) {
+  return (context.sourceTextsByPath.has(sourcePath) ? context.sourceTextsByPath : new Map([[sourcePath, sourceText]]))
+    && (context.publicOwnerRangesByPath?.get(sourcePath) ?? publicOwnerRangesFromKeys(context.publicKeys, sourcePath, sourceText));
+}
+
+function publicOwnerRangesFromKeys(publicKeys, sourcePath, sourceText) {
+  return [...publicKeys]
+    .map((key) => publicKeyParts(key))
+    .filter((parts) => parts?.sourcePath === sourcePath)
+    .map((parts) => ({ name: parts.name, range: rangeForNamedDeclaration(sourceText, parts.name) }))
+    .filter((owner) => owner.range);
+}
+
+function nearestPublicOwnerForOffset(publicOwners, offset) {
+  return (publicOwners ?? [])
+    .filter((owner) => owner.range.start <= offset && offset <= owner.range.end)
+    .sort((left, right) => right.range.start - left.range.start || left.range.end - right.range.end)[0];
+}
+
+function nearestLexicalPublicOwner(publicOwners, binding) {
+  if (binding.depth === 0) return undefined;
+  return publicOwners.filter((owner) => owner.start < binding.start && owner.depth < binding.depth)
+    .sort((left, right) => right.start - left.start)[0];
+}
+
+function rangeForNamedDeclaration(sourceText, name) {
+  if (!sourceText || !name) return undefined;
+  const escaped = escapeRegExp(name);
+  const declaration = new RegExp(`\\b(?:export\\s+)?(?:async\\s+)?(?:function|class|interface|type|enum|namespace|module)\\s+${escaped}\\b`, 'm').exec(sourceText);
+  if (declaration) return declarationRange(sourceText, declaration.index);
+  const variable = new RegExp(`\\b(?:export\\s+)?(?:const|let|var)\\s+${escaped}\\b`, 'm').exec(sourceText);
+  return variable ? declarationRange(sourceText, variable.index) : undefined;
+}
+
+function declarationRange(sourceText, start) {
+  const nextTopLevel = /\n(?:export\s+)?(?:async\s+)?(?:function|class|interface|type|enum|namespace|module|const|let|var)\s+[A-Za-z_$][\w$]*/g;
+  nextTopLevel.lastIndex = start + 1;
+  const next = nextTopLevel.exec(sourceText);
+  return { start, end: next ? next.index : sourceText.length };
+}
+
+function publicKeyParts(key) {
+  const separator = String(key).indexOf('\0');
+  if (separator <= 0) return undefined;
+  return { sourcePath: String(key).slice(0, separator), name: String(key).slice(separator + 1) };
+}
+
+function escapeRegExp(value) { return String(value).replace(/[.*+?^${}()|[\]\\]/g, '\\$&'); }
+
+export { nearestLexicalPublicOwner, nearestPublicOwnerForOffset, publicOwnerRanges };