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

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

@@ -0,0 +1,315 @@
+import { hashSemanticValue } from '@shapeshift-labs/frontier-lang-kernel';
+import { idFragment, uniqueStrings } from '../../native-import-utils.js';
+import { isJsxComponentTag, isJsxSpreadAttribute, jsxContextProviderAncestorMap, parseJsxTags } from '../../js-ts-safe-merge-jsx-attribute-parser.js';
+import { jsxEventHandlerProps, jsxOwnerEventHandlerDeclarations } from './projectSymbolGraphJsxEventHandlers.js';
+import { jsxRenderRiskEvidence } from './projectSymbolGraphJsxRenderRisk.js';
+import { jsxHookCalls } from './projectSymbolGraphJsxHooks.js';
+import { jsxRenderReturnRecords } from './projectSymbolGraphJsxRenderReturns.js';
+import { jsxComponentWrapperRecords, jsxComponentWrapperRenderRiskEvidence, mergeJsxRenderRiskEvidence } from './projectSymbolGraphJsxComponentWrappers.js';
+import { jsxComponentProviderContextConsumerRecords } from './projectSymbolGraphJsxComponentProviderLookup.js';
+import { jsxImportedComponentOwnerIndexes, jsxImportedMemberComponentOwnerIndexes, mergeJsxComponentOwnerIndexes } from './projectSymbolGraphJsxComponentImports.js';
+import { jsxSameFileMemberComponentObjectIndex, jsxSameFileMemberComponentOwnerIndex } from './projectSymbolGraphJsxMemberComponents.js';
+import { jsxProviderFlowAncestorMap, jsxProviderFlowRecords } from './projectSymbolGraphJsxProviderFlows.js';
+import { jsxComponentPropRenderFlowBoundary, jsxComponentPropRenderFlowRecords } from './projectSymbolGraphJsxPropFlows.js';
+import { jsxPropValueEvidence } from './projectSymbolGraphJsxPropValues.js';
+import { lineColumnForOffset } from './lineColumnForOffset.js';
+
+function createProjectJsxGraphRecords(semanticIndex, imports, publicContractRegions, importEdges = [], exportEdges = []) {
+  const publicKeys = publicJsxOwnerKeys(publicContractRegions, semanticIndex);
+  const componentOwnersBySourcePath = componentOwnerIndexesBySourcePath(semanticIndex, imports);
+  const importedOwnersBySourcePath = jsxImportedComponentOwnerIndexes(importEdges, exportEdges, componentOwnersBySourcePath);
+  const memberObjectsBySourcePath = componentMemberObjectIndexesBySourcePath(imports, componentOwnersBySourcePath, importedOwnersBySourcePath);
+  const importedMemberOwnersBySourcePath = jsxImportedMemberComponentOwnerIndexes(importEdges, exportEdges, memberObjectsBySourcePath);
+  const records = imports.map((imported) => jsxRecordsForImport(imported, semanticIndex, publicKeys, componentOwnersBySourcePath, importedOwnersBySourcePath, importedMemberOwnersBySourcePath)).filter(Boolean);
+  return {
+    jsxElementRecords: uniqueRecords(records.flatMap((record) => record.jsxElementRecords)),
+    jsxPropRecords: uniqueRecords(records.flatMap((record) => record.jsxPropRecords))
+  };
+}
+
+function jsxRecordsForImport(imported, semanticIndex, publicKeys, componentOwnersBySourcePath, importedOwnersBySourcePath, importedMemberOwnersBySourcePath) {
+  if (!isJsxLikeImport(imported)) return undefined;
+  const sourceText = nativeImportSourceText(imported);
+  const sourcePath = imported?.sourcePath ?? imported?.nativeSource?.sourcePath;
+  if (!sourceText || !sourcePath) return undefined;
+  const sourceHash = imported?.nativeSource?.sourceHash ?? imported?.metadata?.sourceHash;
+  const publicOwners = publicOwnerRanges(semanticIndex, sourcePath, publicKeys, sourceText);
+  const componentOwners = mergeJsxComponentOwnerIndexes(componentOwnersBySourcePath.get(sourcePath), importedOwnersBySourcePath.get(sourcePath));
+  const componentMemberOwners = mergeJsxComponentOwnerIndexes(
+    jsxSameFileMemberComponentOwnerIndex(sourceText, componentOwners),
+    importedMemberOwnersBySourcePath.get(sourcePath)
+  );
+  const parsed = parseJsxTags(sourceText);
+  const contextProviderAncestors = jsxContextProviderAncestorMap(parsed.tags, sourceText);
+  const providerFlowAncestors = jsxProviderFlowAncestorMap(parsed.tags, sourceText, componentOwners);
+  const elementRecords = parsed.tags.map((tag, index) => jsxElementRecord(tag, index, {
+    sourceText, sourcePath, sourceHash, publicOwners, componentOwners, componentMemberOwners,
+    contextProviderAncestors: contextProviderAncestors.get(tag.start), providerFlowAncestors: providerFlowAncestors.get(tag.start)
+  }));
+  return {
+    jsxElementRecords: elementRecords,
+    jsxPropRecords: parsed.tags.flatMap((tag, index) => jsxPropRecordsForTag(tag, index, elementRecords[index], { sourceText, sourcePath, sourceHash, componentOwners, componentMemberOwners }))
+  };
+}
+
+function jsxElementRecord(tag, index, context) {
+  const sourceSpan = sourceSpanForRange(context, tag.start, tag.end);
+  const owner = nearestPublicOwner(context.publicOwners, tag.start);
+  const propNames = uniqueStrings(tag.attributes.map((attribute) => attribute.name));
+  const propKinds = uniqueStrings(tag.attributes.map((attribute) => propKind(attribute)));
+  const spreadPropCount = tag.attributes.filter(isJsxSpreadAttribute).length;
+  const keyProp = jsxKeyProp(tag);
+  const fragmentKind = jsxFragmentKind(tag.tagName);
+  const eventHandlerProps = jsxEventHandlerProps(tag.attributes, owner?.eventHandlerDeclarations);
+  const effectiveProviders = [...(context.contextProviderAncestors ?? []), ...(context.providerFlowAncestors ?? [])];
+  const componentCall = jsxComponentProviderCallTarget(tag, context.componentOwners, context.componentMemberOwners, effectiveProviders);
+  const componentWrapperCallTarget = jsxComponentWrapperCallTarget(tag, context.componentOwners);
+  const componentContextConsumers = jsxComponentProviderContextConsumerRecords(tag, componentCall, effectiveProviders);
+  const renderRisk = mergeJsxRenderRiskEvidence(mergeJsxRenderRiskEvidence(
+    jsxRenderRiskEvidence(tag, owner, context.contextProviderAncestors, eventHandlerProps, componentContextConsumers),
+    jsxComponentWrapperRenderRiskEvidence(owner),
+    { tagName: tag.tagName, tagKey: tag.key, publicOwnerName: owner?.name }),
+    jsxComponentWrapperRenderRiskEvidence(componentWrapperCallTarget),
+    { tagName: tag.tagName, tagKey: tag.key, publicOwnerName: owner?.name }
+  );
+  return compactRecord({
+    id: `jsx_element_${idFragment(context.sourcePath)}_${index + 1}`,
+    tagName: tag.tagName,
+    tagKey: tag.key,
+    sourcePath: context.sourcePath,
+    sourceHash: context.sourceHash,
+    sourceSpan,
+    start: tag.start,
+    end: tag.end,
+    ordinal: index + 1,
+    propNames,
+    propKinds,
+    propCount: tag.attributes.length,
+    spreadPropCount: spreadPropCount || undefined,
+    keyedChild: keyProp ? true : undefined,
+    keyPropName: keyProp?.name,
+    keyPropValue: keyProp?.value,
+    keyPropText: keyProp?.text,
+    keyPropHash: keyProp?.hash,
+    fragmentKind,
+    component: isJsxComponentTag(tag.tagName) || undefined,
+    publicContract: Boolean(owner) || undefined,
+    publicOwnerName: owner?.name,
+    ...renderRisk,
+    childOrderSignatureHash: hashSemanticValue({
+      kind: 'frontier.lang.projectJsxChildOrderSignature', tagName: tag.tagName, tagKey: tag.key,
+      publicOwnerName: owner?.name, keyPropValue: keyProp?.value, fragmentKind, ordinal: index + 1,
+      span: semanticSpanForHash(sourceSpan)
+    }),
+    signatureHash: hashSemanticValue({
+      kind: 'frontier.lang.projectJsxElementSignature', tagName: tag.tagName, tagKey: tag.key,
+      keyPropValue: keyProp?.value, fragmentKind, propNames, propKinds, spreadPropCount,
+      span: semanticSpanForHash(sourceSpan)
+    })
+  });
+}
+
+function jsxPropRecordsForTag(tag, index, element, context) {
+  return tag.attributes.map((attribute, attrIndex) => {
+    const sourceSpan = sourceSpanForRange(context, attribute.start, attribute.end);
+    const valueEvidence = jsxPropValueEvidence(tag, attribute);
+    const componentPropRenderFlow = jsxComponentPropRenderFlowBoundary(tag, attribute, valueEvidence, { componentOwners: context.componentOwners, componentMemberOwners: context.componentMemberOwners, sourcePath: context.sourcePath, sourceText: context.sourceText });
+    return compactRecord({
+      id: `jsx_prop_${idFragment(context.sourcePath)}_${index + 1}_${attrIndex + 1}`,
+      elementId: element.id, tagName: tag.tagName, tagKey: tag.key, propName: attribute.name,
+      sourcePath: context.sourcePath, sourceHash: context.sourceHash, sourceSpan,
+      start: attribute.start, end: attribute.end, ordinal: attrIndex + 1,
+      propKind: propKind(attribute), keyProp: attribute.name === 'key' || undefined,
+      spread: isJsxSpreadAttribute(attribute) || undefined, spreadOrdinal: attribute.spreadOrdinal,
+      spreadExpressionHash: spreadExpressionHash(attribute),
+      propValueProofStatus: valueEvidence?.proofStatus, propValueReasonCode: valueEvidence?.reasonCode,
+      propValueKind: valueEvidence?.valueKind, propValueText: valueEvidence?.valueText,
+      propValueExpressionText: valueEvidence?.expressionText, propValueReferenceRoot: valueEvidence?.referenceRoot,
+      propValueReferencePath: valueEvidence?.referencePath, propValueDynamicText: valueEvidence?.dynamicText,
+      propValueOptionalReference: valueEvidence?.optionalReference, propValueOptionalReferenceSegments: valueEvidence?.optionalReferenceSegments,
+      propValueOptionalReferenceSegmentIndexes: valueEvidence?.optionalReferenceSegmentIndexes, propValueOptionalNullishBoundaryCount: valueEvidence?.optionalNullishBoundaryCount,
+      propValueDynamicBlockerReasonCode: valueEvidence?.dynamicBlockerReasonCode,
+      propValueExpressionHash: valueEvidence?.expressionHash, propValueSignatureHash: valueEvidence?.signatureHash,
+      componentPropRenderFlowStatus: componentPropRenderFlow?.status, componentPropRenderFlowReasonCode: componentPropRenderFlow?.reasonCode,
+      componentPropRenderFlowClaim: componentPropRenderFlow?.claim, componentPropRenderFlowClaimScope: componentPropRenderFlow?.claimScope,
+      componentPropRenderFlowRenderEquivalenceClaim: componentPropRenderFlow?.renderEquivalenceClaim,
+      componentPropRenderFlowScope: componentPropRenderFlow?.scope,
+      componentPropRenderFlowTargetName: componentPropRenderFlow?.targetName,
+      componentPropRenderFlowTargetKind: componentPropRenderFlow?.targetKind,
+      componentPropRenderFlowTargetOwnerName: componentPropRenderFlow?.targetOwnerName,
+      componentPropRenderFlowTargetOwnerCount: componentPropRenderFlow?.targetOwnerCount,
+      componentPropRenderFlowTargetSourcePath: componentPropRenderFlow?.targetSourcePath,
+      componentPropRenderFlowTargetLookupStatus: componentPropRenderFlow?.targetLookupStatus, componentPropRenderFlowTargetLookupScope: componentPropRenderFlow?.targetLookupScope,
+      componentPropRenderFlowImportEdgeId: componentPropRenderFlow?.importEdgeId, componentPropRenderFlowImportKind: componentPropRenderFlow?.importKind, componentPropRenderFlowImportedName: componentPropRenderFlow?.importedName, componentPropRenderFlowLocalName: componentPropRenderFlow?.localName, componentPropRenderFlowTargetExportName: componentPropRenderFlow?.targetExportName,
+      componentPropRenderFlowReExportEdgeId: componentPropRenderFlow?.reExportEdgeId, componentPropRenderFlowReExportSourcePath: componentPropRenderFlow?.reExportSourcePath, componentPropRenderFlowReExportExportedName: componentPropRenderFlow?.reExportExportedName, componentPropRenderFlowReExportLocalName: componentPropRenderFlow?.reExportLocalName, componentPropRenderFlowReExportTargetSourcePath: componentPropRenderFlow?.reExportTargetSourcePath, componentPropRenderFlowReExportKind: componentPropRenderFlow?.reExportKind, componentPropRenderFlowReExportIdentityId: componentPropRenderFlow?.reExportIdentityId, componentPropRenderFlowTargetLookupHash: componentPropRenderFlow?.targetLookupHash,
+      componentPropRenderFlowMemberObjectName: componentPropRenderFlow?.memberObjectName, componentPropRenderFlowMemberPropertyName: componentPropRenderFlow?.memberPropertyName, componentPropRenderFlowMemberLocalName: componentPropRenderFlow?.memberLocalName, componentPropRenderFlowMemberBindingKind: componentPropRenderFlow?.memberBindingKind, componentPropRenderFlowMemberBindingHash: componentPropRenderFlow?.memberBindingHash,
+      componentPropRenderFlowComponentPropName: componentPropRenderFlow?.componentPropName,
+      componentPropRenderFlowRenderedTagName: componentPropRenderFlow?.renderedTagName,
+      componentPropRenderFlowRenderedPropName: componentPropRenderFlow?.renderedPropName,
+      componentPropRenderFlowPassthroughExpressionText: componentPropRenderFlow?.passthroughExpressionText,
+      componentPropRenderFlowBindingKind: componentPropRenderFlow?.bindingKind,
+      componentPropRenderFlowReturnOrdinal: componentPropRenderFlow?.returnOrdinal,
+      componentPropRenderFlowDynamicBlockerReasonCode: componentPropRenderFlow?.dynamicBlockerReasonCode,
+      componentPropRenderFlowTargetSignatureHash: componentPropRenderFlow?.targetSignatureHash,
+      componentPropRenderFlowSignatureHash: componentPropRenderFlow?.signatureHash,
+      publicContract: element.publicContract, publicOwnerName: element.publicOwnerName,
+      signatureHash: hashSemanticValue({
+        kind: 'frontier.lang.projectJsxPropSignature', tagName: tag.tagName, tagKey: tag.key,
+        propName: attribute.name, propKind: propKind(attribute), text: normalizedAttrText(attribute.text),
+        spreadExpressionHash: spreadExpressionHash(attribute), propValueSignatureHash: valueEvidence?.signatureHash,
+        componentPropRenderFlowSignatureHash: componentPropRenderFlow?.signatureHash
+      })
+    });
+  });
+}
+
+function publicOwnerRanges(semanticIndex, sourcePath, publicKeys, sourceText) { return ownerRanges(semanticIndex, sourcePath, sourceText, (symbol) => symbol?.kind !== 'export' && publicKeys.has(publicKey(sourcePath, symbol?.name))); }
+
+function componentOwnerRanges(semanticIndex, sourcePath, sourceText) { return ownerRanges(semanticIndex, sourcePath, sourceText, (symbol) => symbol?.kind !== 'export' && plainComponentTagName(symbol?.name)).filter(jsxComponentOwnerHasRenderableEvidence); }
+
+function ownerRanges(semanticIndex, sourcePath, sourceText, predicate) {
+  return (semanticIndex?.symbols ?? []).filter((symbol) => predicate(symbol) && symbol.definitionSpan?.path === sourcePath).map((symbol) => publicOwnerRange(symbol, sourceText)).filter((owner) => owner.range);
+}
+
+function componentOwnerIndex(owners) {
+  const result = new Map(); for (const owner of owners) result.set(owner.name, [...(result.get(owner.name) ?? []), owner]); return result;
+}
+
+function componentOwnerIndexesBySourcePath(semanticIndex, imports) { return new Map(imports.map((imported) => componentOwnerIndexEntry(semanticIndex, imported)).filter(([sourcePath]) => sourcePath)); }
+
+function componentOwnerIndexEntry(semanticIndex, imported) {
+  const sourceText = nativeImportSourceText(imported); const sourcePath = imported?.sourcePath ?? imported?.nativeSource?.sourcePath;
+  return [sourcePath, sourceText && sourcePath ? componentOwnerIndex(componentOwnerRanges(semanticIndex, sourcePath, sourceText)) : new Map()];
+}
+
+function componentMemberObjectIndexesBySourcePath(imports, componentOwnersBySourcePath, importedOwnersBySourcePath) {
+  return new Map(imports.map((imported) => componentMemberObjectIndexEntry(imported, componentOwnersBySourcePath, importedOwnersBySourcePath)).filter(([sourcePath]) => sourcePath));
+}
+
+function componentMemberObjectIndexEntry(imported, componentOwnersBySourcePath, importedOwnersBySourcePath) {
+  const sourceText = nativeImportSourceText(imported); const sourcePath = imported?.sourcePath ?? imported?.nativeSource?.sourcePath;
+  const owners = mergeJsxComponentOwnerIndexes(componentOwnersBySourcePath.get(sourcePath), importedOwnersBySourcePath.get(sourcePath));
+  return [sourcePath, sourceText && sourcePath ? jsxSameFileMemberComponentObjectIndex(sourceText, owners) : new Map()];
+}
+
+function jsxComponentProviderCallTarget(tag, componentOwners, componentMemberOwners, contextProviderAncestors = []) {
+  if (!contextProviderAncestors?.length || !isJsxComponentTag(tag.tagName)) return undefined;
+  const targetName = plainComponentTagName(tag.tagName) ? tag.tagName : undefined;
+  if (!targetName) return jsxMemberComponentProviderCallTarget(tag, componentMemberOwners);
+  const owners = componentOwners?.get(targetName) ?? [];
+  if (owners.length !== 1) return { status: 'unsupported', targetName, reasonCode: 'jsx-render-context-consumer-provider-component-target-unsupported' };
+  return { status: 'resolved', targetName, owner: owners[0], scope: owners[0].componentProviderLookupScope, lookupStatus: owners[0].componentCallLookupStatus };
+}
+function jsxMemberComponentProviderCallTarget(tag, componentMemberOwners) { const targetName = memberComponentTagName(tag.tagName); const owners = targetName ? componentMemberOwners?.get(targetName) ?? [] : []; return owners.length === 1 ? { status: 'resolved', targetName, owner: owners[0], scope: owners[0].componentProviderLookupScope, lookupStatus: owners[0].componentCallLookupStatus } : { status: 'unsupported', targetName: tag.tagName, reasonCode: 'jsx-render-context-consumer-provider-component-target-unsupported' }; }
+function jsxComponentWrapperCallTarget(tag, componentOwners) { const targetName = plainComponentTagName(tag.tagName); const owners = targetName ? componentOwners?.get(targetName) ?? [] : []; return owners.length === 1 ? owners[0] : undefined; }
+function jsxComponentOwnerHasRenderableEvidence(owner) { return Boolean(owner.hookCalls?.length || owner.renderReturnRecords?.length || owner.componentWrapperRecords?.length); }
+
+function publicOwnerRange(symbol, sourceText) {
+  const range = rangeForSpan(sourceText, symbol.definitionSpan);
+  const ownerSourceText = range ? sourceText.slice(range.start, range.end) : undefined;
+  const hookCalls = ownerSourceText ? jsxHookCalls(ownerSourceText) : [];
+  const eventHandlerDeclarations = ownerSourceText ? jsxOwnerEventHandlerDeclarations(ownerSourceText, symbol.name) : undefined;
+  const renderReturnRecords = ownerSourceText ? jsxRenderReturnRecords(ownerSourceText) : [];
+  const componentWrapperRecords = ownerSourceText ? jsxComponentWrapperRecords(ownerSourceText, symbol.name) : [];
+  const providerFlowRecords = ownerSourceText ? jsxProviderFlowRecords(ownerSourceText, symbol.name) : [];
+  const componentPropRenderFlowRecords = ownerSourceText ? jsxComponentPropRenderFlowRecords(ownerSourceText, symbol.name, renderReturnRecords) : [];
+  return {
+    name: symbol.name,
+    sourcePath: symbol.definitionSpan?.path,
+    range,
+    hookNames: uniqueStrings(hookCalls.map((call) => call.name)),
+    hookCalls,
+    eventHandlerDeclarations,
+    renderReturnRecords,
+    componentWrapperRecords,
+    providerFlowRecords,
+    componentPropRenderFlowRecords
+  };
+}
+
+function publicJsxOwnerKeys(publicContractRegions = [], semanticIndex) {
+  const keys = new Set(publicContractRegions.flatMap((region) => [
+    publicKey(region.sourcePath, region.symbolName),
+    publicKey(region.sourcePath, region.exportedName)
+  ]).filter(Boolean));
+  for (const symbol of semanticIndex?.symbols ?? []) {
+    if (symbol?.kind === 'export' && symbol.definitionSpan?.path && symbol.name && !String(symbol.name).startsWith('{')) keys.add(publicKey(symbol.definitionSpan.path, symbol.name));
+  }
+  return keys;
+}
+
+function nearestPublicOwner(owners, start) {
+  return owners.filter((owner) => owner.range.start <= start && start <= owner.range.end).sort((left, right) => right.range.start - left.range.start)[0];
+}
+
+function isJsxLikeImport(imported) {
+  const language = String(imported?.language ?? imported?.nativeSource?.language ?? '').toLowerCase();
+  const path = String(imported?.sourcePath ?? imported?.nativeSource?.sourcePath ?? '').toLowerCase();
+  return language === 'jsx' || language === 'tsx' || path.endsWith('.jsx') || path.endsWith('.tsx');
+}
+function rangeForSpan(sourceText, span) {
+  if (!span?.startLine || !span?.startColumn) return undefined;
+  return { start: offsetForLineColumn(sourceText, span.startLine, span.startColumn), end: offsetForLineColumn(sourceText, span.endLine ?? span.startLine, span.endColumn ?? span.startColumn) };
+}
+function offsetForLineColumn(sourceText, line, column) {
+  const lines = String(sourceText ?? '').split(/\n/);
+  let offset = 0;
+  for (let index = 0; index < Math.max(0, line - 1); index += 1) offset += lines[index].length + 1;
+  return offset + Math.max(0, column - 1);
+}
+function sourceSpanForRange(context, start, end) {
+  const startPos = lineColumnForOffset(context.sourceText, start);
+  const endPos = lineColumnForOffset(context.sourceText, end);
+  return { sourceId: context.sourceHash, path: context.sourcePath, start, end, startLine: startPos.line, startColumn: startPos.column, endLine: endPos.line, endColumn: endPos.column };
+}
+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 semanticSpanForHash(span) { return { path: span.path, start: span.start, end: span.end, startLine: span.startLine, startColumn: span.startColumn, endLine: span.endLine, endColumn: span.endColumn }; }
+function normalizedAttrText(text) { return String(text ?? '').trim().replace(/\s+/g, ' '); }
+function normalizedSpreadExpressionText(attribute) { return String(attribute?.expressionText ?? '').trim().replace(/\s+/g, ' '); }
+function propKind(attribute) { return isJsxSpreadAttribute(attribute) ? 'spread' : 'named'; }
+function spreadExpressionHash(attribute) {
+  return isJsxSpreadAttribute(attribute)
+    ? hashSemanticValue({ kind: 'frontier.lang.projectJsxSpreadExpression', text: normalizedSpreadExpressionText(attribute) })
+    : undefined;
+}
+function jsxKeyProp(tag) {
+  const attribute = tag.attributes.find((candidate) => candidate.name === 'key');
+  if (!attribute) return undefined;
+  const parsed = literalJsxKeyValue(attribute.text);
+  return compactRecord({
+    name: 'key',
+    value: parsed?.value,
+    text: normalizedAttrText(attribute.text),
+    hash: hashSemanticValue({
+      kind: 'frontier.lang.projectJsxKeyProp',
+      text: normalizedAttrText(attribute.text),
+      value: parsed?.value
+    })
+  });
+}
+function literalJsxKeyValue(text) {
+  const match = /^key\s*=\s*(?:"([^"]*)"|'([^']*)')\s*$/.exec(String(text ?? '').trim());
+  return match ? { value: match[1] ?? match[2] ?? '' } : undefined;
+}
+function jsxFragmentKind(tagName) {
+  const value = String(tagName ?? '');
+  if (value === 'Fragment') return 'fragment';
+  if (value === 'React.Fragment') return 'react-fragment';
+  return undefined;
+}
+function plainComponentTagName(tagName) { return /^[A-Z][A-Za-z0-9_$]*$/.test(String(tagName ?? '')) ? String(tagName) : undefined; }
+function memberComponentTagName(tagName) { return /^[A-Z][A-Za-z0-9_$]*(?:\.[A-Z][A-Za-z0-9_$]*)+$/.test(String(tagName ?? '')) ? String(tagName) : undefined; }
+function publicKey(sourcePath, name) { return sourcePath && name ? `${sourcePath}\0${name}` : undefined; }
+function compactRecord(record) { return Object.fromEntries(Object.entries(record).filter(([, value]) => value !== undefined)); }
+function uniqueRecords(records) {
+  const seen = new Set();
+  return records.filter((record) => {
+    const key = record.id ?? JSON.stringify(record);
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+}
+export { createProjectJsxGraphRecords };

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

@@ -0,0 +1,155 @@
+import { hashSemanticValue } from '@shapeshift-labs/frontier-lang-kernel';
+
+function jsxRenderReturnCollectionRecord(expressionText) {
+  const items = topLevelArrayItems(expressionText);
+  if (items.length) return collectionRecord('array-literal', 'static-render-return-array-evidence', items, 'Array');
+  const fragment = topLevelFragmentItems(expressionText);
+  if (!fragment?.items.length) return undefined;
+  return collectionRecord(fragment.kind, 'static-render-return-fragment-evidence', fragment.items, 'Fragment');
+}
+
+function collectionRecord(collectionKind, proofStatus, items, hashScope) {
+  return compactRecord({
+    proofStatus,
+    collectionKind,
+    itemCount: items.length,
+    itemExpressionTexts: items,
+    itemRecords: items.map((itemText, index) => ({
+      ordinal: index + 1,
+      expressionText: itemText,
+      expressionHash: hashSemanticValue({
+        kind: `frontier.lang.projectJsxRender${hashScope}ItemExpression`,
+        expressionText: itemText
+      }),
+      signatureHash: hashSemanticValue({
+        kind: `frontier.lang.projectJsxRender${hashScope}Item`,
+        ordinal: index + 1,
+        expressionText: itemText
+      })
+    })),
+    signatureHash: hashSemanticValue({
+      kind: `frontier.lang.projectJsxRender${hashScope}Return`,
+      collectionKind,
+      items
+    })
+  });
+}
+
+function topLevelArrayItems(expressionText) {
+  const value = stripParens(normalizedText(expressionText));
+  if (!value.startsWith('[') || !value.endsWith(']')) return [];
+  const body = value.slice(1, -1);
+  const items = splitTopLevelComma(body).map(normalizedText).filter(Boolean);
+  return items.every((item) => isStaticRenderableArrayItem(item)) ? items : [];
+}
+
+function topLevelFragmentItems(expressionText) {
+  const value = stripParens(normalizedText(expressionText));
+  const shorthand = /^<>\s*([\s\S]*)\s*<\/>$/.exec(value);
+  if (shorthand) return { kind: 'fragment-shorthand', items: topLevelJsxChildren(shorthand[1]) };
+  const named = /^<(Fragment|React\.Fragment)(?:\s[^>]*)?>\s*([\s\S]*)\s*<\/\1>$/.exec(value);
+  if (!named) return undefined;
+  return { kind: named[1] === 'React.Fragment' ? 'fragment-react' : 'fragment-named', items: topLevelJsxChildren(named[2]) };
+}
+
+function topLevelJsxChildren(text) {
+  const value = String(text ?? '');
+  const items = [];
+  let index = 0;
+  while (index < value.length) {
+    while (/\s/.test(value[index] ?? '')) index += 1;
+    if (index >= value.length) break;
+    const end = jsxElementEnd(value, index);
+    if (end <= index) return [];
+    items.push(normalizedText(value.slice(index, end)));
+    index = end;
+  }
+  return items;
+}
+
+function jsxElementEnd(text, start) {
+  const first = jsxTagAt(text, start);
+  if (!first || first.closing) return -1;
+  if (first.selfClosing) return first.end;
+  const stack = [first.name];
+  let index = first.end;
+  while (index < text.length) {
+    const next = text.indexOf('<', index);
+    if (next < 0) return -1;
+    const tag = jsxTagAt(text, next);
+    if (!tag) { index = next + 1; continue; }
+    if (tag.closing) {
+      const open = stack.pop();
+      if (open !== tag.name) return -1;
+      if (!stack.length) return tag.end;
+    } else if (!tag.selfClosing) stack.push(tag.name);
+    index = tag.end;
+  }
+  return -1;
+}
+
+function jsxTagAt(text, start) {
+  const value = String(text ?? '');
+  if (value[start] !== '<') return undefined;
+  const end = jsxTagEnd(value, start + 1);
+  if (end < 0) return undefined;
+  const tagText = value.slice(start, end + 1);
+  if (tagText === '<>') return { name: '#fragment', closing: false, selfClosing: false, end: end + 1 };
+  if (tagText === '</>') return { name: '#fragment', closing: true, selfClosing: false, end: end + 1 };
+  const match = /^<\s*(\/?)\s*([A-Za-z][\w.$:-]*)[\s\S]*?>$/.exec(tagText);
+  if (!match) return undefined;
+  return { name: match[2], closing: Boolean(match[1]), selfClosing: /\/\s*>$/.test(tagText), end: end + 1 };
+}
+
+function jsxTagEnd(text, start) {
+  let quote;
+  for (let index = start; index < text.length; index += 1) {
+    const char = text[index];
+    if (quote) {
+      if (char === '\\') index += 1;
+      else if (char === quote) quote = undefined;
+    } else if (char === '"' || char === "'" || char === '`') quote = char;
+    else if (char === '>') return index;
+  }
+  return -1;
+}
+
+function splitTopLevelComma(text) {
+  const value = String(text ?? '');
+  const parts = [];
+  let start = 0;
+  let quote;
+  let depth = 0;
+  for (let index = 0; index < value.length; index += 1) {
+    const char = value[index];
+    if (quote) {
+      if (char === '\\') index += 1;
+      else if (char === quote) quote = undefined;
+      continue;
+    }
+    if (char === '"' || char === "'" || char === '`') quote = char;
+    else if (char === '(' || char === '[' || char === '{') depth += 1;
+    else if (char === ')' || char === ']' || char === '}') depth = Math.max(0, depth - 1);
+    else if (char === ',' && depth === 0) {
+      parts.push(value.slice(start, index));
+      start = index + 1;
+    }
+  }
+  parts.push(value.slice(start));
+  return parts;
+}
+
+function isStaticRenderableArrayItem(text) {
+  const value = stripParens(normalizedText(text));
+  return /^(?:<|React\s*\.\s*createElement\s*\(|null\b|false\b|undefined\b)/.test(value);
+}
+
+function stripParens(text) {
+  const value = normalizedText(text);
+  const wrapped = /^\(([\s\S]*)\)$/.exec(value);
+  return wrapped ? normalizedText(wrapped[1]) : value;
+}
+function normalizedText(text) { return String(text ?? '').trim().replace(/\s+/g, ' '); }
+function compactRecord(record) { return Object.fromEntries(Object.entries(record).filter(([, value]) => value !== undefined)); }
+
+export { jsxRenderReturnCollectionRecord };