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

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,6 +17,7 @@ export function createSemanticImportSidecar(importResult, options = {}) {
   const universalAstLayers = summarizeSemanticImportSidecarUniversalAstLayers(importEntries);
   const proofSpec = summarizeSemanticImportSidecarProofSpec(importEntries);
   const paradigmSemantics = summarizeSemanticImportSidecarParadigmSemantics(importEntries);
+  const dependencies = summarizeSemanticImportDependencies(imports);
   const readiness = mergeCandidates.reduce(
     (current, candidate) => maxSemanticMergeReadiness(current, candidate.readiness),
     lossSummary.semanticMergeReadiness
@@ -51,6 +52,7 @@ export function createSemanticImportSidecar(importResult, options = {}) {
     universalAstLayers,
     proofSpec,
     paradigmSemantics,
+    dependencies,
     patchHints,
     quality,
     admission,
@@ -92,6 +94,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/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,7 @@ 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 mappingsBySymbolId = new Map();
   for (const mapping of sourceMapMappings) {
     if (mapping.semanticSymbolId && !mappingsBySymbolId.has(mapping.semanticSymbolId)) {
@@ -67,6 +69,8 @@ function semanticImportSidecarEntry(imported, index, options) {
     universalAstLayerIds: universalAstLayers.ids,
     proofSpec,
     paradigmSemantics,
+    dependencyRelationCount: dependencies.total,
+    dependencyPredicates: dependencies.predicates,
     readiness: imported?.metadata?.semanticMergeReadiness ?? imported?.mergeCandidates?.[0]?.readiness ?? 'needs-review',
     emptySemanticIndex: symbols.length === 0,
     regionTaxonomy,

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/package.json

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