@shapeshift-labs/frontier-lang-compiler 0.2.150 → 0.2.151

package/dist/declarations/js-ts-project-merge-admission-routes.d.ts

@@ -0,0 +1,35 @@
+export interface JsTsProjectSafeMergeAdmissionRoute {
+  readonly kind: 'frontier.lang.jsTsProjectMergeAdmissionRoute';
+  readonly version: 1;
+  readonly routeId: string;
+  readonly routeKind?: 'apply' | 'review' | 'rerun' | 'reject' | 'rebase' | 'block' | string;
+  readonly routeLane?: string;
+  readonly routeNext?: string;
+  readonly action?: string;
+  readonly status?: string;
+  readonly source?: string;
+  readonly subjectKind?: string;
+  readonly branch?: string;
+  readonly sourcePath?: string;
+  readonly sourcePaths?: readonly string[];
+  readonly proofLevel?: string;
+  readonly evidenceId?: string;
+  readonly conflictKey?: string;
+  readonly reasonCodes?: readonly string[];
+  readonly requiredEvidence?: readonly string[];
+  readonly presentEvidence?: readonly string[];
+  readonly missingEvidence?: readonly string[];
+  readonly details?: Record<string, unknown>;
+  readonly autoMergeClaim: false;
+  readonly semanticEquivalenceClaim: false;
+}
+
+export interface JsTsProjectSafeMergeAdmissionRouteSummary {
+  readonly total: number;
+  readonly byKind?: Readonly<Record<string, number>>;
+  readonly byAction?: Readonly<Record<string, number>>;
+  readonly byLane?: Readonly<Record<string, number>>;
+  readonly byStatus?: Readonly<Record<string, number>>;
+  readonly byRoute?: Readonly<Record<string, number>>;
+  readonly nextRoute?: JsTsProjectSafeMergeAdmissionRoute;
+}

package/dist/declarations/js-ts-project-merge-commonjs-interop.d.ts

@@ -0,0 +1,29 @@
+export interface JsTsProjectCommonJsRuntimeInteropProof {
+  readonly id?: string;
+  readonly kind?: 'frontier.lang.commonJsRuntimeInteropProof' | string;
+  readonly schema?: 'frontier.lang.commonJsRuntimeInteropProof.v1' | string;
+  readonly status: 'passed' | 'failed' | string;
+  readonly proofLevel?: 'commonjs-runtime-interop' | string;
+  readonly sourcePath: string;
+  readonly sourceHash: string;
+  readonly identityKey?: string;
+  readonly moduleSpecifier: string;
+  readonly importedName?: string;
+  readonly localName?: string;
+  readonly importKind?: string;
+  readonly commonJs?: boolean;
+  readonly interopHelper?: string;
+  readonly packageRuntimeCondition?: string;
+  readonly packageRuntimeConditionEdgeKind?: string;
+  readonly outputTargetSymbolId: string;
+  readonly workerTargetSymbolId?: string;
+  readonly exportAssignmentShapeHash?: string;
+  readonly runtimeTraceHash?: string;
+  readonly helperTraceHash?: string;
+  readonly evidenceHash: string;
+  readonly proofHash?: string;
+  readonly autoMergeClaim: false;
+  readonly semanticEquivalenceClaim: false;
+  readonly runtimeEquivalenceClaim: false;
+  readonly runtimeInteropEquivalenceClaim: false;
+}

package/dist/declarations/js-ts-project-merge-confidence.d.ts

@@ -0,0 +1,64 @@
+export type JsTsProjectSafeMergeRecommendedAction = 'apply' | 'review' | 'block' | string;
+
+export interface JsTsProjectSafeMergeMissingEvidenceRoute {
+  readonly id: string;
+  readonly lane: string;
+  readonly next: string;
+}
+
+export interface JsTsProjectSafeMergeMissingEvidenceTelemetry {
+  readonly total: number;
+  readonly byScope: Readonly<Record<string, number>>;
+  readonly byKind: Readonly<Record<string, number>>;
+  readonly byStatus: Readonly<Record<string, number>>;
+  readonly byAction: Readonly<Record<string, number>>;
+  readonly byRoute: Readonly<Record<string, number>>;
+  readonly byLane: Readonly<Record<string, number>>;
+}
+
+export interface JsTsProjectSafeMergeMissingEvidence {
+  readonly code: string;
+  readonly kind: string;
+  readonly scope: string;
+  readonly status: 'missing' | string;
+  readonly action: 'review' | string;
+  readonly proofLevel?: string;
+  readonly route?: JsTsProjectSafeMergeMissingEvidenceRoute;
+  readonly routeId?: string;
+  readonly routeLane?: string;
+  readonly routeNext?: string;
+  readonly relatedSignals?: readonly string[];
+  readonly summary?: string;
+  readonly suggestedInput?: Record<string, unknown>;
+  readonly autoMergeClaim: false;
+  readonly semanticEquivalenceClaim: false;
+}
+
+export interface JsTsProjectSafeMergeConfidenceSummary {
+  readonly kind: 'frontier.lang.jsTsProjectMergeConfidence';
+  readonly version: 1;
+  readonly schema: 'frontier.lang.jsTsProjectMergeConfidence.v1';
+  readonly id: string;
+  readonly score: number;
+  readonly level: string;
+  readonly higherIsBetter: true;
+  readonly reviewRequired: boolean;
+  readonly autoApplyCandidate: boolean;
+  readonly recommendedAction: JsTsProjectSafeMergeRecommendedAction;
+  readonly reviewRecommended: boolean;
+  readonly blockRecommended: boolean;
+  readonly autoApplyEvidenceComplete: boolean;
+  readonly autoMergeClaim: false;
+  readonly semanticEquivalenceClaim: boolean;
+  readonly evidenceIds: readonly string[];
+  readonly reasonCodes: readonly string[];
+  readonly conflictKeys: readonly string[];
+  readonly missingSignals: readonly string[];
+  readonly nextMissingSignal?: string;
+  readonly nextMissingEvidence?: JsTsProjectSafeMergeMissingEvidence;
+  readonly missingEvidence: readonly JsTsProjectSafeMergeMissingEvidence[];
+  readonly missingEvidenceMatrix: JsTsProjectSafeMergeMissingEvidenceTelemetry;
+  readonly routingCalibration: Record<string, unknown>;
+  readonly dimensions: Readonly<Record<string, string>>;
+  readonly signals: Readonly<Record<string, number>>;
+}

package/dist/declarations/js-ts-project-merge-declaration-emit-parity.d.ts

@@ -0,0 +1,37 @@
+export type JsTsProjectMergeDeclarationEmitParityProofStatus = 'passed' | 'failed' | string;
+export type JsTsProjectMergeDeclarationEmitParityProofLevel = 'typescript-checker-public-api-declaration-output-boundary' | string;
+
+export interface JsTsProjectMergeDeclarationBoundaryFile {
+  readonly sourcePath: string;
+  readonly sourceHash: string;
+  readonly bytes?: number;
+  readonly source?: string;
+}
+
+export interface JsTsProjectMergeDeclarationEmitParityProof {
+  readonly kind: 'typescript-checker-public-api-declaration-emit-parity';
+  readonly version: 1;
+  readonly schema: 'frontier.lang.typescriptDeclarationEmitParityProof.v1';
+  readonly id: string;
+  readonly hash: string;
+  readonly status: JsTsProjectMergeDeclarationEmitParityProofStatus;
+  readonly proofLevel: JsTsProjectMergeDeclarationEmitParityProofLevel;
+  readonly workerDeclarationBoundaryHash?: string;
+  readonly headDeclarationBoundaryHash?: string;
+  readonly outputDeclarationBoundaryHash?: string;
+  readonly declarationFileCount: number;
+  readonly declarationFiles: readonly JsTsProjectMergeDeclarationBoundaryFile[];
+  readonly compilerOptionsHash?: string;
+  readonly diagnosticsHash?: string;
+  readonly missingSignals: readonly string[];
+  readonly reasonCodes: readonly string[];
+  readonly autoMergeClaim: false;
+  readonly semanticEquivalenceClaim: false;
+}
+
+export declare function createJsTsProjectMergeDeclarationEmitParityProof(
+  input?: Record<string, unknown>,
+  files?: readonly { readonly sourcePath?: string; readonly language?: string; readonly baseSourceText?: string; readonly workerSourceText?: string; readonly headSourceText?: string; readonly workerDeleted?: boolean; readonly headDeleted?: boolean }[],
+  outputFiles?: readonly { readonly sourcePath?: string; readonly language?: string; readonly sourceText?: string; readonly sourceHash?: string }[],
+  id?: string
+): JsTsProjectMergeDeclarationEmitParityProof | undefined;

package/dist/declarations/js-ts-project-merge-declarations.d.ts

@@ -0,0 +1,65 @@
+import type { EvidenceRecord } from '@shapeshift-labs/frontier-lang-kernel';
+import type { JsTsSafeMergeConflict } from './js-ts-safe-merge.js';
+import type { JsTsProjectMergeDiagnostic } from './js-ts-project-merge-diagnostics.js';
+
+export type JsTsProjectMergeDeclarationGateStatus = 'passed' | 'blocked' | 'skipped' | string;
+
+export interface JsTsProjectMergeDeclarationFile {
+  readonly sourcePath: string;
+  readonly sourceText: string;
+  readonly sourceHash: string;
+  readonly source?: string;
+  readonly bytes?: number;
+}
+
+export type JsTsProjectMergeDeclarationFiles =
+  | Readonly<Record<string, string>>
+  | ReadonlyMap<string, string>
+  | readonly { readonly sourcePath?: string; readonly path?: string; readonly sourceText?: string; readonly text?: string; readonly source?: string }[];
+
+export interface JsTsProjectMergeDeclarationGateInput {
+  readonly includeDeclarationOutput?: boolean;
+  readonly requireDeclarationOutput?: boolean;
+  readonly outputDeclarations?: JsTsProjectMergeDeclarationFiles;
+  readonly outputDeclarationFiles?: JsTsProjectMergeDeclarationFiles;
+  readonly declarationOutDir?: string;
+  readonly declarationCompilerOptions?: Record<string, unknown>;
+  readonly typescriptDeclarationCompilerOptions?: Record<string, unknown>;
+}
+
+export interface JsTsProjectMergeDeclarationGate {
+  readonly kind: 'frontier.lang.jsTsProjectMergeDeclarationGate';
+  readonly version: 1;
+  readonly schema: 'frontier.lang.jsTsProjectMergeDeclarationGate.v1';
+  readonly id: string;
+  readonly hash: string;
+  readonly status: JsTsProjectMergeDeclarationGateStatus;
+  readonly sourcePaths: readonly string[];
+  readonly declarationFiles: readonly JsTsProjectMergeDeclarationFile[];
+  readonly diagnostics: readonly JsTsProjectMergeDiagnostic[];
+  readonly conflicts: readonly JsTsSafeMergeConflict[];
+  readonly admission: {
+    readonly status: 'auto-merge-candidate' | 'blocked' | 'skipped' | string;
+    readonly action: 'accept-declarations' | 'human-review' | 'skip-declarations' | string;
+    readonly reviewRequired: boolean;
+    readonly autoApplyCandidate: boolean;
+    readonly autoMergeClaim: false;
+    readonly semanticEquivalenceClaim: false;
+    readonly reasonCodes: readonly string[];
+  };
+  readonly summary: {
+    readonly declarationFiles: number;
+    readonly declarationBytes: number;
+    readonly diagnostics: number;
+    readonly conflicts: number;
+    readonly errors: number;
+    readonly warnings: number;
+  };
+  readonly evidence: readonly EvidenceRecord[];
+}
+
+export declare function createJsTsProjectMergeDeclarationGate(
+  input?: JsTsProjectMergeDeclarationGateInput & Record<string, unknown>,
+  outputFiles?: readonly { readonly sourcePath?: string; readonly sourceText?: string; readonly sourceHash?: string }[],
+  id?: string
+): JsTsProjectMergeDeclarationGate | undefined;

package/dist/declarations/js-ts-project-merge-diagnostics.d.ts

@@ -0,0 +1,97 @@
+import type { EvidenceRecord, FrontierSourceLanguage } from '@shapeshift-labs/frontier-lang-kernel';
+import type { JsTsSafeMergeConflict } from './js-ts-safe-merge.js';
+
+export type JsTsProjectMergeDiagnosticsGateStatus = 'passed' | 'blocked' | string;
+export type JsTsProjectMergeDiagnosticSeverity = 'error' | 'warning' | 'suggestion' | 'message' | string;
+export type JsTsProjectMergeDiagnosticPhase = 'syntax' | 'semantic' | string;
+
+export interface JsTsProjectMergeDiagnostic {
+  readonly id?: string;
+  readonly source?: string;
+  readonly code: string;
+  readonly severity: JsTsProjectMergeDiagnosticSeverity;
+  readonly message: string;
+  readonly sourcePath?: string;
+  readonly phase?: JsTsProjectMergeDiagnosticPhase;
+  readonly syntax?: boolean;
+  readonly start?: number;
+  readonly end?: number;
+  readonly line?: number;
+  readonly column?: number;
+}
+
+export interface JsTsProjectMergeOutputFileForDiagnostics {
+  readonly sourcePath?: string;
+  readonly language?: FrontierSourceLanguage | string;
+  readonly sourceText?: string;
+  readonly sourceHash?: string;
+  readonly operation?: string;
+}
+
+export interface JsTsProjectMergeDiagnosticsGateInput {
+  readonly id?: string;
+  readonly projectRoot?: string;
+  readonly typescript?: unknown;
+  readonly ts?: unknown;
+  readonly typescriptModule?: unknown;
+  readonly compilerOptions?: Record<string, unknown>;
+  readonly typescriptCompilerOptions?: Record<string, unknown>;
+  readonly diagnosticOptions?: {
+    readonly syntactic?: boolean;
+    readonly semantic?: boolean;
+  };
+  readonly typescriptDiagnosticOptions?: {
+    readonly syntactic?: boolean;
+    readonly semantic?: boolean;
+  };
+  readonly requireOutputDiagnostics?: boolean;
+  readonly requireOutputSyntaxDiagnostics?: boolean;
+  readonly requireOutputSyntaxGate?: boolean;
+  readonly requireMergedOutputSyntaxDiagnostics?: boolean;
+  readonly requireSyntaxGate?: boolean;
+  readonly outputDiagnostics?: readonly JsTsProjectMergeDiagnostic[] | JsTsProjectMergeDiagnostic;
+  readonly outputSyntaxDiagnostics?: readonly JsTsProjectMergeDiagnostic[] | JsTsProjectMergeDiagnostic;
+  readonly mergedOutputSyntaxDiagnostics?: readonly JsTsProjectMergeDiagnostic[] | JsTsProjectMergeDiagnostic;
+  readonly syntaxDiagnostics?: {
+    readonly output?: readonly JsTsProjectMergeDiagnostic[] | JsTsProjectMergeDiagnostic;
+    readonly merged?: readonly JsTsProjectMergeDiagnostic[] | JsTsProjectMergeDiagnostic;
+  };
+}
+
+export interface JsTsProjectMergeDiagnosticsGate {
+  readonly kind: 'frontier.lang.jsTsProjectMergeDiagnosticsGate';
+  readonly version: 1;
+  readonly schema: 'frontier.lang.jsTsProjectMergeDiagnosticsGate.v1';
+  readonly id: string;
+  readonly hash: string;
+  readonly status: JsTsProjectMergeDiagnosticsGateStatus;
+  readonly sourcePaths: readonly string[];
+  readonly diagnostics: readonly JsTsProjectMergeDiagnostic[];
+  readonly conflicts: readonly JsTsSafeMergeConflict[];
+  readonly admission: {
+    readonly status: 'auto-merge-candidate' | 'blocked' | string;
+    readonly action: 'accept-diagnostics' | 'human-review' | string;
+    readonly reviewRequired: boolean;
+    readonly autoApplyCandidate: boolean;
+    readonly autoMergeClaim: false;
+    readonly semanticEquivalenceClaim: false;
+    readonly reasonCodes: readonly string[];
+  };
+  readonly summary: {
+    readonly diagnostics: number;
+    readonly conflicts: number;
+    readonly errors: number;
+    readonly warnings: number;
+    readonly syntaxErrors: number;
+    readonly bySeverity: Readonly<Record<string, number>>;
+    readonly bySource: Readonly<Record<string, number>>;
+    readonly byPhase: Readonly<Record<string, number>>;
+  };
+  readonly evidence: readonly EvidenceRecord[];
+}
+
+export declare function createJsTsProjectMergeDiagnosticsGate(
+  input?: JsTsProjectMergeDiagnosticsGateInput,
+  outputFiles?: readonly JsTsProjectMergeOutputFileForDiagnostics[],
+  id?: string
+): JsTsProjectMergeDiagnosticsGate | undefined;

package/dist/declarations/js-ts-project-merge-global-augmentation.d.ts

@@ -0,0 +1,30 @@
+export interface JsTsProjectGlobalAugmentationCompatibilityProof {
+  readonly id?: string;
+  readonly kind?: 'frontier.lang.globalAugmentationCompatibilityProof' | string;
+  readonly schema?: 'frontier.lang.globalAugmentationCompatibilityProof.v1' | string;
+  readonly version?: 1;
+  readonly status: 'passed' | 'failed' | 'missing' | 'stale' | string;
+  readonly surfaceKind: 'global-augmentation' | string;
+  readonly sourcePath: string;
+  readonly sourceHash?: string;
+  readonly sourceHashes?: readonly string[];
+  readonly moduleName: 'global' | string;
+  readonly moduleDeclarationRecordId?: string;
+  readonly moduleDeclarationShapeHash?: string;
+  readonly moduleDeclarationSignatureHash?: string;
+  readonly sourceSpanHash?: string;
+  readonly declarationOutputGateId: string;
+  readonly declarationOutputHash: string;
+  readonly declarationEmitParityProofId?: string;
+  readonly consumerDiagnosticsGateId: string;
+  readonly consumerDiagnosticsHash: string;
+  readonly consumerEntrypoints: readonly string[];
+  readonly consumerDiagnosticsPassed: true;
+  readonly proofHash?: string;
+  readonly evidenceIds?: readonly string[];
+  readonly globalCompatibilityClaim: 'declaration-boundary-consumer-diagnostics-only';
+  readonly hostRuntimeInteractionClaim: false;
+  readonly autoMergeClaim: false;
+  readonly runtimeEquivalenceClaim: false;
+  readonly semanticEquivalenceClaim: false;
+}

package/dist/declarations/js-ts-project-merge-jsx-render-branch.d.ts

@@ -0,0 +1,48 @@
+export type JsTsProjectJsxRenderReturnBranchControlKind = 'conditional-expression' | 'logical-expression' | string;
+export type JsTsProjectJsxRenderReturnBranchArmOrigin = 'base' | 'worker' | 'head' | 'output' | string;
+
+export interface JsTsProjectJsxRenderReturnBranchProof {
+  readonly id?: string;
+  readonly kind?: 'frontier.lang.jsxRenderReturnBranchProof' | string;
+  readonly schema?: 'frontier.lang.jsxRenderReturnBranchProof.v1' | string;
+  readonly version?: 1;
+  readonly status: 'passed' | 'verified' | 'failed' | 'missing' | 'stale' | string;
+  readonly evidenceId?: string;
+  readonly evidenceIds?: readonly string[];
+  readonly sourcePath: string;
+  readonly identityKey?: string;
+  readonly baseSourceHash: string;
+  readonly workerSourceHash: string;
+  readonly headSourceHash: string;
+  readonly outputSourceHash: string;
+  readonly publicOwnerName?: string;
+  readonly tagName?: string;
+  readonly tagKey?: string;
+  readonly returnOrdinal?: number;
+  readonly returnKind?: string;
+  readonly branchControlKind: JsTsProjectJsxRenderReturnBranchControlKind;
+  readonly conditionHash?: string;
+  readonly outputConditionHash?: string;
+  readonly consequentHash?: string;
+  readonly outputConsequentHash?: string;
+  readonly consequentOrigin?: JsTsProjectJsxRenderReturnBranchArmOrigin;
+  readonly alternateHash?: string;
+  readonly outputAlternateHash?: string;
+  readonly alternateOrigin?: JsTsProjectJsxRenderReturnBranchArmOrigin;
+  readonly operator?: string;
+  readonly leftHash?: string;
+  readonly outputLeftHash?: string;
+  readonly leftOrigin?: JsTsProjectJsxRenderReturnBranchArmOrigin;
+  readonly rightHash?: string;
+  readonly outputRightHash?: string;
+  readonly rightOrigin?: JsTsProjectJsxRenderReturnBranchArmOrigin;
+  readonly renderReturnSignatureHash?: string;
+  readonly branchArmPreservationHash: string;
+  readonly proofHash?: string;
+  readonly autoMergeClaim: false;
+  readonly semanticEquivalenceClaim: false;
+  readonly runtimeEquivalenceClaim: false;
+  readonly renderEquivalenceClaim: false;
+  readonly branchArmPreservationClaim: true;
+  readonly claimScope: 'static-render-return-branch-arm-preservation-only';
+}

package/dist/declarations/js-ts-project-merge-proof-levels.d.ts

@@ -0,0 +1,109 @@
+export type JsTsProjectMergeProofLevel =
+  | 'syntax-identity'
+  | 'source-span-roundtrip'
+  | 'semantic-edit-replay-clean'
+  | 'parser-roundtrip'
+  | 'diagnostics-clean'
+  | 'declaration-output-stable'
+  | 'focused-test-passed'
+  | 'manifest-metadata-validated'
+  | 'local-checkout-metadata-proof'
+  | 'dependency-install-not-run-default'
+  | 'repository-commands-not-run-default'
+  | 'semantic-equivalence-external'
+  | 'semantic-equivalence-unknown'
+  | string;
+
+export type JsTsProjectMergeProofEvidenceStatus = 'evidence-only' | 'review-evidence-missing' | 'failed-evidence' | string;
+export type JsTsProjectMergeProofEvidenceRecordStatus = 'passed' | 'failed' | 'skipped' | 'unknown' | string;
+
+export interface JsTsProjectMergeProofMissingEvidence {
+  readonly code?: string;
+  readonly kind: 'proof-level' | string;
+  readonly scope?: string;
+  readonly status: 'missing' | 'unknown' | string;
+  readonly proofLevel?: JsTsProjectMergeProofLevel;
+  readonly action: 'review' | string;
+  readonly route?: { readonly id: string; readonly lane: string; readonly next: string };
+  readonly routeId?: string;
+  readonly routeLane?: string;
+  readonly routeNext?: string;
+  readonly evidenceId?: string;
+  readonly summary?: string;
+  readonly nextAction?: string;
+  readonly autoMergeClaim: false;
+  readonly semanticEquivalenceClaim: false;
+}
+
+export interface JsTsProjectMergeProofEvidenceRecord {
+  readonly id: string;
+  readonly kind: 'js-ts-project-merge-proof-evidence';
+  readonly level: JsTsProjectMergeProofLevel;
+  readonly status: JsTsProjectMergeProofEvidenceRecordStatus;
+  readonly scope: string;
+  readonly claimKind: 'evidence' | 'semantic-equivalence-upper-bound' | string;
+  readonly evidenceOnly: boolean;
+  readonly proofClaim: boolean;
+  readonly autoMergeClaim: false;
+  readonly semanticEquivalenceClaim: boolean;
+  readonly summary: string;
+  readonly metadata?: Record<string, unknown> & {
+    readonly proofClaim?: boolean;
+    readonly autoMergeClaim?: false;
+    readonly semanticEquivalenceClaim?: boolean;
+    readonly missingSignal?: string;
+    readonly nextAction?: string;
+  };
+}
+
+export interface JsTsProjectMergeProofEvidenceSummary {
+  readonly records: number;
+  readonly passed: number;
+  readonly failed: number;
+  readonly skipped: number;
+  readonly unknown: number;
+  readonly evidenceLevels: readonly JsTsProjectMergeProofLevel[];
+  readonly passedLevels: readonly JsTsProjectMergeProofLevel[];
+  readonly failedLevels: readonly JsTsProjectMergeProofLevel[];
+  readonly skippedLevels: readonly JsTsProjectMergeProofLevel[];
+  readonly unknownLevels: readonly JsTsProjectMergeProofLevel[];
+  readonly missingLevels: readonly JsTsProjectMergeProofLevel[];
+  readonly unsupportedSurfaceEvidenceCount?: number;
+  readonly unsupportedSurfaceKinds?: readonly string[];
+  readonly unsupportedSurfaceReasonCodes?: readonly string[];
+  readonly unsupportedSurfaceProofGapRouteIds?: readonly string[];
+  readonly unsupportedSurfaceProofGapRouteLanes?: readonly string[];
+  readonly unsupportedSurfaceProofGapRouteCounts?: Readonly<Record<string, number>>;
+  readonly unsupportedSurfaceProofGapRouteLaneCounts?: Readonly<Record<string, number>>;
+  readonly nextUnsupportedSurfaceProofGapRouteId?: string;
+  readonly nextUnsupportedSurfaceProofGapRouteLane?: string;
+  readonly nextUnsupportedSurfaceProofGapCode?: string;
+  readonly missingEvidence: readonly JsTsProjectMergeProofMissingEvidence[];
+  readonly nextMissingEvidence?: JsTsProjectMergeProofMissingEvidence;
+  readonly semanticEquivalenceLevel: 'semantic-equivalence-unknown' | string;
+  readonly semanticEquivalenceClaim: boolean;
+  readonly evidenceOnly: true;
+  readonly proofClaims: number;
+}
+
+export interface JsTsProjectMergeProofEvidence {
+  readonly kind: 'frontier.lang.jsTsProjectMergeProofEvidence';
+  readonly version: 1;
+  readonly schema: 'frontier.lang.jsTsProjectMergeProofEvidence.v1';
+  readonly id: string;
+  readonly hash: string;
+  readonly status: JsTsProjectMergeProofEvidenceStatus;
+  readonly semanticEquivalenceLevel: 'semantic-equivalence-unknown' | string;
+  readonly autoMergeClaim: false;
+  readonly semanticEquivalenceClaim: boolean;
+  readonly records: readonly JsTsProjectMergeProofEvidenceRecord[];
+  readonly summary: JsTsProjectMergeProofEvidenceSummary;
+  readonly metadata?: Record<string, unknown> & {
+    readonly evidenceOnly?: true;
+    readonly proofClaims?: number;
+    readonly missingLevels?: readonly JsTsProjectMergeProofLevel[];
+    readonly nextMissingEvidence?: JsTsProjectMergeProofMissingEvidence;
+    readonly autoMergeClaim?: false;
+    readonly semanticEquivalenceClaim?: boolean;
+  };
+}

package/dist/declarations/js-ts-project-merge-quality-gates.d.ts

@@ -0,0 +1,38 @@
+import type { JsTsSafeMergeConflict } from './js-ts-safe-merge.js';
+export type JsTsProjectMergeQualityGateCategory = 'lint' | 'format' | 'test' | 'build' | string;
+export interface JsTsProjectMergeQualityGateInput {
+  readonly id?: string; readonly gateId?: string; readonly category?: JsTsProjectMergeQualityGateCategory;
+  readonly status?: string; readonly result?: string; readonly command?: string; readonly artifactPath?: string; readonly path?: string;
+  readonly evidenceId?: string; readonly summary?: string | Record<string, unknown>; readonly reasonCode?: string;
+}
+export interface JsTsProjectMergeQualityGateRecord {
+  readonly id: string; readonly category: JsTsProjectMergeQualityGateCategory; readonly status: string; readonly command?: string;
+  readonly artifactPath?: string; readonly evidenceId?: string; readonly summary?: string | Record<string, unknown>; readonly reasonCode?: string;
+}
+export interface JsTsProjectMergeQualityGateEvidence {
+  readonly id: string; readonly kind: string; readonly status: 'passed' | 'failed' | string; readonly summary: string;
+  readonly metadata?: Record<string, unknown> & {
+    readonly gateId?: string; readonly category?: JsTsProjectMergeQualityGateCategory; readonly command?: string; readonly artifactPath?: string;
+    readonly admissionAction?: 'apply' | 'block' | string; readonly nextMissingEvidence?: JsTsProjectMergeQualityGateMissingEvidence;
+    readonly autoMergeClaim?: false; readonly semanticEquivalenceClaim?: false;
+  };
+}
+export interface JsTsProjectMergeQualityGateMissingEvidence {
+  readonly code?: string; readonly kind: 'quality-gate' | string; readonly scope: 'quality-gates' | string;
+  readonly status: 'missing-or-failed' | string; readonly action: 'rerun-gate' | string;
+  readonly gateId?: string; readonly category?: JsTsProjectMergeQualityGateCategory; readonly command?: string; readonly artifactPath?: string;
+  readonly summary?: string; readonly autoMergeClaim: false; readonly semanticEquivalenceClaim: false;
+}
+export interface JsTsProjectMergeQualityGateDecision {
+  readonly status: 'passed' | 'blocked' | string; readonly action: 'apply' | 'block' | string;
+  readonly reviewRequired: boolean; readonly autoApplyCandidate: boolean; readonly reasonCodes: readonly string[];
+  readonly nextMissingEvidence?: JsTsProjectMergeQualityGateMissingEvidence;
+  readonly autoMergeClaim: false; readonly semanticEquivalenceClaim: false;
+}
+export interface JsTsProjectMergeQualityGate {
+  readonly kind: 'frontier.lang.jsTsProjectMergeQualityGate'; readonly version: 1; readonly id: string; readonly status: 'passed' | 'blocked';
+  readonly gates: readonly JsTsProjectMergeQualityGateRecord[]; readonly conflicts: readonly JsTsSafeMergeConflict[];
+  readonly evidence: readonly JsTsProjectMergeQualityGateEvidence[];
+  readonly decision: JsTsProjectMergeQualityGateDecision;
+  readonly summary: { readonly gates: number; readonly passed: number; readonly failed: number; readonly lint: number; readonly format: number; readonly test: number; readonly build: number; };
+}

package/dist/declarations/js-ts-project-merge-semantic-equivalence-proof.d.ts

@@ -0,0 +1,45 @@
+export type JsTsProjectSemanticEquivalenceProofClaimBoundary = 'exact-js-ts-project-source-output-and-gates';
+export type JsTsProjectSemanticEquivalenceProofLevel = 'semantic-equivalence-external';
+
+export interface JsTsProjectSemanticEquivalenceProofFileBinding {
+  readonly sourcePath: string;
+  readonly operation?: string;
+  readonly baseHash?: string;
+  readonly workerHash?: string;
+  readonly headHash?: string;
+  readonly outputHash?: string;
+  readonly deletedOutput?: boolean;
+}
+
+export interface JsTsProjectSemanticEquivalenceProofGateBinding {
+  readonly id: string;
+  readonly status: 'passed' | string;
+  readonly hash: string;
+  readonly gateIds?: readonly string[];
+}
+
+export interface JsTsProjectSemanticEquivalenceProof {
+  readonly id?: string;
+  readonly kind?: 'frontier.lang.jsTsProjectSemanticEquivalenceProof' | string;
+  readonly schema?: 'frontier.lang.jsTsProjectSemanticEquivalenceProof.v1' | string;
+  readonly status: 'passed' | 'verified' | 'failed' | string;
+  readonly evidenceId?: string;
+  readonly verifier?: { readonly name?: string; readonly version?: string; readonly [key: string]: unknown };
+  readonly command?: string;
+  readonly artifactHash?: string;
+  readonly projectId: string;
+  readonly language?: string;
+  readonly sourceFileBindings: readonly JsTsProjectSemanticEquivalenceProofFileBinding[];
+  readonly sourceSetHash: string;
+  readonly outputSetHash: string;
+  readonly gates: {
+    readonly diagnostics: JsTsProjectSemanticEquivalenceProofGateBinding;
+    readonly declarations: JsTsProjectSemanticEquivalenceProofGateBinding;
+    readonly quality: JsTsProjectSemanticEquivalenceProofGateBinding;
+  };
+  readonly proofHash: string;
+  readonly claimKind: 'external-semantic-equivalence';
+  readonly claimBoundary: JsTsProjectSemanticEquivalenceProofClaimBoundary;
+  readonly semanticEquivalenceClaim: true;
+  readonly autoMergeClaim: false;
+}

package/dist/declarations/js-ts-project-merge-tsconfig.d.ts

@@ -0,0 +1,43 @@
+export interface JsTsProjectReferenceInput {
+  readonly path?: string;
+  readonly originalPath?: string;
+  readonly sourcePath?: string;
+  readonly prepend?: boolean;
+  readonly circular?: boolean;
+}
+
+export type JsTsProjectReferencesInput = readonly (string | JsTsProjectReferenceInput)[];
+
+export interface JsTsProjectTsconfigInput {
+  readonly compilerOptions?: Record<string, unknown>;
+  readonly references?: JsTsProjectReferencesInput;
+  readonly [key: string]: unknown;
+}
+
+export type JsTsProjectCompilerOptionMetadata = Readonly<Record<string, unknown>>;
+
+export interface JsTsProjectCompilerOptionSourceMetadata {
+  readonly source: string;
+  readonly compilerOptions?: JsTsProjectCompilerOptionMetadata;
+}
+
+export interface JsTsProjectReferenceMetadata {
+  readonly path: string;
+  readonly originalPath?: string;
+  readonly prepend?: boolean;
+  readonly circular?: boolean;
+}
+
+export interface JsTsProjectCompilerMetadata {
+  readonly diagnosticSource?: string;
+  readonly compilerOptions?: JsTsProjectCompilerOptionMetadata;
+  readonly compilerOptionSources?: readonly JsTsProjectCompilerOptionSourceMetadata[];
+  readonly projectReferences?: readonly JsTsProjectReferenceMetadata[];
+  readonly projectReferenceCount?: number;
+  readonly tsconfigCompilerOptions?: JsTsProjectCompilerOptionMetadata;
+  readonly tsconfigReferences?: readonly JsTsProjectReferenceMetadata[];
+  readonly hasTypescriptCompilerApi?: boolean;
+  readonly hasOptionsOverride?: boolean;
+  readonly rootNames?: readonly string[];
+  readonly sourceFiles?: number;
+}