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

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

@@ -6,17 +6,19 @@ import {
   sourceLines,
   splitParameters
 } from './native-region-scanner-core.js';
+import { braceBlockSpan, endKeywordBlockSpan, pythonBlockSpan, terminatedBlockSpan } from './native-region-scanner-spans.js';
 
 function scanElixir(input) {
   const declarations = [];
   let currentModule;
-  for (const { line, number } of sourceLines(input.sourceText)) {
+  const lines = sourceLines(input.sourceText);
+  for (const [index, { line, number }] of lines.entries()) {
     const trimmed = line.trim();
     let match;
     let recordedMeta = false;
     if ((match = trimmed.match(/^defmodule\s+([A-Z]\w*(?:\.[A-Z]\w*)*)\s+do\b/))) {
       currentModule = match[1];
-      declarations.push(nativeDeclaration(input, number, 'ModuleDefinition', 'module', match[1], {}, true));
+      declarations.push(nativeDeclaration(input, number, 'ModuleDefinition', 'module', match[1], {}, true, endSpanOptions(input, lines, index)));
     } else if ((match = trimmed.match(/^(?:alias|import|require)\s+([A-Z]\w*(?:\.[A-Z]\w*)*)/))) {
       declarations.push(nativeImportDeclaration(input, number, match[1], 'ImportDirective', 'module'));
     } else if ((match = trimmed.match(/^use\s+([A-Z]\w*(?:\.[A-Z]\w*)*)/))) {
@@ -26,7 +28,8 @@ function scanElixir(input) {
       declarations.push(nativeMacroLoss(input, number, trimmed, 'macroExpansion', match[2]));
       recordedMeta = true;
     } else if ((match = trimmed.match(/^defp?\s+([A-Za-z_]\w*[!?]?)\s*(?:\(([^)]*)\)|([^,]*))?/))) {
-      declarations.push(nativeDeclaration(input, number, 'FunctionDefinition', 'function', match[1], { parameters: splitParameters(match[2] ?? match[3]) }, /\bdo\b/.test(trimmed)));
+      const hasDoBlock = /\bdo\b/.test(trimmed);
+      declarations.push(nativeDeclaration(input, number, 'FunctionDefinition', 'function', match[1], { parameters: splitParameters(match[2] ?? match[3]) }, hasDoBlock, hasDoBlock ? endSpanOptions(input, lines, index) : {}));
     } else if (trimmed.startsWith('defstruct')) {
       declarations.push(nativeDeclaration(input, number, 'StructDefinition', 'type', currentModule ?? `struct_${number}`, {}, true));
     } else if ((match = trimmed.match(/^@(type|typep|opaque|callback)\s+([A-Za-z_]\w*[!?]?)/))) {
@@ -39,10 +42,19 @@ function scanElixir(input) {
   return declarations;
 }
 
+function endSpanOptions(input, lines, index) {
+  return { span: endKeywordBlockSpan(input, lines, index) };
+}
+
+function braceSpanOptions(input, lines, index, hasBraceBody) {
+  return hasBraceBody ? { span: braceBlockSpan(input, lines, index) } : {};
+}
+
 function scanErlang(input) {
   const declarations = [];
   const seenFunctions = new Set();
-  for (const { line, number } of sourceLines(input.sourceText)) {
+  const lines = sourceLines(input.sourceText);
+  for (const [index, { line, number }] of lines.entries()) {
     const trimmed = line.trim();
     let match;
     let recordedMacro = false;
@@ -70,7 +82,7 @@ function scanErlang(input) {
       const name = erlangAtomName(match[1]);
       if (!seenFunctions.has(name)) {
         seenFunctions.add(name);
-        declarations.push(nativeDeclaration(input, number, 'FunctionClause', 'function', name, { parameters: splitParameters(match[2]) }, true));
+        declarations.push(nativeDeclaration(input, number, 'FunctionClause', 'function', name, { parameters: splitParameters(match[2]) }, true, { span: terminatedBlockSpan(input, lines, index, /\.\s*$/) }));
       }
     }
     if (!recordedMacro && /(^|[^A-Za-z0-9_])\?[A-Za-z_]\w*/.test(trimmed)) {
@@ -83,7 +95,8 @@ function scanErlang(input) {
 function scanHaskell(input) {
   const declarations = [];
   const seenFunctions = new Set();
-  for (const { line, number } of sourceLines(input.sourceText)) {
+  const lines = sourceLines(input.sourceText);
+  for (const [index, { line, number }] of lines.entries()) {
     const trimmed = line.trim();
     let match;
     if (/^#\s*(?:if|ifdef|ifndef|else|elif|endif|define|include)\b/.test(trimmed)) {
@@ -106,12 +119,15 @@ function scanHaskell(input) {
     } else if ((match = trimmed.match(/^class\s+(?:\([^)]*\)\s*=>\s*)?([A-Z][A-Za-z0-9_']*)\b/))) {
       declarations.push(nativeDeclaration(input, number, 'ClassDeclaration', 'type', match[1], {}, /\bwhere\b/.test(trimmed)));
     } else if ((match = trimmed.match(/^([a-z_][A-Za-z0-9_']*)\s*::\s*(.+)$/))) {
-      seenFunctions.add(match[1]);
-      declarations.push(nativeDeclaration(input, number, 'FunctionSignature', 'function', match[1], { signature: match[2].trim() }, false));
+      declarations.push(nativeDeclaration(input, number, 'FunctionSignature', 'function', match[1], { signature: match[2].trim() }, false, {
+        regionKind: 'declaration',
+        symbolId: `symbol:${input.language}:signature:${idFragment(match[1])}`,
+        metadata: { signatureOnly: true }
+      }));
     } else if ((match = trimmed.match(/^([a-z_][A-Za-z0-9_']*)\b[^=]*=/))) {
       if (!seenFunctions.has(match[1])) {
         seenFunctions.add(match[1]);
-        declarations.push(nativeDeclaration(input, number, 'FunctionBinding', 'function', match[1], {}, true));
+        declarations.push(nativeDeclaration(input, number, 'FunctionBinding', 'function', match[1], {}, true, { span: pythonBlockSpan(input, lines, index) }));
       }
     }
   }
@@ -120,7 +136,8 @@ function scanHaskell(input) {
 
 function scanR(input) {
   const declarations = [];
-  for (const { line, number } of sourceLines(input.sourceText)) {
+  const lines = sourceLines(input.sourceText);
+  for (const [index, { line, number }] of lines.entries()) {
     const trimmed = line.trim();
     let match;
     if ((match = trimmed.match(/^(?:library|require)\s*\(\s*["']?([A-Za-z_][\w.-]*)["']?/))) {
@@ -130,7 +147,7 @@ function scanR(input) {
     } else if ((match = trimmed.match(/^source\s*\(\s*["']([^"']+)["']/))) {
       declarations.push(nativeImportDeclaration(input, number, match[1], 'SourceCall', 'module'));
     } else if ((match = trimmed.match(/^([A-Za-z_][\w.]*)\s*(?:<-|=)\s*function\s*\(([^)]*)\)/))) {
-      declarations.push(nativeDeclaration(input, number, 'FunctionAssignment', 'function', match[1], { parameters: splitParameters(match[2]) }, trimmed.includes('{')));
+      declarations.push(nativeDeclaration(input, number, 'FunctionAssignment', 'function', match[1], { parameters: splitParameters(match[2]) }, trimmed.includes('{'), braceSpanOptions(input, lines, index, trimmed.includes('{'))));
     } else if ((match = trimmed.match(/^([A-Za-z_][\w.]*)\s*<-\s*R6Class\s*\(\s*["']([^"']+)["']/))) {
       declarations.push(nativeDeclaration(input, number, 'R6ClassDeclaration', 'class', match[2] || match[1], { binding: match[1] }, true));
       declarations.push(nativeMacroLoss(input, number, trimmed, 'dynamicRuntime', match[2] || match[1]));
@@ -154,9 +171,19 @@ function scanR(input) {
 }
 
 function scanGenericDeclarations(input) {
-  return sourceLines(input.sourceText)
+  const lines = sourceLines(input.sourceText);
+  return lines
+    .map(({ line, number }, index) => ({ line, number, index }))
     .filter(({ line }) => /\b(function|class|struct|enum|trait|interface|def)\b/.test(line))
-    .map(({ line, number }) => nativeDeclaration(input, number, 'NativeDeclaration', 'variable', idFragment(line.trim()).slice(0, 40), { source: line.trim() }, true));
+    .map(({ line, number, index }) => nativeDeclaration(input, number, 'NativeDeclaration', 'variable', idFragment(line.trim()).slice(0, 40), { source: line.trim() }, true, genericSpanOptions(input, lines, index)));
+}
+
+function genericSpanOptions(input, lines, index) {
+  const line = lines[index]?.line.trim() ?? '';
+  if (line.includes('{')) return { span: braceBlockSpan(input, lines, index) };
+  if (/\b(?:class|module|def|function)\b/.test(line)) return { span: endKeywordBlockSpan(input, lines, index) };
+  if (/:\s*$/.test(line)) return { span: pythonBlockSpan(input, lines, index) };
+  return {};
 }
 
 function elixirMetaName(source) {

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

@@ -0,0 +1,97 @@
+import { upperFirst } from './native-import-utils.js';
+import { nativeDeclaration, nativeImportDeclaration, sourceLines, splitParameters, splitTypeParameters } from './native-region-scanner-core.js';
+import { braceBlockSpan } from './native-region-scanner-spans.js';
+
+function scanJava(input) {
+  const declarations = [];
+  const blockStack = [];
+  const lines = sourceLines(input.sourceText);
+  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(/^package\s+([A-Za-z_][\w.]*);/))) {
+      declarations.push(nativeDeclaration(input, number, 'PackageDeclaration', 'package', match[1], {}, false));
+    } else if ((match = trimmed.match(/^import\s+(?:static\s+)?([A-Za-z_][\w.*]*);/))) {
+      declarations.push(nativeImportDeclaration(input, number, match[1], 'ImportDeclaration', 'package'));
+    } else if ((match = trimmed.match(/^((?:(?:public|protected|private|abstract|final|static|sealed|non-sealed)\s+)*)(class|interface|enum|record|@interface)\s+([A-Za-z_$][\w$]*)/))) {
+      const owner = nearestType(blockStack);
+      const name = owner ? `${owner.name}.${match[3]}` : match[3];
+      const kind = match[2] === '@interface' ? 'AnnotationDeclaration' : `${upperFirst(match[2])}Declaration`;
+      const hasBody = trimmed.includes('{');
+      declarations.push(nativeDeclaration(input, number, kind, javaSymbolKind(match[2]), name, {
+        modifiers: javaModifiers(match[1]),
+        ...(owner ? { owner: owner.name } : {})
+      }, hasBody, spanOptions(input, lines, index, hasBody)));
+      if (hasBody) blockStack.push({ kind: javaTypeStackKind(match[2]), name, bodyDepth: braceDepth + 1 });
+    } else if ((match = trimmed.match(/^((?:(?:public|protected|private|abstract|final|static|synchronized|native)\s+)*)(?:<([^>]+)>\s+)?[A-Za-z_$][\w$<>\[\].?,\s]*\s+([A-Za-z_$][\w$]*)\s*\(([^)]*)\)\s*(?:throws\s+[^{]+)?(?:\{.*|;)?$/))) {
+      const owner = nearestType(blockStack);
+      const target = javaMethodTarget(owner, match[1], match[3]);
+      const hasBody = trimmed.includes('{');
+      declarations.push(nativeDeclaration(input, number, 'MethodDeclaration', target.owner ? 'method' : 'function', target.name, {
+        methodName: match[3],
+        modifiers: javaModifiers(match[1]),
+        typeParameters: splitTypeParameters(match[2]),
+        parameters: splitParameters(match[4]),
+        ...(target.owner ? { owner: target.owner, receiverKind: target.receiverKind } : {})
+      }, hasBody, {
+        ...spanOptions(input, lines, index, hasBody),
+        metadata: {
+          methodName: match[3],
+          modifiers: javaModifiers(match[1]),
+          ...(target.owner ? { owner: target.owner, receiverKind: target.receiverKind } : {})
+        }
+      }));
+      if (hasBody) blockStack.push({ kind: 'method', name: target.name, bodyDepth: braceDepth + 1 });
+    }
+    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', 'enum', 'record', 'annotation'].includes(blockStack[index].kind)) return blockStack[index];
+  }
+  return undefined;
+}
+
+function javaMethodTarget(owner, modifiers, methodName) {
+  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 javaModifiers(raw) {
+  return splitParameters(String(raw ?? '').trim().replace(/\s+/g, ','));
+}
+
+function javaTypeStackKind(kind) {
+  if (kind === '@interface') return 'annotation';
+  return String(kind).replace(/\s+/g, ' ');
+}
+
+function braceDelta(source) {
+  return [...String(source ?? '')].reduce((delta, char) => delta + (char === '{' ? 1 : char === '}' ? -1 : 0), 0);
+}
+
+function javaSymbolKind(kind) {
+  if (kind === 'interface' || kind === '@interface') return 'interface';
+  if (kind === 'enum' || kind === 'record') return 'type';
+  return 'class';
+}
+
+export { scanJava };

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

@@ -0,0 +1,100 @@
+import { jsControlKeyword, nativeDeclaration, nativeSignatureDeclaration, splitParameters } from './native-region-scanner-core.js';
+import { jsInitializerKind, jsVariableHasBody } from './native-region-scanner-js-helpers.js';
+
+function jsClassMemberDeclaration(input, lineNumber, declarationLine, className) {
+  const method = jsClassMethodMatch(declarationLine);
+  if (method && !jsControlKeyword(method.name)) return jsClassMethodDeclaration(input, lineNumber, method, className);
+  const property = jsClassPropertyMatch(declarationLine);
+  if (!property || jsControlKeyword(property.name)) return undefined;
+  return jsClassPropertyDeclaration(input, lineNumber, property, className);
+}
+
+function jsInlineClassMemberDeclarations(input, lineNumber, declarationLine, className) {
+  const open = declarationLine.indexOf('{');
+  const close = declarationLine.lastIndexOf('}');
+  if (open < 0 || close <= open) return [];
+  const body = declarationLine.slice(open + 1, close);
+  const declarations = [];
+  const pattern = /((?:(?:public|private|protected|static|async|override|readonly|abstract|accessor|get|set)\s+)*)(?:async\s+)?(?:get\s+|set\s+)?(#?[A-Za-z_$][\w$]*)\??\s*(?:<[^({;]+>)?\s*\(([^)]*)\)\s*(?::\s*[^={;]+)?\s*(?:\{|=>)/g;
+  for (const match of body.matchAll(pattern)) {
+    const method = { modifiers: match[1], name: match[2], parameters: match[3], source: match[0] };
+    if (!jsControlKeyword(method.name)) declarations.push(jsClassMethodDeclaration(input, lineNumber, method, className));
+  }
+  return declarations;
+}
+
+function jsClassMethodMatch(declarationLine) {
+  const match = declarationLine.match(/^((?:(?:public|private|protected|static|async|override|readonly|abstract|accessor|get|set)\s+)*)(?:async\s+)?(?:get\s+|set\s+)?(#?[A-Za-z_$][\w$]*)\??\s*(?:<[^({;]+>)?\s*\(([^)]*)\)\s*(?::\s*[^={]+)?(?:\{|=>|$)/);
+  if (!match) return undefined;
+  return { modifiers: match[1], name: match[2], parameters: match[3], source: declarationLine };
+}
+
+function jsClassPropertyMatch(declarationLine) {
+  const match = declarationLine.match(/^((?:(?:public|private|protected|static|readonly|declare|accessor)\s+)*)(#?[A-Za-z_$][\w$]*)[?!]?\s*(?::\s*([^=;{]+))?(?:[=;]|$)/);
+  if (!match) return undefined;
+  return { modifiers: match[1], name: match[2], source: declarationLine, valueType: match[3]?.trim() };
+}
+
+function jsClassMethodDeclaration(input, lineNumber, method, className) {
+  const target = jsClassMemberTarget(className, method.modifiers, method.name);
+  const hasBody = String(method.source ?? '').includes('{') || String(method.source ?? '').includes('=>');
+  return (hasBody ? nativeDeclaration : nativeSignatureDeclaration)(input, lineNumber, 'MethodDefinition', 'method', target.name, {
+    methodName: method.name,
+    owner: className,
+    receiverKind: target.receiverKind,
+    accessorKind: jsAccessorKind(method.modifiers),
+    modifiers: jsModifiers(method.modifiers),
+    parameters: splitParameters(method.parameters)
+  }, hasBody, { metadata: jsClassMemberMetadata(className, target, method.name, method.modifiers) });
+}
+
+function jsClassPropertyDeclaration(input, lineNumber, property, className) {
+  const initializerKind = jsInitializerKind(property.source ?? '', property.name);
+  const hasBody = jsVariableHasBody(initializerKind, property.source ?? '');
+  const target = jsClassMemberTarget(className, property.modifiers, property.name);
+  return nativeDeclaration(input, lineNumber, 'PropertyDefinition', initializerKind === 'function' ? 'function' : 'property', target.name, {
+    propertyName: property.name,
+    owner: className,
+    receiverKind: target.receiverKind,
+    valueType: property.valueType,
+    initializerKind,
+    modifiers: jsModifiers(property.modifiers)
+  }, hasBody, {
+    regionKind: initializerKind === 'function' ? 'body' : 'property',
+    metadata: {
+      initializerKind,
+      ...jsClassMemberMetadata(className, target, property.name, property.modifiers)
+    }
+  });
+}
+
+function jsClassMemberTarget(className, modifiers, memberName) {
+  const receiverKind = /\bstatic\b/.test(modifiers) ? 'static' : 'member';
+  return {
+    name: receiverKind === 'static' ? `${className}.static.${memberName}` : `${className}.${memberName}`,
+    receiverKind
+  };
+}
+
+function jsClassMemberMetadata(owner, target, memberName, modifiers) {
+  return {
+    owner,
+    receiverKind: target.receiverKind,
+    propertyName: memberName,
+    methodName: memberName,
+    modifiers: jsModifiers(modifiers),
+    accessorKind: jsAccessorKind(modifiers)
+  };
+}
+
+function jsAccessorKind(modifiers) {
+  if (/\bget\b/.test(modifiers)) return 'get';
+  if (/\bset\b/.test(modifiers)) return 'set';
+  return undefined;
+}
+
+function jsModifiers(raw) {
+  return String(raw ?? '').trim().split(/\s+/).filter(Boolean);
+}
+
+export { jsClassMemberDeclaration, jsInlineClassMemberDeclarations };

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

@@ -1,9 +1,8 @@
 import {
-  jsControlKeyword,
   nativeDeclaration,
   splitParameters
 } from './native-region-scanner-core.js';
-import { jsImportDeclarations } from './native-region-scanner-js-imports.js';
+import { jsExportDeclarations, jsImportDeclarations } from './native-region-scanner-js-imports.js';
 function jsCommentOnlyLine(trimmed) {
   return trimmed.startsWith('//') || trimmed.startsWith('/*') || trimmed.startsWith('*');
 }
@@ -71,13 +70,8 @@ function jsObjectRegionContext(name, declarationLine, lineNumber, regionKind) {
   if (initializerKind !== 'object' && initializerKind !== 'array') return undefined;
   const depth = jsContainerDelta(declarationLine);
   if (depth <= 0) return undefined;
-  return {
-    name,
-    regionKind: regionKind ?? jsRegionKindForDeclarationName(name, declarationLine),
-    initializerKind,
-    depth,
-    startLine: lineNumber
-  };
+  return { name, regionKind: regionKind ?? jsRegionKindForDeclarationName(name, declarationLine), initializerKind, depth, startLine: lineNumber,
+    arrayRecords: initializerKind === 'array' && /(?:define|create|make|build)\w*(?:tools?|actions?|handlers?|commands?|events?|effects?|workflows?)/i.test(declarationLine) };
 }
 
 function jsInitializerKind(line, name) {
@@ -127,15 +121,17 @@ function jsExportedContainerDeclaration(input, lineNumber, trimmed) {
 }
 
 function jsExportedFunctionWrapperDeclaration(input, lineNumber, trimmed) {
-  const match = trimmed.match(/^export\s+default\s+((?:React\.)?(?:forwardRef|memo|lazy|observer)|Object\.freeze)\s*(?:<[^>]+>)?\s*\(\s*(.+)$/);
+  const match = trimmed.match(/^export\s+default\s+(.+)$/);
   if (!match) return undefined;
-  const wrapper = match[1];
-  const argument = match[2].trim();
+  const unwrapped = jsUnwrapFunctionWrapperArgument(match[1]);
+  if (!unwrapped) return undefined;
+  const { wrapper, wrappers, argument } = unwrapped;
+  const wrapperFields = { wrapper, ...(wrappers.length > 1 ? { wrappers } : {}) };
   let functionMatch = argument.match(/^(?:async\s+)?function\*?\s*([A-Za-z_$][\w$]*)?\s*(?:<[^({;]+>)?\s*\(([^)]*)\)/);
   if (functionMatch) {
     return nativeDeclaration(input, lineNumber, 'ExportDefaultFunctionWrapperDeclaration', 'function', functionMatch[1] ?? 'default', {
       exportDefault: true,
-      wrapper,
+      ...wrapperFields,
       parameters: splitParameters(functionMatch[2])
     }, true);
   }
@@ -143,7 +139,7 @@ function jsExportedFunctionWrapperDeclaration(input, lineNumber, trimmed) {
   if (functionMatch) {
     return nativeDeclaration(input, lineNumber, 'ExportDefaultFunctionWrapperDeclaration', 'function', 'default', {
       exportDefault: true,
-      wrapper,
+      ...wrapperFields,
       parameters: splitParameters(functionMatch[1] ?? functionMatch[2])
     }, true);
   }
@@ -151,21 +147,33 @@ function jsExportedFunctionWrapperDeclaration(input, lineNumber, trimmed) {
   if (classMatch) {
     return nativeDeclaration(input, lineNumber, 'ExportDefaultClassWrapperDeclaration', 'class', classMatch[1] ?? 'default', {
       exportDefault: true,
-      wrapper
+      ...wrapperFields
     }, true);
   }
   const aliasMatch = argument.match(/^([A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*)*)\s*(?:[,)]|$)/);
   if (!aliasMatch) return undefined;
   return nativeDeclaration(input, lineNumber, 'ExportDefaultWrappedAlias', 'variable', 'default', {
     exportDefault: true,
-    wrapper,
+    ...wrapperFields,
     alias: aliasMatch[1],
     initializerKind: 'function-wrapper'
   }, false, {
-    metadata: { exportDefault: true, wrapper, alias: aliasMatch[1], initializerKind: 'function-wrapper' }
+    metadata: { exportDefault: true, ...wrapperFields, alias: aliasMatch[1], initializerKind: 'function-wrapper' }
   });
 }
 
+function jsUnwrapFunctionWrapperArgument(source) {
+  const wrappers = [];
+  let argument = String(source ?? '').trim();
+  let match;
+  while ((match = argument.match(/^((?:React\.)?(?:forwardRef|memo|lazy|observer)|Object\.freeze)\s*(?:<[^>]+>)?\s*\(\s*(.+)$/))) {
+    wrappers.push(match[1]);
+    argument = match[2].trim();
+  }
+  if (!wrappers.length) return undefined;
+  return { wrapper: wrappers[0], wrappers, argument };
+}
+
 function jsExportAliasDeclaration(input, lineNumber, trimmed) {
   let match = trimmed.match(/^export\s+default\s+([A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*)*)\s*;?$/);
   if (match) return jsAliasExport(input, lineNumber, 'ExportDefaultAlias', 'default', match[1], { exportDefault: true }, trimmed);
@@ -202,72 +210,6 @@ function jsContainerExport(input, lineNumber, languageKind, name, initializer, f
   return { declaration, context };
 }
 
-function jsObjectPropertyDeclaration(input, lineNumber, trimmed, context) {
-  if (/^[}\])]/.test(trimmed) || trimmed.startsWith('...')) return undefined;
-  const methodMatch = trimmed.match(/^(?:(?:async|get|set)\s+)?(['"]?)([A-Za-z_$][\w$-]*)\1\s*\(([^)]*)\)\s*(?:[:\w\s<>\[\]]*)?(?:\{|=>|,|$)/);
-  if (methodMatch && !jsControlKeyword(methodMatch[2])) {
-    const name = `${context.name}.${methodMatch[2]}`;
-    return nativeDeclaration(input, lineNumber, 'ObjectMethod', 'function', name, {
-      owner: context.name,
-      propertyName: methodMatch[2],
-      parameters: splitParameters(methodMatch[3])
-    }, true, {
-      regionKind: jsPropertyRegionKind(context, methodMatch[2], 'function'),
-      metadata: { owner: context.name, propertyName: methodMatch[2], initializerKind: 'function' }
-    });
-  }
-  const propertyMatch = trimmed.match(/^(?:(['"])([^'"]+)\1|([A-Za-z_$][\w$-]*))\s*:\s*(.+?)(?:,)?$/);
-  if (!propertyMatch) return undefined;
-  const propertyName = propertyMatch[2] ?? propertyMatch[3];
-  if (!propertyName || jsControlKeyword(propertyName)) return undefined;
-  const value = propertyMatch[4].trim();
-  const initializerKind = jsPropertyInitializerKind(value);
-  const functionLike = initializerKind === 'function';
-  const name = `${context.name}.${propertyName}`;
-  return nativeDeclaration(input, lineNumber, functionLike ? 'ObjectFunctionProperty' : 'ObjectProperty', functionLike ? 'function' : 'property', name, {
-    owner: context.name,
-    propertyName,
-    initializerKind
-  }, functionLike || initializerKind === 'object' || initializerKind === 'array', {
-    regionKind: jsPropertyRegionKind(context, propertyName, value),
-    metadata: { owner: context.name, propertyName, initializerKind }
-  });
-}
-
-function jsRouteRecordDeclaration(input, lineNumber, trimmed, context) {
-  if (context.regionKind !== 'route') return undefined;
-  const match = trimmed.match(/^(?:\{\s*)?(?:path|route|href|url)\s*:\s*(['"`])([^'"`]+)\1/);
-  if (!match) return undefined;
-  const routePath = match[2];
-  return nativeDeclaration(input, lineNumber, 'RouteRecord', 'route', `${context.name}.${routePath}`, {
-    owner: context.name,
-    routePath
-  }, true, {
-    regionKind: 'route',
-    metadata: { owner: context.name, routePath, initializerKind: 'object' }
-  });
-}
-
-function jsPropertyInitializerKind(value) {
-  const text = String(value ?? '').trim();
-  if (/^(?:async\s*)?(?:function\b|\([^)]*\)\s*=>|[A-Za-z_$][\w$]*\s*=>)/.test(text)) return 'function';
-  const containerKind = jsContainerInitializerKind(text, undefined, text);
-  if (containerKind) return containerKind;
-  if (/^['"`]/.test(text)) return 'string';
-  if (/^(?:true|false)\b/.test(text)) return 'boolean';
-  if (/^[0-9]/.test(text)) return 'number';
-  return 'expression';
-}
-
-function jsPropertyRegionKind(context, propertyName, value) {
-  const named = jsRegionKindForDeclarationName(propertyName, value);
-  if (named) return named;
-  if (context.regionKind === 'route') return 'route';
-  if (context.regionKind === 'content') return 'content';
-  if (context.regionKind === 'config') return 'config';
-  return 'property';
-}
-
 function jsContainerInitializerKind(initializer, name, source) {
   const text = String(initializer ?? '').trim();
   if (text.startsWith('{')) return 'object';
@@ -279,7 +221,7 @@ function jsContainerInitializerKind(initializer, name, source) {
 
 function jsContainerWrapperLooksSemantic(callee, name, source) {
   const signal = `${callee ?? ''} ${name ?? ''} ${source ?? ''}`.replace(/([a-z0-9])([A-Z])/g, '$1 $2').toLowerCase();
-  return /\b(define|create|make|build|object\.freeze)\b/.test(signal) && /\b(config|settings|options|routes?|router|content|docs?|schema|registry|manifest|catalog|menu|nav)\b/.test(signal);
+  return /\b(define|create|make|build|object\.freeze)\b/.test(signal) && /\b(actions?|handlers?|tools?|commands?|events?|effects?|workflows?|config|settings|options|routes?|router|content|docs?|schema|registry|manifest|catalog|menu|nav)\b/.test(signal);
 }
 
 function jsContainerDelta(source) {
@@ -316,5 +258,5 @@ function findUnescapedBacktick(text, startIndex) {
 
 export { jsCommentOnlyLine, jsContainerDelta, jsDeclarationScanLine };
 export { jsExportAliasDeclaration, jsExportedContainerDeclaration, jsExportedFunctionWrapperDeclaration };
-export { jsInitializerKind, jsImportDeclarations, jsObjectPropertyDeclaration, jsObjectRegionContext };
-export { jsRegionKindForDeclarationName, jsRouteRecordDeclaration, jsVariableHasBody, jsVariableSymbolKind };
+export { jsContainerInitializerKind, jsExportDeclarations, jsInitializerKind, jsImportDeclarations, jsObjectRegionContext };
+export { jsRegionKindForDeclarationName, jsVariableHasBody, jsVariableSymbolKind };

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

@@ -1,7 +1,9 @@
 import {
+  nativeExportDeclaration,
   nativeImportBindingDeclaration,
   nativeImportDeclaration
 } from './native-region-scanner-core.js';
+import { idFragment } from './native-import-utils.js';
 
 export function jsImportDeclarations(input, lineNumber, trimmed) {
   const importEquals = trimmed.match(/^import\s+(type\s+)?([A-Za-z_$][\w$]*)\s*=\s*require\s*\(\s*(['"])([^'"]+)\3\s*\)/);
@@ -28,7 +30,10 @@ export function jsImportDeclarations(input, lineNumber, trimmed) {
       : exportMatch[4]
         ? jsNamedImportBindings(exportMatch[4], { typeOnly, reexport: true })
         : [];
-    return jsImportModuleDeclarations(input, lineNumber, importPath, 'ExportFromDeclaration', bindings, { typeOnly, reexport: true, exportStar: Boolean(exportMatch[2]) });
+    return [
+      ...jsImportModuleDeclarations(input, lineNumber, importPath, 'ExportFromDeclaration', bindings, { typeOnly, reexport: true, exportStar: Boolean(exportMatch[2]) }),
+      ...jsExportModuleDeclarations(input, lineNumber, importPath, bindings, { typeOnly, exportStar: Boolean(exportMatch[2]) })
+    ];
   }
   const destructuredRequireMatch = trimmed.match(/^(?:const|let|var)\s+\{([^}]+)\}\s*=\s*(?:await\s+)?(require|import)\s*\(\s*(['"])([^'"]+)\3\s*\)/);
   if (destructuredRequireMatch) {
@@ -54,6 +59,34 @@ export function jsImportDeclarations(input, lineNumber, trimmed) {
   return [];
 }
 
+export function jsExportDeclarations(input, lineNumber, trimmed) {
+  if (/^export\s+(?:type\s+)?(?:\*|\{[^}]+\}\s+from\b)/.test(trimmed)) return [];
+  const named = trimmed.match(/^export\s+(type\s+)?\{([^}]+)\}\s*;?$/);
+  if (named) return jsLocalExportDeclarations(input, lineNumber, named[2], { typeOnly: Boolean(named[1]) });
+  const namespace = trimmed.match(/^export\s+as\s+namespace\s+([A-Za-z_$][\w$]*)\s*;?$/);
+  if (namespace) return [nativeExportDeclaration(input, lineNumber, namespace[1], 'ExportNamespaceDeclaration', {
+    exportKind: 'namespace'
+  })];
+  const assignment = trimmed.match(/^export\s*=\s*([A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*)*)\s*;?$/);
+  if (assignment) return [nativeExportDeclaration(input, lineNumber, 'module.exports', 'ExportAssignment', {
+    exportKind: 'assignment',
+    localName: assignment[1]
+  }, { name: 'module.exports' })];
+  if (!trimmed.startsWith('export ')) return [];
+  const defaultMatch = trimmed.match(/^export\s+default\s+(.+)$/);
+  if (defaultMatch) return [nativeExportDeclaration(input, lineNumber, 'default', 'ExportDefaultDeclaration', {
+    exportDefault: true,
+    localName: jsExportedDeclarationName(defaultMatch[1])
+  }, { name: 'default' })];
+  const declarationSource = trimmed.replace(/^export\s+(?:declare\s+)?/, '');
+  if (!jsExportedDeclarationLooksComplete(declarationSource)) return [];
+  const exportedName = jsExportedDeclarationName(declarationSource);
+  if (!exportedName) return [];
+  return [nativeExportDeclaration(input, lineNumber, exportedName, 'ExportNamedDeclaration', {
+    declarationKind: jsExportedDeclarationKind(declarationSource)
+  })];
+}
+
 function jsDestructuredImportBindings(raw, importKind) {
   return String(raw ?? '')
     .split(',')
@@ -100,6 +133,47 @@ function jsImportModuleDeclarations(input, lineNumber, importPath, languageKind,
   ];
 }
 
+function jsExportModuleDeclarations(input, lineNumber, importPath, bindings = [], metadata = {}) {
+  const exports = bindings.map((binding) => ({
+    localName: binding.importedName,
+    exportedName: binding.exportedName ?? binding.localName,
+    exportKind: binding.importKind,
+    ...(binding.typeOnly ? { typeOnly: true } : {})
+  }));
+  const statementName = metadata.exportStar
+    ? `* from ${importPath}`
+    : exports.length
+      ? `{${exports.map((binding) => binding.exportedName).join(',')}} from ${importPath}`
+      : `from ${importPath}`;
+  return [
+    nativeExportDeclaration(input, lineNumber, statementName, 'ExportFromDeclaration', {
+      importPath: String(importPath),
+      exportBindings: exports,
+      ...(metadata.typeOnly ? { typeOnly: true } : {}),
+      ...(metadata.exportStar ? { exportStar: true } : {})
+    }, { symbolKind: 'module', metadata }),
+    ...exports.map((binding) => nativeExportDeclaration(input, lineNumber, binding.exportedName, 'ExportBinding', {
+      ...binding,
+      importPath: String(importPath)
+    }, { metadata: { ...binding, importPath: String(importPath) } }))
+  ];
+}
+
+function jsLocalExportDeclarations(input, lineNumber, raw, options = {}) {
+  const bindings = jsNamedExportBindings(raw, options);
+  if (!bindings.length) return [];
+  return [
+    nativeExportDeclaration(input, lineNumber, `{${bindings.map((binding) => binding.exportedName).join(',')}}`, 'ExportNamedDeclaration', {
+      exportBindings: bindings,
+      ...(options.typeOnly ? { typeOnly: true } : {})
+    }, {
+      symbolId: `symbol:${input.language}:export:statement:${idFragment(bindings.map((binding) => binding.exportedName).join('_'))}`,
+      metadata: { bindingCount: bindings.length, ...(options.typeOnly ? { typeOnly: true } : {}) }
+    }),
+    ...bindings.map((binding) => nativeExportDeclaration(input, lineNumber, binding.exportedName, 'ExportBinding', binding, { metadata: binding }))
+  ];
+}
+
 function jsImportBindingsFromClause(clause, options = {}) {
   const source = String(clause ?? '').trim();
   if (!source) return [];
@@ -142,3 +216,49 @@ function jsNamedImportBinding(raw, options = {}) {
     typeOnly
   };
 }
+
+function jsNamedExportBindings(raw, options = {}) {
+  return String(raw ?? '').split(',').map((part) => jsNamedExportBinding(part, options)).filter(Boolean);
+}
+
+function jsNamedExportBinding(raw, options = {}) {
+  let text = String(raw ?? '').trim();
+  if (!text) return undefined;
+  let typeOnly = Boolean(options.typeOnly);
+  if (text.startsWith('type ')) {
+    typeOnly = true;
+    text = text.slice(5).trim();
+  }
+  const match = text.match(/^([A-Za-z_$][\w$]*|\*)\s*(?:as\s+([A-Za-z_$][\w$]*|\*))?$/);
+  if (!match) return undefined;
+  const localName = match[1];
+  return { localName, exportedName: match[2] ?? localName, exportKind: typeOnly ? 'type-named' : 'named', typeOnly };
+}
+
+function jsExportedDeclarationName(source) {
+  const text = String(source ?? '').trim();
+  return text.match(/^(?:async\s+)?function\*?\s+([A-Za-z_$][\w$]*)/)?.[1]
+    ?? text.match(/^(?:abstract\s+)?class\s+([A-Za-z_$][\w$]*)/)?.[1]
+    ?? text.match(/^(?:const|let|var)\s+([A-Za-z_$][\w$]*)/)?.[1]
+    ?? text.match(/^type\s+([A-Za-z_$][\w$]*)/)?.[1]
+    ?? text.match(/^interface\s+([A-Za-z_$][\w$]*)/)?.[1]
+    ?? text.match(/^(?:const\s+)?enum\s+([A-Za-z_$][\w$]*)/)?.[1]
+    ?? text.match(/^([A-Za-z_$][\w$]*)\b/)?.[1]
+    ?? 'default';
+}
+
+function jsExportedDeclarationKind(source) {
+  const text = String(source ?? '').trim();
+  if (/^(?:async\s+)?function/.test(text)) return 'function';
+  if (/^(?:abstract\s+)?class/.test(text)) return 'class';
+  if (/^interface\b|^type\b|^(?:const\s+)?enum\b/.test(text)) return 'type';
+  if (/^(?:const|let|var)\b/.test(text)) return 'variable';
+  return 'value';
+}
+
+function jsExportedDeclarationLooksComplete(source) {
+  const text = String(source ?? '').trim();
+  if (/^(?:async\s+)?function/.test(text)) return text.includes(')') && /[;{]/.test(text);
+  if (/^(?:abstract\s+)?class/.test(text)) return text.includes('{') || text.endsWith(';');
+  return true;
+}