@hardkas/core 0.7.3-alpha → 0.7.5-alpha

package/dist/index.d.ts

@@ -654,6 +654,7 @@ interface RuntimeContext {
     random: DeterministicRandom;
     ids: IdProvider;
     telemetry: TelemetryManager;
+    workflowId?: string;
 }
 /**
  * A default system runtime context (for non-deterministic contexts like dev server or CLI entry points)
@@ -786,7 +787,7 @@ declare class AppendCoordinator {
     };
 }
 
-declare const CURRENT_RUNTIME_VERSION = "0.7.3-alpha";
+declare const CURRENT_RUNTIME_VERSION = "0.7.5-alpha";
 declare const MIN_SUPPORTED_VERSION = "0.5.0-alpha";
 interface MigrationStatus {
     needsMigration: boolean;

package/dist/index.js

@@ -93,7 +93,13 @@ function getTelemetry() {
 }
 var TelemetryProxy = class {
   logAnomaly(anomalyType, severity, subsystem, details, sandboxOverride) {
-    return getTelemetry().logAnomaly(anomalyType, severity, subsystem, details, sandboxOverride);
+    return getTelemetry().logAnomaly(
+      anomalyType,
+      severity,
+      subsystem,
+      details,
+      sandboxOverride
+    );
   }
   init(rootDir) {
     return getTelemetry().init(rootDir);
@@ -142,7 +148,9 @@ var AppendCoordinator = class _AppendCoordinator {
         } catch (e) {
           if (e.code === "EEXIST") {
             if (Date.now() - start > timeoutMs) {
-              throw new Error(`[AppendCoordinator] Timeout waiting for lock on ${lockPath}`);
+              throw new Error(
+                `[AppendCoordinator] Timeout waiting for lock on ${lockPath}`
+              );
             }
             const sleepMs = 5 + Math.floor(Math.random() * 15);
             const sharedBuf = new Int32Array(new SharedArrayBuffer(4));
@@ -152,7 +160,10 @@ var AppendCoordinator = class _AppendCoordinator {
           throw e;
         }
       }
-      fs.writeSync(fd, JSON.stringify({ pid: process.pid, time: (/* @__PURE__ */ new Date()).toISOString() }));
+      fs.writeSync(
+        fd,
+        JSON.stringify({ pid: process.pid, time: (/* @__PURE__ */ new Date()).toISOString() })
+      );
       const recovery = _AppendCoordinator.recoverCorruptedTail(filePath);
       if (recovery.repaired) {
         repaired = true;
@@ -269,7 +280,23 @@ var AppendCoordinator = class _AppendCoordinator {
       } catch (err) {
         const truncateTo = lastLineStart;
         const discardedBytes = stat.size - truncateTo;
-        fs.truncateSync(filePath, truncateTo);
+        let truncated = false;
+        let retries = 5;
+        let lastError = null;
+        while (retries > 0 && !truncated) {
+          try {
+            fs.truncateSync(filePath, truncateTo);
+            truncated = true;
+          } catch (e) {
+            lastError = e;
+            retries--;
+            if (retries > 0) {
+              const sharedBuf = new Int32Array(new SharedArrayBuffer(4));
+              Atomics.wait(sharedBuf, 0, 0, 10);
+            }
+          }
+        }
+        if (!truncated) throw lastError;
         return {
           repaired: true,
           linesDiscarded: discardedBytes,
@@ -311,7 +338,7 @@ var CoreEventBus = class {
     }
   }
   /**
-   * Normalizes and emits an event. 
+   * Normalizes and emits an event.
    * Useful for incremental migration from raw events.
    */
   normalizeAndEmit(event) {
@@ -396,7 +423,10 @@ function maskSecrets(data) {
     let redacted = data.replace(/\b[0-9a-fA-F]{64}\b/g, (match) => {
       return `${match.slice(0, 6)}...${match.slice(-4)} [REDACTED]`;
     });
-    redacted = redacted.replace(/\b([a-z]{3,10}\s+){11,23}[a-z]{3,10}\b/g, "[MNEMONIC REDACTED]");
+    redacted = redacted.replace(
+      /\b([a-z]{3,10}\s+){11,23}[a-z]{3,10}\b/g,
+      "[MNEMONIC REDACTED]"
+    );
     return redacted;
   }
   if (Array.isArray(data)) {
@@ -452,7 +482,12 @@ async function writeFileAtomic(targetPath, data, options = {}) {
         attempts++;
         if (attempts >= maxAttempts) throw e;
         if (e.code === "EPERM" || e.code === "EBUSY") {
-          EnvironmentTelemetry.logAnomaly("FS_RETRY", "low", "fs", `Retrying rename of ${targetPath} due to ${e.code}`);
+          EnvironmentTelemetry.logAnomaly(
+            "FS_RETRY",
+            "low",
+            "fs",
+            `Retrying rename of ${targetPath} due to ${e.code}`
+          );
           await new Promise((resolve) => setTimeout(resolve, 10 * attempts));
           continue;
         }
@@ -470,11 +505,9 @@ async function writeFileAtomic(targetPath, data, options = {}) {
       }
     }
   } catch (err) {
-    throw new HardkasError(
-      "IO_ERROR",
-      `Failed to write file atomically: ${targetPath}`,
-      { cause: err }
-    );
+    throw new HardkasError("IO_ERROR", `Failed to write file atomically: ${targetPath}`, {
+      cause: err
+    });
   } finally {
     if (fs2.existsSync(tempPath)) {
       try {
@@ -515,7 +548,12 @@ function writeFileAtomicSync(targetPath, data, options = {}) {
         attempts++;
         if (attempts >= maxAttempts) throw e;
         if (e.code === "EPERM" || e.code === "EBUSY") {
-          EnvironmentTelemetry.logAnomaly("FS_RETRY", "low", "fs", `Retrying rename sync of ${targetPath} due to ${e.code}`);
+          EnvironmentTelemetry.logAnomaly(
+            "FS_RETRY",
+            "low",
+            "fs",
+            `Retrying rename sync of ${targetPath} due to ${e.code}`
+          );
           continue;
         }
         throw e;
@@ -614,7 +652,9 @@ async function acquireLock(args) {
         release: async () => {
           if (fs3.existsSync(lockPath)) {
             try {
-              const current = JSON.parse(fs3.readFileSync(lockPath, "utf-8"));
+              const current = JSON.parse(
+                fs3.readFileSync(lockPath, "utf-8")
+              );
               if (current.pid === process.pid) {
                 fs3.unlinkSync(lockPath);
               }
@@ -645,13 +685,27 @@ async function acquireLock(args) {
             staleRecoveryAttempted = true;
             try {
               fs3.unlinkSync(lockPath);
-              EnvironmentTelemetry.logAnomaly("STALE_LOCK_RECOVERY", "medium", "lock", `Recovered corrupted lock file at ${lockPath} (Age: ${ageMs}ms)`, args.rootDir);
+              EnvironmentTelemetry.logAnomaly(
+                "STALE_LOCK_RECOVERY",
+                "medium",
+                "lock",
+                `Recovered corrupted lock file at ${lockPath} (Age: ${ageMs}ms)`,
+                args.rootDir
+              );
               continue;
             } catch {
-              throw new HardkasError("LOCK_METADATA_INVALID", `Lock file at ${lockPath} is corrupted and cannot be recovered.`, { cause: err });
+              throw new HardkasError(
+                "LOCK_METADATA_INVALID",
+                `Lock file at ${lockPath} is corrupted and cannot be recovered.`,
+                { cause: err }
+              );
             }
           }
-          throw new HardkasError("LOCK_METADATA_INVALID", `Lock file at ${lockPath} is corrupted.`, { cause: err });
+          throw new HardkasError(
+            "LOCK_METADATA_INVALID",
+            `Lock file at ${lockPath} is corrupted.`,
+            { cause: err }
+          );
         }
         if (existingMetadata) {
           const isLocal = existingMetadata.hostname === os.hostname();
@@ -660,7 +714,13 @@ async function acquireLock(args) {
             staleRecoveryAttempted = true;
             try {
               fs3.unlinkSync(lockPath);
-              EnvironmentTelemetry.logAnomaly("STALE_LOCK_RECOVERY", "medium", "lock", `Recovered lock held by dead process (PID: ${existingMetadata.pid})`, args.rootDir);
+              EnvironmentTelemetry.logAnomaly(
+                "STALE_LOCK_RECOVERY",
+                "medium",
+                "lock",
+                `Recovered lock held by dead process (PID: ${existingMetadata.pid})`,
+                args.rootDir
+              );
               continue;
             } catch (unlinkErr) {
               throw new HardkasError(
@@ -678,7 +738,13 @@ async function acquireLock(args) {
             );
           }
           if (args.wait && Date.now() - start < timeoutMs) {
-            EnvironmentTelemetry.logAnomaly("LOCK_CONTENTION", "low", "lock", `Waiting for lock ${args.name} held by PID ${existingMetadata.pid}`, args.rootDir);
+            EnvironmentTelemetry.logAnomaly(
+              "LOCK_CONTENTION",
+              "low",
+              "lock",
+              `Waiting for lock ${args.name} held by PID ${existingMetadata.pid}`,
+              args.rootDir
+            );
             await new Promise((resolve) => setTimeout(resolve, pollMs));
             continue;
           }
@@ -767,10 +833,18 @@ function clearLock(rootDir, name, options = {}) {
   const isLocal = metadata.hostname === os.hostname();
   const isAlive = isLocal ? isProcessAlive(metadata.pid) : true;
   if (options.ifDead) {
-    if (!isLocal) return { cleared: false, reason: "Cannot verify liveness of remote lock (host: " + metadata.hostname + ")" };
-    if (isAlive) return { cleared: false, reason: `Process (PID: ${metadata.pid}) is still alive` };
+    if (!isLocal)
+      return {
+        cleared: false,
+        reason: "Cannot verify liveness of remote lock (host: " + metadata.hostname + ")"
+      };
+    if (isAlive)
+      return { cleared: false, reason: `Process (PID: ${metadata.pid}) is still alive` };
   } else if (!options.force) {
-    return { cleared: false, reason: "Lock is potentially active. Use --force or --if-dead." };
+    return {
+      cleared: false,
+      reason: "Lock is potentially active. Use --force or --if-dead."
+    };
   }
   fs3.unlinkSync(lockPath);
   return { cleared: true };
@@ -823,7 +897,10 @@ function diffReplays(replayA, replayB) {
     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) });
+      diff.observational.timestampShifts.push({
+        path: "timestamp",
+        shiftMs: Math.abs(timeA - timeB)
+      });
     }
   }
   return diff;
@@ -879,7 +956,7 @@ async function createSnapshot(options) {
   const manifest = {
     snapshotVersion: 1,
     createdAt: (/* @__PURE__ */ new Date()).toISOString(),
-    hardkasVersion: "0.7.3-alpha",
+    hardkasVersion: "0.7.5-alpha",
     stateAuthority: "filesystem",
     projectionAuthority: "sqlite",
     deterministicScope,
@@ -924,7 +1001,10 @@ var TelemetryRotator = class {
     }
     const stats = fs5.statSync(activeFile);
     if (stats.size < maxSizeBytes) {
-      return { rotated: false, reason: `File size (${stats.size}) is below threshold (${maxSizeBytes})` };
+      return {
+        rotated: false,
+        reason: `File size (${stats.size}) is below threshold (${maxSizeBytes})`
+      };
     }
     return this.forceRotate(rootDir);
   }
@@ -1019,7 +1099,9 @@ function verifyArtifactIntegrity(identity, computedHash) {
 }
 function verifyReplay(identity, replayCtx) {
   if (identity.semanticHash !== replayCtx.semanticHash) {
-    throw new Error(`[CRITICAL SEMANTIC ERROR] Replay semantic hash divergence: expected ${identity.semanticHash}, got ${replayCtx.semanticHash}`);
+    throw new Error(
+      `[CRITICAL SEMANTIC ERROR] Replay semantic hash divergence: expected ${identity.semanticHash}, got ${replayCtx.semanticHash}`
+    );
   }
   validateStatusTransition(identity.status, "REPLAY_VERIFIED");
   return "REPLAY_VERIFIED";
@@ -1042,10 +1124,14 @@ function verifyCapabilityBoundary(identity, capability) {
 // src/semantics/migration.ts
 function verifyMigrationIntegrity(preMigration, postMigration) {
   if (preMigration.artifactId !== postMigration.artifactId) {
-    throw new Error(`[CRITICAL SEMANTIC ERROR] Migration unexpectedly altered canonical artifact ID: ${preMigration.artifactId} -> ${postMigration.artifactId}`);
+    throw new Error(
+      `[CRITICAL SEMANTIC ERROR] Migration unexpectedly altered canonical artifact ID: ${preMigration.artifactId} -> ${postMigration.artifactId}`
+    );
   }
   if (postMigration.schemaVersion < preMigration.schemaVersion) {
-    throw new Error(`[CRITICAL SEMANTIC ERROR] Invalid migration: schema downgraded from ${preMigration.schemaVersion} to ${postMigration.schemaVersion}`);
+    throw new Error(
+      `[CRITICAL SEMANTIC ERROR] Invalid migration: schema downgraded from ${preMigration.schemaVersion} to ${postMigration.schemaVersion}`
+    );
   }
 }
 function migrateArtifact(identity, targetVersion) {
@@ -1060,7 +1146,9 @@ function migrateArtifact(identity, targetVersion) {
 }
 function comparePrePostMigrationLineage(preLineageId, postLineageId) {
   if (preLineageId !== postLineageId) {
-    throw new Error(`[CRITICAL SEMANTIC ERROR] Lineage broken across schema migration: ${preLineageId} -> ${postLineageId}`);
+    throw new Error(
+      `[CRITICAL SEMANTIC ERROR] Lineage broken across schema migration: ${preLineageId} -> ${postLineageId}`
+    );
   }
 }
 
@@ -1098,7 +1186,12 @@ function detectSemanticDrift(dashboardView, queryStoreView, replayView, filesyst
   return { hasDrift: false, severity: "NONE" };
 }
 function assertNoSemanticDrift(dashboardView, queryStoreView, replayView, filesystemView) {
-  const report = detectSemanticDrift(dashboardView, queryStoreView, replayView, filesystemView);
+  const report = detectSemanticDrift(
+    dashboardView,
+    queryStoreView,
+    replayView,
+    filesystemView
+  );
   if (report.hasDrift) {
     throw new Error(
       `[CRITICAL SEMANTIC DRIFT] Subsystem disagreement detected.
@@ -1112,14 +1205,18 @@ Resolution Command: ${report.exactReplayCommand}`
 // src/migrations.ts
 import fs6 from "fs";
 import path8 from "path";
-var CURRENT_RUNTIME_VERSION = "0.7.3-alpha";
+var CURRENT_RUNTIME_VERSION = "0.7.5-alpha";
 var MIN_SUPPORTED_VERSION = "0.5.0-alpha";
 var MigrationManager = class {
   static checkVersion(rootDir) {
     const versionFile = path8.join(rootDir, ".hardkas", "version.json");
     if (!fs6.existsSync(versionFile)) {
       this.writeVersion(rootDir, CURRENT_RUNTIME_VERSION);
-      return { needsMigration: false, canDowngrade: true, currentVersion: CURRENT_RUNTIME_VERSION };
+      return {
+        needsMigration: false,
+        canDowngrade: true,
+        currentVersion: CURRENT_RUNTIME_VERSION
+      };
     }
     try {
       const data = JSON.parse(fs6.readFileSync(versionFile, "utf-8"));
@@ -1131,30 +1228,49 @@ var MigrationManager = class {
         return { needsMigration: false, canDowngrade: false, currentVersion: wsVersion };
       }
       if (this.compareSemver(wsVersion, MIN_SUPPORTED_VERSION) < 0) {
-        throw new HardkasError("MIGRATION_UNSUPPORTED", `Workspace version ${wsVersion} is too old to migrate to ${CURRENT_RUNTIME_VERSION}`);
+        throw new HardkasError(
+          "MIGRATION_UNSUPPORTED",
+          `Workspace version ${wsVersion} is too old to migrate to ${CURRENT_RUNTIME_VERSION}`
+        );
       }
       return { needsMigration: true, canDowngrade: true, currentVersion: wsVersion };
     } catch (err) {
       if (err instanceof HardkasError) throw err;
-      throw new HardkasError("MIGRATION_ERROR", `Failed to parse version.json: ${err.message}`);
+      throw new HardkasError(
+        "MIGRATION_ERROR",
+        `Failed to parse version.json: ${err.message}`
+      );
     }
   }
   static migrate(rootDir, dryRun = false) {
     const status = this.checkVersion(rootDir);
     if (!status.canDowngrade) {
-      throw new HardkasError("DOWNGRADE_REFUSED", `Cannot safely downgrade from workspace version ${status.currentVersion} to runtime version ${CURRENT_RUNTIME_VERSION}.`);
+      throw new HardkasError(
+        "DOWNGRADE_REFUSED",
+        `Cannot safely downgrade from workspace version ${status.currentVersion} to runtime version ${CURRENT_RUNTIME_VERSION}.`
+      );
     }
     if (!status.needsMigration) return;
     if (dryRun) {
-      console.log(`[DRY-RUN] Would migrate workspace from ${status.currentVersion} to ${CURRENT_RUNTIME_VERSION}`);
+      console.log(
+        `[DRY-RUN] Would migrate workspace from ${status.currentVersion} to ${CURRENT_RUNTIME_VERSION}`
+      );
       return;
     }
     this.backupWorkspace(rootDir);
     try {
       this.writeVersion(rootDir, CURRENT_RUNTIME_VERSION);
     } catch (err) {
-      getTelemetry().logAnomaly("EXTERNAL_MUTATION", "critical", "projection", `Migration failed: ${err.message}`);
-      throw new HardkasError("MIGRATION_FAILED", `Migration failed, workspace might be corrupted: ${err.message}`);
+      getTelemetry().logAnomaly(
+        "EXTERNAL_MUTATION",
+        "critical",
+        "projection",
+        `Migration failed: ${err.message}`
+      );
+      throw new HardkasError(
+        "MIGRATION_FAILED",
+        `Migration failed, workspace might be corrupted: ${err.message}`
+      );
     }
   }
   static writeVersion(rootDir, version) {
@@ -1195,11 +1311,7 @@ var kaspaNetworkIdSchema = z.enum([
   "devnet",
   "simulated"
 ]);
-var executionModeSchema = z.enum([
-  "simulated",
-  "real",
-  "readonly"
-]);
+var executionModeSchema = z.enum(["simulated", "real", "readonly"]);
 var artifactTypeSchema = z.enum([
   "txPlan",
   "signedTx",
@@ -1239,7 +1351,9 @@ var InvariantViolationError = class extends HardkasError {
   domain;
   severity;
   constructor(domain, message, options) {
-    super(`INVARIANT_VIOLATION_${domain.toUpperCase()}`, message, { cause: options?.cause });
+    super(`INVARIANT_VIOLATION_${domain.toUpperCase()}`, message, {
+      cause: options?.cause
+    });
     this.name = "InvariantViolationError";
     this.domain = domain;
     this.severity = options?.severity || "fatal";

package/package.json

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