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

package/dist/semantic-import-runtime-promise-combinator-evidence.js

@@ -0,0 +1,166 @@
+function promiseCombinatorEvidenceRecords(line, start, end) {
+  const text = String(line ?? '');
+  return promiseCombinatorCalls(text)
+    .filter((call) => start >= call.open && end <= call.close + 1)
+    .sort((left, right) => right.open - left.open)
+    .slice(0, 1)
+    .map((call) => promiseCombinatorRecord(text, call, start, end))
+    .filter(Boolean);
+}
+
+function promiseCombinatorContextReasonCodes(record) {
+  return uniqueStrings([
+    'runtime-order-promise-combinator-merge-requires-concurrency-evidence',
+    record?.arrayElementOrdinal ? 'runtime-order-promise-combinator-merge-requires-element-order-evidence' : undefined,
+    record?.methodName === 'all' ? 'runtime-order-promise-all-merge-requires-all-settlement-evidence' : undefined,
+    record?.methodName === 'allSettled' ? 'runtime-order-promise-all-settled-merge-requires-settlement-record-evidence' : undefined,
+    record?.methodName === 'race' ? 'runtime-order-promise-race-merge-requires-first-settlement-evidence' : undefined,
+    record?.methodName === 'any' ? 'runtime-order-promise-any-merge-requires-first-fulfillment-evidence' : undefined,
+    record?.runtimeEquivalenceClaim === false ? 'runtime-order-promise-combinator-runtime-equivalence-not-proven' : undefined
+  ]);
+}
+
+function promiseCombinatorCalls(text) {
+  const calls = [];
+  const state = scanState();
+  for (let index = 0; index < text.length; index += 1) {
+    const char = text[index], next = text[index + 1];
+    if (advanceIgnoredState(state, char, next)) { if (state.skipNext) { state.skipNext = false; index += 1; } continue; }
+    if (!wordAt(text, index, 'Promise')) continue;
+    const dot = skipSpaces(text, index + 'Promise'.length);
+    if (text[dot] !== '.') continue;
+    const methodStart = skipSpaces(text, dot + 1);
+    const methodName = promiseMethodNameAt(text, methodStart);
+    if (!methodName) continue;
+    const open = skipSpaces(text, methodStart + methodName.length);
+    if (text[open] !== '(') continue;
+    const close = matchingIndex(text, open, '(', ')');
+    if (close !== undefined) calls.push({ methodName, open, close, start: index });
+  }
+  return calls;
+}
+
+function promiseCombinatorRecord(text, call, start, end) {
+  const argument = segmentContaining(text, call.open + 1, call.close, start, end);
+  const array = arrayElementContaining(text, argument, start, end);
+  return compactRecord({
+    kind: 'promise-combinator',
+    methodName: call.methodName,
+    concurrencySemantics: promiseConcurrencySemantics(call.methodName),
+    settlementPolicy: promiseSettlementPolicy(call.methodName),
+    callText: normalizeOrderEvidenceText(text.slice(call.start, call.close + 1)),
+    argumentOrdinal: argument?.ordinal,
+    argumentText: argument ? normalizeOrderEvidenceText(text.slice(argument.start, argument.end)) : undefined,
+    directArrayArgument: array ? true : undefined,
+    arrayElementOrdinal: array?.ordinal,
+    arrayElementCount: array?.count,
+    arrayElementText: array?.text,
+    regionWithinCombinator: true,
+    runtimeEquivalenceClaim: false,
+    semanticEquivalenceClaim: false
+  });
+}
+
+function arrayElementContaining(text, argument, start, end) {
+  if (!argument) return undefined;
+  const arrayStart = skipSpaces(text, argument.start);
+  if (text[arrayStart] !== '[') return undefined;
+  const arrayEnd = matchingIndex(text, arrayStart, '[', ']');
+  if (arrayEnd === undefined || start < arrayStart || end > arrayEnd + 1) return undefined;
+  const segment = segmentContaining(text, arrayStart + 1, arrayEnd, start, end);
+  return segment && { ...segment, count: topLevelSegments(text, arrayStart + 1, arrayEnd).length, text: normalizeOrderEvidenceText(text.slice(segment.start, segment.end)) };
+}
+
+function segmentContaining(text, start, end, targetStart, targetEnd) {
+  return topLevelSegments(text, start, end)
+    .find((segment) => targetStart >= segment.start && targetEnd <= segment.end + 1);
+}
+
+function topLevelSegments(text, start, end) {
+  const segments = [];
+  const state = scanState();
+  let segmentStart = start;
+  for (let index = start; index < end; index += 1) {
+    const char = text[index], next = text[index + 1];
+    if (advanceIgnoredState(state, char, next)) { if (state.skipNext) { state.skipNext = false; index += 1; } continue; }
+    if (char === '(') { state.parenDepth += 1; continue; }
+    if (char === ')') { state.parenDepth = Math.max(0, state.parenDepth - 1); continue; }
+    if (char === '[') { state.bracketDepth += 1; continue; }
+    if (char === ']') { state.bracketDepth = Math.max(0, state.bracketDepth - 1); continue; }
+    if (char === '{') { state.braceDepth += 1; continue; }
+    if (char === '}') { state.braceDepth = Math.max(0, state.braceDepth - 1); continue; }
+    if (char === ',' && !state.parenDepth && !state.bracketDepth && !state.braceDepth) {
+      segments.push({ start: skipSpaces(text, segmentStart), end: trimEnd(text, segmentStart, index), ordinal: segments.length + 1 });
+      segmentStart = index + 1;
+    }
+  }
+  segments.push({ start: skipSpaces(text, segmentStart), end: trimEnd(text, segmentStart, end), ordinal: segments.length + 1 });
+  return segments.filter((segment) => segment.start <= segment.end);
+}
+
+function matchingIndex(text, open, openChar, closeChar) {
+  const state = scanState();
+  let depth = 0;
+  for (let index = open; index < text.length; index += 1) {
+    const char = text[index], next = text[index + 1];
+    if (advanceIgnoredState(state, char, next)) { if (state.skipNext) { state.skipNext = false; index += 1; } continue; }
+    if (char === openChar) depth += 1;
+    else if (char === closeChar && --depth === 0) return index;
+  }
+  return undefined;
+}
+
+function advanceIgnoredState(state, char, next) {
+  if (state.lineComment) return true;
+  if (state.blockComment) { if (char === '*' && next === '/') { state.blockComment = false; state.skipNext = true; } return true; }
+  if (state.quote) {
+    if (state.escaped) state.escaped = false;
+    else if (char === '\\') state.escaped = true;
+    else if (char === state.quote) state.quote = undefined;
+    return true;
+  }
+  if (char === '/' && next === '/') { state.lineComment = true; return true; }
+  if (char === '/' && next === '*') { state.blockComment = true; state.skipNext = true; return true; }
+  if (char === '\'' || char === '"' || char === '`') { state.quote = char; return true; }
+  return false;
+}
+
+function promiseMethodNameAt(text, index) {
+  for (const name of ['allSettled', 'all', 'race', 'any']) {
+    if (wordAt(text, index, name)) return name;
+  }
+  return undefined;
+}
+
+function promiseConcurrencySemantics(methodName) {
+  return ({
+    all: 'concurrent-all-inputs',
+    allSettled: 'concurrent-all-settled-inputs',
+    race: 'concurrent-first-settled-input',
+    any: 'concurrent-first-fulfilled-input'
+  })[methodName];
+}
+
+function promiseSettlementPolicy(methodName) {
+  return ({
+    all: 'fulfill-array-or-first-reject',
+    allSettled: 'settled-record-array',
+    race: 'first-settled-wins',
+    any: 'first-fulfilled-or-aggregate-reject'
+  })[methodName];
+}
+
+function wordAt(text, index, word) {
+  return text.slice(index, index + word.length) === word
+    && !isIdentifierPart(text[index - 1]) && !isIdentifierPart(text[index + word.length]);
+}
+
+function skipSpaces(text, index) { let cursor = index; while (/\s/.test(text[cursor] ?? '')) cursor += 1; return cursor; }
+function trimEnd(text, start, end) { let cursor = end; while (cursor > start && /\s/.test(text[cursor - 1] ?? '')) cursor -= 1; return cursor; }
+function scanState() { return { parenDepth: 0, bracketDepth: 0, braceDepth: 0 }; }
+function normalizeOrderEvidenceText(value) { return String(value ?? '').replace(/\s+/g, ' ').trim(); }
+function isIdentifierPart(char) { return /[A-Za-z0-9_$]/.test(char ?? ''); }
+function uniqueStrings(values) { return [...new Set((values ?? []).filter(Boolean).map(String))]; }
+function compactRecord(record) { return Object.fromEntries(Object.entries(record).filter(([, value]) => value !== undefined && (!Array.isArray(value) || value.length > 0))); }
+
+export { promiseCombinatorContextReasonCodes, promiseCombinatorEvidenceRecords };

package/dist/semantic-import-runtime-reachability-evidence.js

@@ -0,0 +1,269 @@
+function reachabilityOrderEvidence(lines, lineNumber) {
+  if (!Array.isArray(lines) || lineNumber <= 1) return [];
+  const targetDepth = statementDepthBeforeLine(lines, lineNumber);
+  for (let index = lineNumber - 2; index >= 0; index -= 1) {
+    const line = lines[index] ?? '', depth = statementDepthBeforeLine(lines, index + 1);
+    if (depth < targetDepth) break;
+    if (depth > targetDepth || isIgnorableReachabilityLine(line)) continue;
+    if (sameDepthControlBoundary(line)) break;
+    const completion = unconditionalCompletionRecord(line, index + 1);
+    if (completion) return [compactRecord({ kind: 'same-block-unreachable-after-completion', status: 'unreachable', proofLevel: 'lexical-same-block-completion', targetLine: lineNumber, completionKind: completion.kind, completionLine: completion.line, completionText: completion.text, completionLabel: completion.label, staticReachabilityEvidence: true, fullPathReachabilityClaim: false, runtimeEquivalenceClaim: false, semanticEquivalenceClaim: false })];
+  }
+  const branch = exhaustiveIfElseCompletionRecord(lines, lineNumber, targetDepth);
+  if (branch) return [branch];
+  const switchCompletion = exhaustiveSwitchCompletionRecord(lines, lineNumber, targetDepth);
+  if (switchCompletion) return [switchCompletion];
+  const tryFinallyCompletion = tryFinallyCompletionRecord(lines, lineNumber, targetDepth);
+  if (tryFinallyCompletion) return [tryFinallyCompletion];
+  const nestedBlockCompletion = nestedBlockCompletionRecord(lines, lineNumber, targetDepth);
+  return nestedBlockCompletion ? [nestedBlockCompletion] : [];
+}
+
+const nestedPathCompletionMaxDepth = 2;
+
+function unconditionalCompletionRecord(line, lineNumber) {
+  let text = stripLineCommentOutsideStrings(line).trim();
+  if (!text || text.startsWith('/*') || text.startsWith('*')) return undefined;
+  while (/^[A-Za-z_$][\w$]*\s*:\s*/.test(text) && !/^(?:case|default)\b/.test(text)) text = text.replace(/^[A-Za-z_$][\w$]*\s*:\s*/, '').trim();
+  const match = /^(return|throw|break|continue)\b\s*([A-Za-z_$][\w$]*)?/.exec(text);
+  return match ? compactRecord({ kind: match[1], line: lineNumber, label: (match[1] === 'break' || match[1] === 'continue') ? match[2] : undefined, text: normalizeOrderEvidenceText(text.slice(0, statementEnd(text, 0))) }) : undefined;
+}
+
+function exhaustiveIfElseCompletionRecord(lines, lineNumber, targetDepth, remainingDepth = nestedPathCompletionMaxDepth) {
+  const closeElseLine = previousCodeLine(lines, lineNumber - 1);
+  if (!closeElseLine || statementDepthBeforeLine(lines, closeElseLine.lineNumber) !== targetDepth || !/^\s*}\s*$/.test(stripLineCommentOutsideStrings(closeElseLine.text))) return undefined;
+  const elseStart = findBranchStartLine(lines, closeElseLine.lineNumber - 1, targetDepth, 'else');
+  if (!elseStart) return undefined;
+  const branches = [{ start: elseStart, closeLine: closeElseLine.lineNumber }];
+  let previousCloseLine = previousBranchCloseLine(lines, elseStart, targetDepth);
+  while (previousCloseLine) {
+    const start = findBranchStartLine(lines, previousCloseLine - 1, targetDepth);
+    if (!start) return undefined;
+    branches.unshift({ start, closeLine: previousCloseLine });
+    if (start.branchKind === 'if') break;
+    previousCloseLine = previousBranchCloseLine(lines, start, targetDepth);
+  }
+  if (branches[0]?.start.branchKind !== 'if') return undefined;
+  const completions = branches.map((branch) => lastTopLevelCompletionInBlock(lines, branch.start.lineNumber + 1, branch.closeLine - 1, targetDepth + 1, remainingDepth));
+  if (completions.some((completion) => !completion)) return undefined;
+  const elseIfLines = branches.filter((branch) => branch.start.branchKind === 'else-if').map((branch) => branch.start.lineNumber);
+  const completionKinds = completions.map(completionKind);
+  const completionTexts = completions.map(completionText);
+  const boundedNestedPathEvidence = completions.some(completionUsesBoundedNestedPath);
+  return compactRecord({ kind: elseIfLines.length ? 'exhaustive-if-chain-unreachable-after-completion' : 'exhaustive-if-else-unreachable-after-completion', status: 'unreachable', proofLevel: boundedNestedPathEvidence ? (elseIfLines.length ? 'lexical-if-chain-bounded-nested-completion' : 'lexical-if-else-bounded-nested-completion') : (elseIfLines.length ? 'lexical-if-chain-completion' : 'lexical-if-else-completion'), targetLine: lineNumber, ifLine: branches[0].start.lineNumber, elseLine: elseStart.lineNumber, elseIfLines: elseIfLines.length ? elseIfLines : undefined, branchLineNumbers: branches.map((branch) => branch.start.lineNumber), completionKind: completionKinds.every((kind) => kind === completionKinds[0]) ? completionKinds[0] : 'mixed', completionText: completionTexts.join(' | '), branchCompletionKinds: completionKinds, branchCompletionTexts: completionTexts, branchCompletionProofLevels: boundedNestedPathEvidence ? completions.map(completionProofLevel) : undefined, boundedNestedPathEvidence: boundedNestedPathEvidence || undefined, staticReachabilityEvidence: true, fullPathReachabilityClaim: false, runtimeEquivalenceClaim: false, semanticEquivalenceClaim: false });
+}
+
+function findBranchStartLine(lines, startLineNumber, targetDepth, expectedKind) {
+  for (let lineNumber = startLineNumber; lineNumber >= 1; lineNumber -= 1) {
+    if (statementDepthBeforeLine(lines, lineNumber) < targetDepth) return undefined;
+    if (statementDepthBeforeLine(lines, lineNumber) !== targetDepth) continue;
+    const text = stripLineCommentOutsideStrings(lines[lineNumber - 1]).trim();
+    const branchKind = branchStartKind(text);
+    if (branchKind && (!expectedKind || branchKind === expectedKind)) return { lineNumber, text, branchKind };
+  }
+  return undefined;
+}
+
+function branchStartKind(text) { if (!/[{]\s*$/.test(text)) return undefined; if (/^if\b/.test(text)) return 'if'; if (/^}?\s*else\s+if\b/.test(text)) return 'else-if'; if (/^}?\s*else\b/.test(text)) return 'else'; return undefined; }
+
+function previousBranchCloseLine(lines, branchStart, targetDepth) {
+  if (/^\s*}/.test(stripLineCommentOutsideStrings(branchStart.text))) return branchStart.lineNumber;
+  const closeLine = previousCodeLine(lines, branchStart.lineNumber - 1);
+  return closeLine && statementDepthBeforeLine(lines, closeLine.lineNumber) === targetDepth && /^\s*}\s*$/.test(stripLineCommentOutsideStrings(closeLine.text)) ? closeLine.lineNumber : undefined;
+}
+
+function lastTopLevelCompletionInBlock(lines, startLineNumber, endLineNumber, depth, remainingDepth = nestedPathCompletionMaxDepth) {
+  const tail = previousCodeLineInRange(lines, startLineNumber, endLineNumber);
+  if (!tail || statementDepthBeforeLine(lines, tail.lineNumber) !== depth) return undefined;
+  const completion = unconditionalCompletionRecord(tail.text, tail.lineNumber);
+  if (completion) return completion;
+  return remainingDepth > 0 ? nestedTailCompletionRecord(lines, tail.lineNumber, depth, remainingDepth - 1) : undefined;
+}
+
+function nestedTailCompletionRecord(lines, closeLineNumber, targetDepth, remainingDepth) {
+  const closeLine = { lineNumber: closeLineNumber, text: lines[closeLineNumber - 1] };
+  if (!/^\s*}\s*$/.test(stripLineCommentOutsideStrings(closeLine.text))) return undefined;
+  return exhaustiveIfElseCompletionRecord(lines, closeLineNumber + 1, targetDepth, remainingDepth)
+    ?? exhaustiveSwitchCompletionRecord(lines, closeLineNumber + 1, targetDepth, remainingDepth)
+    ?? tryFinallyCompletionRecord(lines, closeLineNumber + 1, targetDepth, remainingDepth)
+    ?? nestedBlockCompletionRecord(lines, closeLineNumber + 1, targetDepth, remainingDepth);
+}
+
+function exhaustiveSwitchCompletionRecord(lines, lineNumber, targetDepth, remainingDepth = nestedPathCompletionMaxDepth) {
+  const closeLine = previousCodeLine(lines, lineNumber - 1);
+  if (!closeLine || statementDepthBeforeLine(lines, closeLine.lineNumber) !== targetDepth || !/^\s*}\s*$/.test(stripLineCommentOutsideStrings(closeLine.text))) return undefined;
+  const switchStart = findMatchingSwitchStartLine(lines, closeLine.lineNumber, targetDepth);
+  if (!switchStart) return undefined;
+
+  const labels = switchCaseLabels(lines, switchStart.lineNumber + 1, closeLine.lineNumber - 1, targetDepth + 1);
+  if (!labels.length || !labels.some((label) => label.kind === 'default')) return undefined;
+
+  const completions = labels.map((label, index) => {
+    const nextLine = labels[index + 1]?.lineNumber ?? closeLine.lineNumber;
+    return lastTopLevelCompletionInBlock(lines, label.lineNumber + 1, nextLine - 1, targetDepth + 1, remainingDepth);
+  });
+  if (completions.some((completion) => !completion || !completionKindsAllowed(completion, switchExitCompletionKinds))) return undefined;
+
+  const defaultLabel = labels.find((label) => label.kind === 'default');
+  const completionKinds = completions.map(completionKind);
+  const completionTexts = completions.map(completionText);
+  const boundedNestedPathEvidence = completions.some(completionUsesBoundedNestedPath);
+  return compactRecord({ kind: 'exhaustive-switch-unreachable-after-completion', status: 'unreachable', proofLevel: boundedNestedPathEvidence ? 'lexical-switch-default-bounded-nested-completion' : 'lexical-switch-default-completion', targetLine: lineNumber, switchLine: switchStart.lineNumber, defaultLine: defaultLabel?.lineNumber, labelLineNumbers: labels.map((label) => label.lineNumber), caseLines: labels.filter((label) => label.kind === 'case').map((label) => label.lineNumber), completionKind: completionKinds.every((kind) => kind === completionKinds[0]) ? completionKinds[0] : 'mixed', completionText: completionTexts.join(' | '), branchCompletionKinds: completionKinds, branchCompletionTexts: completionTexts, branchCompletionProofLevels: boundedNestedPathEvidence ? completions.map(completionProofLevel) : undefined, boundedNestedPathEvidence: boundedNestedPathEvidence || undefined, staticReachabilityEvidence: true, fullPathReachabilityClaim: false, runtimeEquivalenceClaim: false, semanticEquivalenceClaim: false });
+}
+
+const switchExitCompletionKinds = new Set(['return', 'throw']);
+
+function tryFinallyCompletionRecord(lines, lineNumber, targetDepth, remainingDepth = nestedPathCompletionMaxDepth) {
+  const closeLine = previousCodeLine(lines, lineNumber - 1);
+  if (!closeLine || statementDepthBeforeLine(lines, closeLine.lineNumber) !== targetDepth || !/^\s*}\s*$/.test(stripLineCommentOutsideStrings(closeLine.text))) return undefined;
+  const finallyStart = findFinallyStartLine(lines, closeLine.lineNumber - 1, targetDepth);
+  if (!finallyStart) return undefined;
+  const tryStart = findTryStartLineBeforeFinally(lines, finallyStart, targetDepth);
+  if (!tryStart) return undefined;
+
+  const completion = lastTopLevelCompletionInBlock(lines, finallyStart.lineNumber + 1, closeLine.lineNumber - 1, targetDepth + 1, remainingDepth);
+  if (!completion || !completionKindsAllowed(completion, tryFinallyExitCompletionKinds)) return undefined;
+  const boundedNestedPathEvidence = completionUsesBoundedNestedPath(completion);
+
+  return compactRecord({ kind: 'try-finally-unreachable-after-finalizer-completion', status: 'unreachable', proofLevel: boundedNestedPathEvidence ? 'lexical-try-finally-finalizer-bounded-nested-completion' : 'lexical-try-finally-finalizer-completion', targetLine: lineNumber, tryLine: tryStart.lineNumber, catchLines: tryStart.catchLines.length ? tryStart.catchLines : undefined, finallyLine: finallyStart.lineNumber, completionKind: completionKind(completion), completionLine: completionLine(completion), completionText: completionText(completion), completionProofLevel: boundedNestedPathEvidence ? completionProofLevel(completion) : undefined, boundedNestedPathEvidence: boundedNestedPathEvidence || undefined, staticReachabilityEvidence: true, fullPathReachabilityClaim: false, runtimeEquivalenceClaim: false, semanticEquivalenceClaim: false });
+}
+
+const tryFinallyExitCompletionKinds = new Set(['return', 'throw']);
+
+function nestedBlockCompletionRecord(lines, lineNumber, targetDepth, remainingDepth = nestedPathCompletionMaxDepth) {
+  const closeLine = previousCodeLine(lines, lineNumber - 1);
+  if (!closeLine || statementDepthBeforeLine(lines, closeLine.lineNumber) !== targetDepth || !/^\s*}\s*$/.test(stripLineCommentOutsideStrings(closeLine.text))) return undefined;
+  const blockStart = findPlainBlockStartLine(lines, closeLine.lineNumber, targetDepth);
+  if (!blockStart) return undefined;
+  const completion = lastTopLevelCompletionInBlock(lines, blockStart.lineNumber + 1, closeLine.lineNumber - 1, targetDepth + 1, remainingDepth);
+  if (!completion) return undefined;
+  return compactRecord({ kind: 'nested-block-unreachable-after-completion', status: 'unreachable', proofLevel: completionUsesBoundedNestedPath(completion) ? 'lexical-bounded-nested-block-nested-completion' : 'lexical-bounded-nested-block-completion', targetLine: lineNumber, blockLine: blockStart.lineNumber, completionKind: completionKind(completion), completionLine: completionLine(completion), completionText: completionText(completion), completionProofLevel: completionProofLevel(completion), boundedNestedPathEvidence: true, staticReachabilityEvidence: true, fullPathReachabilityClaim: false, runtimeEquivalenceClaim: false, semanticEquivalenceClaim: false });
+}
+
+function findFinallyStartLine(lines, startLineNumber, targetDepth) {
+  for (let lineNumber = startLineNumber; lineNumber >= 1; lineNumber -= 1) {
+    const depth = statementDepthBeforeLine(lines, lineNumber);
+    if (depth < targetDepth) return undefined;
+    if (depth !== targetDepth) continue;
+    const text = stripLineCommentOutsideStrings(lines[lineNumber - 1]).trim();
+    if (/^}?\s*finally\b.*[{]\s*$/.test(text)) return { lineNumber, text };
+    if (/[{]\s*$/.test(text)) return undefined;
+  }
+  return undefined;
+}
+
+function findTryStartLineBeforeFinally(lines, finallyStart, targetDepth) {
+  const catchLines = [];
+  for (let lineNumber = finallyStart.lineNumber - 1; lineNumber >= 1; lineNumber -= 1) {
+    const depth = statementDepthBeforeLine(lines, lineNumber);
+    if (depth < targetDepth) return undefined;
+    if (depth !== targetDepth) continue;
+    const text = stripLineCommentOutsideStrings(lines[lineNumber - 1]).trim();
+    if (/^try\b.*[{]\s*$/.test(text)) return { lineNumber, text, catchLines };
+    if (/^}?\s*catch\b.*[{]\s*$/.test(text)) {
+      catchLines.unshift(lineNumber);
+      continue;
+    }
+    if (/^\s*}\s*$/.test(text)) continue;
+    return undefined;
+  }
+  return undefined;
+}
+
+function findPlainBlockStartLine(lines, closeLineNumber, targetDepth) {
+  for (let lineNumber = closeLineNumber - 1; lineNumber >= 1; lineNumber -= 1) {
+    const depth = statementDepthBeforeLine(lines, lineNumber);
+    if (depth < targetDepth) return undefined;
+    if (depth !== targetDepth) continue;
+    const text = stripLineCommentOutsideStrings(lines[lineNumber - 1]).trim();
+    if (plainBlockStartLine(text)) return { lineNumber, text };
+    if (/[{]\s*$/.test(text)) return undefined;
+  }
+  return undefined;
+}
+
+function plainBlockStartLine(text) { return /^(?:[A-Za-z_$][\w$]*\s*:\s*)?\{\s*$/.test(text); }
+
+function findMatchingSwitchStartLine(lines, closeLineNumber, targetDepth) {
+  for (let lineNumber = closeLineNumber - 1; lineNumber >= 1; lineNumber -= 1) {
+    const depth = statementDepthBeforeLine(lines, lineNumber);
+    if (depth < targetDepth) break;
+    if (depth !== targetDepth) continue;
+    const text = stripLineCommentOutsideStrings(lines[lineNumber - 1]).trim();
+    if (/[{]\s*$/.test(text)) return /^switch\b/.test(text) ? { lineNumber, text } : undefined;
+  }
+  return undefined;
+}
+
+function switchCaseLabels(lines, startLineNumber, endLineNumber, depth) {
+  const labels = [];
+  for (let lineNumber = startLineNumber; lineNumber <= endLineNumber; lineNumber += 1) {
+    if (statementDepthBeforeLine(lines, lineNumber) !== depth) continue;
+    const text = stripLineCommentOutsideStrings(lines[lineNumber - 1]).trim();
+    const kind = switchCaseLabelKind(text);
+    if (kind) labels.push({ kind, lineNumber, text });
+  }
+  return labels;
+}
+
+function switchCaseLabelKind(text) { if (/^case\b.*:\s*$/.test(text)) return 'case'; if (/^default\s*:\s*$/.test(text)) return 'default'; return undefined; }
+
+function previousCodeLine(lines, lineNumber) { for (let index = lineNumber - 1; index >= 0; index -= 1) if (!isIgnorableReachabilityLine(lines[index])) return { lineNumber: index + 1, text: lines[index] }; return undefined; }
+
+function previousCodeLineInRange(lines, startLineNumber, endLineNumber) { for (let index = endLineNumber - 1; index >= startLineNumber - 1; index -= 1) if (!isIgnorableReachabilityLine(lines[index])) return { lineNumber: index + 1, text: lines[index] }; return undefined; }
+
+function completionKind(completion) { return completion?.completionKind ?? completion?.kind; }
+
+function completionLine(completion) { return completion?.completionLine ?? completion?.line; }
+
+function completionText(completion) { return completion?.completionText ?? completion?.text; }
+
+function completionProofLevel(completion) { return completion?.proofLevel ?? 'lexical-same-block-completion'; }
+
+function completionUsesBoundedNestedPath(completion) { return Boolean(completion) && (completion.boundedNestedPathEvidence === true || completion.line === undefined); }
+
+function completionKindsAllowed(completion, allowedKinds) { const kinds = completionExitKinds(completion); return kinds.length > 0 && kinds.every((kind) => allowedKinds.has(kind)); }
+
+function completionExitKinds(completion) {
+  const branchKinds = completion?.branchCompletionKinds;
+  if (Array.isArray(branchKinds) && branchKinds.length && branchKinds.every((kind) => kind !== 'mixed')) return branchKinds;
+  const kind = completionKind(completion);
+  return kind && kind !== 'mixed' ? [kind] : [];
+}
+
+function statementDepthBeforeLine(lines, lineNumber) {
+  let depth = 0;
+  for (let index = 0; index < lineNumber - 1; index += 1) depth = statementDepthAfterLine(lines[index], depth);
+  return Math.max(0, depth - leadingCloseBraceCount(lines[lineNumber - 1] ?? ''));
+}
+function statementDepthAfterLine(line, depth) { const leadingClose = leadingCloseBraceCount(line), adjusted = Math.max(0, depth - leadingClose); return Math.max(0, adjusted + openBraceCount(line) - Math.max(0, closeBraceCount(line) - leadingClose)); }
+function isIgnorableReachabilityLine(line) { const text = stripLineCommentOutsideStrings(line).trim(); return !text || text.startsWith('/*') || text.startsWith('*'); }
+function sameDepthControlBoundary(line) { const text = stripLineCommentOutsideStrings(line).trim(); return /^(?:case\b|default\s*:|catch\b|finally\b|else\b)/.test(text) || /^}\s*(?:else|catch|finally)\b/.test(text); }
+function stripLineCommentOutsideStrings(line) {
+  const text = String(line ?? '');
+  let quote, escaped = false;
+  for (let index = 0; index < text.length - 1; index += 1) {
+    const char = text[index], next = text[index + 1];
+    if (quote) { if (escaped) escaped = false; else if (char === '\\') escaped = true; else if (char === quote) quote = undefined; continue; }
+    if (char === '\'' || char === '"' || char === '`') { quote = char; continue; }
+    if (char === '/' && next === '/') return text.slice(0, index);
+  }
+  return text;
+}
+function leadingCloseBraceCount(line) { const match = String(line ?? '').match(/^\s*}+/); return match ? match[0].replace(/\s/g, '').length : 0; }
+function openBraceCount(line) { return countCharsOutsideStrings(line, '{'); }
+function closeBraceCount(line) { return countCharsOutsideStrings(line, '}'); }
+function countCharsOutsideStrings(line, target) {
+  let count = 0, quote, escaped = false;
+  for (const char of String(line ?? '')) {
+    if (quote) { if (escaped) escaped = false; else if (char === '\\') escaped = true; else if (char === quote) quote = undefined; continue; }
+    if (char === '\'' || char === '"' || char === '`') { quote = char; continue; }
+    if (char === target) count += 1;
+  }
+  return count;
+}
+function normalizeOrderEvidenceText(value) { return String(value ?? '').replace(/\s+/g, ' ').trim(); }
+function statementEnd(line, start) { const semicolon = String(line ?? '').indexOf(';', start); return semicolon === -1 ? String(line ?? '').length : semicolon + 1; }
+function compactRecord(record) { return Object.fromEntries(Object.entries(record).filter(([, value]) => value !== undefined && value !== '')); }
+
+export { reachabilityOrderEvidence };