@ricsam/r5d-worker 0.0.123 → 0.0.125

package/dist/cjs/recovery-journal-runtime.cjs

@@ -0,0 +1,133 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var recovery_journal_runtime_exports = {};
+__export(recovery_journal_runtime_exports, {
+  serveRecoveryJournal: () => serveRecoveryJournal
+});
+module.exports = __toCommonJS(recovery_journal_runtime_exports);
+var import_recovery_journal_protocol = require("./recovery-journal-protocol.cjs");
+var import_recovery_store = require("./recovery-store.cjs");
+function serveRecoveryJournal(port, filename, hooks = {}) {
+  const store = new import_recovery_store.WorkerRecoveryStore(filename);
+  const outputReplays = /* @__PURE__ */ new Map();
+  let nextReplayId = 1;
+  function runOp(op, args) {
+    switch (op) {
+      case "admit": {
+        const message = args[0];
+        const admission = store.admit(message);
+        return {
+          admission,
+          response: admission === "new" ? void 0 : store.response(message.requestId),
+          cancelled: store.isRequestCancelled(message.requestId)
+        };
+      }
+      case "readmitUnknownBranchDeletion":
+        return store.readmitUnknownBranchDeletion(args[0]);
+      case "record": {
+        const message = args[0];
+        if (typeof message.requestId === "string" && store.isUnknown(message.requestId)) return { suppressed: true, recorded: message };
+        return { suppressed: false, recorded: store.record(message) };
+      }
+      case "unknown":
+        store.unknown(args[0]);
+        return null;
+      case "unknownRun":
+        store.unknownRun(args[0]);
+        return null;
+      case "acknowledgeResult":
+        store.acknowledgeResult(args[0]);
+        return null;
+      case "acknowledgeOutput":
+        store.acknowledgeOutput(args[0], args[1], args[2]);
+        return null;
+      case "acknowledgeTerminal":
+        store.acknowledgeTerminal(args[0]);
+        return null;
+      case "cancelSession":
+        store.cancelSession(args[0]);
+        return null;
+      case "isRequestCancelled":
+        return store.isRequestCancelled(args[0]);
+      case "operations":
+        return store.operations();
+      case "recoveryState": {
+        const requests = args[0];
+        return {
+          operations: store.operations(),
+          cursors: store.outputCursors(),
+          responses: store.responses(requests),
+          terminals: store.terminals()
+        };
+      }
+      case "terminals":
+        return store.terminals();
+      case "outputReplayBegin": {
+        const replayId = nextReplayId++;
+        outputReplays.set(replayId, store.output(args[0]));
+        return replayId;
+      }
+      case "outputReplayNext": {
+        const replay = outputReplays.get(args[0]);
+        if (!replay) return { frames: [], done: true };
+        const maxFrames = args[1];
+        const frames = [];
+        while (frames.length < maxFrames) {
+          const next = replay.next();
+          if (next.done) {
+            outputReplays.delete(args[0]);
+            return { frames, done: true };
+          }
+          frames.push(next.value);
+        }
+        return { frames, done: false };
+      }
+      case "outputReplayEnd":
+        outputReplays.delete(args[0]);
+        return null;
+    }
+  }
+  port.on("message", (message) => {
+    if (!message || typeof message !== "object") return;
+    const request = message;
+    if (request.type !== "batch" || typeof request.id !== "number" || !Array.isArray(request.entries)) return;
+    const entries = request.entries;
+    try {
+      hooks.beforeBatch?.();
+      const results = store.batch(
+        () => entries.map((entry) => {
+          if (!(0, import_recovery_journal_protocol.isWorkerRecoveryJournalOp)(entry.op)) throw new Error(`Unknown recovery journal operation: ${String(entry.op)}`);
+          return { seq: entry.seq, value: runOp(entry.op, entry.args) };
+        })
+      );
+      port.postMessage({ type: "batch_result", id: request.id, results });
+    } catch (error) {
+      port.postMessage({
+        type: "batch_failure",
+        id: request.id,
+        error: (0, import_recovery_journal_protocol.serializeWorkerRecoveryJournalError)(error)
+      });
+    }
+  });
+  port.postMessage({ type: "ready", ledgerId: store.ledgerId });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  serveRecoveryJournal
+});

package/dist/cjs/recovery-journal-thread.cjs

@@ -0,0 +1,9 @@
+"use strict";
+var import_node_worker_threads = require("node:worker_threads");
+var import_recovery_journal_runtime = require("./recovery-journal-runtime.cjs");
+if (import_node_worker_threads.isMainThread || !import_node_worker_threads.parentPort) {
+  throw new Error("The recovery journal thread must be started by the worker runtime");
+}
+const data = import_node_worker_threads.workerData;
+if (!data || typeof data.filename !== "string" || !data.filename) throw new Error("The recovery journal thread needs a store filename");
+(0, import_recovery_journal_runtime.serveRecoveryJournal)(import_node_worker_threads.parentPort, data.filename);