@hardkas/core 0.5.5-alpha → 0.6.1-alpha

package/dist/index.d.ts

@@ -1,4 +1,5 @@
 import { z } from 'zod';
+import { AsyncLocalStorage } from 'node:async_hooks';
 
 /**
  * Lightweight branded/nominal types for domain-critical strings/numbers.
@@ -70,7 +71,7 @@ declare const asEventId: (id: string) => EventId;
 declare const asCorrelationId: (id: string) => CorrelationId;
 declare const asKaspaAddress: (addr: string) => KaspaAddress;
 declare const asRpcEndpointId: (id: string) => RpcEndpointId;
-declare const asNetworkId: (id: string) => NetworkId$1;
+declare const asNetworkId: <T extends string>(id: T) => Brand<T, "NetworkId">;
 declare const asEventSequence: (seq: number) => EventSequence;
 declare const asDaaScore: (score: number | bigint) => DaaScore;
 
@@ -81,7 +82,7 @@ type EventDomain = "workflow" | "integrity" | "rpc" | "dag" | "replay" | "localn
 /**
  * HardKAS Core Event Kinds.
  */
-type EventKind = "workflow.plan.created" | "workflow.signed" | "workflow.submitted" | "workflow.receipt" | "workflow.started" | "workflow.completed" | "workflow.failed" | "integrity.hash_mismatch" | "integrity.schema_violation" | "integrity.lineage_break" | "integrity.violation" | "dag.conflict" | "dag.displacement" | "dag.sink_moved" | "rpc.health" | "rpc.error" | "rpc.stale" | "replay.divergence" | "replay.verified" | "localnet.started" | "localnet.stopped" | "l2.deposit.planned" | "l2.withdrawal.planned";
+type EventKind = "workflow.plan.created" | "workflow.signed" | "workflow.submitted" | "workflow.receipt" | "workflow.started" | "workflow.completed" | "workflow.failed" | "integrity.hash_mismatch" | "integrity.schema_violation" | "integrity.lineage_break" | "integrity.violation" | "dag.conflict" | "dag.displacement" | "dag.sink_moved" | "rpc.health" | "rpc.error" | "rpc.stale" | "replay.divergence" | "replay.verified" | "localnet.started" | "localnet.stopped" | "l2.deposit.planned" | "l2.withdrawal.planned" | "artifact.written" | "artifact.indexed" | "artifact.corrupted" | "sqlite.commit" | "replay.invalidated" | "replay.completed" | "replay.excluded" | "sse.emitted" | "dashboard.cache_invalidated" | "dashboard.refetch_started" | "dashboard.refetch_completed" | "query_store.sync_started" | "query_store.sync_completed" | "lineage.verification_failed";
 /**
  * Payload mapping for each event kind.
  */
@@ -192,6 +193,60 @@ interface EventPayloadByKind {
         amount: bigint;
         from: string;
     };
+    "artifact.written": {
+        artifactId: ArtifactId;
+        path: string;
+    };
+    "artifact.indexed": {
+        artifactId: ArtifactId;
+        schema: string;
+    };
+    "artifact.corrupted": {
+        artifactId: ArtifactId;
+        path: string;
+        issue: string;
+    };
+    "sqlite.commit": {
+        transactionId: string;
+        rowCount: number;
+    };
+    "replay.invalidated": {
+        artifactId: ArtifactId;
+        reason: string;
+    };
+    "replay.completed": {
+        targetArtifactId: ArtifactId;
+        success: boolean;
+    };
+    "replay.excluded": {
+        artifactId: ArtifactId;
+        reason: string;
+    };
+    "sse.emitted": {
+        eventId: EventId;
+        channel: string;
+    };
+    "dashboard.cache_invalidated": {
+        key: string;
+    };
+    "dashboard.refetch_started": {
+        key: string;
+    };
+    "dashboard.refetch_completed": {
+        key: string;
+        success: boolean;
+    };
+    "query_store.sync_started": {
+        syncId: string;
+    };
+    "query_store.sync_completed": {
+        syncId: string;
+        stats: Record<string, number>;
+    };
+    "lineage.verification_failed": {
+        artifactId: ArtifactId;
+        missingParentId: ArtifactId;
+    };
 }
 /**
  * Formal Event Envelope (v1).
@@ -205,7 +260,10 @@ interface EventEnvelope<K extends EventKind = EventKind> {
     domain: EventDomain;
     kind: K;
     timestamp: string;
-    sequence?: EventSequence | undefined;
+    emittedAt: string;
+    sequenceNumber: EventSequence;
+    globalOffset?: number;
+    sourceSubsystem: string;
     workflowId: WorkflowId;
     correlationId: CorrelationId;
     causationId?: EventId;
@@ -256,7 +314,9 @@ declare function createEventEnvelope<K extends EventKind>(params: {
     artifactId?: ArtifactId;
     txId?: TxId;
     eventId?: EventId;
-    sequence?: EventSequence;
+    sequenceNumber: EventSequence;
+    globalOffset?: number;
+    sourceSubsystem: string;
 }): EventEnvelope<K>;
 /**
  * Lightweight runtime validation for event envelopes.
@@ -269,6 +329,11 @@ type UnknownEventPayload = {
     readonly type: "unknown";
     readonly data: Record<string, unknown>;
 };
+/**
+ * Attaches the canonical Event Ledger appender to the core event bus.
+ * This guarantees that all formal EventEnvelopes are persisted to events.jsonl.
+ */
+declare function attachLedgerAppender(workspaceRoot: string): () => void;
 
 /**
  * @deprecated Use Brand from domain-types.js instead.
@@ -334,6 +399,37 @@ interface CorruptionIssue {
  */
 declare function formatCorruptionIssue(issue: CorruptionIssue): string;
 
+type IntegrityStatus = "verified" | "corrupted" | "invalid_json" | "unknown";
+/**
+ * Explains the causal origin and validation state of a derived value.
+ */
+interface StateProvenance {
+    /**
+     * The architectural authority that asserts this state (e.g. "query-store projection", "filesystem artifact", "memory cache")
+     */
+    authority: string;
+    /**
+     * The source artifact ID from which this state was derived (if applicable)
+     */
+    derivedFrom?: ArtifactId;
+    /**
+     * The absolute or relative file path of the source artifact
+     */
+    originalPath?: string;
+    /**
+     * Current deterministic integrity of the source
+     */
+    integrity: IntegrityStatus;
+    /**
+     * The replay scope indicating where this state is valid (e.g., "local-only", "global")
+     */
+    replayScope: "local-only" | "global" | "unknown";
+    /**
+     * True if this state has been independently verified against network consensus
+     */
+    consensusValidated: boolean;
+}
+
 /**
  * HardKAS Lock Metadata schema v1
  */
@@ -368,6 +464,7 @@ interface AcquireLockArgs {
 declare const LOCK_ORDER: string[];
 /**
  * Acquires a named lock for the workspace.
+ * Supports automatic stale lock recovery when the holding process is dead.
  */
 declare function acquireLock(args: AcquireLockArgs): Promise<LockHandle>;
 /**
@@ -406,16 +503,307 @@ declare function clearLock(rootDir: string, name: string, options?: {
     reason?: string;
 };
 
+interface StructuralDiff {
+    missingArtifacts: string[];
+    excludedArtifacts: string[];
+    missingProjections: string[];
+}
+interface DeterministicDiff {
+    stateRootDiverged: boolean;
+    lineageDiverged: boolean;
+    graphDiverged: boolean;
+    differences: Array<{
+        path: string;
+        a: any;
+        b: any;
+    }>;
+}
+interface RuntimeNoiseDiff {
+    timestampShifts: Array<{
+        path: string;
+        shiftMs: number;
+    }>;
+    eventOrderingShifts: string[];
+    metadataDrift: string[];
+}
+interface LayeredReplayDiff {
+    schema: "hardkas.replayDiff.v1";
+    structural: StructuralDiff;
+    deterministic: DeterministicDiff;
+    observational: RuntimeNoiseDiff;
+}
+declare function diffReplays(replayA: any, replayB: any): LayeredReplayDiff;
+
+interface SnapshotManifest {
+    snapshotVersion: number;
+    createdAt: string;
+    hardkasVersion: string;
+    stateAuthority: "filesystem";
+    projectionAuthority: "sqlite";
+    deterministicScope: "local-only" | "consensus-validated";
+    consensusValidated: boolean;
+    includedArtifacts: number;
+    excludedArtifacts: number;
+    corruptedArtifacts: number;
+}
+interface CreateSnapshotOptions {
+    hardkasDir: string;
+    outputDir: string;
+    deterministicScope?: "local-only" | "consensus-validated";
+}
+declare function createSnapshot(options: CreateSnapshotOptions): Promise<SnapshotManifest>;
+declare function readSnapshotManifest(snapshotDir: string): Promise<SnapshotManifest>;
+
+/**
+ * Deterministic comparison utility for cross-platform string sorting.
+ * Avoids localeCompare() which is dependent on the host machine's ICU version and OS locale.
+ */
+declare function deterministicCompare(a: string, b: string): number;
+
+type TelemetrySubsystem = "lock" | "fs" | "replay" | "normalization" | "query-store" | "lineage" | "projection" | "unknown";
+type AnomalyType = "LOCK_CONTENTION" | "STALE_LOCK_RECOVERY" | "FS_RETRY" | "NORMALIZATION_COLLISION" | "REPLAY_RECONCILIATION" | "EXTERNAL_MUTATION" | "PATH_TRAVERSAL_ATTEMPT" | "ORPHAN_PROJECTION_RECOVERY";
+type Severity = "low" | "medium" | "high" | "critical";
+interface AnomalyEvent {
+    timestamp: string;
+    seed?: number | undefined;
+    caseId?: string | undefined;
+    bucket?: string | undefined;
+    anomalyType: AnomalyType;
+    severity: Severity;
+    subsystem: TelemetrySubsystem;
+    details: string;
+    sandbox?: string | undefined;
+}
+
+declare class TelemetryManager {
+    private rootDir;
+    private currentContext;
+    private preservedSandboxes;
+    constructor(rootDir?: string);
+    init(rootDir: string): void;
+    setContext(context: {
+        seed?: number;
+        caseId?: string;
+        bucket?: string;
+    }): void;
+    clearContext(): void;
+    getContext(): {
+        seed?: number;
+        caseId?: string;
+        bucket?: string;
+    };
+    logAnomaly(anomalyType: AnomalyType, severity: Severity, subsystem: TelemetrySubsystem, details: string, sandboxOverride?: string): void;
+    shouldPreserveSandbox(sandboxDir: string): boolean;
+}
+declare const telemetryContextStorage: AsyncLocalStorage<TelemetryManager>;
+declare const globalTelemetry: TelemetryManager;
+declare function getTelemetry(): TelemetryManager;
+declare class TelemetryProxy {
+    logAnomaly(anomalyType: AnomalyType, severity: Severity, subsystem: TelemetrySubsystem, details: string, sandboxOverride?: string): void;
+    init(rootDir: string): void;
+    setContext(context: {
+        seed?: number;
+        caseId?: string;
+        bucket?: string;
+    }): void;
+    clearContext(): void;
+    getContext(): {
+        seed?: number;
+        caseId?: string;
+        bucket?: string;
+    };
+    shouldPreserveSandbox(sandboxDir: string): boolean;
+}
+declare const EnvironmentTelemetry: TelemetryProxy;
+
+interface RotationResult {
+    rotated: boolean;
+    archivePath?: string;
+    bytesRotated?: number;
+    reason?: string;
+}
+declare class TelemetryRotator {
+    private static readonly DEFAULT_MAX_SIZE_BYTES;
+    /**
+     * Rotates the telemetry stream if it exceeds the maximum size.
+     * This is a safe operation that renames the active file to an archive directory.
+     */
+    static rotateIfNeeded(rootDir: string, maxSizeBytes?: number): RotationResult;
+    /**
+     * Forces a rotation regardless of file size.
+     */
+    static forceRotate(rootDir: string): RotationResult;
+    /**
+     * Lists all archived telemetry segments.
+     */
+    static listArchivedSegments(rootDir: string): string[];
+}
+
+interface DeterministicClock {
+    now(): number;
+}
+interface DeterministicRandom {
+    next(): number;
+}
+interface IdProvider {
+    execution(): string;
+    workflow(): string;
+}
+interface RuntimeContext {
+    clock: DeterministicClock;
+    random: DeterministicRandom;
+    ids: IdProvider;
+    telemetry: TelemetryManager;
+}
+/**
+ * A default system runtime context (for non-deterministic contexts like dev server or CLI entry points)
+ * This should NOT be used directly in pure canonical domain logic (e.g. artifacts, replays).
+ */
+declare const systemRuntimeContext: RuntimeContext;
+
+/**
+ * Formal Artifact Status Lattice
+ *
+ * UNKNOWN: Unreadable, ambiguous, partially classified, migration-pending states.
+ * PROJECTED: An artifact read from disk / state whose truth has not yet been verified.
+ * STALE: An artifact whose dependencies/lineage has drifted since it was verified.
+ * VERIFIED: Integrity, signature, and internal capability constraints are verified.
+ * REPLAY_VERIFIED: Full lineage and determinism verified via an active replay.
+ * CORRUPTED: Irreparable semantic or cryptographic corruption detected.
+ * QUARANTINED: Corrupted or malicious artifact safely isolated from runtime.
+ */
+type ArtifactStatus = "UNKNOWN" | "PROJECTED" | "STALE" | "VERIFIED" | "REPLAY_VERIFIED" | "CORRUPTED" | "QUARANTINED";
+/**
+ * Baseline schema version is 1.
+ */
+type SchemaVersion = 1;
+interface SemanticIdentity {
+    /** The unique artifact ID */
+    artifactId: string;
+    /** The semantic hash of the artifact content */
+    semanticHash: string;
+    /** Formal schema version */
+    schemaVersion: SchemaVersion;
+    /** Current status in the lattice */
+    status: ArtifactStatus;
+}
+
+/**
+ * Throws a loud runtime error if a transition is invalid.
+ * Invariant: `artifact_status_transitions_are_semantically_valid`
+ */
+declare function validateStatusTransition(from: ArtifactStatus, to: ArtifactStatus): void;
+
+interface ReplayContext {
+    semanticHash: string;
+    lineageId: string;
+    replayHash: string;
+}
+/**
+ * Resolves a canonical artifact.
+ * Implicit 'latest' is STRICTLY FORBIDDEN.
+ * You must provide an explicit artifactId, lineageId, or semanticHash.
+ * Invariant: `canonical_resolution_never_depends_on_implicit_latest`
+ */
+declare function resolveCanonicalArtifact(params: {
+    artifactId?: string;
+    lineageId?: string;
+    semanticHash?: string;
+}): string;
+/**
+ * Verifies that the artifact content integrity is valid.
+ */
+declare function verifyArtifactIntegrity(identity: SemanticIdentity, computedHash: string): void;
+/**
+ * Verifies the artifact via active replay, isolating it from ambient state.
+ * Invariant: `replay_isolated_from_ambient_runtime_state`
+ */
+declare function verifyReplay(identity: SemanticIdentity, replayCtx: ReplayContext): ArtifactStatus;
+declare function verifyProjectionFreshness(identity: SemanticIdentity, currentLineageHead: string): boolean;
+declare function classifyArtifactStatus(identity: SemanticIdentity, isReadable: boolean, isCorrupted: boolean): ArtifactStatus;
+declare function resolveLineage(artifactId: string): string[];
+declare function verifyCapabilityBoundary(identity: SemanticIdentity, capability: string): void;
+
+interface MigrationResult {
+    migratedIdentity: SemanticIdentity;
+    success: boolean;
+    error?: string;
+}
+/**
+ * Validates that an artifact migration preserves identity and lineage semantics.
+ * Invariant: `schema_evolution_preserves_semantic_identity`
+ */
+declare function verifyMigrationIntegrity(preMigration: SemanticIdentity, postMigration: SemanticIdentity): void;
+/**
+ * Handles migrating an artifact to a newer schema version.
+ * Currently, only schemaVersion: 1 exists as the baseline.
+ */
+declare function migrateArtifact(identity: SemanticIdentity, targetVersion: SchemaVersion): MigrationResult;
+/**
+ * Compares lineage before and after migration to ensure continuity.
+ */
+declare function comparePrePostMigrationLineage(preLineageId: string, postLineageId: string): void;
+
+interface SemanticDriftReport {
+    hasDrift: boolean;
+    conflictingSubsystem?: string;
+    exactReplayCommand?: string;
+    severity: "NONE" | "CRITICAL";
+    details?: string;
+}
+/**
+ * Compares the truth across different subsystems.
+ * If multiple subsystems disagree about truth, that is a CRITICAL semantic failure.
+ * Invariant: `subsystems_cannot_disagree_about_canonical_truth`
+ */
+declare function detectSemanticDrift(dashboardView: SemanticIdentity, queryStoreView: SemanticIdentity, replayView: SemanticIdentity, filesystemView: SemanticIdentity): SemanticDriftReport;
+/**
+ * Asserts no semantic drift exists. Fails loudly.
+ */
+declare function assertNoSemanticDrift(dashboardView: SemanticIdentity, queryStoreView: SemanticIdentity, replayView: SemanticIdentity, filesystemView: SemanticIdentity): void;
+
+declare class AppendCoordinator {
+    /**
+     * Safely appends a line to a JSONL log under process coordination locks.
+     * Performs an immediate fsync to ensure data durability.
+     * Also repairs the trailing line if it is corrupted, emitting an anomaly.
+     */
+    static appendAtomic(filePath: string, line: string, rootDir: string): void;
+    /**
+     * Scans a JSONL stream for corruption, truncating malformed trailing lines.
+     */
+    static recoverCorruptedTail(filePath: string): {
+        repaired: boolean;
+        linesDiscarded: number;
+        originalTail: string;
+    };
+}
+
+declare const CURRENT_RUNTIME_VERSION = "0.6.1-alpha";
+declare const MIN_SUPPORTED_VERSION = "0.5.0-alpha";
+interface MigrationStatus {
+    needsMigration: boolean;
+    canDowngrade: boolean;
+    currentVersion: string;
+}
+declare class MigrationManager {
+    static checkVersion(rootDir: string): MigrationStatus;
+    static migrate(rootDir: string, dryRun?: boolean): void;
+    private static writeVersion;
+    private static backupWorkspace;
+    private static compareSemver;
+}
+
 declare const SOMPI_PER_KAS = 100000000n;
-declare const kaspaNetworkIdSchema: z.ZodEnum<["mainnet", "testnet-10", "testnet-11", "testnet-12", "simnet", "simnet-1", "devnet"]>;
+declare const kaspaNetworkIdSchema: z.ZodEnum<["mainnet", "testnet-10", "testnet-11", "testnet-12", "simnet", "simnet-1", "devnet", "simulated"]>;
 type NetworkId = Brand<z.infer<typeof kaspaNetworkIdSchema>, "NetworkId">;
 declare const executionModeSchema: z.ZodEnum<["simulated", "real", "readonly"]>;
 type ExecutionMode = z.infer<typeof executionModeSchema>;
-declare const artifactTypeSchema: z.ZodEnum<["txPlan", "signedTx", "txReceipt", "txTrace", "snapshot"]>;
+declare const artifactTypeSchema: z.ZodEnum<["txPlan", "signedTx", "txReceipt", "txTrace", "snapshot", "workflow.v1"]>;
 type ArtifactType = z.infer<typeof artifactTypeSchema>;
-declare const NetworkIdSchema: z.ZodEnum<["mainnet", "testnet-10", "testnet-11", "testnet-12", "simnet", "simnet-1", "devnet"]>;
+declare const NetworkIdSchema: z.ZodEnum<["mainnet", "testnet-10", "testnet-11", "testnet-12", "simnet", "simnet-1", "devnet", "simulated"]>;
 declare const ExecutionModeSchema: z.ZodEnum<["simulated", "real", "readonly"]>;
-declare const ArtifactTypeSchema: z.ZodEnum<["txPlan", "signedTx", "txReceipt", "txTrace", "snapshot"]>;
+declare const ArtifactTypeSchema: z.ZodEnum<["txPlan", "signedTx", "txReceipt", "txTrace", "snapshot", "workflow.v1"]>;
 declare const hardkasConfigSchema: z.ZodObject<{
     project: z.ZodObject<{
         name: z.ZodString;
@@ -428,13 +816,13 @@ declare const hardkasConfigSchema: z.ZodObject<{
         root: string;
     }>;
     network: z.ZodObject<{
-        id: z.ZodEnum<["mainnet", "testnet-10", "testnet-11", "testnet-12", "simnet", "simnet-1", "devnet"]>;
+        id: z.ZodEnum<["mainnet", "testnet-10", "testnet-11", "testnet-12", "simnet", "simnet-1", "devnet", "simulated"]>;
         rpcUrl: z.ZodOptional<z.ZodString>;
     }, "strip", z.ZodTypeAny, {
-        id: "mainnet" | "testnet-10" | "testnet-11" | "testnet-12" | "simnet" | "simnet-1" | "devnet";
+        id: "mainnet" | "testnet-10" | "testnet-11" | "testnet-12" | "simnet" | "simnet-1" | "devnet" | "simulated";
         rpcUrl?: string | undefined;
     }, {
-        id: "mainnet" | "testnet-10" | "testnet-11" | "testnet-12" | "simnet" | "simnet-1" | "devnet";
+        id: "mainnet" | "testnet-10" | "testnet-11" | "testnet-12" | "simnet" | "simnet-1" | "devnet" | "simulated";
         rpcUrl?: string | undefined;
     }>;
     localnet: z.ZodDefault<z.ZodObject<{
@@ -453,7 +841,7 @@ declare const hardkasConfigSchema: z.ZodObject<{
         root: string;
     };
     network: {
-        id: "mainnet" | "testnet-10" | "testnet-11" | "testnet-12" | "simnet" | "simnet-1" | "devnet";
+        id: "mainnet" | "testnet-10" | "testnet-11" | "testnet-12" | "simnet" | "simnet-1" | "devnet" | "simulated";
         rpcUrl?: string | undefined;
     };
     localnet: {
@@ -466,7 +854,7 @@ declare const hardkasConfigSchema: z.ZodObject<{
         root: string;
     };
     network: {
-        id: "mainnet" | "testnet-10" | "testnet-11" | "testnet-12" | "simnet" | "simnet-1" | "devnet";
+        id: "mainnet" | "testnet-10" | "testnet-11" | "testnet-12" | "simnet" | "simnet-1" | "devnet" | "simulated";
         rpcUrl?: string | undefined;
     };
     localnet?: {
@@ -496,4 +884,4 @@ declare function parseHardkasConfig(input: unknown): HardkasConfig;
 declare function parseKasToSompi(input: string): bigint;
 declare function formatSompi(amountSompi: bigint): string;
 
-export { type AcquireLockArgs, type ArtifactId, type ArtifactType, ArtifactTypeSchema, type Brand, type Branded, type ContentHash, type CoreEvent, type CoreEventListener, type CorrelationId, type CorruptionCode, type CorruptionIssue, type CorruptionSeverity, type DaaScore, type EventDomain, type EventEnvelope, type EventId, type EventKind, type EventPayloadByKind, type EventSequence, type ExecutionMode, ExecutionModeSchema, type HardkasConfig, HardkasError, type InvariantDomain, type InvariantSeverity, InvariantViolationError, type KaspaAddress, LOCK_ORDER, type LineageId, type LockHandle, type LockMetadata, type NetworkId, NetworkIdSchema, type RpcEndpointId, SOMPI_PER_KAS, type StampedEvent, type TxId, type UnknownEventPayload, type WorkflowId, type WriteFileAtomicOptions, acquireLock, artifactTypeSchema, asArtifactId, asContentHash, asCorrelationId, asDaaScore, asEventId, asEventSequence, asKaspaAddress, asLineageId, asNetworkId, asRpcEndpointId, asTxId, asWorkflowId, clearLock, coreEvents, createEventEnvelope, executionModeSchema, formatCorruptionIssue, formatSompi, hardkasConfigSchema, isProcessAlive, kaspaNetworkIdSchema, listLocks, maskSecrets, parseHardkasConfig, parseKasToSompi, redactSecret, validateEventEnvelope, withLock, withLocks, writeFileAtomic, writeFileAtomicSync };
+export { type AcquireLockArgs, type AnomalyEvent, type AnomalyType, AppendCoordinator, type ArtifactId, type ArtifactStatus, type ArtifactType, ArtifactTypeSchema, type Brand, type Branded, CURRENT_RUNTIME_VERSION, type ContentHash, type CoreEvent, type CoreEventListener, type CorrelationId, type CorruptionCode, type CorruptionIssue, type CorruptionSeverity, type CreateSnapshotOptions, type DaaScore, type DeterministicClock, type DeterministicDiff, type DeterministicRandom, EnvironmentTelemetry, type EventDomain, type EventEnvelope, type EventId, type EventKind, type EventPayloadByKind, type EventSequence, type ExecutionMode, ExecutionModeSchema, type HardkasConfig, HardkasError, type IdProvider, type IntegrityStatus, type InvariantDomain, type InvariantSeverity, InvariantViolationError, type KaspaAddress, LOCK_ORDER, type LayeredReplayDiff, type LineageId, type LockHandle, type LockMetadata, MIN_SUPPORTED_VERSION, MigrationManager, type MigrationResult, type MigrationStatus, type NetworkId, NetworkIdSchema, type ReplayContext, type RpcEndpointId, type RuntimeContext, type RuntimeNoiseDiff, SOMPI_PER_KAS, type SchemaVersion, type SemanticDriftReport, type SemanticIdentity, type Severity, type SnapshotManifest, type StampedEvent, type StateProvenance, type StructuralDiff, TelemetryManager, TelemetryRotator, type TelemetrySubsystem, type TxId, type UnknownEventPayload, type WorkflowId, type WriteFileAtomicOptions, acquireLock, artifactTypeSchema, asArtifactId, asContentHash, asCorrelationId, asDaaScore, asEventId, asEventSequence, asKaspaAddress, asLineageId, asNetworkId, asRpcEndpointId, asTxId, asWorkflowId, assertNoSemanticDrift, attachLedgerAppender, classifyArtifactStatus, clearLock, comparePrePostMigrationLineage, coreEvents, createEventEnvelope, createSnapshot, detectSemanticDrift, deterministicCompare, diffReplays, executionModeSchema, formatCorruptionIssue, formatSompi, getTelemetry, globalTelemetry, hardkasConfigSchema, isProcessAlive, kaspaNetworkIdSchema, listLocks, maskSecrets, migrateArtifact, parseHardkasConfig, parseKasToSompi, readSnapshotManifest, redactSecret, resolveCanonicalArtifact, resolveLineage, systemRuntimeContext, telemetryContextStorage, validateEventEnvelope, validateStatusTransition, verifyArtifactIntegrity, verifyCapabilityBoundary, verifyMigrationIntegrity, verifyProjectionFreshness, verifyReplay, withLock, withLocks, writeFileAtomic, writeFileAtomicSync };