@ricsam/r5d-worker 0.0.137 → 0.0.139

package/dist/cjs/workspace-projection-ledger.cjs

@@ -1,81 +0,0 @@
-"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 workspace_projection_ledger_exports = {};
-__export(workspace_projection_ledger_exports, {
-  WorkspaceProjectionLedger: () => WorkspaceProjectionLedger
-});
-module.exports = __toCommonJS(workspace_projection_ledger_exports);
-const RETAINED_OUTCOMES = /* @__PURE__ */ new Set(["no_change", "updated", "published", "large_diff_blocked"]);
-class WorkspaceProjectionLedger {
-  projectedTokens = /* @__PURE__ */ new Map();
-  lastCycle = null;
-  static recordKey(mount) {
-    return `${mount.hydrationIncarnationKey}\0${mount.id}`;
-  }
-  get lastCycleResult() {
-    return this.lastCycle;
-  }
-  lastProjectedToken(mount) {
-    return this.projectedTokens.get(WorkspaceProjectionLedger.recordKey(mount));
-  }
-  /**
-   * Record a completed cycle. `projectedMutationTokens` names the token each
-   * active mount carried when the cycle projected it; a mount absent from it
-   * keeps its earlier record. Any outcome that leaves the outer clone without
-   * a trustworthy projection clears the ledger.
-   */
-  recordCycle(input) {
-    if (!RETAINED_OUTCOMES.has(input.result.outcome)) {
-      this.reset();
-      return;
-    }
-    const mountsById = new Map(input.mounts.map((mount) => [mount.id, mount]));
-    for (const [mountId, token] of Object.entries(input.projectedMutationTokens ?? {})) {
-      const mount = mountsById.get(mountId);
-      if (mount) this.projectedTokens.set(WorkspaceProjectionLedger.recordKey(mount), token);
-    }
-    this.lastCycle = input.result;
-  }
-  reset() {
-    this.projectedTokens.clear();
-    this.lastCycle = null;
-  }
-  /**
-   * The previous cycle's result when every request targets a configured
-   * mount and no mount's token moved since its recorded projection. A request
-   * without a target (a workspace-rooted command may touch any checkout), a
-   * mount without a token (a pending deletion), or pending deletion work all
-   * require a real cycle.
-   */
-  answerFromLastCycle(input) {
-    if (!this.lastCycle || input.pendingDeletions || input.targetMountIds.length === 0) return null;
-    const mountIds = new Set(input.mounts.map(({ id }) => id));
-    if (!input.targetMountIds.every((mountId) => mountId !== null && mountIds.has(mountId))) return null;
-    for (const mount of input.mounts) {
-      if (!mount.mutationToken) return null;
-      const recorded = this.projectedTokens.get(WorkspaceProjectionLedger.recordKey(mount));
-      if (recorded === void 0 || recorded !== mount.mutationToken()) return null;
-    }
-    return this.lastCycle;
-  }
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  WorkspaceProjectionLedger
-});

package/dist/cjs/workspace-publication-evidence.cjs

@@ -1,46 +0,0 @@
-"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 workspace_publication_evidence_exports = {};
-__export(workspace_publication_evidence_exports, {
-  activeProjectBranchNames: () => activeProjectBranchNames,
-  activeProjectBranchPublicationEvidence: () => activeProjectBranchPublicationEvidence
-});
-module.exports = __toCommonJS(workspace_publication_evidence_exports);
-function projectBranchMountId(projectId, branchName) {
-  return `project:${projectId}:${encodeURIComponent(branchName)}`;
-}
-function activeProjectBranchNames(projectId, branchNames, activeMountIds) {
-  const active = new Set(activeMountIds);
-  return [...branchNames].filter((branchName) => active.has(projectBranchMountId(projectId, branchName))).sort((left, right) => left.localeCompare(right));
-}
-function activeProjectBranchPublicationEvidence(projects, activeMountIds) {
-  const active = new Set(activeMountIds);
-  return projects.flatMap(
-    (project) => project.executionDisabled || project.mirrorWritesDisabled ? [] : project.branches.flatMap(
-      (branch) => active.has(projectBranchMountId(project.projectId, branch.branchName)) ? [{ branchId: branch.branchId, projectId: project.projectId, branchName: branch.branchName }] : []
-    )
-  ).sort(
-    (left, right) => left.projectId.localeCompare(right.projectId) || left.branchName.localeCompare(right.branchName) || left.branchId.localeCompare(right.branchId)
-  );
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  activeProjectBranchNames,
-  activeProjectBranchPublicationEvidence
-});

package/dist/cjs/workspace-sync-coalescer.cjs

@@ -1,58 +0,0 @@
-"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 workspace_sync_coalescer_exports = {};
-__export(workspace_sync_coalescer_exports, {
-  WorkspaceSyncCoalescer: () => WorkspaceSyncCoalescer
-});
-module.exports = __toCommonJS(workspace_sync_coalescer_exports);
-class WorkspaceSyncCoalescer {
-  constructor(options) {
-    this.options = options;
-  }
-  options;
-  pendingBatch = null;
-  batchesStarted = 0;
-  /** Requests attached to the batch that has not started yet. */
-  get queuedRequestCount() {
-    return this.pendingBatch?.requests.length ?? 0;
-  }
-  /** Batches whose body has been entered, whether or not they ran a cycle. */
-  get startedBatchCount() {
-    return this.batchesStarted;
-  }
-  request(request) {
-    const queued = this.pendingBatch;
-    if (queued) {
-      queued.requests.push(request);
-      return queued.settlement;
-    }
-    const batch = { requests: [request], settlement: Promise.resolve() };
-    this.pendingBatch = batch;
-    batch.settlement = this.options.runExclusive(async () => {
-      if (this.pendingBatch === batch) this.pendingBatch = null;
-      this.batchesStarted += 1;
-      return await this.options.runBatch(batch.requests);
-    });
-    return batch.settlement;
-  }
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  WorkspaceSyncCoalescer
-});

package/dist/mjs/atomic-rename.mjs

@@ -1,261 +0,0 @@
-import fs from "node:fs";
-import os from "node:os";
-import path from "node:path";
-import { randomUUID } from "node:crypto";
-class AtomicRenameError extends Error {
-  constructor(syscall, code, errno, path2, dest) {
-    super(`${code}: ${syscall} failed, ${path2} -> ${dest}`);
-    this.syscall = syscall;
-    this.code = code;
-    this.errno = errno;
-    this.path = path2;
-    this.dest = dest;
-    this.name = "AtomicRenameError";
-  }
-  syscall;
-  code;
-  errno;
-  path;
-  dest;
-}
-const UNSUPPORTED_CODES = /* @__PURE__ */ new Set(["EINVAL", "ENOSYS", "ENOTSUP", "EOPNOTSUPP", "EPERM"]);
-function isAtomicRenameUnsupported(error) {
-  return error instanceof AtomicRenameError && UNSUPPORTED_CODES.has(error.code);
-}
-const LINUX_AT_FDCWD = -100;
-const LINUX_RENAME_NOREPLACE = 1;
-const LINUX_RENAME_EXCHANGE = 2;
-const DARWIN_RENAME_SWAP = 2;
-const DARWIN_RENAME_EXCL = 4;
-const LINUX_SYS_RENAMEAT2 = { x64: 316, arm64: 276 };
-const PROBE_PREFIX = ".r5d-atomic-rename-probe-";
-let loaded = null;
-let override = null;
-const errnoNames = /* @__PURE__ */ new Map();
-for (const [name, value] of Object.entries(os.constants.errno)) errnoNames.set(value, name);
-function errnoCode(errno) {
-  return errnoNames.get(errno) ?? `E${errno}`;
-}
-function cString(value) {
-  return Buffer.from(`${value}\0`, "utf8");
-}
-function loadNative() {
-  if (loaded) return loaded;
-  loaded = { calls: null, detail: "not attempted" };
-  try {
-    const ffi = require("bun:ffi");
-    const { dlopen, FFIType, ptr, read } = ffi;
-    if (process.platform === "darwin") {
-      const lib = dlopen("libSystem.B.dylib", {
-        renamex_np: { args: [FFIType.ptr, FFIType.ptr, FFIType.u32], returns: FFIType.i32 },
-        __error: { args: [], returns: FFIType.ptr }
-      });
-      loaded = {
-        calls: {
-          rename2: (from, to, flags) => {
-            const fromBuffer = cString(from);
-            const toBuffer = cString(to);
-            return lib.symbols.renamex_np(ptr(fromBuffer), ptr(toBuffer), flags);
-          },
-          errno: () => read.i32(lib.symbols.__error(), 0),
-          exchangeFlag: DARWIN_RENAME_SWAP,
-          noReplaceFlag: DARWIN_RENAME_EXCL,
-          backend: "renamex_np"
-        }
-      };
-      return loaded;
-    }
-    if (process.platform === "linux") {
-      const errnoLib = dlopen("libc.so.6", { __errno_location: { args: [], returns: FFIType.ptr } });
-      const errno = () => read.i32(errnoLib.symbols.__errno_location(), 0);
-      try {
-        const lib = dlopen("libc.so.6", {
-          renameat2: { args: [FFIType.i32, FFIType.ptr, FFIType.i32, FFIType.ptr, FFIType.u32], returns: FFIType.i32 }
-        });
-        loaded = {
-          calls: {
-            rename2: (from, to, flags) => {
-              const fromBuffer = cString(from);
-              const toBuffer = cString(to);
-              return lib.symbols.renameat2(LINUX_AT_FDCWD, ptr(fromBuffer), LINUX_AT_FDCWD, ptr(toBuffer), flags);
-            },
-            errno,
-            exchangeFlag: LINUX_RENAME_EXCHANGE,
-            noReplaceFlag: LINUX_RENAME_NOREPLACE,
-            backend: "renameat2"
-          }
-        };
-        return loaded;
-      } catch (error) {
-        const number = LINUX_SYS_RENAMEAT2[process.arch];
-        if (number === void 0) {
-          loaded = { calls: null, detail: `renameat2 symbol unavailable and no syscall number for ${process.arch}: ${String(error)}` };
-          return loaded;
-        }
-        const lib = dlopen("libc.so.6", {
-          syscall: {
-            args: [FFIType.i64, FFIType.i64, FFIType.i64, FFIType.i64, FFIType.i64, FFIType.i64],
-            returns: FFIType.i64
-          }
-        });
-        loaded = {
-          calls: {
-            rename2: (from, to, flags) => {
-              const fromBuffer = cString(from);
-              const toBuffer = cString(to);
-              return Number(
-                lib.symbols.syscall(number, LINUX_AT_FDCWD, Number(ptr(fromBuffer)), LINUX_AT_FDCWD, Number(ptr(toBuffer)), flags)
-              );
-            },
-            errno,
-            exchangeFlag: LINUX_RENAME_EXCHANGE,
-            noReplaceFlag: LINUX_RENAME_NOREPLACE,
-            backend: "syscall"
-          }
-        };
-        return loaded;
-      }
-    }
-    loaded = { calls: null, detail: `no atomic exchange primitive on ${process.platform}` };
-  } catch (error) {
-    loaded = { calls: null, detail: `bun:ffi unavailable: ${error instanceof Error ? error.message : String(error)}` };
-  }
-  return loaded;
-}
-function applyOverride(support) {
-  if (override?.exchange !== void 0) support.exchange = override.exchange;
-  if (override?.noReplace !== void 0) support.noReplace = override.noReplace;
-  return support;
-}
-function atomicRenameSupport() {
-  const native = loadNative();
-  return applyOverride(
-    native.calls ? { platform: process.platform, exchange: native.calls.backend, noReplace: native.calls.backend } : { platform: process.platform, exchange: "unavailable", noReplace: "link", detail: native.detail }
-  );
-}
-function overrideAtomicRenameSupportForTests(value) {
-  override = value;
-}
-function resetAtomicRenameProbesForTests() {
-  probes.clear();
-}
-function call(native, syscall, from, to, flags) {
-  if (native.rename2(from, to, flags) === 0) return;
-  const errno = native.errno();
-  throw new AtomicRenameError(syscall, errnoCode(errno), errno, from, to);
-}
-function exchangeWith(support, a, b) {
-  const native = loadNative().calls;
-  if (support.exchange === "unavailable" || !native) {
-    throw new AtomicRenameError("exchange", "ENOSYS", os.constants.errno.ENOSYS, a, b);
-  }
-  call(native, support.exchange, a, b, native.exchangeFlag);
-}
-function renameNoReplaceWith(support, from, to) {
-  const native = loadNative().calls;
-  if (support.noReplace !== "link" && native) {
-    call(native, support.noReplace, from, to, native.noReplaceFlag);
-    return;
-  }
-  const source = fs.lstatSync(from);
-  if (!source.isFile()) throw new AtomicRenameError("link", "ENOTSUP", os.constants.errno.ENOTSUP, from, to);
-  try {
-    fs.linkSync(from, to);
-  } catch (error) {
-    const code = error.code ?? "EIO";
-    throw new AtomicRenameError("link", code, error.errno ?? 0, from, to);
-  }
-  fs.unlinkSync(from);
-}
-function exchangePaths(a, b) {
-  exchangeWith(atomicRenameSupport(), a, b);
-}
-function renameNoReplace(from, to) {
-  renameNoReplaceWith(atomicRenameSupport(), from, to);
-}
-const probes = /* @__PURE__ */ new Map();
-function withoutTemporaries(directory, run) {
-  const token = randomUUID();
-  const a = path.join(directory, `${PROBE_PREFIX}${token}-a`);
-  const b = path.join(directory, `${PROBE_PREFIX}${token}-b`);
-  try {
-    run(a, b);
-  } finally {
-    fs.rmSync(a, { force: true });
-    fs.rmSync(b, { force: true });
-  }
-}
-function createProbeFile(filePath, content) {
-  const descriptor = fs.openSync(filePath, fs.constants.O_WRONLY | fs.constants.O_CREAT | fs.constants.O_EXCL, 384);
-  try {
-    fs.writeSync(descriptor, content);
-    return fs.fstatSync(descriptor);
-  } finally {
-    fs.closeSync(descriptor);
-  }
-}
-function probeAtomicRenameSupport(directory) {
-  const native = atomicRenameSupport();
-  const dev = fs.lstatSync(directory).dev;
-  const cached = probes.get(dev);
-  if (cached) return applyOverride({ ...cached });
-  const probed = { ...native };
-  if (native.exchange !== "unavailable") {
-    withoutTemporaries(directory, (a, b) => {
-      const statA = createProbeFile(a, "a");
-      const statB = createProbeFile(b, "b");
-      let swapped = false;
-      let detail;
-      try {
-        exchangeWith(native, a, b);
-        const afterA = fs.lstatSync(a);
-        const afterB = fs.lstatSync(b);
-        swapped = afterA.ino === statB.ino && afterB.ino === statA.ino;
-        if (!swapped) detail = `exchange flag ignored by the filesystem holding ${directory}`;
-      } catch (error) {
-        detail = `exchange rejected by the filesystem holding ${directory}: ${error instanceof Error ? error.message : String(error)}`;
-      }
-      if (!swapped) {
-        probed.exchange = "unavailable";
-        probed.detail = detail;
-      }
-    });
-  }
-  if (native.noReplace !== "link") {
-    withoutTemporaries(directory, (a, b) => {
-      createProbeFile(a, "a");
-      createProbeFile(b, "b");
-      let refused = false;
-      try {
-        renameNoReplaceWith(native, a, b);
-      } catch (error) {
-        refused = error instanceof AtomicRenameError && error.code === "EEXIST";
-      }
-      if (!refused) {
-        probed.noReplace = "link";
-        probed.detail = `${probed.detail ? `${probed.detail}; ` : ""}no-replace flag ignored by the filesystem holding ${directory}`;
-      }
-    });
-  }
-  probes.set(dev, probed);
-  return applyOverride({ ...probed });
-}
-function atomicRenamePrimitivesFor(directory) {
-  const support = probeAtomicRenameSupport(directory);
-  return {
-    support,
-    exchange: (a, b) => exchangeWith(support, a, b),
-    renameNoReplace: (from, to) => renameNoReplaceWith(support, from, to)
-  };
-}
-export {
-  AtomicRenameError,
-  atomicRenamePrimitivesFor,
-  atomicRenameSupport,
-  exchangePaths,
-  isAtomicRenameUnsupported,
-  overrideAtomicRenameSupportForTests,
-  probeAtomicRenameSupport,
-  renameNoReplace,
-  resetAtomicRenameProbesForTests
-};

package/dist/mjs/browser-upload.mjs

@@ -1,42 +0,0 @@
-import fs from "node:fs/promises";
-import { constants } from "node:fs";
-import os from "node:os";
-import path from "node:path";
-import {
-  BROWSER_UPLOAD_CHUNK_BYTES,
-  validateUploadFile
-} from "@ricsam/r5d-api/browser-upload";
-async function readBrowserUploadChunk(input, context) {
-  if (typeof input.filePath !== "string" || !input.filePath.trim() || input.filePath.includes("\0"))
-    throw new Error("Upload requires a file path.");
-  if (!Number.isSafeInteger(input.offset) || input.offset < 0) throw new Error("Invalid upload read offset.");
-  if (input.offset > 0 && !input.version) throw new Error("Upload continuation requires a file version.");
-  const expanded = input.filePath.replace(/\$\{R5D_ROOT\}|\$R5D_ROOT\b/g, () => context.rootDir).replace(/\$\{R5D_SESSION_ID\}|\$R5D_SESSION_ID\b/g, () => context.sessionId).replace(/^~\//, () => `${os.homedir()}/`);
-  const filePath = path.resolve(context.cwd, expanded);
-  const handle = await fs.open(filePath, constants.O_RDONLY | constants.O_NONBLOCK);
-  try {
-    const stat = await handle.stat({ bigint: true });
-    if (!stat.isFile()) throw new Error(`Upload source is not a regular file: ${input.filePath}`);
-    const metadata = validateUploadFile({ filename: path.basename(filePath), size: Number(stat.size) });
-    const versionOf = (s) => `${s.dev}:${s.ino}:${s.size}:${s.mtimeNs}:${s.ctimeNs}`;
-    const version = versionOf(stat);
-    if (input.version !== void 0 && input.version !== version)
-      throw new Error(`Upload source changed while being transferred: ${input.filePath}`);
-    if (input.offset > metadata.size) throw new Error("Upload offset is past the end of the file.");
-    const bytes = Buffer.alloc(input.metadataOnly === true ? 0 : Math.min(BROWSER_UPLOAD_CHUNK_BYTES, metadata.size - input.offset));
-    let read = 0;
-    while (read < bytes.length) {
-      const { bytesRead } = await handle.read(bytes, read, bytes.length - read, input.offset + read);
-      if (!bytesRead) throw new Error(`Upload source was truncated: ${input.filePath}`);
-      read += bytesRead;
-    }
-    if (versionOf(await handle.stat({ bigint: true })) !== version)
-      throw new Error(`Upload source changed while being read: ${input.filePath}`);
-    return { type: "browser_upload_read", ...metadata, version, offset: input.offset, base64: bytes.toString("base64") };
-  } finally {
-    await handle.close();
-  }
-}
-export {
-  readBrowserUploadChunk
-};