@ricsam/r5d-worker 0.0.137 → 0.0.139

package/dist/mjs/supervisor.mjs

@@ -1,114 +0,0 @@
-import { constants as osConstants } from "node:os";
-import { terminateProcessTree } from "./process-tree.mjs";
-const WORKER_RUNTIME_ENV = "R5D_WORKER_INTERNAL_RUNTIME";
-const WORKER_RELOAD_EXIT_CODE = 75;
-const WORKER_RECONNECT_EXIT_CODE = 76;
-const WORKER_CREDENTIAL_RESTART_EXIT_CODE = 77;
-const WORKER_RECONNECT_DELAY_MS = 2e3;
-const WORKER_RECONNECT_JITTER_MS = 3e3;
-const WORKER_RECONNECT_MAX_DELAY_MS = 3e4;
-const SUPERVISOR_SIGNALS = ["SIGINT", "SIGTERM", "SIGHUP"];
-function defaultRuntimeSpawner(argv, options) {
-  return Bun.spawn(argv, options);
-}
-function defaultRuntimeDelay(delayMs) {
-  return new Promise((resolve) => setTimeout(resolve, delayMs));
-}
-function workerReconnectDelayMs(random = Math.random, attempt = 0) {
-  const sample = Math.max(0, Math.min(1, random()));
-  const exponent = Math.min(20, Math.max(0, Math.floor(attempt)));
-  const ceiling = Math.min(WORKER_RECONNECT_MAX_DELAY_MS, (WORKER_RECONNECT_DELAY_MS + WORKER_RECONNECT_JITTER_MS) * 2 ** exponent);
-  const floor = Math.min(WORKER_RECONNECT_DELAY_MS * 2 ** exponent, ceiling * 0.4);
-  return floor + Math.floor(sample * (ceiling - floor));
-}
-async function defaultRuntimeReaper(runtime) {
-  await terminateProcessTree(runtime, { graceMs: 6e3 });
-}
-function isRetryableWorkerServerStatus(status) {
-  return status === 408 || status === 429 || status >= 500;
-}
-function signalExitCode(signal) {
-  return 128 + (osSignalNumber(signal) ?? 1);
-}
-function osSignalNumber(signal) {
-  return osConstants.signals[signal];
-}
-async function superviseWorkerRuntime(argv, env = process.env, spawnRuntime = defaultRuntimeSpawner, waitBeforeReconnect = defaultRuntimeDelay, reapCredentialRuntime = defaultRuntimeReaper, reconnectDelay) {
-  if (!process.argv[1]) {
-    throw new Error("Cannot locate the r5d-worker entrypoint");
-  }
-  let reconnectAttempt = 0;
-  while (true) {
-    const runtime = spawnRuntime([process.execPath, process.argv[1], ...argv], {
-      stdin: "inherit",
-      stdout: "inherit",
-      stderr: "inherit",
-      detached: true,
-      env: {
-        ...env,
-        [WORKER_RUNTIME_ENV]: "1"
-      }
-    });
-    let receivedSignal;
-    let resolveSignal;
-    const signalReceived = new Promise((resolve) => {
-      resolveSignal = resolve;
-    });
-    const handlers = SUPERVISOR_SIGNALS.map((signal) => {
-      const handler = () => {
-        if (receivedSignal) return;
-        receivedSignal = signal;
-        resolveSignal?.(signal);
-      };
-      process.on(signal, handler);
-      return { signal, handler };
-    });
-    try {
-      const outcome = await Promise.race([
-        runtime.exited.then((exitCode2) => ({ type: "exit", exitCode: exitCode2 })),
-        signalReceived.then((signal) => ({ type: "signal", signal }))
-      ]);
-      try {
-        await reapCredentialRuntime(runtime);
-      } catch (error) {
-        process.stderr.write(
-          `[r5d-worker] runtime restart/exit aborted because process-group reaping failed: ${error instanceof Error ? error.message : String(error)}
-`
-        );
-        return 1;
-      }
-      if (outcome.type === "signal" || receivedSignal) {
-        return signalExitCode(outcome.type === "signal" ? outcome.signal : receivedSignal);
-      }
-      const { exitCode } = outcome;
-      if (exitCode === WORKER_RELOAD_EXIT_CODE) {
-        process.stdout.write("[r5d-worker] activating updated worker runtime\n");
-        continue;
-      }
-      if (exitCode === WORKER_RECONNECT_EXIT_CODE) {
-        const reconnectDelayMs = reconnectDelay?.() ?? workerReconnectDelayMs(Math.random, reconnectAttempt++);
-        process.stderr.write(`[r5d-worker] reconnecting in ${reconnectDelayMs}ms
-`);
-        await waitBeforeReconnect(reconnectDelayMs);
-        if (receivedSignal) return signalExitCode(receivedSignal);
-        continue;
-      }
-      return exitCode;
-    } finally {
-      const processEvents = process;
-      for (const { signal, handler } of handlers) processEvents.off(signal, handler);
-    }
-  }
-}
-export {
-  WORKER_CREDENTIAL_RESTART_EXIT_CODE,
-  WORKER_RECONNECT_DELAY_MS,
-  WORKER_RECONNECT_EXIT_CODE,
-  WORKER_RECONNECT_JITTER_MS,
-  WORKER_RECONNECT_MAX_DELAY_MS,
-  WORKER_RELOAD_EXIT_CODE,
-  WORKER_RUNTIME_ENV,
-  isRetryableWorkerServerStatus,
-  superviseWorkerRuntime,
-  workerReconnectDelayMs
-};

package/dist/mjs/three-way-merge.mjs

@@ -1,318 +0,0 @@
-const BINARY_PROBE_BYTES = 8e3;
-const DEFAULT_MAX_LINES = 1e6;
-const DEFAULT_MAX_EDIT_DISTANCE = 2e4;
-const DEFAULT_MAX_ALIGNMENT_CELLS = 1e8;
-const DEFAULT_MAX_DIFF_WORK = 5e7;
-const NEWLINE = 10;
-const NO_COMMON_LINES = /* @__PURE__ */ Symbol("no-common-lines");
-function isBinaryContent(content) {
-  return content.subarray(0, BINARY_PROBE_BYTES).includes(0);
-}
-class LineTable {
-  ids = /* @__PURE__ */ new Map();
-  lines = [];
-  intern(line) {
-    const key = line.toString("latin1");
-    let id = this.ids.get(key);
-    if (id === void 0) {
-      id = this.lines.length;
-      this.ids.set(key, id);
-      this.lines.push(line);
-    }
-    return id;
-  }
-}
-function splitLines(content, table, maxLines) {
-  let count = 0;
-  for (let offset = 0; offset < content.length; ) {
-    const newline = content.indexOf(NEWLINE, offset);
-    count += 1;
-    if (count > maxLines) return null;
-    offset = newline < 0 ? content.length : newline + 1;
-  }
-  const ids = new Int32Array(count);
-  let index = 0;
-  for (let offset = 0; offset < content.length; ) {
-    const newline = content.indexOf(NEWLINE, offset);
-    const end = newline < 0 ? content.length : newline + 1;
-    ids[index] = table.intern(content.subarray(offset, end));
-    index += 1;
-    offset = end;
-  }
-  return ids;
-}
-function findSplit(a, a0, a1, b, b0, b1, forward, backward, maxEditDistance, budget) {
-  const n = a1 - a0;
-  const m = b1 - b0;
-  const maxD = Math.ceil((n + m) / 2);
-  const offset = maxD;
-  const length = 2 * maxD + 2;
-  forward.fill(-1, 0, length);
-  backward.fill(-1, 0, length);
-  forward[offset + 1] = 0;
-  backward[offset + 1] = 0;
-  const delta = n - m;
-  const meetOnForward = (delta & 1) !== 0;
-  let forwardStart = 0;
-  let forwardEnd = 0;
-  let backwardStart = 0;
-  let backwardEnd = 0;
-  for (let d = 0; d < maxD; d += 1) {
-    if (2 * d > maxEditDistance) return null;
-    budget.remaining -= 2 * (2 * d + 1);
-    if (budget.remaining < 0) return null;
-    for (let k = -d + forwardStart; k <= d - forwardEnd; k += 2) {
-      const kIndex = offset + k;
-      let x = k === -d || k !== d && forward[kIndex - 1] < forward[kIndex + 1] ? forward[kIndex + 1] : forward[kIndex - 1] + 1;
-      let y = x - k;
-      const snakeStart = x;
-      while (x < n && y < m && a[a0 + x] === b[b0 + y]) {
-        x += 1;
-        y += 1;
-      }
-      budget.remaining -= x - snakeStart;
-      forward[kIndex] = x;
-      if (x > n) forwardEnd += 2;
-      else if (y > m) forwardStart += 2;
-      else if (meetOnForward) {
-        const reverseIndex = offset + delta - k;
-        if (reverseIndex >= 0 && reverseIndex < length && backward[reverseIndex] !== -1 && x >= n - backward[reverseIndex]) {
-          return [a0 + x, b0 + y];
-        }
-      }
-    }
-    for (let k = -d + backwardStart; k <= d - backwardEnd; k += 2) {
-      const kIndex = offset + k;
-      let x = k === -d || k !== d && backward[kIndex - 1] < backward[kIndex + 1] ? backward[kIndex + 1] : backward[kIndex - 1] + 1;
-      let y = x - k;
-      const snakeStart = x;
-      while (x < n && y < m && a[a1 - x - 1] === b[b1 - y - 1]) {
-        x += 1;
-        y += 1;
-      }
-      budget.remaining -= x - snakeStart;
-      backward[kIndex] = x;
-      if (x > n) backwardEnd += 2;
-      else if (y > m) backwardStart += 2;
-      else if (!meetOnForward) {
-        const forwardIndex = offset + delta - k;
-        if (forwardIndex >= 0 && forwardIndex < length && forward[forwardIndex] !== -1) {
-          const forwardX = forward[forwardIndex];
-          if (forwardX >= n - x) return [a0 + forwardX, b0 + forwardX - (forwardIndex - offset)];
-        }
-      }
-    }
-  }
-  return n + m > maxEditDistance ? null : NO_COMMON_LINES;
-}
-function diffLines(a, b, options = {}) {
-  const maxEditDistance = options.maxEditDistance ?? DEFAULT_MAX_EDIT_DISTANCE;
-  if (maxEditDistance < 0) return null;
-  const budget = { remaining: options.maxWork ?? DEFAULT_MAX_DIFF_WORK };
-  const scratchLength = a.length + b.length + 4;
-  const forward = new Int32Array(scratchLength);
-  const backward = new Int32Array(scratchLength);
-  const hunks = [];
-  const stack = [0, a.length, 0, b.length];
-  let topLevel = true;
-  while (stack.length > 0) {
-    let b1 = stack.pop();
-    let b0 = stack.pop();
-    let a1 = stack.pop();
-    let a0 = stack.pop();
-    while (a0 < a1 && b0 < b1 && a[a0] === b[b0]) {
-      a0 += 1;
-      b0 += 1;
-    }
-    while (a0 < a1 && b0 < b1 && a[a1 - 1] === b[b1 - 1]) {
-      a1 -= 1;
-      b1 -= 1;
-    }
-    if (a0 === a1 && b0 === b1) continue;
-    let noCommonLines = a0 === a1 || b0 === b1;
-    if (!noCommonLines && topLevel) {
-      const seen = /* @__PURE__ */ new Set();
-      for (let index = a0; index < a1; index += 1) seen.add(a[index]);
-      noCommonLines = true;
-      for (let index = b0; index < b1; index += 1) {
-        if (seen.has(b[index])) {
-          noCommonLines = false;
-          break;
-        }
-      }
-      if (noCommonLines && a1 - a0 + (b1 - b0) > maxEditDistance) return null;
-    }
-    topLevel = false;
-    const split = noCommonLines ? NO_COMMON_LINES : findSplit(a, a0, a1, b, b0, b1, forward, backward, maxEditDistance, budget);
-    if (split === null) return null;
-    if (split === NO_COMMON_LINES) {
-      const previous = hunks[hunks.length - 1];
-      if (previous && previous.aEnd === a0 && previous.bEnd === b0) {
-        previous.aEnd = a1;
-        previous.bEnd = b1;
-      } else hunks.push({ aStart: a0, aEnd: a1, bStart: b0, bEnd: b1 });
-      continue;
-    }
-    stack.push(split[0], a1, split[1], b1, a0, split[0], b0, split[1]);
-  }
-  return hunks;
-}
-function analyzeAlignment(a, b, lcsLength, maxCells) {
-  const n = a.length;
-  const m = b.length;
-  const kMin = lcsLength - m;
-  const kMax = n - lcsLength;
-  const width = kMax - kMin + 1;
-  const certain = new Int32Array(n).fill(-1);
-  const ambiguous = new Uint8Array(n);
-  if (n === 0) return { certain, ambiguous };
-  if ((n + 1) * width > maxCells) return null;
-  const computeSuffixRow = (i, next, out) => {
-    for (let index = width - 1; index >= 0; index -= 1) {
-      const j = i - kMax + index;
-      if (j < 0 || j >= m) {
-        out[index] = 0;
-        continue;
-      }
-      const down = index > 0 ? next[index - 1] : 0;
-      const right = index + 1 < width ? out[index + 1] : 0;
-      const diagonal = next[index] + (a[i] === b[j] ? 1 : 0);
-      out[index] = down > right ? down > diagonal ? down : diagonal : right > diagonal ? right : diagonal;
-    }
-  };
-  const computePrefixRow = (i, previous, out) => {
-    for (let index = 0; index < width; index += 1) {
-      const j = i - kMax + index;
-      if (j <= 0 || j > m || i === 0) {
-        out[index] = 0;
-        continue;
-      }
-      const up = index + 1 < width ? previous[index + 1] : 0;
-      const left = index > 0 ? out[index - 1] : 0;
-      const diagonal = previous[index] + (a[i - 1] === b[j - 1] ? 1 : 0);
-      out[index] = up > left ? up > diagonal ? up : diagonal : left > diagonal ? left : diagonal;
-    }
-  };
-  const blockSize = Math.ceil(Math.sqrt(n + 1));
-  const checkpoints = /* @__PURE__ */ new Map();
-  let suffixNext = new Int32Array(width);
-  let suffixCurrent = new Int32Array(width);
-  checkpoints.set(n, new Int32Array(width));
-  for (let i = n - 1; i >= 0; i -= 1) {
-    computeSuffixRow(i, suffixNext, suffixCurrent);
-    if (i % blockSize === 0) checkpoints.set(i, suffixCurrent.slice());
-    [suffixNext, suffixCurrent] = [suffixCurrent, suffixNext];
-  }
-  const block = Array.from({ length: blockSize + 1 }, () => new Int32Array(width));
-  let prefixPrevious = new Int32Array(width);
-  let prefixCurrent = new Int32Array(width);
-  for (let blockStart = 0; blockStart < n; blockStart += blockSize) {
-    const blockEnd = Math.min(blockStart + blockSize, n);
-    block[blockEnd - blockStart] = checkpoints.get(blockEnd);
-    for (let i = blockEnd - 1; i > blockStart; i -= 1) computeSuffixRow(i, block[i + 1 - blockStart], block[i - blockStart]);
-    for (let i = blockStart; i < blockEnd; i += 1) {
-      computePrefixRow(i, prefixPrevious, prefixCurrent);
-      const suffix = block[i + 1 - blockStart];
-      let bestDeletion = 0;
-      let matches = 0;
-      let partner = -1;
-      for (let index = 0; index < width; index += 1) {
-        const j = i - kMax + index;
-        if (j < 0 || j > m) continue;
-        const prefix = prefixCurrent[index];
-        const deleted = prefix + (index > 0 ? suffix[index - 1] : 0);
-        if (deleted > bestDeletion) bestDeletion = deleted;
-        if (j < m && a[i] === b[j] && prefix + 1 + suffix[index] === lcsLength) {
-          matches += 1;
-          partner = j;
-        }
-      }
-      if (matches === 1 && bestDeletion < lcsLength) certain[i] = partner;
-      else if (matches > 0) ambiguous[i] = 1;
-      [prefixPrevious, prefixCurrent] = [prefixCurrent, prefixPrevious];
-    }
-  }
-  return { certain, ambiguous };
-}
-function rangesEqual(a, aStart, aEnd, b, bStart, bEnd) {
-  if (aEnd - aStart !== bEnd - bStart) return false;
-  for (let offset = 0; offset < aEnd - aStart; offset += 1) {
-    if (a[aStart + offset] !== b[bStart + offset]) return false;
-  }
-  return true;
-}
-function anyAmbiguous(flags, start, end) {
-  for (let index = start; index < end; index += 1) if (flags[index]) return true;
-  return false;
-}
-function sideAlignment(base, side, options) {
-  const maxEditDistance = Math.min(options.maxEditDistance, Math.floor(options.maxAlignmentCells / (base.length + 1)) - 1);
-  const hunks = diffLines(base, side, { maxEditDistance, maxWork: options.maxDiffWork });
-  if (!hunks) return null;
-  let deleted = 0;
-  for (const hunk of hunks) deleted += hunk.aEnd - hunk.aStart;
-  return analyzeAlignment(base, side, base.length - deleted, options.maxAlignmentCells);
-}
-function mergeThreeWay(base, ours, theirs, options = {}) {
-  if (ours.equals(base)) return { kind: "clean", content: theirs };
-  if (theirs.equals(base)) return { kind: "clean", content: ours };
-  if (ours.equals(theirs)) return { kind: "clean", content: ours };
-  if (isBinaryContent(base) || isBinaryContent(ours) || isBinaryContent(theirs)) return { kind: "conflict", conflicts: 1 };
-  const maxLines = options.maxLines ?? DEFAULT_MAX_LINES;
-  const bounds = {
-    maxEditDistance: options.maxEditDistance ?? DEFAULT_MAX_EDIT_DISTANCE,
-    maxAlignmentCells: options.maxAlignmentCells ?? DEFAULT_MAX_ALIGNMENT_CELLS,
-    maxDiffWork: options.maxDiffWork ?? DEFAULT_MAX_DIFF_WORK
-  };
-  const table = new LineTable();
-  const baseLines = splitLines(base, table, maxLines);
-  const oursLines = splitLines(ours, table, maxLines);
-  const theirsLines = splitLines(theirs, table, maxLines);
-  if (!baseLines || !oursLines || !theirsLines) return { kind: "conflict", conflicts: 1 };
-  const oursAlignment = sideAlignment(baseLines, oursLines, bounds);
-  const theirsAlignment = sideAlignment(baseLines, theirsLines, bounds);
-  if (!oursAlignment || !theirsAlignment) return { kind: "conflict", conflicts: 1 };
-  const oursMatch = oursAlignment.certain;
-  const theirsMatch = theirsAlignment.certain;
-  const output = [];
-  let conflicts = 0;
-  let i = 0;
-  let o = 0;
-  let t = 0;
-  for (; ; ) {
-    while (i < baseLines.length && oursMatch[i] === o && theirsMatch[i] === t) {
-      output.push(table.lines[baseLines[i]]);
-      i += 1;
-      o += 1;
-      t += 1;
-    }
-    if (i === baseLines.length && o === oursLines.length && t === theirsLines.length) break;
-    let j = i;
-    while (j < baseLines.length && (oursMatch[j] < 0 || theirsMatch[j] < 0)) j += 1;
-    const oursEnd = j < baseLines.length ? oursMatch[j] : oursLines.length;
-    const theirsEnd = j < baseLines.length ? theirsMatch[j] : theirsLines.length;
-    if (rangesEqual(baseLines, i, j, oursLines, o, oursEnd)) {
-      for (let index = t; index < theirsEnd; index += 1) output.push(table.lines[theirsLines[index]]);
-    } else if (rangesEqual(baseLines, i, j, theirsLines, t, theirsEnd)) {
-      for (let index = o; index < oursEnd; index += 1) output.push(table.lines[oursLines[index]]);
-    } else if (rangesEqual(oursLines, o, oursEnd, theirsLines, t, theirsEnd) && // Git compares its hunks, not the region text: the same text reached by
-    // differently shaped hunks still conflicts there, so only a region whose
-    // alignment is unique on both sides is safely the same change.
-    !anyAmbiguous(oursAlignment.ambiguous, i, j) && !anyAmbiguous(theirsAlignment.ambiguous, i, j)) {
-      for (let index = o; index < oursEnd; index += 1) output.push(table.lines[oursLines[index]]);
-    } else conflicts += 1;
-    i = j;
-    o = oursEnd;
-    t = theirsEnd;
-  }
-  if (conflicts > 0) return { kind: "conflict", conflicts };
-  return { kind: "clean", content: Buffer.concat(output) };
-}
-const threeWayMergeTestHarness = { diffLines, analyzeAlignment };
-export {
-  analyzeAlignment,
-  diffLines,
-  isBinaryContent,
-  mergeThreeWay,
-  threeWayMergeTestHarness
-};