@shapeshift-labs/frontier-lang-compiler 0.2.38 → 0.2.40

package/README.md

@@ -2,6 +2,16 @@
 
 Compiler facade for Frontier Lang. It composes the parser, checker, semantic kernel, and projection adapters for TypeScript, JavaScript, Rust, Python, and C.
 
+## Vision
+
+Frontier Lang and Frontier Swarm are two parts of the same system: a semantic programming substrate for agent teams.
+
+Frontier Lang is the universal code representation. It imports source from native languages into a replayable semantic graph: AST layers, symbols, ownership regions, source maps, effects, proof obligations, runtime assumptions, tests, traces, and merge history. It preserves exact native source where needed, imports parser/compiler facts where available, and projects semantic programs back out through target-language adapters.
+
+Frontier Swarm is the coordination layer for many agents working on that graph. It breaks large engineering goals into owned semantic regions, assigns workers isolated slices of context, collects machine-readable evidence, scores merge readiness, and lets the coordinator integrate patches without reading every worker transcript manually.
+
+The shared goal is semantic merging for code. A worker output should say what it changed, what semantic region it owns, what source hashes it depended on, what tests or traces prove the change, what assumptions it conflicts with, and whether it is ready to merge, needs porting, or is discovery-only.
+
 ```js
 import { compileFrontierSource } from '@shapeshift-labs/frontier-lang-compiler';
 
@@ -118,6 +128,7 @@ import {
   createNativeImportCoverageMatrix,
   createNativeParserAstFormatMatrix,
   createProjectionTargetLossMatrix,
+  createUniversalCapabilityMatrix,
   importNativeSource
 } from '@shapeshift-labs/frontier-lang-compiler';
 
@@ -142,6 +153,15 @@ const pythonProjection = projectionMatrix.languages.find((entry) => entry.langua
 console.log(pythonProjection.sourceProjection.exactSource.lossClass); // "exactSourceProjection"
 console.log(pythonProjection.sourceProjection.stubs.lossClass); // "nativeSourceStubs"
 console.log(pythonProjection.targets.find((entry) => entry.target === 'rust').lossClass); // "missingAdapter"
+
+const universalMatrix = createUniversalCapabilityMatrix({
+  imports: [imported],
+  requiredFeatures: ['syntax', 'semantic', 'sourcePreservation']
+});
+const pythonUniversal = universalMatrix.languages.find((entry) => entry.language === 'python');
+
+console.log(pythonUniversal.readiness); // combined import/parser/projection readiness
+console.log(pythonUniversal.blockers); // missing evidence/adapters that prevent merge admission
 ```
 
 The projection target matrix separates five runtime/API classes:
@@ -152,6 +172,8 @@ The projection target matrix separates five runtime/API classes:
 - `targetAdapterProjection`: a host-owned native-to-target adapter is present and produced target output with its own evidence/readiness.
 - `missingAdapter`: no native-to-target projection adapter is declared; preserve or stub the original source language instead, or inject host-owned parser/semantic adapter evidence.
 
+`createUniversalCapabilityMatrix` composes the import coverage, parser AST format, parser feature, and projection target matrices into a single language row per source language. It is the coordinator-facing view for universal-language work: it shows imports, symbols, source-map mappings, parser feature readiness, projection targets, missing adapters, unsupported target features, blockers, and review reasons without claiming lossless conversion where evidence is absent.
+
 Preserve exact native source text, token/trivia hashes, comments, whitespace, and source directives as evidence. This does not claim full semantic understanding; it keeps round-trip material available while exact parser adapters catch up:
 
 ```js
@@ -242,6 +264,44 @@ console.log(changeSet.mergeCandidate.readiness); // merge-admission classificati
 
 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.
 
+Extract a surgical semantic slice when a worker only needs one symbol, region, native AST node, or source path:
+
+```js
+import {
+  createSemanticSlice,
+  importNativeSource,
+  testSemanticSlice,
+  writeSemanticSliceJson
+} from '@shapeshift-labs/frontier-lang-compiler';
+
+const sourceText = 'export function parseExpression(input) { return input; }\n';
+const imported = importNativeSource({
+  language: 'typescript',
+  sourcePath: 'src/parser.ts',
+  sourceText
+});
+
+const slice = createSemanticSlice(imported, {
+  entryRefs: ['symbol:parseExpression'],
+  includeDependencies: true,
+  focusedCommands: ['npm test -- parser-expression'],
+  fixtureHints: ['operator precedence corpus']
+});
+
+console.log(slice.kind); // "frontier.lang.semanticSlice"
+console.log(slice.mergeAdmission.conflictKeys); // semantic ownership keys
+console.log(slice.sourceFiles[0].sourceHash); // stale-check input for admission
+
+const gate = testSemanticSlice(slice, {
+  currentSources: { 'src/parser.ts': sourceText }
+});
+
+console.log(gate.status); // "passed", "needs-review", or "failed"
+console.log(writeSemanticSliceJson(slice)); // stable JSON for worker inputs
+```
+
+A semantic slice is the small unit a swarm can hand to a worker instead of copying a full repository. It carries the selected symbols, ownership regions, native nodes, relations, occurrences, source-map links, source spans, source excerpts, source hashes, focused verification commands, fixture hints, and merge-admission metadata. It does not claim the patch is correct; it makes the context and conflicts machine-readable so admission scoring can combine changed ownership, focused test status, stale/source-hash checks, evidence, and semantic risk in one sortable record.
+
 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:
 
 ```js
@@ -484,7 +544,7 @@ The published Frontier package family is generated from one shared package catal
 - [`@shapeshift-labs/frontier-lang-csharp`](https://www.npmjs.com/package/@shapeshift-labs/frontier-lang-csharp): C# Roslyn source-language importer package for Frontier Lang semantic documents, including package-level metadata, Roslyn adapter helpers, native import results, and semantic sidecar generation for SyntaxTree/SyntaxNode-shaped ASTs.
 - [`@shapeshift-labs/frontier-lang-clang`](https://www.npmjs.com/package/@shapeshift-labs/frontier-lang-clang): Clang AST source-language importer package for Frontier Lang semantic documents, including package-level metadata, Clang AST JSON adapter helpers, native import results, and semantic sidecar generation for C/C++ translation units.
 - [`@shapeshift-labs/frontier-lang-cli`](https://www.npmjs.com/package/@shapeshift-labs/frontier-lang-cli): Command line interface for parsing, checking, hashing, and emitting Frontier Lang projects.
-- [`@shapeshift-labs/frontier-lang`](https://www.npmjs.com/package/@shapeshift-labs/frontier-lang): Umbrella package for Frontier Lang kernel, parser, checker, and projection adapters.
+- [`@shapeshift-labs/frontier-lang`](https://www.npmjs.com/package/@shapeshift-labs/frontier-lang): Umbrella package for Frontier Lang kernel, parser, checker, compiler facade, universal AST helpers, and projection adapters.
 - [`@shapeshift-labs/frontier-kv`](https://www.npmjs.com/package/@shapeshift-labs/frontier-kv): Serializable in-memory key/value state for Frontier apps, including TTL, versioned compare-and-set, batched patch mutations, scans, watchers, snapshots, JSONL event evidence, and replay verification.
 - [`@shapeshift-labs/frontier-kv-locks`](https://www.npmjs.com/package/@shapeshift-labs/frontier-kv-locks): Lease-style lock records on top of Frontier KV, including acquire, renew, release, fencing tokens, expiration, owner evidence, and replayable lock events.
 - [`@shapeshift-labs/frontier-kv-rate-limit`](https://www.npmjs.com/package/@shapeshift-labs/frontier-kv-rate-limit): Patch-native rate limit buckets for Frontier KV, including fixed windows, sliding windows, token buckets, deterministic refill, consume evidence, and reset records.

package/bench/smoke.mjs

@@ -12,18 +12,21 @@ import {
   createNativeParserAstFormatMatrix,
   createNativeParserFeatureMatrix,
   createProjectionTargetLossMatrix,
+  createUniversalCapabilityMatrix,
   createNativeSourcePreservation,
   createPythonAstNativeImporterAdapter,
   createRustSynNativeImporterAdapter,
   createSwiftSyntaxNativeImporterAdapter,
   createSemanticImportSidecar,
+  createSemanticSlice,
   diffNativeSources,
   importExternalSemanticIndex,
   importNativeSource,
   projectNativeImportToSource,
   queryNativeParserFeatureMatrix,
   runNativeImporterAdapter,
-  summarizeNativeImportFeatureEvidence
+  summarizeNativeImportFeatureEvidence,
+  testSemanticSlice
 } from '../dist/index.js';
 
 const source = `
@@ -140,6 +143,14 @@ const projectionMatrixStart = performance.now();
 const projectionLossMatrix = createProjectionTargetLossMatrix({ imports: nativeImportResults });
 const projectionMatrixDurationMs = performance.now() - projectionMatrixStart;
 
+const universalMatrixStart = performance.now();
+const universalCapabilityMatrix = createUniversalCapabilityMatrix({
+  imports: nativeImportResults,
+  adapters: [estreeAdapter, createPythonAstNativeImporterAdapter(), createRustSynNativeImporterAdapter(), createClangAstNativeImporterAdapter(), createGoAstNativeImporterAdapter(), createJavaAstNativeImporterAdapter(), kotlinPsiAdapter, createCSharpRoslynNativeImporterAdapter(), createSwiftSyntaxNativeImporterAdapter()],
+  requiredFeatures: ['syntax', 'semantic', 'sourcePreservation']
+});
+const universalMatrixDurationMs = performance.now() - universalMatrixStart;
+
 const preservationStart = performance.now();
 const preservationRecords = nativeImportResults.map((imported) => imported.metadata.sourcePreservation ?? createNativeSourcePreservation({
   language: imported.language,
@@ -154,6 +165,23 @@ const semanticSidecars = nativeImportResults.map((imported) => createSemanticImp
 const sidecarDurationMs = performance.now() - sidecarStart;
 const sidecarOwnershipRegions = semanticSidecars.reduce((sum, sidecar) => sum + sidecar.ownershipRegions.length, 0);
 
+const sliceStart = performance.now();
+const semanticSlices = nativeImportResults.slice(0, 100).map((imported, index) => {
+  const symbol = imported.semanticIndex?.symbols?.[0]?.name ?? imported.semanticIndex?.symbols?.[0]?.id;
+  return createSemanticSlice(imported, {
+    entryRefs: symbol ? [`symbol:${symbol}`] : [],
+    includeDependencies: index % 2 === 0,
+    focusedCommands: [`npm test -- semantic-slice-${index}`]
+  });
+});
+const sliceDurationMs = performance.now() - sliceStart;
+const sliceSourceMapLinks = semanticSlices.reduce((sum, slice) => sum + slice.sourceMapLinks.length, 0);
+const sliceConflictKeys = semanticSlices.reduce((sum, slice) => sum + slice.mergeAdmission.conflictKeys.length, 0);
+const sliceGateStart = performance.now();
+const semanticSliceGates = semanticSlices.map((slice) => testSemanticSlice(slice, { requireSourceMapLinks: false }));
+const sliceGateDurationMs = performance.now() - sliceGateStart;
+const sliceGateFailures = semanticSliceGates.filter((gate) => gate.status === 'failed').length;
+
 const featureEvidenceStart = performance.now();
 const featureEvidenceSummaries = nativeImportResults.map((imported) => summarizeNativeImportFeatureEvidence(imported.losses, {
   evidence: imported.evidence
@@ -304,12 +332,23 @@ console.log(JSON.stringify({
   projectionMatrixMissingAdapters: projectionLossMatrix.summary.missingAdapters,
   projectionMatrixUnsupportedTargetFeatures: projectionLossMatrix.summary.unsupportedTargetFeatures,
   projectionMatrixDurationMs: Number(projectionMatrixDurationMs.toFixed(2)),
+  universalMatrixLanguages: universalCapabilityMatrix.summary.languages,
+  universalMatrixImports: universalCapabilityMatrix.summary.imports,
+  universalMatrixBlockedLanguages: universalCapabilityMatrix.summary.blockedLanguages,
+  universalMatrixMissingAdapters: universalCapabilityMatrix.summary.missingAdapters,
+  universalMatrixDurationMs: Number(universalMatrixDurationMs.toFixed(2)),
   sourcePreservationRecords: preservationRecords.length,
   sourcePreservationTokens: preservationTokens,
   sourcePreservationDurationMs: Number(preservationDurationMs.toFixed(2)),
   semanticSidecars: semanticSidecars.length,
   sidecarOwnershipRegions,
   sidecarDurationMs: Number(sidecarDurationMs.toFixed(2)),
+  semanticSlices: semanticSlices.length,
+  sliceDurationMs: Number(sliceDurationMs.toFixed(2)),
+  sliceGateDurationMs: Number(sliceGateDurationMs.toFixed(2)),
+  sliceSourceMapLinks,
+  sliceConflictKeys,
+  sliceGateFailures,
   featureEvidencePolicyMatches,
   featureEvidenceDurationMs: Number(featureEvidenceDurationMs.toFixed(2)),
   nativeProjections: nativeProjections.length,

package/dist/index.d.ts

@@ -652,6 +652,101 @@ export interface ProjectionTargetLossMatrixOptions {
   readonly generatedAt?: number;
 }
 
+export interface UniversalCapabilityLanguageRow {
+  readonly language: FrontierSourceLanguage | string;
+  readonly aliases: readonly string[];
+  readonly extensions: readonly string[];
+  readonly readiness: SemanticMergeReadiness;
+  readonly imports: {
+    readonly total: number;
+    readonly readiness: SemanticMergeReadiness;
+    readonly symbols: number;
+    readonly sourceMaps: number;
+    readonly sourceMapMappings: number;
+    readonly losses: number;
+    readonly lossKinds: Readonly<Record<string, number>>;
+    readonly readinessReasons: readonly string[];
+  };
+  readonly parser: {
+    readonly readiness: SemanticMergeReadiness;
+    readonly rows: number;
+    readonly parsers: readonly string[];
+    readonly mergeReadyParsers: readonly string[];
+    readonly blockingFeatures: readonly NativeParserFeatureCategory[];
+    readonly reviewFeatures: readonly NativeParserFeatureCategory[];
+    readonly languageSummary?: NativeParserFeatureLanguageSummary;
+  };
+  readonly projection: {
+    readonly readiness: SemanticMergeReadiness;
+    readonly sourceProjection?: ProjectionTargetLanguageCoverage['sourceProjection'];
+    readonly targets: readonly ProjectionTargetCoverageEntry[];
+    readonly summary: ProjectionTargetLanguageCoverage['summary'];
+    readonly missingTargets: readonly (FrontierCompileTarget | string)[];
+    readonly unsupportedTargets: readonly (FrontierCompileTarget | string)[];
+  };
+  readonly evidence: {
+    readonly parserAdapters: number;
+    readonly adapterCoverageSummaries: number;
+    readonly adapterCoverageGaps: Readonly<Record<string, number>>;
+    readonly knownLossKinds: readonly NativeImportKnownLossKind[];
+    readonly sourceMapMappings: number;
+  };
+  readonly blockers: readonly string[];
+  readonly review: readonly string[];
+}
+
+export interface UniversalCapabilityMatrix {
+  readonly kind: 'frontier.lang.universalCapabilityMatrix';
+  readonly version: 1;
+  readonly generatedAt: number;
+  readonly languages: readonly UniversalCapabilityLanguageRow[];
+  readonly summary: {
+    readonly languages: number;
+    readonly imports: number;
+    readonly symbols: number;
+    readonly sourceMapMappings: number;
+    readonly losses: number;
+    readonly parserRows: number;
+    readonly parserMergeReady: number;
+    readonly targetEntries: number;
+    readonly missingAdapters: number;
+    readonly unsupportedTargetFeatures: number;
+    readonly exactSourceProjection: number;
+    readonly nativeSourceStubs: number;
+    readonly blockers: number;
+    readonly reviewReasons: number;
+    readonly readyLanguages: number;
+    readonly readyWithLossesLanguages: number;
+    readonly reviewLanguages: number;
+    readonly blockedLanguages: number;
+    readonly byReadiness: Readonly<Record<SemanticMergeReadiness, number>>;
+    readonly byImportReadiness: Readonly<Record<SemanticMergeReadiness, number>>;
+    readonly byParserReadiness: Readonly<Record<SemanticMergeReadiness, number>>;
+    readonly byProjectionReadiness: Readonly<Record<SemanticMergeReadiness, number>>;
+  };
+  readonly matrices: {
+    readonly importCoverage: NativeImportCoverageMatrix;
+    readonly parserFormats: NativeParserAstFormatMatrix;
+    readonly parserFeatures: NativeParserFeatureMatrix;
+    readonly projectionTargets: ProjectionTargetLossMatrix;
+  };
+  readonly metadata: {
+    readonly requiredFeatures: readonly NativeParserFeatureCategory[];
+    readonly minimumReadiness: SemanticMergeReadiness;
+    readonly compileTargets: readonly (FrontierCompileTarget | string)[];
+    readonly note: string;
+  };
+}
+
+export interface UniversalCapabilityMatrixOptions extends
+  NativeImportCoverageMatrixOptions,
+  NativeParserAstFormatMatrixOptions,
+  NativeParserFeatureMatrixOptions,
+  ProjectionTargetLossMatrixOptions {
+  readonly targetAdapters?: readonly NativeTargetProjectionAdapter[];
+  readonly targets?: readonly (FrontierCompileTarget | string)[];
+}
+
 export interface NativeImportContractSource {
   readonly id: string;
   readonly language?: FrontierSourceLanguage | string;
@@ -1329,6 +1424,184 @@ export interface NativeSourceChangeSet {
   };
 }
 
+export type SemanticSliceInput =
+  | NativeSourceImportResult
+  | NativeProjectImportResult
+  | ImportNativeSourceOptions
+  | FrontierUniversalAstEnvelope
+  | SemanticImportSidecar
+  | {
+    readonly import?: NativeSourceImportResult | NativeProjectImportResult | ImportNativeSourceOptions;
+    readonly importResult?: NativeSourceImportResult | NativeProjectImportResult | ImportNativeSourceOptions;
+    readonly universalAst?: FrontierUniversalAstEnvelope;
+    readonly sidecar?: SemanticImportSidecar;
+    readonly source?: ImportNativeSourceOptions;
+  };
+
+export interface CreateSemanticSliceOptions {
+  readonly id?: string;
+  readonly generatedAt?: number;
+  readonly language?: FrontierSourceLanguage | string;
+  readonly sourcePath?: string;
+  readonly sourceHash?: string;
+  readonly sourceText?: string;
+  readonly symbol?: string;
+  readonly region?: string;
+  readonly nativeNodeId?: string;
+  readonly entryRefs?: readonly string[] | string;
+  readonly semanticRefs?: readonly string[] | string;
+  readonly refs?: readonly string[] | string;
+  readonly includeDependencies?: boolean;
+  readonly maxDependencyDepth?: number;
+  readonly includeSourceText?: boolean;
+  readonly maxExcerptBytes?: number;
+  readonly focusedCommands?: readonly string[] | string;
+  readonly fixtureHints?: readonly string[] | string;
+  readonly regionPrefix?: string;
+  readonly evidenceId?: string;
+  readonly mergeCandidateId?: string;
+  readonly sidecar?: SemanticImportSidecar;
+  readonly metadata?: Record<string, unknown>;
+}
+
+export interface SemanticSliceSourceMapLink {
+  readonly id?: string;
+  readonly sourceMapId?: 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 SemanticSliceSourceFile {
+  readonly path?: string;
+  readonly sourceHash?: string;
+  readonly spans: readonly SourceSpan[];
+  readonly spanCount: number;
+  readonly excerptCount: number;
+  readonly sourceTextAvailable: boolean;
+  readonly excerpts: readonly {
+    readonly span: SourceSpan;
+    readonly text: string;
+    readonly textHash: string;
+    readonly truncated: boolean;
+  }[];
+}
+
+export interface SemanticSliceExpectedAssertion {
+  readonly id: string;
+  readonly expected: boolean;
+}
+
+export interface SemanticSlice {
+  readonly kind: 'frontier.lang.semanticSlice';
+  readonly version: 1;
+  readonly id: string;
+  readonly generatedAt: number;
+  readonly language?: FrontierSourceLanguage | string;
+  readonly sourcePath?: string;
+  readonly importId?: string;
+  readonly universalAstId?: string;
+  readonly semanticIndexId?: string;
+  readonly sidecarId?: string;
+  readonly entryRefs: readonly string[];
+  readonly matchedEntryRefs: readonly string[];
+  readonly unresolvedEntryRefs: readonly string[];
+  readonly symbols: readonly (SemanticIndexRecord['symbols'][number] | SemanticImportSidecarSymbol)[];
+  readonly ownershipRegions: readonly SemanticImportOwnershipRegion[];
+  readonly nativeNodes: readonly NativeAstNode[];
+  readonly relations: readonly SemanticIndexRecord['relations'][number][];
+  readonly occurrences: readonly SemanticIndexRecord['occurrences'][number][];
+  readonly sourceMapLinks: readonly SemanticSliceSourceMapLink[];
+  readonly sourceSpans: readonly SourceSpan[];
+  readonly sourceFiles: readonly SemanticSliceSourceFile[];
+  readonly losses: readonly NativeAstLossRecord[];
+  readonly evidence: readonly EvidenceRecord[];
+  readonly mergeCandidate: SemanticMergeCandidateRecord;
+  readonly verification: {
+    readonly focusedCommands: readonly string[];
+    readonly fixtureHints: readonly string[];
+    readonly expectedAssertions: readonly SemanticSliceExpectedAssertion[];
+  };
+  readonly summary: {
+    readonly symbols: number;
+    readonly ownershipRegions: number;
+    readonly nativeNodes: number;
+    readonly relations: number;
+    readonly occurrences: number;
+    readonly sourceMapLinks: number;
+    readonly sourceFiles: number;
+    readonly losses: number;
+    readonly conflictKeys: number;
+    readonly readiness: SemanticMergeReadiness;
+    readonly unresolvedEntryRefs: number;
+    readonly sourceTextAvailable: boolean;
+  };
+  readonly mergeAdmission: {
+    readonly autoMergeClaim: false;
+    readonly reviewRequired: boolean;
+    readonly readiness: SemanticMergeReadiness;
+    readonly reasons: readonly string[];
+    readonly conflictKeys: readonly string[];
+    readonly ownershipKeys: readonly string[];
+    readonly sourceHashes: readonly { readonly path?: string; readonly sourceHash?: string }[];
+    readonly staleCheck: {
+      readonly mode: 'source-hash' | string;
+      readonly requiresCurrentSource: boolean;
+      readonly sourceFiles: number;
+    };
+  };
+  readonly metadata?: Record<string, unknown>;
+}
+
+export interface TestSemanticSliceOptions {
+  readonly id?: string;
+  readonly generatedAt?: number;
+  readonly requireSourceMapLinks?: boolean;
+  readonly currentSources?: Readonly<Record<string, string>> | ReadonlyMap<string, string>;
+  readonly metadata?: Record<string, unknown>;
+}
+
+export interface SemanticSliceTestAssertion {
+  readonly id: string;
+  readonly status: 'passed' | 'warning' | 'failed';
+  readonly summary: string;
+  readonly metadata?: Record<string, unknown>;
+}
+
+export interface SemanticSliceTestResult {
+  readonly kind: 'frontier.lang.semanticSliceTestResult';
+  readonly version: 1;
+  readonly id: string;
+  readonly generatedAt: number;
+  readonly sliceId?: string;
+  readonly status: 'passed' | 'needs-review' | 'failed';
+  readonly readiness: SemanticMergeReadiness;
+  readonly assertions: readonly SemanticSliceTestAssertion[];
+  readonly summary: {
+    readonly assertions: number;
+    readonly passed: number;
+    readonly warnings: number;
+    readonly failed: number;
+    readonly sourceHashChecks: number;
+    readonly symbols: number;
+    readonly ownershipRegions: number;
+    readonly sourceMapLinks: number;
+  };
+  readonly metadata?: Record<string, unknown>;
+}
+
 export type NativeImporterAdapterExactness =
   | 'exact-parser-ast'
   | 'parser-tree'
@@ -2253,6 +2526,7 @@ export declare function createNativeParserAstFormatMatrix(options?: NativeParser
 export declare function createNativeParserFeatureMatrix(options?: NativeParserFeatureMatrixOptions): NativeParserFeatureMatrix;
 export declare function queryNativeParserFeatureMatrix(matrixOrOptions?: NativeParserFeatureMatrix | NativeParserFeatureMatrixOptions, query?: NativeParserFeatureMatrixQuery): NativeParserFeatureMatrixQueryResult;
 export declare function createProjectionTargetLossMatrix(options?: ProjectionTargetLossMatrixOptions): ProjectionTargetLossMatrix;
+export declare function createUniversalCapabilityMatrix(options?: UniversalCapabilityMatrixOptions): UniversalCapabilityMatrix;
 export declare function createNativeSourcePreservation(options: CreateNativeSourcePreservationOptions): NativeSourcePreservation;
 export declare function createSemanticImportSidecar(importResult: NativeSourceImportResult | NativeProjectImportResult, options?: SemanticImportSidecarOptions): SemanticImportSidecar;
 export declare function createNativeImportResultContract(importResult: NativeSourceImportResult | NativeProjectImportResult, options?: NativeImportResultContractOptions): NativeImportResultContract;
@@ -2275,6 +2549,10 @@ export declare function importExternalSemanticIndex(input: ImportExternalSemanti
 export declare function importNativeSource(input: ImportNativeSourceOptions): NativeSourceImportResult;
 export declare function diffNativeSources(input: DiffNativeSourcesOptions): NativeSourceChangeSet;
 export declare function diffNativeSourceImports(input: DiffNativeSourceImportsOptions): NativeSourceChangeSet;
+export declare function createSemanticSlice(input: SemanticSliceInput, options?: CreateSemanticSliceOptions): SemanticSlice;
+export declare function testSemanticSlice(slice: SemanticSlice, options?: TestSemanticSliceOptions): SemanticSliceTestResult;
+export declare function readSemanticSliceJson(source: string): SemanticSlice;
+export declare function writeSemanticSliceJson(slice: SemanticSlice): string;
 export declare function importNativeProject(input: ImportNativeProjectOptions): Promise<NativeProjectImportResult>;
 export declare function createUniversalAstFromDocument(document: FrontierLangDocument, input?: {
   readonly id?: string;