@shapeshift-labs/frontier-lang-compiler 0.2.66 → 0.2.68

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

@@ -0,0 +1,277 @@
+import type {
+  EvidenceRecord,
+  FrontierSourceLanguage,
+  SemanticMergeReadiness,
+  SourceSpan
+} from '@shapeshift-labs/frontier-lang-kernel';
+
+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' | 'semantic-claim' | 'claim-hash' | 'evidence' | 'proof' | 'replay' | 'patch' | 'merge-decision' | 'actor' | 'record-source' | '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 type SemanticHistoryClaimKind = 'fact' | 'theory' | 'invariant' | 'semantic-claim' | string;
+export type SemanticHistoryClaimStatus = 'accepted' | 'rejected' | 'proposed' | 'superseded' | string;
+export type SemanticHistoryProofAttemptStatus = 'passed' | 'failed' | 'unknown' | 'blocked' | string;
+export type SemanticHistoryMergeDecisionStatus = 'accepted' | 'rejected' | 'admitted' | 'blocked' | 'needs-review' | string;
+
+export interface SemanticHistoryActorRef {
+  readonly id?: string;
+  readonly kind?: string;
+  readonly role?: string;
+  readonly displayName?: string;
+  readonly runId?: string;
+  readonly lane?: string;
+  readonly taskId?: string;
+  readonly metadata?: Record<string, unknown>;
+}
+
+export interface SemanticHistoryRecordSourceRef {
+  readonly id?: string;
+  readonly sourceId?: string;
+  readonly sourceKind?: string;
+  readonly sourcePath?: string;
+  readonly sourceHash?: string;
+  readonly href?: string;
+  readonly importId?: string;
+  readonly runId?: string;
+  readonly jobId?: string;
+  readonly lane?: string;
+  readonly taskId?: string;
+  readonly metadata?: Record<string, unknown>;
+}
+
+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 SemanticHistoryClaimRecord {
+  readonly kind: 'frontier.lang.semanticHistoryClaim';
+  readonly version: 1;
+  readonly id: string;
+  readonly hash: string;
+  readonly claimKind?: SemanticHistoryClaimKind;
+  readonly status?: SemanticHistoryClaimStatus;
+  readonly subject?: string;
+  readonly predicate?: string;
+  readonly object?: unknown;
+  readonly text?: string;
+  readonly language?: FrontierSourceLanguage | string;
+  readonly sourcePath?: string;
+  readonly sourceHash?: string;
+  readonly baseHash?: string;
+  readonly targetHash?: string;
+  readonly conflictKeys?: readonly string[];
+  readonly evidenceIds?: readonly string[];
+  readonly proofIds?: readonly string[];
+  readonly replayIds?: readonly string[];
+  readonly actor?: SemanticHistoryActorRef;
+  readonly recordSource?: SemanticHistoryRecordSourceRef;
+  readonly metadata?: Record<string, unknown>;
+}
+
+export interface SemanticHistoryImportedParserEvidenceRecord {
+  readonly kind: 'frontier.lang.semanticHistoryImportedParserEvidence';
+  readonly version: 1;
+  readonly id: string;
+  readonly hash: string;
+  readonly evidenceId?: string;
+  readonly importId?: string;
+  readonly parserId?: string;
+  readonly parserKind?: string;
+  readonly language?: FrontierSourceLanguage | string;
+  readonly sourcePath?: string;
+  readonly sourceHash?: string;
+  readonly astHash?: string;
+  readonly semanticIndexHash?: string;
+  readonly status?: EvidenceRecord['status'] | string;
+  readonly evidenceIds?: readonly string[];
+  readonly replayIds?: readonly string[];
+  readonly actor?: SemanticHistoryActorRef;
+  readonly recordSource?: SemanticHistoryRecordSourceRef;
+  readonly metadata?: Record<string, unknown>;
+}
+
+export interface SemanticHistoryProofAttemptRecord {
+  readonly kind: 'frontier.lang.semanticHistoryProofAttempt';
+  readonly version: 1;
+  readonly id: string;
+  readonly hash: string;
+  readonly proofId?: string;
+  readonly proofKind?: string;
+  readonly status?: SemanticHistoryProofAttemptStatus;
+  readonly proverId?: string;
+  readonly claimIds?: readonly string[];
+  readonly evidenceIds?: readonly string[];
+  readonly proofIds?: readonly string[];
+  readonly replayIds?: readonly string[];
+  readonly command?: string;
+  readonly resultHash?: string;
+  readonly actor?: SemanticHistoryActorRef;
+  readonly recordSource?: SemanticHistoryRecordSourceRef;
+  readonly metadata?: Record<string, unknown>;
+}
+
+export interface SemanticHistoryPatchAncestryRecord {
+  readonly kind: 'frontier.lang.semanticHistoryPatchAncestry';
+  readonly version: 1;
+  readonly id: string;
+  readonly hash: string;
+  readonly patchId?: string;
+  readonly parentPatchIds?: readonly string[];
+  readonly ancestorPatchIds?: readonly string[];
+  readonly baseHash?: string;
+  readonly targetHash?: string;
+  readonly parentHashes?: readonly string[];
+  readonly ancestorHashes?: readonly string[];
+  readonly conflictKeys?: readonly string[];
+  readonly actor?: SemanticHistoryActorRef;
+  readonly recordSource?: SemanticHistoryRecordSourceRef;
+  readonly metadata?: Record<string, unknown>;
+}
+
+export interface SemanticHistoryMergeDecisionRecord {
+  readonly kind: 'frontier.lang.semanticHistoryMergeDecision';
+  readonly version: 1;
+  readonly id: string;
+  readonly hash: string;
+  readonly decision?: SemanticHistoryMergeDecisionStatus;
+  readonly status?: SemanticHistoryMergeDecisionStatus;
+  readonly decidedAt?: number | string;
+  readonly claimIds?: readonly string[];
+  readonly acceptedClaimIds?: readonly string[];
+  readonly rejectedClaimIds?: readonly string[];
+  readonly patchIds?: readonly string[];
+  readonly conflictKeys?: readonly string[];
+  readonly evidenceIds?: readonly string[];
+  readonly proofIds?: readonly string[];
+  readonly reasonCodes?: readonly string[];
+  readonly actor?: SemanticHistoryActorRef;
+  readonly recordSource?: SemanticHistoryRecordSourceRef;
+  readonly metadata?: Record<string, unknown>;
+}
+
+export type SemanticHistoryClaimInput = string | (Partial<SemanticHistoryClaimRecord> & {
+  readonly relation?: string;
+  readonly value?: unknown;
+  readonly expected?: unknown;
+  readonly key?: string;
+  readonly conflictKey?: string;
+  readonly accepted?: boolean;
+  readonly rejected?: boolean;
+  readonly semanticNodeId?: string;
+  readonly symbolId?: string;
+});
+
+export type SemanticHistoryImportedParserEvidenceInput = string | EvidenceRecord | (Partial<SemanticHistoryImportedParserEvidenceRecord> & {
+  readonly parser?: string;
+  readonly adapterId?: string;
+  readonly nativeAstHash?: string;
+});
+
+export type SemanticHistoryProofAttemptInput = string | EvidenceRecord | (Partial<SemanticHistoryProofAttemptRecord> & {
+  readonly prover?: string;
+  readonly proofHash?: string;
+});
+
+export type SemanticHistoryPatchAncestryInput = string | (Partial<SemanticHistoryPatchAncestryRecord> & {
+  readonly parents?: readonly string[] | string;
+  readonly ancestors?: readonly string[] | string;
+});
+
+export type SemanticHistoryMergeDecisionInput = string | Partial<SemanticHistoryMergeDecisionRecord>;
+
+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 actorIds: readonly string[];
+  readonly recordSourceIds: readonly string[];
+  readonly ownershipKeys: readonly string[];
+  readonly semanticCandidateIds: readonly string[];
+  readonly semanticClaimIds: readonly string[];
+  readonly semanticClaimHashes: readonly string[];
+  readonly acceptedFactIds: readonly string[];
+  readonly rejectedTheoryIds: readonly string[];
+  readonly conflictKeys: readonly string[];
+  readonly evidenceIds: readonly string[];
+  readonly importedParserEvidenceIds: readonly string[];
+  readonly importedParserEvidenceHashes: readonly string[];
+  readonly proofIds: readonly string[];
+  readonly proofAttemptIds: readonly string[];
+  readonly proofAttemptHashes: readonly string[];
+  readonly replayIds: readonly string[];
+  readonly patchIds: readonly string[];
+  readonly patchHashes: readonly string[];
+  readonly mergeDecisionIds: readonly string[];
+  readonly mergeDecisionHashes: readonly string[];
+}

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

@@ -7,111 +7,32 @@ import type {
 } 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[];
-}
-
+import type { SemanticHistoryAdmissionStatus, SemanticHistoryReviewerStatus, SemanticHistoryReplayLinkKind, SemanticHistoryOverlapKind, SemanticHistoryConflictReason, SemanticHistoryClaimKind, SemanticHistoryClaimStatus, SemanticHistoryProofAttemptStatus, SemanticHistoryMergeDecisionStatus, SemanticHistoryActorRef, SemanticHistoryRecordSourceRef, SemanticHistorySourceRef, SemanticHistoryOwnershipRegionRef, SemanticHistoryCandidateRef, SemanticHistoryClaimRecord, SemanticHistoryImportedParserEvidenceRecord, SemanticHistoryProofAttemptRecord, SemanticHistoryPatchAncestryRecord, SemanticHistoryMergeDecisionRecord, SemanticHistoryClaimInput, SemanticHistoryImportedParserEvidenceInput, SemanticHistoryProofAttemptInput, SemanticHistoryPatchAncestryInput, SemanticHistoryMergeDecisionInput, SemanticHistoryReviewerState, SemanticHistoryAdmissionState, SemanticHistoryReplayLink, SemanticHistoryRecordIndex } from './semantic-history-records.js';
+export type { SemanticHistoryAdmissionStatus, SemanticHistoryReviewerStatus, SemanticHistoryReplayLinkKind, SemanticHistoryOverlapKind, SemanticHistoryConflictReason, SemanticHistoryClaimKind, SemanticHistoryClaimStatus, SemanticHistoryProofAttemptStatus, SemanticHistoryMergeDecisionStatus, SemanticHistoryActorRef, SemanticHistoryRecordSourceRef, SemanticHistorySourceRef, SemanticHistoryOwnershipRegionRef, SemanticHistoryCandidateRef, SemanticHistoryClaimRecord, SemanticHistoryImportedParserEvidenceRecord, SemanticHistoryProofAttemptRecord, SemanticHistoryPatchAncestryRecord, SemanticHistoryMergeDecisionRecord, SemanticHistoryClaimInput, SemanticHistoryImportedParserEvidenceInput, SemanticHistoryProofAttemptInput, SemanticHistoryPatchAncestryInput, SemanticHistoryMergeDecisionInput, SemanticHistoryReviewerState, SemanticHistoryAdmissionState, SemanticHistoryReplayLink, SemanticHistoryRecordIndex } from './semantic-history-records.js';
 export interface SemanticHistoryRecord {
   readonly kind: 'frontier.lang.semanticHistoryRecord';
   readonly version: 1;
   readonly id: string;
+  readonly stableId: string;
+  readonly hash: string;
   readonly createdAt: number | string;
   readonly baseHash?: string;
   readonly targetHash?: string;
   readonly language?: FrontierSourceLanguage | string;
   readonly sourcePath?: string;
+  readonly actor?: SemanticHistoryActorRef;
+  readonly recordSource?: SemanticHistoryRecordSourceRef;
   readonly sourceIds: readonly string[];
   readonly importIds: readonly string[];
   readonly sources: readonly SemanticHistorySourceRef[];
   readonly ownershipRegions: readonly SemanticHistoryOwnershipRegionRef[];
   readonly semanticCandidates: readonly SemanticHistoryCandidateRef[];
+  readonly acceptedFacts: readonly SemanticHistoryClaimRecord[];
+  readonly rejectedTheories: readonly SemanticHistoryClaimRecord[];
+  readonly importedParserEvidence: readonly SemanticHistoryImportedParserEvidenceRecord[];
+  readonly proofAttempts: readonly SemanticHistoryProofAttemptRecord[];
+  readonly patchAncestry: readonly SemanticHistoryPatchAncestryRecord[];
+  readonly mergeDecisions: readonly SemanticHistoryMergeDecisionRecord[];
   readonly evidenceIds: readonly string[];
   readonly proofIds: readonly string[];
   readonly reviewer: SemanticHistoryReviewerState;
@@ -124,6 +45,18 @@ export interface SemanticHistoryRecord {
 export interface CreateSemanticHistoryRecordInput {
   readonly id?: string;
   readonly createdAt?: number | string;
+  readonly actor?: SemanticHistoryActorRef | string;
+  readonly actorId?: string;
+  readonly actorKind?: string;
+  readonly actorRole?: string;
+  readonly recordSource?: SemanticHistoryRecordSourceRef | string;
+  readonly historySource?: SemanticHistoryRecordSourceRef | string;
+  readonly recordSourceId?: string;
+  readonly historySourceId?: string;
+  readonly runId?: string;
+  readonly jobId?: string;
+  readonly lane?: string;
+  readonly taskId?: string;
   readonly baseHash?: string;
   readonly targetHash?: string;
   readonly beforeHash?: string;
@@ -140,6 +73,21 @@ export interface CreateSemanticHistoryRecordInput {
   readonly sourceRefs?: readonly SemanticHistorySourceRef[] | SemanticHistorySourceRef;
   readonly ownershipRegions?: readonly (SemanticHistoryOwnershipRegionRef | SemanticImportOwnershipRegion)[] | SemanticHistoryOwnershipRegionRef | SemanticImportOwnershipRegion;
   readonly semanticCandidates?: readonly (Partial<SemanticHistoryCandidateRef> | SemanticMergeCandidateRecord)[] | Partial<SemanticHistoryCandidateRef> | SemanticMergeCandidateRecord;
+  readonly semanticClaims?: readonly SemanticHistoryClaimInput[] | SemanticHistoryClaimInput;
+  readonly claims?: readonly SemanticHistoryClaimInput[] | SemanticHistoryClaimInput;
+  readonly acceptedFacts?: readonly SemanticHistoryClaimInput[] | SemanticHistoryClaimInput;
+  readonly acceptedSemanticClaims?: readonly SemanticHistoryClaimInput[] | SemanticHistoryClaimInput;
+  readonly rejectedTheories?: readonly SemanticHistoryClaimInput[] | SemanticHistoryClaimInput;
+  readonly rejectedSemanticClaims?: readonly SemanticHistoryClaimInput[] | SemanticHistoryClaimInput;
+  readonly importedParserEvidence?: readonly SemanticHistoryImportedParserEvidenceInput[] | SemanticHistoryImportedParserEvidenceInput;
+  readonly parserEvidence?: readonly SemanticHistoryImportedParserEvidenceInput[] | SemanticHistoryImportedParserEvidenceInput;
+  readonly proofAttempts?: readonly SemanticHistoryProofAttemptInput[] | SemanticHistoryProofAttemptInput;
+  readonly proofs?: readonly SemanticHistoryProofAttemptInput[] | SemanticHistoryProofAttemptInput;
+  readonly patchAncestry?: readonly SemanticHistoryPatchAncestryInput[] | SemanticHistoryPatchAncestryInput;
+  readonly patchAncestors?: readonly SemanticHistoryPatchAncestryInput[] | SemanticHistoryPatchAncestryInput;
+  readonly ancestry?: readonly SemanticHistoryPatchAncestryInput[] | SemanticHistoryPatchAncestryInput;
+  readonly mergeDecisions?: readonly SemanticHistoryMergeDecisionInput[] | SemanticHistoryMergeDecisionInput;
+  readonly decisions?: readonly SemanticHistoryMergeDecisionInput[] | SemanticHistoryMergeDecisionInput;
   readonly mergeCandidates?: readonly SemanticMergeCandidateRecord[] | SemanticMergeCandidateRecord;
   readonly evidence?: readonly EvidenceRecord[];
   readonly evidenceIds?: readonly string[] | string;
@@ -158,9 +106,14 @@ export interface CreateSemanticHistoryRecordInput {
 
 export interface SemanticHistoryOverlapQueryOptions {
   readonly includeSourcePaths?: boolean;
+  readonly includeClaims?: boolean;
   readonly includeEvidence?: boolean;
   readonly includeProofs?: boolean;
   readonly includeReplay?: boolean;
+  readonly includePatches?: boolean;
+  readonly includeMergeDecisions?: boolean;
+  readonly includeActors?: boolean;
+  readonly includeRecordSources?: boolean;
   readonly includeBaseHashes?: boolean;
   readonly includeTargetHashes?: boolean;
   readonly conflictOnSourcePath?: boolean;
@@ -182,7 +135,7 @@ export declare const SemanticHistoryAdmissionStatuses: readonly SemanticHistoryA
 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 createSemanticHistoryRecord(input?: CreateSemanticHistoryRecordInput, options?: { readonly id?: string; readonly createdAt?: number | string; readonly actor?: SemanticHistoryActorRef | string; readonly actorId?: string; readonly actorKind?: string; readonly actorRole?: string; readonly recordSource?: SemanticHistoryRecordSourceRef | string; readonly historySource?: SemanticHistoryRecordSourceRef | string; readonly recordSourceId?: string; readonly historySourceId?: string; readonly runId?: string; readonly jobId?: string; readonly lane?: string; readonly taskId?: 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-slice-admission.d.ts

@@ -36,6 +36,115 @@ export interface SemanticSliceAdmissionMergeScore {
   readonly penalties: readonly string[];
 }
 
+export interface SemanticSliceAdmissionSpan {
+  readonly path?: string;
+  readonly sourceId?: string;
+  readonly sourceHash?: string;
+  readonly startLine?: number;
+  readonly startColumn?: number;
+  readonly endLine?: number;
+  readonly endColumn?: number;
+  readonly startOffset?: number;
+  readonly endOffset?: number;
+}
+
+export interface SemanticSliceAdmissionSelectedSymbol {
+  readonly id?: string;
+  readonly name?: string;
+  readonly displayName?: string;
+  readonly kind?: string;
+  readonly signature?: string;
+  readonly nativeAstNodeId?: string;
+  readonly sourcePath?: string;
+  readonly sourceSpan?: SemanticSliceAdmissionSpan;
+  readonly ownershipRegionId?: string;
+  readonly ownershipRegionKey?: string;
+  readonly ownershipRegionKind?: string;
+}
+
+export interface SemanticSliceAdmissionSelectedRegion {
+  readonly id?: string;
+  readonly key?: string;
+  readonly conflictKey?: string;
+  readonly kind?: string;
+  readonly granularity?: string;
+  readonly symbolId?: string;
+  readonly symbolName?: string;
+  readonly nativeAstNodeId?: string;
+  readonly sourcePath?: string;
+  readonly sourceSpan?: SemanticSliceAdmissionSpan;
+}
+
+export interface SemanticSliceAdmissionSelectedNativeNode {
+  readonly id?: string;
+  readonly kind?: string;
+  readonly languageKind?: string;
+  readonly sourcePath?: string;
+  readonly sourceSpan?: SemanticSliceAdmissionSpan;
+  readonly parentId?: string;
+  readonly childCount: number;
+}
+
+export interface SemanticSliceAdmissionSelectedRelation {
+  readonly id?: string;
+  readonly predicate?: string;
+  readonly kind?: string;
+  readonly sourceId?: string;
+  readonly targetId?: string;
+}
+
+export interface SemanticSliceAdmissionSelectedOccurrence {
+  readonly id?: string;
+  readonly symbolId?: string;
+  readonly nativeAstNodeId?: string;
+  readonly role?: string;
+  readonly sourcePath?: string;
+  readonly sourceSpan?: SemanticSliceAdmissionSpan;
+}
+
+export interface SemanticSliceAdmissionSelectedSourceMapLink {
+  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 nativeAstNodeId?: string;
+  readonly ownershipRegionId?: string;
+  readonly ownershipRegionKey?: string;
+  readonly ownershipRegionKind?: string;
+  readonly precision?: string;
+  readonly sourceSpan?: SemanticSliceAdmissionSpan;
+}
+
+export interface SemanticSliceAdmissionSelectedSourceFile {
+  readonly path?: string;
+  readonly sourceHash?: string;
+  readonly spanCount: number;
+  readonly excerptCount: number;
+  readonly sourceTextAvailable: boolean;
+}
+
+export interface SemanticSliceAdmissionSelectedSurface {
+  readonly entryRefs: readonly string[];
+  readonly matchedEntryRefs: readonly string[];
+  readonly unresolvedEntryRefs: readonly string[];
+  readonly symbols: readonly SemanticSliceAdmissionSelectedSymbol[];
+  readonly ownershipRegions: readonly SemanticSliceAdmissionSelectedRegion[];
+  readonly nativeNodes: readonly SemanticSliceAdmissionSelectedNativeNode[];
+  readonly relations: readonly SemanticSliceAdmissionSelectedRelation[];
+  readonly occurrences: readonly SemanticSliceAdmissionSelectedOccurrence[];
+  readonly sourceMapLinks: readonly SemanticSliceAdmissionSelectedSourceMapLink[];
+  readonly sourceSpans: readonly SemanticSliceAdmissionSpan[];
+  readonly sourceFiles: readonly SemanticSliceAdmissionSelectedSourceFile[];
+  readonly sourceHashes: SemanticSlice['mergeAdmission']['sourceHashes'];
+  readonly conflictKeys: readonly string[];
+  readonly ownershipKeys: readonly string[];
+}
+
 export interface SemanticSliceAdmissionRecord {
   readonly kind: 'frontier.lang.semanticSliceAdmission';
   readonly version: 1;
@@ -66,6 +175,8 @@ export interface SemanticSliceAdmissionRecord {
   readonly conflictKeys: readonly string[];
   readonly ownershipKeys: readonly string[];
   readonly sourceHashes: SemanticSlice['mergeAdmission']['sourceHashes'];
+  readonly selectedSurface: SemanticSliceAdmissionSelectedSurface;
+  readonly evidence: readonly EvidenceRecord[];
   readonly testResult?: SemanticSliceTestResult;
   readonly reasons: readonly string[];
   readonly metadata: Record<string, unknown>;

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

@@ -63,6 +63,19 @@ export type SemanticSliceInput =
     readonly source?: ImportNativeSourceOptions;
   };
 
+export interface SemanticSliceSourceHashExpectation {
+  readonly path?: string;
+  readonly sourcePath?: string;
+  readonly sourceHash?: string;
+  readonly hash?: string;
+  readonly expected?: string;
+}
+
+export type SemanticSliceSourceHashExpectations =
+  | Readonly<Record<string, string>>
+  | ReadonlyMap<string, string>
+  | readonly (SemanticSliceSourceHashExpectation | readonly [string | undefined, string])[];
+
 export interface CreateSemanticSliceOptions {
   readonly id?: string;
   readonly generatedAt?: number;
@@ -73,6 +86,14 @@ export interface CreateSemanticSliceOptions {
   readonly symbol?: string;
   readonly region?: string;
   readonly nativeNodeId?: string;
+  readonly expectedSymbols?: readonly string[] | string;
+  readonly expectedSymbolRefs?: readonly string[] | string;
+  readonly expectedRegions?: readonly string[] | string;
+  readonly expectedRegionRefs?: readonly string[] | string;
+  readonly expectedSourceHashes?: SemanticSliceSourceHashExpectations;
+  readonly expectedSymbolCount?: number;
+  readonly expectedRegionCount?: number;
+  readonly expectedSourceFileCount?: number;
   readonly entryRefs?: readonly string[] | string;
   readonly semanticRefs?: readonly string[] | string;
   readonly refs?: readonly string[] | string;
@@ -126,7 +147,12 @@ export interface SemanticSliceSourceFile {
 
 export interface SemanticSliceExpectedAssertion {
   readonly id: string;
-  readonly expected: boolean;
+  readonly category?: 'symbol' | 'region' | 'sourceHash' | 'summaryCount' | string;
+  readonly ref?: string;
+  readonly path?: string;
+  readonly key?: string;
+  readonly expected: unknown;
+  readonly actual?: unknown;
 }
 
 export interface SemanticSlice {
@@ -195,6 +221,14 @@ export interface TestSemanticSliceOptions {
   readonly generatedAt?: number;
   readonly requireSourceMapLinks?: boolean;
   readonly currentSources?: Readonly<Record<string, string>> | ReadonlyMap<string, string>;
+  readonly expectedSymbols?: readonly string[] | string;
+  readonly expectedSymbolRefs?: readonly string[] | string;
+  readonly expectedRegions?: readonly string[] | string;
+  readonly expectedRegionRefs?: readonly string[] | string;
+  readonly expectedSourceHashes?: SemanticSliceSourceHashExpectations;
+  readonly expectedSymbolCount?: number;
+  readonly expectedRegionCount?: number;
+  readonly expectedSourceFileCount?: number;
   readonly metadata?: Record<string, unknown>;
 }
 
@@ -220,6 +254,7 @@ export interface SemanticSliceTestResult {
     readonly warnings: number;
     readonly failed: number;
     readonly sourceHashChecks: number;
+    readonly expectedAssertions: number;
     readonly symbols: number;
     readonly ownershipRegions: number;
     readonly sourceMapLinks: number;