@shapeshift-labs/frontier-lang-compiler 0.2.103 → 0.2.104

package/dist/js-ts-semantic-merge-member-source.js

@@ -0,0 +1,64 @@
+function canonicalizeSourceBodies(sourceText, preparedRegions, side) {
+  let output = sourceText;
+  const replacements = preparedRegions
+    .map((region) => ({ range: region[side], replacement: region.base.body }))
+    .sort((left, right) => right.range.bodyStart - left.range.bodyStart);
+  for (const { range, replacement } of replacements) {
+    output = `${output.slice(0, range.bodyStart)}${replacement}${output.slice(range.bodyEnd)}`;
+  }
+  return output;
+}
+
+function applyMemberAdditions(headSourceText, preparedRegions) {
+  let output = headSourceText;
+  const replacements = preparedRegions
+    .filter((region) => region.workerAddedMembers.length)
+    .map((region) => ({ range: region.head, replacement: appendMembersToBody(region.head.body, region.workerAddedMembers) }))
+    .sort((left, right) => right.range.bodyStart - left.range.bodyStart);
+  for (const { range, replacement } of replacements) {
+    output = `${output.slice(0, range.bodyStart)}${replacement}${output.slice(range.bodyEnd)}`;
+  }
+  return output;
+}
+
+function appendMembersToBody(body, members) {
+  if (!members.length) return body;
+  const indent = inferMemberIndent(body) ?? inferMemberIndent(members.map((member) => member.text).join('\n')) ?? '  ';
+  const addedText = members.map((member) => normalizeMemberForInsertion(member.text, indent)).join('\n');
+  const trailing = body.match(/\s*$/)?.[0] ?? '';
+  const before = body.slice(0, body.length - trailing.length);
+  if (!before.trim()) {
+    const closingIndent = trailing.includes('\n') ? trailing.slice(trailing.lastIndexOf('\n') + 1) : '';
+    return `\n${addedText}\n${closingIndent}`;
+  }
+  return `${before}${before.endsWith('\n') ? '' : '\n'}${addedText}${trailing.includes('\n') ? trailing : `\n${trailing}`}`;
+}
+
+function inferMemberIndent(text) {
+  return String(text ?? '').match(/\n([ \t]*)\S/)?.[1];
+}
+
+function normalizeMemberForInsertion(text, indent) {
+  const lines = String(text ?? '').replace(/\r\n/g, '\n').replace(/\r/g, '\n').split('\n');
+  while (lines.length && !lines[0].trim()) lines.shift();
+  while (lines.length && !lines[lines.length - 1].trim()) lines.pop();
+  const commonIndent = minimumIndent(lines);
+  return lines.map((line) => {
+    const normalized = commonIndent ? line.slice(Math.min(commonIndent, leadingWhitespace(line))) : line;
+    return normalized.trim() ? `${indent}${normalized}` : normalized;
+  }).join('\n');
+}
+
+function minimumIndent(lines) {
+  const indents = lines.filter((line) => line.trim()).map(leadingWhitespace);
+  return indents.length ? Math.min(...indents) : 0;
+}
+
+function leadingWhitespace(line) {
+  return line.match(/^[ \t]*/)?.[0].length ?? 0;
+}
+
+export {
+  applyMemberAdditions,
+  canonicalizeSourceBodies
+};

package/dist/js-ts-semantic-merge-member-utils.js

@@ -0,0 +1,18 @@
+function normalizeMemberText(text) {
+  return String(text ?? '')
+    .replace(/\r\n/g, '\n')
+    .replace(/\r/g, '\n')
+    .split('\n')
+    .map((line) => line.trimEnd())
+    .join('\n')
+    .trim();
+}
+
+function uniqueStrings(values) {
+  return [...new Set(values.filter(Boolean).map(String))];
+}
+
+export {
+  normalizeMemberText,
+  uniqueStrings
+};

package/dist/js-ts-semantic-merge-parse.js

@@ -0,0 +1,15 @@
+export {
+  findContainer,
+  normalizeKind
+} from './js-ts-semantic-merge-member-containers.js';
+export {
+  parseMembers
+} from './js-ts-semantic-merge-member-segments.js';
+export {
+  applyMemberAdditions,
+  canonicalizeSourceBodies
+} from './js-ts-semantic-merge-member-source.js';
+export {
+  normalizeMemberText,
+  uniqueStrings
+} from './js-ts-semantic-merge-member-utils.js';

package/dist/js-ts-semantic-merge.js

@@ -0,0 +1,21 @@
+export {
+  JsTsSafeMergeConflictCodes,
+  JsTsSafeMergeGateIds,
+  JsTsSafeMergeStatuses,
+  safeMergeJsTsImportsAndDeclarations
+} from './js-ts-safe-merge.js';
+export {
+  mergeJsTsSafeMemberAdditions,
+  safeMergeJsTsMembers
+} from './js-ts-safe-member-merge.js';
+export {
+  createJsTsSemanticMergeConflictExplanation,
+  createJsTsSemanticMergeGateResult,
+  JsTsSemanticMergeConflictClasses,
+  JsTsSemanticMergeGateStatuses
+} from './js-ts-semantic-merge-contracts.js';
+export {
+  createJsTsSemanticConflictSidecars,
+  JsTsSemanticConflictSidecarClasses,
+  summarizeJsTsSemanticConflictSidecars
+} from './js-ts-semantic-conflict-sidecars.js';

package/dist/lightweight-dependency-effects.js

@@ -0,0 +1,51 @@
+function lightweightEffectKinds(line) {
+  const kinds = [];
+  if (/\bawait\b|import\s*\(/.test(line)) kinds.push('async');
+  if (hasGlobalNetworkCall(line)) kinds.push('network');
+  if (/\b(localStorage|sessionStorage|indexedDB|caches|cookie)\b/.test(line)) kinds.push('storage');
+  if (hasGlobalSchedulerCall(line)) kinds.push('scheduler');
+  if (/\b(console|process|Deno|Bun)\s*\./.test(line)) kinds.push('host');
+  if (hasBrowserEffect(line)) kinds.push('browser');
+  return kinds;
+}
+
+function hasGlobalNetworkCall(line) {
+  return hasBareCall(line, ['fetch', 'XMLHttpRequest', 'WebSocket', 'EventSource'])
+    || hasGlobalPropertyCall(line, ['fetch', 'XMLHttpRequest', 'WebSocket', 'EventSource']);
+}
+
+function hasGlobalSchedulerCall(line) {
+  const names = [
+    'setTimeout',
+    'setInterval',
+    'clearTimeout',
+    'clearInterval',
+    'requestAnimationFrame',
+    'cancelAnimationFrame',
+    'requestIdleCallback',
+    'cancelIdleCallback',
+    'queueMicrotask',
+    'setImmediate',
+    'clearImmediate'
+  ];
+  return hasBareCall(line, names) || hasGlobalPropertyCall(line, names);
+}
+
+function hasBrowserEffect(line) {
+  return /\b(document|window|navigator|location|history)\s*\./.test(line)
+    || hasGlobalConstructorCall(line, ['Worker', 'SharedWorker']);
+}
+
+function hasBareCall(line, names) {
+  return names.some((name) => new RegExp(`(?:^|[^\\w$.])${name}\\s*\\(`).test(line));
+}
+
+function hasGlobalPropertyCall(line, names) {
+  return names.some((name) => new RegExp(`\\b(?:window|globalThis|self)\\s*\\.\\s*${name}\\s*\\(`).test(line));
+}
+
+function hasGlobalConstructorCall(line, names) {
+  return names.some((name) => new RegExp(`(?:^|[^\\w$.])new\\s+(?:(?:window|globalThis|self)\\s*\\.\\s*)?${name}\\s*\\(`).test(line));
+}
+
+export { lightweightEffectKinds };

package/dist/lightweight-dependency-language.js

@@ -41,7 +41,7 @@ export function isDependencyIdentifier(value) {
 export function dependencyScanRanges(input, declarations, lines) {
   const ordered = [...(declarations ?? [])].sort((left, right) => (left.span?.startLine ?? 0) - (right.span?.startLine ?? 0));
   return ordered
-    .filter((declaration) => declaration?.symbolId && declaration.role !== 'import')
+    .filter((declaration) => declaration?.symbolId && declaration.role !== 'import' && shouldScanDependencyDeclaration(input, declaration))
     .map((declaration, index) => ({
       declaration,
       startLine: declaration.span?.startLine ?? 1,
@@ -49,6 +49,17 @@ export function dependencyScanRanges(input, declarations, lines) {
     }));
 }
 
+function shouldScanDependencyDeclaration(input, declaration) {
+  if (!isJavaScriptLikeLanguage(input)) return true;
+  if (declaration.metadata?.signatureOnly || declaration.fields?.typeKind) return false;
+  if (/^Type(?:Alias|Method|Property|FunctionProperty)/.test(String(declaration?.kind ?? ''))) return false;
+  return !['interface', 'type'].includes(String(declaration?.symbolKind ?? '').toLowerCase());
+}
+
+function isJavaScriptLikeLanguage(input) {
+  return ['javascript', 'typescript'].includes(String(input?.language ?? '').toLowerCase());
+}
+
 export function maskDependencyLine(input, line, state) {
   const language = String(input.language ?? '').toLowerCase();
   const text = String(line ?? '');

package/dist/lightweight-dependency-relations.js

@@ -7,6 +7,7 @@ import {
   isDependencyIdentifier,
   maskDependencyLine
 } from './lightweight-dependency-language.js';
+import { lightweightEffectKinds } from './lightweight-dependency-effects.js';
 import { sourceLines } from './native-region-scanner-core.js';
 
 export function lightweightDependencyRelations(input, declarations, documentId) {
@@ -108,6 +109,7 @@ function addLightweightSemanticFacts(input, documentId, declaration, line, lineN
 function shouldScanRuntimeFacts(input, declaration) {
   if (!isJavaScriptLike(input)) return true;
   if (declaration?.fields?.typeKind) return false;
+  if (['object', 'array'].includes(declaration?.fields?.initializerKind)) return false;
   if (/^Type(?:Alias|Method|Property|FunctionProperty)/.test(String(declaration?.kind ?? ''))) return false;
   return !['interface', 'type'].includes(String(declaration?.symbolKind ?? '').toLowerCase());
 }
@@ -119,6 +121,10 @@ function isJavaScriptLike(input) {
 function isIgnoredDependencyOccurrence(input, line, startIndex, name) {
   if (!isJavaScriptLike(input)) return false;
   const endIndex = startIndex + String(name).length;
+  const beforeText = line.slice(0, startIndex);
+  if (/\b(?:async\s+)?function\*?\s*$/.test(beforeText) || /\bclass\s*$/.test(beforeText)) return true;
+  const afterText = line.slice(endIndex);
+  if (/^\s*\([^)]*\)\s*\{/.test(afterText) && /^\s*(?:async\s+)?(?:get\s+|set\s+)?$/.test(beforeText)) return true;
   const previous = previousNonSpace(line, startIndex - 1);
   const next = nextNonSpace(line, endIndex);
   return previous === '.' || next === ':';
@@ -148,17 +154,6 @@ function lightweightControlFlowKinds(line, state = {}) {
   return kinds;
 }
 
-function lightweightEffectKinds(line) {
-  const kinds = [];
-  if (/\bawait\b|import\s*\(/.test(line)) kinds.push('async');
-  if (hasGlobalNetworkCall(line)) kinds.push('network');
-  if (/\b(localStorage|sessionStorage|indexedDB|caches|cookie)\b/.test(line)) kinds.push('storage');
-  if (/\b(setTimeout|setInterval|requestAnimationFrame|queueMicrotask)\s*\(/.test(line)) kinds.push('scheduler');
-  if (/\b(console|process|Deno|Bun)\s*\./.test(line)) kinds.push('host');
-  if (/\b(document|window|navigator|location|history)\s*\./.test(line)) kinds.push('browser');
-  return kinds;
-}
-
 function lightweightMutationKinds(line) {
   const kinds = [];
   if (/\bdelete\s+[A-Za-z_$][\w$.[\]]*/.test(line)) kinds.push('delete');
@@ -199,24 +194,11 @@ function blockBraceDelta(line) {
   return delta;
 }
 
-function hasGlobalNetworkCall(line) {
-  return hasBareCall(line, ['fetch', 'XMLHttpRequest', 'WebSocket', 'EventSource'])
-    || hasGlobalPropertyCall(line, ['fetch', 'XMLHttpRequest', 'WebSocket', 'EventSource']);
-}
-
-function hasBareCall(line, names) {
-  return names.some((name) => new RegExp(`(?:^|[^\\w$.])${name}\\s*\\(`).test(line));
-}
-
-function hasGlobalPropertyCall(line, names) {
-  return names.some((name) => new RegExp(`\\b(?:window|globalThis|self)\\s*\\.\\s*${name}\\s*\\(`).test(line));
-}
-
 function hasRuntimeAssignment(line) {
   const text = String(line ?? '');
   for (let index = 0; index < text.length; index += 1) {
     if (text[index] !== '=' || !isPlainAssignmentOperator(text, index)) continue;
-    if (!isLocalDeclarationInitializer(text, index)) return true;
+    if (!isLocalDeclarationInitializer(text, index) && !isJsxAttributeInitializer(text, index)) return true;
   }
   return false;
 }
@@ -237,6 +219,8 @@ function isLocalDeclarationInitializer(text, index) {
     || /^(?:export\s+)?type\s+[A-Za-z_$][\w$]*(?:\s*<[^>]+>)?\s*$/.test(statement);
 }
 
+function isJsxAttributeInitializer(text, index) { const before = text.slice(0, index); const open = before.lastIndexOf('<'); return open >= 0 && before.lastIndexOf('>') < open && /<[A-Za-z][^<>{}]*\s[A-Za-z_$][\w:.-]*\s*$/.test(before.slice(open)); }
+
 function addFactRecord(input, documentId, declaration, predicate, factKind, lineNumber, records) {
   const key = `${declaration.symbolId}|${predicate}|${factKind}|${lineNumber}`;
   if (records.seen.has(key)) return;
@@ -280,7 +264,9 @@ function addDependencyRecord(input, documentId, caller, target, occurrence, reco
       confidence: 'lexical-reference',
       sourceDocumentId: documentId,
       sourceName: caller.name,
-      targetName: target.name
+      targetName: target.name,
+      occurrenceId,
+      sourceSpan: span
     }
   });
   records.occurrences.push({
@@ -306,5 +292,6 @@ function addDependencyRecord(input, documentId, caller, target, occurrence, reco
 }
 
 function isCallReference(line, afterIdentifierIndex) {
-  return /^\s*\(/.test(String(line ?? '').slice(afterIdentifierIndex));
+  const rest = String(line ?? '').slice(afterIdentifierIndex);
+  return /^\s*(?:\(|\?\.\s*\(|\?\.\s*(?:[A-Za-z_$][\w$]*|\[[^\]]+\])(?:\s*(?:\.|\?\.)\s*(?:[A-Za-z_$][\w$]*|\[[^\]]+\]))*\s*(?:\?\.)?\s*\()/.test(rest);
 }

package/dist/native-region-scanner-core.js

@@ -8,7 +8,7 @@ function nativeDeclaration(input, lineNumber, languageKind, symbolKind, name, fi
     languageKind: `${input.language}.${languageKind}`,
     name,
     symbolKind,
-    symbolId: `symbol:${input.language}:${idFragment(name)}`,
+    symbolId: options.symbolId ?? `symbol:${input.language}:${idFragment(name)}`,
     span: options.span ?? spanForLine(input, lineNumber),
     fields,
     metadata: { scan: 'lightweight-declaration', hasBody, ...options.metadata },
@@ -18,6 +18,22 @@ function nativeDeclaration(input, lineNumber, languageKind, symbolKind, name, fi
   };
 }
 
+function nativeSignatureDeclaration(input, lineNumber, languageKind, symbolKind, name, fields = {}, _hasBody = false, options = {}) {
+  const signatureParts = [name, fields.signature, fields.returnType, fields.valueType, ...(fields.parameters ?? [])];
+  const signatureKey = idFragment(signatureParts.filter(Boolean).join(':') || `${name}:${lineNumber}`);
+  const sourcePath = input.sourcePath ?? `${input.language}:memory`;
+  const regionKind = options.regionKind ?? 'declaration';
+  return nativeDeclaration(input, lineNumber, languageKind, symbolKind, name, fields, false, {
+    regionKind,
+    symbolId: options.symbolId ?? `symbol:${input.language}:signature:${idFragment(name)}:${signatureKey}`,
+    metadata: {
+      signatureOnly: true,
+      ownershipRegionKey: options.ownershipRegionKey ?? `source#${sourcePath}#${regionKind}#${name}#${signatureKey}`,
+      ...options.metadata
+    }
+  });
+}
+
 function nativeImportDeclaration(input, lineNumber, importPath, languageKind, symbolKind, options = {}) {
   const name = String(options.name ?? importPath);
   const nodeId = `native_${idFragment(languageKind)}_${lineNumber}_${idFragment(name)}`;
@@ -65,6 +81,20 @@ function nativeImportBindingDeclaration(input, lineNumber, importPath, binding,
   });
 }
 
+function nativeExportDeclaration(input, lineNumber, exportedName, languageKind = 'ExportDeclaration', fields = {}, options = {}) {
+  const name = String(options.name ?? exportedName ?? 'default');
+  return nativeDeclaration(input, lineNumber, languageKind, options.symbolKind ?? 'export', name, {
+    exportedName: String(exportedName ?? name),
+    ...fields
+  }, false, {
+    role: options.role ?? 'export',
+    regionKind: options.regionKind ?? 'export',
+    span: options.span,
+    symbolId: options.symbolId ?? `symbol:${input.language}:export:${idFragment(name)}`,
+    metadata: { scan: 'lightweight-export', ...options.metadata }
+  });
+}
+
 function nativeMacroLoss(input, lineNumber, source, kind, name = idFragment(source).slice(0, 40)) {
   const nodeId = `native_${kind}_${lineNumber}_${idFragment(name)}`;
   return {
@@ -202,9 +232,11 @@ export {
   jsControlKeyword,
   lightweightCoverageLosses,
   nativeDeclaration,
+  nativeExportDeclaration,
   nativeImportDeclaration,
   nativeImportBindingDeclaration,
   nativeMacroLoss,
+  nativeSignatureDeclaration,
   sourceLines,
   splitParameters,
   splitTypeParameters

package/dist/native-region-scanner-csharp.js

@@ -0,0 +1,151 @@
+import { uniqueStrings, upperFirst } from './native-import-utils.js';
+import { nativeDeclaration, nativeImportDeclaration, sourceLines, splitParameters } from './native-region-scanner-core.js';
+import { braceBlockSpan } from './native-region-scanner-spans.js';
+
+function scanCSharp(input) {
+  const declarations = [];
+  const lines = sourceLines(input.sourceText);
+  const blockStack = [];
+  let braceDepth = 0;
+  for (const [index, { line, number }] of lines.entries()) {
+    const trimmed = line.trim();
+    const lineStartDepth = depthAfterLeadingClosers(trimmed, braceDepth);
+    while (blockStack.length && blockStack[blockStack.length - 1].bodyDepth > lineStartDepth) blockStack.pop();
+
+    let match;
+    if ((match = trimmed.match(/^using\s+([A-Za-z_]\w*)\s*=\s*(.+?)\s*;/))) {
+      declarations.push(nativeDeclaration(input, number, 'UsingAliasDirective', 'type', match[1], { target: match[2].trim() }, false));
+    } else if ((match = trimmed.match(/^using\s+(?:static\s+)?([A-Za-z_][\w.]*)\s*;/))) {
+      declarations.push(nativeImportDeclaration(input, number, match[1], 'UsingDirective', 'namespace'));
+    } else if ((match = trimmed.match(/^namespace\s+([A-Za-z_][\w.]*)/))) {
+      const hasBody = trimmed.includes('{');
+      declarations.push(nativeDeclaration(input, number, 'NamespaceDeclaration', 'namespace', match[1], {}, hasBody, spanOptions(input, lines, index, hasBody)));
+      if (hasBody) blockStack.push({ kind: 'namespace', name: match[1], bodyDepth: braceDepth + 1 });
+    } else if ((match = trimmed.match(/^((?:(?:public|protected|private|internal|static|unsafe|new)\s+)*)delegate\s+(.+?)\s+([A-Za-z_]\w*)\s*\(([^)]*)\)\s*;/))) {
+      declarations.push(nativeDeclaration(input, number, 'DelegateDeclaration', 'type', match[3], {
+        returnType: match[2].trim(),
+        parameters: splitParameters(match[4]),
+        modifiers: csharpModifiers(match[1])
+      }, false));
+    } else if ((match = trimmed.match(/^((?:(?:public|protected|private|internal|abstract|sealed|static|partial|readonly|ref|unsafe)\s+)*)(class|interface|struct|enum|record(?:\s+(?:class|struct))?)\s+([A-Za-z_]\w*)/))) {
+      const owner = nearestType(blockStack);
+      const name = owner ? `${owner.name}.${match[3]}` : match[3];
+      const hasBody = trimmed.includes('{');
+      declarations.push(nativeDeclaration(input, number, csharpDeclarationKind(match[2]), csharpSymbolKind(match[2]), name, {
+        csharpKind: match[2].replace(/\s+/g, ' '),
+        modifiers: csharpModifiers(match[1]),
+        ...(owner ? { owner: owner.name } : {})
+      }, hasBody, spanOptions(input, lines, index, hasBody)));
+      if (hasBody) blockStack.push({ kind: csharpTypeStackKind(match[2]), name, bodyDepth: braceDepth + 1 });
+    } else if ((match = trimmed.match(/^((?:(?:public|protected|private|internal|static|virtual|override|async|partial|sealed|abstract|extern|new|unsafe|readonly)\s+)*)(?:[A-Za-z_][\w<>\[\].?,\s]*\??|void)\s+([A-Za-z_]\w*)\s*\(([^)]*)\)\s*(?:=>.*|\{.*|;)?$/))) {
+      const parameters = splitParameters(match[3]);
+      const owner = nearestType(blockStack);
+      const extensionReceiver = csharpExtensionReceiver(parameters);
+      const target = csharpMethodTarget(owner, match[1], match[2], extensionReceiver);
+      const hasBody = trimmed.includes('{') || trimmed.includes('=>');
+      declarations.push(nativeDeclaration(input, number, extensionReceiver ? 'ExtensionMethodDeclaration' : 'MethodDeclaration', target.owner ? 'method' : 'function', target.name, {
+        parameters,
+        methodName: match[2],
+        modifiers: csharpModifiers(match[1]),
+        ...(target.owner ? { owner: target.owner, receiverKind: target.receiverKind } : {}),
+        ...(extensionReceiver ? { extensionReceiver } : {})
+      }, hasBody, {
+        ...spanOptions(input, lines, index, trimmed.includes('{')),
+        metadata: {
+          methodName: match[2],
+          modifiers: csharpModifiers(match[1]),
+          ...(target.owner ? { owner: target.owner, receiverKind: target.receiverKind } : {}),
+          ...(extensionReceiver ? { extensionReceiver } : {})
+        }
+      }));
+      if (trimmed.includes('{')) blockStack.push({ kind: 'method', name: target.name, bodyDepth: braceDepth + 1 });
+    } else if ((match = trimmed.match(/^((?:(?:public|protected|private|internal|static|virtual|override|abstract|sealed|new|unsafe)\s+)*)event\s+(.+?)\s+([A-Za-z_]\w*)\s*(?:[;{=]|=>)/))) {
+      const owner = nearestType(blockStack);
+      const name = owner ? `${owner.name}.${match[3]}` : match[3];
+      declarations.push(nativeDeclaration(input, number, 'EventDeclaration', 'event', name, {
+        eventType: match[2].trim(),
+        accessors: csharpAccessors(trimmed),
+        modifiers: csharpModifiers(match[1]),
+        ...(owner ? { owner: owner.name, eventName: match[3] } : {})
+      }, trimmed.includes('{'), spanOptions(input, lines, index, trimmed.includes('{'))));
+    } else if ((match = trimmed.match(/^((?:(?:public|protected|private|internal|static|virtual|override|abstract|sealed|new|required|readonly|unsafe)\s+)*)([A-Za-z_][\w<>\[\].?,\s]*\??)\s+([A-Za-z_]\w*)\s*(?:\{|=>)/))) {
+      const owner = nearestType(blockStack);
+      const name = owner ? `${owner.name}.${match[3]}` : match[3];
+      declarations.push(nativeDeclaration(input, number, 'PropertyDeclaration', 'property', name, {
+        propertyType: match[2].trim(),
+        accessors: csharpAccessors(trimmed),
+        modifiers: csharpModifiers(match[1]),
+        ...(owner ? { owner: owner.name, propertyName: match[3] } : {})
+      }, trimmed.includes('{') || trimmed.includes('=>'), spanOptions(input, lines, index, trimmed.includes('{'))));
+    }
+    braceDepth = Math.max(0, braceDepth + braceDelta(line));
+  }
+  return declarations;
+}
+
+function spanOptions(input, lines, index, hasBraceBody) {
+  return hasBraceBody ? { span: braceBlockSpan(input, lines, index) } : {};
+}
+
+function depthAfterLeadingClosers(trimmed, depth) {
+  const closers = String(trimmed).match(/^}+/)?.[0].length ?? 0;
+  return Math.max(0, depth - closers);
+}
+
+function nearestType(blockStack) {
+  for (let index = blockStack.length - 1; index >= 0; index -= 1) {
+    if (blockStack[index].kind === 'method') return undefined;
+    if (['class', 'interface', 'struct', 'record'].includes(blockStack[index].kind)) return blockStack[index];
+  }
+  return undefined;
+}
+
+function csharpMethodTarget(owner, modifiers, methodName, extensionReceiver) {
+  if (extensionReceiver) return { name: `${extensionReceiver.type}.extension.${methodName}`, owner: extensionReceiver.type, receiverKind: 'extension' };
+  if (!owner) return { name: methodName };
+  const receiverKind = /\bstatic\b/.test(modifiers) ? 'static' : 'member';
+  return { name: receiverKind === 'static' ? `${owner.name}.static.${methodName}` : `${owner.name}.${methodName}`, owner: owner.name, receiverKind };
+}
+
+function csharpModifiers(raw) {
+  return splitParameters(String(raw ?? '').trim().replace(/\s+/g, ','));
+}
+
+function csharpTypeStackKind(kind) {
+  const normalized = String(kind).replace(/\s+/g, ' ');
+  if (normalized.startsWith('record')) return 'record';
+  if (normalized === 'enum') return 'enum';
+  if (normalized === 'struct') return 'struct';
+  if (normalized === 'interface') return 'interface';
+  return 'class';
+}
+
+function csharpSymbolKind(kind) {
+  const normalized = String(kind).replace(/\s+/g, ' ');
+  if (normalized === 'interface') return 'interface';
+  if (normalized === 'struct' || normalized === 'enum' || normalized.startsWith('record')) return 'type';
+  return 'class';
+}
+
+function csharpDeclarationKind(kind) {
+  const normalized = String(kind).replace(/\s+/g, ' ');
+  if (normalized === 'record struct') return 'RecordStructDeclaration';
+  if (normalized === 'record class') return 'RecordClassDeclaration';
+  if (normalized === 'record') return 'RecordDeclaration';
+  return `${upperFirst(normalized)}Declaration`;
+}
+
+function csharpExtensionReceiver(parameters) {
+  const match = String(parameters?.[0] ?? '').match(/^this\s+(.+?)\s+([A-Za-z_]\w*)$/);
+  return match ? { type: match[1].trim(), name: match[2] } : undefined;
+}
+
+function csharpAccessors(source) {
+  return uniqueStrings([...String(source ?? '').matchAll(/\b(get|set|init|add|remove)\b/g)].map((match) => match[1]));
+}
+
+function braceDelta(source) {
+  return [...String(source ?? '')].reduce((delta, char) => delta + (char === '{' ? 1 : char === '}' ? -1 : 0), 0);
+}
+
+export { scanCSharp };

package/dist/native-region-scanner-dart.js

@@ -0,0 +1,91 @@
+import { upperFirst } from './native-import-utils.js';
+import { nativeDeclaration, nativeImportDeclaration, sourceLines, splitParameters } from './native-region-scanner-core.js';
+import { braceBlockSpan } from './native-region-scanner-spans.js';
+
+function scanDart(input) {
+  const declarations = [];
+  const lines = sourceLines(input.sourceText);
+  const blockStack = [];
+  let braceDepth = 0;
+  for (const [index, { line, number }] of lines.entries()) {
+    const trimmed = line.trim();
+    const lineStartDepth = depthAfterLeadingClosers(trimmed, braceDepth);
+    while (blockStack.length && blockStack[blockStack.length - 1].bodyDepth > lineStartDepth) blockStack.pop();
+
+    let match;
+    if ((match = trimmed.match(/^(?:import|export)\s+['"]([^'"]+)['"]/))) {
+      declarations.push(nativeImportDeclaration(input, number, match[1], 'UriBasedDirective', 'library'));
+    } else if ((match = trimmed.match(/^part\s+['"]([^'"]+)['"]/))) {
+      declarations.push(nativeImportDeclaration(input, number, match[1], 'PartDirective', 'library'));
+    } else if ((match = trimmed.match(/^(?:(?:abstract|base|final|interface|sealed)\s+)*(class|mixin|enum)\s+([A-Za-z_]\w*)/))) {
+      const hasBody = trimmed.includes('{');
+      declarations.push(nativeDeclaration(input, number, `${upperFirst(match[1])}Declaration`, dartSymbolKind(match[1]), match[2], {}, hasBody, spanOptions(input, lines, index, hasBody)));
+      if (hasBody) blockStack.push({ kind: match[1], name: match[2], bodyDepth: braceDepth + 1 });
+    } else if ((match = trimmed.match(/^extension(?:\s+([A-Za-z_]\w*))?\s+on\s+([A-Za-z_]\w*(?:<[^>]+>)?)\s*\{/))) {
+      const name = match[1] ? `${match[1]}.extension` : `${match[2]}.extension`;
+      declarations.push(nativeDeclaration(input, number, 'ExtensionDeclaration', 'implementation', name, {
+        receiverType: match[2],
+        ...(match[1] ? { extensionName: match[1] } : {})
+      }, true, spanOptions(input, lines, index, true)));
+      blockStack.push({ kind: 'extension', name, receiverType: match[2], bodyDepth: braceDepth + 1 });
+    } else if ((match = trimmed.match(/^typedef\s+([A-Za-z_]\w*)\b/))) {
+      declarations.push(nativeDeclaration(input, number, 'TypeAlias', 'type', match[1], {}, false));
+    } else if ((match = trimmed.match(/^((?:(?:external|static)\s+)*)(?:[A-Za-z_]\w*(?:<[^>]+>)?\??|void)\s+([A-Za-z_]\w*)\s*\(([^)]*)\)\s*(?:async\s*)?(?:\{|=>|;)/))) {
+      const owner = nearestContainer(blockStack);
+      const target = dartFunctionTarget(owner, match[1], match[2]);
+      const hasBraceBody = trimmed.includes('{');
+      declarations.push(nativeDeclaration(input, number, 'FunctionDeclaration', target.owner ? 'method' : 'function', target.name, {
+        parameters: splitParameters(match[3]),
+        ...(target.owner ? { owner: target.owner, methodName: match[2], receiverKind: target.receiverKind } : {}),
+        ...(owner?.receiverType ? { receiverType: owner.receiverType } : {})
+      }, hasBraceBody || trimmed.includes('=>'), {
+        ...spanOptions(input, lines, index, hasBraceBody),
+        metadata: {
+          ...(target.owner ? { owner: target.owner, methodName: match[2], receiverKind: target.receiverKind } : {}),
+          ...(owner?.receiverType ? { receiverType: owner.receiverType } : {})
+        }
+      }));
+      if (hasBraceBody) blockStack.push({ kind: 'function', name: target.name, bodyDepth: braceDepth + 1 });
+    } else if ((match = trimmed.match(/^(?:(?:static|external|late)\s+)*(?:const|final|var)\s+(?:[A-Za-z_]\w*(?:<[^>]+>)?\??\s+)?([A-Za-z_]\w*)\b/))) {
+      declarations.push(nativeDeclaration(input, number, 'VariableDeclaration', 'variable', match[1], {}, false));
+    }
+    braceDepth = Math.max(0, braceDepth + braceDelta(line));
+  }
+  return declarations;
+}
+
+function spanOptions(input, lines, index, hasBraceBody) {
+  return hasBraceBody ? { span: braceBlockSpan(input, lines, index) } : {};
+}
+
+function depthAfterLeadingClosers(trimmed, depth) {
+  const closers = String(trimmed).match(/^}+/)?.[0].length ?? 0;
+  return Math.max(0, depth - closers);
+}
+
+function nearestContainer(blockStack) {
+  for (let index = blockStack.length - 1; index >= 0; index -= 1) {
+    if (blockStack[index].kind === 'function') return undefined;
+    if (['class', 'mixin', 'enum', 'extension'].includes(blockStack[index].kind)) return blockStack[index];
+  }
+  return undefined;
+}
+
+function dartFunctionTarget(owner, modifiers, methodName) {
+  if (!owner) return { name: methodName };
+  if (owner.kind === 'extension') return { name: `${owner.name}.${methodName}`, owner: owner.name, receiverKind: 'extension' };
+  const receiverKind = /\bstatic\b/.test(modifiers) ? 'static' : 'member';
+  return { name: receiverKind === 'static' ? `${owner.name}.static.${methodName}` : `${owner.name}.${methodName}`, owner: owner.name, receiverKind };
+}
+
+function braceDelta(source) {
+  return [...String(source ?? '')].reduce((delta, char) => delta + (char === '{' ? 1 : char === '}' ? -1 : 0), 0);
+}
+
+function dartSymbolKind(kind) {
+  if (kind === 'mixin') return 'trait';
+  if (kind === 'enum') return 'type';
+  return 'class';
+}
+
+export { scanDart };