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

package/README.md

@@ -50,6 +50,34 @@ console.log(imported.nativeSource.ast.rootId);
 console.log(imported.patch.operations.length);
 ```
 
+Import external code-intelligence payloads into Frontier semantic evidence when a project already has language tooling such as SCIP, LSIF, LSP, or SemanticDB:
+
+```js
+import { importExternalSemanticIndex } from '@shapeshift-labs/frontier-lang-compiler';
+
+const importedIndex = importExternalSemanticIndex({
+  format: 'scip',
+  language: 'typescript',
+  payload: {
+    metadata: { project_root: '/repo' },
+    documents: [{
+      relative_path: 'src/todo.ts',
+      occurrences: [{
+        symbol: 'scip-typescript npm todo 1.0.0 src/todo.ts/ addTodo().',
+        range: [0, 16, 23],
+        symbol_roles: 1
+      }]
+    }]
+  }
+});
+
+console.log(importedIndex.semanticIndex.symbols.length);
+console.log(importedIndex.summary.sourceMapMappings);
+console.log(importedIndex.readiness.readiness); // "ready-with-losses" or review-required
+```
+
+External semantic-index imports create Frontier `SemanticIndexRecord`, `SourceMapRecord`, evidence, losses, ownership facts, and a universal AST envelope. They are a bridge from existing language servers/indexers into semantic merge tooling; they do not claim full parser AST coverage, macro expansion, type checking, comments/trivia preservation, or lossless cross-language code generation by themselves.
+
 Native imports include source maps, semantic merge candidates, and a loss summary for admission queues and dashboards. Informational losses produce `ready-with-losses`, warning losses produce `needs-review`, and error losses or failed import evidence produce `blocked`:
 
 ```js
@@ -163,10 +191,30 @@ const imported = importNativeSource({
 const sidecar = createSemanticImportSidecar(imported);
 
 console.log(sidecar.summary.emptySemanticIndex); // false when symbols were found
-console.log(sidecar.ownershipRegions[0].key); // source#src/runtime.ts#class#Runtime
+console.log(sidecar.ownershipRegions[0].key); // source#src/runtime.ts#type#Runtime
 console.log(sidecar.patchHints[0].supportedOperations); // source-region patch operations
 ```
 
+The built-in JavaScript/TypeScript lightweight scanner also emits review-required ownership regions for clear route/config/content/property shapes in exported objects and arrays:
+
+```js
+const importedConfig = importNativeSource({
+  language: 'typescript',
+  sourcePath: 'src/routes.ts',
+  sourceText: `
+    export const appRoutes = [
+      { path: "/home", component: Home }
+    ];
+    export const siteContent = {
+      docs: { title: "Docs" }
+    };
+  `
+});
+
+const configSidecar = createSemanticImportSidecar(importedConfig);
+console.log(configSidecar.regionTaxonomy.presentKinds); // includes "route" and "content"
+```
+
 Compare before/after native source imports from a worker patch and emit a semantic change set for admission scoring:
 
 ```js

package/bench/smoke.mjs

@@ -7,6 +7,7 @@ import {
   createProjectionTargetLossMatrix,
   createNativeSourcePreservation,
   createSemanticImportSidecar,
+  importExternalSemanticIndex,
   importNativeSource,
   projectNativeImportToSource,
   runNativeImporterAdapter,
@@ -134,6 +135,70 @@ const nativeTargetAdapterDurationMs = performance.now() - nativeTargetAdapterSta
 const nativeTargetAdapterBytes = nativeTargetAdapterCompiles.reduce((sum, result) => sum + result.output.length, 0);
 const nativeTargetAdapterSourceMaps = nativeTargetAdapterCompiles.reduce((sum, result) => sum + result.sourceMaps.length, 0);
 
+const regionScanStart = performance.now();
+const regionScanImports = [];
+for (let index = 0; index < 100; index += 1) {
+  const imported = importNativeSource({
+    language: 'typescript',
+    sourcePath: `src/regions-${index}.ts`,
+    sourceText: `
+      export const appRoutes${index} = [
+        { path: "/${index}", component: Screen${index} },
+        { path: "/${index}/settings", component: Settings${index} }
+      ];
+      export const contentBlocks${index} = {
+        docs: { title: "Docs ${index}" },
+        legal: { title: "Legal ${index}" }
+      };
+      export const runtimeConfig${index} = {
+        limits: { count: ${index} },
+        resolve(id) { return id; }
+      };
+      export const helpers${index} = {
+        plain: ${index}
+      };
+    `
+  });
+  regionScanImports.push({ imported, sidecar: createSemanticImportSidecar(imported) });
+}
+const regionScanDurationMs = performance.now() - regionScanStart;
+const regionScanSymbols = regionScanImports.reduce((sum, entry) => sum + entry.imported.semanticIndex.symbols.length, 0);
+const regionScanOwnershipRegions = regionScanImports.reduce((sum, entry) => sum + entry.sidecar.ownershipRegions.length, 0);
+
+const externalSemanticStart = performance.now();
+const externalSemanticImports = [];
+for (let index = 0; index < 100; index += 1) {
+  externalSemanticImports.push(importExternalSemanticIndex({
+    format: index % 2 === 0 ? 'scip' : 'lsp',
+    language: index % 2 === 0 ? 'typescript' : 'python',
+    payload: index % 2 === 0
+      ? {
+        metadata: { project_root: '/bench' },
+        documents: [{
+          relative_path: `src/external-${index}.ts`,
+          language: 'typescript',
+          occurrences: [{
+            symbol: `scip-typescript npm bench 1.0.0 src/external-${index}.ts/ external${index}().`,
+            range: [0, 16, 24],
+            symbol_roles: 1
+          }]
+        }]
+      }
+      : {
+        uri: `file:///bench/src/external-${index}.py`,
+        languageId: 'python',
+        documentSymbols: [{
+          name: `external_${index}`,
+          kind: 12,
+          range: { start: { line: 0, character: 0 }, end: { line: 1, character: 0 } }
+        }]
+      }
+  }));
+}
+const externalSemanticDurationMs = performance.now() - externalSemanticStart;
+const externalSemanticSymbols = externalSemanticImports.reduce((sum, imported) => sum + imported.semanticIndex.symbols.length, 0);
+const externalSemanticMappings = externalSemanticImports.reduce((sum, imported) => sum + imported.summary.sourceMapMappings, 0);
+
 console.log(JSON.stringify({
   compiles: 250,
   bytes,
@@ -172,5 +237,13 @@ console.log(JSON.stringify({
   nativeTargetAdapterCompiles: nativeTargetAdapterCompiles.length,
   nativeTargetAdapterBytes,
   nativeTargetAdapterSourceMaps,
-  nativeTargetAdapterDurationMs: Number(nativeTargetAdapterDurationMs.toFixed(2))
+  nativeTargetAdapterDurationMs: Number(nativeTargetAdapterDurationMs.toFixed(2)),
+  regionScanImports: regionScanImports.length,
+  regionScanSymbols,
+  regionScanOwnershipRegions,
+  regionScanDurationMs: Number(regionScanDurationMs.toFixed(2)),
+  externalSemanticImports: externalSemanticImports.length,
+  externalSemanticSymbols,
+  externalSemanticMappings,
+  externalSemanticDurationMs: Number(externalSemanticDurationMs.toFixed(2))
 }));

package/dist/index.d.ts

@@ -140,6 +140,10 @@ export type NativeImportRegionTaxonomyKind =
   | 'call'
   | 'type'
   | 'effect'
+  | 'property'
+  | 'config'
+  | 'content'
+  | 'route'
   | 'generatedOutput'
   | string;
 
@@ -1067,6 +1071,63 @@ export type NativeSourceImportResult = LanguageImportResult & {
   readonly universalAst: FrontierUniversalAstEnvelope;
 };
 
+export type ExternalSemanticIndexFormat =
+  | 'frontier-semantic-index'
+  | 'scip'
+  | 'lsif'
+  | 'lsp'
+  | 'semanticdb'
+  | string;
+
+export interface ImportExternalSemanticIndexOptions {
+  readonly format?: ExternalSemanticIndexFormat;
+  readonly payload?: unknown;
+  readonly semanticIndex?: SemanticIndexRecord;
+  readonly id?: string;
+  readonly semanticIndexId?: string;
+  readonly universalAstId?: string;
+  readonly documentId?: string;
+  readonly documentName?: string;
+  readonly sourceMapId?: string;
+  readonly language?: FrontierSourceLanguage | string;
+  readonly sourcePath?: string;
+  readonly sourceHash?: string;
+  readonly projectRoot?: string;
+  readonly parser?: string;
+  readonly evidence?: readonly EvidenceRecord[];
+  readonly metadata?: Record<string, unknown>;
+  readonly universalAstMetadata?: Record<string, unknown>;
+}
+
+export interface ExternalSemanticIndexImportSummary {
+  readonly documents: number;
+  readonly symbols: number;
+  readonly occurrences: number;
+  readonly relations: number;
+  readonly facts: number;
+  readonly sourceMapMappings: number;
+  readonly losses: number;
+  readonly readiness: SemanticMergeReadiness;
+}
+
+export interface ExternalSemanticIndexImportResult {
+  readonly kind: 'frontier.lang.externalSemanticIndexImport';
+  readonly version: 1;
+  readonly id: string;
+  readonly format: ExternalSemanticIndexFormat;
+  readonly language?: FrontierSourceLanguage | string;
+  readonly sourcePath?: string;
+  readonly projectRoot?: string;
+  readonly semanticIndex: SemanticIndexRecord;
+  readonly universalAst: FrontierUniversalAstEnvelope;
+  readonly sourceMaps: readonly SourceMapRecord[];
+  readonly losses: readonly NativeAstLossRecord[];
+  readonly evidence: readonly EvidenceRecord[];
+  readonly readiness: NativeImportReadinessClassification;
+  readonly summary: ExternalSemanticIndexImportSummary;
+  readonly metadata: Record<string, unknown>;
+}
+
 export interface NativeImporterAdapterParseInput {
   readonly sourceText: string;
   readonly sourcePath?: string;
@@ -1474,6 +1535,7 @@ export declare const ProjectionTargetLossClasses: readonly ProjectionTargetLossC
 export declare const NativeImportReadinessBySeverity: Readonly<Record<NativeImportLossSummary['highestSeverity'], SemanticMergeReadiness>>;
 export declare const NativeImportFeatureEvidencePolicies: Readonly<Record<string, NativeImportFeatureEvidencePolicy>>;
 export declare const NativeImportLanguageProfiles: readonly NativeImportLanguageProfile[];
+export declare const ExternalSemanticIndexFormats: readonly ExternalSemanticIndexFormat[];
 export declare function normalizeCompileTarget(target?: string): FrontierCompileTarget;
 export declare function compileFrontierSource(source: string, options?: FrontierCompileOptions): FrontierCompileResult;
 export declare function compileFrontierDocument(document: FrontierLangDocument, options?: FrontierCompileOptions): FrontierCompileResult;
@@ -1500,6 +1562,7 @@ export declare function createTreeSitterNativeImporterAdapter(options?: TreeSitt
 export declare function runNativeImporterAdapter(adapter: NativeImporterAdapter, input: RunNativeImporterAdapterOptions): Promise<NativeImporterAdapterImportResult>;
 export declare function runNativeTargetProjectionAdapter(adapter: NativeTargetProjectionAdapter, input: NativeTargetProjectionAdapterInput): NativeTargetProjectionResult;
 export declare function projectNativeImportToSource(importResult: NativeSourceImportResult | NativeProjectImportResult, options?: ProjectNativeImportToSourceOptions): NativeSourceProjectionResult;
+export declare function importExternalSemanticIndex(input: ImportExternalSemanticIndexOptions | SemanticIndexRecord): ExternalSemanticIndexImportResult;
 export declare function importNativeSource(input: ImportNativeSourceOptions): NativeSourceImportResult;
 export declare function diffNativeSources(input: DiffNativeSourcesOptions): NativeSourceChangeSet;
 export declare function diffNativeSourceImports(input: DiffNativeSourceImportsOptions): NativeSourceChangeSet;