@hardkas/core 0.5.5-alpha → 0.6.0-alpha

package/dist/index.d.ts

@@ -70,7 +70,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 +81,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 +192,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 +259,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 +313,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.
@@ -334,6 +393,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
  */
@@ -406,16 +496,94 @@ 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;
+
+interface DeterministicClock {
+    now(): number;
+}
+interface DeterministicRandom {
+    next(): number;
+}
+interface IdProvider {
+    execution(): string;
+    workflow(): string;
+}
+interface RuntimeContext {
+    clock: DeterministicClock;
+    random: DeterministicRandom;
+    ids: IdProvider;
+}
+/**
+ * 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;
+
 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 +596,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 +621,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 +634,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 +664,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 ArtifactId, type ArtifactType, ArtifactTypeSchema, type Brand, type Branded, type ContentHash, type CoreEvent, type CoreEventListener, type CorrelationId, type CorruptionCode, type CorruptionIssue, type CorruptionSeverity, type CreateSnapshotOptions, type DaaScore, type DeterministicClock, type DeterministicDiff, type DeterministicRandom, 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, type NetworkId, NetworkIdSchema, type RpcEndpointId, type RuntimeContext, type RuntimeNoiseDiff, SOMPI_PER_KAS, type SnapshotManifest, type StampedEvent, type StateProvenance, type StructuralDiff, 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, createSnapshot, deterministicCompare, diffReplays, executionModeSchema, formatCorruptionIssue, formatSompi, hardkasConfigSchema, isProcessAlive, kaspaNetworkIdSchema, listLocks, maskSecrets, parseHardkasConfig, parseKasToSompi, readSnapshotManifest, redactSecret, systemRuntimeContext, validateEventEnvelope, withLock, withLocks, writeFileAtomic, writeFileAtomicSync };

package/dist/index.js

@@ -37,13 +37,16 @@ var CoreEventBus = class {
 };
 var coreEvents = new CoreEventBus();
 function createEventEnvelope(params) {
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString();
   return {
     schema: "hardkas.event",
     version: "1.0.0",
     eventId: params.eventId || crypto.randomUUID(),
     domain: params.domain,
     kind: params.kind,
-    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    timestamp,
+    emittedAt: timestamp,
+    sourceSubsystem: params.sourceSubsystem,
     workflowId: params.workflowId,
     correlationId: params.correlationId,
     causationId: params.causationId,
@@ -51,7 +54,8 @@ function createEventEnvelope(params) {
     txId: params.txId,
     networkId: params.networkId,
     payload: params.payload,
-    ...params.sequence !== void 0 ? { sequence: params.sequence } : {}
+    sequenceNumber: params.sequenceNumber,
+    globalOffset: params.globalOffset
   };
 }
 function validateEventEnvelope(event) {
@@ -114,10 +118,11 @@ function redactSecret(value) {
 // src/fs.ts
 import fs from "fs";
 import path from "path";
+import crypto2 from "crypto";
 async function writeFileAtomic(targetPath, data, options = {}) {
   const dir = path.dirname(targetPath);
   const base = path.basename(targetPath);
-  const tempPath = path.join(dir, `.tmp.${base}.${Math.random().toString(36).slice(2)}`);
+  const tempPath = path.join(dir, `.tmp.${base}.${crypto2.randomUUID()}`);
   let fd = null;
   try {
     if (!fs.existsSync(dir)) {
@@ -179,7 +184,7 @@ async function writeFileAtomic(targetPath, data, options = {}) {
 function writeFileAtomicSync(targetPath, data, options = {}) {
   const dir = path.dirname(targetPath);
   const base = path.basename(targetPath);
-  const tempPath = path.join(dir, `.tmp.${base}.${Math.random().toString(36).slice(2)}`);
+  const tempPath = path.join(dir, `.tmp.${base}.${crypto2.randomUUID()}`);
   let fd = null;
   try {
     if (!fs.existsSync(dir)) {
@@ -420,6 +425,150 @@ function clearLock(rootDir, name, options = {}) {
   return { cleared: true };
 }
 
+// src/replay.ts
+function diffReplays(replayA, replayB) {
+  const diff = {
+    schema: "hardkas.replayDiff.v1",
+    structural: {
+      missingArtifacts: [],
+      excludedArtifacts: [],
+      missingProjections: []
+    },
+    deterministic: {
+      stateRootDiverged: false,
+      lineageDiverged: false,
+      graphDiverged: false,
+      differences: []
+    },
+    observational: {
+      timestampShifts: [],
+      eventOrderingShifts: [],
+      metadataDrift: []
+    }
+  };
+  if (replayA.artifacts?.length !== replayB.artifacts?.length) {
+    diff.structural.missingArtifacts.push("artifact_count_mismatch");
+  }
+  const stateA = replayA.stateRoot || replayA.postStateHash;
+  const stateB = replayB.stateRoot || replayB.postStateHash;
+  if (stateA !== stateB) {
+    diff.deterministic.stateRootDiverged = true;
+    diff.deterministic.differences.push({
+      path: "stateRoot",
+      a: stateA,
+      b: stateB
+    });
+  }
+  if (replayA.amountSompi !== void 0 && replayB.amountSompi !== void 0 && replayA.amountSompi !== replayB.amountSompi) {
+    diff.deterministic.differences.push({
+      path: "amountSompi",
+      a: replayA.amountSompi,
+      b: replayB.amountSompi
+    });
+  }
+  const tsA = replayA.timestamp || replayA.createdAt;
+  const tsB = replayB.timestamp || replayB.createdAt;
+  if (tsA && tsB) {
+    const timeA = new Date(tsA).getTime();
+    const timeB = new Date(tsB).getTime();
+    if (timeA !== timeB) {
+      diff.observational.timestampShifts.push({ path: "timestamp", shiftMs: Math.abs(timeA - timeB) });
+    }
+  }
+  return diff;
+}
+
+// src/snapshot.ts
+import fs3 from "fs/promises";
+import path3 from "path";
+async function createSnapshot(options) {
+  const { hardkasDir, outputDir, deterministicScope = "local-only" } = options;
+  await fs3.mkdir(outputDir, { recursive: true });
+  await fs3.mkdir(path3.join(outputDir, "artifacts"), { recursive: true });
+  await fs3.mkdir(path3.join(outputDir, "projections"), { recursive: true });
+  await fs3.mkdir(path3.join(outputDir, "events"), { recursive: true });
+  await fs3.mkdir(path3.join(outputDir, "replay"), { recursive: true });
+  await fs3.mkdir(path3.join(outputDir, "metadata"), { recursive: true });
+  let included = 0;
+  let excluded = 0;
+  let corrupted = 0;
+  const artifactsDir = path3.join(hardkasDir, "artifacts");
+  try {
+    const list = await fs3.readdir(artifactsDir);
+    for (const f of list) {
+      if (f.endsWith(".json")) {
+        const src = path3.join(artifactsDir, f);
+        const dest = path3.join(outputDir, "artifacts", f);
+        try {
+          const content = await fs3.readFile(src, "utf-8");
+          const parsed = JSON.parse(content);
+          if (parsed.schema && parsed.schema.startsWith("hardkas.")) {
+            await fs3.copyFile(src, dest);
+            included++;
+          } else {
+            excluded++;
+          }
+        } catch {
+          corrupted++;
+        }
+      }
+    }
+  } catch {
+  }
+  try {
+    const eventsLog = path3.join(hardkasDir, "events.jsonl");
+    await fs3.copyFile(eventsLog, path3.join(outputDir, "events", "events.jsonl"));
+  } catch {
+  }
+  try {
+    const dbPath = path3.join(hardkasDir, "store.db");
+    await fs3.copyFile(dbPath, path3.join(outputDir, "projections", "store.db"));
+  } catch {
+  }
+  const manifest = {
+    snapshotVersion: 1,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    hardkasVersion: "0.6.0-alpha",
+    stateAuthority: "filesystem",
+    projectionAuthority: "sqlite",
+    deterministicScope,
+    consensusValidated: deterministicScope === "consensus-validated",
+    includedArtifacts: included,
+    excludedArtifacts: excluded,
+    corruptedArtifacts: corrupted
+  };
+  await fs3.writeFile(
+    path3.join(outputDir, "manifest.json"),
+    JSON.stringify(manifest, null, 2),
+    "utf-8"
+  );
+  return manifest;
+}
+async function readSnapshotManifest(snapshotDir) {
+  const manifestPath = path3.join(snapshotDir, "manifest.json");
+  const content = await fs3.readFile(manifestPath, "utf-8");
+  return JSON.parse(content);
+}
+
+// src/deterministic.ts
+function deterministicCompare(a, b) {
+  return a < b ? -1 : a > b ? 1 : 0;
+}
+
+// src/runtime-context.ts
+var systemRuntimeContext = {
+  clock: {
+    now: () => Date.now()
+  },
+  random: {
+    next: () => Math.random()
+  },
+  ids: {
+    execution: () => `exec_${Date.now().toString(36)}`,
+    workflow: () => `wf_${Date.now().toString(36)}`
+  }
+};
+
 // src/index.ts
 var SOMPI_PER_KAS = 100000000n;
 var kaspaNetworkIdSchema = z.enum([
@@ -429,7 +578,8 @@ var kaspaNetworkIdSchema = z.enum([
   "testnet-12",
   "simnet",
   "simnet-1",
-  "devnet"
+  "devnet",
+  "simulated"
 ]);
 var executionModeSchema = z.enum([
   "simulated",
@@ -441,7 +591,8 @@ var artifactTypeSchema = z.enum([
   "signedTx",
   "txReceipt",
   "txTrace",
-  "snapshot"
+  "snapshot",
+  "workflow.v1"
 ]);
 var NetworkIdSchema = kaspaNetworkIdSchema;
 var ExecutionModeSchema = executionModeSchema;
@@ -534,6 +685,9 @@ export {
   clearLock,
   coreEvents,
   createEventEnvelope,
+  createSnapshot,
+  deterministicCompare,
+  diffReplays,
   executionModeSchema,
   formatCorruptionIssue,
   formatSompi,
@@ -544,7 +698,9 @@ export {
   maskSecrets,
   parseHardkasConfig,
   parseKasToSompi,
+  readSnapshotManifest,
   redactSecret,
+  systemRuntimeContext,
   validateEventEnvelope,
   withLock,
   withLocks,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hardkas/core",
-  "version": "0.5.5-alpha",
+  "version": "0.6.0-alpha",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",