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

package/dist/js-ts-safe-project-merge-jsx-graph-conflicts.js

@@ -0,0 +1,173 @@
+import { compactRecord } from './js-ts-safe-merge-context.js';
+import { jsxRenderReturnBranchProofAssessment } from './js-ts-safe-project-merge-jsx-render-branch-proof.js';
+import {
+  hasRenderRisk,
+  jsxChildOrderDetails,
+  jsxChildOrderFingerprint,
+  jsxChildOrderIdentityKey,
+  jsxPropDetails,
+  jsxPropFingerprint,
+  jsxPropIdentityKey,
+  jsxPropLabel,
+  jsxRenderRiskDetails,
+  jsxRenderRiskFingerprint,
+  jsxRenderRiskIdentityKey,
+  jsxRenderRiskReasonCodes
+} from './js-ts-safe-project-merge-jsx-graph-conflict-details.js';
+function projectJsxPropDeltaConflicts(projectGraphDelta) {
+  const baseGraph = projectGraphDelta?.stages?.base?.projectSymbolGraph;
+  const workerGraph = projectGraphDelta?.stages?.worker?.projectSymbolGraph;
+  const headGraph = projectGraphDelta?.stages?.head?.projectSymbolGraph;
+  const outputGraph = projectGraphDelta?.stages?.output?.projectSymbolGraph;
+  if (!baseGraph || !workerGraph || !headGraph) return [];
+  const base = publicJsxProps(baseGraph.jsxPropRecords);
+  const worker = publicJsxProps(workerGraph.jsxPropRecords);
+  const head = publicJsxProps(headGraph.jsxPropRecords);
+  const output = publicJsxProps(outputGraph?.jsxPropRecords);
+  return uniqueStrings([...base.keys(), ...worker.keys(), ...head.keys()]).flatMap((identityKey) => {
+    const baseRecord = base.get(identityKey);
+    const workerRecord = worker.get(identityKey);
+    const headRecord = head.get(identityKey);
+    const fingerprints = [jsxPropFingerprint(baseRecord), jsxPropFingerprint(workerRecord), jsxPropFingerprint(headRecord)];
+    if (fingerprints[0] === fingerprints[1] || fingerprints[0] === fingerprints[2] || fingerprints[1] === fingerprints[2]) return [];
+    return [projectJsxPropDeltaConflict(identityKey, baseRecord, workerRecord, headRecord, output.get(identityKey))];
+  });
+}
+function projectJsxRenderRiskDeltaConflicts(projectGraphDelta, options = {}) {
+  const baseGraph = projectGraphDelta?.stages?.base?.projectSymbolGraph;
+  const workerGraph = projectGraphDelta?.stages?.worker?.projectSymbolGraph;
+  const headGraph = projectGraphDelta?.stages?.head?.projectSymbolGraph;
+  const outputGraph = projectGraphDelta?.stages?.output?.projectSymbolGraph;
+  if (!baseGraph || !workerGraph || !headGraph) return [];
+  const base = publicJsxRenderRisks(baseGraph.jsxElementRecords);
+  const worker = publicJsxRenderRisks(workerGraph.jsxElementRecords);
+  const head = publicJsxRenderRisks(headGraph.jsxElementRecords);
+  const output = publicJsxRenderRisks(outputGraph?.jsxElementRecords);
+  return uniqueStrings([...base.keys(), ...worker.keys(), ...head.keys()]).flatMap((identityKey) => {
+    const baseRecord = base.get(identityKey);
+    const workerRecord = worker.get(identityKey);
+    const headRecord = head.get(identityKey);
+    const fingerprints = [jsxRenderRiskFingerprint(baseRecord), jsxRenderRiskFingerprint(workerRecord), jsxRenderRiskFingerprint(headRecord)];
+    if (fingerprints[0] === fingerprints[1] || fingerprints[0] === fingerprints[2] || fingerprints[1] === fingerprints[2]) return [];
+    const branchProof = jsxRenderReturnBranchProofAssessment({ identityKey, baseRecord, workerRecord, headRecord, outputRecord: output.get(identityKey) }, options);
+    if (branchProof?.status === 'passed') return [];
+    return [projectJsxRenderRiskDeltaConflict(identityKey, baseRecord, workerRecord, headRecord, output.get(identityKey), branchProof)];
+  });
+}
+function projectJsxChildOrderDeltaConflicts(projectGraphDelta) {
+  const baseGraph = projectGraphDelta?.stages?.base?.projectSymbolGraph;
+  const workerGraph = projectGraphDelta?.stages?.worker?.projectSymbolGraph;
+  const headGraph = projectGraphDelta?.stages?.head?.projectSymbolGraph;
+  const outputGraph = projectGraphDelta?.stages?.output?.projectSymbolGraph;
+  if (!baseGraph || !workerGraph || !headGraph) return [];
+  const base = publicJsxChildOrders(baseGraph.jsxElementRecords);
+  const worker = publicJsxChildOrders(workerGraph.jsxElementRecords);
+  const head = publicJsxChildOrders(headGraph.jsxElementRecords);
+  const output = publicJsxChildOrders(outputGraph?.jsxElementRecords);
+  return uniqueStrings([...base.keys(), ...worker.keys(), ...head.keys()]).flatMap((identityKey) => {
+    const baseRecord = base.get(identityKey);
+    const workerRecord = worker.get(identityKey);
+    const headRecord = head.get(identityKey);
+    const fingerprints = [jsxChildOrderFingerprint(baseRecord), jsxChildOrderFingerprint(workerRecord), jsxChildOrderFingerprint(headRecord)];
+    if (fingerprints[0] === fingerprints[1] || fingerprints[0] === fingerprints[2] || fingerprints[1] === fingerprints[2]) return [];
+    return [projectJsxChildOrderDeltaConflict(identityKey, baseRecord, workerRecord, headRecord, output.get(identityKey))];
+  });
+}
+function projectJsxPropDeltaConflict(identityKey, baseRecord, workerRecord, headRecord, outputRecord) {
+  const sourcePath = workerRecord?.sourcePath ?? headRecord?.sourcePath ?? baseRecord?.sourcePath;
+  const label = jsxPropLabel(workerRecord ?? headRecord ?? baseRecord);
+  return {
+    code: 'project-jsx-public-prop-delta-conflict',
+    gateId: 'project-graph-delta',
+    message: `Worker and head both changed JSX public ${label} ${JSON.stringify(identityKey)} in incompatible ways.`,
+    sourcePath,
+    details: compactRecord({
+      reasonCode: 'project-jsx-public-prop-delta-conflict',
+      conflictKey: `project-graph-delta#jsx-prop#${identityKey}`,
+      identityKey,
+      sourcePath,
+      base: jsxPropDetails(baseRecord),
+      worker: jsxPropDetails(workerRecord),
+      head: jsxPropDetails(headRecord),
+      output: jsxPropDetails(outputRecord)
+    })
+  };
+}
+function projectJsxChildOrderDeltaConflict(identityKey, baseRecord, workerRecord, headRecord, outputRecord) {
+  const sourcePath = workerRecord?.sourcePath ?? headRecord?.sourcePath ?? baseRecord?.sourcePath;
+  return {
+    code: 'project-jsx-public-child-order-delta-conflict',
+    gateId: 'project-graph-delta',
+    message: `Worker and head both changed JSX keyed child order evidence ${JSON.stringify(identityKey)} in incompatible ways.`,
+    sourcePath,
+    details: compactRecord({
+      reasonCode: 'project-jsx-public-child-order-delta-conflict',
+      conflictKey: `project-graph-delta#jsx-child-order#${identityKey}`,
+      identityKey,
+      sourcePath,
+      base: jsxChildOrderDetails(baseRecord),
+      worker: jsxChildOrderDetails(workerRecord),
+      head: jsxChildOrderDetails(headRecord),
+      output: jsxChildOrderDetails(outputRecord)
+    })
+  };
+}
+function projectJsxRenderRiskDeltaConflict(identityKey, baseRecord, workerRecord, headRecord, outputRecord, branchProof) {
+  const sourcePath = workerRecord?.sourcePath ?? headRecord?.sourcePath ?? baseRecord?.sourcePath;
+  return {
+    code: 'project-jsx-public-render-risk-delta-conflict',
+    gateId: 'project-graph-delta',
+    message: `Worker and head both changed JSX public render-semantics evidence ${JSON.stringify(identityKey)} in incompatible ways.`,
+    sourcePath,
+    details: compactRecord({
+      reasonCode: 'project-jsx-public-render-risk-delta-conflict',
+      reasonCodes: uniqueStrings([...jsxRenderRiskReasonCodes(baseRecord, workerRecord, headRecord, outputRecord), ...(branchProof?.reasonCodes ?? [])]),
+      conflictKey: `project-graph-delta#jsx-render-risk#${identityKey}`,
+      identityKey,
+      sourcePath,
+      routeId: branchProof?.routeId,
+      routeLane: branchProof?.routeLane,
+      routeNext: branchProof?.routeNext,
+      base: jsxRenderRiskDetails(baseRecord),
+      worker: jsxRenderRiskDetails(workerRecord),
+      head: jsxRenderRiskDetails(headRecord),
+      output: jsxRenderRiskDetails(outputRecord),
+      jsxRenderReturnBranchProof: branchProof?.record,
+      autoMergeClaim: false,
+      semanticEquivalenceClaim: false,
+      runtimeEquivalenceClaim: false,
+      renderEquivalenceClaim: false
+    })
+  };
+}
+function publicJsxProps(records = []) {
+  const result = new Map();
+  for (const record of records) {
+    if (!record?.publicContract) continue;
+    const key = jsxPropIdentityKey(record);
+    if (key && !result.has(key)) result.set(key, record);
+  }
+  return result;
+}
+function publicJsxRenderRisks(records = []) {
+  const result = new Map();
+  for (const record of records ?? []) {
+    if (!record?.publicContract || !hasRenderRisk(record)) continue;
+    const key = jsxRenderRiskIdentityKey(record);
+    if (key && !result.has(key)) result.set(key, record);
+  }
+  return result;
+}
+function publicJsxChildOrders(records = []) {
+  const result = new Map();
+  for (const record of records ?? []) {
+    if (!record?.publicContract || !record?.keyPropValue) continue;
+    const key = jsxChildOrderIdentityKey(record);
+    if (key && !result.has(key)) result.set(key, record);
+  }
+  return result;
+}
+
+function uniqueStrings(values) { return [...new Set(values.filter((value) => typeof value === 'string' && value.length > 0))]; }
+
+export { projectJsxChildOrderDeltaConflicts, projectJsxPropDeltaConflicts, projectJsxRenderRiskDeltaConflicts };

package/dist/js-ts-safe-project-merge-jsx-prop-contracts.js

@@ -0,0 +1,86 @@
+import { compactRecord, uniqueStrings } from './js-ts-safe-merge-context.js';
+
+export function collectJsxComponentPropContractsFromFileResults(fileResults = []) {
+  const contracts = [];
+  for (const file of Array.isArray(fileResults) ? fileResults : []) {
+    const fallback = file.result?.metadata?.composed?.jsxAttributeFallback;
+    const candidates = fallback?.componentPropContracts ?? fallback?.jsxComponentPropContracts ?? [];
+    for (const candidate of Array.isArray(candidates) ? candidates : []) {
+      contracts.push({ ...candidate, sourcePath: candidate.sourcePath ?? file.sourcePath });
+    }
+  }
+  return contracts;
+}
+
+export function normalizeJsxComponentPropContracts(value) {
+  const values = Array.isArray(value) ? value : [];
+  return values.map((contract, index) => {
+    const attributes = uniqueStrings((Array.isArray(contract.attributes) ? contract.attributes : [])
+      .map((attribute) => String(attribute))
+      .filter(Boolean));
+    return compactRecord({
+      id: contract.id ?? `jsx_component_prop_contract_${index + 1}`,
+      sourcePath: stringOrUndefined(contract.sourcePath),
+      tagName: stringOrUndefined(contract.tagName),
+      tagKey: stringOrUndefined(contract.tagKey),
+      attributes: attributes.length ? attributes : undefined,
+      attributeCount: numberOrUndefined(contract.attributeCount) ?? attributes.length
+    });
+  });
+}
+
+export function matchingJsxComponentPropContracts(diagnostic, jsxComponentPropContracts) {
+  if (!jsxComponentPropContracts.length) return [];
+  const sourcePath = diagnostic.sourcePath;
+  if (!sourcePath) return jsxComponentPropContracts;
+  return jsxComponentPropContracts.filter((contract) => contract.sourcePath === sourcePath);
+}
+
+export function jsxComponentPropContractConflict(jsxComponentPropContracts) {
+  return {
+    code: 'jsx-component-prop-contract-evidence-unavailable',
+    gateId: 'jsx-component-prop-contract',
+    message: 'JSX component prop changes require TypeScript diagnostics or supplied diagnostics before project admission.',
+    sourcePath: jsxComponentPropContracts.length === 1 ? jsxComponentPropContracts[0].sourcePath : undefined,
+    details: {
+      required: true,
+      candidates: jsxComponentPropContracts
+    }
+  };
+}
+
+export function jsxComponentPropContractEvidence(id, status, diagnostics, conflicts, diagnosticSource, jsxComponentPropContracts) {
+  if (!jsxComponentPropContracts.length) return [];
+  return [{
+    id: `${id}_jsx_component_prop_contract_evidence`,
+    kind: 'js-ts-jsx-component-prop-contract-evidence',
+    status: status === 'passed' ? 'passed' : 'failed',
+    summary: status === 'passed'
+      ? `Validated ${jsxComponentPropContracts.length} JSX component prop contract candidate(s) with diagnostics evidence.`
+      : `Blocked JSX component prop contract candidate(s) on ${conflicts.length} diagnostic or evidence conflict(s).`,
+    metadata: {
+      candidates: jsxComponentPropContracts.length,
+      attributes: jsxComponentPropContracts.reduce((total, contract) => total + (contract.attributeCount ?? 0), 0),
+      diagnosticSource,
+      diagnostics: diagnostics.length,
+      conflicts: conflicts.length,
+      contracts: jsxComponentPropContracts
+    }
+  }];
+}
+
+export function jsxComponentPropContractSummary(jsxComponentPropContracts) {
+  return {
+    jsxComponentPropContractCandidates: jsxComponentPropContracts.length,
+    jsxComponentPropContractFiles: uniqueStrings(jsxComponentPropContracts.map((contract) => contract.sourcePath)).length,
+    jsxComponentPropContractAttributes: jsxComponentPropContracts.reduce((total, contract) => total + (contract.attributeCount ?? 0), 0)
+  };
+}
+
+function stringOrUndefined(value) {
+  return value === undefined || value === null ? undefined : String(value);
+}
+
+function numberOrUndefined(value) {
+  return Number.isFinite(value) ? value : undefined;
+}

package/dist/js-ts-safe-project-merge-jsx-render-branch-proof.js

@@ -0,0 +1,189 @@
+import { hashSemanticValue } from '@shapeshift-labs/frontier-lang-kernel';
+import { compactRecord } from './js-ts-safe-merge-context.js';
+
+const JsxRenderReturnBranchRoute = Object.freeze({
+  routeId: 'prove-jsx-render-return-branch-arm-preservation',
+  routeLane: 'jsx-static-render-return-branches',
+  routeNext: 'supply-jsx-render-return-branch-proof'
+});
+
+function jsxRenderReturnBranchProofAssessment(input, options = {}) {
+  const delta = jsxRenderReturnBranchDelta(input);
+  if (!delta) return undefined;
+  const proof = jsxRenderReturnBranchProofFor(delta, options);
+  const reasonCodes = [];
+  if (!proof) reasonCodes.push('jsx-render-return-branch-proof-missing');
+  else {
+    if (proof.status !== 'passed' && proof.status !== 'verified') reasonCodes.push('jsx-render-return-branch-proof-status-not-passed');
+    if (proof.schema !== 'frontier.lang.jsxRenderReturnBranchProof.v1' && proof.kind !== 'frontier.lang.jsxRenderReturnBranchProof') reasonCodes.push('jsx-render-return-branch-proof-schema-missing');
+    if (proof.sourcePath !== delta.sourcePath) reasonCodes.push('jsx-render-return-branch-proof-source-path-mismatch');
+    for (const stage of ['base', 'worker', 'head', 'output']) {
+      if (proof[`${stage}SourceHash`] !== delta[`${stage}SourceHash`]) reasonCodes.push('jsx-render-return-branch-proof-source-hash-mismatch');
+    }
+    if (proof.identityKey !== undefined && proof.identityKey !== delta.identityKey) reasonCodes.push('jsx-render-return-branch-proof-identity-mismatch');
+    if (proof.publicOwnerName !== delta.publicOwnerName || proof.tagName !== delta.tagName || proof.tagKey !== delta.tagKey) reasonCodes.push('jsx-render-return-branch-proof-identity-mismatch');
+    if (proof.returnOrdinal !== delta.returnOrdinal || proof.returnKind !== delta.returnKind || proof.branchControlKind !== delta.branchControlKind) reasonCodes.push('jsx-render-return-branch-proof-branch-kind-unsupported');
+    if (delta.nonRenderRiskPresent) reasonCodes.push('jsx-render-return-branch-proof-non-render-risk-present');
+    if (delta.branchCountUnsupported) reasonCodes.push('jsx-render-return-branch-proof-branch-count-unsupported');
+    reasonCodes.push(...branchReasonCodes(delta, proof));
+    if (proof.branchArmPreservationHash !== delta.branchArmPreservationHash) reasonCodes.push('jsx-render-return-branch-proof-output-signature-mismatch');
+    if (proof.autoMergeClaim !== false || proof.semanticEquivalenceClaim !== false || proof.runtimeEquivalenceClaim !== false
+      || proof.renderEquivalenceClaim !== false || proof.branchArmPreservationClaim !== true
+      || proof.claimScope !== 'static-render-return-branch-arm-preservation-only') {
+      reasonCodes.push('jsx-render-return-branch-proof-claim-flags-missing');
+    }
+  }
+  const status = proof && reasonCodes.length === 0 ? 'passed' : proof ? 'failed' : 'missing';
+  return {
+    status,
+    ...JsxRenderReturnBranchRoute,
+    reasonCodes: uniqueStrings(reasonCodes),
+    record: compactRecord({
+      schema: 'frontier.lang.jsxRenderReturnBranchProofAssessment.v1',
+      status,
+      proofStatus: proof?.status,
+      proofId: proof?.id,
+      proofHash: proof?.proofHash,
+      ...JsxRenderReturnBranchRoute,
+      reasonCodes: uniqueStrings(reasonCodes),
+      expected: delta,
+      autoMergeClaim: false,
+      semanticEquivalenceClaim: false,
+      runtimeEquivalenceClaim: false,
+      renderEquivalenceClaim: false,
+      branchArmPreservationClaim: status === 'passed'
+    })
+  };
+}
+
+function jsxRenderReturnBranchDelta({ identityKey, baseRecord, workerRecord, headRecord, outputRecord } = {}) {
+  const records = { base: baseRecord, worker: workerRecord, head: headRecord, output: outputRecord };
+  const branches = Object.fromEntries(Object.entries(records).map(([stage, record]) => [stage, singleBranch(record)]));
+  if (!Object.values(records).some((record) => hasBranchUnsupported(record))) return undefined;
+  const outputBranch = branches.output;
+  const branchControlKind = firstString(outputBranch?.branchControlKind, branches.worker?.branchControlKind, branches.head?.branchControlKind, branches.base?.branchControlKind);
+  if (branchControlKind !== 'conditional-expression' && branchControlKind !== 'logical-expression') return undefined;
+  const sourcePath = firstString(outputRecord?.sourcePath, workerRecord?.sourcePath, headRecord?.sourcePath, baseRecord?.sourcePath);
+  const delta = compactRecord({
+    schema: 'frontier.lang.jsxRenderReturnBranchDelta.v1',
+    identityKey,
+    sourcePath,
+    publicOwnerName: firstString(outputRecord?.publicOwnerName, workerRecord?.publicOwnerName, headRecord?.publicOwnerName, baseRecord?.publicOwnerName),
+    tagName: firstString(outputRecord?.tagName, workerRecord?.tagName, headRecord?.tagName, baseRecord?.tagName),
+    tagKey: firstString(outputRecord?.tagKey, workerRecord?.tagKey, headRecord?.tagKey, baseRecord?.tagKey),
+    baseSourceHash: baseRecord?.sourceHash,
+    workerSourceHash: workerRecord?.sourceHash,
+    headSourceHash: headRecord?.sourceHash,
+    outputSourceHash: outputRecord?.sourceHash,
+    returnOrdinal: outputBranch?.ordinal,
+    returnKind: outputBranch?.returnKind,
+    branchControlKind,
+    nonRenderRiskPresent: nonRenderRiskPresent(outputRecord ?? workerRecord ?? headRecord ?? baseRecord) || undefined,
+    branchCountUnsupported: Object.values(branches).some((branch) => !branch) || undefined,
+    base: branchSummary(branches.base),
+    worker: branchSummary(branches.worker),
+    head: branchSummary(branches.head),
+    output: branchSummary(branches.output)
+  });
+  return { ...delta, branchArmPreservationHash: jsxRenderReturnBranchProofHash(delta) };
+}
+
+function branchReasonCodes(delta, proof) {
+  if (delta.branchControlKind === 'conditional-expression') return conditionalBranchReasonCodes(delta, proof);
+  if (delta.branchControlKind === 'logical-expression') return logicalBranchReasonCodes(delta, proof);
+  return ['jsx-render-return-branch-proof-branch-kind-unsupported'];
+}
+
+function conditionalBranchReasonCodes(delta, proof) {
+  const reasons = [];
+  if (proof.conditionHash !== delta.base?.conditionHash || proof.outputConditionHash !== delta.output?.conditionHash) reasons.push('jsx-render-return-branch-proof-condition-hash-mismatch');
+  if (proof.consequentOrigin === undefined || proof.alternateOrigin === undefined) reasons.push('jsx-render-return-branch-proof-output-arm-origin-missing');
+  if (proof.outputConsequentHash !== delta.output?.consequentHash || proof.outputAlternateHash !== delta.output?.alternateHash) reasons.push('jsx-render-return-branch-proof-arm-hash-mismatch');
+  if (proof.consequentHash !== armHash(delta, proof.consequentOrigin, 'consequentHash')) reasons.push('jsx-render-return-branch-proof-arm-hash-mismatch');
+  if (proof.alternateHash !== armHash(delta, proof.alternateOrigin, 'alternateHash')) reasons.push('jsx-render-return-branch-proof-arm-hash-mismatch');
+  if (delta.output?.consequentHash !== armHash(delta, proof.consequentOrigin, 'consequentHash')) reasons.push('jsx-render-return-branch-proof-arm-hash-mismatch');
+  if (delta.output?.alternateHash !== armHash(delta, proof.alternateOrigin, 'alternateHash')) reasons.push('jsx-render-return-branch-proof-arm-hash-mismatch');
+  return reasons;
+}
+
+function logicalBranchReasonCodes(delta, proof) {
+  const reasons = [];
+  if (proof.operator !== delta.output?.operator) reasons.push('jsx-render-return-branch-proof-branch-kind-unsupported');
+  if (proof.leftOrigin === undefined || proof.rightOrigin === undefined) reasons.push('jsx-render-return-branch-proof-output-arm-origin-missing');
+  if (proof.outputLeftHash !== delta.output?.leftHash || proof.outputRightHash !== delta.output?.rightHash) reasons.push('jsx-render-return-branch-proof-arm-hash-mismatch');
+  if (proof.leftHash !== armHash(delta, proof.leftOrigin, 'leftHash')) reasons.push('jsx-render-return-branch-proof-logical-guard-hash-mismatch');
+  if (proof.rightHash !== armHash(delta, proof.rightOrigin, 'rightHash')) reasons.push('jsx-render-return-branch-proof-arm-hash-mismatch');
+  if (delta.output?.leftHash !== armHash(delta, proof.leftOrigin, 'leftHash')) reasons.push('jsx-render-return-branch-proof-logical-guard-hash-mismatch');
+  if (delta.output?.rightHash !== armHash(delta, proof.rightOrigin, 'rightHash')) reasons.push('jsx-render-return-branch-proof-arm-hash-mismatch');
+  return reasons;
+}
+
+function jsxRenderReturnBranchProofFor(delta, options = {}) {
+  return [
+    options.jsxRenderReturnBranchProof,
+    ...(Array.isArray(options.jsxRenderReturnBranchProofs) ? options.jsxRenderReturnBranchProofs : [])
+  ].filter(Boolean).find((proof) => proof.identityKey === delta.identityKey || (
+    proof.sourcePath === delta.sourcePath && proof.publicOwnerName === delta.publicOwnerName && proof.tagKey === delta.tagKey
+  ));
+}
+
+function jsxRenderReturnBranchProofHash(delta) {
+  return hashSemanticValue({
+    kind: 'frontier.lang.jsxRenderReturnBranchProof.expected.v1',
+    identityKey: delta.identityKey,
+    sourcePath: delta.sourcePath,
+    publicOwnerName: delta.publicOwnerName,
+    tagName: delta.tagName,
+    tagKey: delta.tagKey,
+    baseSourceHash: delta.baseSourceHash,
+    workerSourceHash: delta.workerSourceHash,
+    headSourceHash: delta.headSourceHash,
+    outputSourceHash: delta.outputSourceHash,
+    returnOrdinal: delta.returnOrdinal,
+    returnKind: delta.returnKind,
+    branchControlKind: delta.branchControlKind,
+    base: delta.base,
+    worker: delta.worker,
+    head: delta.head,
+    output: delta.output
+  });
+}
+
+function singleBranch(record) {
+  const returns = Array.isArray(record?.renderReturnRecords) ? record.renderReturnRecords : [];
+  if (returns.length !== 1) return undefined;
+  const item = returns[0];
+  const branch = item.conditionalBranchRecord ?? item.logicalBranchRecord;
+  return branch ? { ...item, ...branch } : undefined;
+}
+
+function branchSummary(branch) {
+  if (!branch) return undefined;
+  return compactRecord({
+    ordinal: branch.ordinal,
+    returnKind: branch.returnKind,
+    branchControlKind: branch.branchControlKind,
+    conditionHash: branch.conditionHash,
+    consequentHash: branch.consequentHash,
+    alternateHash: branch.alternateHash,
+    operator: branch.operator,
+    leftHash: branch.leftHash,
+    rightHash: branch.rightHash,
+    signatureHash: branch.signatureHash
+  });
+}
+
+function nonRenderRiskPresent(record) {
+  return (record?.renderRiskKinds ?? []).some((kind) => kind !== 'render-return-boundary' && kind !== 'render-return-branch-control-flow');
+}
+function hasBranchUnsupported(record) { return (record?.renderRiskReasonCodes ?? []).includes('jsx-render-return-branch-unsupported'); }
+function armHash(delta, origin, field) { return ['base', 'worker', 'head', 'output'].includes(origin) ? delta[origin]?.[field] : undefined; }
+function firstString(...values) { return values.find((value) => typeof value === 'string' && value.length > 0); }
+function uniqueStrings(values) { return [...new Set(values.filter((value) => typeof value === 'string' && value.length > 0))]; }
+
+export {
+  JsxRenderReturnBranchRoute,
+  jsxRenderReturnBranchDelta,
+  jsxRenderReturnBranchProofAssessment,
+  jsxRenderReturnBranchProofHash
+};