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

package/dist/semantic-import-effect-occurrences.js

@@ -0,0 +1,242 @@
+import { uniqueStrings } from './native-import-utils.js';
+
+const schedulerEffectNames = ['setTimeout', 'setInterval', 'clearTimeout', 'clearInterval', 'requestAnimationFrame', 'cancelAnimationFrame', 'requestIdleCallback', 'cancelIdleCallback', 'queueMicrotask', 'setImmediate', 'clearImmediate'];
+
+function splitEffectFactOccurrences(group, sourceText) {
+  const concreteKinds = group.factKinds.filter((kind) => kind !== 'async');
+  const line = sourceLine(sourceText, group.line);
+  if (!concreteKinds.length && group.factKinds.includes('async')) {
+    const ranges = effectOccurrenceRanges(line, 'async');
+    return ranges.length > 1
+      ? ranges.map((range, occurrenceIndex) => ({ ...group, factKinds: ['async'], occurrenceRange: range, occurrenceOrdinalHint: occurrenceIndex + 1 }))
+      : [group];
+  }
+  if (!concreteKinds.length) return [group];
+  return concreteKinds.flatMap((factKind, index) => {
+    const base = {
+      ...group,
+      facts: group.facts.filter((fact) => fact.value?.kind === factKind
+        || (index === 0 && fact.value?.kind === 'async')),
+      factKinds: uniqueStrings([factKind, index === 0 && group.factKinds.includes('async') ? 'async' : undefined])
+    };
+    const ranges = effectOccurrenceRanges(line, factKind);
+    return ranges.length > 1
+      ? ranges.map((range, occurrenceIndex) => ({ ...base, occurrenceRange: range, occurrenceOrdinalHint: occurrenceIndex + 1 }))
+      : [base];
+  });
+}
+
+function splitMutationFactOccurrences(group, sourceText) {
+  const line = sourceLine(sourceText, group.line);
+  return group.factKinds.flatMap((factKind) => {
+    const base = {
+      ...group,
+      facts: group.facts.filter((fact) => fact.value?.kind === factKind),
+      factKinds: [factKind]
+    };
+    const ranges = mutationOccurrenceRanges(line, factKind);
+    return ranges.length > 1
+      ? ranges.map((range, occurrenceIndex) => ({ ...base, occurrenceRange: range, occurrenceOrdinalHint: occurrenceIndex + 1 }))
+      : [base];
+  });
+}
+
+function effectOccurrenceRanges(line, factKind) {
+  if (factKind === 'network') return namedCallRanges(line, ['fetch', 'XMLHttpRequest', 'WebSocket', 'EventSource'], 'network-call');
+  if (factKind === 'scheduler') return namedCallRanges(line, schedulerEffectNames, 'scheduler-call');
+  if (factKind === 'storage') return tokenExpressionRanges(line, ['localStorage', 'sessionStorage', 'indexedDB', 'caches', 'cookie'], 'storage-effect');
+  if (factKind === 'host-context') return importMetaRanges(line);
+  if (factKind === 'host') return tokenExpressionRanges(line, ['console', 'process', 'Deno', 'Bun'], 'host-effect');
+  if (factKind === 'browser') return sortedRanges([
+    ...namedCallRanges(line, ['Worker', 'SharedWorker'], 'browser-constructor'),
+    ...tokenExpressionRanges(line, ['document', 'window', 'navigator', 'location', 'history'], 'browser-effect')
+  ]);
+  if (factKind === 'tagged-template') return taggedTemplateRanges(line);
+  if (factKind === 'async') return awaitEffectRanges(line);
+  if (factKind === 'generator') return yieldEffectRanges(line);
+  return [];
+}
+
+function mutationOccurrenceRanges(line, factKind) {
+  if (factKind === 'mutating-call') return mutatingCallRanges(line);
+  if (factKind === 'delete') return deleteMutationRanges(line);
+  if (factKind === 'assignment') return assignmentRanges(line);
+  if (factKind === 'update') return updateRanges(line);
+  return [];
+}
+
+function namedCallRanges(line, names, kind) {
+  const text = String(line ?? '');
+  const ranges = [];
+  for (let index = 0; index < text.length; index += 1) {
+    const match = namedCallAt(text, index, names);
+    if (!match) continue;
+    const open = text.indexOf('(', match.start);
+    const close = matchingParenIndex(text, open);
+    ranges.push({ start: match.start, end: close === undefined ? statementEnd(text, open) : close + 1, kind });
+    index = Math.max(index, open);
+  }
+  return sortedRanges([...ranges, ...globalBracketCallRanges(text, names, kind)]);
+}
+
+function globalBracketCallRanges(text, names, kind) {
+  const ranges = [];
+  for (const name of names) {
+    const pattern = new RegExp(`(?:^|[^\\w$.])((?:new\\s+)?(?:window|globalThis|self)\\s*(?:\\?\\.)?\\s*\\[\\s*(['"\`])${name}\\2\\s*\\]\\s*(?:\\?\\.)?\\s*\\()`, 'g');
+    for (const match of text.matchAll(pattern)) {
+      const start = match.index + match[0].indexOf(match[1]);
+      const open = text.indexOf('(', start);
+      const close = matchingParenIndex(text, open);
+      ranges.push({ start, end: close === undefined ? statementEnd(text, open) : close + 1, kind });
+    }
+  }
+  return ranges;
+}
+
+function mutatingCallRanges(line) {
+  const text = String(line ?? '');
+  const ranges = [];
+  const pattern = /[A-Za-z_$][\w$]*(?:(?:\s*(?:\.|\?\.)\s*[A-Za-z_$][\w$]*)|\s*\[[^\]]+\])*\s*(?:(?:\.|\?\.)\s*(?:push|pop|shift|unshift|splice|sort|reverse|set|add|delete|clear)\s*(?:\?\.)?|\s*(?:\?\.)?\s*\[\s*(['"`])(?:push|pop|shift|unshift|splice|sort|reverse|set|add|delete|clear)\1\s*\]\s*(?:\?\.)?)\s*\(/g;
+  for (const match of text.matchAll(pattern)) {
+    const open = text.indexOf('(', match.index);
+    const close = matchingParenIndex(text, open);
+    ranges.push({ start: match.index, end: close === undefined ? statementEnd(text, open) : close + 1, kind: 'mutating-call' });
+  }
+  return ranges;
+}
+
+function deleteMutationRanges(line) {
+  const text = String(line ?? '');
+  return [...text.matchAll(/\bdelete\s+[A-Za-z_$][\w$]*(?:(?:\s*(?:\.|\?\.)\s*[A-Za-z_$][\w$]*)|\s*\[[^\]]+\])*/g)]
+    .map((match) => ({ start: match.index, end: statementEnd(text, match.index), kind: 'delete-mutation' }));
+}
+
+function assignmentRanges(line) {
+  const text = String(line ?? '');
+  return [...text.matchAll(/(^|[^\w$])([A-Za-z_$][\w$]*(?:(?:\s*(?:\.|\?\.)\s*[A-Za-z_$][\w$]*)|\s*\[[^\]]+\])*)\s*=(?!=|>)/g)]
+    .map((match) => ({ start: match.index + match[1].length, end: statementEnd(text, match.index + match[1].length), kind: 'assignment' }));
+}
+
+function updateRanges(line) {
+  const text = String(line ?? '');
+  return [...text.matchAll(/(^|[^\w$])((?:\+\+|--)\s*)?[A-Za-z_$][\w$]*(?:(?:\s*(?:\.|\?\.)\s*[A-Za-z_$][\w$]*)|\s*\[[^\]]+\])*(?:\s*(?:\+\+|--|\+=|-=|\*=|\/=|%=|\|\|=|&&=|\?\?=))/g)]
+    .map((match) => ({ start: match.index + match[1].length, end: statementEnd(text, match.index + match[1].length), kind: 'update' }));
+}
+
+function tokenExpressionRanges(line, tokens, kind) {
+  const text = String(line ?? '');
+  const pattern = new RegExp(`\\b(?:${tokens.join('|')})\\b`, 'g');
+  return [...text.matchAll(pattern)].map((match) => ({
+    start: match.index,
+    end: statementEnd(text, match.index),
+    kind
+  }));
+}
+
+function awaitEffectRanges(line) {
+  const text = String(line ?? '');
+  return [...text.matchAll(/\bawait\b/g)]
+    .map((match) => ({ start: match.index, end: statementEnd(text, match.index), kind: 'async-effect' }));
+}
+
+function yieldEffectRanges(line) {
+  const text = String(line ?? '');
+  return [...text.matchAll(/\byield\s*\*?/g)]
+    .map((match) => ({ start: match.index, end: statementEnd(text, match.index), kind: 'generator-effect' }));
+}
+
+function importMetaRanges(line) {
+  const text = String(line ?? '');
+  return [...text.matchAll(/\bimport\s*\.\s*meta(?:\s*\.\s*[A-Za-z_$][\w$]*)*/g)]
+    .map((match) => ({ start: match.index, end: statementEnd(text, match.index), kind: 'import-meta-host-context' }));
+}
+
+function taggedTemplateRanges(line) {
+  const text = String(line ?? '');
+  const ranges = [];
+  const pattern = /(?:^|[^\w$.)\]])([A-Za-z_$][\w$]*(?:(?:\s*\.\s*[A-Za-z_$][\w$]*)|\s*\[[^\]]+\])*)\s*`/g;
+  for (const match of text.matchAll(pattern)) {
+    const start = match.index + match[0].indexOf(match[1]);
+    const tick = text.indexOf('`', start);
+    ranges.push({ start, end: templateEnd(text, tick), kind: 'tagged-template' });
+  }
+  return ranges;
+}
+
+function namedCallAt(text, index, names) {
+  if (isIdentifierPart(text[index - 1]) || text[index - 1] === '.' || text[index - 1] === '$') return undefined;
+  const receiverLength = receiverPrefixLength(text, index);
+  const start = index + receiverLength;
+  for (const name of names) {
+    if (text.slice(start, start + name.length) !== name || isIdentifierPart(text[start + name.length])) continue;
+    const open = optionalCallOpen(text, skipSpaces(text, start + name.length));
+    if (text[open] === '(') return { start: constructorStartBefore(text, index) ?? index };
+  }
+  return undefined;
+}
+
+function receiverPrefixLength(text, index) {
+  for (const prefix of ['window?.', 'globalThis?.', 'self?.', 'window.', 'globalThis.', 'self.']) {
+    if (text.slice(index, index + prefix.length) === prefix) return prefix.length;
+  }
+  return 0;
+}
+
+function optionalCallOpen(text, index) {
+  return text[index] === '?' && text[index + 1] === '.' ? skipSpaces(text, index + 2) : index;
+}
+
+function constructorStartBefore(text, index) {
+  let cursor = index - 1;
+  while (/\s/.test(text[cursor] ?? '')) cursor -= 1;
+  const end = cursor + 1;
+  const start = end - 3;
+  return text.slice(start, end) === 'new' && !isIdentifierPart(text[start - 1]) ? start : undefined;
+}
+
+function sortedRanges(ranges) {
+  return ranges.slice().sort((left, right) => left.start - right.start || left.end - right.end);
+}
+
+function sourceLine(sourceText, lineNumber) {
+  return String(sourceText ?? '').split(/\r\n|\n|\r/)[Number(lineNumber) - 1] ?? '';
+}
+
+function statementEnd(line, start) {
+  const semicolon = String(line ?? '').indexOf(';', Math.max(0, start));
+  return semicolon === -1 ? String(line ?? '').length : semicolon + 1;
+}
+
+function templateEnd(line, start) {
+  for (let index = start + 1, escaped = false; index < line.length; index += 1) {
+    if (escaped) escaped = false;
+    else if (line[index] === '\\') escaped = true;
+    else if (line[index] === '`') return index + 1;
+  }
+  return line.length;
+}
+
+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;
+}
+
+function skipSpaces(text, index) { let cursor = index; while (/\s/.test(text[cursor] ?? '')) cursor += 1; return cursor; }
+function isIdentifierPart(char) { return /[A-Za-z0-9_$]/.test(char ?? ''); }
+
+export { splitEffectFactOccurrences, splitMutationFactOccurrences };

package/dist/semantic-import-effect-regions.js

@@ -1,6 +1,10 @@
+import { hashSemanticValue } from '@shapeshift-labs/frontier-lang-kernel';
 import { caseSensitiveIdFragment, idFragment, uniqueRecordsById, uniqueStrings } from './native-import-utils.js';
+import { splitEffectFactOccurrences, splitMutationFactOccurrences } from './semantic-import-effect-occurrences.js';
+import { semanticFactOrderInfo, semanticFactRuntimeOrderEvidence, semanticFactRuntimeOrderSignatureEvidence } from './semantic-import-runtime-order-evidence.js';
 
 const semanticFactRegionKinds = new Set(['controlFlow', 'effect', 'mutation']);
+const schedulerEffectNames = ['setTimeout', 'setInterval', 'clearTimeout', 'clearInterval', 'requestAnimationFrame', 'cancelAnimationFrame', 'requestIdleCallback', 'cancelIdleCallback', 'queueMicrotask', 'setImmediate', 'clearImmediate'];
 
 export function semanticEffectRegionRecordsForImport(imported, semanticIndex, options = {}) {
   const symbolsById = new Map((semanticIndex?.symbols ?? []).map((symbol) => [symbol.id, symbol]));
@@ -8,12 +12,15 @@ export function semanticEffectRegionRecordsForImport(imported, semanticIndex, op
     && semanticFactSubjectCanOwnRuntimeRegion(symbolsById.get(fact.subjectId)));
   if (!facts.length) return { symbols: [], ownershipRegions: [] };
   const sourceText = nativeImportSourceText(imported);
-  const groups = semanticFactRegionGroups(facts);
+  const groups = semanticFactRegionGroups(facts, sourceText);
   const ordinals = new Map();
+  const orderInfo = semanticFactOrderInfo(groups);
   const records = groups.map((group, index) => {
     const fact = group.facts[0];
     const spanInfo = semanticFactSpanInfo(sourceText, group, fact, imported);
+    const runtimeOrderEvidence = semanticFactRuntimeOrderEvidence(sourceText, group, fact, spanInfo, orderInfo.get(group));
     const owner = symbolsById.get(fact.subjectId);
+    const signatureHash = hashSemanticValue({ kind: 'frontier.lang.semanticFactRuntimeRegionSignature', subjectId: fact.subjectId, subjectName: owner?.name, regionKind: group.regionKind, factKinds: group.factKinds, spanKind: spanInfo.kind, runtimeOrderEvidence: semanticFactRuntimeOrderSignatureEvidence(runtimeOrderEvidence) });
     const sourcePath = fact.value?.sourcePath ?? imported?.sourcePath ?? imported?.nativeSource?.sourcePath;
     const language = imported?.language ?? imported?.nativeSource?.language ?? imported?.nativeAst?.language;
     const signature = semanticFactRegionSignature(group);
@@ -42,6 +49,7 @@ export function semanticEffectRegionRecordsForImport(imported, semanticIndex, op
         factLine: group.line,
         predicate: group.regionKind,
         spanKind: spanInfo.kind,
+        runtimeOrderEvidence,
         occurrenceOrdinal: ordinal,
         subjectId: fact.subjectId,
         subjectName: owner?.name
@@ -56,6 +64,7 @@ export function semanticEffectRegionRecordsForImport(imported, semanticIndex, op
         language,
         nativeAstNodeId: region.nativeAstNodeId,
         sourceSpan: region.sourceSpan,
+        signatureHash,
         ownershipRegionId: region.id,
         ownershipKey: region.key,
         ownershipRegionKind: group.regionKind,
@@ -69,7 +78,7 @@ export function semanticEffectRegionRecordsForImport(imported, semanticIndex, op
   };
 }
 
-function semanticFactRegionGroups(facts) {
+function semanticFactRegionGroups(facts, sourceText) {
   const groups = new Map();
   for (const fact of facts) {
     const line = Number(fact?.value?.line);
@@ -81,45 +90,27 @@ function semanticFactRegionGroups(facts) {
     group.factKinds = uniqueStrings(group.facts.map((item) => item.value?.kind).filter(Boolean));
     groups.set(key, group);
   }
-  return [...groups.values()].flatMap(splitSemanticFactGroup);
+  return [...groups.values()].flatMap((group) => splitSemanticFactGroup(group, sourceText));
 }
 
-function splitSemanticFactGroup(group) {
-  if (group.regionKind === 'effect') return splitEffectFactGroup(group);
-  return group.factKinds.map((factKind) => ({
-    ...group,
-    facts: group.facts.filter((fact) => fact.value?.kind === factKind),
-    factKinds: [factKind]
-  }));
+function splitSemanticFactGroup(group, sourceText) {
+  if (group.regionKind === 'effect') return splitEffectFactGroup(group, sourceText);
+  if (group.regionKind === 'mutation') return splitMutationFactOccurrences(group, sourceText);
+  return group.factKinds.map((factKind) => ({ ...group, facts: group.facts.filter((fact) => fact.value?.kind === factKind), factKinds: [factKind] }));
 }
 
-function splitEffectFactGroup(group) {
-  const concreteKinds = group.factKinds.filter((kind) => kind !== 'async');
-  if (!concreteKinds.length) return [group];
-  return concreteKinds.map((factKind, index) => ({
-    ...group,
-    facts: group.facts.filter((fact) => fact.value?.kind === factKind
-      || (index === 0 && fact.value?.kind === 'async')),
-    factKinds: uniqueStrings([factKind, index === 0 && group.factKinds.includes('async') ? 'async' : undefined])
-  }));
-}
+function splitEffectFactGroup(group, sourceText) { return splitEffectFactOccurrences(group, sourceText); }
 
-function semanticFactRegionSignature(group) {
-  return (group.factKinds?.length ? group.factKinds : [group.regionKind]).join('+');
-}
+function semanticFactRegionSignature(group) { return (group.factKinds?.length ? group.factKinds : [group.regionKind]).join('+'); }
 
 function nextSemanticFactOrdinal(ordinals, group, fact, signature) {
   const key = [group.regionKind, fact.subjectId, group.sourcePath, signature].join('\0');
-  const next = (ordinals.get(key) ?? 0) + 1;
-  ordinals.set(key, next);
-  return next;
+  const next = (ordinals.get(key) ?? 0) + 1; ordinals.set(key, next); return next;
 }
 
 function semanticFactSubjectCanOwnRuntimeRegion(symbol) {
-  if (!symbol) return true;
-  if (symbol.metadata?.ownershipRegionKind === 'body') return true;
-  return /function|method|action|effect|handler|constructor/
-    .test(String(symbol.kind ?? '').toLowerCase());
+  if (!symbol || symbol.metadata?.ownershipRegionKind === 'body') return true;
+  return /function|method|action|effect|handler|constructor/.test(String(symbol.kind ?? '').toLowerCase());
 }
 
 function semanticFactSpanInfo(sourceText, group, fact, imported) {
@@ -143,6 +134,7 @@ function semanticFactSpanInfo(sourceText, group, fact, imported) {
 }
 
 function semanticFactExpressionRange(line, group) {
+  if (group.occurrenceRange) return group.occurrenceRange;
   if (group.regionKind === 'effect') return effectRange(line, group.factKinds);
   if (group.regionKind === 'mutation') return mutationRange(line, group.factKinds);
   if (group.regionKind === 'controlFlow') return controlFlowRange(line, group.factKinds);
@@ -150,12 +142,18 @@ function semanticFactExpressionRange(line, group) {
 }
 
 function effectRange(line, kinds) {
+  if (kinds.includes('tagged-template')) return taggedTemplateRange(line);
+  if (kinds.includes('template-interpolation') || kinds.includes('template-literal')) return templateLiteralRange(line);
   if (kinds.includes('network')) return namedCallRange(line, ['fetch', 'XMLHttpRequest', 'WebSocket', 'EventSource'], 'network-call');
-  if (kinds.includes('scheduler')) return namedCallRange(line, ['setTimeout', 'setInterval', 'requestAnimationFrame', 'queueMicrotask'], 'scheduler-call');
+  if (kinds.includes('scheduler')) return namedCallRange(line, schedulerEffectNames, 'scheduler-call');
   if (kinds.includes('storage')) return tokenExpressionRange(line, ['localStorage', 'sessionStorage', 'indexedDB', 'caches', 'cookie'], 'storage-effect');
+  if (kinds.includes('host-context')) return tokenExpressionRange(line, ['import\\s*\\.\\s*meta(?:\\s*\\.\\s*[A-Za-z_$][\\w$]*)*'], 'import-meta-host-context');
   if (kinds.includes('host')) return tokenExpressionRange(line, ['console', 'process', 'Deno', 'Bun'], 'host-effect');
-  if (kinds.includes('browser')) return tokenExpressionRange(line, ['document', 'window', 'navigator', 'location', 'history'], 'browser-effect');
-  if (kinds.includes('async')) return keywordExpressionRange(line, 'await', 'async-effect');
+  if (kinds.includes('browser')) return namedCallRange(line, ['Worker', 'SharedWorker'], 'browser-constructor')
+    ?? tokenExpressionRange(line, ['document', 'window', 'navigator', 'location', 'history'], 'browser-effect');
+  if (kinds.includes('async')) return keywordExpressionRange(line, /(await|async)\b/, 'async-effect');
+  if (kinds.includes('generator')) return keywordExpressionRange(line, /\byield\b|\bfunction\s*\*/, 'generator-effect');
+  if (kinds.includes('getter')) return getterAccessRange(line);
   return undefined;
 }
 
@@ -173,55 +171,66 @@ function controlFlowRange(line, kinds) {
     ?? caseHeadRange(line) ?? keywordExpressionRange(line, /else\b/, 'control-branch');
   if (kinds.includes('loop')) return controlHeadRange(line, /(for|while)\b/, 'control-loop')
     ?? keywordExpressionRange(line, /do\b/, 'control-loop');
+  if (kinds.includes('transfer')) return keywordExpressionRange(line, /(break|continue)\b/, 'control-transfer');
   if (kinds.includes('exception')) return keywordExpressionRange(line, /(throw|catch|finally|try)\b/, 'control-exception');
   if (kinds.includes('async')) return keywordExpressionRange(line, /(await|async)\b/, 'control-async');
   return undefined;
 }
 
 function namedCallRange(line, names, kind) {
+  const ranges = [];
   for (const name of names) {
-    const pattern = new RegExp(`(?:^|[^\\w$.])((?:window|globalThis|self)\\s*\\.\\s*)?${name}\\s*\\(`);
+    const pattern = new RegExp(`(?:^|[^\\w$.])((?:new\\s+)?(?:(?:window|globalThis|self)\\s*(?:\\.|\\?\\.)\\s*)?${name}\\s*(?:\\?\\.)?\\s*\\()`);
     const match = pattern.exec(line);
     if (!match) continue;
-    const start = match.index + match[0].search(new RegExp(`((?:window|globalThis|self)\\s*\\.\\s*)?${name}\\s*\\(`));
-    const open = line.indexOf('(', start);
-    const close = matchingParenIndex(line, open);
-    return { start, end: close === undefined ? statementEnd(line, open) : close + 1, kind };
+    const start = match.index + match[0].search(new RegExp(`(?:new\\s+)?(?:(?:window|globalThis|self)\\s*(?:\\.|\\?\\.)\\s*)?${name}\\s*(?:\\?\\.)?\\s*\\(`));
+    ranges.push(callRange(line, start, kind));
   }
-  return undefined;
+  ranges.push(...globalBracketCallRanges(line, names, kind));
+  return ranges.sort((left, right) => left.start - right.start || left.end - right.end)[0];
+}
+
+function globalBracketCallRanges(line, names, kind) {
+  const ranges = [];
+  for (const name of names) {
+    const pattern = new RegExp(`(?:^|[^\\w$.])((?:new\\s+)?(?:window|globalThis|self)\\s*(?:\\?\\.)?\\s*\\[\\s*(['"\`])${name}\\2\\s*\\]\\s*(?:\\?\\.)?\\s*\\()`, 'g');
+    for (const match of line.matchAll(pattern)) {
+      const start = match.index + match[0].indexOf(match[1]);
+      ranges.push(callRange(line, start, kind));
+    }
+  }
+  return ranges;
 }
 
+function callRange(line, start, kind) { const open = line.indexOf('(', start); const close = matchingParenIndex(line, open); return { start, end: close === undefined ? statementEnd(line, open) : close + 1, kind }; }
+
 function controlHeadRange(line, keyword, kind) {
   const match = keyword.exec(line);
   if (!match) return undefined;
-  const open = line.indexOf('(', match.index);
-  const close = matchingParenIndex(line, open);
+  const open = line.indexOf('(', match.index), close = matchingParenIndex(line, open);
   return close === undefined ? undefined : { start: match.index, end: close + 1, kind };
 }
 
 function caseHeadRange(line) {
   const match = /\b(case|default)\b/.exec(line);
   if (!match) return undefined;
-  const colon = line.indexOf(':', match.index);
-  return { start: match.index, end: colon === -1 ? statementEnd(line, match.index) : colon + 1, kind: 'control-branch' };
+  const colon = line.indexOf(':', match.index); return { start: match.index, end: colon === -1 ? statementEnd(line, match.index) : colon + 1, kind: 'control-branch' };
 }
 
 function mutatingCallRange(line) {
-  const match = /[A-Za-z_$][\w$.[\]]*(?:\s*\.\s*[A-Za-z_$][\w$.[\]]*)*\s*\.\s*(?:push|pop|shift|unshift|splice|sort|reverse|set|add|delete|clear)\s*\(/.exec(line);
+  const match = /[A-Za-z_$][\w$]*(?:(?:\s*(?:\.|\?\.)\s*[A-Za-z_$][\w$]*)|\s*\[[^\]]+\])*\s*(?:(?:\.|\?\.)\s*(?:push|pop|shift|unshift|splice|sort|reverse|set|add|delete|clear)\s*(?:\?\.)?|\s*(?:\?\.)?\s*\[\s*(['"`])(?:push|pop|shift|unshift|splice|sort|reverse|set|add|delete|clear)\1\s*\]\s*(?:\?\.)?)\s*\(/.exec(line);
   if (!match) return undefined;
-  const open = line.indexOf('(', match.index);
-  const close = matchingParenIndex(line, open);
+  const open = line.indexOf('(', match.index), close = matchingParenIndex(line, open);
   return { start: match.index, end: close === undefined ? statementEnd(line, open) : close + 1, kind: 'mutating-call' };
 }
 
 function assignmentRange(line) {
-  const match = /\b[A-Za-z_$][\w$.[\]]*\s*=(?!=|>)/.exec(line);
-  return match ? { start: match.index, end: statementEnd(line, match.index), kind: 'assignment' } : undefined;
+  const match = /(^|[^\w$])([A-Za-z_$][\w$]*(?:(?:\s*(?:\.|\?\.)\s*[A-Za-z_$][\w$]*)|\s*\[[^\]]+\])*)\s*=(?!=|>)/.exec(line);
+  return match ? { start: match.index + match[1].length, end: statementEnd(line, match.index + match[1].length), kind: 'assignment' } : undefined;
 }
-
 function updateRange(line) {
-  const match = /\b[A-Za-z_$][\w$.[\]]*(?:\+\+|--|\s*(?:\+=|-=|\*=|\/=|%=|\|\|=|&&=|\?\?=))/.exec(line);
-  return match ? { start: match.index, end: statementEnd(line, match.index), kind: 'update' } : undefined;
+  const match = /(^|[^\w$])([A-Za-z_$][\w$]*(?:(?:\s*(?:\.|\?\.)\s*[A-Za-z_$][\w$]*)|\s*\[[^\]]+\])*)(?:\+\+|--|\s*(?:\+=|-=|\*=|\/=|%=|\|\|=|&&=|\?\?=))/.exec(line);
+  return match ? { start: match.index + match[1].length, end: statementEnd(line, match.index + match[1].length), kind: 'update' } : undefined;
 }
 
 function tokenExpressionRange(line, tokens, kind) {
@@ -230,10 +239,43 @@ function tokenExpressionRange(line, tokens, kind) {
   return match ? { start: match.index, end: statementEnd(line, match.index), kind } : undefined;
 }
 
+function getterAccessRange(line) {
+  const pattern = /\b[A-Za-z_$][\w$]*(?:(?:\s*\?\.\s*|\s*\.\s*)[A-Za-z_$][\w$]*|\s*\[[^\]]+\])+/g;
+  for (const match of line.matchAll(pattern)) {
+    const next = nextNonSpace(line, match.index + match[0].length);
+    if (next === '(') continue;
+    return { start: match.index, end: match.index + match[0].length, kind: 'getter-access' };
+  }
+  return undefined;
+}
+function taggedTemplateRange(line) {
+  const match = /(?:^|[^\w$.)\]])([A-Za-z_$][\w$]*(?:(?:\s*\.\s*[A-Za-z_$][\w$]*)|\s*\[[^\]]+\])*)\s*`/.exec(line);
+  if (!match) return templateLiteralRange(line);
+  const start = match.index + match[0].indexOf(match[1]);
+  return { start, end: templateEnd(line, line.indexOf('`', start)), kind: 'tagged-template' };
+}
+function templateLiteralRange(line) {
+  const start = line.indexOf('`');
+  return start < 0 ? undefined : { start, end: templateEnd(line, start), kind: 'template-literal' };
+}
+function templateEnd(line, start) {
+  for (let index = start + 1, escaped = false; index < line.length; index += 1) {
+    if (escaped) escaped = false;
+    else if (line[index] === '\\') escaped = true;
+    else if (line[index] === '`') return index + 1;
+  }
+  return line.length;
+}
 function keywordExpressionRange(line, keyword, kind) {
   const match = keyword instanceof RegExp ? keyword.exec(line) : new RegExp(`\\b${keyword}\\b`).exec(line);
   return match ? { start: match.index, end: statementEnd(line, match.index), kind } : undefined;
 }
+function nextNonSpace(line, index) {
+  for (let cursor = index; cursor < line.length; cursor += 1) {
+    if (!/\s/.test(line[cursor])) return line[cursor];
+  }
+  return '';
+}
 
 function statementEnd(line, start) {
   const semicolon = line.indexOf(';', Math.max(0, start));
@@ -264,9 +306,7 @@ function matchingParenIndex(line, open) {
 }
 
 function semanticFactRegionKey(prefix = 'source', sourcePath, regionKind, symbolName, index) {
-  return [prefix, sourcePath ?? 'memory', regionKind, symbolName || `unknown#${index + 1}`]
-    .map((part) => String(part).replace(/\s+/g, ' ').trim())
-    .join('#');
+  return [prefix, sourcePath ?? 'memory', regionKind, symbolName || `unknown#${index + 1}`].map((part) => String(part).replace(/\s+/g, ' ').trim()).join('#');
 }
 
 function semanticFactRegionMergePolicy(regionKind) {
@@ -276,8 +316,5 @@ function semanticFactRegionMergePolicy(regionKind) {
 }
 
 function nativeImportSourceText(imported) {
-  return imported?.metadata?.sourcePreservation?.sourceText
-    ?? imported?.nativeSource?.metadata?.sourcePreservation?.sourceText
-    ?? imported?.nativeAst?.metadata?.sourcePreservation?.sourceText
-    ?? imported?.universalAst?.metadata?.sourcePreservation?.sourceText;
+  return imported?.metadata?.sourcePreservation?.sourceText ?? imported?.nativeSource?.metadata?.sourcePreservation?.sourceText ?? imported?.nativeAst?.metadata?.sourcePreservation?.sourceText ?? imported?.universalAst?.metadata?.sourcePreservation?.sourceText;
 }