@ricsam/r5d-worker 0.0.123 → 0.0.125

package/dist/cjs/workspace-mount-hold-fence.cjs

@@ -0,0 +1,120 @@
+"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_mount_hold_fence_exports = {};
+__export(workspace_mount_hold_fence_exports, {
+  WorkspaceMountHoldAbortedError: () => WorkspaceMountHoldAbortedError,
+  WorkspaceMountHoldFence: () => WorkspaceMountHoldFence
+});
+module.exports = __toCommonJS(workspace_mount_hold_fence_exports);
+class WorkspaceMountHoldAbortedError extends Error {
+  constructor(reason) {
+    super(reason);
+    this.name = "WorkspaceMountHoldAbortedError";
+  }
+}
+class WorkspaceMountHoldFence {
+  holds = /* @__PURE__ */ new Map();
+  waiters = /* @__PURE__ */ new Set();
+  now;
+  constructor(options = {}) {
+    this.now = options.now ?? (() => Date.now());
+  }
+  /** Take one hold on every listed mount; the returned release is idempotent. */
+  hold(mountIds, description) {
+    const ids = [...new Set(mountIds)];
+    for (const id of ids) {
+      const existing = this.holds.get(id);
+      if (existing) {
+        existing.count += 1;
+        continue;
+      }
+      this.holds.set(id, { count: 1, description, sinceMs: this.now() });
+    }
+    let released = false;
+    return () => {
+      if (released) return;
+      released = true;
+      for (const id of ids) {
+        const existing = this.holds.get(id);
+        if (!existing) continue;
+        existing.count -= 1;
+        if (existing.count === 0) this.holds.delete(id);
+      }
+      this.wake();
+    };
+  }
+  isHeld(mountIds) {
+    return mountIds.some((id) => this.holds.has(id));
+  }
+  /** Human-readable holder of the first held mount among `mountIds`, for diagnostics. */
+  describeHold(mountIds) {
+    for (const id of mountIds) {
+      const hold = this.holds.get(id);
+      if (hold) return `${hold.description} (held for ${Math.round((this.now() - hold.sinceMs) / 1e3)}s)`;
+    }
+    return null;
+  }
+  /** Every held mount id, sorted, for status reporting. */
+  heldMountIds() {
+    return [...this.holds.keys()].sort();
+  }
+  /**
+   * Resolves in the same turn as the release that leaves none of `mountIds`
+   * held, so the caller can re-check and reserve without an interleaving
+   * hold. Resolves immediately when nothing is held. Rejects with
+   * WorkspaceMountHoldAbortedError when `signal` aborts first.
+   */
+  waitForRelease(mountIds, options = {}) {
+    if (options.signal?.aborted) {
+      return Promise.reject(new WorkspaceMountHoldAbortedError(abortReason(options.signal)));
+    }
+    if (!this.isHeld(mountIds)) return Promise.resolve();
+    return new Promise((resolve, reject) => {
+      const waiter = { mountIds, resolve, reject, signal: options.signal };
+      if (options.signal) {
+        const signal = options.signal;
+        waiter.onAbort = () => {
+          this.waiters.delete(waiter);
+          reject(new WorkspaceMountHoldAbortedError(abortReason(signal)));
+        };
+        signal.addEventListener("abort", waiter.onAbort, { once: true });
+      }
+      this.waiters.add(waiter);
+    });
+  }
+  wake() {
+    for (const waiter of [...this.waiters]) {
+      if (this.isHeld(waiter.mountIds)) continue;
+      this.waiters.delete(waiter);
+      if (waiter.signal && waiter.onAbort) waiter.signal.removeEventListener("abort", waiter.onAbort);
+      waiter.resolve();
+    }
+  }
+}
+function abortReason(signal) {
+  const reason = signal.reason;
+  if (reason instanceof Error) return reason.message;
+  if (typeof reason === "string" && reason) return reason;
+  return "Workspace mount reservation was aborted";
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  WorkspaceMountHoldAbortedError,
+  WorkspaceMountHoldFence
+});

package/dist/mjs/command-launcher.mjs

@@ -216,7 +216,9 @@ class WorkerCommandLauncher {
         if (!argv.length) throw new Error("Command argv must not be empty");
         return [...prefix, ...argv];
       },
-      cancel: () => this.cancel(request.id),
+      cancel: async () => {
+        await this.cancel(request.id);
+      },
       diagnose: async () => {
         this.assertHealthy();
         if (!this.child) return void 0;
@@ -232,9 +234,10 @@ class WorkerCommandLauncher {
       release: () => this.releaseRecord(record)
     };
   }
+  /** Revoke a launch. Returns whether this launcher still held it (queued or acquired, not yet released). */
   async cancel(id) {
     const record = this.launches.get(id);
-    if (!record || record.released) return;
+    if (!record || record.released) return false;
     record.revoked = true;
     record.rejectAdmission(new CommandLaunchCancelledError());
     if (this.child) {
@@ -244,6 +247,7 @@ class WorkerCommandLauncher {
         throw this.fail(error instanceof Error ? error : new Error(String(error)));
       }
     }
+    return true;
   }
   async cancelSession(sessionId) {
     await this.cancelMatching((_id, ownerSessionId) => ownerSessionId === sessionId);