@shapeshift-labs/frontier-lang-compiler 0.2.41 → 0.2.43

package/dist/declarations/roundtrip.d.ts

@@ -0,0 +1,200 @@
+import type {
+  CapabilityAdapterBinding,
+  CapabilityUnsupportedTarget,
+  CompileTarget,
+  EvidenceRecord,
+  FrontierLangDocument,
+  FrontierUniversalAstEnvelope,
+  FrontierSourceLanguage,
+  LanguageImportResult,
+  NativeAstLossRecord,
+  NativeAstNode,
+  NativeAstRecord,
+  NativeSourceNode,
+  SemanticMergeCandidateRecord,
+  SemanticMergeReadiness,
+  SemanticIndexRecord,
+  SemanticNode,
+  SemanticPatchBundle,
+  SourceMapMappingRecord,
+  SourceMapRecord,
+  SourcePreservationLevel,
+  SourcePreservationRecord,
+  SourceSpan,
+  UniversalAstLayerMap,
+  UniversalAstLayerRecord
+} from '@shapeshift-labs/frontier-lang-kernel';
+import type { Diagnostic } from '@shapeshift-labs/frontier-lang-checker';
+import type { EmitTypeScriptOptions, TypeScriptAstModule, TypeScriptDocumentSourceMapResult, TypeScriptGeneratedSourceMapResult } from '@shapeshift-labs/frontier-lang-typescript';
+import type { EmitJavaScriptOptions, EmitJavaScriptWithSourceMapResult, JavaScriptAstModule, JavaScriptSourceMapResult } from '@shapeshift-labs/frontier-lang-javascript';
+import type { EmitRustOptions, EmitRustWithSourceMapResult, RustAstModule, RustSourceMapResult } from '@shapeshift-labs/frontier-lang-rust';
+import type { EmitPythonOptions, EmitPythonWithSourceMapResult, PythonAstModule, PythonSourceMapResult } from '@shapeshift-labs/frontier-lang-python';
+import type { CAstHeader, CSourceMapResult, EmitCHeaderOptions, EmitCHeaderWithSourceMapResult } from '@shapeshift-labs/frontier-lang-c';
+import type { FrontierCompileTarget, FrontierCompileEmitOptions, FrontierTargetAst, FrontierTargetSourceMapResult, FrontierTargetDocumentSourceMapResult, FrontierCompileOptions, FrontierCompileResult, CapabilityResolution } from './compile.js';
+import type { NativeImportTaxonomyKind, NativeImportKnownLossKind, NativeImportRegionTaxonomyKind, NativeImportLossSummaryOptions, NativeImportFeatureEvidenceRisk, NativeImportFeatureEvidencePolicy, NativeImportFeatureEvidenceIssue, NativeImportFeatureEvidenceSummary, NativeImportLossSummary, NativeImportReadinessClassification, NativeImportLanguageProfile } from './native-import-losses.js';
+import type { NativeParserAstFormatKind, NativeParserAstFormatProfile, NativeParserAstFormatCoverage, NativeParserAstFormatMatrix, NativeParserAstFormatMatrixOptions } from './native-parser-formats.js';
+import type { NativeParserFeatureCategory, NativeParserFeatureCoverageStatus, NativeParserFeatureCoverage, NativeParserFeatureCoverageMap, NativeParserFeatureMergeAssessment, NativeParserFeatureParserRow, NativeParserFeatureLanguageSummary, NativeParserFeatureMatrix, NativeParserFeatureMatrixOptions, NativeParserFeatureMatrixQuery, NativeParserFeatureMatrixQueryResult, NativeImporterAdapterCoverageAggregate } from './native-parser-features.js';
+import type { NativeImportCoverageLanguage, NativeImportCoverageMatrix, NativeImportCoverageMatrixOptions } from './native-import-coverage.js';
+import type { ProjectionTargetLossClass, ProjectionSourceProjectionCoverage, ProjectionTargetCoverageEntry, ProjectionTargetLanguageCoverage, ProjectionTargetLossMatrix, ProjectionTargetLossMatrixOptions } from './projection-coverage.js';
+import type { UniversalCapabilityLanguageRow, UniversalCapabilityMatrix, UniversalCapabilityMatrixOptions } from './universal-capability.js';
+import type { NativeImportContractSource, NativeImportSourcePreservationRecordSummary, NativeImportSourcePreservationContract, NativeImportAdapterCoverageRecordSummary, NativeImportAdapterCoverageContract, NativeImportRegionSummary, NativeImportSourceMapSummary, NativeImportReadinessContract, NativeImportResultContract, NativeImportResultContractOptions } from './native-import-contracts.js';
+import type { NativeSourceTokenKind, NativeSourcePreservedToken, NativeSourcePreservedDirective, NativeSourcePreservation, CreateNativeSourcePreservationOptions } from './source-preservation.js';
+import type { SemanticImportOwnershipRegion, SemanticImportSidecarSymbol, SemanticImportRegionTaxonomySummary, SemanticImportPatchHint, SemanticImportSidecarImportEntry, SemanticImportSidecarSourcePreservationRecord, SemanticImportSidecarUniversalAstLayerSummary, SemanticImportSidecarProofSpecSummary, SemanticImportSidecarParadigmSemanticsSummary, SemanticImportSidecar, SemanticImportSidecarOptions } from './semantic-sidecar.js';
+import type { NativeSourceChangeKind, NativeSourceChangeProjectionEndpoint, NativeSourceChangeProjectionSourceMapLink, NativeSourceChangeProjectionMetadata, NativeSourceChangeProjectionSummary, NativeSourceChangeSymbol, NativeSourceChangeRegion, NativeSourceChangeSummary, DiffNativeSourceImportsOptions, DiffNativeSourcesOptions, NativeSourceChangeSet } from './native-diff.js';
+import type { SemanticSliceInput, CreateSemanticSliceOptions, SemanticSliceSourceMapLink, SemanticSliceSourceFile, SemanticSliceExpectedAssertion, SemanticSlice, TestSemanticSliceOptions, SemanticSliceTestAssertion, SemanticSliceTestResult } from './semantic-slice.js';
+import type { NativeImporterAdapterExactness, NativeImporterAdapterSemanticCoverage, NativeImporterAdapterCoverageSnapshot, NativeImporterAdapterCoverageObserved, NativeImporterAdapterCoverageCapabilityRow, NativeImporterAdapterCoverageCapabilityEvidence, NativeImporterAdapterCoverageSummary, NativeImporterAdapterCoverageInput } from './adapter-coverage.js';
+import type { NativeImporterAdapterDiagnostic, ImportNativeSourceOptions, NativeSourceImportResult, ExternalSemanticIndexFormat, ImportExternalSemanticIndexOptions, ExternalSemanticIndexImportSummary, ExternalSemanticIndexImportResult, NativeImporterAdapterParseInput, NativeImporterAdapterParseResult, NativeImporterAdapter, NativeImporterAdapterSummary, RunNativeImporterAdapterOptions, NativeImporterAdapterImportResult } from './import-adapter-core.js';
+import type { JavaScriptNativeImporterAdapterOptions, TypeScriptCompilerNativeImporterAdapterOptions, PythonAstNativeImporterAdapterOptions, RustSynNativeImporterAdapterOptions, ClangAstNativeImporterAdapterOptions, GoAstNativeImporterAdapterOptions } from './import-adapter-options-native.js';
+import type { JavaAstNativeImporterAdapterOptions, KotlinPsiNativeImporterAdapterOptions, CSharpRoslynNativeImporterAdapterOptions, SwiftSyntaxNativeImporterAdapterOptions, TreeSitterNativeImporterAdapterOptions } from './import-adapter-options-platform.js';
+import type { NativeTargetProjectionAdapterCoverageInput, NativeTargetProjectionAdapterSummary, NativeTargetProjectionAdapterInput, NativeTargetProjectionAdapterResult, NativeTargetProjectionAdapter, NativeTargetProjectionAdapterResolverInput, NativeTargetProjectionResult } from './target-adapters.js';
+import type { NativeProjectSourceInput, ImportNativeProjectOptions, NativeProjectImportResult, NativeSourceProjectionMode, ProjectNativeImportToSourceOptions, NativeSourceProjectionDeclaration, NativeSourceProjectionResult, NativeSourceCompileOutputMode, CompileNativeSourceOptions, NativeSourceCompileResult } from './native-project.js';
+
+export type NativeImportRoundtripReadinessStatus =
+  | 'exact'
+  | 'preserved-source'
+  | 'stub-only'
+  | 'blocked'
+  | 'needs-review';
+
+export interface NativeImportRoundtripReadinessOptions extends ProjectNativeImportToSourceOptions {
+  readonly projection?: NativeSourceProjectionResult;
+}
+
+export interface NativeImportRoundtripReadinessClassification {
+  readonly kind: 'frontier.lang.nativeImportRoundtripReadiness';
+  readonly version: 1;
+  readonly status: NativeImportRoundtripReadinessStatus;
+  readonly semanticMergeReadiness: SemanticMergeReadiness;
+  readonly reasons: readonly string[];
+  readonly importReadiness: NativeImportReadinessClassification;
+  readonly projectionReadiness: NativeImportReadinessClassification;
+  readonly projectionMode: NativeSourceProjectionMode;
+  readonly checks: {
+    readonly nativeImport: {
+      readonly imports: number;
+      readonly exactAst: boolean;
+      readonly losses: number;
+      readonly readiness: SemanticMergeReadiness;
+    };
+    readonly universalAst: {
+      readonly present: boolean;
+      readonly valid: boolean;
+      readonly issues: readonly string[];
+      readonly nativeSources: number;
+      readonly semanticSymbols: number;
+      readonly sourceMaps: number;
+      readonly sourceMapMappings: number;
+    };
+    readonly projectedSource: {
+      readonly mode: NativeSourceProjectionMode;
+      readonly outputHash: string;
+      readonly expectedSourceHash?: string;
+      readonly sourceHashVerified: boolean;
+      readonly declarations: number;
+      readonly losses: number;
+      readonly readiness: SemanticMergeReadiness;
+    };
+  };
+  readonly evidence: {
+    readonly importEvidenceIds: readonly string[];
+    readonly projectionEvidenceIds: readonly string[];
+    readonly failedEvidenceIds: readonly string[];
+  };
+  readonly metadata: Record<string, unknown>;
+}
+
+export type NativeRoundtripEvidenceStatus = NativeImportRoundtripReadinessStatus | 'target-adapter';
+
+export type NativeRoundtripSourceMapPrecision = SourceMapMappingRecord['precision'] | 'line' | 'declaration' | 'estimated' | 'unknown' | 'none' | string;
+
+export interface NativeRoundtripSourceMapEvidence {
+  readonly total: number;
+  readonly ids: readonly string[];
+  readonly mappings: number;
+  readonly precision: NativeRoundtripSourceMapPrecision;
+  readonly byPrecision: Readonly<Record<string, number>>;
+  readonly byOrigin: Readonly<Record<string, number>>;
+  readonly withSourceSpan: number;
+  readonly withGeneratedSpan: number;
+  readonly withSemanticSymbol: number;
+  readonly targetPaths: readonly string[];
+}
+
+export interface NativeRoundtripEvidenceMetadata {
+  readonly status: NativeRoundtripEvidenceStatus;
+  readonly semanticMergeReadiness: SemanticMergeReadiness;
+  readonly reviewRequired: boolean;
+  readonly sourcePath?: string;
+  readonly language?: FrontierSourceLanguage | string;
+  readonly target?: CompileTarget | string;
+  readonly import: {
+    readonly id?: string;
+    readonly readiness: SemanticMergeReadiness;
+    readonly exactAst: boolean;
+    readonly lossCount: number;
+    readonly evidenceIds: readonly string[];
+  };
+  readonly universalAst: {
+    readonly id?: string;
+    readonly present: boolean;
+    readonly valid: boolean;
+    readonly issues: readonly string[];
+    readonly nativeSources: number;
+    readonly semanticSymbols: number;
+    readonly sourceMaps: NativeRoundtripSourceMapEvidence;
+  };
+  readonly projection: {
+    readonly id?: string;
+    readonly mode?: NativeSourceProjectionMode;
+    readonly readiness: SemanticMergeReadiness;
+    readonly sourceHashVerified: boolean;
+    readonly outputHash?: string;
+    readonly declarationCount: number;
+    readonly lossCount: number;
+    readonly evidenceIds: readonly string[];
+  };
+  readonly output: {
+    readonly mode?: NativeSourceCompileOutputMode;
+    readonly targetProjectionId?: string;
+    readonly targetProjectionAdapterId?: string;
+    readonly targetCoverageLossClass?: ProjectionTargetLossClass | string;
+    readonly targetReadiness?: SemanticMergeReadiness;
+    readonly targetSupported?: boolean;
+    readonly sourceMaps: NativeRoundtripSourceMapEvidence;
+  };
+  readonly losses: {
+    readonly total: number;
+    readonly bySeverity: Readonly<Record<string, number>>;
+    readonly byKind: Readonly<Record<string, number>>;
+    readonly blockingLossIds: readonly string[];
+    readonly reviewLossIds: readonly string[];
+    readonly informationalLossIds: readonly string[];
+  };
+}
+
+export interface NativeRoundtripEvidenceRecord extends Omit<EvidenceRecord, 'kind' | 'metadata'> {
+  readonly kind: 'import';
+  readonly metadata: {
+    readonly schema: 'frontier.lang.nativeRoundtripEvidence';
+    readonly version: 1;
+    readonly roundtripEvidence: NativeRoundtripEvidenceMetadata;
+    readonly [key: string]: unknown;
+  };
+}
+
+export interface NativeRoundtripEvidenceOptions {
+  readonly id?: string;
+  readonly projection?: NativeSourceProjectionResult;
+  readonly targetProjection?: NativeTargetProjectionResult;
+  readonly targetCoverage?: ProjectionTargetCoverageEntry;
+  readonly sourceMaps?: readonly SourceMapRecord[];
+  readonly losses?: readonly NativeAstLossRecord[];
+  readonly readiness?: NativeImportReadinessClassification;
+  readonly target?: CompileTarget | string;
+  readonly outputMode?: NativeSourceCompileOutputMode;
+}
+
+export declare function createNativeRoundtripEvidence(
+  importResult: NativeSourceImportResult,
+  options?: NativeRoundtripEvidenceOptions
+): NativeRoundtripEvidenceRecord;

package/dist/declarations/runtime.d.ts

@@ -0,0 +1,135 @@
+import type {
+  CapabilityAdapterBinding,
+  CapabilityUnsupportedTarget,
+  CompileTarget,
+  EvidenceRecord,
+  FrontierLangDocument,
+  FrontierUniversalAstEnvelope,
+  FrontierSourceLanguage,
+  LanguageImportResult,
+  NativeAstLossRecord,
+  NativeAstNode,
+  NativeAstRecord,
+  NativeSourceNode,
+  SemanticMergeCandidateRecord,
+  SemanticMergeReadiness,
+  SemanticIndexRecord,
+  SemanticNode,
+  SemanticPatchBundle,
+  SourceMapMappingRecord,
+  SourceMapRecord,
+  SourcePreservationLevel,
+  SourcePreservationRecord,
+  SourceSpan,
+  UniversalAstLayerMap,
+  UniversalAstLayerRecord
+} from '@shapeshift-labs/frontier-lang-kernel';
+import type { Diagnostic } from '@shapeshift-labs/frontier-lang-checker';
+import type { EmitTypeScriptOptions, TypeScriptAstModule, TypeScriptDocumentSourceMapResult, TypeScriptGeneratedSourceMapResult } from '@shapeshift-labs/frontier-lang-typescript';
+import type { EmitJavaScriptOptions, EmitJavaScriptWithSourceMapResult, JavaScriptAstModule, JavaScriptSourceMapResult } from '@shapeshift-labs/frontier-lang-javascript';
+import type { EmitRustOptions, EmitRustWithSourceMapResult, RustAstModule, RustSourceMapResult } from '@shapeshift-labs/frontier-lang-rust';
+import type { EmitPythonOptions, EmitPythonWithSourceMapResult, PythonAstModule, PythonSourceMapResult } from '@shapeshift-labs/frontier-lang-python';
+import type { CAstHeader, CSourceMapResult, EmitCHeaderOptions, EmitCHeaderWithSourceMapResult } from '@shapeshift-labs/frontier-lang-c';
+import type { FrontierCompileTarget, FrontierCompileEmitOptions, FrontierTargetAst, FrontierTargetSourceMapResult, FrontierTargetDocumentSourceMapResult, FrontierCompileOptions, FrontierCompileResult, CapabilityResolution } from './compile.js';
+import type { NativeImportTaxonomyKind, NativeImportKnownLossKind, NativeImportRegionTaxonomyKind, NativeImportLossSummaryOptions, NativeImportFeatureEvidenceRisk, NativeImportFeatureEvidencePolicy, NativeImportFeatureEvidenceIssue, NativeImportFeatureEvidenceSummary, NativeImportLossSummary, NativeImportReadinessClassification, NativeImportLanguageProfile } from './native-import-losses.js';
+import type { NativeParserAstFormatKind, NativeParserAstFormatProfile, NativeParserAstFormatCoverage, NativeParserAstFormatMatrix, NativeParserAstFormatMatrixOptions } from './native-parser-formats.js';
+import type { NativeParserFeatureCategory, NativeParserFeatureCoverageStatus, NativeParserFeatureCoverage, NativeParserFeatureCoverageMap, NativeParserFeatureMergeAssessment, NativeParserFeatureParserRow, NativeParserFeatureLanguageSummary, NativeParserFeatureMatrix, NativeParserFeatureMatrixOptions, NativeParserFeatureMatrixQuery, NativeParserFeatureMatrixQueryResult, NativeImporterAdapterCoverageAggregate } from './native-parser-features.js';
+import type { NativeImportCoverageLanguage, NativeImportCoverageMatrix, NativeImportCoverageMatrixOptions } from './native-import-coverage.js';
+import type { ProjectionTargetLossClass, ProjectionSourceProjectionCoverage, ProjectionTargetCoverageEntry, ProjectionTargetLanguageCoverage, ProjectionTargetLossMatrix, ProjectionTargetLossMatrixOptions } from './projection-coverage.js';
+import type { ProjectionReadinessMatrix, ProjectionReadinessMatrixOptions, ProjectionReadinessMatrixQuery, ProjectionReadinessMatrixQueryResult } from './projection-readiness.js';
+import type { UniversalCapabilityLanguageRow, UniversalCapabilityMatrix, UniversalCapabilityMatrixOptions } from './universal-capability.js';
+import type { UniversalDialectRegistry, UniversalDialectRegistryInput, UniversalDialectRecordInput, UniversalExternRecordInput } from './universal-dialects.js';
+import type { NativeImportContractSource, NativeImportSourcePreservationRecordSummary, NativeImportSourcePreservationContract, NativeImportAdapterCoverageRecordSummary, NativeImportAdapterCoverageContract, NativeImportRegionSummary, NativeImportSourceMapSummary, NativeImportReadinessContract, NativeImportResultContract, NativeImportResultContractOptions } from './native-import-contracts.js';
+import type { NativeSourceTokenKind, NativeSourcePreservedToken, NativeSourcePreservedDirective, NativeSourcePreservation, CreateNativeSourcePreservationOptions } from './source-preservation.js';
+import type { SemanticImportOwnershipRegion, SemanticImportSidecarSymbol, SemanticImportRegionTaxonomySummary, SemanticImportPatchHint, SemanticImportSidecarImportEntry, SemanticImportSidecarSourcePreservationRecord, SemanticImportSidecarUniversalAstLayerSummary, SemanticImportSidecarProofSpecSummary, SemanticImportSidecarParadigmSemanticsSummary, SemanticImportSidecar, SemanticImportSidecarOptions } from './semantic-sidecar.js';
+import type { NativeSourceChangeKind, NativeSourceChangeProjectionEndpoint, NativeSourceChangeProjectionSourceMapLink, NativeSourceChangeProjectionMetadata, NativeSourceChangeProjectionSummary, NativeSourceChangeSymbol, NativeSourceChangeRegion, NativeSourceChangeSummary, DiffNativeSourceImportsOptions, DiffNativeSourcesOptions, NativeSourceChangeSet } from './native-diff.js';
+import type { SemanticSliceInput, CreateSemanticSliceOptions, SemanticSliceSourceMapLink, SemanticSliceSourceFile, SemanticSliceExpectedAssertion, SemanticSlice, TestSemanticSliceOptions, SemanticSliceTestAssertion, SemanticSliceTestResult } from './semantic-slice.js';
+import type { NativeImporterAdapterExactness, NativeImporterAdapterSemanticCoverage, NativeImporterAdapterCoverageSnapshot, NativeImporterAdapterCoverageObserved, NativeImporterAdapterCoverageCapabilityRow, NativeImporterAdapterCoverageCapabilityEvidence, NativeImporterAdapterCoverageSummary, NativeImporterAdapterCoverageInput } from './adapter-coverage.js';
+import type { NativeImporterAdapterDiagnostic, ImportNativeSourceOptions, NativeSourceImportResult, ExternalSemanticIndexFormat, ImportExternalSemanticIndexOptions, ExternalSemanticIndexImportSummary, ExternalSemanticIndexImportResult, NativeImporterAdapterParseInput, NativeImporterAdapterParseResult, NativeImporterAdapter, NativeImporterAdapterSummary, RunNativeImporterAdapterOptions, NativeImporterAdapterImportResult } from './import-adapter-core.js';
+import type { JavaScriptNativeImporterAdapterOptions, TypeScriptCompilerNativeImporterAdapterOptions, PythonAstNativeImporterAdapterOptions, RustSynNativeImporterAdapterOptions, ClangAstNativeImporterAdapterOptions, GoAstNativeImporterAdapterOptions } from './import-adapter-options-native.js';
+import type { JavaAstNativeImporterAdapterOptions, KotlinPsiNativeImporterAdapterOptions, CSharpRoslynNativeImporterAdapterOptions, SwiftSyntaxNativeImporterAdapterOptions, TreeSitterNativeImporterAdapterOptions } from './import-adapter-options-platform.js';
+import type { NativeTargetProjectionAdapterCoverageInput, NativeTargetProjectionAdapterSummary, NativeTargetProjectionAdapterInput, NativeTargetProjectionAdapterResult, NativeTargetProjectionAdapter, NativeTargetProjectionAdapterResolverInput, NativeTargetProjectionResult } from './target-adapters.js';
+import type { NativeProjectSourceInput, ImportNativeProjectOptions, NativeProjectImportResult, NativeSourceProjectionMode, ProjectNativeImportToSourceOptions, NativeSourceProjectionDeclaration, NativeSourceProjectionResult, NativeSourceCompileOutputMode, CompileNativeSourceOptions, NativeSourceCompileResult } from './native-project.js';
+import type { NativeImportRoundtripReadinessStatus, NativeImportRoundtripReadinessOptions, NativeImportRoundtripReadinessClassification } from './roundtrip.js';
+
+export declare const FrontierCompileTargets: readonly FrontierCompileTarget[];
+export declare const NativeImportRoundtripReadinessStatuses: readonly NativeImportRoundtripReadinessStatus[];
+export declare const NativeImportTaxonomyKinds: readonly NativeImportTaxonomyKind[];
+export declare const NativeImportLossKinds: readonly NativeImportKnownLossKind[];
+export declare const NativeImportRegionTaxonomyKinds: readonly NativeImportRegionTaxonomyKind[];
+export declare const ProjectionTargetLossClasses: readonly ProjectionTargetLossClass[];
+export declare const NativeParserFeatureCategories: readonly NativeParserFeatureCategory[];
+export declare const NativeParserFeatureCoverageStatuses: readonly NativeParserFeatureCoverageStatus[];
+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 NativeParserAstFormatProfiles: readonly NativeParserAstFormatProfile[];
+export declare const NativeParserAstFormats: readonly string[];
+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;
+export declare function compileNativeSource(input: ImportNativeSourceOptions | NativeSourceImportResult, options?: CompileNativeSourceOptions): NativeSourceCompileResult;
+export declare function projectFrontierAst(document: FrontierLangDocument, target?: FrontierCompileOptions['target'], options?: FrontierCompileEmitOptions): FrontierTargetAst;
+export declare function renderTargetAst(ast: FrontierTargetAst, target?: FrontierCompileOptions['target']): string;
+export declare function renderTargetAstWithSourceMap(ast: FrontierTargetAst, target?: FrontierCompileOptions['target'], options?: FrontierCompileEmitOptions): FrontierTargetSourceMapResult;
+export declare function emitForTargetWithSourceMap(document: FrontierLangDocument, target?: FrontierCompileOptions['target'], options?: FrontierCompileEmitOptions): FrontierTargetDocumentSourceMapResult;
+export declare function resolveCapabilityAdapters(document: FrontierLangDocument, target?: FrontierCompileOptions['target'], options?: { readonly platform?: string }): readonly CapabilityResolution[];
+export declare function getNativeImportFeatureEvidencePolicy(kind: NativeImportKnownLossKind | string): NativeImportFeatureEvidencePolicy | undefined;
+export declare function summarizeNativeImportFeatureEvidence(losses?: readonly NativeAstLossRecord[], options?: NativeImportLossSummaryOptions): NativeImportFeatureEvidenceSummary;
+export declare function summarizeNativeImportLosses(losses?: readonly NativeAstLossRecord[], options?: NativeImportLossSummaryOptions): NativeImportLossSummary;
+export declare function classifyNativeImportReadiness(losses?: readonly NativeAstLossRecord[], options?: NativeImportLossSummaryOptions): NativeImportReadinessClassification;
+export declare function classifyNativeImportRoundtripReadiness(importResult: NativeSourceImportResult | NativeProjectImportResult, options?: NativeImportRoundtripReadinessOptions): NativeImportRoundtripReadinessClassification;
+export declare function createNativeImportCoverageMatrix(options?: NativeImportCoverageMatrixOptions): NativeImportCoverageMatrix;
+export declare function getNativeParserAstFormatProfile(format?: string): NativeParserAstFormatProfile | undefined;
+export declare function createNativeParserAstFormatMatrix(options?: NativeParserAstFormatMatrixOptions): NativeParserAstFormatMatrix;
+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 createProjectionReadinessMatrix(options?: ProjectionReadinessMatrixOptions): ProjectionReadinessMatrix;
+export declare function queryProjectionReadinessMatrix(matrixOrOptions?: ProjectionReadinessMatrix | ProjectionReadinessMatrixOptions, query?: ProjectionReadinessMatrixQuery): ProjectionReadinessMatrixQueryResult;
+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;
+export declare function createEstreeNativeImporterAdapter(options?: JavaScriptNativeImporterAdapterOptions): NativeImporterAdapter;
+export declare function createBabelNativeImporterAdapter(options?: JavaScriptNativeImporterAdapterOptions): NativeImporterAdapter;
+export declare function createTypeScriptCompilerNativeImporterAdapter(options?: TypeScriptCompilerNativeImporterAdapterOptions): NativeImporterAdapter;
+export declare function createPythonAstNativeImporterAdapter(options?: PythonAstNativeImporterAdapterOptions): NativeImporterAdapter;
+export declare function createRustSynNativeImporterAdapter(options?: RustSynNativeImporterAdapterOptions): NativeImporterAdapter;
+export declare function createClangAstNativeImporterAdapter(options?: ClangAstNativeImporterAdapterOptions): NativeImporterAdapter;
+export declare function createGoAstNativeImporterAdapter(options?: GoAstNativeImporterAdapterOptions): NativeImporterAdapter;
+export declare function createJavaAstNativeImporterAdapter(options?: JavaAstNativeImporterAdapterOptions): NativeImporterAdapter;
+export declare function createKotlinPsiNativeImporterAdapter(options?: KotlinPsiNativeImporterAdapterOptions): NativeImporterAdapter;
+export declare function createCSharpRoslynNativeImporterAdapter(options?: CSharpRoslynNativeImporterAdapterOptions): NativeImporterAdapter;
+export declare function createSwiftSyntaxNativeImporterAdapter(options?: SwiftSyntaxNativeImporterAdapterOptions): NativeImporterAdapter;
+export declare function createTreeSitterNativeImporterAdapter(options?: TreeSitterNativeImporterAdapterOptions): NativeImporterAdapter;
+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;
+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;
+  readonly nativeSources?: readonly NativeSourceNode[];
+  readonly semanticIndex?: SemanticIndexRecord;
+  readonly sourceMaps?: readonly SourceMapRecord[];
+  readonly losses?: readonly NativeAstLossRecord[];
+  readonly evidence?: readonly EvidenceRecord[];
+  readonly mergeCandidates?: readonly SemanticMergeCandidateRecord[];
+  readonly layers?: UniversalAstLayerMap | readonly UniversalAstLayerRecord[];
+  readonly universalDialectRegistry?: UniversalDialectRegistryInput | UniversalDialectRegistry;
+  readonly dialects?: readonly UniversalDialectRecordInput[];
+  readonly externs?: readonly UniversalExternRecordInput[];
+  readonly metadata?: Record<string, unknown>;
+}): FrontierUniversalAstEnvelope;
+export declare function readUniversalAstJson(source: string): FrontierUniversalAstEnvelope;
+export declare function writeUniversalAstJson(envelope: FrontierUniversalAstEnvelope): string;
+export declare function emitForTarget(document: FrontierLangDocument, target?: FrontierCompileOptions['target'], options?: FrontierCompileEmitOptions): string;

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

@@ -0,0 +1,188 @@
+import type {
+  EvidenceRecord,
+  FrontierSourceLanguage,
+  SemanticMergeCandidateRecord,
+  SemanticMergeReadiness,
+  SourceSpan
+} from '@shapeshift-labs/frontier-lang-kernel';
+import type { SemanticImportOwnershipRegion } from './semantic-sidecar.js';
+
+export type SemanticHistoryAdmissionStatus = 'proposed' | 'queued' | 'admitted' | 'needs-review' | 'blocked' | 'rejected' | string;
+export type SemanticHistoryReviewerStatus = 'unreviewed' | 'approved' | 'changes-requested' | 'reviewed' | 'rejected' | string;
+export type SemanticHistoryReplayLinkKind = 'patch' | 'slice' | 'sidecar' | 'run' | 'proof' | 'source' | 'command' | 'url' | 'replay' | string;
+export type SemanticHistoryOverlapKind = 'ownership' | 'conflict-key' | 'source' | 'source-path' | 'import' | 'semantic-candidate' | 'evidence' | 'proof' | 'replay' | 'base-hash' | 'target-hash';
+export type SemanticHistoryConflictReason = 'ownership-overlap' | 'semantic-conflict-key-overlap' | 'base-hash-mismatch' | 'target-hash-mismatch' | 'admission-blocked' | 'reviewer-rejected' | 'source-path-overlap' | string;
+
+export interface SemanticHistorySourceRef {
+  readonly id?: string;
+  readonly importId?: string;
+  readonly language?: FrontierSourceLanguage | string;
+  readonly sourcePath?: string;
+  readonly sourceHash?: string;
+  readonly baseHash?: string;
+  readonly targetHash?: string;
+  readonly metadata?: Record<string, unknown>;
+}
+
+export interface SemanticHistoryOwnershipRegionRef {
+  readonly id?: string;
+  readonly key: string;
+  readonly regionKind?: string;
+  readonly granularity?: string;
+  readonly language?: FrontierSourceLanguage | string;
+  readonly sourcePath?: string;
+  readonly sourceHash?: string;
+  readonly symbolId?: string;
+  readonly symbolName?: string;
+  readonly sourceSpan?: SourceSpan;
+  readonly metadata?: Record<string, unknown>;
+}
+
+export interface SemanticHistoryCandidateRef {
+  readonly id: string;
+  readonly importResultId?: string;
+  readonly patchId?: string;
+  readonly sourcePath?: string;
+  readonly baseHash?: string;
+  readonly targetHash?: string;
+  readonly readiness?: SemanticMergeReadiness | string;
+  readonly conflictKeys: readonly string[];
+  readonly ownershipKeys: readonly string[];
+  readonly evidenceIds: readonly string[];
+  readonly proofIds: readonly string[];
+  readonly replayIds: readonly string[];
+  readonly metadata?: Record<string, unknown>;
+}
+
+export interface SemanticHistoryReviewerState {
+  readonly status: SemanticHistoryReviewerStatus;
+  readonly reviewerId?: string;
+  readonly reviewedAt?: number | string;
+  readonly evidenceIds?: readonly string[];
+  readonly metadata?: Record<string, unknown>;
+}
+
+export interface SemanticHistoryAdmissionState {
+  readonly status: SemanticHistoryAdmissionStatus;
+  readonly readiness: SemanticMergeReadiness | string;
+  readonly admittedAt?: number | string;
+  readonly reviewerId?: string;
+  readonly reasonCodes?: readonly string[];
+  readonly evidenceIds?: readonly string[];
+  readonly metadata?: Record<string, unknown>;
+}
+
+export interface SemanticHistoryReplayLink {
+  readonly id: string;
+  readonly kind: SemanticHistoryReplayLinkKind;
+  readonly href?: string;
+  readonly path?: string;
+  readonly command?: string;
+  readonly hash?: string;
+  readonly targetId?: string;
+  readonly metadata?: Record<string, unknown>;
+}
+
+export interface SemanticHistoryRecordIndex {
+  readonly baseHashes: readonly string[];
+  readonly targetHashes: readonly string[];
+  readonly sourceIds: readonly string[];
+  readonly importIds: readonly string[];
+  readonly sourcePaths: readonly string[];
+  readonly sourceHashes: readonly string[];
+  readonly ownershipKeys: readonly string[];
+  readonly semanticCandidateIds: readonly string[];
+  readonly conflictKeys: readonly string[];
+  readonly evidenceIds: readonly string[];
+  readonly proofIds: readonly string[];
+  readonly replayIds: readonly string[];
+}
+
+export interface SemanticHistoryRecord {
+  readonly kind: 'frontier.lang.semanticHistoryRecord';
+  readonly version: 1;
+  readonly id: string;
+  readonly createdAt: number | string;
+  readonly baseHash?: string;
+  readonly targetHash?: string;
+  readonly language?: FrontierSourceLanguage | string;
+  readonly sourcePath?: string;
+  readonly sourceIds: readonly string[];
+  readonly importIds: readonly string[];
+  readonly sources: readonly SemanticHistorySourceRef[];
+  readonly ownershipRegions: readonly SemanticHistoryOwnershipRegionRef[];
+  readonly semanticCandidates: readonly SemanticHistoryCandidateRef[];
+  readonly evidenceIds: readonly string[];
+  readonly proofIds: readonly string[];
+  readonly reviewer: SemanticHistoryReviewerState;
+  readonly admission: SemanticHistoryAdmissionState;
+  readonly replayLinks: readonly SemanticHistoryReplayLink[];
+  readonly index: SemanticHistoryRecordIndex;
+  readonly metadata?: Record<string, unknown>;
+}
+
+export interface CreateSemanticHistoryRecordInput {
+  readonly id?: string;
+  readonly createdAt?: number | string;
+  readonly baseHash?: string;
+  readonly targetHash?: string;
+  readonly beforeHash?: string;
+  readonly afterHash?: string;
+  readonly language?: FrontierSourceLanguage | string;
+  readonly sourcePath?: string;
+  readonly sourceHash?: string;
+  readonly sourceId?: string;
+  readonly sourceIds?: readonly string[] | string;
+  readonly importId?: string;
+  readonly importIds?: readonly string[] | string;
+  readonly importResultId?: string;
+  readonly sources?: readonly SemanticHistorySourceRef[] | SemanticHistorySourceRef;
+  readonly sourceRefs?: readonly SemanticHistorySourceRef[] | SemanticHistorySourceRef;
+  readonly ownershipRegions?: readonly (SemanticHistoryOwnershipRegionRef | SemanticImportOwnershipRegion)[] | SemanticHistoryOwnershipRegionRef | SemanticImportOwnershipRegion;
+  readonly semanticCandidates?: readonly (Partial<SemanticHistoryCandidateRef> | SemanticMergeCandidateRecord)[] | Partial<SemanticHistoryCandidateRef> | SemanticMergeCandidateRecord;
+  readonly mergeCandidates?: readonly SemanticMergeCandidateRecord[] | SemanticMergeCandidateRecord;
+  readonly evidence?: readonly EvidenceRecord[];
+  readonly evidenceIds?: readonly string[] | string;
+  readonly proofIds?: readonly string[] | string;
+  readonly reviewer?: SemanticHistoryReviewerState | SemanticHistoryReviewerStatus;
+  readonly admission?: Partial<SemanticHistoryAdmissionState>;
+  readonly replayLinks?: readonly (SemanticHistoryReplayLink | string)[] | SemanticHistoryReplayLink | string;
+  readonly replay?: readonly (SemanticHistoryReplayLink | string)[] | SemanticHistoryReplayLink | string;
+  readonly importResult?: unknown;
+  readonly imported?: unknown;
+  readonly changeSet?: unknown;
+  readonly changedRegions?: readonly unknown[];
+  readonly mergeCandidate?: unknown;
+  readonly metadata?: Record<string, unknown>;
+}
+
+export interface SemanticHistoryOverlapQueryOptions {
+  readonly includeSourcePaths?: boolean;
+  readonly includeEvidence?: boolean;
+  readonly includeProofs?: boolean;
+  readonly includeReplay?: boolean;
+  readonly includeBaseHashes?: boolean;
+  readonly includeTargetHashes?: boolean;
+  readonly conflictOnSourcePath?: boolean;
+}
+
+export interface SemanticHistoryOverlapRecord {
+  readonly schema: 'frontier.lang.semanticHistoryOverlap.v1';
+  readonly leftId: string;
+  readonly rightId: string;
+  readonly overlap: Partial<Record<SemanticHistoryOverlapKind, readonly string[]>>;
+  readonly overlapKinds: readonly SemanticHistoryOverlapKind[];
+  readonly conflict: boolean;
+  readonly conflictReasons: readonly SemanticHistoryConflictReason[];
+  readonly admission: { readonly left?: SemanticHistoryAdmissionStatus; readonly right?: SemanticHistoryAdmissionStatus };
+  readonly reviewer: { readonly left?: SemanticHistoryReviewerStatus; readonly right?: SemanticHistoryReviewerStatus };
+}
+
+export declare const SemanticHistoryAdmissionStatuses: readonly SemanticHistoryAdmissionStatus[];
+export declare const SemanticHistoryReviewerStatuses: readonly SemanticHistoryReviewerStatus[];
+export declare const SemanticHistoryOverlapKinds: readonly SemanticHistoryOverlapKind[];
+export declare const SemanticHistoryConflictReasons: readonly SemanticHistoryConflictReason[];
+export declare function createSemanticHistoryRecord(input?: CreateSemanticHistoryRecordInput, options?: { readonly id?: string; readonly createdAt?: number | string }): SemanticHistoryRecord;
+export declare function querySemanticHistoryRecordOverlaps(records: SemanticHistoryRecord | readonly SemanticHistoryRecord[], options?: SemanticHistoryOverlapQueryOptions): readonly SemanticHistoryOverlapRecord[];
+export declare function semanticHistoryRecordsOverlap(left: SemanticHistoryRecord, right: SemanticHistoryRecord, options?: SemanticHistoryOverlapQueryOptions): boolean;
+export declare function semanticHistoryRecordsConflict(left: SemanticHistoryRecord, right: SemanticHistoryRecord, options?: SemanticHistoryOverlapQueryOptions): boolean;

package/dist/declarations/semantic-merge-conflicts.d.ts

@@ -0,0 +1,82 @@
+import type {
+  FrontierSourceLanguage,
+  SemanticMergeCandidateRecord,
+  SemanticMergeReadiness
+} from '@shapeshift-labs/frontier-lang-kernel';
+
+export type SemanticMergeConflictClass =
+  | 'same-symbol-edit'
+  | 'delete-modify'
+  | 'shifted-code'
+  | 'duplicate-signature'
+  | 'dependency-drift'
+  | 'behavior-evidence-needed';
+
+export type SemanticMergeConflictRisk = 'low' | 'medium' | 'high';
+
+export interface SemanticMergeConflictClassRecord {
+  readonly schema: 'frontier.lang.semanticMergeConflictClass.v1';
+  readonly id: string;
+  readonly class: SemanticMergeConflictClass;
+  readonly risk: SemanticMergeConflictRisk;
+  readonly readiness: SemanticMergeReadiness;
+  readonly conflictKeys: readonly string[];
+  readonly symbolIds: readonly string[];
+  readonly regionKeys: readonly string[];
+  readonly evidenceIds: readonly string[];
+  readonly reasonCode: string;
+  readonly language?: FrontierSourceLanguage | string;
+  readonly sourcePath?: string;
+  readonly metadata?: Record<string, unknown>;
+}
+
+export interface SemanticMergeConflictSummary {
+  readonly schema: 'frontier.lang.semanticMergeConflictSummary.v1';
+  readonly total: number;
+  readonly classes: readonly SemanticMergeConflictClass[];
+  readonly byClass: Readonly<Record<string, number>>;
+  readonly byRisk: Readonly<Record<string, number>>;
+  readonly highestRisk: SemanticMergeConflictRisk;
+  readonly readiness: SemanticMergeReadiness;
+  readonly riskScore: number;
+  readonly conflictKeys: readonly string[];
+  readonly language?: FrontierSourceLanguage | string;
+  readonly sourcePath?: string;
+}
+
+export type SemanticMergeCandidateWithConflicts = SemanticMergeCandidateRecord & {
+  readonly conflictClasses?: readonly SemanticMergeConflictClassRecord[];
+  readonly conflictSummary?: SemanticMergeConflictSummary;
+  readonly metadata?: SemanticMergeCandidateRecord['metadata'] & {
+    readonly conflictClasses?: readonly SemanticMergeConflictClassRecord[];
+    readonly conflictSummary?: SemanticMergeConflictSummary;
+  };
+};
+
+export interface SemanticMergeConflictClassQueryOptions {
+  readonly class?: SemanticMergeConflictClass | string;
+  readonly classes?: readonly (SemanticMergeConflictClass | string)[];
+  readonly risk?: SemanticMergeConflictRisk | string;
+  readonly risks?: readonly (SemanticMergeConflictRisk | string)[];
+  readonly readiness?: SemanticMergeReadiness | string;
+  readonly readinesses?: readonly (SemanticMergeReadiness | string)[];
+  readonly conflictKey?: string;
+  readonly sort?: boolean;
+}
+
+export type QueriedSemanticMergeConflictClassRecord = SemanticMergeConflictClassRecord & {
+  readonly candidateId?: string;
+  readonly candidateReadiness?: SemanticMergeReadiness;
+  readonly candidateRiskScore: number;
+};
+
+export declare const SemanticMergeConflictClasses: readonly SemanticMergeConflictClass[];
+export declare function querySemanticMergeConflictClasses(candidates: SemanticMergeCandidateWithConflicts | readonly SemanticMergeCandidateWithConflicts[], options?: SemanticMergeConflictClassQueryOptions): readonly QueriedSemanticMergeConflictClassRecord[];
+export declare function semanticMergeConflictRiskScore(candidateOrSummary: SemanticMergeCandidateWithConflicts | SemanticMergeConflictSummary): number;
+export declare function sortSemanticMergeCandidatesByConflictRisk<T extends SemanticMergeCandidateWithConflicts>(candidates: readonly T[], options?: { readonly desc?: boolean }): readonly T[];
+export declare function summarizeSemanticMergeConflicts(conflictClasses?: readonly SemanticMergeConflictClassRecord[], context?: {
+  readonly readiness?: SemanticMergeReadiness;
+  readonly conflictKeys?: readonly string[];
+  readonly sourcePath?: string;
+  readonly language?: FrontierSourceLanguage | string;
+}): SemanticMergeConflictSummary;