@shapeshift-labs/frontier-lang-compiler 0.2.23 → 0.2.24

package/README.md

@@ -191,10 +191,30 @@ const imported = importNativeSource({
 const sidecar = createSemanticImportSidecar(imported);
 
 console.log(sidecar.summary.emptySemanticIndex); // false when symbols were found
-console.log(sidecar.ownershipRegions[0].key); // source#src/runtime.ts#class#Runtime
+console.log(sidecar.ownershipRegions[0].key); // source#src/runtime.ts#type#Runtime
 console.log(sidecar.patchHints[0].supportedOperations); // source-region patch operations
 ```
 
+The built-in JavaScript/TypeScript lightweight scanner also emits review-required ownership regions for clear route/config/content/property shapes in exported objects and arrays:
+
+```js
+const importedConfig = importNativeSource({
+  language: 'typescript',
+  sourcePath: 'src/routes.ts',
+  sourceText: `
+    export const appRoutes = [
+      { path: "/home", component: Home }
+    ];
+    export const siteContent = {
+      docs: { title: "Docs" }
+    };
+  `
+});
+
+const configSidecar = createSemanticImportSidecar(importedConfig);
+console.log(configSidecar.regionTaxonomy.presentKinds); // includes "route" and "content"
+```
+
 Compare before/after native source imports from a worker patch and emit a semantic change set for admission scoring:
 
 ```js

package/bench/smoke.mjs

@@ -135,6 +135,36 @@ const nativeTargetAdapterDurationMs = performance.now() - nativeTargetAdapterSta
 const nativeTargetAdapterBytes = nativeTargetAdapterCompiles.reduce((sum, result) => sum + result.output.length, 0);
 const nativeTargetAdapterSourceMaps = nativeTargetAdapterCompiles.reduce((sum, result) => sum + result.sourceMaps.length, 0);
 
+const regionScanStart = performance.now();
+const regionScanImports = [];
+for (let index = 0; index < 100; index += 1) {
+  const imported = importNativeSource({
+    language: 'typescript',
+    sourcePath: `src/regions-${index}.ts`,
+    sourceText: `
+      export const appRoutes${index} = [
+        { path: "/${index}", component: Screen${index} },
+        { path: "/${index}/settings", component: Settings${index} }
+      ];
+      export const contentBlocks${index} = {
+        docs: { title: "Docs ${index}" },
+        legal: { title: "Legal ${index}" }
+      };
+      export const runtimeConfig${index} = {
+        limits: { count: ${index} },
+        resolve(id) { return id; }
+      };
+      export const helpers${index} = {
+        plain: ${index}
+      };
+    `
+  });
+  regionScanImports.push({ imported, sidecar: createSemanticImportSidecar(imported) });
+}
+const regionScanDurationMs = performance.now() - regionScanStart;
+const regionScanSymbols = regionScanImports.reduce((sum, entry) => sum + entry.imported.semanticIndex.symbols.length, 0);
+const regionScanOwnershipRegions = regionScanImports.reduce((sum, entry) => sum + entry.sidecar.ownershipRegions.length, 0);
+
 const externalSemanticStart = performance.now();
 const externalSemanticImports = [];
 for (let index = 0; index < 100; index += 1) {
@@ -208,6 +238,10 @@ console.log(JSON.stringify({
   nativeTargetAdapterBytes,
   nativeTargetAdapterSourceMaps,
   nativeTargetAdapterDurationMs: Number(nativeTargetAdapterDurationMs.toFixed(2)),
+  regionScanImports: regionScanImports.length,
+  regionScanSymbols,
+  regionScanOwnershipRegions,
+  regionScanDurationMs: Number(regionScanDurationMs.toFixed(2)),
   externalSemanticImports: externalSemanticImports.length,
   externalSemanticSymbols,
   externalSemanticMappings,

package/dist/index.d.ts

@@ -140,6 +140,10 @@ export type NativeImportRegionTaxonomyKind =
   | 'call'
   | 'type'
   | 'effect'
+  | 'property'
+  | 'config'
+  | 'content'
+  | 'route'
   | 'generatedOutput'
   | string;
 

package/dist/index.js

@@ -262,6 +262,10 @@ export const NativeImportRegionTaxonomyKinds = Object.freeze([
   'call',
   'type',
   'effect',
+  'property',
+  'config',
+  'content',
+  'route',
   'generatedOutput'
 ]);
 
@@ -4019,10 +4023,23 @@ function scanJavaScriptLike(input) {
   const declarations = [];
   let currentClass;
   let classDepth = 0;
+  let currentObject;
+  const lexicalState = { inBlockComment: false, inTemplateString: false };
   for (const { line, number } of sourceLines(input.sourceText)) {
-    const trimmed = line.trim();
+    const scanLine = jsDeclarationScanLine(line, lexicalState);
+    const trimmed = scanLine.trim();
+    if (!trimmed || jsCommentOnlyLine(trimmed)) continue;
     const declarationLine = trimmed.replace(/^(?:export\s+)?(?:declare\s+)?/, '');
     let match;
+    if (currentObject) {
+      const routeRecord = jsRouteRecordDeclaration(input, number, trimmed, currentObject);
+      if (routeRecord) {
+        declarations.push(routeRecord);
+      } else {
+        const property = jsObjectPropertyDeclaration(input, number, trimmed, currentObject);
+        if (property) declarations.push(property);
+      }
+    }
     if ((match = trimmed.match(/^import\s+(?:.+?\s+from\s+)?['"]([^'"]+)['"]/))) {
       declarations.push(nativeImportDeclaration(input, number, match[1], 'ImportDeclaration', 'module'));
     } else if ((match = trimmed.match(/^import\s*\(\s*['"]([^'"]+)['"]\s*\)/))) {
@@ -4050,11 +4067,20 @@ function scanJavaScriptLike(input) {
     } else if ((match = declarationLine.match(/^(?:const|let|var)\s+([A-Za-z_$][\w$]*)\s*=\s*(?:async\s*)?\(?([^=;]*)\)?\s*=>/))) {
       declarations.push(nativeDeclaration(input, number, 'VariableFunctionDeclaration', 'function', match[1], { parameters: splitParameters(match[2]) }, true));
     } else if ((match = declarationLine.match(/^(?:const|let|var)\s+([A-Za-z_$][\w$]*)\b/))) {
-      declarations.push(nativeDeclaration(input, number, 'VariableDeclaration', 'variable', match[1], {}, false));
+      const initializerKind = jsInitializerKind(declarationLine);
+      const regionKind = jsRegionKindForDeclarationName(match[1], declarationLine);
+      declarations.push(nativeDeclaration(input, number, 'VariableDeclaration', jsVariableSymbolKind(regionKind, initializerKind), match[1], {
+        initializerKind
+      }, jsVariableHasBody(initializerKind, declarationLine), {
+        regionKind,
+        metadata: { initializerKind }
+      }));
+      currentObject = jsObjectRegionContext(match[1], declarationLine, number, regionKind);
     } else if ((match = trimmed.match(/^(?:module\.)?exports\.([A-Za-z_$][\w$]*)\s*=\s*(?:async\s+)?function\*?\s*\(([^)]*)\)/))) {
       declarations.push(nativeDeclaration(input, number, 'CommonJsFunctionExport', 'function', match[1], { parameters: splitParameters(match[2]) }, true));
     } else if ((match = trimmed.match(/^(?:module\.)?exports\.([A-Za-z_$][\w$]*)\s*=/))) {
-      declarations.push(nativeDeclaration(input, number, 'CommonJsExport', 'variable', match[1], { export: 'commonjs' }, false));
+      const regionKind = jsRegionKindForDeclarationName(match[1], trimmed);
+      declarations.push(nativeDeclaration(input, number, 'CommonJsExport', 'variable', match[1], { export: 'commonjs' }, false, { regionKind }));
     } else if (currentClass && (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*[^={]+)?(?:\{|=>|$)/)) && !jsControlKeyword(match[1])) {
       declarations.push(nativeDeclaration(input, number, 'MethodDefinition', 'method', `${currentClass}.${match[1]}`, {
         methodName: match[1],
@@ -4075,10 +4101,224 @@ function scanJavaScriptLike(input) {
         classDepth = 0;
       }
     }
+    if (currentObject) {
+      if (number !== currentObject.startLine) currentObject.depth += jsContainerDelta(trimmed);
+      if (currentObject.depth <= 0) currentObject = undefined;
+    }
   }
   return declarations;
 }
 
+function jsCommentOnlyLine(trimmed) {
+  return trimmed.startsWith('//') || trimmed.startsWith('/*') || trimmed.startsWith('*');
+}
+
+function jsDeclarationScanLine(line, state) {
+  let text = String(line ?? '');
+  if (state.inTemplateString) {
+    const close = findUnescapedBacktick(text, 0);
+    if (close < 0) return '';
+    text = text.slice(close + 1);
+    state.inTemplateString = false;
+  }
+  if (state.inBlockComment) {
+    const close = text.indexOf('*/');
+    if (close < 0) return '';
+    text = text.slice(close + 2);
+    state.inBlockComment = false;
+  }
+  let output = '';
+  let quote;
+  let escaped = false;
+  for (let index = 0; index < text.length; index += 1) {
+    const char = text[index];
+    const next = text[index + 1];
+    if (quote) {
+      output += char;
+      if (escaped) {
+        escaped = false;
+      } else if (char === '\\') {
+        escaped = true;
+      } else if (char === quote) {
+        quote = undefined;
+      }
+      continue;
+    }
+    if (char === '/' && next === '/') break;
+    if (char === '/' && next === '*') {
+      const close = text.indexOf('*/', index + 2);
+      if (close < 0) {
+        state.inBlockComment = true;
+        break;
+      }
+      index = close + 1;
+      continue;
+    }
+    if (char === '\'' || char === '"') {
+      quote = char;
+      output += char;
+      continue;
+    }
+    if (char === '`') {
+      const close = findUnescapedBacktick(text, index + 1);
+      if (close < 0) {
+        state.inTemplateString = true;
+        output += '``';
+        break;
+      }
+      output += text.slice(index, close + 1);
+      index = close;
+      continue;
+    }
+    output += char;
+  }
+  return output;
+}
+
+function findUnescapedBacktick(text, startIndex) {
+  let escaped = false;
+  for (let index = startIndex; index < text.length; index += 1) {
+    const char = text[index];
+    if (escaped) {
+      escaped = false;
+    } else if (char === '\\') {
+      escaped = true;
+    } else if (char === '`') {
+      return index;
+    }
+  }
+  return -1;
+}
+
+function jsObjectRegionContext(name, declarationLine, lineNumber, regionKind) {
+  const initializerKind = jsInitializerKind(declarationLine);
+  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
+  };
+}
+
+function jsInitializerKind(line) {
+  const initializer = String(line ?? '').split('=').slice(1).join('=').trim();
+  if (!initializer) return 'unknown';
+  if (/^(?:async\s+)?function\b/.test(initializer) || /=>/.test(initializer)) return 'function';
+  if (initializer.startsWith('{')) return 'object';
+  if (initializer.startsWith('[')) return 'array';
+  if (/^new\s+/.test(initializer)) return 'instance';
+  if (/^['"`]/.test(initializer)) return 'string';
+  if (/^(?:true|false)\b/.test(initializer)) return 'boolean';
+  if (/^[0-9]/.test(initializer)) return 'number';
+  return 'expression';
+}
+
+function jsVariableHasBody(initializerKind, declarationLine) {
+  return initializerKind === 'function'
+    || initializerKind === 'object'
+    || initializerKind === 'array'
+    || /\{/.test(String(declarationLine ?? ''));
+}
+
+function jsVariableSymbolKind(regionKind, initializerKind) {
+  if (regionKind === 'route') return 'route';
+  if (initializerKind === 'function') return 'function';
+  return 'variable';
+}
+
+function jsRegionKindForDeclarationName(name, source = '') {
+  const raw = `${name ?? ''} ${source ?? ''}`;
+  const text = raw.replace(/([a-z0-9])([A-Z])/g, '$1 $2').toLowerCase();
+  const compact = raw.toLowerCase();
+  if (/\b(routes?|router|screens?|pages?|navigation|navitems?|menuitems?)\b/.test(text) || /(route|router|screen|page|navigation|navitem|menuitem)/.test(compact)) return 'route';
+  if (/\b(config|settings|options|flags?|schema|manifest|registry|catalog)\b/.test(text) || /(config|settings|options|flags|schema|manifest|registry|catalog)/.test(compact)) return 'config';
+  if (/\b(content|copy|docs?|legal|messages?|strings?|i18n|locale|translations?)\b/.test(text) || /(content|copy|docs|legal|messages|strings|i18n|locale|translations)/.test(compact)) return 'content';
+  return undefined;
+}
+
+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(/\b(?: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';
+  if (text.startsWith('{')) return 'object';
+  if (text.startsWith('[')) return 'array';
+  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 jsContainerDelta(source) {
+  let delta = 0;
+  for (const char of String(source ?? '')) {
+    if (char === '{' || char === '[') delta += 1;
+    if (char === '}' || char === ']') delta -= 1;
+  }
+  return delta;
+}
+
 function scanPython(input) {
   const declarations = [];
   for (const { line, number } of sourceLines(input.sourceText)) {
@@ -4778,7 +5018,7 @@ function rMetaName(source) {
   return match?.[1] ?? 'dynamic';
 }
 
-function nativeDeclaration(input, lineNumber, languageKind, symbolKind, name, fields = {}, hasBody = false) {
+function nativeDeclaration(input, lineNumber, languageKind, symbolKind, name, fields = {}, hasBody = false, options = {}) {
   const nodeId = `native_${idFragment(languageKind)}_${lineNumber}_${idFragment(name)}`;
   return {
     nodeId,
@@ -4789,7 +5029,9 @@ function nativeDeclaration(input, lineNumber, languageKind, symbolKind, name, fi
     symbolId: `symbol:${input.language}:${idFragment(name)}`,
     span: spanForLine(input, lineNumber),
     fields,
-    metadata: { scan: 'lightweight-declaration', hasBody },
+    metadata: { scan: 'lightweight-declaration', hasBody, ...options.metadata },
+    ...(options.regionKind ? { regionKind: options.regionKind } : {}),
+    ...(options.role ? { role: options.role } : {}),
     ...(hasBody ? { loss: opaqueBodyLoss(input, lineNumber, nodeId, name) } : {})
   };
 }
@@ -6649,6 +6891,8 @@ function semanticPatchHintForRegion(region, readiness, options = {}) {
 
 function semanticRegionKindForDeclaration(declaration) {
   if (declaration.role === 'import' || declaration.importPath) return 'import';
+  if (declaration.regionKind) return normalizeNativeImportRegionKind(declaration.regionKind);
+  if (declaration.metadata?.ownershipRegionKind) return normalizeNativeImportRegionKind(declaration.metadata.ownershipRegionKind);
   const kind = declaration.symbolKind ?? declaration.kind ?? declaration.nativeNode?.kind;
   if (semanticKindIsType(kind)) return 'type';
   if (semanticKindCanOwnBody(kind, declaration.span ?? declaration.nativeNode?.span)) return 'body';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shapeshift-labs/frontier-lang-compiler",
-  "version": "0.2.23",
+  "version": "0.2.24",
   "description": "Compiler facade for Frontier Lang source documents and language projection adapters.",
   "type": "module",
   "main": "./dist/index.js",