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

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

@@ -0,0 +1,150 @@
+import { hashSemanticValue } from '@shapeshift-labs/frontier-lang-kernel';
+import { uniqueStrings } from '../../native-import-utils.js';
+
+const WRAPPER_CALL = /(?<![\w$.])((?:React\s*\.\s*)?(?:memo|forwardRef|observer|lazy))\s*(?:<[^(){};]*>)?\s*\(/g;
+
+function jsxComponentWrapperRecords(ownerSourceText, ownerName) {
+  const text = String(ownerSourceText ?? '');
+  const records = [];
+  for (const match of text.matchAll(WRAPPER_CALL)) {
+    const callStart = match.index;
+    if (braceDepthBefore(text, callStart) > 0) continue;
+    const calleeText = normalizedCalleeText(match[1]);
+    const wrapperName = calleeText.split('.').pop();
+    const afterCall = text.slice(callStart + match[0].length);
+    const argumentKind = wrapperArgumentKind(afterCall);
+    const innerComponentName = wrapperInnerComponentName(afterCall) ?? ownerName;
+    const lazyImportSpecifier = wrapperName === 'lazy' ? lazyImportSpecifierText(afterCall) : undefined;
+    const wrapperExpressionText = normalizedText(text.slice(callStart, callExpressionPreviewEnd(text, callStart)));
+    records.push(compactRecord({
+      ordinal: records.length + 1,
+      proofStatus: 'static-component-wrapper-evidence',
+      reasonCode: 'jsx-render-component-wrapper-static-evidence',
+      wrapperName,
+      wrapperCalleeText: calleeText,
+      wrapperExpressionText,
+      wrapperArgumentKind: argumentKind,
+      innerComponentName,
+      ownerName,
+      lazyImportFactory: Boolean(lazyImportSpecifier) || undefined,
+      lazyImportSpecifier,
+      lazyLoadEquivalenceClaim: wrapperName === 'lazy' ? false : undefined,
+      renderEquivalenceClaim: false,
+      runtimeEquivalenceClaim: false,
+      wrapperExpressionHash: hashSemanticValue({
+        kind: 'frontier.lang.projectJsxComponentWrapperExpression',
+        ownerName,
+        calleeText,
+        wrapperExpressionText
+      }),
+      signatureHash: hashSemanticValue({
+        kind: 'frontier.lang.projectJsxComponentWrapper',
+        ownerName,
+        ordinal: records.length + 1,
+        wrapperName,
+        calleeText,
+        argumentKind,
+        innerComponentName
+      })
+    }));
+  }
+  return records;
+}
+
+function jsxComponentWrapperRenderRiskEvidence(owner) {
+  const records = Array.isArray(owner?.componentWrapperRecords) ? owner.componentWrapperRecords : [];
+  if (!records.length) return {};
+  const componentWrapperNames = uniqueStrings(records.map((record) => record.wrapperName));
+  const componentWrapperCalleeTexts = uniqueStrings(records.map((record) => record.wrapperCalleeText));
+  const lazyBoundaryCount = records.filter((record) => record.wrapperName === 'lazy').length;
+  return compactRecord({
+    renderRiskKinds: ['component-wrapper-boundary'],
+    renderRiskReasonCodes: uniqueStrings(['jsx-render-component-wrapper-static-evidence', 'jsx-render-component-wrapper-render-equivalence-unproved', lazyBoundaryCount ? 'jsx-render-component-wrapper-lazy-boundary-evidence' : undefined, lazyBoundaryCount ? 'jsx-render-component-wrapper-lazy-runtime-equivalence-unproved' : undefined]),
+    componentWrapperNames,
+    componentWrapperCalleeTexts,
+    componentWrapperRecords: records,
+    componentWrapperCount: records.length,
+    componentWrapperLazyBoundaryCount: lazyBoundaryCount || undefined,
+    componentWrapperRenderEquivalenceClaim: false,
+    componentWrapperLazyLoadEquivalenceClaim: lazyBoundaryCount ? false : undefined,
+    componentWrapperSignatureHash: hashSemanticValue({
+      kind: 'frontier.lang.projectJsxComponentWrappers',
+      publicOwnerName: owner?.name,
+      records
+    })
+  });
+}
+
+function mergeJsxRenderRiskEvidence(primary = {}, secondary = {}, context = {}) {
+  if (!hasRenderRisk(secondary)) return primary;
+  const renderRiskKinds = uniqueStrings([...(primary.renderRiskKinds ?? []), ...(secondary.renderRiskKinds ?? [])]);
+  const renderRiskReasonCodes = uniqueStrings([...(primary.renderRiskReasonCodes ?? []), ...(secondary.renderRiskReasonCodes ?? [])]);
+  return compactRecord({
+    ...primary,
+    ...secondary,
+    renderRiskKinds,
+    renderRiskReasonCodes,
+    renderRiskSignatureHash: hashSemanticValue({
+      kind: 'frontier.lang.projectJsxRenderRiskSignature',
+      tagName: context.tagName,
+      tagKey: context.tagKey,
+      publicOwnerName: context.publicOwnerName,
+      baseRenderRiskSignatureHash: primary.renderRiskSignatureHash,
+      componentWrapperSignatureHash: secondary.componentWrapperSignatureHash,
+      renderRiskKinds,
+      renderRiskReasonCodes
+    })
+  });
+}
+
+function hasRenderRisk(record) { return Array.isArray(record?.renderRiskKinds) && record.renderRiskKinds.length > 0; }
+function normalizedCalleeText(text) { return String(text ?? '').replace(/\s+/g, '').replace('React.', 'React.'); }
+function normalizedText(text) { return String(text ?? '').trim().replace(/\s+/g, ' '); }
+function compactRecord(record) { return Object.fromEntries(Object.entries(record).filter(([, value]) => value !== undefined)); }
+
+function wrapperArgumentKind(text) {
+  const value = String(text ?? '').trim();
+  if (/^(?:async\s+)?function\b/.test(value)) return 'function-expression';
+  if (/^class\b/.test(value)) return 'class-expression';
+  if (lazyImportSpecifierText(value)) return 'lazy-import-factory';
+  if (/^(?:React\s*\.\s*)?(?:memo|forwardRef|observer|lazy)\s*(?:<[^(){};]*>)?\s*\(/.test(value)) return 'wrapper-call';
+  if (/^(?:async\s*)?(?:\([^)]*\)|[A-Za-z_$][\w$]*)\s*=>/.test(value)) return 'arrow-function';
+  if (/^[A-Za-z_$][\w$]*(?:\s*\.\s*[A-Za-z_$][\w$]*)*/.test(value)) return 'reference';
+  return 'unknown';
+}
+
+function wrapperInnerComponentName(text) {
+  const preview = String(text ?? '').slice(0, 360);
+  return /\bfunction\s+([A-Za-z_$][\w$]*)\b/.exec(preview)?.[1]
+    ?? /\bclass\s+([A-Za-z_$][\w$]*)\b/.exec(preview)?.[1];
+}
+
+function lazyImportSpecifierText(text) { return /^(?:async\s*)?(?:\([^)]*\)|[A-Za-z_$][\w$]*)\s*=>\s*import\s*\(\s*(['"])([^'"]+)\1\s*\)/.exec(String(text ?? '').trim().slice(0, 260))?.[2]; }
+
+function callExpressionPreviewEnd(text, start) {
+  const value = String(text ?? '');
+  const firstBody = value.indexOf('{', start);
+  const firstLine = value.indexOf('\n', start);
+  const candidates = [firstBody, firstLine, start + 180].filter((index) => index >= start);
+  return Math.min(...candidates, value.length);
+}
+
+function braceDepthBefore(text, offset) {
+  const value = String(text ?? '').slice(0, offset);
+  let depth = 0;
+  let quote;
+  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 === '{') depth += 1;
+    else if (char === '}') depth = Math.max(0, depth - 1);
+  }
+  return depth;
+}
+
+export { jsxComponentWrapperRecords, jsxComponentWrapperRenderRiskEvidence, mergeJsxRenderRiskEvidence };

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

@@ -0,0 +1,71 @@
+import { staticOptionalMemberReference } from './staticOptionalMemberReference.js';
+
+function jsxContextTargetClassification(expressionText) {
+  const text = normalizedContextTargetText(expressionText);
+  if (!text) return undefined;
+  const optionalReference = staticOptionalMemberReference(text);
+  if (optionalReference) return staticOptionalContextTarget(optionalReference);
+  const reference = staticContextTargetReference(text);
+  if (reference) return staticContextTarget(reference);
+  return dynamicContextTarget(text);
+}
+
+function staticOptionalContextTarget(reference) {
+  return {
+    proofStatus: 'static-optional-context-target-evidence',
+    reasonCode: 'jsx-render-context-consumer-target-static-optional-reference-evidence',
+    contextName: reference.text,
+    contextTargetKind: 'optional-reference',
+    contextTargetReferenceRoot: reference.root,
+    contextTargetReferencePath: reference.path,
+    contextTargetReferenceMemberPath: reference.memberPath,
+    optionalReference: true,
+    optionalReferenceSegments: reference.optionalSegments,
+    optionalReferenceSegmentIndexes: reference.optionalSegmentIndexes,
+    optionalNullishBoundaryCount: reference.optionalSegmentIndexes.length
+  };
+}
+
+function staticContextTarget(reference) {
+  return {
+    proofStatus: 'static-context-target-evidence',
+    reasonCode: 'jsx-render-context-consumer-target-static-evidence',
+    contextName: reference.text,
+    contextTargetKind: 'reference',
+    contextTargetReferenceRoot: reference.root,
+    contextTargetReferencePath: reference.path,
+    contextTargetReferenceMemberPath: reference.memberPath
+  };
+}
+
+function dynamicContextTarget(text) {
+  const dynamicTargetKind = dynamicContextTargetKind(text);
+  return {
+    proofStatus: 'dynamic-context-target-unsupported',
+    reasonCode: 'jsx-render-context-consumer-target-unsupported',
+    contextTargetKind: 'dynamic-expression',
+    dynamicTarget: true,
+    dynamicTargetKind,
+    dynamicBlockerReasonCode: `jsx-render-context-consumer-target-${dynamicTargetKind}-unsupported`
+  };
+}
+
+function staticContextTargetReference(text) {
+  const value = normalizedContextTargetText(text);
+  if (!/^(?:[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, memberPath: path.slice(1) };
+}
+
+function dynamicContextTargetKind(text) {
+  const value = normalizedContextTargetText(text);
+  if (/\[[\s\S]*\]/.test(value)) return 'computed-reference';
+  if (/\?\.\s*\(/.test(value) || /\b[A-Za-z_$][\w$]*(?:\s*(?:\.|\?\.)\s*[A-Za-z_$][\w$]*)*\s*\(/.test(value)) return 'call-expression';
+  if (/\?\./.test(value)) return 'optional-reference';
+  return 'dynamic-expression';
+}
+
+function normalizedContextTargetText(text) { return String(text ?? '').trim().replace(/\s+/g, ' '); }
+
+export { jsxContextTargetClassification };

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

@@ -0,0 +1,212 @@
+import { hashSemanticValue } from '@shapeshift-labs/frontier-lang-kernel';
+import { isJsxSpreadAttribute } from '../../js-ts-safe-merge-jsx-attribute-parser.js';
+import { staticOptionalMemberReference } from './staticOptionalMemberReference.js';
+
+function jsxContextProviderValueRecord(attributes = []) {
+  const attribute = attributes.find((candidate) => candidate.name === 'value' && !isJsxSpreadAttribute(candidate));
+  if (!attribute) return undefined;
+  const expressionText = normalizedJsxAttributeValueText(attribute.text);
+  const classification = jsxContextValueClassification(expressionText);
+  const referenceBindingHash = classification.referenceBinding ? hashSemanticValue({
+    kind: 'frontier.lang.projectJsxContextProviderValueReferenceBinding',
+    expressionText,
+    referenceText: classification.referenceBinding.text,
+    root: classification.referenceBinding.root,
+    memberPath: classification.referenceBinding.memberPath,
+    optionalReference: classification.referenceBinding.optionalReference,
+    optionalReferenceSegments: classification.referenceBinding.optionalSegments,
+    optionalReferenceSegmentIndexes: classification.referenceBinding.optionalSegmentIndexes
+  }) : undefined;
+  return compactRecord({
+    propName: 'value',
+    propKind: propKind(attribute),
+    proofStatus: classification.proofStatus,
+    reasonCode: classification.reasonCode,
+    literalValueKind: classification.literal?.kind,
+    literalValueText: classification.literal?.text,
+    staticValueKind: classification.staticValueKind,
+    staticValueText: classification.staticValueText,
+    staticReferenceRoot: classification.referenceBinding?.root,
+    staticReferencePath: classification.referenceBinding?.path,
+    staticReferenceMemberPath: classification.referenceBinding?.memberPath,
+    optionalReference: classification.referenceBinding?.optionalReference,
+    optionalReferenceSegments: classification.referenceBinding?.optionalSegments,
+    optionalReferenceSegmentIndexes: classification.referenceBinding?.optionalSegmentIndexes,
+    optionalNullishBoundaryCount: classification.referenceBinding?.optionalSegmentIndexes?.length,
+    referenceBindingStatus: classification.referenceBinding?.status,
+    referenceBindingScope: classification.referenceBinding?.scope,
+    referenceBindingHash,
+    dynamicValueKind: classification.dynamic?.kind,
+    dynamicValueText: classification.dynamic?.text,
+    dynamicBlockerReasonCode: classification.dynamic?.reasonCode,
+    expressionHash: hashSemanticValue({
+      kind: 'frontier.lang.projectJsxContextProviderValueExpression',
+      expressionText
+    }),
+    signatureHash: hashSemanticValue({
+      kind: 'frontier.lang.projectJsxContextProviderValue',
+      expressionText,
+      proofStatus: classification.proofStatus,
+      staticValueKind: classification.staticValueKind,
+      optionalNullishBoundaryCount: classification.referenceBinding?.optionalSegmentIndexes?.length,
+      referenceBindingHash,
+      dynamicValueKind: classification.dynamic?.kind,
+      dynamicBlockerReasonCode: classification.dynamic?.reasonCode
+    })
+  });
+}
+
+function jsxContextProviderValueReasonCode(record) {
+  if (record.reasonCode) return record.reasonCode;
+  if (record.proofStatus === 'literal-context-value-evidence') return 'jsx-render-context-provider-value-literal-evidence';
+  if (record.proofStatus === 'static-reference-context-value-evidence') return 'jsx-render-context-provider-value-static-reference-evidence';
+  if (record.proofStatus === 'static-optional-reference-context-value-evidence') return 'jsx-render-context-provider-value-static-optional-reference-evidence';
+  if (record.proofStatus === 'static-data-context-value-evidence') return 'jsx-render-context-provider-value-static-data-evidence';
+  return 'jsx-render-context-provider-value-unsupported';
+}
+
+function jsxContextValueClassification(expressionText) {
+  const literal = jsxLiteralContextValue(expressionText);
+  if (literal) {
+    return {
+      proofStatus: 'literal-context-value-evidence',
+      reasonCode: 'jsx-render-context-provider-value-literal-evidence',
+      literal
+    };
+  }
+  const expression = unwrapJsxExpression(expressionText);
+  const referenceBinding = staticReferenceBinding(expression);
+  if (referenceBinding) {
+    return {
+      proofStatus: 'static-reference-context-value-evidence',
+      reasonCode: 'jsx-render-context-provider-value-static-reference-evidence',
+      staticValueKind: 'reference',
+      staticValueText: referenceBinding.text,
+      referenceBinding
+    };
+  }
+  const optionalReferenceBinding = staticOptionalReferenceBinding(expression);
+  if (optionalReferenceBinding) {
+    return {
+      proofStatus: 'static-optional-reference-context-value-evidence',
+      reasonCode: 'jsx-render-context-provider-value-static-optional-reference-evidence',
+      staticValueKind: 'optional-reference',
+      staticValueText: optionalReferenceBinding.text,
+      referenceBinding: optionalReferenceBinding
+    };
+  }
+  const dataKind = staticDataExpressionKind(expression);
+  if (dataKind) {
+    return {
+      proofStatus: 'static-data-context-value-evidence',
+      reasonCode: 'jsx-render-context-provider-value-static-data-evidence',
+      staticValueKind: dataKind,
+      staticValueText: normalizedText(expression)
+    };
+  }
+  return {
+    proofStatus: 'dynamic-context-value-unsupported',
+    reasonCode: 'jsx-render-context-provider-value-unsupported',
+    dynamic: dynamicContextValueBlocker(expression)
+  };
+}
+
+function jsxLiteralContextValue(expressionText) {
+  const expression = unwrapJsxExpression(expressionText);
+  if (/^"(?:[^"\\]|\\.)*"$/.test(expression) || /^'(?:[^'\\]|\\.)*'$/.test(expression)) return { kind: 'string', text: expression };
+  if (/^(?:true|false)$/.test(expression)) return { kind: 'boolean', text: expression };
+  if (/^(?:null|undefined)$/.test(expression)) return { kind: expression, text: expression };
+  if (/^-?(?:0|[1-9]\d*)(?:\.\d+)?$/.test(expression)) return { kind: 'number', text: expression };
+  return undefined;
+}
+
+function staticDataExpressionKind(expressionText) {
+  const expression = normalizedText(expressionText);
+  const kind = expression.startsWith('{') && expression.endsWith('}') ? 'object' : expression.startsWith('[') && expression.endsWith(']') ? 'array' : undefined;
+  if (!kind || !balancedDelimiters(expression)) return undefined;
+  if (/[();=]|=>|\.\.\.|\b(?:await|yield|new|function|class|import|require)\b/.test(expression)) return undefined;
+  if (!/^[\s{}\[\],:."'A-Za-z0-9_$-]+$/.test(expression)) return undefined;
+  return kind;
+}
+
+function staticReferenceBinding(expressionText) {
+  const expression = normalizedText(expressionText);
+  if (!/^(?:this|[A-Za-z_$][\w$]*)(?:\s*\.\s*[A-Za-z_$][\w$]*)*$/.test(expression)) return undefined;
+  const text = expression.replace(/\s+/g, '');
+  const path = text.split('.');
+  const [root, ...memberPath] = path;
+  return {
+    text,
+    root,
+    path,
+    memberPath,
+    status: 'static-reference-binding-evidence',
+    scope: 'jsx-context-provider-value-reference'
+  };
+}
+
+function staticOptionalReferenceBinding(expressionText) {
+  const reference = staticOptionalMemberReference(expressionText);
+  return reference ? {
+    ...reference,
+    optionalReference: true,
+    status: 'static-optional-reference-binding-evidence',
+    scope: 'jsx-context-provider-value-optional-reference'
+  } : undefined;
+}
+
+function dynamicContextValueBlocker(expressionText) {
+  const text = normalizedText(expressionText);
+  if (!text) return dynamicBlocker('empty-expression', text);
+  if (/\.\.\./.test(text)) return dynamicBlocker('spread-data', text);
+  if (/\[[\s\S]*\]/.test(text)) return dynamicBlocker('computed-reference', text);
+  if (/(?:^|[^\w$])(?:await|yield|new|function|class|import|require)\b/.test(text)) return dynamicBlocker('runtime-expression', text);
+  if (/=>/.test(text)) return dynamicBlocker('function-expression', text);
+  if (/\?\.\s*\(/.test(text) || /\b[A-Za-z_$][\w$]*(?:\s*(?:\.|\?\.)\s*[A-Za-z_$][\w$]*)*\s*(?:<[^>]+>\s*)?\(/.test(text)) return dynamicBlocker('call-expression', text);
+  if (/\?\./.test(text)) return dynamicBlocker('optional-reference', text);
+  return dynamicBlocker('dynamic-expression', text);
+}
+
+function dynamicBlocker(kind, text) {
+  return {
+    kind,
+    text,
+    reasonCode: `jsx-render-context-provider-value-${kind}-unsupported`
+  };
+}
+
+function balancedDelimiters(text) {
+  const stack = [];
+  const pairs = { '{': '}', '[': ']' };
+  let quote;
+  for (let index = 0; 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 === "'") {
+      quote = char;
+    } else if (pairs[char]) {
+      stack.push(pairs[char]);
+    } else if ((char === '}' || char === ']') && stack.pop() !== char) {
+      return false;
+    }
+  }
+  return !quote && stack.length === 0;
+}
+
+function unwrapJsxExpression(text) {
+  const normalized = normalizedText(text);
+  return normalizedText(/^\{\s*([\s\S]*?)\s*\}$/.exec(normalized)?.[1] ?? normalized);
+}
+
+function normalizedJsxAttributeValueText(text) {
+  const match = /^[A-Za-z_$][\w$:-]*\s*=\s*([\s\S]*)$/.exec(String(text ?? '').trim());
+  return normalizedText(match?.[1] ?? '');
+}
+
+function normalizedText(text) { return String(text ?? '').trim().replace(/\s+/g, ' '); }
+function propKind(attribute) { return isJsxSpreadAttribute(attribute) ? 'spread' : 'named'; }
+function compactRecord(record) { return Object.fromEntries(Object.entries(record).filter(([, value]) => value !== undefined)); }
+
+export { jsxContextProviderValueReasonCode, jsxContextProviderValueRecord };

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

@@ -0,0 +1,172 @@
+import { hashSemanticValue } from '@shapeshift-labs/frontier-lang-kernel';
+import { isJsxSpreadAttribute } from '../../js-ts-safe-merge-jsx-attribute-parser.js';
+import { staticOptionalMemberReference } from './staticOptionalMemberReference.js';
+
+function jsxOwnerEventHandlerDeclarations(sourceText, ownerName) {
+  const records = [
+    ...functionHandlerDeclarations(sourceText, ownerName),
+    ...variableHandlerDeclarations(sourceText, ownerName)
+  ];
+  return records.length ? new Map(records.map((record) => [record.name, record])) : undefined;
+}
+
+function functionHandlerDeclarations(sourceText, ownerName) {
+  return [...String(sourceText ?? '').matchAll(/\bfunction\s+([A-Za-z_$][\w$]*)\s*\([^)]*\)\s*\{/g)]
+    .map((match) => handlerDeclarationRecord(sourceText, ownerName, match[1], 'function', match.index, balancedEnd(sourceText, match.index + match[0].lastIndexOf('{'), '{', '}')));
+}
+
+function variableHandlerDeclarations(sourceText, ownerName) {
+  return [...String(sourceText ?? '').matchAll(/\b(?:const|let|var)\s+([A-Za-z_$][\w$]*)\s*=\s*(?:async\s*)?(?:function\b|\([^)]*\)\s*=>|[A-Za-z_$][\w$]*\s*=>)/g)]
+    .map((match) => handlerDeclarationRecord(sourceText, ownerName, match[1], match[0].includes('function') ? 'function-expression' : 'arrow-function', match.index, statementEnd(sourceText, match.index)));
+}
+
+function handlerDeclarationRecord(sourceText, ownerName, name, declarationKind, start, end) {
+  const declarationText = normalizedDeclarationText(String(sourceText ?? '').slice(start, end ?? statementEnd(sourceText, start)));
+  return compactRecord({
+    name,
+    declarationKind,
+    ownerName,
+    declarationHash: hashSemanticValue({ kind: 'frontier.lang.projectJsxEventHandlerDeclaration', ownerName, name, declarationKind, declarationText })
+  });
+}
+
+function jsxEventHandlerProps(attributes = [], handlerDeclarations) {
+  const eventHandlers = attributes.filter(isJsxEventHandlerAttribute);
+  return eventHandlers.map((attribute, index) => jsxEventHandlerPropRecord(attribute, index + 1, handlerDeclarations));
+}
+
+function jsxEventHandlerPropRecord(attribute, ordinal, handlerDeclarations) {
+  const expressionText = normalizedJsxAttributeValueText(attribute.text);
+  const handlerReference = staticEventHandlerReference(expressionText);
+  const inlineHandlerText = handlerReference ? undefined : staticJsxInlineHandlerText(expressionText);
+  const handlerDeclaration = handlerReference?.plainReference ? handlerDeclarations?.get(handlerReference.text) : undefined;
+  const inlineHandlerExpressionHash = inlineHandlerText ? hashSemanticValue({
+    kind: 'frontier.lang.projectJsxInlineEventHandlerExpression',
+    propName: attribute.name,
+    inlineHandlerText
+  }) : undefined;
+  return compactRecord({
+    propName: attribute.name,
+    ordinal,
+    propKind: propKind(attribute),
+    proofStatus: handlerReference?.proofStatus ?? (inlineHandlerText ? 'static-inline-event-handler-evidence' : 'dynamic-event-handler-unsupported'),
+    reasonCode: handlerReference?.reasonCode,
+    handlerReferenceText: handlerReference?.text,
+    handlerReferenceRoot: handlerReference?.root,
+    handlerReferencePath: handlerReference?.path,
+    optionalReference: handlerReference?.optionalReference,
+    optionalReferenceSegments: handlerReference?.optionalSegments,
+    optionalReferenceSegmentIndexes: handlerReference?.optionalSegmentIndexes,
+    optionalNullishBoundaryCount: handlerReference?.optionalSegmentIndexes?.length,
+    handlerDeclarationKind: handlerDeclaration?.declarationKind,
+    handlerDeclarationName: handlerDeclaration?.name,
+    handlerDeclarationOwnerName: handlerDeclaration?.ownerName,
+    handlerDeclarationHash: handlerDeclaration?.declarationHash,
+    inlineHandlerText,
+    inlineHandlerExpressionHash,
+    dynamicExpressionText: handlerReference || inlineHandlerText ? undefined : expressionText,
+    dynamicExpressionKind: handlerReference || inlineHandlerText ? undefined : dynamicEventHandlerExpressionKind(expressionText),
+    dynamicBlockerReasonCode: handlerReference || inlineHandlerText ? undefined : dynamicEventHandlerBlockerReasonCode(expressionText),
+    expressionHash: hashSemanticValue({
+      kind: 'frontier.lang.projectJsxEventHandlerExpression',
+      propName: attribute.name,
+      expressionText
+    }),
+    signatureHash: hashSemanticValue({
+      kind: 'frontier.lang.projectJsxEventHandlerProp',
+      propName: attribute.name,
+      ordinal,
+      expressionText,
+      handlerReference,
+      handlerDeclarationHash: handlerDeclaration?.declarationHash,
+      inlineHandlerText,
+      dynamicBlockerReasonCode: handlerReference || inlineHandlerText ? undefined : dynamicEventHandlerBlockerReasonCode(expressionText)
+    })
+  });
+}
+
+function jsxEventHandlerReasonCodes(records = []) {
+  if (!records.length) return [];
+  const hasStaticReference = records.some((record) => record.proofStatus === 'static-event-handler-reference-evidence');
+  const hasOptionalReference = records.some((record) => record.proofStatus === 'static-optional-event-handler-reference-evidence');
+  const hasInline = records.some((record) => record.proofStatus === 'static-inline-event-handler-evidence');
+  const hasDynamic = records.some((record) => record.proofStatus === 'dynamic-event-handler-unsupported');
+  return [
+    hasStaticReference || hasOptionalReference || hasInline ? 'jsx-render-event-handler-prop-static-evidence' : undefined,
+    hasOptionalReference ? 'jsx-render-event-handler-prop-static-optional-reference-evidence' : undefined,
+    hasInline ? 'jsx-render-event-handler-prop-static-inline-evidence' : undefined,
+    records.some((record) => record.handlerDeclarationHash) ? 'jsx-render-event-handler-local-declaration-evidence' : undefined,
+    hasDynamic ? 'jsx-render-event-handler-prop-unsupported' : undefined
+  ];
+}
+
+function staticEventHandlerReference(expressionText) {
+  const text = normalizedText(expressionText);
+  const expression = normalizedText(/^\{\s*([\s\S]*?)\s*\}$/.exec(text)?.[1] ?? text);
+  const optionalReference = staticOptionalMemberReference(expression);
+  if (optionalReference) return {
+    ...optionalReference,
+    proofStatus: 'static-optional-event-handler-reference-evidence',
+    reasonCode: 'jsx-render-event-handler-prop-static-optional-reference-evidence',
+    optionalReference: true
+  };
+  if (!/^(?:this|[A-Za-z_$][\w$]*)(?:\s*\.\s*[A-Za-z_$][\w$]*)*$/.test(expression)) return undefined;
+  const normalized = expression.replace(/\s+/g, '');
+  const path = normalized.split('.');
+  return { text: normalized, root: path[0], path, proofStatus: 'static-event-handler-reference-evidence', plainReference: true };
+}
+
+function staticJsxInlineHandlerText(expressionText) {
+  const text = normalizedText(expressionText);
+  const expression = normalizedText(/^\{\s*([\s\S]*?)\s*\}$/.exec(text)?.[1] ?? text);
+  if (/^(?:async\s*)?(?:\([^)]*\)|[A-Za-z_$][\w$]*)\s*=>[\s\S]+$/.test(expression)) return expression;
+  if (/^(?:async\s+)?function(?:\s+[A-Za-z_$][\w$]*)?\s*\([^)]*\)\s*\{[\s\S]*\}$/.test(expression)) return expression;
+  return undefined;
+}
+
+function dynamicEventHandlerExpressionKind(expressionText) {
+  const expression = normalizedEventHandlerExpression(expressionText);
+  if (/\[[\s\S]*\]/.test(expression)) return 'computed-reference';
+  if (/\?\.\s*\(/.test(expression) || /\b[A-Za-z_$][\w$]*(?:\s*(?:\.|\?\.)\s*[A-Za-z_$][\w$]*)*\s*\(/.test(expression)) return 'call-expression';
+  if (/\?\./.test(expression)) return 'optional-reference';
+  return 'dynamic-expression';
+}
+
+function dynamicEventHandlerBlockerReasonCode(expressionText) {
+  return `jsx-render-event-handler-prop-${dynamicEventHandlerExpressionKind(expressionText)}-unsupported`;
+}
+
+function balancedEnd(text, openIndex, open, close) {
+  const value = String(text ?? '');
+  if (value[openIndex] !== open) return undefined;
+  let depth = 0;
+  for (let index = openIndex; index < value.length; index += 1) {
+    if (value[index] === open) depth += 1;
+    else if (value[index] === close && --depth === 0) return index + 1;
+  }
+  return undefined;
+}
+
+function statementEnd(text, start) {
+  const value = String(text ?? '');
+  const end = value.indexOf(';', start);
+  if (end !== -1) return end + 1;
+  const lineEnd = value.indexOf('\n', start);
+  return lineEnd === -1 ? value.length : lineEnd;
+}
+
+function normalizedDeclarationText(text) { return String(text ?? '').trim().replace(/\s+/g, ' '); }
+function normalizedJsxAttributeValueText(text) {
+  const match = /^[A-Za-z_$][\w$:-]*\s*=\s*([\s\S]*)$/.exec(String(text ?? '').trim());
+  return normalizedText(match?.[1] ?? '');
+}
+function normalizedEventHandlerExpression(text) {
+  const normalized = normalizedText(text);
+  return normalizedText(/^\{\s*([\s\S]*?)\s*\}$/.exec(normalized)?.[1] ?? normalized);
+}
+function normalizedText(text) { return String(text ?? '').trim().replace(/\s+/g, ' '); }
+function propKind(attribute) { return isJsxSpreadAttribute(attribute) ? 'spread' : 'named'; }
+function isJsxEventHandlerAttribute(attribute) { return !isJsxSpreadAttribute(attribute) && /^on[A-Z0-9]/.test(String(attribute?.name ?? '')); }
+function compactRecord(record) { return Object.fromEntries(Object.entries(record).filter(([, value]) => value !== undefined)); }
+
+export { jsxEventHandlerProps, jsxEventHandlerReasonCodes, jsxOwnerEventHandlerDeclarations };