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

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

@@ -0,0 +1,152 @@
+import { lineColumnForOffset } from './lineColumnForOffset.js';
+
+const CssModulePathPattern = /\.module\.css(?:[?#].*)?$/i;
+
+function cssModuleSourceRecord(imported) {
+  const sourcePath = sourcePathForImport(imported);
+  if (!isCssModulePath(sourcePath)) return undefined;
+  const metadata = objectValue(imported?.metadata);
+  const nativeMetadata = objectValue(imported?.nativeSource?.metadata);
+  const astMetadata = objectValue(imported?.nativeAst?.metadata);
+  return compactRecord({
+    sourcePath,
+    sourceHash: imported?.nativeSource?.sourceHash ?? imported?.metadata?.sourceHash,
+    cssModuleEvidence: firstObject(
+      metadata.cssModuleEvidence,
+      metadata.cssModules,
+      nativeMetadata.cssModuleEvidence,
+      nativeMetadata.cssModules,
+      astMetadata.cssModuleEvidence,
+      astMetadata.cssModules
+    ),
+    bundlerTransformHash: firstString(metadata.bundlerTransformHash, nativeMetadata.bundlerTransformHash, astMetadata.bundlerTransformHash),
+    sourceMapProofHash: firstString(metadata.sourceMapProofHash, nativeMetadata.sourceMapProofHash, astMetadata.sourceMapProofHash)
+  });
+}
+
+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 sourcePathForImport(imported) {
+  return imported?.sourcePath ?? imported?.nativeSource?.sourcePath;
+}
+
+function isCssModuleBindingEdge(edge) {
+  return isCssModulePath(edge?.resolvedModulePath ?? edge?.moduleSpecifier) && Boolean(edge.localName);
+}
+
+function isCssModulePath(path) {
+  return CssModulePathPattern.test(String(path ?? ''));
+}
+
+function cssModuleSpecifierPath(moduleSpecifier) {
+  return String(moduleSpecifier ?? '').replace(/^\.\//, '');
+}
+
+function bindingsForSourcePath(bindingsByLocal, sourcePath) {
+  const result = [];
+  for (const [key, bindings] of bindingsByLocal.entries()) {
+    if (key.startsWith(`${sourcePath}\0`)) result.push(...bindings);
+  }
+  return result;
+}
+
+function localKey(sourcePath, localName) {
+  return sourcePath && localName ? `${sourcePath}\0${localName}` : '';
+}
+
+function groupBy(records, keyFn) {
+  const result = new Map();
+  for (const record of records) {
+    const key = keyFn(record);
+    if (!key) continue;
+    result.set(key, [...(result.get(key) ?? []), record]);
+  }
+  return result;
+}
+
+function uniqueRecords(records, keyFn = (record) => record.id ?? JSON.stringify(record)) {
+  const seen = new Set();
+  return records.filter((record) => {
+    const key = keyFn(record);
+    if (!key || seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+}
+
+function cssModuleUseSiteKey(site) {
+  return [site.cssModuleImportBindingId, site.jsSourcePath, site.sourceSpan?.start, site.sourceSpan?.end, site.exportName, site.useSiteKind].join('\0');
+}
+
+function cssModuleBlockerKey(blocker) {
+  return [blocker.cssModuleImportBindingId, blocker.sourcePath, blocker.sourceSpan?.start, blocker.sourceSpan?.end, blocker.reasonCode].join('\0');
+}
+
+function sourceSpanForRange(sourceText, sourcePath, sourceHash, start, end) {
+  const startPos = lineColumnForOffset(sourceText, start);
+  const endPos = lineColumnForOffset(sourceText, end);
+  return {
+    sourceId: sourceHash,
+    path: sourcePath,
+    start,
+    end,
+    startLine: startPos.line,
+    startColumn: startPos.column,
+    endLine: endPos.line,
+    endColumn: endPos.column
+  };
+}
+
+function semanticSpanForHash(span) {
+  return span ? { path: span.path, start: span.start, end: span.end, startLine: span.startLine, startColumn: span.startColumn, endLine: span.endLine, endColumn: span.endColumn } : undefined;
+}
+
+function compactRecord(record) {
+  return Object.fromEntries(Object.entries(record).filter(([, value]) => value !== undefined));
+}
+
+function escapeRegExp(value) {
+  return String(value).replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+function isIdentifierChar(char) {
+  return typeof char === 'string' && /[A-Za-z0-9_$]/.test(char);
+}
+
+function objectValue(value) {
+  return value && typeof value === 'object' && !Array.isArray(value) ? value : {};
+}
+
+function firstObject(...values) {
+  return values.find((value) => value && typeof value === 'object' && !Array.isArray(value));
+}
+
+function firstString(...values) {
+  for (const value of values) if (value !== undefined && value !== null && String(value)) return String(value);
+  return undefined;
+}
+
+export {
+  bindingsForSourcePath,
+  compactRecord,
+  cssModuleBlockerKey,
+  cssModuleSourceRecord,
+  cssModuleSpecifierPath,
+  cssModuleUseSiteKey,
+  escapeRegExp,
+  groupBy,
+  isCssModuleBindingEdge,
+  isIdentifierChar,
+  localKey,
+  nativeImportSourceText,
+  semanticSpanForHash,
+  sourcePathForImport,
+  sourceSpanForRange,
+  uniqueRecords
+};

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

@@ -0,0 +1,82 @@
+import {
+  cssModuleBlockerKey,
+  cssModuleSourceRecord,
+  cssModuleUseSiteKey,
+  isCssModuleBindingEdge,
+  localKey,
+  nativeImportSourceText,
+  sourcePathForImport,
+  uniqueRecords
+} from './projectSymbolGraphCssModuleUtils.js';
+import {
+  cssModuleBindingBlocker,
+  cssModuleImportBindingRecord,
+  cssModuleMissingExportBlockers,
+  cssModuleTransformBlockers,
+  cssModuleUseSiteGraphRecords
+} from './projectSymbolGraphCssModuleRecords.js';
+import {
+  cssModuleJsxUseSites,
+  cssModuleLexicalUseSites
+} from './projectSymbolGraphCssModuleScanners.js';
+
+function createProjectCssModuleGraphRecords(semanticIndex, imports, importEdges, scopeReferenceRecords, jsxPropRecords) {
+  const sourceTextsByPath = new Map(imports
+    .map((imported) => [sourcePathForImport(imported), nativeImportSourceText(imported)])
+    .filter(([sourcePath, sourceText]) => sourcePath && typeof sourceText === 'string'));
+  const cssSourcesByPath = new Map(imports
+    .map((imported) => [sourcePathForImport(imported), cssModuleSourceRecord(imported)])
+    .filter(([sourcePath]) => sourcePath));
+  const documentsById = new Map((semanticIndex?.documents ?? []).map((document) => [document.id, document]));
+  const importBindings = uniqueRecords(importEdges
+    .filter(isCssModuleBindingEdge)
+    .map((edge, index) => cssModuleImportBindingRecord(edge, index, documentsById, cssSourcesByPath)));
+  const bindingsByLocal = groupBindingsByLocal(importBindings);
+  const { useSites: lexicalUseSites, blockers: lexicalBlockers } = cssModuleLexicalUseSites(importBindings, sourceTextsByPath);
+  const { useSites: jsxUseSites, blockers: jsxBlockers } = cssModuleJsxUseSites(bindingsByLocal, jsxPropRecords);
+  const namedImportBlockers = importBindings
+    .filter((binding) => binding.importKind === 'named')
+    .map((binding) => cssModuleNamedExportBlocker(binding));
+  const missingTransformBlockers = importBindings
+    .filter((binding) => hasUseSite(binding, lexicalUseSites) || hasUseSite(binding, jsxUseSites))
+    .flatMap((binding) => cssModuleTransformBlockers(binding));
+  const cssModuleUseSites = uniqueRecords([...jsxUseSites, ...lexicalUseSites], cssModuleUseSiteKey);
+  const bindingsById = new Map(importBindings.map((binding) => [binding.id, binding]));
+  const missingExportBlockers = cssModuleMissingExportBlockers(bindingsById, cssModuleUseSites);
+  const cssModuleUseSiteBlockers = uniqueRecords([
+    ...lexicalBlockers,
+    ...jsxBlockers,
+    ...namedImportBlockers,
+    ...missingExportBlockers,
+    ...missingTransformBlockers
+  ], cssModuleBlockerKey);
+  return {
+    cssModuleImportBindings: importBindings,
+    cssModuleUseSites,
+    cssModuleUseSiteBlockers,
+    cssModuleUseSiteGraphs: cssModuleUseSiteGraphRecords(importBindings, cssModuleUseSites, cssModuleUseSiteBlockers)
+  };
+}
+
+function groupBindingsByLocal(importBindings) {
+  const result = new Map();
+  for (const binding of importBindings) {
+    const key = localKey(binding.sourcePath, binding.localName);
+    if (!key) continue;
+    result.set(key, [...(result.get(key) ?? []), binding]);
+  }
+  return result;
+}
+
+function cssModuleNamedExportBlocker(binding) {
+  return cssModuleBindingBlocker(binding, {
+    reasonCode: 'css-module-named-export-transform-unproved',
+    expressionText: binding.localName
+  });
+}
+
+function hasUseSite(binding, useSites) {
+  return useSites.some((site) => site.cssModuleImportBindingId === binding.id);
+}
+
+export { createProjectCssModuleGraphRecords };

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

@@ -0,0 +1,170 @@
+import { hashSemanticValue } from '@shapeshift-labs/frontier-lang-kernel';
+
+function jsxImportedComponentOwnerIndexes(importEdges = [], exportEdges = [], componentOwnersBySourcePath = new Map()) {
+  const exportLocalNames = exportLocalNameIndex(exportEdges);
+  const reExportTargets = reExportTargetIndex(exportEdges);
+  const result = new Map();
+  for (const edge of importEdges) {
+    const localName = plainComponentName(edge?.localName);
+    if (!localName || edge.isTypeOnly || edge.importKind === 'module' || !edge.resolvedModulePath) continue;
+    const target = importedOwnerTarget(edge, exportLocalNames, reExportTargets, componentOwnersBySourcePath);
+    if (!target) continue;
+    addImportedOwner(result, edge.sourcePath, localName, importedOwnerRecord(target.owner, edge, target));
+  }
+  return result;
+}
+
+function jsxImportedMemberComponentOwnerIndexes(importEdges = [], exportEdges = [], memberOwnersBySourcePath = new Map()) {
+  const exportLocalNames = exportLocalNameIndex(exportEdges);
+  const reExportTargets = reExportTargetIndex(exportEdges);
+  const result = new Map();
+  for (const edge of importEdges) {
+    const localObjectName = plainComponentName(edge?.localName);
+    if (!localObjectName || edge.isTypeOnly || edge.importKind === 'module' || !edge.resolvedModulePath) continue;
+    const target = importedMemberOwnerTarget(edge, exportLocalNames, reExportTargets, memberOwnersBySourcePath);
+    if (!target) continue;
+    for (const [propertyName, owners] of target.members) {
+      if (owners.length !== 1) continue;
+      const tagName = `${localObjectName}.${propertyName}`;
+      addImportedOwner(result, edge.sourcePath, tagName, importedMemberOwnerRecord(owners[0], edge, target, propertyName));
+    }
+  }
+  return result;
+}
+
+function mergeJsxComponentOwnerIndexes(localOwners = new Map(), importedOwners = new Map()) {
+  const result = new Map([...localOwners].map(([name, owners]) => [name, [...owners]]));
+  for (const [name, owners] of importedOwners) result.set(name, [...(result.get(name) ?? []), ...owners]);
+  return result;
+}
+
+function importedOwnerName(edge, exportLocalNames) {
+  const importedName = edge.importedName || edge.localName;
+  if (importedName !== 'default') return importedName;
+  return exportLocalNames.get(`${edge.resolvedModulePath}\0default`) ?? edge.localName;
+}
+
+function importedOwnerTarget(edge, exportLocalNames, reExportTargets, componentOwnersBySourcePath) {
+  const directOwnerName = importedOwnerName(edge, exportLocalNames);
+  const directOwners = componentOwnersBySourcePath.get(edge.resolvedModulePath)?.get(directOwnerName) ?? [];
+  if (directOwners.length === 1) return { owner: directOwners[0], ownerName: directOwnerName, targetExportName: edge.importedName ?? directOwnerName };
+  const reExport = reExportTargets.get(`${edge.resolvedModulePath}\0${edge.importedName || edge.localName}`);
+  const starReExport = reExport ?? starReExportTarget(edge);
+  if (!starReExport) return undefined;
+  return importedReExportOwnerTarget(edge, starReExport, exportLocalNames, componentOwnersBySourcePath);
+}
+
+function importedMemberOwnerTarget(edge, exportLocalNames, reExportTargets, memberOwnersBySourcePath) {
+  const directObjectName = importedOwnerName(edge, exportLocalNames);
+  const directMembers = memberOwnersBySourcePath.get(edge.resolvedModulePath)?.get(directObjectName);
+  if (directMembers?.size) return { members: directMembers, objectName: directObjectName, targetExportName: edge.importedName ?? directObjectName };
+  const reExport = reExportTargets.get(`${edge.resolvedModulePath}\0${edge.importedName || edge.localName}`);
+  const starReExport = reExport ?? starReExportTarget(edge);
+  if (!starReExport) return undefined;
+  return importedReExportMemberOwnerTarget(edge, starReExport, exportLocalNames, memberOwnersBySourcePath);
+}
+
+function importedReExportOwnerTarget(edge, reExport, exportLocalNames, componentOwnersBySourcePath) {
+  const targetExportName = reExport.localName ?? reExport.exportedName;
+  const ownerName = targetExportName === 'default' ? exportLocalNames.get(`${reExport.resolvedModulePath}\0default`) ?? edge.localName : targetExportName;
+  const owners = componentOwnersBySourcePath.get(reExport.resolvedModulePath)?.get(ownerName) ?? [];
+  return owners.length === 1 ? { owner: owners[0], ownerName, targetExportName, reExport } : undefined;
+}
+
+function importedReExportMemberOwnerTarget(edge, reExport, exportLocalNames, memberOwnersBySourcePath) {
+  const targetExportName = reExport.localName ?? reExport.exportedName;
+  const objectName = targetExportName === 'default' ? exportLocalNames.get(`${reExport.resolvedModulePath}\0default`) ?? edge.localName : targetExportName;
+  const members = memberOwnersBySourcePath.get(reExport.resolvedModulePath)?.get(objectName);
+  return members?.size ? { members, objectName, targetExportName, reExport } : undefined;
+}
+
+function starReExportTarget(edge) {
+  if (edge.reExportResolutionKind !== 'export-star' || !edge.reExportTargetSourcePath) return undefined;
+  return {
+    id: edge.reExportRelationId,
+    sourcePath: edge.reExportSourcePath,
+    exportedName: edge.importedName ?? edge.localName,
+    localName: edge.importedName ?? edge.localName,
+    resolvedModulePath: edge.reExportTargetSourcePath,
+    exportStar: true,
+    reExportIdentityId: edge.reExportIdentityId
+  };
+}
+
+function importedMemberOwnerRecord(owner, edge, target, propertyName) {
+  const reExport = target.reExport;
+  const scope = reExport ? 'project-import-reexport-member-component' : 'project-import-member-component';
+  const componentCallMemberBindingHash = hashSemanticValue({
+    kind: 'frontier.lang.projectJsxImportedMemberComponentBinding',
+    localObjectName: edge.localName,
+    targetObjectName: target.objectName,
+    propertyName,
+    localName: owner.componentCallMemberLocalName,
+    targetSourcePath: reExport?.resolvedModulePath ?? edge.resolvedModulePath,
+    importEdgeId: edge.id,
+    reExportEdgeId: reExport?.id,
+    reExportIdentityId: reExport?.reExportIdentityId,
+    sourceMemberBindingHash: owner.componentCallMemberBindingHash
+  });
+  return {
+    ...importedOwnerRecord(owner, edge, target),
+    componentProviderLookupScope: scope,
+    componentCallLookupStatus: reExport ? 'project-import-reexport-member-component-target-evidence' : 'project-import-member-component-target-evidence',
+    componentCallTargetSourcePath: owner.sourcePath,
+    componentCallMemberObjectName: edge.localName,
+    componentCallMemberPropertyName: propertyName,
+    componentCallMemberBindingHash
+  };
+}
+
+function importedOwnerRecord(owner, edge, target) {
+  const reExport = target.reExport;
+  return {
+    ...owner,
+    componentProviderLookupScope: reExport ? 'project-import-reexport-component' : 'project-import-direct-component',
+    componentCallLookupStatus: reExport ? 'project-import-reexport-component-target-evidence' : 'project-import-component-target-evidence',
+    componentCallTargetSourcePath: reExport?.resolvedModulePath ?? edge.resolvedModulePath,
+    componentCallImportEdgeId: edge.id,
+    componentCallImportKind: edge.importKind,
+    componentCallImportedName: edge.importedName,
+    componentCallLocalName: edge.localName,
+    componentCallTargetExportName: target.targetExportName,
+    componentCallReExportEdgeId: reExport?.id,
+    componentCallReExportSourcePath: reExport?.sourcePath,
+    componentCallReExportExportedName: reExport?.exportedName,
+    componentCallReExportLocalName: reExport?.localName,
+    componentCallReExportTargetSourcePath: reExport?.resolvedModulePath,
+    componentCallReExportKind: reExport?.exportStar ? 'export-star' : reExport ? 'named' : undefined,
+    componentCallReExportIdentityId: reExport?.reExportIdentityId
+  };
+}
+
+function exportLocalNameIndex(exportEdges = []) {
+  const result = new Map();
+  for (const edge of exportEdges) {
+    if (!edge?.sourcePath || !edge.exportedName) continue;
+    result.set(`${edge.sourcePath}\0${edge.exportedName}`, edge.localName ?? edge.exportedName);
+  }
+  return result;
+}
+
+function reExportTargetIndex(exportEdges = []) {
+  const result = new Map();
+  for (const edge of exportEdges) {
+    if (!edge?.sourcePath || !edge.resolvedModulePath || !edge.isReExport || edge.exportStar || !plainComponentName(edge.exportedName)) continue;
+    result.set(`${edge.sourcePath}\0${edge.exportedName}`, edge);
+  }
+  return result;
+}
+
+function addImportedOwner(result, sourcePath, localName, owner) {
+  const byName = result.get(sourcePath) ?? new Map();
+  byName.set(localName, [...(byName.get(localName) ?? []), owner]);
+  result.set(sourcePath, byName);
+}
+
+function plainComponentName(name) {
+  return /^[A-Z][A-Za-z0-9_$]*$/.test(String(name ?? '')) ? String(name) : undefined;
+}
+
+export { jsxImportedComponentOwnerIndexes, jsxImportedMemberComponentOwnerIndexes, mergeJsxComponentOwnerIndexes };

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

@@ -0,0 +1,167 @@
+import { hashSemanticValue } from '@shapeshift-labs/frontier-lang-kernel';
+import { uniqueStrings } from '../../native-import-utils.js';
+
+function jsxComponentProviderContextConsumerRecords(tag, componentCall, contextProviderAncestors = []) {
+  if (!componentCall) return [];
+  if (componentCall.status !== 'resolved') return [unsupportedComponentProviderLookupRecord(tag, componentCall, contextProviderAncestors)];
+  const calls = (componentCall.owner?.hookCalls ?? []).filter((call) => call?.contextExpressionHash);
+  return calls.map((call) => componentContextConsumerRecord(call, tag, componentCall, contextProviderAncestors));
+}
+
+function componentContextConsumerRecord(call, tag, componentCall, contextProviderAncestors) {
+  const proofStatus = call.contextConsumerProofStatus ?? (call.contextConsumerDynamicTarget
+    ? 'dynamic-context-target-unsupported'
+    : 'static-context-target-evidence');
+  const provider = nearestContextProvider(contextProviderAncestors, call.contextName);
+  const flow = provider?.providerFlowStatus === 'static-provider-children-flow-evidence';
+  const projectImport = String(componentCall.scope ?? '').startsWith('project-import-');
+  const componentCallLookupHash = hashSemanticValue({
+    kind: 'frontier.lang.projectJsxComponentProviderLookupTarget',
+    tagName: tag.tagName,
+    targetName: componentCall.targetName,
+    ownerName: componentCall.owner?.name,
+    scope: componentCall.scope,
+    targetSourcePath: componentCall.owner?.componentCallTargetSourcePath,
+    importEdgeId: componentCall.owner?.componentCallImportEdgeId,
+    reExportEdgeId: componentCall.owner?.componentCallReExportEdgeId,
+    reExportIdentityId: componentCall.owner?.componentCallReExportIdentityId,
+    memberBindingHash: componentCall.owner?.componentCallMemberBindingHash
+  });
+  const lookupHash = provider ? hashSemanticValue({
+    kind: 'frontier.lang.projectJsxComponentContextProviderLookup',
+    contextName: call.contextName,
+    tagName: provider.tagName,
+    depth: provider.depth,
+    providerFlowHash: provider.providerFlowHash,
+    componentProviderFlowLookupHash: provider.componentProviderFlowLookupHash,
+    componentCallLookupHash
+  }) : undefined;
+  const signatureHash = hashSemanticValue({
+    kind: 'frontier.lang.projectJsxComponentContextConsumerWithProviderLookup',
+    baseSignatureHash: call.contextConsumerSignatureHash,
+    contextName: call.contextName,
+    provider,
+    componentCallLookupHash
+  });
+  return compactRecord({
+    hookName: call.name,
+    ordinal: call.ordinal,
+    contextName: call.contextName,
+    contextExpressionText: call.contextExpressionText,
+    contextExpressionHash: call.contextExpressionHash,
+    contextTargetKind: call.contextTargetKind,
+    contextTargetReasonCode: call.contextTargetReasonCode,
+    contextTargetReferenceRoot: call.contextTargetReferenceRoot,
+    contextTargetReferencePath: call.contextTargetReferencePath,
+    contextTargetReferenceMemberPath: call.contextTargetReferenceMemberPath,
+    optionalReference: call.contextTargetOptionalReference,
+    optionalReferenceSegments: call.contextTargetOptionalReferenceSegments,
+    optionalReferenceSegmentIndexes: call.contextTargetOptionalReferenceSegmentIndexes,
+    optionalNullishBoundaryCount: call.contextTargetOptionalNullishBoundaryCount,
+    contextProviderLookupStatus: contextProviderLookupStatus(provider, flow, projectImport),
+    contextProviderLookupScope: contextProviderLookupScope(flow, projectImport, componentCall.scope, provider),
+    contextProviderLookupName: provider?.contextName,
+    contextProviderLookupTagName: provider?.tagName,
+    contextProviderLookupDepth: provider?.depth,
+    contextProviderLookupHash: lookupHash,
+    componentCallLookupStatus: componentCall.lookupStatus ?? 'same-file-component-target-evidence',
+    componentCallTagName: tag.tagName,
+    componentCallTargetName: componentCall.targetName,
+    componentCallTargetOwnerName: componentCall.owner?.name,
+    componentCallTargetSourcePath: componentCall.owner?.componentCallTargetSourcePath,
+    componentCallImportEdgeId: componentCall.owner?.componentCallImportEdgeId,
+    componentCallImportKind: componentCall.owner?.componentCallImportKind,
+    componentCallImportedName: componentCall.owner?.componentCallImportedName,
+    componentCallLocalName: componentCall.owner?.componentCallLocalName,
+    componentCallMemberObjectName: componentCall.owner?.componentCallMemberObjectName,
+    componentCallMemberPropertyName: componentCall.owner?.componentCallMemberPropertyName,
+    componentCallMemberLocalName: componentCall.owner?.componentCallMemberLocalName,
+    componentCallMemberBindingKind: componentCall.owner?.componentCallMemberBindingKind,
+    componentCallMemberBindingHash: componentCall.owner?.componentCallMemberBindingHash,
+    componentCallTargetExportName: componentCall.owner?.componentCallTargetExportName,
+    componentCallReExportEdgeId: componentCall.owner?.componentCallReExportEdgeId,
+    componentCallReExportSourcePath: componentCall.owner?.componentCallReExportSourcePath,
+    componentCallReExportExportedName: componentCall.owner?.componentCallReExportExportedName,
+    componentCallReExportLocalName: componentCall.owner?.componentCallReExportLocalName,
+    componentCallReExportTargetSourcePath: componentCall.owner?.componentCallReExportTargetSourcePath,
+    componentCallReExportKind: componentCall.owner?.componentCallReExportKind,
+    componentCallReExportIdentityId: componentCall.owner?.componentCallReExportIdentityId,
+    componentCallLookupHash,
+    componentProviderFlowStatus: provider?.providerFlowStatus,
+    componentProviderFlowOwnerName: provider?.componentProviderFlowOwnerName,
+    componentProviderFlowHash: provider?.providerFlowHash,
+    componentProviderFlowLookupStatus: provider?.componentProviderFlowLookupStatus,
+    componentProviderFlowLookupScope: provider?.componentProviderFlowLookupScope,
+    componentProviderFlowLookupHash: provider?.componentProviderFlowLookupHash,
+    componentProviderFlowComponentTagName: provider?.componentProviderFlowComponentTagName,
+    componentProviderFlowTargetOwnerName: provider?.componentProviderFlowTargetOwnerName,
+    componentProviderFlowTargetSourcePath: provider?.componentProviderFlowTargetSourcePath,
+    componentProviderFlowImportEdgeId: provider?.componentProviderFlowImportEdgeId,
+    componentProviderFlowImportKind: provider?.componentProviderFlowImportKind,
+    componentProviderFlowImportedName: provider?.componentProviderFlowImportedName,
+    componentProviderFlowLocalName: provider?.componentProviderFlowLocalName,
+    componentProviderFlowTargetExportName: provider?.componentProviderFlowTargetExportName,
+    componentProviderFlowReExportEdgeId: provider?.componentProviderFlowReExportEdgeId,
+    componentProviderFlowReExportSourcePath: provider?.componentProviderFlowReExportSourcePath,
+    componentProviderFlowReExportExportedName: provider?.componentProviderFlowReExportExportedName,
+    componentProviderFlowReExportLocalName: provider?.componentProviderFlowReExportLocalName,
+    componentProviderFlowReExportTargetSourcePath: provider?.componentProviderFlowReExportTargetSourcePath,
+    componentProviderFlowReExportKind: provider?.componentProviderFlowReExportKind,
+    componentProviderFlowReExportIdentityId: provider?.componentProviderFlowReExportIdentityId,
+    signatureHash,
+    proofStatus,
+    dynamicTargetKind: call.contextTargetDynamicKind,
+    dynamicBlockerReasonCode: call.contextTargetDynamicBlockerReasonCode,
+    dynamicTarget: call.contextConsumerDynamicTarget
+  });
+}
+
+function contextProviderLookupStatus(provider, flow, projectImport) {
+  if (!provider) return undefined;
+  if (flow && provider.componentProviderFlowLookupScope) return 'static-project-import-component-provider-flow-evidence';
+  if (projectImport) return flow ? 'static-project-import-component-provider-flow-evidence' : 'static-project-import-component-provider-evidence';
+  return flow ? 'static-same-file-component-provider-flow-evidence' : 'static-same-file-component-provider-evidence';
+}
+
+function contextProviderLookupScope(flow, projectImport, scope, provider) {
+  if (flow && provider?.componentProviderFlowLookupScope) return projectImportProviderFlowScope(provider.componentProviderFlowLookupScope);
+  if (projectImport) return flow ? projectImportProviderFlowScope(scope) : scope;
+  if (scope === 'same-file-member-component') return flow ? 'same-file-member-component-children-flow' : 'same-file-member-component';
+  return flow ? 'same-file-component-children-flow' : 'same-file-direct-component';
+}
+
+function projectImportProviderFlowScope(scope) {
+  if (scope === 'project-import-reexport-member-component') return 'project-import-reexport-member-component-children-flow';
+  if (scope === 'project-import-member-component') return 'project-import-member-component-children-flow';
+  return scope === 'project-import-reexport-component' ? 'project-import-reexport-component-children-flow' : 'project-import-component-children-flow';
+}
+
+function unsupportedComponentProviderLookupRecord(tag, componentCall, contextProviderAncestors) {
+  const reasonCodes = uniqueStrings([componentCall.reasonCode, 'jsx-render-context-consumer-provider-component-target-unsupported']);
+  return compactRecord({
+    proofStatus: 'component-provider-lookup-unsupported',
+    contextProviderLookupScope: 'same-file-direct-component',
+    componentCallLookupStatus: 'component-target-unsupported',
+    componentCallTagName: tag.tagName,
+    componentCallTargetName: componentCall.targetName,
+    componentCallUnsupportedReasonCodes: reasonCodes,
+    contextProviderPath: contextProviderAncestors.map((provider) => provider.contextName).filter(Boolean),
+    signatureHash: hashSemanticValue({
+      kind: 'frontier.lang.projectJsxComponentProviderLookupUnsupported',
+      tagName: tag.tagName,
+      targetName: componentCall.targetName,
+      reasonCodes
+    })
+  });
+}
+
+function nearestContextProvider(providers = [], contextName) {
+  if (!contextName) return undefined;
+  const match = providers.map((provider, depth) => ({ ...provider, depth: depth + 1 })).reverse()
+    .find((provider) => provider.contextName === contextName);
+  return match ? compactRecord(match) : undefined;
+}
+
+function compactRecord(record) { return Object.fromEntries(Object.entries(record).filter(([, value]) => value !== undefined)); }
+
+export { jsxComponentProviderContextConsumerRecords };