@shapeshift-labs/frontier-lang-compiler 0.2.53 → 0.2.55

package/README.md

@@ -19,6 +19,19 @@ const result = compileFrontierSource(source, { target: 'typescript' });
 if (result.ok) console.log(result.output);
 ```
 
+Run a small end-to-end demo after installing or building the package:
+
+```sh
+npm run build
+node examples/native-js-to-rust-demo.mjs
+```
+
+The demo prints JavaScript source, the Frontier universal AST/semantic-index summary,
+Rust declaration stubs, a host-adapter Rust projection, and a direct Frontier-source
+to Rust projection. Native JavaScript projection remains loss-aware: without a
+target adapter the compiler emits review-required stubs rather than claiming a
+lossless JS-to-Rust transpilation.
+
 Emit code with declaration-level source-map sidecars for semantic review and merge admission:
 
 ```js

package/bench/smoke.mjs

@@ -97,6 +97,7 @@ console.log(JSON.stringify({
   nativeTargetAdapterDurationMs: Number(transformMetrics.nativeTargetAdapterDurationMs.toFixed(2)),
   regionScanImports: sourceChangeMetrics.regionScanImports,
   regionScanSymbols: sourceChangeMetrics.regionScanSymbols,
+  regionScanDependencyRelations: sourceChangeMetrics.regionScanDependencyRelations,
   regionScanOwnershipRegions: sourceChangeMetrics.regionScanOwnershipRegions,
   regionScanDurationMs: Number(sourceChangeMetrics.regionScanDurationMs.toFixed(2)),
   changeProjectionSets: sourceChangeMetrics.changeProjectionSets,

package/bench/source-change-suite.mjs

@@ -22,6 +22,7 @@ function measureRegionScan() {
       language: 'typescript',
       sourcePath: `src/regions-${index}.ts`,
       sourceText: `
+      export function normalizeCount${index}(value) { return value; }
       export const appRoutes${index} = [
         { path: "/${index}", component: Screen${index} },
         { path: "/${index}/settings", component: Settings${index} }
@@ -31,7 +32,7 @@ function measureRegionScan() {
         legal: { title: "Legal ${index}" }
       };
       export const runtimeConfig${index} = {
-        limits: { count: ${index} },
+        limits: { count: normalizeCount${index}(${index}) },
         resolve(id) { return id; }
       };
       export const helpers${index} = {
@@ -45,6 +46,7 @@ function measureRegionScan() {
   return {
     regionScanImports: regionScanImports.length,
     regionScanSymbols: regionScanImports.reduce((sum, entry) => sum + entry.imported.semanticIndex.symbols.length, 0),
+    regionScanDependencyRelations: regionScanImports.reduce((sum, entry) => sum + entry.sidecar.dependencies.total, 0),
     regionScanOwnershipRegions: regionScanImports.reduce((sum, entry) => sum + entry.sidecar.ownershipRegions.length, 0),
     regionScanDurationMs
   };

package/dist/declarations/semantic-sidecar.d.ts

@@ -132,6 +132,7 @@ export interface SemanticImportSidecarImportEntry {
   readonly universalAstLayerIds: readonly string[];
   readonly proofSpec: SemanticImportSidecarProofSpecSummary;
   readonly paradigmSemantics: SemanticImportSidecarParadigmSemanticsSummary;
+  readonly dependencyRelationCount: number; readonly dependencyPredicates: readonly string[];
   readonly readiness: SemanticMergeReadiness;
   readonly emptySemanticIndex: boolean;
   readonly regionTaxonomy?: SemanticImportRegionTaxonomySummary;
@@ -228,6 +229,13 @@ export interface SemanticImportSidecarParadigmSemanticsSummary {
   readonly empty: boolean;
 }
 
+export interface SemanticImportDependencySummary {
+  readonly total: number; readonly calls: number; readonly uses: number; readonly references: number;
+  readonly imports: number; readonly extends: number; readonly implements: number; readonly includes: number; readonly requires: number;
+  readonly byPredicate: Readonly<Record<string, number>>; readonly predicates: readonly string[];
+  readonly ids: readonly string[]; readonly sourceSymbolIds: readonly string[]; readonly targetSymbolIds: readonly string[];
+}
+
 export interface SemanticImportSidecar {
   readonly kind: 'frontier.lang.semanticImportSidecar';
   readonly version: 1;
@@ -238,11 +246,7 @@ export interface SemanticImportSidecar {
   readonly imports: readonly SemanticImportSidecarImportEntry[];
   readonly symbols: readonly SemanticImportSidecarSymbol[];
   readonly ownershipRegions: readonly SemanticImportOwnershipRegion[];
-  readonly sourceMaps: {
-    readonly total: number;
-    readonly mappings: number;
-    readonly ids: readonly string[];
-  };
+  readonly sourceMaps: { readonly total: number; readonly mappings: number; readonly ids: readonly string[] };
   readonly sourcePreservation: {
     readonly total: number;
     readonly ids: readonly string[];
@@ -259,6 +263,7 @@ export interface SemanticImportSidecar {
   readonly universalAstLayers: SemanticImportSidecarUniversalAstLayerSummary;
   readonly proofSpec: SemanticImportSidecarProofSpecSummary;
   readonly paradigmSemantics: SemanticImportSidecarParadigmSemanticsSummary;
+  readonly dependencies: SemanticImportDependencySummary;
   readonly patchHints: readonly SemanticImportPatchHint[];
   readonly quality: SemanticImportSidecarQuality;
   readonly admission: SemanticImportSidecarAdmission;
@@ -280,11 +285,7 @@ export interface SemanticImportSidecar {
     readonly reviewLossIds: readonly string[];
   };
   readonly regionTaxonomy: SemanticImportRegionTaxonomySummary;
-  readonly evidence: {
-    readonly total: number;
-    readonly failed: readonly string[];
-    readonly ids: readonly string[];
-  };
+  readonly evidence: { readonly total: number; readonly failed: readonly string[]; readonly ids: readonly string[] };
   readonly summary: {
     readonly imports: number;
     readonly symbols: number;
@@ -300,6 +301,7 @@ export interface SemanticImportSidecar {
     readonly paradigmSemanticsRecords: number;
     readonly paradigmSemanticsGroups: number;
     readonly paradigmSemanticsLoweringRecords: number;
+    readonly dependencyRelations: number; readonly dependencyPredicates: readonly string[];
     readonly patchHints: number;
     readonly evidenceWarnings: number;
     readonly readiness: SemanticMergeReadiness;

package/dist/internal/index-impl/createLightweightNativeImport.js

@@ -1,4 +1,4 @@
-import{idFragment}from'../../native-import-utils.js';import{lightweightCoverageLosses,scanNativeDeclarations}from'../../native-region-scanner.js';import{semanticOwnershipRegionForDeclaration}from'../../semantic-import-regions.js';import{createSemanticIndexRecord,hashSemanticValue}from'@shapeshift-labs/frontier-lang-kernel';
+import{idFragment}from'../../native-import-utils.js';import{lightweightDependencyRelations}from'../../lightweight-dependency-relations.js';import{lightweightCoverageLosses,scanNativeDeclarations}from'../../native-region-scanner.js';import{semanticOwnershipRegionForDeclaration}from'../../semantic-import-regions.js';import{createSemanticIndexRecord,hashSemanticValue}from'@shapeshift-labs/frontier-lang-kernel';
 export function createLightweightNativeImport(input) {
   const parser = input.parser ?? `${input.language}.lightweight-declaration-scan`;
   const rootId = 'native_root';
@@ -20,6 +20,7 @@ export function createLightweightNativeImport(input) {
   const facts = [];
   const mappings = [];
   const evidenceId = `evidence_${idFragment(input.sourcePath ?? input.language)}_lightweight_scan`;
+  const dependencies = lightweightDependencyRelations(input, declarations, documentId);
 
   for (const declaration of declarations) {
     const ownershipRegion = semanticOwnershipRegionForDeclaration(input, declaration, documentId);
@@ -105,6 +106,9 @@ export function createLightweightNativeImport(input) {
     }
     if (declaration.loss) losses.push(declaration.loss);
   }
+  occurrences.push(...dependencies.occurrences);
+  relations.push(...dependencies.relations);
+  facts.push(...dependencies.facts);
   losses.push(...lightweightCoverageLosses(input, declarations, input.sourcePreservation));
 
   const semanticIndex = createSemanticIndexRecord({
@@ -124,12 +128,13 @@ export function createLightweightNativeImport(input) {
       kind: 'import',
       status: 'passed',
       path: input.sourcePath,
-      summary: `Lightweight declaration scan found ${symbols.length} symbol(s).`,
-      metadata: { parser }
+      summary: `Lightweight declaration scan found ${symbols.length} symbol(s) and ${dependencies.summary.total} dependency edge(s).`,
+      metadata: { parser, dependencyRelations: dependencies.summary.total }
     }],
     metadata: {
       parser,
       coverage: 'declarations-only',
+      dependencyRelations: dependencies.summary,
       unsupported: ['full expression AST', 'type checking', 'control flow', 'comments and formatting preservation']
     }
   });
@@ -145,6 +150,8 @@ export function createLightweightNativeImport(input) {
       parser,
       scanKind: 'lightweight-declaration-scan',
       declarationCount: declarations.length,
+      dependencyRelationCount: dependencies.summary.total,
+      dependencyOccurrenceCount: dependencies.occurrences.length,
       ...(input.sourcePreservation ? {
         sourcePreservationId: input.sourcePreservation.id,
         sourcePreservationSummary: input.sourcePreservation.summary

package/dist/internal/index-impl/createSemanticImportSidecar.js

@@ -1,4 +1,4 @@
-import{idFragment,maxSemanticMergeReadiness,uniqueRecordsById}from'../../native-import-utils.js';import{summarizeSemanticImportSidecarParadigmSemantics,summarizeSemanticImportSidecarProofSpec,summarizeSemanticImportSidecarUniversalAstLayers}from'../../semantic-import-layers.js';import{semanticPatchHintForRegion,summarizeSemanticImportRegionTaxonomy}from'../../semantic-import-regions.js';import{semanticImportSidecarEntry}from'../../semantic-import-sidecar-entry.js';import{summarizeKernelSourcePreservation}from'../../semantic-import-source-preservation.js';
+import{idFragment,maxSemanticMergeReadiness,uniqueRecordsById}from'../../native-import-utils.js';import{summarizeSemanticImportDependencies}from'../../semantic-import-dependencies.js';import{summarizeSemanticImportSidecarParadigmSemantics,summarizeSemanticImportSidecarProofSpec,summarizeSemanticImportSidecarUniversalAstLayers}from'../../semantic-import-layers.js';import{semanticPatchHintForRegion,summarizeSemanticImportRegionTaxonomy}from'../../semantic-import-regions.js';import{semanticImportSidecarEntry}from'../../semantic-import-sidecar-entry.js';import{summarizeKernelSourcePreservation}from'../../semantic-import-source-preservation.js';
 import{createSemanticImportSidecarAdmission,createSemanticImportSidecarQuality}from'./createSemanticImportSidecarAdmission.js';
 import{summarizeNativeImportLosses}from'./summarizeNativeImportLosses.js';
 export function createSemanticImportSidecar(importResult, options = {}) {
@@ -17,9 +17,14 @@ export function createSemanticImportSidecar(importResult, options = {}) {
   const universalAstLayers = summarizeSemanticImportSidecarUniversalAstLayers(importEntries);
   const proofSpec = summarizeSemanticImportSidecarProofSpec(importEntries);
   const paradigmSemantics = summarizeSemanticImportSidecarParadigmSemantics(importEntries);
+  const dependencies = summarizeSemanticImportDependencies(imports);
+  const entryReadiness = importEntries.reduce(
+    (current, entry) => maxSemanticMergeReadiness(current, entry.readiness),
+    lossSummary.semanticMergeReadiness
+  );
   const readiness = mergeCandidates.reduce(
     (current, candidate) => maxSemanticMergeReadiness(current, candidate.readiness),
-    lossSummary.semanticMergeReadiness
+    entryReadiness
   );
   const patchHints = ownershipRegions.map((region) => semanticPatchHintForRegion(region, readiness, options));
   const quality = createSemanticImportSidecarQuality({
@@ -51,6 +56,7 @@ export function createSemanticImportSidecar(importResult, options = {}) {
     universalAstLayers,
     proofSpec,
     paradigmSemantics,
+    dependencies,
     patchHints,
     quality,
     admission,
@@ -92,6 +98,8 @@ export function createSemanticImportSidecar(importResult, options = {}) {
       paradigmSemanticsRecords: paradigmSemantics.total,
       paradigmSemanticsGroups: paradigmSemantics.groups.length,
       paradigmSemanticsLoweringRecords: paradigmSemantics.loweringRecords,
+      dependencyRelations: dependencies.total,
+      dependencyPredicates: dependencies.predicates,
       patchHints: patchHints.length,
       evidenceWarnings: quality.emptyEvidenceWarnings.length,
       readiness,

package/dist/internal/index-impl/treeSitterDeclaration.js

@@ -1,24 +1,32 @@
-import{declarationRecord}from'./declarationRecord.js';import{nativeNodeId}from'./nativeNodeId.js';import{shortNodeText}from'./shortNodeText.js';import{treeSitterFieldText}from'./treeSitterFieldText.js';
+import{declarationRecord}from'./declarationRecord.js';import{shortNodeText}from'./shortNodeText.js';import{treeSitterChildText,treeSitterFieldText}from'./treeSitterNodeAccess.js';
 export function treeSitterDeclaration(node, kind, nativeNodeId, input) {
   if (/import|include|use/.test(kind)) {
-    const name = treeSitterFieldText(node, 'path') ?? treeSitterFieldText(node, 'source') ?? shortNodeText(node);
+    const name = treeSitterNamedText(node, ['string', 'string_fragment', 'identifier']) ?? shortNodeText(node);
     if (name) return declarationRecord(input, nativeNodeId, name, 'module', 'import');
   }
   if (/function|method|fn_item|function_declaration/.test(kind)) {
-    const name = treeSitterFieldText(node, 'name');
+    const name = treeSitterNamedText(node, ['identifier', 'property_identifier']);
     if (name) return declarationRecord(input, nativeNodeId, name, 'function', 'definition');
   }
   if (/class/.test(kind)) {
-    const name = treeSitterFieldText(node, 'name');
+    const name = treeSitterNamedText(node, ['type_identifier', 'identifier']);
     if (name) return declarationRecord(input, nativeNodeId, name, 'class', 'definition');
   }
   if (/interface/.test(kind)) {
-    const name = treeSitterFieldText(node, 'name');
+    const name = treeSitterNamedText(node, ['type_identifier', 'identifier']);
     if (name) return declarationRecord(input, nativeNodeId, name, 'interface', 'definition');
   }
   if (/struct|enum|type/.test(kind)) {
-    const name = treeSitterFieldText(node, 'name');
+    const name = treeSitterNamedText(node, ['type_identifier', 'identifier']);
     if (name) return declarationRecord(input, nativeNodeId, name, 'type', 'definition');
   }
+  if (/variable_declarator|property_declaration|field_declaration/.test(kind)) {
+    const name = treeSitterNamedText(node, ['identifier', 'property_identifier', 'field_identifier']);
+    if (name) return declarationRecord(input, nativeNodeId, name, 'variable', 'definition');
+  }
   return undefined;
 }
+
+function treeSitterNamedText(node, childKinds) {
+  return treeSitterFieldText(node, 'name') ?? treeSitterFieldText(node, 'declarator') ?? treeSitterChildText(node, childKinds);
+}

package/dist/internal/index-impl/treeSitterFieldText.js

@@ -1,5 +1 @@
-import{shortNodeText}from'./shortNodeText.js';
-export function treeSitterFieldText(node, field) {
-  if (typeof node.childForFieldName !== 'function') return undefined;
-  return shortNodeText(node.childForFieldName(field));
-}
+export{treeSitterFieldText}from'./treeSitterNodeAccess.js';

package/dist/internal/index-impl/treeSitterNodeAccess.js

@@ -0,0 +1,75 @@
+import{shortNodeText}from'./shortNodeText.js';
+export function treeSitterNodeKind(node) {
+  return String(node?.type ?? node?.kind ?? 'node');
+}
+
+export function treeSitterChildren(node) {
+  const children = treeSitterArrayChildren(node, 'children');
+  if (children.length) return children;
+  const childCountChildren = treeSitterIndexedChildren(node, 'childCount', 'child');
+  if (childCountChildren.length) return childCountChildren;
+  const namedChildren = treeSitterArrayChildren(node, 'namedChildren');
+  if (namedChildren.length) return namedChildren;
+  return treeSitterIndexedChildren(node, 'namedChildCount', 'namedChild');
+}
+
+export function treeSitterChildText(node, kinds) {
+  const wanted = new Set(kinds);
+  const stack = [...treeSitterChildren(node)];
+  while (stack.length) {
+    const child = stack.shift();
+    if (!child || typeof child !== 'object') continue;
+    if (wanted.has(treeSitterNodeKind(child))) {
+      const text = shortNodeText(child);
+      if (text) return text;
+    }
+    stack.unshift(...treeSitterChildren(child));
+  }
+  return undefined;
+}
+
+export function treeSitterFieldText(node, field) {
+  const exact = treeSitterFieldNode(node, field);
+  if (exact) return shortNodeText(exact);
+  return treeSitterNamedFieldText(node, field);
+}
+
+function treeSitterFieldNode(node, field) {
+  if (typeof node?.childForFieldName === 'function') return node.childForFieldName(field);
+  if (typeof node?.child_by_field_name === 'function') return node.child_by_field_name(field);
+  return undefined;
+}
+
+function treeSitterNamedFieldText(node, field) {
+  for (const child of treeSitterChildren(node)) {
+    if (treeSitterFieldName(child) === field) {
+      const text = shortNodeText(child);
+      if (text) return text;
+    }
+  }
+  return undefined;
+}
+
+function treeSitterFieldName(node) {
+  if (typeof node?.fieldName === 'string') return node.fieldName;
+  if (typeof node?.field_name === 'string') return node.field_name;
+  if (typeof node?.fieldName === 'function') return node.fieldName();
+  if (typeof node?.field_name === 'function') return node.field_name();
+  return undefined;
+}
+
+function treeSitterArrayChildren(node, field) {
+  const value = node?.[field];
+  return Array.isArray(value) ? value.filter((child) => child && typeof child === 'object') : [];
+}
+
+function treeSitterIndexedChildren(node, countField, childMethod) {
+  const count = Number(node?.[countField]);
+  if (!Number.isFinite(count) || count <= 0 || typeof node?.[childMethod] !== 'function') return [];
+  const children = [];
+  for (let index = 0; index < count; index += 1) {
+    const child = node[childMethod](index);
+    if (child && typeof child === 'object') children.push(child);
+  }
+  return children;
+}

package/dist/internal/index-impl/visitTreeSitterNode.js

@@ -1,5 +1,5 @@
 import{idFragment}from'../../native-import-utils.js';
-import{nativeNodeId}from'./nativeNodeId.js';import{numberOrUndefined}from'./numberOrUndefined.js';import{shortNodeText}from'./shortNodeText.js';import{spanFromTreeSitterNode}from'./spanFromTreeSitterNode.js';import{treeSitterDeclaration}from'./treeSitterDeclaration.js';
+import{nativeNodeId}from'./nativeNodeId.js';import{numberOrUndefined}from'./numberOrUndefined.js';import{shortNodeText}from'./shortNodeText.js';import{spanFromTreeSitterNode}from'./spanFromTreeSitterNode.js';import{treeSitterDeclaration}from'./treeSitterDeclaration.js';import{treeSitterChildren,treeSitterNodeKind}from'./treeSitterNodeAccess.js';
 export function visitTreeSitterNode(node, context, propertyPath, depth = 0) {
   if (!node || typeof node !== 'object' || context.truncated) return undefined;
   if (context.objectIds.has(node)) return context.objectIds.get(node);
@@ -8,7 +8,7 @@ export function visitTreeSitterNode(node, context, propertyPath, depth = 0) {
     return undefined;
   }
   context.counter += 1;
-  const kind = String(node.type ?? node.kind ?? 'node');
+  const kind = treeSitterNodeKind(node);
   const span = spanFromTreeSitterNode(node, context.input);
   const id = nativeNodeId(context, kind, { start: { line: span?.startLine, column: span?.startColumn } }, propertyPath);
   context.objectIds.set(node, id);
@@ -82,32 +82,6 @@ export function visitTreeSitterNode(node, context, propertyPath, depth = 0) {
   return id;
 }
 
-function treeSitterChildren(node) {
-  const children = treeSitterArrayChildren(node, 'children');
-  if (children.length) return children;
-  const childCountChildren = treeSitterIndexedChildren(node, 'childCount', 'child');
-  if (childCountChildren.length) return childCountChildren;
-  const namedChildren = treeSitterArrayChildren(node, 'namedChildren');
-  if (namedChildren.length) return namedChildren;
-  return treeSitterIndexedChildren(node, 'namedChildCount', 'namedChild');
-}
-
-function treeSitterArrayChildren(node, field) {
-  const value = node[field];
-  return Array.isArray(value) ? value.filter((child) => child && typeof child === 'object') : [];
-}
-
-function treeSitterIndexedChildren(node, countField, childMethod) {
-  const count = Number(node[countField]);
-  if (!Number.isFinite(count) || count <= 0 || typeof node[childMethod] !== 'function') return [];
-  const children = [];
-  for (let index = 0; index < count; index += 1) {
-    const child = node[childMethod](index);
-    if (child && typeof child === 'object') children.push(child);
-  }
-  return children;
-}
-
 function treeSitterBoolean(node, ...fields) {
   for (const field of fields) {
     const value = node[field];

package/dist/lightweight-dependency-relations.js

@@ -0,0 +1,271 @@
+import { idFragment } from './native-import-utils.js';
+import { sourceLines } from './native-region-scanner-core.js';
+
+const jsLikeLanguages = new Set(['javascript', 'typescript']);
+const ignoredIdentifiers = new Set([
+  'async', 'await', 'break', 'case', 'catch', 'class', 'const', 'continue', 'default',
+  'delete', 'do', 'else', 'export', 'extends', 'false', 'finally', 'for', 'from',
+  'function', 'if', 'import', 'in', 'instanceof', 'let', 'new', 'null', 'of',
+  'return', 'static', 'super', 'switch', 'this', 'throw', 'true', 'try', 'typeof',
+  'undefined', 'var', 'void', 'while', 'with', 'yield'
+]);
+
+export function lightweightDependencyRelations(input, declarations, documentId) {
+  if (!jsLikeLanguages.has(String(input.language ?? '').toLowerCase())) {
+    return { relations: [], occurrences: [], facts: [], summary: emptySummary() };
+  }
+  const lines = sourceLines(input.sourceText);
+  const identifiers = declarationIdentifierMap(input, declarations, lines);
+  const records = { relations: [], occurrences: [], facts: [], seen: new Set() };
+  for (const scan of declarationScanRanges(declarations, lines)) {
+    scanDeclarationDependencies(input, documentId, scan, identifiers, lines, records);
+  }
+  return {
+    relations: records.relations,
+    occurrences: records.occurrences,
+    facts: records.facts,
+    summary: {
+      total: records.relations.length,
+      calls: records.relations.filter((relation) => relation.predicate === 'calls').length,
+      uses: records.relations.filter((relation) => relation.predicate === 'uses').length
+    }
+  };
+}
+
+function declarationIdentifierMap(input, declarations, lines) {
+  const identifiers = new Map();
+  for (const declaration of declarations ?? []) {
+    if (!declaration?.symbolId) continue;
+    const target = {
+      name: declaration.name,
+      symbolId: declaration.symbolId,
+      symbolKind: declaration.symbolKind,
+      nodeId: declaration.nodeId,
+      role: declaration.role
+    };
+    for (const identifier of identifiersForDeclaration(input, declaration, lines)) {
+      addIdentifierTarget(identifiers, identifier, target);
+    }
+  }
+  return identifiers;
+}
+
+function identifiersForDeclaration(input, declaration, lines) {
+  const identifiers = new Set();
+  addIdentifier(identifiers, declaration.name);
+  const parts = String(declaration.name ?? '').split('.');
+  addIdentifier(identifiers, parts[parts.length - 1]);
+  if (declaration.role === 'import') {
+    const line = lines[(declaration.span?.startLine ?? 1) - 1]?.line ?? '';
+    for (const identifier of importLocalIdentifiers(line)) addIdentifier(identifiers, identifier);
+    addIdentifier(identifiers, packageIdentifier(declaration.importPath ?? declaration.name));
+  }
+  return [...identifiers];
+}
+
+function importLocalIdentifiers(line) {
+  const source = String(line ?? '');
+  const identifiers = [];
+  let match = source.match(/^import\s+([A-Za-z_$][\w$]*)\s+from\b/);
+  if (match) identifiers.push(match[1]);
+  match = source.match(/^import\s+\*\s+as\s+([A-Za-z_$][\w$]*)\s+from\b/);
+  if (match) identifiers.push(match[1]);
+  match = source.match(/^import\s+[^,{]+,\s*\{([^}]+)\}\s+from\b/);
+  if (match) identifiers.push(...namedImportIdentifiers(match[1]));
+  match = source.match(/^import\s+\{([^}]+)\}\s+from\b/);
+  if (match) identifiers.push(...namedImportIdentifiers(match[1]));
+  return identifiers;
+}
+
+function namedImportIdentifiers(raw) {
+  return String(raw ?? '')
+    .split(',')
+    .map((part) => part.trim().split(/\s+as\s+/i).pop()?.trim())
+    .filter(Boolean);
+}
+
+function packageIdentifier(value) {
+  const parts = String(value ?? '').split('/').filter(Boolean);
+  const last = parts[parts.length - 1] ?? value;
+  return String(last).replace(/[^A-Za-z0-9_$]/g, '');
+}
+
+function addIdentifierTarget(map, identifier, target) {
+  if (!isIdentifier(identifier)) return;
+  const existing = map.get(identifier) ?? [];
+  if (!existing.some((entry) => entry.symbolId === target.symbolId)) existing.push(target);
+  map.set(identifier, existing);
+}
+
+function addIdentifier(set, value) {
+  if (isIdentifier(value)) set.add(value);
+}
+
+function isIdentifier(value) {
+  const text = String(value ?? '');
+  return /^[A-Za-z_$][\w$]*$/.test(text) && !ignoredIdentifiers.has(text);
+}
+
+function declarationScanRanges(declarations, lines) {
+  return (declarations ?? [])
+    .filter((declaration) => declaration?.symbolId && declaration.role !== 'import')
+    .map((declaration) => ({
+      declaration,
+      startLine: declaration.span?.startLine ?? 1,
+      endLine: declarationScanEndLine(declaration, lines)
+    }));
+}
+
+function declarationScanEndLine(declaration, lines) {
+  const startLine = declaration.span?.startLine ?? 1;
+  if (!declaration.metadata?.hasBody || declaration.kind === 'ClassDeclaration') return startLine;
+  return balancedRegionEndLine(lines, startLine);
+}
+
+function balancedRegionEndLine(lines, startLine) {
+  const state = { inBlockComment: false, inTemplateString: false };
+  let depth = 0;
+  let opened = false;
+  for (let index = Math.max(0, startLine - 1); index < lines.length; index += 1) {
+    for (const char of maskReferenceLine(lines[index].line, state)) {
+      if (char === '{' || char === '[' || char === '(') {
+        depth += 1;
+        opened = true;
+      } else if (char === '}' || char === ']' || char === ')') {
+        depth -= 1;
+      }
+    }
+    if (opened && depth <= 0) return lines[index].number;
+  }
+  return startLine;
+}
+
+function scanDeclarationDependencies(input, documentId, scan, identifiers, lines, records) {
+  const state = { inBlockComment: false, inTemplateString: false };
+  for (let lineNumber = scan.startLine; lineNumber <= scan.endLine; lineNumber += 1) {
+    const scanLine = maskReferenceLine(lines[lineNumber - 1]?.line ?? '', state);
+    for (const match of scanLine.matchAll(/[A-Za-z_$][\w$]*/g)) {
+      const name = match[0];
+      if (ignoredIdentifiers.has(name) || !identifiers.has(name)) continue;
+      const targets = identifiers.get(name).filter((target) => target.symbolId !== scan.declaration.symbolId);
+      for (const target of targets) {
+        addDependencyRecord(input, documentId, scan.declaration, target, {
+          line: scanLine,
+          lineNumber,
+          startColumn: match.index + 1,
+          name
+        }, records);
+      }
+    }
+  }
+}
+
+function addDependencyRecord(input, documentId, caller, target, occurrence, records) {
+  const predicate = isCallReference(occurrence.line, occurrence.startColumn + occurrence.name.length - 1) ? 'calls' : 'uses';
+  const key = `${caller.symbolId}|${predicate}|${target.symbolId}|${occurrence.lineNumber}|${occurrence.startColumn}`;
+  if (records.seen.has(key)) return;
+  records.seen.add(key);
+  const relationId = `rel_${idFragment(caller.symbolId)}_${predicate}_${idFragment(target.symbolId)}_${occurrence.lineNumber}_${occurrence.startColumn}`;
+  const occurrenceId = `occ_${idFragment(caller.nodeId)}_${predicate}_${idFragment(target.symbolId)}_${occurrence.lineNumber}_${occurrence.startColumn}`;
+  const span = {
+    sourceId: input.sourceHash,
+    path: input.sourcePath,
+    startLine: occurrence.lineNumber,
+    endLine: occurrence.lineNumber,
+    startColumn: occurrence.startColumn,
+    endColumn: occurrence.startColumn + occurrence.name.length
+  };
+  records.relations.push({
+    id: relationId,
+    sourceId: caller.symbolId,
+    predicate,
+    targetId: target.symbolId,
+    metadata: {
+      scan: 'lightweight-dependency',
+      confidence: 'lexical-reference',
+      sourceDocumentId: documentId,
+      sourceName: caller.name,
+      targetName: target.name
+    }
+  });
+  records.occurrences.push({
+    id: occurrenceId,
+    documentId,
+    symbolId: target.symbolId,
+    role: 'reference',
+    span,
+    nativeAstNodeId: caller.nodeId
+  });
+  records.facts.push({
+    id: `fact_${idFragment(relationId)}_lightweight_dependency`,
+    predicate: 'lightweightDependency',
+    subjectId: caller.symbolId,
+    value: {
+      relationId,
+      predicate,
+      targetId: target.symbolId,
+      line: occurrence.lineNumber,
+      confidence: 'lexical-reference'
+    }
+  });
+}
+
+function isCallReference(line, afterIdentifierIndex) {
+  return /^\s*\(/.test(String(line ?? '').slice(afterIdentifierIndex));
+}
+
+function maskReferenceLine(line, state) {
+  const text = String(line ?? '');
+  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 (state.inBlockComment) {
+      output += ' ';
+      if (char === '*' && next === '/') {
+        output += ' ';
+        index += 1;
+        state.inBlockComment = false;
+      }
+      continue;
+    }
+    if (state.inTemplateString) {
+      output += ' ';
+      if (char === '`' && !escaped) state.inTemplateString = false;
+      escaped = char === '\\' && !escaped;
+      continue;
+    }
+    if (quote) {
+      output += ' ';
+      if (escaped) escaped = false;
+      else if (char === '\\') escaped = true;
+      else if (char === quote) quote = undefined;
+      continue;
+    }
+    if (char === '/' && next === '/') break;
+    if (char === '/' && next === '*') {
+      output += '  ';
+      index += 1;
+      state.inBlockComment = true;
+      continue;
+    }
+    if (char === '\'' || char === '"') {
+      output += ' ';
+      quote = char;
+      continue;
+    }
+    if (char === '`') {
+      output += ' ';
+      state.inTemplateString = true;
+      continue;
+    }
+    output += char;
+  }
+  return output;
+}
+
+function emptySummary() {
+  return { total: 0, calls: 0, uses: 0 };
+}

package/dist/semantic-import-dependencies.js

@@ -0,0 +1,62 @@
+import { countBy, uniqueRecordsById, uniqueStrings } from './native-import-utils.js';
+
+function summarizeSemanticImportDependencies(imports) {
+  return summarizeSemanticImportDependencyRelations((imports ?? [])
+    .flatMap((imported) => imported?.semanticIndex?.relations ?? imported?.universalAst?.semanticIndex?.relations ?? []));
+}
+
+function summarizeSemanticImportDependencyRelations(relations) {
+  const dependencyRelations = uniqueRecordsById((relations ?? []).filter(isDependencyRelation));
+  const predicateKeys = dependencyRelations.map((relation) => semanticDependencyPredicateKey(relation.predicate));
+  const byPredicate = countBy(predicateKeys);
+  return {
+    total: dependencyRelations.length,
+    calls: byPredicate.calls ?? 0,
+    uses: byPredicate.uses ?? 0,
+    references: byPredicate.references ?? 0,
+    imports: byPredicate.imports ?? 0,
+    extends: byPredicate.extends ?? 0,
+    implements: byPredicate.implements ?? 0,
+    includes: byPredicate.includes ?? 0,
+    requires: byPredicate.requires ?? 0,
+    byPredicate,
+    predicates: uniqueStrings(predicateKeys),
+    ids: dependencyRelations.map((relation) => relation.id).filter(Boolean),
+    sourceSymbolIds: uniqueStrings(dependencyRelations.map((relation) => relation.sourceId).filter(Boolean)),
+    targetSymbolIds: uniqueStrings(dependencyRelations.map((relation) => relation.targetId).filter(Boolean))
+  };
+}
+
+function isDependencyRelation(relation) {
+  const predicate = String(relation?.predicate ?? '').toLowerCase();
+  if (!predicate || predicate === 'defines' || predicate === 'definitionof') return false;
+  return predicate === 'imports'
+    || predicate === 'calls'
+    || predicate === 'uses'
+    || predicate.includes('reference')
+    || predicate.includes('depend')
+    || predicate.includes('require')
+    || predicate.includes('include')
+    || predicate.includes('extend')
+    || predicate.includes('implement');
+}
+
+function semanticDependencyPredicateKey(predicate) {
+  const value = String(predicate ?? 'unknown').toLowerCase();
+  if (value.includes('call')) return 'calls';
+  if (value.includes('reference')) return 'references';
+  if (value.includes('import')) return 'imports';
+  if (value.includes('depend')) return 'depends';
+  if (value.includes('require')) return 'requires';
+  if (value.includes('include')) return 'includes';
+  if (value.includes('extend')) return 'extends';
+  if (value.includes('implement')) return 'implements';
+  if (value === 'uses') return 'uses';
+  return value || 'unknown';
+}
+
+export {
+  semanticDependencyPredicateKey,
+  summarizeSemanticImportDependencies,
+  summarizeSemanticImportDependencyRelations
+};

package/dist/semantic-import-sidecar-entry.js

@@ -1,4 +1,5 @@
 import { uniqueRecordsById, uniqueStrings } from './native-import-utils.js';
+import { summarizeSemanticImportDependencyRelations } from './semantic-import-dependencies.js';
 import { semanticOwnershipRegionForSymbol, summarizeSemanticImportRegionTaxonomy } from './semantic-import-regions.js';
 import { collectKernelSourcePreservationFromImport } from './semantic-import-source-preservation.js';
 import {
@@ -16,6 +17,8 @@ function semanticImportSidecarEntry(imported, index, options) {
   const universalAstLayers = summarizeUniversalAstLayers(imported?.universalAst);
   const proofSpec = summarizeProofSpecLayer(imported?.universalAst?.proof ?? imported?.proof);
   const paradigmSemantics = summarizeParadigmSemanticsLayer(imported?.universalAst?.paradigmSemantics ?? imported?.paradigmSemantics);
+  const dependencies = summarizeSemanticImportDependencyRelations(semanticIndex?.relations ?? []);
+  const readiness = semanticImportEntryReadiness(imported);
   const mappingsBySymbolId = new Map();
   for (const mapping of sourceMapMappings) {
     if (mapping.semanticSymbolId && !mappingsBySymbolId.has(mapping.semanticSymbolId)) {
@@ -42,7 +45,7 @@ function semanticImportSidecarEntry(imported, index, options) {
       ownershipRegionId: region.id,
       ownershipKey: region.key,
       ownershipRegionKind: region.regionKind,
-      readiness: imported?.metadata?.semanticMergeReadiness ?? imported?.mergeCandidates?.[0]?.readiness ?? 'needs-review'
+      readiness
     });
   }
   const ownershipRegions = uniqueRecordsById(regions);
@@ -67,7 +70,9 @@ function semanticImportSidecarEntry(imported, index, options) {
     universalAstLayerIds: universalAstLayers.ids,
     proofSpec,
     paradigmSemantics,
-    readiness: imported?.metadata?.semanticMergeReadiness ?? imported?.mergeCandidates?.[0]?.readiness ?? 'needs-review',
+    dependencyRelationCount: dependencies.total,
+    dependencyPredicates: dependencies.predicates,
+    readiness,
     emptySemanticIndex: symbols.length === 0,
     regionTaxonomy,
     symbols,
@@ -75,4 +80,14 @@ function semanticImportSidecarEntry(imported, index, options) {
   };
 }
 
+function semanticImportEntryReadiness(imported) {
+  const readiness = imported?.metadata?.semanticMergeReadiness
+    ?? imported?.metadata?.nativeImportLossSummary?.semanticMergeReadiness
+    ?? imported?.readiness?.semanticMergeReadiness
+    ?? imported?.readiness?.readiness
+    ?? (typeof imported?.readiness === 'string' ? imported.readiness : undefined)
+    ?? imported?.mergeCandidates?.[0]?.readiness;
+  return readiness ?? 'needs-review';
+}
+
 export { semanticImportSidecarEntry };

package/dist/semantic-import-sidecar-types.d.ts

@@ -90,6 +90,8 @@ export interface SemanticImportSidecarImportEntry {
   readonly universalAstLayerIds: readonly string[];
   readonly proofSpec: SemanticImportSidecarProofSpecSummary;
   readonly paradigmSemantics: SemanticImportSidecarParadigmSemanticsSummary;
+  readonly dependencyRelationCount: number;
+  readonly dependencyPredicates: readonly string[];
   readonly readiness: SemanticMergeReadiness;
   readonly emptySemanticIndex: boolean;
   readonly regionTaxonomy?: SemanticImportRegionTaxonomySummary;
@@ -186,6 +188,23 @@ export interface SemanticImportSidecarParadigmSemanticsSummary {
   readonly empty: boolean;
 }
 
+export interface SemanticImportDependencySummary {
+  readonly total: number;
+  readonly calls: number;
+  readonly uses: number;
+  readonly references: number;
+  readonly imports: number;
+  readonly extends: number;
+  readonly implements: number;
+  readonly includes: number;
+  readonly requires: number;
+  readonly byPredicate: Readonly<Record<string, number>>;
+  readonly predicates: readonly string[];
+  readonly ids: readonly string[];
+  readonly sourceSymbolIds: readonly string[];
+  readonly targetSymbolIds: readonly string[];
+}
+
 export interface SemanticImportSidecar {
   readonly kind: 'frontier.lang.semanticImportSidecar';
   readonly version: 1;
@@ -217,6 +236,7 @@ export interface SemanticImportSidecar {
   readonly universalAstLayers: SemanticImportSidecarUniversalAstLayerSummary;
   readonly proofSpec: SemanticImportSidecarProofSpecSummary;
   readonly paradigmSemantics: SemanticImportSidecarParadigmSemanticsSummary;
+  readonly dependencies: SemanticImportDependencySummary;
   readonly patchHints: readonly SemanticImportPatchHint[];
   readonly quality: SemanticImportSidecarQuality;
   readonly admission: SemanticImportSidecarAdmission;
@@ -258,6 +278,8 @@ export interface SemanticImportSidecar {
     readonly paradigmSemanticsRecords: number;
     readonly paradigmSemanticsGroups: number;
     readonly paradigmSemanticsLoweringRecords: number;
+    readonly dependencyRelations: number;
+    readonly dependencyPredicates: readonly string[];
     readonly patchHints: number;
     readonly evidenceWarnings: number;
     readonly readiness: SemanticMergeReadiness;

package/examples/native-js-to-rust-demo.mjs

@@ -0,0 +1,148 @@
+import {
+  compileFrontierSource,
+  compileNativeSource,
+  importNativeSource,
+  writeUniversalAstJson
+} from '../dist/index.js';
+
+const javascriptSource = `import { nanoid } from "nanoid";
+
+export function addTodo(title) {
+  return { id: nanoid(), title };
+}
+
+export class TodoStore {
+  save(title) {
+    return addTodo(title);
+  }
+}
+`;
+
+const imported = importNativeSource({
+  language: 'javascript',
+  sourcePath: 'src/todo.js',
+  sourceText: javascriptSource
+});
+
+const graphSummary = {
+  universalAst: imported.universalAst.kind,
+  semanticIndexId: imported.semanticIndex.id,
+  symbols: imported.semanticIndex.symbols.map((symbol) => ({
+    name: symbol.name,
+    kind: symbol.kind,
+    region: symbol.metadata?.ownershipRegionKind
+  })),
+  sourceMapMappings: imported.sourceMaps[0]?.mappings.length ?? 0,
+  mergeReadiness: imported.metadata.nativeImportLossSummary.semanticMergeReadiness,
+  losses: imported.losses.map((loss) => loss.kind)
+};
+
+console.log('--- JavaScript source ---');
+console.log(javascriptSource.trim());
+console.log('\n--- Frontier graph summary ---');
+console.log(JSON.stringify(graphSummary, null, 2));
+console.log('\n--- Universal AST envelope excerpt ---');
+console.log(JSON.stringify(universalAstExcerpt(imported), null, 2));
+
+const stubProjection = compileNativeSource(imported, {
+  target: 'rust',
+  targetPath: 'src/todo.rs'
+});
+
+console.log('\n--- Rust declaration stubs without a target adapter ---');
+console.log(`ok=${stubProjection.ok} readiness=${stubProjection.readiness.readiness} mode=${stubProjection.outputMode}`);
+console.log(stubProjection.output.trim());
+
+const adapterProjection = compileNativeSource(imported, {
+  target: 'rust',
+  targetPath: 'src/todo.rs',
+  targetAdapters: [createDemoJsToRustAdapter()]
+});
+
+console.log('\n--- Rust output with a host-owned target adapter ---');
+console.log(`ok=${adapterProjection.ok} readiness=${adapterProjection.readiness.readiness} mode=${adapterProjection.outputMode}`);
+console.log(adapterProjection.output.trim());
+
+const frontierSource = `module TodoApp @id("mod_todo")
+
+type TodoInput @id("type_todo_input") {
+  title: Text
+}
+
+entity Todo @id("ent_todo") {
+  title @id("field_title"): Text
+}
+
+action addTodo @id("action_add") {
+  input TodoInput
+  writes field_title
+  returns Patch
+}
+`;
+
+const canonicalRust = compileFrontierSource(frontierSource, { target: 'rust' });
+
+console.log('\n--- Frontier source projected directly to Rust ---');
+console.log(`ok=${canonicalRust.ok} target=${canonicalRust.target}`);
+console.log(canonicalRust.output.trim());
+
+function universalAstExcerpt(importResult) {
+  const parsed = JSON.parse(writeUniversalAstJson(importResult.universalAst));
+  return {
+    kind: parsed.kind,
+    id: parsed.id,
+    documentCount: parsed.documents?.length ?? 0,
+    symbolCount: parsed.semanticIndex?.symbols?.length ?? 0,
+    sourceMapCount: parsed.sourceMaps?.length ?? 0
+  };
+}
+
+function createDemoJsToRustAdapter() {
+  return {
+    id: 'demo-js-to-rust-target-adapter',
+    sourceLanguage: 'javascript',
+    target: 'rust',
+    version: '0.0.0-demo',
+    capabilities: ['declaration-stubs'],
+    coverage: {
+      readiness: 'ready',
+      handledLossKinds: ['opaqueNative', 'declarationOnlyCoverage', 'partialSemanticIndex', 'sourceMapApproximation', 'sourcePreservation'],
+      notes: ['Demo adapter turns Frontier semantic symbols into deterministic Rust scaffolding.']
+    },
+    project(input) {
+      const symbols = input.importResult.semanticIndex?.symbols ?? [];
+      return {
+        output: renderRustScaffold(symbols),
+        readiness: 'ready',
+        evidence: [{
+          id: 'evidence_demo_js_to_rust_adapter',
+          kind: 'projection',
+          status: 'passed',
+          summary: 'Demo adapter projected JavaScript semantic symbols to Rust scaffolding.'
+        }]
+      };
+    }
+  };
+}
+
+function renderRustScaffold(symbols) {
+  const lines = ['// Generated from Frontier semantic graph evidence.'];
+  for (const symbol of symbols) {
+    if (symbol.kind === 'class') {
+      lines.push(`pub struct ${symbol.name};`, '');
+    } else if (symbol.kind === 'function' || symbol.kind === 'method') {
+      lines.push(`pub fn ${rustName(symbol.name)}() {`);
+      lines.push('    todo!("port body from native source evidence");');
+      lines.push('}', '');
+    }
+  }
+  return `${lines.join('\n').trim()}\n`;
+}
+
+function rustName(name) {
+  return String(name)
+    .replace(/\./g, '_')
+    .replace(/([a-z0-9])([A-Z])/g, '$1_$2')
+    .replace(/[^A-Za-z0-9_]/g, '_')
+    .toLowerCase();
+}

package/package.json

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