@shapeshift-labs/frontier-lang-compiler 0.2.161 → 0.2.163

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

@@ -11,6 +11,7 @@ import { jsxImportedComponentOwnerIndexes, jsxImportedMemberComponentOwnerIndexe
 import { jsxSameFileMemberComponentObjectIndex, jsxSameFileMemberComponentOwnerIndex } from './projectSymbolGraphJsxMemberComponents.js';
 import { jsxProviderFlowAncestorMap, jsxProviderFlowRecords } from './projectSymbolGraphJsxProviderFlows.js';
 import { jsxComponentPropRenderFlowBoundary, jsxComponentPropRenderFlowRecords } from './projectSymbolGraphJsxPropFlows.js';
+import { jsxPropComponentFlowRecordFields, jsxPropValueRecordFields } from './projectSymbolGraphJsxPropRecordFields.js';
 import { jsxPropValueEvidence } from './projectSymbolGraphJsxPropValues.js';
 import { lineColumnForOffset } from './lineColumnForOffset.js';
 
@@ -112,7 +113,7 @@ function jsxElementRecord(tag, index, context) {
 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 valueEvidence = jsxPropValueEvidence(tag, attribute, context);
     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}`,
@@ -122,36 +123,8 @@ function jsxPropRecordsForTag(tag, index, element, context) {
       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,
+      ...jsxPropValueRecordFields(valueEvidence),
+      ...jsxPropComponentFlowRecordFields(componentPropRenderFlow),
       publicContract: element.publicContract, publicOwnerName: element.publicOwnerName,
       signatureHash: hashSemanticValue({
         kind: 'frontier.lang.projectJsxPropSignature', tagName: tag.tagName, tagKey: tag.key,

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

@@ -0,0 +1,201 @@
+function staticMapCall(expressionText) {
+  const value = normalizedReturnExpression(expressionText);
+  const target = /^([A-Za-z_$][\w$]*)\s*\.\s*map\s*\(/.exec(value);
+  if (!target) return undefined;
+  const argsStart = target[0].length - 1;
+  const argsEnd = matchingClose(value, argsStart, '(', ')');
+  if (argsEnd !== value.length - 1) return undefined;
+  return {
+    arrayName: target[1],
+    callbackText: normalizedText(value.slice(argsStart + 1, argsEnd))
+  };
+}
+
+function staticMapCallback(callbackText) {
+  const value = normalizedText(callbackText);
+  const match = /^(?:\(\s*([A-Za-z_$][\w$]*)(?:\s*,\s*([A-Za-z_$][\w$]*))?\s*\)|([A-Za-z_$][\w$]*))\s*=>\s*([\s\S]*)$/.exec(value);
+  if (!match) return undefined;
+  const bodyExpressionText = normalizedReturnExpression(match[4]);
+  if (bodyExpressionText.startsWith('{')) return undefined;
+  return {
+    callbackText: value,
+    parameterName: match[1] ?? match[3],
+    indexParameterName: match[2],
+    bodyExpressionText
+  };
+}
+
+function constArrayLiteralBinding(sourceText, arrayName) {
+  const value = String(sourceText ?? '');
+  const declaration = new RegExp(`\\bconst\\s+${escapeRegExp(arrayName)}\\s*=\\s*\\[`, 'g').exec(value);
+  if (!declaration) return undefined;
+  const arrayStart = value.indexOf('[', declaration.index);
+  const arrayEnd = matchingClose(value, arrayStart, '[', ']');
+  if (arrayEnd < 0) return undefined;
+  return { arrayLiteralText: normalizedText(value.slice(arrayStart, arrayEnd + 1)) };
+}
+
+function staticMapSourceItemRecord(sourceItemExpressionText) {
+  const literal = staticLiteralValue(sourceItemExpressionText);
+  if (literal) return { kind: literal.kind, props: new Map() };
+  const props = staticObjectLiteralProps(sourceItemExpressionText);
+  return props ? { kind: 'object-literal', props } : undefined;
+}
+
+function staticObjectLiteralProps(sourceItemExpressionText) {
+  const value = normalizedReturnExpression(sourceItemExpressionText);
+  if (!value.startsWith('{') || !value.endsWith('}')) return undefined;
+  const parts = splitTopLevel(value.slice(1, -1), ',').filter((part) => normalizedText(part));
+  if (!parts.length) return undefined;
+  const props = new Map();
+  for (const part of parts) {
+    const match = /^\s*([A-Za-z_$][\w$]*)\s*:\s*([\s\S]*?)\s*$/.exec(part);
+    if (!match) return undefined;
+    const literal = staticLiteralValue(match[2]);
+    if (!literal) return undefined;
+    props.set(match[1], literal);
+  }
+  return props;
+}
+
+function staticLiteralValue(text) {
+  const value = normalizedText(text);
+  const string = /^"([^"]*)"|'([^']*)'$/.exec(value);
+  if (string) return { value: string[1] ?? string[2] ?? '', text: value, kind: 'string' };
+  if (/^-?\d+(?:\.\d+)?$/.test(value)) return { value: Number(value), text: value, kind: 'number' };
+  if (value === 'true' || value === 'false') return { value: value === 'true', text: value, kind: 'boolean' };
+  if (value === 'null') return { value: null, text: value, kind: 'null' };
+  return undefined;
+}
+
+function mapKeyResolution(keyEvidence, parameterName, sourceItemProps) {
+  if (!keyEvidence) return undefined;
+  if (keyEvidence.keyValue !== undefined) return { keyValue: keyEvidence.keyValue, keyStatic: true };
+  const prefix = `${parameterName}.`;
+  if (!keyEvidence.keyExpressionText?.startsWith(prefix)) return { keyStatic: false };
+  const keySourcePropName = keyEvidence.keyExpressionText.slice(prefix.length);
+  if (!/^[A-Za-z_$][\w$]*$/.test(keySourcePropName)) return { keyStatic: false };
+  const prop = sourceItemProps.get(keySourcePropName);
+  return prop ? { keyValue: prop.value, keySourcePropName, keyStatic: true } : { keySourcePropName, keyStatic: false };
+}
+
+function jsxKeyEvidence(expressionText) {
+  const openingTag = firstJsxOpeningTagText(expressionText);
+  if (!openingTag) return undefined;
+  const match = /\bkey\s*=\s*("[^"]*"|'[^']*'|\{[^}]*\})/.exec(openingTag);
+  if (!match) return undefined;
+  const rawValue = match[1].trim();
+  const quoted = /^"([^"]*)"|'([^']*)'$/.exec(rawValue);
+  const braced = /^\{\s*([\s\S]*?)\s*\}$/.exec(rawValue);
+  return compactRecord({
+    keyPropText: normalizedText(match[0]),
+    keyValue: quoted ? quoted[1] ?? quoted[2] ?? '' : undefined,
+    keyExpressionText: braced ? normalizedText(braced[1]) : undefined
+  });
+}
+
+function firstJsxOpeningTagText(expressionText) {
+  const value = normalizedReturnExpression(expressionText);
+  const start = value.indexOf('<');
+  if (start < 0 || value[start + 1] === '/' || value[start + 1] === '>') return undefined;
+  let quote;
+  let braceDepth = 0;
+  for (let index = start + 1; 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 === '{') braceDepth += 1;
+    else if (char === '}') braceDepth = Math.max(0, braceDepth - 1);
+    else if (char === '>' && braceDepth === 0) return value.slice(start, index + 1);
+  }
+  return undefined;
+}
+
+function directJsxChildren(text) {
+  const value = normalizedText(text);
+  const children = [];
+  const childPattern = /<([A-Za-z][\w.]*)\b[^>]*\/>|<([A-Za-z][\w.]*)\b[^>]*>[\s\S]*?<\/\2>/g;
+  for (const match of value.matchAll(childPattern)) children.push(normalizedText(match[0]));
+  return children;
+}
+
+function isJsxExpression(text) {
+  const value = normalizedReturnExpression(text);
+  return /^<[A-Za-z][\w.]*(?:\s|>|\/>)/.test(value) || /^React\s*\.\s*createElement\s*\(/.test(value);
+}
+
+function splitTopLevel(text, delimiter) {
+  const value = String(text ?? '');
+  const parts = [];
+  let quote;
+  let depth = 0;
+  let start = 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 === '{' || char === '<') depth += 1;
+    else if (char === ')' || char === ']' || char === '}') depth = Math.max(0, depth - 1);
+    else if (char === '>' && depth > 0) depth = Math.max(0, depth - 1);
+    else if (depth === 0 && value.slice(index, index + delimiter.length) === delimiter) {
+      parts.push(value.slice(start, index));
+      start = index + delimiter.length;
+      index += delimiter.length - 1;
+    }
+  }
+  parts.push(value.slice(start));
+  return parts;
+}
+
+function matchingClose(text, openIndex, openChar, closeChar) {
+  const value = String(text ?? '');
+  let quote;
+  let depth = 0;
+  for (let index = openIndex; 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 === openChar) depth += 1;
+    else if (char === closeChar) {
+      depth -= 1;
+      if (depth === 0) return index;
+    }
+  }
+  return -1;
+}
+
+function escapeRegExp(text) { return String(text ?? '').replace(/[.*+?^${}()|[\]\\]/g, '\\$&'); }
+function normalizedText(text) { return String(text ?? '').trim().replace(/\s+/g, ' '); }
+function normalizedReturnExpression(text) {
+  const value = normalizedText(text);
+  const wrapped = /^\(([\s\S]*)\)$/.exec(value);
+  return wrapped ? normalizedText(wrapped[1]) : value;
+}
+function compactRecord(record) { return Object.fromEntries(Object.entries(record).filter(([, value]) => value !== undefined)); }
+
+export {
+  compactRecord,
+  constArrayLiteralBinding,
+  directJsxChildren,
+  isJsxExpression,
+  jsxKeyEvidence,
+  mapKeyResolution,
+  normalizedReturnExpression,
+  normalizedText,
+  splitTopLevel,
+  staticMapCall,
+  staticMapCallback,
+  staticMapSourceItemRecord
+};

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

@@ -0,0 +1,210 @@
+import { hashSemanticValue } from '@shapeshift-labs/frontier-lang-kernel';
+import {
+  compactRecord,
+  constArrayLiteralBinding,
+  directJsxChildren,
+  isJsxExpression,
+  jsxKeyEvidence,
+  mapKeyResolution,
+  normalizedReturnExpression,
+  splitTopLevel,
+  staticMapCall,
+  staticMapCallback,
+  staticMapSourceItemRecord
+} from './projectSymbolGraphJsxRenderReturnCollectionHelpers.js';
+
+function jsxRenderReturnCollectionRecord(expressionText, sourceText) {
+  const value = normalizedReturnExpression(expressionText);
+  return arrayLiteralCollectionRecord(value)
+    ?? fragmentCollectionRecord(value)
+    ?? staticConstArrayMapCollectionRecord(value, sourceText);
+}
+
+function arrayLiteralCollectionRecord(expressionText) {
+  if (!expressionText.startsWith('[') || !expressionText.endsWith(']')) return undefined;
+  const itemExpressionTexts = splitTopLevel(expressionText.slice(1, -1), ',').map(normalizedReturnExpression).filter(Boolean);
+  if (!itemExpressionTexts.length || itemExpressionTexts.some((item) => !isJsxExpression(item))) return undefined;
+  return jsxCollectionRecord({
+    proofStatus: 'static-render-return-array-evidence',
+    reasonCode: 'jsx-render-return-array-static-evidence',
+    collectionKind: 'array-literal',
+    itemExpressionTexts,
+    itemRecords: collectionItemRecords('array-literal', itemExpressionTexts)
+  });
+}
+
+function fragmentCollectionRecord(expressionText) {
+  if (expressionText.startsWith('<>') && expressionText.endsWith('</>')) {
+    const itemExpressionTexts = directJsxChildren(expressionText.slice(2, -3));
+    if (!itemExpressionTexts.length) return undefined;
+    return jsxCollectionRecord({
+      proofStatus: 'static-render-return-fragment-evidence',
+      reasonCode: 'jsx-render-return-fragment-static-evidence',
+      collectionKind: 'fragment-shorthand',
+      itemExpressionTexts,
+      itemRecords: collectionItemRecords('fragment-shorthand', itemExpressionTexts)
+    });
+  }
+  const named = /^<((?:React\.)?Fragment)\b[^>]*>([\s\S]*)<\/\1>$/.exec(expressionText);
+  if (!named) return undefined;
+  const itemExpressionTexts = directJsxChildren(named[2]);
+  if (!itemExpressionTexts.length) return undefined;
+  const collectionKind = named[1] === 'React.Fragment' ? 'fragment-react' : 'fragment-named';
+  return jsxCollectionRecord({
+    proofStatus: 'static-render-return-fragment-evidence',
+    reasonCode: 'jsx-render-return-fragment-static-evidence',
+    collectionKind,
+    itemExpressionTexts,
+    itemRecords: collectionItemRecords(collectionKind, itemExpressionTexts)
+  });
+}
+
+function staticConstArrayMapCollectionRecord(expressionText, sourceText) {
+  const mapCall = staticMapCall(expressionText);
+  if (!mapCall) return undefined;
+  const arrayBinding = constArrayLiteralBinding(sourceText, mapCall.arrayName);
+  if (!arrayBinding) return undefined;
+  const callback = staticMapCallback(mapCall.callbackText);
+  if (!callback || !isJsxExpression(callback.bodyExpressionText)) return undefined;
+  const sourceItemExpressionTexts = splitTopLevel(arrayBinding.arrayLiteralText.slice(1, -1), ',').map(normalizedReturnExpression).filter(Boolean);
+  if (!sourceItemExpressionTexts.length) return undefined;
+  const sourceItemRecords = sourceItemExpressionTexts.map(staticMapSourceItemRecord);
+  if (sourceItemRecords.some((record) => !record)) return undefined;
+  const keyEvidence = jsxKeyEvidence(callback.bodyExpressionText);
+  const itemExpressionTexts = sourceItemExpressionTexts.map(() => callback.bodyExpressionText);
+  const itemRecords = sourceItemExpressionTexts.map((sourceItemExpressionText, index) => staticConstArrayMapItemRecord({
+    callback,
+    index,
+    keyEvidence,
+    sourceItem: sourceItemRecords[index],
+    sourceItemExpressionText
+  }));
+  return jsxCollectionRecord({
+    proofStatus: 'static-render-return-map-evidence',
+    reasonCode: 'jsx-render-return-static-const-array-map-evidence',
+    collectionKind: 'static-const-array-map',
+    claimScope: 'static-const-array-map-structure-only',
+    renderEquivalenceClaim: false,
+    runtimeEquivalenceClaim: false,
+    sourceArrayName: mapCall.arrayName,
+    sourceArrayItemCount: sourceItemExpressionTexts.length,
+    sourceItemExpressionTexts,
+    mapCallbackExpressionText: callback.callbackText,
+    mapParameterName: callback.parameterName,
+    mapIndexParameterName: callback.indexParameterName,
+    callbackExpressionText: callback.bodyExpressionText,
+    itemExpressionTexts,
+    itemRecords
+  });
+}
+
+function staticConstArrayMapItemRecord(input) {
+  const { callback, index, keyEvidence, sourceItem, sourceItemExpressionText } = input;
+  const keyResolution = mapKeyResolution(keyEvidence, callback.parameterName, sourceItem.props);
+  return compactRecord({
+    ordinal: index + 1,
+    proofStatus: 'static-render-return-map-item-evidence',
+    expressionText: callback.bodyExpressionText,
+    expressionHash: hashSemanticValue({ kind: 'frontier.lang.projectJsxRenderReturnMapItemExpression', text: callback.bodyExpressionText }),
+    sourceItemExpressionText,
+    sourceItemExpressionHash: hashSemanticValue({ kind: 'frontier.lang.projectJsxRenderReturnMapSourceItem', text: sourceItemExpressionText }),
+    sourceItemKind: sourceItem.kind,
+    keyPropText: keyEvidence?.keyPropText,
+    keyExpressionText: keyEvidence?.keyExpressionText,
+    keyValue: keyResolution?.keyValue,
+    keySourcePropName: keyResolution?.keySourcePropName,
+    keyStatic: keyResolution?.keyStatic,
+    signatureHash: hashSemanticValue({
+      kind: 'frontier.lang.projectJsxRenderReturnMapItem',
+      ordinal: index + 1,
+      expressionText: callback.bodyExpressionText,
+      sourceItemExpressionText,
+      sourceItemKind: sourceItem.kind,
+      keyPropText: keyEvidence?.keyPropText,
+      keyExpressionText: keyEvidence?.keyExpressionText,
+      keyValue: keyResolution?.keyValue,
+      keySourcePropName: keyResolution?.keySourcePropName
+    })
+  });
+}
+
+function jsxCollectionRecord(record) {
+  const itemRecords = record.itemRecords ?? [];
+  const keyedListRecord = keyedListRecordFor(record.collectionKind, itemRecords);
+  return compactRecord({
+    ...record,
+    itemCount: itemRecords.length,
+    keyedListRecord,
+    signatureHash: hashSemanticValue({
+      kind: 'frontier.lang.projectJsxRenderReturnCollection',
+      proofStatus: record.proofStatus,
+      collectionKind: record.collectionKind,
+      sourceArrayName: record.sourceArrayName,
+      sourceItemExpressionTexts: record.sourceItemExpressionTexts,
+      mapCallbackExpressionText: record.mapCallbackExpressionText,
+      itemExpressionTexts: record.itemExpressionTexts,
+      itemRecords,
+      keyedListSignatureHash: keyedListRecord?.signatureHash,
+      claimScope: record.claimScope,
+      renderEquivalenceClaim: record.renderEquivalenceClaim,
+      runtimeEquivalenceClaim: record.runtimeEquivalenceClaim
+    })
+  });
+}
+
+function collectionItemRecords(collectionKind, itemExpressionTexts) {
+  return itemExpressionTexts.map((itemExpressionText, index) => {
+    const key = jsxKeyEvidence(itemExpressionText);
+    return compactRecord({
+      ordinal: index + 1,
+      proofStatus: 'static-render-return-collection-item-evidence',
+      expressionText: itemExpressionText,
+      expressionHash: hashSemanticValue({ kind: 'frontier.lang.projectJsxRenderReturnCollectionItemExpression', text: itemExpressionText }),
+      keyPropText: key?.keyPropText,
+      keyExpressionText: key?.keyExpressionText,
+      keyValue: key?.keyValue,
+      keyStatic: key ? key.keyValue !== undefined : undefined,
+      signatureHash: hashSemanticValue({
+        kind: 'frontier.lang.projectJsxRenderReturnCollectionItem',
+        collectionKind,
+        ordinal: index + 1,
+        expressionText: itemExpressionText,
+        keyPropText: key?.keyPropText,
+        keyExpressionText: key?.keyExpressionText,
+        keyValue: key?.keyValue
+      })
+    });
+  });
+}
+
+function keyedListRecordFor(collectionKind, itemRecords) {
+  if (!itemRecords.length || itemRecords.some((record) => record.keyStatic === false || (!record.keyPropText && !record.keyExpressionText && record.keyValue === undefined))) return undefined;
+  const keyRecords = itemRecords.map((record) => compactRecord({
+    ordinal: record.ordinal,
+    keyPropText: record.keyPropText,
+    keyExpressionText: record.keyExpressionText,
+    keyValue: record.keyValue,
+    keySourcePropName: record.keySourcePropName,
+    keyStatic: record.keyStatic
+  }));
+  return compactRecord({
+    proofStatus: 'static-render-return-keyed-list-evidence',
+    reasonCode: 'jsx-render-return-keyed-list-static-evidence',
+    claimScope: 'static-list-key-identity-only',
+    renderEquivalenceClaim: false,
+    runtimeEquivalenceClaim: false,
+    keyCount: keyRecords.length,
+    keyRecords,
+    keyValues: keyRecords.every((record) => record.keyValue !== undefined) ? keyRecords.map((record) => record.keyValue) : undefined,
+    signatureHash: hashSemanticValue({
+      kind: 'frontier.lang.projectJsxRenderReturnKeyedList',
+      collectionKind,
+      keyRecords,
+      claimScope: 'static-list-key-identity-only',
+      renderEquivalenceClaim: false,
+      runtimeEquivalenceClaim: false
+    })
+  });
+}
+
+export { jsxRenderReturnCollectionRecord };

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

@@ -1,12 +1,16 @@
 import { hashSemanticValue } from '@shapeshift-labs/frontier-lang-kernel';
-import { jsxRenderReturnCollectionRecord } from './projectSymbolGraphJsxRenderCollections.js';
+import { jsxRenderReturnCollectionRecord } from './projectSymbolGraphJsxRenderReturnCollections.js';
 
 function jsxRenderReturnRecords(sourceText) {
   const statements = returnStatements(sourceText);
   const implicitArrows = statements.length ? [] : implicitArrowReturnStatements(sourceText);
   return [...statements, ...implicitArrows]
-    .filter((statement) => isRenderableReturnExpression(statement.expressionText))
-    .map((statement, index) => renderReturnRecord(statement, index));
+    .map((statement) => ({
+      statement,
+      collectionRecord: jsxRenderReturnCollectionRecord(statement.expressionText, sourceText)
+    }))
+    .filter(({ statement, collectionRecord }) => collectionRecord || isRenderableReturnExpression(statement.expressionText))
+    .map(({ statement, collectionRecord }, index) => renderReturnRecord(statement, index, collectionRecord));
 }
 
 function jsxRenderReturnRiskEvidence(owner) {
@@ -18,6 +22,8 @@ function jsxRenderReturnRiskEvidence(owner) {
   const hasLogicalBranchEvidence = records.some((record) => record.logicalBranchRecord);
   const hasArrayCollectionEvidence = records.some((record) => record.collectionRecord?.collectionKind === 'array-literal');
   const hasFragmentCollectionEvidence = records.some((record) => String(record.collectionRecord?.collectionKind ?? '').startsWith('fragment-'));
+  const hasMapCollectionEvidence = records.some((record) => record.collectionRecord?.collectionKind === 'static-const-array-map');
+  const hasKeyedListEvidence = records.some((record) => record.collectionRecord?.keyedListRecord);
   const renderRiskKinds = ['render-return-boundary', branched ? 'render-return-branch-control-flow' : undefined].filter(Boolean);
   const hasImplicitArrow = records.some((record) => record.returnKind === 'implicit-arrow-expression');
   const renderRiskReasonCodes = [
@@ -27,6 +33,8 @@ function jsxRenderReturnRiskEvidence(owner) {
     hasLogicalBranchEvidence ? 'jsx-render-return-logical-branch-static-evidence' : undefined,
     hasArrayCollectionEvidence ? 'jsx-render-return-array-static-evidence' : undefined,
     hasFragmentCollectionEvidence ? 'jsx-render-return-fragment-static-evidence' : undefined,
+    hasMapCollectionEvidence ? 'jsx-render-return-static-const-array-map-evidence' : undefined,
+    hasKeyedListEvidence ? 'jsx-render-return-keyed-list-static-evidence' : undefined,
     branched ? 'jsx-render-return-branch-unsupported' : undefined
   ].filter(Boolean);
   const record = compactRecord({
@@ -80,12 +88,11 @@ function implicitArrowReturnStatements(sourceText) {
   return statements;
 }
 
-function renderReturnRecord(statement, index) {
+function renderReturnRecord(statement, index, collectionRecord) {
   const expressionText = normalizedText(statement.expressionText);
   const ifConditionText = normalizedText(statement.ifConditionText);
   const conditionalBranch = conditionalBranchRecord(expressionText);
   const logicalBranch = logicalBranchRecord(expressionText);
-  const collectionRecord = jsxRenderReturnCollectionRecord(expressionText);
   return compactRecord({
     ordinal: index + 1,
     proofStatus: 'static-render-return-evidence',