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

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

@@ -0,0 +1,291 @@
+import { hashSemanticValue } from '@shapeshift-labs/frontier-lang-kernel';
+import { jsxRenderReturnCollectionRecord } from './projectSymbolGraphJsxRenderCollections.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));
+}
+
+function jsxRenderReturnRiskEvidence(owner) {
+  const records = Array.isArray(owner?.renderReturnRecords) ? owner.renderReturnRecords : [];
+  if (!records.length) return {};
+  const branchCount = records.filter((record) => record.branchControlKind !== 'return-statement' || record.ifConditionHash).length;
+  const branched = records.length > 1 || branchCount > 0;
+  const hasConditionalBranchEvidence = records.some((record) => record.conditionalBranchRecord);
+  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 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 = [
+    'jsx-render-return-static-evidence',
+    hasImplicitArrow ? 'jsx-render-return-implicit-arrow-static-evidence' : undefined,
+    hasConditionalBranchEvidence ? 'jsx-render-return-conditional-branch-static-evidence' : undefined,
+    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,
+    branched ? 'jsx-render-return-branch-unsupported' : undefined
+  ].filter(Boolean);
+  const record = compactRecord({
+    renderReturnRecords: records,
+    renderReturnCount: records.length,
+    renderReturnBranchCount: branchCount || undefined,
+    renderReturnSignatureHash: hashSemanticValue({
+      kind: 'frontier.lang.projectJsxRenderReturns',
+      publicOwnerName: owner?.name,
+      records
+    })
+  });
+  return { renderRiskKinds, renderRiskReasonCodes, record };
+}
+
+function returnStatements(sourceText) {
+  const text = String(sourceText ?? '');
+  const statements = [];
+  for (const match of text.matchAll(/\breturn\b/g)) {
+    const start = match.index;
+    const expressionStart = start + match[0].length;
+    const expressionEnd = statementEnd(text, expressionStart);
+    if (expressionEnd <= expressionStart) continue;
+    statements.push({
+      start,
+      end: expressionEnd,
+      expressionText: normalizedReturnExpression(text.slice(expressionStart, expressionEnd).replace(/;$/, '')),
+      returnKind: 'return-statement',
+      ifConditionText: nearestIfConditionText(text, start)
+    });
+  }
+  return statements;
+}
+
+function implicitArrowReturnStatements(sourceText) {
+  const text = String(sourceText ?? '');
+  const statements = [];
+  for (const match of text.matchAll(/=>/g)) {
+    if (braceDepthBefore(text, match.index) > 0) continue;
+    const expressionStart = skipWhitespace(text, match.index + match[0].length);
+    if (text[expressionStart] === '{') continue;
+    const expressionEnd = statementEnd(text, expressionStart);
+    if (expressionEnd <= expressionStart) continue;
+    statements.push({
+      start: match.index,
+      end: expressionEnd,
+      expressionText: normalizedReturnExpression(text.slice(expressionStart, expressionEnd).replace(/;$/, '')),
+      returnKind: 'implicit-arrow-expression'
+    });
+  }
+  return statements;
+}
+
+function renderReturnRecord(statement, index) {
+  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',
+    returnKind: statement.returnKind,
+    branchControlKind: branchControlKind(expressionText),
+    expressionText,
+    expressionHash: hashSemanticValue({ kind: 'frontier.lang.projectJsxRenderReturnExpression', expressionText }),
+    conditionalBranchRecord: conditionalBranch,
+    logicalBranchRecord: logicalBranch,
+    collectionRecord,
+    ifConditionText,
+    ifConditionHash: ifConditionText ? hashSemanticValue({ kind: 'frontier.lang.projectJsxRenderReturnIfCondition', ifConditionText }) : undefined,
+    signatureHash: hashSemanticValue({
+      kind: 'frontier.lang.projectJsxRenderReturn',
+      ordinal: index + 1,
+      returnKind: statement.returnKind,
+      branchControlKind: branchControlKind(expressionText),
+      expressionText,
+      conditionalBranch,
+      logicalBranch,
+      collectionRecord,
+      ifConditionText
+    })
+  });
+}
+
+function isRenderableReturnExpression(text) {
+  const value = normalizedText(text).replace(/^\(([\s\S]*)\)$/, '$1').trim();
+  if (/^(?:null|false|undefined)$/.test(value)) return true;
+  if (/^(?:<|\[?\s*<|React\s*\.\s*createElement\s*\()/.test(value)) return true;
+  return topLevelConditionalOperator(value) || /(?:^|\s)(?:&&|\|\|)\s*</.test(value) || /[?:]\s*(?:<|null|false|undefined)\b/.test(value);
+}
+
+function branchControlKind(expressionText) {
+  if (topLevelConditionalOperator(expressionText)) return 'conditional-expression';
+  if (topLevelLogicalOperator(expressionText)) return 'logical-expression';
+  return 'return-statement';
+}
+
+function nearestIfConditionText(text, returnIndex) {
+  const prefix = String(text ?? '').slice(Math.max(0, returnIndex - 180), returnIndex);
+  const match = /if\s*\(([\s\S]*?)\)\s*(?:\{\s*)?$/.exec(prefix);
+  return match ? match[1] : undefined;
+}
+
+function statementEnd(text, start) {
+  const value = String(text ?? '');
+  let quote;
+  let depth = 0;
+  let escaped = false;
+  for (let index = start; index < value.length; index += 1) {
+    const char = value[index];
+    if (quote) {
+      if (escaped) escaped = false;
+      else if (char === '\\') escaped = true;
+      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) return index + 1;
+  }
+  return value.length;
+}
+
+function topLevelConditionalOperator(text) {
+  return topLevelOperator(text, '?');
+}
+function topLevelLogicalOperator(text) {
+  return topLevelOperator(text, '&&') || topLevelOperator(text, '||');
+}
+function topLevelOperator(text, operator) {
+  const value = String(text ?? '');
+  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 (depth === 0 && value.slice(index, index + operator.length) === operator) return true;
+  }
+  return false;
+}
+
+function conditionalBranchRecord(expressionText) {
+  const split = splitTopLevelConditional(expressionText);
+  if (!split) return undefined;
+  return compactRecord({
+    proofStatus: 'static-conditional-render-branch-evidence',
+    conditionText: split.conditionText,
+    consequentText: split.consequentText,
+    alternateText: split.alternateText,
+    conditionHash: hashSemanticValue({ kind: 'frontier.lang.projectJsxRenderConditionalCondition', text: split.conditionText }),
+    consequentHash: hashSemanticValue({ kind: 'frontier.lang.projectJsxRenderConditionalConsequent', text: split.consequentText }),
+    alternateHash: hashSemanticValue({ kind: 'frontier.lang.projectJsxRenderConditionalAlternate', text: split.alternateText }),
+    signatureHash: hashSemanticValue({ kind: 'frontier.lang.projectJsxRenderConditionalBranch', ...split })
+  });
+}
+
+function logicalBranchRecord(expressionText) {
+  const split = splitTopLevelLogical(expressionText);
+  if (!split) return undefined;
+  return compactRecord({
+    proofStatus: 'static-logical-render-branch-evidence',
+    operator: split.operator,
+    leftText: split.leftText,
+    rightText: split.rightText,
+    leftHash: hashSemanticValue({ kind: 'frontier.lang.projectJsxRenderLogicalLeft', text: split.leftText }),
+    rightHash: hashSemanticValue({ kind: 'frontier.lang.projectJsxRenderLogicalRight', text: split.rightText }),
+    signatureHash: hashSemanticValue({ kind: 'frontier.lang.projectJsxRenderLogicalBranch', ...split })
+  });
+}
+
+function splitTopLevelConditional(text) {
+  const value = String(text ?? '');
+  let quote;
+  let depth = 0;
+  let question = -1;
+  let nested = 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 (depth === 0 && char === '?') {
+      if (question < 0) question = index;
+      else nested += 1;
+    } else if (depth === 0 && char === ':' && question >= 0) {
+      if (nested > 0) nested -= 1;
+      else return {
+        conditionText: normalizedText(value.slice(0, question)),
+        consequentText: normalizedReturnExpression(value.slice(question + 1, index)),
+        alternateText: normalizedReturnExpression(value.slice(index + 1))
+      };
+    }
+  }
+  return undefined;
+}
+
+function splitTopLevelLogical(text) {
+  const value = String(text ?? '');
+  let quote;
+  let depth = 0;
+  for (let index = 0; index < value.length - 1; 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 (depth === 0 && (value.slice(index, index + 2) === '&&' || value.slice(index, index + 2) === '||')) {
+      return {
+        operator: value.slice(index, index + 2),
+        leftText: normalizedReturnExpression(value.slice(0, index)),
+        rightText: normalizedReturnExpression(value.slice(index + 2))
+      };
+    }
+  }
+  return undefined;
+}
+
+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)); }
+function skipWhitespace(text, start) { let index = start; while (/\s/.test(String(text ?? '')[index] ?? '')) index += 1; return index; }
+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 { jsxRenderReturnRecords, jsxRenderReturnRiskEvidence };

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

@@ -0,0 +1,279 @@
+import { hashSemanticValue } from '@shapeshift-labs/frontier-lang-kernel';
+import { uniqueStrings } from '../../native-import-utils.js';
+import { jsxContextProviderBoundary } from '../../js-ts-safe-merge-jsx-attribute-parser.js';
+import { jsxContextProviderValueReasonCode, jsxContextProviderValueRecord } from './projectSymbolGraphJsxContextValues.js';
+import { jsxEventHandlerReasonCodes } from './projectSymbolGraphJsxEventHandlers.js';
+import { jsxRenderReturnRiskEvidence } from './projectSymbolGraphJsxRenderReturns.js';
+function jsxRenderRiskEvidence(tag, owner, contextProviderAncestors = [], eventHandlerProps = [], componentContextConsumerRecords = []) {
+  const contextBoundary = jsxContextProviderBoundary(tag.tagName);
+  const contextValueRecord = contextBoundary ? jsxContextProviderValueRecord(tag.attributes) : undefined;
+  const contextProviderPath = contextProviderAncestors.map((provider) => provider.contextName).filter(Boolean);
+  const contextProviderAncestorTags = contextProviderAncestors.map((provider) => provider.tagName).filter(Boolean);
+  const contextProviderNestingSignatureHash = contextProviderPath.length ? hashSemanticValue({
+    kind: 'frontier.lang.projectJsxContextProviderNesting',
+    tagName: tag.tagName,
+    tagKey: tag.key,
+    publicOwnerName: owner?.name,
+    contextProviderPath,
+    contextProviderAncestorTags
+  }) : undefined;
+  const hookCalls = Array.isArray(owner?.hookCalls) ? owner.hookCalls : [];
+  const hookCallOrder = hookCalls.map((call) => call.name).filter(Boolean);
+  const hookNames = uniqueStrings(hookCallOrder.length ? hookCallOrder : owner?.hookNames ?? []);
+  const hookDependencyRecords = hookCalls.filter((call) => call?.dependencyArrayHash).map(hookDependencyRecord);
+  const hookEffectRecords = hookCalls.filter((call) => call?.effectCallbackHash).map(hookEffectRecord);
+  const contextConsumerRecords = [...hookCalls.filter((call) => call?.contextExpressionHash).map((call) => contextConsumerRecord(call, contextProviderAncestors)), ...componentContextConsumerRecords];
+  const contextConsumerNames = uniqueStrings(contextConsumerRecords.map((record) => record.contextName));
+  const hookCallOrderSignatureHash = hookCallOrder.length > 1 ? hashSemanticValue({
+    kind: 'frontier.lang.projectJsxHookCallOrder',
+    publicOwnerName: owner?.name,
+    hookCallOrder
+  }) : undefined;
+  const hookDependencySignatureHash = hookDependencyRecords.length ? hashSemanticValue({
+    kind: 'frontier.lang.projectJsxHookDependencyArrays',
+    publicOwnerName: owner?.name,
+    hookDependencyRecords
+  }) : undefined;
+  const hookEffectSignatureHash = hookEffectRecords.length ? hashSemanticValue({
+    kind: 'frontier.lang.projectJsxHookEffects',
+    publicOwnerName: owner?.name,
+    hookEffectRecords
+  }) : undefined;
+  const contextConsumerSignatureHash = contextConsumerRecords.length ? hashSemanticValue({
+    kind: 'frontier.lang.projectJsxContextConsumers',
+    publicOwnerName: owner?.name,
+    contextConsumerRecords
+  }) : undefined;
+  const contextConsumerReasonCodes = jsxContextConsumerReasonCodes(contextConsumerRecords);
+  const renderReturnRisk = jsxRenderReturnRiskEvidence(owner);
+  const eventHandlerSignatureHash = eventHandlerProps.length ? hashSemanticValue({
+    kind: 'frontier.lang.projectJsxEventHandlerProps',
+    tagName: tag.tagName,
+    tagKey: tag.key,
+    publicOwnerName: owner?.name,
+    eventHandlerProps
+  }) : undefined;
+  const renderRiskKinds = uniqueStrings([
+    contextBoundary ? 'context-provider-boundary' : undefined,
+    contextValueRecord ? 'context-provider-value-boundary' : undefined,
+    contextProviderNestingSignatureHash ? 'context-provider-nesting' : undefined,
+    hookNames.length ? 'hook-owner-render-scope' : undefined,
+    hookCallOrderSignatureHash ? 'hook-call-order-boundary' : undefined,
+    hookDependencySignatureHash ? 'hook-dependency-boundary' : undefined,
+    hookEffectSignatureHash ? 'hook-effect-boundary' : undefined,
+    contextConsumerSignatureHash ? 'context-consumer-boundary' : undefined,
+    ...(renderReturnRisk.renderRiskKinds ?? []),
+    eventHandlerSignatureHash ? 'event-handler-prop-boundary' : undefined
+  ]);
+  if (!renderRiskKinds.length) return {};
+  const renderRiskReasonCodes = uniqueStrings([
+    contextBoundary ? 'jsx-render-context-provider-boundary' : undefined,
+    contextValueRecord ? jsxContextProviderValueReasonCode(contextValueRecord) : undefined,
+    contextProviderNestingSignatureHash ? 'jsx-render-context-provider-nesting-unsupported' : undefined,
+    hookNames.length ? 'jsx-render-public-owner-hooks' : undefined,
+    hookCallOrderSignatureHash ? 'jsx-render-hook-call-order-unsupported' : undefined,
+    ...jsxHookDependencyReasonCodes(hookDependencyRecords),
+    ...jsxHookEffectReasonCodes(hookEffectRecords),
+    ...contextConsumerReasonCodes,
+    ...(renderReturnRisk.renderRiskReasonCodes ?? []),
+    ...jsxEventHandlerReasonCodes(eventHandlerProps)
+  ]);
+  return compactRecord({
+    renderRiskKinds,
+    renderRiskReasonCodes,
+    contextBoundaryKind: contextBoundary?.kind,
+    contextName: contextBoundary?.contextName,
+    contextValuePropName: contextValueRecord?.propName,
+    contextValueExpressionHash: contextValueRecord?.expressionHash,
+    contextValueSignatureHash: contextValueRecord?.signatureHash,
+    contextValueRecord,
+    contextProviderPath: contextProviderPath.length ? contextProviderPath : undefined,
+    contextProviderAncestorTags: contextProviderAncestorTags.length ? contextProviderAncestorTags : undefined,
+    contextProviderAncestorCount: contextProviderPath.length || undefined,
+    contextProviderNestingSignatureHash,
+    hookNames: hookNames.length ? hookNames : undefined,
+    hookCallOrder: hookCallOrder.length ? hookCallOrder : undefined,
+    hookCallCount: hookCallOrder.length || undefined,
+    hookCallOrderSignatureHash,
+    hookDependencyRecords: hookDependencyRecords.length ? hookDependencyRecords : undefined,
+    hookDependencyCount: hookDependencyRecords.length || undefined,
+    hookDependencySignatureHash,
+    hookEffectRecords: hookEffectRecords.length ? hookEffectRecords : undefined,
+    hookEffectCount: hookEffectRecords.length || undefined,
+    hookEffectSignatureHash,
+    contextConsumerNames: contextConsumerNames.length ? contextConsumerNames : undefined,
+    contextConsumerRecords: contextConsumerRecords.length ? contextConsumerRecords : undefined,
+    contextConsumerCount: contextConsumerRecords.length || undefined,
+    contextConsumerSignatureHash,
+    ...renderReturnRisk.record,
+    eventHandlerPropNames: eventHandlerProps.length ? uniqueStrings(eventHandlerProps.map((record) => record.propName)) : undefined,
+    eventHandlerPropRecords: eventHandlerProps.length ? eventHandlerProps : undefined,
+    eventHandlerPropCount: eventHandlerProps.length || undefined,
+    eventHandlerSignatureHash,
+    renderRiskSignatureHash: hashSemanticValue({
+      kind: 'frontier.lang.projectJsxRenderRiskSignature',
+      tagName: tag.tagName,
+      tagKey: tag.key,
+      publicOwnerName: owner?.name,
+      renderRiskKinds,
+      renderRiskReasonCodes,
+      contextBoundaryKind: contextBoundary?.kind,
+      contextName: contextBoundary?.contextName,
+      contextValueRecord,
+      contextProviderPath,
+      contextProviderAncestorTags,
+      contextProviderNestingSignatureHash,
+      hookNames,
+      hookCallOrder,
+      hookCallOrderSignatureHash,
+      hookDependencyRecords,
+      hookDependencySignatureHash,
+      hookEffectRecords,
+      hookEffectSignatureHash,
+      contextConsumerNames,
+      contextConsumerRecords,
+      contextConsumerSignatureHash,
+      renderReturnRisk: renderReturnRisk.record,
+      eventHandlerProps,
+      eventHandlerSignatureHash
+    })
+  });
+}
+function hookDependencyRecord(call) {
+  return compactRecord({
+    hookName: call.name,
+    ordinal: call.ordinal,
+    dependencyCount: call.dependencyCount,
+    dependencyTexts: call.dependencyTexts,
+    dependencyRecords: call.dependencyRecords,
+    proofStatus: call.dependencyProofStatus,
+    dynamicDependencyTexts: call.dynamicDependencyTexts,
+    dynamicDependencyReasonCodes: call.dynamicDependencyReasonCodes,
+    dependencyArrayHash: call.dependencyArrayHash,
+    dependencySignatureHash: call.dependencySignatureHash
+  });
+}
+function jsxHookDependencyReasonCodes(records = []) {
+  if (!records.length) return [];
+  const hasStatic = records.some((record) => record.proofStatus === 'static-dependency-array-evidence');
+  const hasDynamic = records.some((record) => record.proofStatus === 'dynamic-dependency-array-unsupported');
+  return [
+    hasStatic ? 'jsx-render-hook-dependency-array-static-evidence' : undefined,
+    hasDynamic ? 'jsx-render-hook-dependency-array-unsupported' : undefined
+  ];
+}
+function hookEffectRecord(call) {
+  return compactRecord({
+    hookName: call.name,
+    ordinal: call.ordinal,
+    proofStatus: call.effectProofStatus,
+    callbackKind: call.effectCallbackKind,
+    callbackText: call.effectCallbackText,
+    dynamicCallbackText: call.effectDynamicCallbackText,
+    callbackHash: call.effectCallbackHash,
+    callbackReferenceRoot: call.effectCallbackReferenceRoot,
+    callbackReferencePath: call.effectCallbackReferencePath,
+    callbackReferenceMemberPath: call.effectCallbackReferenceMemberPath,
+    callbackOptionalReference: call.effectCallbackOptionalReference,
+    callbackOptionalReferenceSegments: call.effectCallbackOptionalReferenceSegments,
+    callbackOptionalReferenceSegmentIndexes: call.effectCallbackOptionalReferenceSegmentIndexes,
+    callbackOptionalNullishBoundaryCount: call.effectCallbackOptionalNullishBoundaryCount,
+    dynamicCallbackKind: call.effectDynamicCallbackKind,
+    dynamicCallbackBlockerReasonCode: call.effectDynamicCallbackBlockerReasonCode,
+    cleanupProofStatus: call.effectCleanupProofStatus,
+    cleanupReturnKind: call.effectCleanupReturnKind,
+    cleanupReturnText: call.effectCleanupReturnText,
+    dynamicCleanupReturnText: call.effectDynamicCleanupReturnText,
+    cleanupReturnHash: call.effectCleanupReturnHash,
+    cleanupReturnReferenceRoot: call.effectCleanupReturnReferenceRoot,
+    cleanupReturnReferencePath: call.effectCleanupReturnReferencePath,
+    cleanupReturnReferenceMemberPath: call.effectCleanupReturnReferenceMemberPath,
+    cleanupReturnOptionalReference: call.effectCleanupReturnOptionalReference,
+    cleanupReturnOptionalReferenceSegments: call.effectCleanupReturnOptionalReferenceSegments,
+    cleanupReturnOptionalReferenceSegmentIndexes: call.effectCleanupReturnOptionalReferenceSegmentIndexes,
+    cleanupReturnOptionalNullishBoundaryCount: call.effectCleanupReturnOptionalNullishBoundaryCount,
+    dynamicCleanupReturnKind: call.effectDynamicCleanupReturnKind,
+    dynamicCleanupReturnBlockerReasonCode: call.effectDynamicCleanupReturnBlockerReasonCode,
+    cleanupReturnPresent: call.effectCleanupReturnPresent,
+    runtimeEquivalenceClaim: call.effectRuntimeEquivalenceClaim,
+    signatureHash: call.effectSignatureHash
+  });
+}
+function jsxHookEffectReasonCodes(records = []) {
+  if (!records.length) return [];
+  const hasStaticCallback = records.some((record) => record.proofStatus === 'static-effect-callback-source-evidence');
+  const hasStaticCleanup = records.some((record) => record.cleanupProofStatus === 'static-effect-cleanup-source-evidence');
+  const hasDynamic = records.some((record) => record.proofStatus === 'dynamic-effect-callback-unsupported' || record.cleanupProofStatus === 'dynamic-effect-cleanup-unsupported');
+  return [
+    hasStaticCallback ? 'jsx-render-hook-effect-static-callback-evidence' : undefined,
+    records.some((record) => record.callbackOptionalReference) ? 'jsx-render-hook-effect-static-optional-callback-evidence' : undefined,
+    hasStaticCleanup ? 'jsx-render-hook-effect-static-cleanup-evidence' : undefined,
+    records.some((record) => record.cleanupReturnOptionalReference) ? 'jsx-render-hook-effect-static-optional-cleanup-evidence' : undefined,
+    records.some((record) => record.runtimeEquivalenceClaim === false) ? 'jsx-render-hook-effect-runtime-equivalence-unproved' : undefined,
+    hasDynamic ? 'jsx-render-hook-effect-unsupported' : undefined,
+    ...records.map((record) => record.dynamicCallbackBlockerReasonCode),
+    ...records.map((record) => record.dynamicCleanupReturnBlockerReasonCode)
+  ];
+}
+function contextConsumerRecord(call, contextProviderAncestors = []) {
+  const proofStatus = call.contextConsumerProofStatus ?? (call.contextConsumerDynamicTarget
+    ? 'dynamic-context-target-unsupported'
+    : 'static-context-target-evidence');
+  const provider = nearestContextProvider(contextProviderAncestors, call.contextName);
+  const lookupHash = provider ? hashSemanticValue({
+    kind: 'frontier.lang.projectJsxContextProviderLookup',
+    contextName: call.contextName,
+    tagName: provider.tagName,
+    depth: provider.depth
+  }) : undefined;
+  const signatureHash = provider ? hashSemanticValue({
+    kind: 'frontier.lang.projectJsxContextConsumerWithProviderLookup',
+    baseSignatureHash: call.contextConsumerSignatureHash,
+    contextName: call.contextName,
+    provider
+  }) : call.contextConsumerSignatureHash;
+  return compactRecord({
+    hookName: call.name,
+    ordinal: call.ordinal,
+    contextName: call.contextName,
+    contextExpressionText: call.contextExpressionText,
+    contextExpressionHash: call.contextExpressionHash,
+    contextTargetKind: call.contextTargetKind,
+    contextTargetReasonCode: call.contextTargetReasonCode,
+    contextTargetReferenceRoot: call.contextTargetReferenceRoot,
+    contextTargetReferencePath: call.contextTargetReferencePath,
+    contextTargetReferenceMemberPath: call.contextTargetReferenceMemberPath,
+    optionalReference: call.contextTargetOptionalReference,
+    optionalReferenceSegments: call.contextTargetOptionalReferenceSegments,
+    optionalReferenceSegmentIndexes: call.contextTargetOptionalReferenceSegmentIndexes,
+    optionalNullishBoundaryCount: call.contextTargetOptionalNullishBoundaryCount,
+    contextProviderLookupStatus: provider ? 'static-provider-ancestor-evidence' : undefined,
+    contextProviderLookupName: provider?.contextName,
+    contextProviderLookupTagName: provider?.tagName,
+    contextProviderLookupDepth: provider?.depth,
+    contextProviderLookupHash: lookupHash,
+    signatureHash,
+    proofStatus,
+    dynamicTargetKind: call.contextTargetDynamicKind,
+    dynamicBlockerReasonCode: call.contextTargetDynamicBlockerReasonCode,
+    dynamicTarget: call.contextConsumerDynamicTarget
+  });
+}
+function nearestContextProvider(providers = [], contextName) {
+  if (!contextName) return undefined;
+  const index = providers.map((provider, depth) => ({ ...provider, depth: depth + 1 })).reverse()
+    .find((provider) => provider.contextName === contextName);
+  return index ? compactRecord(index) : undefined;
+}
+function jsxContextConsumerReasonCodes(records = []) {
+  if (!records.length) return [];
+  const hasStatic = records.some((record) => record.proofStatus === 'static-context-target-evidence'); const hasStaticOptional = records.some((record) => record.proofStatus === 'static-optional-context-target-evidence' || record.optionalReference); const hasDynamic = records.some((record) => record.dynamicTarget);
+  const hasProviderLookup = records.some((record) => record.contextProviderLookupStatus === 'static-provider-ancestor-evidence'); const hasComponentLookup = records.some((record) => record.contextProviderLookupStatus === 'static-same-file-component-provider-evidence');
+  const hasComponentFlow = records.some((record) => record.contextProviderLookupStatus === 'static-same-file-component-provider-flow-evidence');
+  const hasProjectComponentLookup = records.some((record) => record.contextProviderLookupStatus === 'static-project-import-component-provider-evidence');
+  const hasProjectComponentFlow = records.some((record) => record.contextProviderLookupStatus === 'static-project-import-component-provider-flow-evidence');
+  const hasUnsupportedComponentTarget = records.some((record) => record.componentCallLookupStatus === 'component-target-unsupported');
+  return uniqueStrings([hasStatic ? 'jsx-render-context-consumer-target-static-evidence' : undefined, hasStaticOptional ? 'jsx-render-context-consumer-target-static-optional-reference-evidence' : undefined, hasProviderLookup ? 'jsx-render-context-consumer-provider-lookup-static-evidence' : undefined, hasComponentLookup ? 'jsx-render-context-consumer-provider-component-lookup-static-evidence' : undefined, hasComponentFlow ? 'jsx-render-context-consumer-provider-component-flow-static-evidence' : undefined, hasProjectComponentLookup ? 'jsx-render-context-consumer-provider-project-component-lookup-static-evidence' : undefined, hasProjectComponentFlow ? 'jsx-render-context-consumer-provider-project-component-flow-static-evidence' : undefined, hasUnsupportedComponentTarget ? 'jsx-render-context-consumer-provider-component-target-unsupported' : undefined, hasDynamic ? 'jsx-render-context-consumer-target-unsupported' : undefined, hasDynamic ? 'jsx-render-context-consumer-dynamic-target-unsupported' : undefined, ...records.map((record) => record.dynamicBlockerReasonCode)]);
+}
+function compactRecord(record) { return Object.fromEntries(Object.entries(record).filter(([, value]) => value !== undefined)); }
+export { jsxRenderRiskEvidence };