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

package/dist/semantic-import-runtime-resource-management-evidence.js

@@ -0,0 +1,293 @@
+import { hashSemanticValue } from '@shapeshift-labs/frontier-lang-kernel';
+import { caseSensitiveIdFragment, idFragment, uniqueRecordsById, uniqueStrings } from './native-import-utils.js';
+import { maskNonCode } from './js-ts-semantic-scope-use-def-scan.js';
+
+function resourceManagementRecordsForImport(imported, semanticIndex, options = {}) {
+  const declarations = resourceManagementDeclarationsForImport(imported, semanticIndex);
+  const records = declarations.map((declaration, index) => resourceManagementRegionRecord(imported, declaration, index, options));
+  return {
+    symbols: uniqueRecordsById(records.map((record) => record.symbol)),
+    ownershipRegions: uniqueRecordsById(records.map((record) => record.region))
+  };
+}
+
+function resourceManagementRuntimeRegionRecordsForImport(imported, semanticIndex, publicKeys = new Set()) {
+  const declarations = resourceManagementDeclarationsForImport(imported, semanticIndex);
+  const publicNames = new Set((semanticIndex?.symbols ?? []).filter((symbol) => symbol?.kind === 'export').map((symbol) => symbol.name));
+  return declarations.map((declaration, index) => {
+    const { region } = resourceManagementRegionRecord(imported, declaration, index);
+    const runtimeOrderEvidence = region.metadata.runtimeOrderEvidence;
+    const signatureHash = hashSemanticValue({
+      kind: 'frontier.lang.projectRuntimeRegionSignature',
+      regionKind: region.regionKind,
+      runtimeKind: 'resource-management',
+      runtimeOrderEvidence,
+      declarationText: declaration.declarationText,
+      initializerText: declaration.initializerText
+    });
+    return compactRecord({
+      id: `runtime_region_${idFragment(region.id)}_${idFragment(signatureHash)}`,
+      key: region.key,
+      regionKind: region.regionKind,
+      runtimeKind: 'resource-management',
+      runtimeKinds: declaration.runtimeKinds,
+      sourcePath: region.sourcePath,
+      sourceHash: region.sourceHash,
+      sourceSpan: region.sourceSpan,
+      precision: region.precision,
+      spanKind: region.metadata.spanKind,
+      symbolId: declaration.ownerId,
+      symbolName: declaration.ownerName,
+      symbolKind: declaration.ownerKind,
+      line: declaration.line,
+      ordinal: declaration.ordinal,
+      runtimeOrderEvidence,
+      signatureHash,
+      publicContract: publicKeys.has(runtimePublicKey(region.sourcePath, declaration.ownerName))
+        || publicNames.has(declaration.ownerName) || undefined,
+      factIds: [],
+      evidenceIds: [`resource-management:${declaration.id}`]
+    });
+  });
+}
+
+function resourceManagementDeclarationsForImport(imported, semanticIndex) {
+  const sourceText = nativeImportSourceText(imported);
+  if (typeof sourceText !== 'string' || !sourceText.includes('using')) return [];
+  const sourcePath = imported?.sourcePath ?? imported?.nativeSource?.sourcePath ?? imported?.nativeAst?.sourcePath;
+  const language = imported?.language ?? imported?.nativeSource?.language ?? imported?.nativeAst?.language;
+  const sourceHash = imported?.nativeSource?.sourceHash ?? imported?.nativeAst?.sourceHash ?? imported?.sourceHash;
+  const masked = maskNonCode(sourceText).code;
+  const lineStarts = lineStartsFor(sourceText);
+  const scopes = braceScopes(masked, lineStarts);
+  const rawDeclarations = usingDeclarationMatches(sourceText, masked, lineStarts).map((match) => {
+    const scope = innermostScopeFor(scopes, match.start) ?? moduleScope(sourceText, lineStarts);
+    const owner = ownerSymbolFor(semanticIndex?.symbols ?? [], sourcePath, match.line);
+    return {
+      ...match,
+      id: `resource_${caseSensitiveIdFragment(`${sourcePath ?? 'memory'}:${match.start}:${match.end}:${match.name}`)}`,
+      kind: 'resource-management',
+      language,
+      sourcePath,
+      sourceHash,
+      ownerId: owner?.id,
+      ownerName: owner?.name ?? '(module)',
+      ownerKind: owner?.kind ?? 'module',
+      nativeAstNodeId: owner?.nativeAstNodeId,
+      scopeId: scope.id,
+      scopeStartLine: scope.startLine,
+      scopeExitLine: scope.endLine,
+      scopeStartColumn: scope.startColumn,
+      scopeExitColumn: scope.endColumn,
+      runtimeKinds: uniqueStrings(['resource-management', match.awaitUsing ? 'await-using' : 'using'])
+    };
+  });
+  return assignResourceOrder(rawDeclarations);
+}
+
+function resourceManagementRegionRecord(imported, declaration, index, options = {}) {
+  const key = [options.regionPrefix ?? 'source', declaration.sourcePath ?? 'memory', 'effect', `${declaration.ownerName}:resource-management:${declaration.name}#${declaration.ordinal}`].join('#');
+  const runtimeOrderEvidence = resourceManagementRuntimeOrderEvidence(declaration);
+  const signatureHash = hashSemanticValue({ kind: 'frontier.lang.resourceManagementRegionSignature', runtimeOrderEvidence });
+  const symbolName = `${declaration.ownerName}:effect:resource-management#${declaration.ordinal}`;
+  const region = {
+    id: `region_${caseSensitiveIdFragment(key)}`,
+    key,
+    regionKind: 'effect',
+    granularity: 'resource-management-declaration',
+    language: declaration.language,
+    sourcePath: declaration.sourcePath,
+    sourceHash: declaration.sourceHash,
+    symbolId: `symbol:${declaration.language ?? 'source'}:resource-management:${idFragment(key)}`,
+    symbolName,
+    symbolKind: 'effect',
+    nativeAstNodeId: declaration.nativeAstNodeId,
+    sourceSpan: sourceSpanForDeclaration(declaration, imported),
+    precision: 'line',
+    mergePolicy: 'effect-boundary-review-required',
+    metadata: {
+      semanticRegionTaxonomy: true,
+      factKinds: declaration.runtimeKinds,
+      factLine: declaration.line,
+      predicate: 'effect',
+      spanKind: 'resource-management-declaration',
+      runtimeOrderEvidence,
+      occurrenceOrdinal: declaration.ordinal,
+      subjectId: declaration.ownerId,
+      subjectName: declaration.ownerName,
+      resourceManagementDeclaration: compactRecord({
+        name: declaration.name,
+        awaitUsing: declaration.awaitUsing || undefined,
+        initializerText: declaration.initializerText,
+        declarationText: declaration.declarationText,
+        scopeExitLine: declaration.scopeExitLine
+      })
+    }
+  };
+  return {
+    region,
+    symbol: {
+      id: region.symbolId,
+      name: symbolName,
+      kind: 'effect',
+      language: declaration.language,
+      nativeAstNodeId: declaration.nativeAstNodeId,
+      sourceSpan: region.sourceSpan,
+      signatureHash,
+      ownershipRegionId: region.id,
+      ownershipKey: region.key,
+      ownershipRegionKind: 'effect',
+      readiness: 'needs-review'
+    }
+  };
+}
+
+function resourceManagementRuntimeOrderEvidence(declaration) {
+  return {
+    schema: 'frontier.lang.runtimeOrderEvidence.v1',
+    source: 'lexical-source-scan',
+    subjectId: declaration.ownerId,
+    regionKind: 'effect',
+    runtimeKinds: declaration.runtimeKinds,
+    line: declaration.line,
+    resourceManagementOrder: declaration.scopeDeclarations.map((item) => compactRecord({
+      kind: 'resource-management',
+      name: item.name,
+      declarationKind: item.awaitUsing ? 'await-using' : 'using',
+      awaitUsing: item.awaitUsing || undefined,
+      line: item.line,
+      column: item.column,
+      acquisitionOrderIndex: item.acquisitionOrderIndex,
+      disposalOrderIndex: item.disposalOrderIndex,
+      disposalOrder: 'reverse-lexical-scope',
+      scopeStartLine: item.scopeStartLine,
+      scopeExitLine: item.scopeExitLine,
+      declarationText: item.declarationText,
+      initializerText: item.initializerText,
+      focusedDeclaration: item.id === declaration.id || undefined,
+      disposalMethodPolicy: item.awaitUsing ? 'Symbol.asyncDispose-or-Symbol.dispose' : 'Symbol.dispose',
+      staticResourceManagementEvidence: true,
+      runtimeEquivalenceClaim: false,
+      disposalEffectEquivalenceClaim: false,
+      semanticEquivalenceClaim: false
+    }))
+  };
+}
+
+function usingDeclarationMatches(sourceText, masked, lineStarts) {
+  const pattern = /(^|[^\w$])(?:(await)\s+)?using\s+([A-Za-z_$][\w$]*)\s*(?::[^=;\n]+)?=\s*/g;
+  const records = [];
+  for (const match of masked.matchAll(pattern)) {
+    const start = match.index + match[1].length;
+    const initializerStart = match.index + match[0].length;
+    const end = statementEnd(masked, initializerStart);
+    const location = lineColumnAt(lineStarts, start);
+    records.push({
+      start,
+      end,
+      line: location.line,
+      column: location.column,
+      name: match[3],
+      awaitUsing: Boolean(match[2]),
+      declarationText: normalizeText(sourceText.slice(start, end)),
+      initializerText: normalizeText(sourceText.slice(initializerStart, end).replace(/;\s*$/, ''))
+    });
+  }
+  return records;
+}
+
+function assignResourceOrder(declarations) {
+  const byScope = new Map();
+  for (const declaration of declarations) {
+    const group = byScope.get(declaration.scopeId) ?? [];
+    group.push(declaration);
+    byScope.set(declaration.scopeId, group);
+  }
+  for (const group of byScope.values()) {
+    group.sort((left, right) => left.start - right.start);
+    group.forEach((declaration, index) => {
+      declaration.acquisitionOrderIndex = index + 1;
+      declaration.disposalOrderIndex = group.length - index;
+      declaration.ordinal = index + 1;
+      declaration.scopeDeclarations = group;
+    });
+  }
+  return declarations;
+}
+
+function ownerSymbolFor(symbols, sourcePath, line) {
+  return symbols
+    .filter((symbol) => symbol?.definitionSpan?.path === sourcePath || !sourcePath)
+    .filter((symbol) => symbol?.definitionSpan?.startLine <= line && symbol?.definitionSpan?.endLine >= line)
+    .filter((symbol) => symbol?.metadata?.ownershipRegionKind === 'body' || /function|method|constructor|class/.test(String(symbol.kind ?? '').toLowerCase()))
+    .sort((left, right) => spanSize(left.definitionSpan) - spanSize(right.definitionSpan))[0];
+}
+
+function braceScopes(masked, lineStarts) {
+  const scopes = [];
+  const stack = [];
+  for (let index = 0; index < masked.length; index += 1) {
+    const char = masked[index];
+    if (char === '{') {
+      const location = lineColumnAt(lineStarts, index);
+      stack.push({ start: index, startLine: location.line, startColumn: location.column });
+    } else if (char === '}' && stack.length) {
+      const open = stack.pop();
+      const location = lineColumnAt(lineStarts, index);
+      scopes.push({ ...open, end: index, endLine: location.line, endColumn: location.column, id: `scope:${open.start}:${index}` });
+    }
+  }
+  return scopes;
+}
+
+function innermostScopeFor(scopes, offset) {
+  return scopes
+    .filter((scope) => scope.start < offset && scope.end > offset)
+    .sort((left, right) => (left.end - left.start) - (right.end - right.start))[0];
+}
+
+function moduleScope(sourceText, lineStarts) {
+  return { id: 'scope:module', startLine: 1, startColumn: 1, endLine: lineStarts.length, endColumn: String(sourceText).length - lineStarts[lineStarts.length - 1] + 1 };
+}
+
+function sourceSpanForDeclaration(declaration, imported) {
+  return {
+    sourceId: declaration.sourceHash,
+    path: declaration.sourcePath ?? imported?.sourcePath ?? imported?.nativeSource?.sourcePath,
+    startLine: declaration.line,
+    endLine: declaration.line,
+    startColumn: declaration.column,
+    endColumn: declaration.column + Math.max(1, declaration.declarationText.length)
+  };
+}
+
+function lineStartsFor(sourceText) {
+  const starts = [0];
+  for (let index = 0; index < sourceText.length; index += 1) if (sourceText[index] === '\n') starts.push(index + 1);
+  return starts;
+}
+
+function lineColumnAt(lineStarts, offset) {
+  let lineIndex = 0;
+  while (lineIndex + 1 < lineStarts.length && lineStarts[lineIndex + 1] <= offset) lineIndex += 1;
+  return { line: lineIndex + 1, column: offset - lineStarts[lineIndex] + 1 };
+}
+
+function statementEnd(masked, start) {
+  for (let index = start, depth = 0; index < masked.length; index += 1) {
+    const char = masked[index];
+    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;
+    else if ((char === '\n' || char === '\r') && depth === 0) return index;
+  }
+  return masked.length;
+}
+
+function runtimePublicKey(sourcePath, symbolName) { return sourcePath && symbolName ? `${sourcePath}\0${symbolName}` : undefined; }
+function nativeImportSourceText(imported) { return imported?.metadata?.sourcePreservation?.sourceText ?? imported?.nativeSource?.metadata?.sourcePreservation?.sourceText ?? imported?.nativeAst?.metadata?.sourcePreservation?.sourceText ?? imported?.universalAst?.metadata?.sourcePreservation?.sourceText ?? imported?.sourceText; }
+function spanSize(span) { return Math.max(0, Number(span?.endLine ?? 0) - Number(span?.startLine ?? 0)); }
+function normalizeText(value) { return String(value ?? '').replace(/\s+/g, ' ').trim(); }
+function compactRecord(record) { return Object.fromEntries(Object.entries(record).filter(([, value]) => value !== undefined)); }
+
+export { resourceManagementRecordsForImport, resourceManagementRuntimeRegionRecordsForImport };

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

@@ -0,0 +1,304 @@
+function switchDispatchOrderEvidence(lines, lineNumber) {
+  if (!Array.isArray(lines) || !Number.isFinite(Number(lineNumber))) return [];
+  const stack = [];
+  let pendingSwitch;
+  let depth = 0;
+  for (let index = 0; index < lineNumber; index += 1) {
+    const line = String(lines[index] ?? '');
+    const leadingClose = leadingCloseBraceCount(line);
+    if (leadingClose) {
+      depth = Math.max(0, depth - leadingClose);
+      while (stack.length && stack[stack.length - 1].depth > depth) stack.pop();
+    }
+    const opens = openBraceCount(line);
+    const closes = closeBraceCount(line) - leadingClose;
+    const switchHead = switchHeadRecord(line);
+    if (switchHead) {
+      pendingSwitch = undefined;
+      if (opens > 0) stack.push(switchContext(switchHead, index + 1, depth + 1));
+      else pendingSwitch = switchContext(switchHead, index + 1, depth + 1);
+    } else if (pendingSwitch && opens > 0) {
+      stack.push({ ...pendingSwitch, depth: depth + 1 });
+      pendingSwitch = undefined;
+    }
+    const current = stack[stack.length - 1];
+    const caseHead = caseHeadRecord(line);
+    if (current && caseHead) {
+      current.caseOrdinal = (current.caseOrdinal ?? 0) + 1;
+      const previous = current.currentCase;
+      const previousCompletion = current.currentCaseCompletion;
+      current.currentCase = { ...caseHead, line: index + 1, ordinal: current.caseOrdinal, previousCase: previous, previousCaseCompletionKind: previousCompletion, fallthroughFromPrevious: Boolean(previous && !previousCompletion) };
+      current.currentCaseCompletion = undefined;
+    }
+    if (index + 1 === Number(lineNumber)) return switchDispatchRecord(current);
+    if (current?.currentCase) current.currentCaseCompletion = current.currentCaseCompletion ?? caseCompletionKind(line);
+    depth = Math.max(0, depth + opens - Math.max(0, closes));
+    while (stack.length && stack[stack.length - 1].depth > depth) stack.pop();
+  }
+  return [];
+}
+
+function loopIterationOrderEvidence(lines, lineNumber) {
+  if (!Array.isArray(lines) || !Number.isFinite(Number(lineNumber))) return [];
+  const stack = [];
+  let pendingLoop;
+  let depth = 0;
+  for (let index = 0; index < lineNumber; index += 1) {
+    const line = String(lines[index] ?? '');
+    const leadingClose = leadingCloseBraceCount(line);
+    if (leadingClose) {
+      depth = Math.max(0, depth - leadingClose);
+      while (stack.length && stack[stack.length - 1].depth > depth) stack.pop();
+    }
+    const opens = openBraceCount(line);
+    const closes = closeBraceCount(line) - leadingClose;
+    const loopHead = loopHeadRecord(line);
+    if (loopHead) {
+      pendingLoop = undefined;
+      if (opens > 0) stack.push(loopContext(loopHead, index + 1, depth + 1));
+      else pendingLoop = loopContext(loopHead, index + 1, depth + 1);
+    } else if (pendingLoop && opens > 0) {
+      stack.push({ ...pendingLoop, depth: depth + 1 });
+      pendingLoop = undefined;
+    }
+    if (index + 1 === Number(lineNumber)) return loopIterationRecord(stack[stack.length - 1]);
+    depth = Math.max(0, depth + opens - Math.max(0, closes));
+    while (stack.length && stack[stack.length - 1].depth > depth) stack.pop();
+  }
+  return [];
+}
+
+function controlTransferOrderEvidence(lines, lineNumber) {
+  if (!Array.isArray(lines) || !Number.isFinite(Number(lineNumber))) return [];
+  const number = Number(lineNumber);
+  const record = controlTransferRecord(String(lines[number - 1] ?? ''), number);
+  const target = record?.labelText ? labelTargetEvidence(lines, number, record.labelText) : undefined;
+  if (record && target) return [{ ...record, ...target }];
+  return record ? [record] : [];
+}
+
+function switchContext(head, line, depth) {
+  return { line, depth, text: head.text, discriminantText: head.discriminantText, caseOrdinal: 0 };
+}
+
+function loopContext(head, line, depth) {
+  return { line, depth, ...head };
+}
+
+function switchDispatchRecord(current) {
+  if (!current) return [];
+  return [compactRecord({
+    kind: 'switch-dispatch',
+    switchLine: current.line,
+    switchText: current.text,
+    discriminantText: current.discriminantText,
+    caseLine: current.currentCase?.line,
+    caseText: current.currentCase?.text,
+    caseKind: current.currentCase?.kind,
+    caseOrdinal: current.currentCase?.ordinal,
+    previousCaseLine: current.currentCase?.previousCase?.line,
+    previousCaseText: current.currentCase?.previousCase?.text,
+    previousCaseKind: current.currentCase?.previousCase?.kind,
+    previousCaseOrdinal: current.currentCase?.previousCase?.ordinal,
+    previousCaseCompletionKind: current.currentCase?.previousCaseCompletionKind,
+    fallthroughFromPrevious: current.currentCase?.fallthroughFromPrevious || undefined
+  })];
+}
+
+function loopIterationRecord(current) {
+  if (!current) return [];
+  return [compactRecord({
+    kind: 'loop-iteration',
+    loopKind: current.loopKind,
+    loopLine: current.line,
+    loopText: current.text,
+    iteratorText: current.iteratorText,
+    iterableText: current.iterableText,
+    initializerText: current.initializerText,
+    conditionText: current.conditionText,
+    updateText: current.updateText
+  })];
+}
+
+function controlTransferRecord(line, lineNumber) {
+  const match = /\b(break|continue)\b\s*([A-Za-z_$][\w$]*)?/.exec(String(line ?? ''));
+  if (!match) return undefined;
+  return compactRecord({
+    kind: 'control-transfer',
+    transferKind: match[1],
+    line: lineNumber,
+    labelText: match[2],
+    text: normalizeOrderEvidenceText(line.slice(match.index, statementEnd(line, match.index)))
+  });
+}
+
+function labelTargetEvidence(lines, lineNumber, labelText) {
+  const stack = [];
+  let depth = 0;
+  for (let index = 0; index < lineNumber - 1; index += 1) {
+    const line = String(lines[index] ?? '');
+    const leadingClose = leadingCloseBraceCount(line);
+    if (leadingClose) {
+      depth = Math.max(0, depth - leadingClose);
+      while (stack.length && stack[stack.length - 1].depth > depth) stack.pop();
+    }
+    const label = labelRecord(lines, index, depth);
+    if (label) stack.push(label);
+    depth = Math.max(0, depth + openBraceCount(line) - Math.max(0, closeBraceCount(line) - leadingClose));
+    while (stack.length && stack[stack.length - 1].depth > depth) stack.pop();
+  }
+  const current = [...stack].reverse().find((record) => record.labelText === labelText);
+  return current ? compactRecord({
+    labelLine: current.labelLine,
+    labelTargetLine: current.labelTargetLine,
+    labelTargetKind: current.labelTargetKind,
+    labelTargetText: current.labelTargetText
+  }) : undefined;
+}
+
+function labelRecord(lines, index, depth) {
+  const line = String(lines[index] ?? '');
+  const match = /^\s*([A-Za-z_$][\w$]*)\s*:\s*(.*)$/.exec(line);
+  if (!match || match[1] === 'case' || match[1] === 'default') return undefined;
+  const sameLineTarget = normalizeOrderEvidenceText(match[2]);
+  const next = sameLineTarget ? { line: index + 1, text: sameLineTarget } : nextNonEmptyLine(lines, index + 1);
+  if (!next?.text) return undefined;
+  return compactRecord({
+    labelText: match[1],
+    labelLine: index + 1,
+    labelTargetLine: next.line,
+    labelTargetKind: labelTargetKind(next.text),
+    labelTargetText: labelTargetText(next.text),
+    depth: depth + Math.max(1, openBraceCount(next.text))
+  });
+}
+
+function nextNonEmptyLine(lines, start) {
+  for (let index = start; index < lines.length; index += 1) {
+    const text = normalizeOrderEvidenceText(lines[index]);
+    if (text) return { line: index + 1, text };
+  }
+  return undefined;
+}
+
+function labelTargetKind(text) {
+  if (loopHeadRecord(text)) return 'loop';
+  if (switchHeadRecord(text)) return 'switch';
+  if (/^\{/.test(String(text ?? ''))) return 'block';
+  return 'statement';
+}
+
+function labelTargetText(text) {
+  return loopHeadRecord(text)?.text ?? switchHeadRecord(text)?.text ?? normalizeOrderEvidenceText(text);
+}
+
+function switchHeadRecord(line) {
+  for (const match of String(line ?? '').matchAll(/\bswitch\b/g)) {
+    const open = line.indexOf('(', match.index);
+    const close = matchingParenIndex(line, open);
+    if (open >= 0 && close !== undefined) return {
+      text: normalizeOrderEvidenceText(line.slice(match.index, close + 1)),
+      discriminantText: normalizeOrderEvidenceText(line.slice(open + 1, close))
+    };
+  }
+  return undefined;
+}
+
+function loopHeadRecord(line) {
+  return parenthesizedLoopHead(line, /\bfor\s+await\b/g, 'for-await')
+    ?? parenthesizedLoopHead(line, /\bfor\b/g, 'for')
+    ?? parenthesizedLoopHead(line, /\bwhile\b/g, 'while')
+    ?? doLoopHead(line);
+}
+
+function parenthesizedLoopHead(line, pattern, keywordKind) {
+  for (const match of String(line ?? '').matchAll(pattern)) {
+    const open = line.indexOf('(', match.index);
+    const close = matchingParenIndex(line, open);
+    if (open < 0 || close === undefined) continue;
+    const headerText = normalizeOrderEvidenceText(line.slice(open + 1, close));
+    const text = normalizeOrderEvidenceText(line.slice(match.index, close + 1));
+    if (keywordKind === 'while') return { loopKind: 'while', text, conditionText: headerText };
+    return forLoopHeaderRecord(keywordKind, text, headerText);
+  }
+  return undefined;
+}
+
+function forLoopHeaderRecord(keywordKind, text, headerText) {
+  const ofMatch = headerText.match(/^(.*?)\s+of\s+(.+)$/);
+  if (ofMatch) return { loopKind: keywordKind === 'for-await' ? 'for-await-of' : 'for-of', text, iteratorText: normalizeOrderEvidenceText(ofMatch[1]), iterableText: normalizeOrderEvidenceText(ofMatch[2]) };
+  const inMatch = headerText.match(/^(.*?)\s+in\s+(.+)$/);
+  if (inMatch) return { loopKind: 'for-in', text, iteratorText: normalizeOrderEvidenceText(inMatch[1]), iterableText: normalizeOrderEvidenceText(inMatch[2]) };
+  const parts = headerText.split(';').map(normalizeOrderEvidenceText);
+  return { loopKind: keywordKind, text, initializerText: parts[0], conditionText: parts[1], updateText: parts[2] };
+}
+
+function doLoopHead(line) {
+  const match = /\bdo\b/.exec(String(line ?? ''));
+  return match ? { loopKind: 'do', text: 'do' } : undefined;
+}
+
+function caseHeadRecord(line) {
+  const match = /\b(case|default)\b/.exec(String(line ?? ''));
+  if (!match) return undefined;
+  const colon = line.indexOf(':', match.index);
+  return {
+    kind: match[1] === 'default' ? 'default' : 'case',
+    text: normalizeOrderEvidenceText(line.slice(match.index, colon === -1 ? statementEnd(line, match.index) : colon + 1))
+  };
+}
+
+function caseCompletionKind(line) {
+  const text = String(line ?? '');
+  if (/\bbreak\b/.test(text)) return 'break';
+  if (/\bcontinue\b/.test(text)) return 'continue';
+  if (/\breturn\b/.test(text)) return 'return';
+  if (/\bthrow\b/.test(text)) return 'throw';
+  return undefined;
+}
+
+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 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)); }
+
+function countCharsOutsideStrings(line, target) {
+  let count = 0;
+  let quote;
+  let 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 matchingParenIndex(line, open) {
+  if (open < 0) return undefined;
+  let depth = 0;
+  let quote;
+  let escaped = false;
+  for (let index = open; index < line.length; index += 1) {
+    const char = line[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; continue; }
+    if (char === '(') depth += 1;
+    else if (char === ')' && --depth === 0) return index;
+  }
+  return undefined;
+}
+
+export { controlTransferOrderEvidence, loopIterationOrderEvidence, switchDispatchOrderEvidence };

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

@@ -0,0 +1,44 @@
+function throwOrderEvidenceRecords(line, start, end) {
+  const text = String(line ?? '');
+  const index = throwTokenIndex(text, Math.max(0, Math.min(start, end)));
+  if (index < 0) return [];
+  const statementEndIndex = statementEnd(text, index);
+  const expressionStart = index + 'throw'.length;
+  const expressionText = normalizeOrderEvidenceText(text.slice(expressionStart, statementEndIndex).replace(/;$/, ''));
+  return [compactRecord({
+    kind: 'throw',
+    text: normalizeOrderEvidenceText(text.slice(index, statementEndIndex)),
+    expressionText,
+    throwColumn: index + 1,
+    regionWithinThrow: start >= index && start <= statementEndIndex || undefined
+  })];
+}
+
+function throwTokenIndex(text, beforeIndex) {
+  let quote;
+  let escaped = false;
+  let latest = -1;
+  for (let index = 0; index < text.length && index <= beforeIndex; index += 1) {
+    const char = text[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; continue; }
+    if (text.slice(index, index + 5) === 'throw' && !isIdentifierPart(text[index - 1]) && !isIdentifierPart(text[index + 5])) latest = index;
+  }
+  return latest;
+}
+
+function statementEnd(text, start) {
+  const semicolon = String(text ?? '').indexOf(';', Math.max(0, start));
+  return semicolon === -1 ? String(text ?? '').length : semicolon + 1;
+}
+
+function normalizeOrderEvidenceText(value) { return String(value ?? '').replace(/\s+/g, ' ').trim(); }
+function isIdentifierPart(char) { return /[A-Za-z0-9_$]/.test(char ?? ''); }
+function compactRecord(record) { return Object.fromEntries(Object.entries(record).filter(([, value]) => value !== undefined && value !== '')); }
+
+export { throwOrderEvidenceRecords };