@ricsam/r5d-worker 0.0.136 → 0.0.138

package/dist/mjs/pty-output-coalescer.mjs

@@ -1,61 +0,0 @@
-const DEFAULT_PTY_OUTPUT_FLUSH_INTERVAL_MS = 8;
-const DEFAULT_PTY_OUTPUT_MAX_BUFFER_BYTES = 64 * 1024;
-function defaultSchedule(callback, delayMs) {
-  const timer = setTimeout(callback, delayMs);
-  timer.unref();
-  return () => clearTimeout(timer);
-}
-function createPtyOutputCoalescer(options) {
-  const flushIntervalMs = options.flushIntervalMs ?? DEFAULT_PTY_OUTPUT_FLUSH_INTERVAL_MS;
-  const maxBufferBytes = options.maxBufferBytes ?? DEFAULT_PTY_OUTPUT_MAX_BUFFER_BYTES;
-  const now = options.now ?? Date.now;
-  const schedule = options.schedule ?? defaultSchedule;
-  let buffer = "";
-  let bufferedBytes = 0;
-  let cancelScheduledFlush = null;
-  let lastSendAt = Number.NEGATIVE_INFINITY;
-  const sendNow = (data) => {
-    lastSendAt = now();
-    options.send(data);
-  };
-  const flush = () => {
-    if (cancelScheduledFlush) {
-      cancelScheduledFlush();
-      cancelScheduledFlush = null;
-    }
-    if (bufferedBytes === 0) {
-      return;
-    }
-    const data = buffer;
-    buffer = "";
-    bufferedBytes = 0;
-    sendNow(data);
-  };
-  const push = (data) => {
-    if (data.length === 0) {
-      return;
-    }
-    if (bufferedBytes === 0 && now() - lastSendAt >= flushIntervalMs) {
-      sendNow(data);
-      return;
-    }
-    buffer += data;
-    bufferedBytes += Buffer.byteLength(data, "utf8");
-    if (bufferedBytes >= maxBufferBytes) {
-      flush();
-      return;
-    }
-    if (!cancelScheduledFlush) {
-      cancelScheduledFlush = schedule(() => {
-        cancelScheduledFlush = null;
-        flush();
-      }, flushIntervalMs);
-    }
-  };
-  return { push, flush };
-}
-export {
-  DEFAULT_PTY_OUTPUT_FLUSH_INTERVAL_MS,
-  DEFAULT_PTY_OUTPUT_MAX_BUFFER_BYTES,
-  createPtyOutputCoalescer
-};

package/dist/mjs/recovery-journal-protocol.mjs

@@ -1,30 +0,0 @@
-const WORKER_RECOVERY_JOURNAL_OPS = [
-  "admit",
-  "readmitUnknownBranchDeletion",
-  "record",
-  "unknown",
-  "unknownRun",
-  "acknowledgeResult",
-  "acknowledgeOutput",
-  "acknowledgeTerminal",
-  "cancelSession",
-  "isRequestCancelled",
-  "operations",
-  "recoveryState",
-  "terminals",
-  "outputReplayBegin",
-  "outputReplayNext",
-  "outputReplayEnd"
-];
-function isWorkerRecoveryJournalOp(value) {
-  return typeof value === "string" && WORKER_RECOVERY_JOURNAL_OPS.includes(value);
-}
-function serializeWorkerRecoveryJournalError(error) {
-  if (!(error instanceof Error)) return { name: "Error", message: String(error) };
-  return { name: error.name, message: error.message, ...typeof error.stack === "string" ? { stack: error.stack } : {} };
-}
-export {
-  WORKER_RECOVERY_JOURNAL_OPS,
-  isWorkerRecoveryJournalOp,
-  serializeWorkerRecoveryJournalError
-};

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

@@ -1,112 +0,0 @@
-import {
-  isWorkerRecoveryJournalOp,
-  serializeWorkerRecoveryJournalError
-} from "./recovery-journal-protocol.mjs";
-import { WorkerRecoveryStore } from "./recovery-store.mjs";
-function serveRecoveryJournal(port, filename, hooks = {}) {
-  const store = new 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 (!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: serializeWorkerRecoveryJournalError(error)
-      });
-    }
-  });
-  port.postMessage({ type: "ready", ledgerId: store.ledgerId });
-}
-export {
-  serveRecoveryJournal
-};

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

@@ -1,8 +0,0 @@
-import { isMainThread, parentPort, workerData } from "node:worker_threads";
-import { serveRecoveryJournal } from "./recovery-journal-runtime.mjs";
-if (isMainThread || !parentPort) {
-  throw new Error("The recovery journal thread must be started by the worker runtime");
-}
-const data = workerData;
-if (!data || typeof data.filename !== "string" || !data.filename) throw new Error("The recovery journal thread needs a store filename");
-serveRecoveryJournal(parentPort, data.filename);