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

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;
+}

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

@@ -1,5 +1,5 @@
-import { nativeDeclaration } from './native-region-scanner-core.js';
-import { jsContainerDelta, jsRegionKindForDeclarationName } from './native-region-scanner-js-helpers.js';
+import { jsControlKeyword, nativeDeclaration, splitParameters } from './native-region-scanner-core.js';
+import { jsContainerDelta, jsContainerInitializerKind, jsRegionKindForDeclarationName } from './native-region-scanner-js-helpers.js';
 
 function jsCurrentObjectContext(stack) {
   return stack[stack.length - 1];
@@ -9,6 +9,21 @@ function jsContextAllowsPropertyScan(context) {
   return context?.initializerKind === 'object';
 }
 
+function jsArrayObjectContextFromLine(context, lineNumber, source) {
+  if (context?.initializerKind !== 'array' || context.arrayRecords !== true || !String(source ?? '').trim().startsWith('{')) return undefined;
+  const depth = jsContainerDelta(source);
+  if (depth <= 0) return undefined;
+  const index = (context.nextItemIndex ?? 0) + 1;
+  context.nextItemIndex = index;
+  return { name: `${context.name}.${index}`, ownerName: context.name, regionKind: context.regionKind, initializerKind: 'object', arrayItem: true, depth, startLine: lineNumber };
+}
+
+function updateJsArrayObjectContextName(context, source) {
+  if (!context?.arrayItem) return;
+  const match = String(source ?? '').trim().match(/^(?:name|id|key|slug|tool|command)\s*:\s*(['"`])([^'"`]+)\1/);
+  if (match) context.name = `${context.ownerName}.${match[2]}`;
+}
+
 function jsNestedObjectContextFromDeclaration(declaration, lineNumber, source) {
   const initializerKind = declaration?.fields?.initializerKind ?? declaration?.metadata?.initializerKind;
   if (initializerKind !== 'object' && initializerKind !== 'array') return undefined;
@@ -32,9 +47,9 @@ function jsInlineNestedObjectDeclarations(input, lineNumber, source, parentDecla
   for (const entry of splitTopLevelEntries(body)) {
     const parsed = parseObjectEntry(entry);
     if (!parsed) continue;
-    const initializerKind = nestedInitializerKind(parsed.value);
+    const initializerKind = parsed.method ? 'function' : nestedInitializerKind(parsed.value);
     const name = `${parentDeclaration.name}.${parsed.key}`;
-    const regionKind = nestedPropertyRegionKind(parentDeclaration, parsed.key, parsed.value);
+    const regionKind = initializerKind === 'function' ? 'body' : nestedPropertyRegionKind(parentDeclaration, parsed.key, parsed.value);
     const declaration = nativeDeclaration(input, lineNumber, initializerKind === 'function' ? 'NestedObjectFunctionProperty' : 'NestedObjectProperty', initializerKind === 'function' ? 'function' : 'property', name, {
       owner: parentDeclaration.name,
       propertyName: parsed.key,
@@ -57,6 +72,73 @@ function updateJsObjectContextStack(stack, lineNumber, source) {
   while (stack.length && stack[stack.length - 1].depth <= 0) stack.pop();
 }
 
+function jsObjectPropertyDeclaration(input, lineNumber, trimmed, context) {
+  if (/^[}\])]/.test(trimmed) || trimmed.startsWith('...')) return undefined;
+  const methodMatch = trimmed.match(/^(?:(?:async|get|set)\s+)?(?:\[\s*(['"`])([^'"`]+)\1\s*\]|(['"`]?)([A-Za-z_$][\w$-]*)\3)\s*\(([^)]*)\)\s*(?:[:\w\s<>\[\]]*)?(?:\{|=>|,|$)/);
+  const methodName = methodMatch?.[2] ?? methodMatch?.[4];
+  if (methodMatch && !jsControlKeyword(methodName)) {
+    const name = `${context.name}.${methodName}`;
+    return nativeDeclaration(input, lineNumber, 'ObjectMethod', 'function', name, {
+      owner: context.name,
+      propertyName: methodName,
+      parameters: splitParameters(methodMatch[5])
+    }, true, {
+      regionKind: 'body',
+      metadata: { owner: context.name, propertyName: methodName, initializerKind: 'function' }
+    });
+  }
+  const propertyMatch = trimmed.match(/^(?:\[\s*(['"`])([^'"`]+)\1\s*\]|(['"`])([^'"`]+)\3|([A-Za-z_$][\w$-]*))\s*:\s*(.+?)(?:,)?$/);
+  if (!propertyMatch) return undefined;
+  const propertyName = propertyMatch[2] ?? propertyMatch[4] ?? propertyMatch[5];
+  if (!propertyName || jsControlKeyword(propertyName)) return undefined;
+  const value = propertyMatch[6].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: functionLike ? 'body' : 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 inlineObjectBody(source) {
   const text = String(source ?? '');
   const open = text.indexOf('{');
@@ -113,10 +195,12 @@ function splitTopLevelEntries(body) {
 }
 
 function parseObjectEntry(entry) {
-  if (!entry || entry.startsWith('...') || entry.startsWith('[')) return undefined;
-  const match = entry.match(/^(?:(['"])([^'"]+)\1|([A-Za-z_$][\w$-]*))\s*:\s*(.+)$/s);
-  if (!match) return undefined;
-  return { key: match[2] ?? match[3], value: match[4].trim() };
+  if (!entry || entry.startsWith('...')) return undefined;
+  const match = entry.match(/^(?:\[\s*(['"`])([^'"`]+)\1\s*\]|(['"`])([^'"`]+)\3|([A-Za-z_$][\w$-]*))\s*:\s*(.+)$/s);
+  if (match) return { key: match[2] ?? match[4] ?? match[5], value: match[6].trim() };
+  const methodMatch = entry.match(/^(?:(?:async|get|set)\s+)?(?:\[\s*(['"`])([^'"`]+)\1\s*\]|(['"`]?)([A-Za-z_$][\w$-]*)\3)\s*\(([^)]*)\)\s*(?:[:\w\s<>\[\]]*)?(?:\{|=>|$)/s);
+  if (!methodMatch) return undefined;
+  return { key: methodMatch[2] ?? methodMatch[4], value: entry.trim(), method: true };
 }
 
 function nestedInitializerKind(value) {
@@ -139,9 +223,13 @@ function nestedPropertyRegionKind(parentDeclaration, propertyName, value) {
 }
 
 export {
+  jsArrayObjectContextFromLine,
   jsContextAllowsPropertyScan,
   jsCurrentObjectContext,
   jsInlineNestedObjectDeclarations,
   jsNestedObjectContextFromDeclaration,
+  jsObjectPropertyDeclaration,
+  jsRouteRecordDeclaration,
+  updateJsArrayObjectContextName,
   updateJsObjectContextStack
 };

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

@@ -0,0 +1,27 @@
+function jsStructureDelta(source) {
+  let value = 0;
+  let opened = false;
+  let quote;
+  let escaped = false;
+  for (const char of String(source ?? '')) {
+    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 === '{' || char === '[' || char === '(') {
+      value += 1;
+      opened = true;
+    } else if (char === '}' || char === ']' || char === ')') {
+      value -= 1;
+    }
+  }
+  return { value, opened };
+}
+
+export { jsStructureDelta };

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

@@ -0,0 +1,99 @@
+import {
+  jsControlKeyword,
+  nativeDeclaration,
+  nativeSignatureDeclaration,
+  splitParameters
+} from './native-region-scanner-core.js';
+import { jsRegionKindForDeclarationName } from './native-region-scanner-js-helpers.js';
+import { jsStructureDelta } from './native-region-scanner-js-structure.js';
+
+function jsTypeRegionContext(name, declarationLine, lineNumber, regionKind, typeKind) {
+  const depth = jsStructureDelta(declarationLine).value;
+  if (depth <= 0) return undefined;
+  return {
+    name,
+    typeKind,
+    regionKind,
+    depth,
+    startLine: lineNumber,
+    memberStack: []
+  };
+}
+
+function jsCurrentTypeMemberContext(context) {
+  return context.memberStack.at(-1) ?? context;
+}
+
+function updateJsTypeRegionContext(context, lineNumber, source) {
+  const delta = jsStructureDelta(source).value;
+  context.depth += delta;
+  for (const memberContext of context.memberStack) {
+    if (memberContext.startLine !== lineNumber) memberContext.depth += delta;
+  }
+  while (context.memberStack.length && context.memberStack.at(-1).depth <= 0) context.memberStack.pop();
+}
+
+function jsTypeMemberDeclaration(input, lineNumber, declarationLine, context) {
+  const text = String(declarationLine ?? '').trim();
+  if (!text || /^[}\])]/.test(text) || text.startsWith('//')) return undefined;
+  let match = text.match(/^(?:readonly\s+)?(['"]?)([A-Za-z_$][\w$-]*)\1\??\s*(?:<[^({;]+>)?\s*\(([^)]*)\)\s*(?::\s*([^;,]+))?[;,]?$/);
+  if (match && !jsControlKeyword(match[2])) {
+    return nativeSignatureDeclaration(input, lineNumber, 'TypeMethodSignature', 'method', `${context.name}.${match[2]}`, {
+      owner: context.name,
+      propertyName: match[2],
+      parameters: splitParameters(match[3]),
+      returnType: match[4]?.trim(),
+      typeKind: context.typeKind
+    }, false, {
+      regionKind: jsTypeMemberRegionKind(context, match[2], text),
+      metadata: { owner: context.name, propertyName: match[2], typeKind: context.typeKind }
+    });
+  }
+  match = text.match(/^(?:readonly\s+)?(['"]?)([A-Za-z_$][\w$-]*)\1\??\s*:\s*(.+?)[;,]?$/);
+  if (!match || jsControlKeyword(match[2])) return undefined;
+  const valueType = match[3].trim();
+  const functionLike = /=>/.test(valueType) || /^\([^)]*\)\s*=>/.test(valueType);
+  const hasNestedTypeLiteralBody = jsTypeMemberValueStartsTypeLiteral(valueType) && jsStructureDelta(text).value > 0;
+  return (functionLike ? nativeSignatureDeclaration : nativeDeclaration)(input, lineNumber, functionLike ? 'TypeFunctionPropertySignature' : 'TypePropertySignature', functionLike ? 'function' : 'property', `${context.name}.${match[2]}`, {
+    owner: context.name,
+    propertyName: match[2],
+    valueType,
+    typeKind: context.typeKind
+  }, hasNestedTypeLiteralBody, {
+    regionKind: jsTypeMemberRegionKind(context, match[2], text),
+    metadata: { owner: context.name, propertyName: match[2], typeKind: context.typeKind }
+  });
+}
+
+function jsNestedTypeMemberContextFromDeclaration(declaration, lineNumber, source, parentContext) {
+  if (!declaration) return undefined;
+  const depth = jsStructureDelta(source).value;
+  if (depth <= 0) return undefined;
+  const valueType = declaration.fields?.valueType ?? declaration.fields?.returnType;
+  const nestedTypeLiteral = jsTypeMemberValueStartsTypeLiteral(valueType);
+  return {
+    name: nestedTypeLiteral ? declaration.name : parentContext.name,
+    typeKind: parentContext.typeKind,
+    regionKind: nestedTypeLiteral ? (declaration.regionKind ?? 'property') : parentContext.regionKind,
+    depth,
+    startLine: lineNumber,
+    suppressMembers: !nestedTypeLiteral
+  };
+}
+
+function jsTypeMemberValueStartsTypeLiteral(valueType) {
+  const text = String(valueType ?? '').trim();
+  return text.startsWith('{') || /=>\s*\{\s*$/.test(text);
+}
+
+function jsTypeMemberRegionKind(context, propertyName) {
+  return jsRegionKindForDeclarationName(propertyName) ?? (context.regionKind === 'type' ? 'property' : context.regionKind) ?? 'property';
+}
+
+export {
+  jsCurrentTypeMemberContext,
+  jsNestedTypeMemberContextFromDeclaration,
+  jsTypeMemberDeclaration,
+  jsTypeRegionContext,
+  updateJsTypeRegionContext
+};