@shapeshift-labs/frontier-lang-compiler 0.2.162 → 0.2.164

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',

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

@@ -0,0 +1,196 @@
+import { isJsxSpreadAttribute } from '../../js-ts-safe-merge-jsx-attribute-parser.js';
+import { parseStaticObjectLiteralExpression } from './projectSymbolGraphJsxStaticLiterals.js';
+
+function jsxSpreadPropValueEvidence(tag, attribute, context = {}) {
+  const expressionText = jsxSpreadExpressionText(attribute);
+  const source = staticObjectSpreadSource(expressionText, attribute, context);
+  if (!source?.status) return dynamicSpreadPropValueEvidence(expressionText, source?.reasonCode);
+  const precedence = staticSpreadPrecedenceEvidence(tag, attribute, source.entries);
+  const propNames = uniqueStrings(source.entries.map((entry) => entry.propName));
+  return compactRecord({
+    proofStatus: 'static-object-spread-jsx-prop-value-evidence',
+    reasonCode: 'jsx-render-prop-spread-static-object-evidence',
+    valueKind: 'object-spread',
+    valueText: source.valueText,
+    expressionText,
+    staticSpreadSourceKind: source.sourceKind,
+    staticSpreadSourceName: source.sourceName,
+    staticSpreadPropEntries: source.entries,
+    staticSpreadPropNames: propNames,
+    staticSpreadPropCount: propNames.length,
+    staticSpreadEffectivePropEntries: precedence.effectiveEntries,
+    staticSpreadEffectivePropNames: uniqueStrings(precedence.effectiveEntries.map((entry) => entry.propName)),
+    staticSpreadExplicitOverridePropNames: precedence.explicitOverridePropNames,
+    staticSpreadOverridesExplicitPropNames: precedence.overridesExplicitPropNames,
+    staticSpreadDuplicatePropNames: duplicatePropNames(source.entries),
+    staticSpreadPrecedenceStatus: precedence.status,
+    claimScope: 'static-object-spread-props-only',
+    renderEquivalenceClaim: false
+  });
+}
+
+function dynamicSpreadPropValueEvidence(expressionText, reasonCode) {
+  return {
+    proofStatus: 'dynamic-jsx-prop-spread-unsupported',
+    reasonCode: 'jsx-render-prop-spread-unsupported',
+    valueKind: 'spread-expression',
+    expressionText,
+    dynamicText: expressionText,
+    dynamicBlockerReasonCode: reasonCode ?? jsxPropSpreadDynamicBlockerReasonCode(expressionText),
+    claimScope: 'static-object-spread-props-only',
+    renderEquivalenceClaim: false
+  };
+}
+
+function staticObjectSpreadSource(expressionText, attribute, context = {}) {
+  const text = normalizedText(expressionText);
+  if (!text) return { reasonCode: 'jsx-render-prop-spread-expression-unsupported' };
+  if (text.startsWith('{')) {
+    const parsed = parseStaticObjectLiteralExpression(text);
+    return parsed.value
+      ? { status: 'static', sourceKind: 'inline-object-literal', valueText: text, entries: parsed.value.entries }
+      : { reasonCode: parsed.reasonCode ?? jsxPropSpreadDynamicBlockerReasonCode(text) };
+  }
+  if (simpleIdentifierExpression(text)) {
+    const resolved = sameFileConstObjectSpreadSource(text, attribute, context);
+    return resolved.status ? resolved : { reasonCode: resolved.reasonCode ?? 'jsx-render-prop-spread-reference-unsupported' };
+  }
+  return { reasonCode: jsxPropSpreadDynamicBlockerReasonCode(text) };
+}
+
+function sameFileConstObjectSpreadSource(name, attribute, context = {}) {
+  const sourceText = String(context.sourceText ?? '');
+  if (!sourceText) return { reasonCode: 'jsx-render-prop-spread-reference-unsupported' };
+  const beforeOffset = Number.isFinite(attribute?.start) ? attribute.start : sourceText.length;
+  const declarations = constObjectInitializers(sourceText, name).filter((declaration) => declaration.start < beforeOffset);
+  if (declarations.length !== 1) return {
+    reasonCode: declarations.length > 1 ? 'jsx-render-prop-spread-ambiguous-const-object-unsupported' : 'jsx-render-prop-spread-reference-unsupported'
+  };
+  const parsed = parseStaticObjectLiteralExpression(declarations[0].initializerText);
+  return parsed.value
+    ? {
+      status: 'static',
+      sourceKind: 'same-file-const-object',
+      sourceName: name,
+      valueText: normalizedText(declarations[0].initializerText),
+      entries: parsed.value.entries
+    }
+    : { reasonCode: parsed.reasonCode ?? 'jsx-render-prop-spread-const-object-dynamic-unsupported' };
+}
+
+function constObjectInitializers(sourceText, name) {
+  const result = [];
+  const pattern = new RegExp(`\\bconst\\s+${escapeRegExp(name)}\\s*=\\s*`, 'g');
+  let match;
+  while ((match = pattern.exec(sourceText))) {
+    const start = match.index;
+    const initializerText = readConstInitializerText(sourceText, pattern.lastIndex);
+    if (initializerText) result.push({ start, initializerText });
+  }
+  return result;
+}
+
+function readConstInitializerText(sourceText, start) {
+  let quote;
+  let depth = 0;
+  for (let index = start; index < sourceText.length; index += 1) {
+    const char = sourceText[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 (depth === 0 && (char === ';' || char === '\n')) return sourceText.slice(start, index).trim();
+  }
+  return sourceText.slice(start).trim();
+}
+
+function staticSpreadPrecedenceEvidence(tag, attribute, entries) {
+  const index = attributeIndexInTag(tag, attribute);
+  const before = namedAttributesBefore(tag, index);
+  const after = namedAttributesAfter(tag, index);
+  const lastEntries = lastStaticEntriesByProp(entries);
+  const explicitOverridePropNames = uniqueStrings(lastEntries.filter((entry) => after.has(entry.propName)).map((entry) => entry.propName));
+  const overridesExplicitPropNames = uniqueStrings(lastEntries.filter((entry) => before.has(entry.propName)).map((entry) => entry.propName));
+  const effectiveEntries = lastEntries.filter((entry) => !after.has(entry.propName));
+  return {
+    effectiveEntries,
+    explicitOverridePropNames,
+    overridesExplicitPropNames,
+    status: staticSpreadPrecedenceStatus(explicitOverridePropNames, overridesExplicitPropNames, duplicatePropNames(entries))
+  };
+}
+
+function namedAttributesBefore(tag, index) {
+  return new Set((tag.attributes ?? []).slice(0, Math.max(0, index)).filter((candidate) => !isJsxSpreadAttribute(candidate)).map((candidate) => candidate.name));
+}
+
+function namedAttributesAfter(tag, index) {
+  return new Set((tag.attributes ?? []).slice(index + 1).filter((candidate) => !isJsxSpreadAttribute(candidate)).map((candidate) => candidate.name));
+}
+
+function staticSpreadPrecedenceStatus(explicitOverridePropNames, overridesExplicitPropNames, duplicateNames) {
+  if (explicitOverridePropNames.length && overridesExplicitPropNames.length) return 'static-spread-between-explicit-props';
+  if (explicitOverridePropNames.length) return 'static-spread-overridden-by-later-explicit-prop';
+  if (overridesExplicitPropNames.length) return 'static-spread-overrides-earlier-explicit-prop';
+  if (duplicateNames.length) return 'static-spread-duplicate-prop-last-write-wins';
+  return 'static-spread-props-preserved';
+}
+
+function attributeIndexInTag(tag, attribute) {
+  const attributes = tag.attributes ?? [];
+  const direct = attributes.indexOf(attribute);
+  if (direct >= 0) return direct;
+  return attributes.findIndex((candidate) => candidate.start === attribute?.start && candidate.end === attribute?.end && candidate.name === attribute?.name);
+}
+
+function lastStaticEntriesByProp(entries) {
+  const byProp = new Map();
+  for (const entry of entries) byProp.set(entry.propName, entry);
+  return [...byProp.values()].sort((left, right) => left.ordinal - right.ordinal);
+}
+
+function duplicatePropNames(entries) {
+  const counts = new Map();
+  for (const entry of entries) counts.set(entry.propName, (counts.get(entry.propName) ?? 0) + 1);
+  return [...counts.entries()].filter(([, count]) => count > 1).map(([name]) => name);
+}
+
+function jsxSpreadExpressionText(attribute) {
+  const expressionText = normalizedText(attribute?.expressionText);
+  if (expressionText) return expressionText;
+  const text = String(attribute?.text ?? '').trim();
+  const braced = /^\{\s*\.\.\.\s*([\s\S]*?)\s*\}$/.exec(text);
+  if (braced) return normalizedText(braced[1]);
+  const unbraced = /^\.\.\.\s*([\s\S]*)$/.exec(text);
+  return unbraced ? normalizedText(unbraced[1]) : undefined;
+}
+
+function jsxPropSpreadDynamicBlockerReasonCode(text) {
+  const value = normalizedText(text);
+  if (/\[[\s\S]*\]/.test(value)) return 'jsx-render-prop-spread-computed-reference-unsupported';
+  if (/^`[\s\S]*\$\{[\s\S]*`$/.test(value)) return 'jsx-render-prop-spread-template-interpolation-unsupported';
+  if (/\?\.\s*\(/.test(value) || /\b[A-Za-z_$][\w$]*(?:\s*(?:\.|\?\.)\s*[A-Za-z_$][\w$]*)*\s*\(/.test(value)) return 'jsx-render-prop-spread-call-expression-unsupported';
+  if (/^\{/.test(value)) return 'jsx-render-prop-spread-dynamic-object-unsupported';
+  if (staticPropReference(value)) return 'jsx-render-prop-spread-reference-unsupported';
+  return 'jsx-render-prop-spread-expression-unsupported';
+}
+
+function staticPropReference(text) {
+  const value = normalizedText(text);
+  if (!/^(?:this|[A-Za-z_$][\w$]*)(?:\s*\.\s*[A-Za-z_$][\w$]*)*$/.test(value)) return undefined;
+  const normalized = value.replace(/\s+/g, '');
+  const path = normalized.split('.');
+  return { text: normalized, root: path[0], path };
+}
+
+function simpleIdentifierExpression(text) { return /^[A-Za-z_$][\w$]*$/.test(String(text ?? '').trim()); }
+function escapeRegExp(text) { return String(text ?? '').replace(/[.*+?^${}()|[\]\\]/g, '\\$&'); }
+function uniqueStrings(values) { return [...new Set(values.filter((value) => typeof value === 'string' && value.length > 0))]; }
+function normalizedText(text) { return String(text ?? '').trim().replace(/\s+/g, ' '); }
+function compactRecord(record) { return Object.fromEntries(Object.entries(record).filter(([, value]) => value !== undefined)); }
+
+export { jsxSpreadPropValueEvidence };