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

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
@@ -209,10 +229,12 @@ const changeSet = diffNativeSources({
 
 console.log(changeSet.changedSymbols[0]?.changeKind); // "modified"
 console.log(changeSet.changedRegions[0]?.conflictKey); // semantic ownership key
+console.log(changeSet.changedRegions[0]?.metadata.changedRegionProjection.reviewRequired); // true
+console.log(changeSet.metadata.changedRegionProjectionSummary.autoMergeClaims); // 0
 console.log(changeSet.mergeCandidate.readiness); // merge-admission classification
 ```
 
-Use `diffNativeSourceImports` when the worker or runner already produced `importNativeSource` results. Body-only edits that the lightweight scanner cannot anchor to a symbol are still reported as file-level changed regions instead of being silently treated as safe.
+Use `diffNativeSourceImports` when the worker or runner already produced `importNativeSource` results. Changed regions include a `metadata.changedRegionProjection` envelope with before/after source hashes, source-map links, ownership keys, readiness, and `autoMergeClaim: false` so swarm admission tools can score or port patches without treating semantic metadata as proof. Body-only edits that the lightweight scanner cannot anchor to a symbol are still reported as file-level changed regions instead of being silently treated as safe.
 
 Compile native source imports through the same reader/IR/writer facade that swarms use for sidecar evidence. Same-language targets preserve exact source when hashes match; cross-language targets emit declaration stubs until a real adapter provides stronger evidence:
 

package/bench/smoke.mjs

@@ -7,6 +7,7 @@ import {
   createProjectionTargetLossMatrix,
   createNativeSourcePreservation,
   createSemanticImportSidecar,
+  diffNativeSources,
   importExternalSemanticIndex,
   importNativeSource,
   projectNativeImportToSource,
@@ -135,6 +136,50 @@ 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 changeProjectionStart = performance.now();
+const changeProjectionSets = [];
+for (let index = 0; index < 80; index += 1) {
+  changeProjectionSets.push(diffNativeSources({
+    language: 'javascript',
+    sourcePath: `src/change-projection-${index}.js`,
+    beforeSourceText: `export function changeProjection${index}() { return ${index}; }\n`,
+    afterSourceText: `export function changeProjection${index}() { return ${index + 1}; }\nexport const changeProjectionFlag${index} = true;\n`
+  }));
+}
+const changeProjectionDurationMs = performance.now() - changeProjectionStart;
+const changedRegionProjections = changeProjectionSets.reduce((sum, changeSet) => sum + changeSet.metadata.changedRegionProjectionSummary.withProjection, 0);
+const changedRegionProjectionSourceMapLinks = changeProjectionSets.reduce((sum, changeSet) => sum + changeSet.metadata.changedRegionProjectionSummary.sourceMapLinks, 0);
+
 const externalSemanticStart = performance.now();
 const externalSemanticImports = [];
 for (let index = 0; index < 100; index += 1) {
@@ -208,6 +253,14 @@ console.log(JSON.stringify({
   nativeTargetAdapterBytes,
   nativeTargetAdapterSourceMaps,
   nativeTargetAdapterDurationMs: Number(nativeTargetAdapterDurationMs.toFixed(2)),
+  regionScanImports: regionScanImports.length,
+  regionScanSymbols,
+  regionScanOwnershipRegions,
+  regionScanDurationMs: Number(regionScanDurationMs.toFixed(2)),
+  changeProjectionSets: changeProjectionSets.length,
+  changedRegionProjections,
+  changedRegionProjectionSourceMapLinks,
+  changeProjectionDurationMs: Number(changeProjectionDurationMs.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;
 
@@ -782,6 +786,91 @@ export interface SemanticImportSidecarOptions {
 
 export type NativeSourceChangeKind = 'added' | 'removed' | 'modified' | 'unchanged';
 
+export interface NativeSourceChangeProjectionEndpoint {
+  readonly side: 'before' | 'after';
+  readonly importId?: string;
+  readonly sidecarId?: string;
+  readonly nativeSourceId?: string;
+  readonly nativeAstId?: string;
+  readonly semanticIndexId?: string;
+  readonly universalAstId?: string;
+  readonly sourcePath?: string;
+  readonly sourceHash?: string;
+  readonly sourcePreservationId?: string;
+  readonly exactSourceAvailable: boolean;
+  readonly ownershipRegionId?: string;
+  readonly ownershipKey?: string;
+  readonly ownershipRegionKind?: NativeImportRegionTaxonomyKind;
+  readonly sourceSpan?: SourceSpan;
+  readonly sourceMapIds: readonly string[];
+  readonly sourceMapMappingIds: readonly string[];
+}
+
+export interface NativeSourceChangeProjectionSourceMapLink {
+  readonly id: string;
+  readonly side: 'before' | 'after';
+  readonly sourceMapId?: string;
+  readonly sourceMapMappingId?: string;
+  readonly sourcePath?: string;
+  readonly sourceHash?: string;
+  readonly targetPath?: string;
+  readonly targetHash?: string;
+  readonly semanticSymbolId?: string;
+  readonly semanticOccurrenceId?: string;
+  readonly semanticNodeId?: string;
+  readonly nativeSourceId?: string;
+  readonly nativeAstNodeId?: string;
+  readonly precision?: string;
+  readonly sourceSpan?: SourceSpan;
+  readonly generatedSpan?: SourceMapMappingRecord['generatedSpan'];
+  readonly ownershipRegionId?: string;
+  readonly ownershipRegionKey?: string;
+  readonly ownershipRegionKind?: NativeImportRegionTaxonomyKind;
+}
+
+export interface NativeSourceChangeProjectionMetadata {
+  readonly schema: 'frontier.lang.changedRegionProjection.v1';
+  readonly id: string;
+  readonly reviewRequired: true;
+  readonly autoMergeClaim: false;
+  readonly changeKind: NativeSourceChangeKind;
+  readonly language?: FrontierSourceLanguage | string;
+  readonly sourcePath?: string;
+  readonly conflictKey: string;
+  readonly region: {
+    readonly id?: string;
+    readonly key?: string;
+    readonly kind?: NativeImportRegionTaxonomyKind;
+    readonly granularity?: string;
+    readonly precision?: string;
+    readonly sourceSpan?: SourceSpan;
+    readonly nativeAstNodeId?: string;
+    readonly symbolId?: string;
+    readonly symbolName?: string;
+    readonly symbolKind?: string;
+  };
+  readonly before?: NativeSourceChangeProjectionEndpoint;
+  readonly after?: NativeSourceChangeProjectionEndpoint;
+  readonly sourceMapLinks: readonly NativeSourceChangeProjectionSourceMapLink[];
+  readonly admission: {
+    readonly readiness: SemanticMergeReadiness;
+    readonly action: 'review-addition' | 'review-removal' | 'review-file' | 'review-port' | 'rerun-or-human-port' | string;
+    readonly reasons: readonly string[];
+    readonly conflictKeys: readonly string[];
+  };
+}
+
+export interface NativeSourceChangeProjectionSummary {
+  readonly schema: 'frontier.lang.changedRegionProjectionSummary.v1';
+  readonly total: number;
+  readonly withProjection: number;
+  readonly reviewRequired: number;
+  readonly autoMergeClaims: number;
+  readonly sourceMapLinks: number;
+  readonly byAction: Readonly<Record<string, number>>;
+  readonly byRegionKind: Readonly<Record<string, number>>;
+}
+
 export interface NativeSourceChangeSymbol {
   readonly changeKind: NativeSourceChangeKind;
   readonly key: string;
@@ -809,6 +898,9 @@ export interface NativeSourceChangeSymbol {
 export interface NativeSourceChangeRegion extends SemanticImportOwnershipRegion {
   readonly changeKind: NativeSourceChangeKind;
   readonly conflictKey: string;
+  readonly metadata?: SemanticImportOwnershipRegion['metadata'] & {
+    readonly changedRegionProjection?: NativeSourceChangeProjectionMetadata;
+  };
 }
 
 export interface NativeSourceChangeSummary {
@@ -871,7 +963,9 @@ export interface NativeSourceChangeSet {
   readonly semanticIndex?: SemanticIndexRecord;
   readonly losses: readonly NativeAstLossRecord[];
   readonly summary: NativeSourceChangeSummary;
-  readonly metadata?: Record<string, unknown>;
+  readonly metadata?: Record<string, unknown> & {
+    readonly changedRegionProjectionSummary?: NativeSourceChangeProjectionSummary;
+  };
 }
 
 export type NativeImporterAdapterExactness =

package/dist/index.js

@@ -262,6 +262,10 @@ export const NativeImportRegionTaxonomyKinds = Object.freeze([
   'call',
   'type',
   'effect',
+  'property',
+  'config',
+  'content',
+  'route',
   'generatedOutput'
 ]);
 
@@ -3154,6 +3158,25 @@ export function diffNativeSourceImports(input) {
   if (sourceChanged && changedSymbols.length === 0 && changedRegions.length === 0) {
     changedRegions = [fileLevelNativeChangeRegion({ language, sourcePath, beforeHash, afterHash, before, after })];
   }
+  const readiness = maxSemanticMergeReadiness(
+    maxSemanticMergeReadiness(nativeImportReadiness(before), nativeImportReadiness(after)),
+    sourceChanged && changedSymbols.length === 0 ? 'needs-review' : 'ready'
+  );
+  const reasons = nativeSourceChangeReasons({ before, after, beforeHash, afterHash, changedSymbols, changedRegions, readiness });
+  changedRegions = attachNativeChangeRegionProjectionMetadata(changedRegions, {
+    before,
+    after,
+    beforeSidecar,
+    afterSidecar,
+    changedSymbols,
+    language,
+    sourcePath,
+    beforeHash,
+    afterHash,
+    readiness,
+    reasons
+  });
+  const changedRegionProjectionSummary = summarizeNativeChangedRegionProjections(changedRegions);
   const evidence = [{
     id: input.evidenceId ?? `evidence_${idPart}_native_source_diff`,
     kind: 'import',
@@ -3168,14 +3191,10 @@ export function diffNativeSourceImports(input) {
       sourceChanged,
       addedSymbols: changedSymbols.filter((symbol) => symbol.changeKind === 'added').length,
       removedSymbols: changedSymbols.filter((symbol) => symbol.changeKind === 'removed').length,
-      modifiedSymbols: changedSymbols.filter((symbol) => symbol.changeKind === 'modified').length
+      modifiedSymbols: changedSymbols.filter((symbol) => symbol.changeKind === 'modified').length,
+      changedRegionProjectionSummary
     }
   }];
-  const readiness = maxSemanticMergeReadiness(
-    maxSemanticMergeReadiness(nativeImportReadiness(before), nativeImportReadiness(after)),
-    sourceChanged && changedSymbols.length === 0 ? 'needs-review' : 'ready'
-  );
-  const reasons = nativeSourceChangeReasons({ before, after, beforeHash, afterHash, changedSymbols, changedRegions, readiness });
   const conflictKeys = uniqueStrings([
     ...changedSymbols.map((symbol) => symbol.conflictKey),
     ...changedRegions.map((region) => region.conflictKey ?? region.key ?? region.id),
@@ -3226,7 +3245,8 @@ export function diffNativeSourceImports(input) {
       beforeImportId: before?.id,
       afterImportId: after?.id,
       sourceChanged,
-      changeSummary: nativeSourceChangeSummary(changedSymbols, changedRegions, sourceChanged)
+      changeSummary: nativeSourceChangeSummary(changedSymbols, changedRegions, sourceChanged),
+      changedRegionProjectionSummary
     }
   });
   return {
@@ -3255,6 +3275,7 @@ export function diffNativeSourceImports(input) {
       afterSidecarId: afterSidecar?.id,
       beforeImportContract: before?.metadata?.importResultContract,
       afterImportContract: after?.metadata?.importResultContract,
+      changedRegionProjectionSummary,
       ...input.metadata
     }
   };
@@ -3400,6 +3421,199 @@ function fileLevelNativeChangeRegion(input) {
   };
 }
 
+function attachNativeChangeRegionProjectionMetadata(regions, context) {
+  return (regions ?? []).map((region) => {
+    const projection = nativeChangedRegionProjectionMetadata(region, context);
+    return {
+      ...region,
+      metadata: {
+        ...(region.metadata ?? {}),
+        changedRegionProjection: projection
+      }
+    };
+  });
+}
+
+function nativeChangedRegionProjectionMetadata(region, context) {
+  const beforeRegion = findSemanticImportRegion(context.beforeSidecar, region);
+  const afterRegion = findSemanticImportRegion(context.afterSidecar, region);
+  const regionSymbols = (context.changedSymbols ?? []).filter((symbol) => nativeChangeSymbolTouchesRegion(symbol, region));
+  const sourceMapLinks = uniqueRecordsById([
+    ...nativeChangeProjectionSourceMapLinks(context.before, 'before', beforeRegion ?? region, regionSymbols),
+    ...nativeChangeProjectionSourceMapLinks(context.after, 'after', afterRegion ?? region, regionSymbols)
+  ]).slice(0, 24);
+  const action = nativeChangedRegionProjectionAction(region, context.readiness);
+  const conflictKeys = uniqueStrings([
+    region.conflictKey,
+    region.key ? `region:${region.key}` : undefined,
+    region.id ? `region:${region.id}` : undefined,
+    ...regionSymbols.map((symbol) => symbol.conflictKey)
+  ].filter(Boolean));
+  return {
+    schema: 'frontier.lang.changedRegionProjection.v1',
+    id: `changed_region_projection_${idFragment(region.conflictKey ?? region.key ?? region.id)}`,
+    reviewRequired: true,
+    autoMergeClaim: false,
+    changeKind: region.changeKind,
+    language: region.language ?? context.language,
+    sourcePath: region.sourcePath ?? context.sourcePath,
+    conflictKey: region.conflictKey,
+    region: {
+      id: region.id,
+      key: region.key,
+      kind: region.regionKind,
+      granularity: region.granularity,
+      precision: region.precision,
+      sourceSpan: region.sourceSpan,
+      nativeAstNodeId: region.nativeAstNodeId,
+      symbolId: region.symbolId,
+      symbolName: region.symbolName,
+      symbolKind: region.symbolKind
+    },
+    before: nativeChangeProjectionEndpoint(context.before, context.beforeSidecar, beforeRegion ?? (region.changeKind === 'added' ? undefined : region), 'before'),
+    after: nativeChangeProjectionEndpoint(context.after, context.afterSidecar, afterRegion ?? (region.changeKind === 'removed' ? undefined : region), 'after'),
+    sourceMapLinks,
+    admission: {
+      readiness: context.readiness,
+      action,
+      reasons: context.reasons ?? [],
+      conflictKeys
+    }
+  };
+}
+
+function findSemanticImportRegion(sidecar, region) {
+  return (sidecar?.ownershipRegions ?? []).find((candidate) => (
+    (region.id && candidate.id === region.id) ||
+    (region.key && candidate.key === region.key)
+  ));
+}
+
+function nativeChangeProjectionEndpoint(imported, sidecar, region, side) {
+  if (!imported && !region) return undefined;
+  const preservation = nativeImportSourcePreservationRecord(imported);
+  const sourceMaps = imported?.sourceMaps ?? imported?.universalAst?.sourceMaps ?? [];
+  const regionMappings = sourceMaps
+    .flatMap((sourceMap) => (sourceMap?.mappings ?? []).map((mapping) => ({ sourceMap, mapping })))
+    .filter(({ mapping }) => nativeChangeMappingTouchesRegion(mapping, region, []));
+  return {
+    side,
+    importId: imported?.id,
+    sidecarId: sidecar?.id,
+    nativeSourceId: imported?.nativeSource?.id,
+    nativeAstId: imported?.nativeAst?.id,
+    semanticIndexId: imported?.semanticIndex?.id,
+    universalAstId: imported?.universalAst?.id,
+    sourcePath: imported?.sourcePath ?? region?.sourcePath,
+    sourceHash: imported?.nativeSource?.sourceHash ?? imported?.nativeAst?.sourceHash ?? region?.sourceHash,
+    sourcePreservationId: preservation?.id,
+    exactSourceAvailable: preservation?.summary?.exactSourceAvailable === true,
+    ownershipRegionId: region?.id,
+    ownershipKey: region?.key,
+    ownershipRegionKind: region?.regionKind,
+    sourceSpan: region?.sourceSpan,
+    sourceMapIds: sourceMaps.map((sourceMap) => sourceMap?.id).filter(Boolean),
+    sourceMapMappingIds: regionMappings.map(({ mapping }) => mapping?.id).filter(Boolean)
+  };
+}
+
+function nativeChangeProjectionSourceMapLinks(imported, side, region, symbols) {
+  if (!imported) return [];
+  const sourceMaps = imported.sourceMaps ?? imported.universalAst?.sourceMaps ?? [];
+  const links = [];
+  for (const sourceMap of sourceMaps) {
+    for (const mapping of sourceMap?.mappings ?? []) {
+      if (!nativeChangeMappingTouchesRegion(mapping, region, symbols)) continue;
+      links.push({
+        id: `${side}:${sourceMap.id}:${mapping.id}`,
+        side,
+        sourceMapId: sourceMap.id,
+        sourceMapMappingId: mapping.id,
+        sourcePath: mapping.sourceSpan?.path ?? sourceMap.sourcePath ?? imported.sourcePath,
+        sourceHash: sourceMap.sourceHash ?? imported.nativeSource?.sourceHash ?? imported.nativeAst?.sourceHash,
+        targetPath: mapping.generatedSpan?.targetPath ?? sourceMap.targetPath,
+        targetHash: mapping.generatedSpan?.targetHash ?? sourceMap.targetHash,
+        semanticSymbolId: mapping.semanticSymbolId,
+        semanticOccurrenceId: mapping.semanticOccurrenceId,
+        semanticNodeId: mapping.semanticNodeId,
+        nativeSourceId: mapping.nativeSourceId,
+        nativeAstNodeId: mapping.nativeAstNodeId,
+        precision: mapping.precision,
+        sourceSpan: mapping.sourceSpan,
+        generatedSpan: mapping.generatedSpan,
+        ownershipRegionId: mapping.ownershipRegionId,
+        ownershipRegionKey: mapping.ownershipRegionKey,
+        ownershipRegionKind: mapping.ownershipRegionKind
+      });
+    }
+  }
+  return links;
+}
+
+function nativeChangeMappingTouchesRegion(mapping, region, symbols) {
+  if (!mapping || !region) return false;
+  const symbolIds = new Set((symbols ?? []).map((symbol) => symbol.id).filter(Boolean));
+  const occurrenceIds = new Set((symbols ?? []).map((symbol) => symbol.semanticOccurrenceId).filter(Boolean));
+  const mappingIds = new Set((symbols ?? []).map((symbol) => symbol.sourceMapMappingId).filter(Boolean));
+  if (mappingIds.has(mapping.id)) return true;
+  if (region.id && mapping.ownershipRegionId === region.id) return true;
+  if (region.key && mapping.ownershipRegionKey === region.key) return true;
+  if (region.nativeAstNodeId && mapping.nativeAstNodeId === region.nativeAstNodeId) return true;
+  if (symbolIds.has(mapping.semanticSymbolId)) return true;
+  if (occurrenceIds.has(mapping.semanticOccurrenceId)) return true;
+  if (region.granularity === 'file') {
+    return !region.sourcePath || sourceSpanPathMatches(mapping.sourceSpan, region.sourcePath);
+  }
+  return false;
+}
+
+function sourceSpanPathMatches(span, sourcePath) {
+  if (!span || !sourcePath) return false;
+  return span.path === sourcePath || span.sourceId === sourcePath;
+}
+
+function nativeChangeSymbolTouchesRegion(symbol, region) {
+  return Boolean(symbol && region && (
+    (region.id && symbol.ownershipRegionId === region.id) ||
+    (region.key && (
+      symbol.ownershipKey === region.key ||
+      symbol.beforeOwnershipKey === region.key ||
+      symbol.afterOwnershipKey === region.key
+    ))
+  ));
+}
+
+function nativeChangedRegionProjectionAction(region, readiness) {
+  if (readiness === 'blocked') return 'rerun-or-human-port';
+  if (region.changeKind === 'added') return 'review-addition';
+  if (region.changeKind === 'removed') return 'review-removal';
+  if (region.granularity === 'file') return 'review-file';
+  return 'review-port';
+}
+
+function nativeImportSourcePreservationRecord(imported) {
+  return imported?.metadata?.sourcePreservation
+    ?? imported?.nativeSource?.metadata?.sourcePreservation
+    ?? imported?.nativeAst?.metadata?.sourcePreservation
+    ?? imported?.universalAst?.metadata?.sourcePreservation;
+}
+
+function summarizeNativeChangedRegionProjections(regions) {
+  const projections = (regions ?? [])
+    .map((region) => region?.metadata?.changedRegionProjection)
+    .filter(Boolean);
+  return {
+    schema: 'frontier.lang.changedRegionProjectionSummary.v1',
+    total: regions?.length ?? 0,
+    withProjection: projections.length,
+    reviewRequired: projections.filter((projection) => projection.reviewRequired === true).length,
+    autoMergeClaims: projections.filter((projection) => projection.autoMergeClaim === true).length,
+    sourceMapLinks: projections.reduce((sum, projection) => sum + (projection.sourceMapLinks?.length ?? 0), 0),
+    byAction: countBy(projections.map((projection) => projection.admission?.action ?? 'unknown')),
+    byRegionKind: countBy(projections.map((projection) => projection.region?.kind ?? 'unknown'))
+  };
+}
+
 function nativeImportReadiness(imported) {
   return imported?.metadata?.semanticMergeReadiness
     ?? imported?.metadata?.nativeImportLossSummary?.semanticMergeReadiness
@@ -3463,11 +3677,31 @@ function nativeChangeSpans(changedSymbols, changedRegions, input) {
       symbolId: region.symbolId,
       span: region.sourceSpan,
       conflictKey: region.conflictKey ?? `region:${region.key ?? region.id}`,
-      metadata: { changeKind: region.changeKind, regionKind: region.regionKind, granularity: region.granularity }
+      metadata: {
+        changeKind: region.changeKind,
+        regionKind: region.regionKind,
+        granularity: region.granularity,
+        ...(region.metadata?.changedRegionProjection ? {
+          changedRegionProjection: nativeChangedRegionProjectionSpanMetadata(region.metadata.changedRegionProjection)
+        } : {})
+      }
     }));
   return uniqueRecordsById([...symbolSpans, ...regionSpans]);
 }
 
+function nativeChangedRegionProjectionSpanMetadata(projection) {
+  return {
+    schema: projection.schema,
+    id: projection.id,
+    reviewRequired: projection.reviewRequired,
+    autoMergeClaim: projection.autoMergeClaim,
+    beforeSourceHash: projection.before?.sourceHash,
+    afterSourceHash: projection.after?.sourceHash,
+    sourceMapLinks: projection.sourceMapLinks?.length ?? 0,
+    admission: projection.admission
+  };
+}
+
 function nativeSourceChangeSummary(changedSymbols, changedRegions, sourceChanged) {
   return {
     sourceChanged,
@@ -4019,10 +4253,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 +4297,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 +4331,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 +5248,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 +5259,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 +7121,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.25",
   "description": "Compiler facade for Frontier Lang source documents and language projection adapters.",
   "type": "module",
   "main": "./dist/index.js",