@dbx-tools/core 0.6.65 → 0.6.67

package/lib/src/process-lock.js

@@ -0,0 +1,355 @@
+/**
+ * Keyed mutual exclusion across the main thread and its worker threads.
+ *
+ * {@link withProcessLock} serializes callbacks that share a key: one runs at a
+ * time, the rest queue in arrival order, and different keys proceed
+ * concurrently. Unlike a plain in-module `Promise` chain, the queue is shared by
+ * every thread wired up through {@link processLockWorkerOptions}, so a worker
+ * pool cannot run two callbacks for the same key at once.
+ *
+ * The name says `process`: this coordinates the THREADS of one Node process. It
+ * is not cross-process and not cross-host - a second `node` invocation, or a
+ * second app replica, has its own coordinator and shares nothing. When the scope
+ * is a deployment rather than a process, use
+ * `@dbx-tools/postgres`'s `withAdvisoryLock`, which puts the arbiter in
+ * PostgreSQL where every replica can see it.
+ *
+ * The main thread owns the only coordinator. Each participating thread gets one
+ * `MessagePort` to it, and a lock is granted by a message back over that port.
+ * Consequently:
+ *
+ *   - the lock is ADVISORY, like Postgres advisory locks - it protects a
+ *     critical section only insofar as every writer takes the same key;
+ *   - fairness is FIFO per key, since the coordinator queues waiters in the
+ *     order their requests arrive;
+ *   - a thread that dies while holding a lock releases it, because its port
+ *     closing is what hands the key to the next waiter (see
+ *     {@link LockCoordinator.removePort}).
+ *
+ * @module
+ */
+import { isMainThread, MessageChannel, parentPort, workerData, } from "node:worker_threads";
+import { error, hash, object } from "@dbx-tools/shared-core";
+/**
+ * `workerData` slot carrying the coordinator port into a worker, and the
+ * `parentPort` message `type` for the late {@link attachProcessLock} handshake.
+ * Namespaced because both travel through channels an application also uses:
+ * `workerData` is the caller's own object, and `parentPort` carries the caller's
+ * own messages.
+ */
+const LOCK_PORT_KEY = "__dbxToolsProcessLockPort";
+const ATTACH_MESSAGE_TYPE = "__dbxToolsProcessLockAttach";
+/**
+ * Arbiter for every key, living on the main thread.
+ *
+ * Holds no timers and no handles of its own: a port is unref'd by its client
+ * while idle (see {@link LockClient}), so an idle coordinator never keeps the
+ * process alive.
+ */
+class LockCoordinator {
+    states = new Map();
+    /** Serve one client. Called once per participating thread. */
+    addPort(port) {
+        port.on("message", (message) => {
+            switch (message.type) {
+                case "acquire":
+                    this.acquire(message.key, message.requestId, port);
+                    break;
+                case "release":
+                    this.release(message.key, message.requestId);
+                    break;
+                default:
+                    break;
+            }
+        });
+        // A closed port means its thread exited or was terminated. Releasing here is
+        // what keeps one crashed worker from wedging a key for the process lifetime.
+        port.on("close", () => this.removePort(port));
+        // The coordinator side stays unref'd for its whole life. It is a pure
+        // responder - it never has business of its own pending - so keeping the
+        // event loop alive for it would mean a process that used a lock once could
+        // never exit. A request always arrives from a client that has ref'd ITS
+        // port, so the loop is awake whenever there is actually something to serve.
+        port.unref();
+        port.start();
+    }
+    acquire(key, requestId, port) {
+        const waiter = { requestId, port };
+        const state = this.states.get(key);
+        if (!state) {
+            this.states.set(key, { owner: waiter, queue: [] });
+            grant(waiter);
+            return;
+        }
+        state.queue.push(waiter);
+    }
+    /**
+     * Hand the key on, ignoring a release from anyone but the current owner.
+     *
+     * A stale release is expected, not defensive coding: an aborted acquisition
+     * sends one for a request that never owned the key, and honouring it would
+     * revoke the lock from whoever holds it now.
+     */
+    release(key, requestId) {
+        const state = this.states.get(key);
+        if (state?.owner.requestId !== requestId)
+            return;
+        this.grantNext(key, state);
+    }
+    /** Promote the next waiter, or drop the key when nobody wants it. */
+    grantNext(key, state) {
+        const next = state.queue.shift();
+        if (!next) {
+            this.states.delete(key);
+            return;
+        }
+        state.owner = next;
+        grant(next);
+    }
+    /**
+     * Drop a dead thread from every key: release the ones it owned and remove it
+     * from the queues it was waiting in.
+     *
+     * Queue removal must happen FIRST. A thread can appear as both the owner of
+     * one key and a waiter for another, and promoting it out of a queue it can no
+     * longer answer for would grant a lock to a closed port - stalling that key
+     * until the process ends.
+     */
+    removePort(port) {
+        for (const state of this.states.values()) {
+            if (state.queue.length > 0) {
+                state.queue = state.queue.filter((waiter) => waiter.port !== port);
+            }
+        }
+        for (const [key, state] of [...this.states]) {
+            if (state.owner.port === port)
+                this.grantNext(key, state);
+        }
+    }
+}
+/** Notify a waiter that it now owns its key. */
+function grant(waiter) {
+    waiter.port.postMessage({ type: "granted", requestId: waiter.requestId });
+}
+/**
+ * A thread's end of the conversation: sends requests, awaits grants, and runs
+ * callbacks.
+ *
+ * Owns the event-loop bookkeeping. The port is unref'd while idle so holding a
+ * lock module never blocks process exit, and ref'd exactly while this thread has
+ * an outstanding request or an unreleased lock - otherwise Node would consider
+ * itself out of work and exit mid-critical-section, dropping the grant that was
+ * already on its way.
+ */
+class LockClient {
+    port;
+    pending = new Map();
+    /** Requests + held locks. The port is ref'd while this is above zero. */
+    active = 0;
+    closed = false;
+    constructor(port) {
+        this.port = port;
+        port.on("message", (message) => {
+            if (message.type !== "granted")
+                return;
+            this.settle(message.requestId);
+        });
+        port.on("close", () => {
+            this.closed = true;
+            // The coordinator is gone (main thread exiting, or this worker being torn
+            // down). Fail the waiters rather than hang them: a caller blocked on a
+            // lock that can never be granted is indistinguishable from a deadlock.
+            const closeError = new Error("Process lock port closed before the lock was granted");
+            for (const settle of [...this.pending.values()])
+                settle(closeError);
+        });
+        port.unref();
+        port.start();
+    }
+    /** Resolve or reject one pending request and drop its ref. */
+    settle(requestId, failure) {
+        const settle = this.pending.get(requestId);
+        if (!settle)
+            return;
+        this.pending.delete(requestId);
+        settle(failure);
+    }
+    /** Ref the port for the first unit of outstanding work. */
+    retain() {
+        if (this.active++ === 0)
+            this.port.ref();
+    }
+    /** Unref once nothing is outstanding, so the thread can exit. */
+    release() {
+        if (--this.active === 0)
+            this.port.unref();
+    }
+    async run(key, fn) {
+        if (this.closed) {
+            throw new Error("Process lock port is closed");
+        }
+        const requestId = hash.id();
+        this.retain();
+        try {
+            await new Promise((resolve, reject) => {
+                this.pending.set(requestId, (failure) => (failure ? reject(failure) : resolve()));
+                try {
+                    this.port.postMessage({ type: "acquire", requestId, key });
+                }
+                catch (cause) {
+                    this.pending.delete(requestId);
+                    reject(error.toError(cause));
+                }
+            });
+        }
+        catch (cause) {
+            // Never granted, so there is nothing to release - just drop the ref.
+            this.release();
+            throw cause;
+        }
+        try {
+            return await fn();
+        }
+        finally {
+            // Post before unref'ing: the release must be in flight while the port is
+            // still holding the loop open, or the next waiter is stranded.
+            if (!this.closed) {
+                this.port.postMessage({ type: "release", requestId, key });
+            }
+            this.release();
+        }
+    }
+}
+/** The coordinator, on the main thread only. */
+const coordinator = isMainThread ? new LockCoordinator() : undefined;
+/**
+ * This thread's client, created on first use.
+ *
+ * Lazy so importing this module costs nothing and, more importantly, so a worker
+ * that never locks anything is never forced to have been started through
+ * {@link processLockWorkerOptions}. The main thread wires a channel to its own
+ * coordinator; a worker adopts the port it was handed.
+ */
+let client;
+function lockClient() {
+    if (client)
+        return client;
+    if (coordinator) {
+        const { port1, port2 } = new MessageChannel();
+        coordinator.addPort(port1);
+        client = new LockClient(port2);
+        return client;
+    }
+    const port = workerData?.[LOCK_PORT_KEY];
+    if (!port) {
+        throw new Error("This worker has no process-lock port. Start it with processLockWorkerOptions() " +
+            "(or call attachProcessLock(worker) and await processLockAttached()).");
+    }
+    client = new LockClient(port);
+    return client;
+}
+/**
+ * Run `fn` while holding the lock named by `key`, releasing it when `fn`
+ * settles.
+ *
+ * Callers sharing a key are serialized across the main thread and every worker
+ * started through {@link processLockWorkerOptions}; distinct keys never block
+ * each other. Returns whatever `fn` returns and propagates what it throws, so it
+ * drops into an existing expression without restructuring.
+ *
+ * `key` is any value with a stable identity - a string, a `["invoice", id]`
+ * tuple, a config object - canonicalized by `object.toStableKey`, the same rule
+ * `@dbx-tools/postgres` uses for advisory-lock ids and channel names. Structure
+ * is part of the identity: `["invoice", 7]` and `"invoice_7"` are different
+ * locks.
+ *
+ * @example
+ * await withProcessLock(["cache", name], async () => {
+ *   if (!(await exists(name))) await build(name);
+ * });
+ */
+export function withProcessLock(key, fn) {
+    return lockClient().run(lockKey(key), fn);
+}
+/** Canonical string identity for a lock key (see `object.toStableKey`). */
+function lockKey(key) {
+    return object
+        .toOneOrMany(key)
+        .map((part) => object.toStableKey(part))
+        .join("\u0000");
+}
+/**
+ * Add the coordinator port to a `Worker`'s options so the worker can lock
+ * immediately - during module initialization, before any message is handled.
+ *
+ * Preserves the caller's `workerData` and `transferList`; the port is
+ * transferred, as `MessagePort` cannot be cloned.
+ *
+ * @example
+ * new Worker(url, processLockWorkerOptions({ workerData: { tenant } }));
+ */
+export function processLockWorkerOptions(options = {}) {
+    const port = createCoordinatorPort("processLockWorkerOptions");
+    const existing = object.isRecord(options.workerData) ? options.workerData : {};
+    return {
+        ...options,
+        workerData: { ...existing, [LOCK_PORT_KEY]: port },
+        transferList: [...(options.transferList ?? []), port],
+    };
+}
+/**
+ * Wire an ALREADY-RUNNING worker into the lock, for a worker this code did not
+ * construct (a pool from a library, say).
+ *
+ * Prefer {@link processLockWorkerOptions}: the port arrives with a message, so
+ * the worker cannot lock during module initialization and must await
+ * {@link processLockAttached} first. The worker side needs no other change -
+ * `withProcessLock` works normally once the port lands.
+ */
+export function attachProcessLock(worker) {
+    const port = createCoordinatorPort("attachProcessLock");
+    worker.postMessage({ type: ATTACH_MESSAGE_TYPE, port }, [port]);
+}
+/** A fresh coordinator-side channel, or a clear error off the main thread. */
+function createCoordinatorPort(caller) {
+    if (!coordinator) {
+        throw new Error(`${caller}() must be called from the main thread`);
+    }
+    const { port1, port2 } = new MessageChannel();
+    coordinator.addPort(port1);
+    return port2;
+}
+/**
+ * In a worker, resolve once the {@link attachProcessLock} port has arrived.
+ *
+ * Only needed on the attach path, and safe to await regardless: it returns
+ * immediately when the worker already has a port (the
+ * {@link processLockWorkerOptions} case) or when called on the main thread, so
+ * shared worker code does not branch on how it was started.
+ *
+ * A `parentPort` listener keeps the worker alive, which is CORRECT here and
+ * deliberately not unref'd: this promise is pending work, and a worker allowed to
+ * exit while awaiting its port would die silently instead of locking. The
+ * listener is removed as soon as the port lands, so the worker is free to exit
+ * again the moment the wait is over.
+ */
+export function processLockAttached() {
+    if (isMainThread || client || workerData?.[LOCK_PORT_KEY]) {
+        return Promise.resolve();
+    }
+    const port = parentPort;
+    if (!port) {
+        return Promise.reject(new Error("processLockAttached() must be called from a worker thread"));
+    }
+    return new Promise((resolve) => {
+        const onMessage = (message) => {
+            if (!object.isRecord(message) || message.type !== ATTACH_MESSAGE_TYPE)
+                return;
+            port.off("message", onMessage);
+            client = new LockClient(message.port);
+            resolve();
+        };
+        port.on("message", onMessage);
+    });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"process-lock.js","sourceRoot":"","sources":["../../src/process-lock.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Keyed mutual exclusion across the main thread and its worker threads.\n *\n * {@link withProcessLock} serializes callbacks that share a key: one runs at a\n * time, the rest queue in arrival order, and different keys proceed\n * concurrently. Unlike a plain in-module `Promise` chain, the queue is shared by\n * every thread wired up through {@link processLockWorkerOptions}, so a worker\n * pool cannot run two callbacks for the same key at once.\n *\n * The name says `process`: this coordinates the THREADS of one Node process. It\n * is not cross-process and not cross-host - a second `node` invocation, or a\n * second app replica, has its own coordinator and shares nothing. When the scope\n * is a deployment rather than a process, use\n * `@dbx-tools/postgres`'s `withAdvisoryLock`, which puts the arbiter in\n * PostgreSQL where every replica can see it.\n *\n * The main thread owns the only coordinator. Each participating thread gets one\n * `MessagePort` to it, and a lock is granted by a message back over that port.\n * Consequently:\n *\n *   - the lock is ADVISORY, like Postgres advisory locks - it protects a\n *     critical section only insofar as every writer takes the same key;\n *   - fairness is FIFO per key, since the coordinator queues waiters in the\n *     order their requests arrive;\n *   - a thread that dies while holding a lock releases it, because its port\n *     closing is what hands the key to the next waiter (see\n *     {@link LockCoordinator.removePort}).\n *\n * @module\n */\n\nimport {\n  isMainThread,\n  MessageChannel,\n  parentPort,\n  workerData,\n  type MessagePort,\n  type Worker,\n  type WorkerOptions,\n} from \"node:worker_threads\";\nimport { error, hash, object } from \"@dbx-tools/shared-core\";\n\n/**\n * `workerData` slot carrying the coordinator port into a worker, and the\n * `parentPort` message `type` for the late {@link attachProcessLock} handshake.\n * Namespaced because both travel through channels an application also uses:\n * `workerData` is the caller's own object, and `parentPort` carries the caller's\n * own messages.\n */\nconst LOCK_PORT_KEY = \"__dbxToolsProcessLockPort\";\nconst ATTACH_MESSAGE_TYPE = \"__dbxToolsProcessLockAttach\";\n\n/** Sent by a client to the coordinator. */\ntype LockRequest =\n  | { type: \"acquire\"; requestId: string; key: string }\n  | { type: \"release\"; requestId: string; key: string };\n\n/** Sent by the coordinator to the client that now owns the key. */\ntype LockResponse = { type: \"granted\"; requestId: string };\n\ntype LockMessage = LockRequest | LockResponse;\n\n/** The `parentPort` envelope that hands a late-attached worker its port. */\ninterface AttachMessage {\n  type: typeof ATTACH_MESSAGE_TYPE;\n  port: MessagePort;\n}\n\n/** One outstanding or granted acquisition. */\ninterface LockWaiter {\n  requestId: string;\n  port: MessagePort;\n}\n\n/** Shape of the `workerData` slice this module reads. */\ninterface LockWorkerData {\n  [LOCK_PORT_KEY]?: MessagePort;\n}\n\n/**\n * A key's owner plus its FIFO queue of waiters.\n *\n * Owner and queue live in ONE map entry rather than two parallel maps so a key\n * cannot end up half-present - a queue whose owner map entry was already deleted\n * would strand its waiters forever, and the entry is dropped only when the key\n * is both unowned and unwanted.\n */\ninterface LockState {\n  owner: LockWaiter;\n  queue: LockWaiter[];\n}\n\n/**\n * Arbiter for every key, living on the main thread.\n *\n * Holds no timers and no handles of its own: a port is unref'd by its client\n * while idle (see {@link LockClient}), so an idle coordinator never keeps the\n * process alive.\n */\nclass LockCoordinator {\n  private readonly states = new Map<string, LockState>();\n\n  /** Serve one client. Called once per participating thread. */\n  addPort(port: MessagePort): void {\n    port.on(\"message\", (message: LockMessage) => {\n      switch (message.type) {\n        case \"acquire\":\n          this.acquire(message.key, message.requestId, port);\n          break;\n        case \"release\":\n          this.release(message.key, message.requestId);\n          break;\n        default:\n          break;\n      }\n    });\n    // A closed port means its thread exited or was terminated. Releasing here is\n    // what keeps one crashed worker from wedging a key for the process lifetime.\n    port.on(\"close\", () => this.removePort(port));\n    // The coordinator side stays unref'd for its whole life. It is a pure\n    // responder - it never has business of its own pending - so keeping the\n    // event loop alive for it would mean a process that used a lock once could\n    // never exit. A request always arrives from a client that has ref'd ITS\n    // port, so the loop is awake whenever there is actually something to serve.\n    port.unref();\n    port.start();\n  }\n\n  private acquire(key: string, requestId: string, port: MessagePort): void {\n    const waiter: LockWaiter = { requestId, port };\n    const state = this.states.get(key);\n    if (!state) {\n      this.states.set(key, { owner: waiter, queue: [] });\n      grant(waiter);\n      return;\n    }\n    state.queue.push(waiter);\n  }\n\n  /**\n   * Hand the key on, ignoring a release from anyone but the current owner.\n   *\n   * A stale release is expected, not defensive coding: an aborted acquisition\n   * sends one for a request that never owned the key, and honouring it would\n   * revoke the lock from whoever holds it now.\n   */\n  private release(key: string, requestId: string): void {\n    const state = this.states.get(key);\n    if (state?.owner.requestId !== requestId) return;\n    this.grantNext(key, state);\n  }\n\n  /** Promote the next waiter, or drop the key when nobody wants it. */\n  private grantNext(key: string, state: LockState): void {\n    const next = state.queue.shift();\n    if (!next) {\n      this.states.delete(key);\n      return;\n    }\n    state.owner = next;\n    grant(next);\n  }\n\n  /**\n   * Drop a dead thread from every key: release the ones it owned and remove it\n   * from the queues it was waiting in.\n   *\n   * Queue removal must happen FIRST. A thread can appear as both the owner of\n   * one key and a waiter for another, and promoting it out of a queue it can no\n   * longer answer for would grant a lock to a closed port - stalling that key\n   * until the process ends.\n   */\n  private removePort(port: MessagePort): void {\n    for (const state of this.states.values()) {\n      if (state.queue.length > 0) {\n        state.queue = state.queue.filter((waiter) => waiter.port !== port);\n      }\n    }\n    for (const [key, state] of [...this.states]) {\n      if (state.owner.port === port) this.grantNext(key, state);\n    }\n  }\n}\n\n/** Notify a waiter that it now owns its key. */\nfunction grant(waiter: LockWaiter): void {\n  waiter.port.postMessage({ type: \"granted\", requestId: waiter.requestId } satisfies LockResponse);\n}\n\n/**\n * A thread's end of the conversation: sends requests, awaits grants, and runs\n * callbacks.\n *\n * Owns the event-loop bookkeeping. The port is unref'd while idle so holding a\n * lock module never blocks process exit, and ref'd exactly while this thread has\n * an outstanding request or an unreleased lock - otherwise Node would consider\n * itself out of work and exit mid-critical-section, dropping the grant that was\n * already on its way.\n */\nclass LockClient {\n  private readonly pending = new Map<string, (error?: Error) => void>();\n  /** Requests + held locks. The port is ref'd while this is above zero. */\n  private active = 0;\n  private closed = false;\n\n  constructor(private readonly port: MessagePort) {\n    port.on(\"message\", (message: LockMessage) => {\n      if (message.type !== \"granted\") return;\n      this.settle(message.requestId);\n    });\n    port.on(\"close\", () => {\n      this.closed = true;\n      // The coordinator is gone (main thread exiting, or this worker being torn\n      // down). Fail the waiters rather than hang them: a caller blocked on a\n      // lock that can never be granted is indistinguishable from a deadlock.\n      const closeError = new Error(\"Process lock port closed before the lock was granted\");\n      for (const settle of [...this.pending.values()]) settle(closeError);\n    });\n    port.unref();\n    port.start();\n  }\n\n  /** Resolve or reject one pending request and drop its ref. */\n  private settle(requestId: string, failure?: Error): void {\n    const settle = this.pending.get(requestId);\n    if (!settle) return;\n    this.pending.delete(requestId);\n    settle(failure);\n  }\n\n  /** Ref the port for the first unit of outstanding work. */\n  private retain(): void {\n    if (this.active++ === 0) this.port.ref();\n  }\n\n  /** Unref once nothing is outstanding, so the thread can exit. */\n  private release(): void {\n    if (--this.active === 0) this.port.unref();\n  }\n\n  async run<T>(key: string, fn: () => T | Promise<T>): Promise<T> {\n    if (this.closed) {\n      throw new Error(\"Process lock port is closed\");\n    }\n    const requestId = hash.id();\n    this.retain();\n    try {\n      await new Promise<void>((resolve, reject) => {\n        this.pending.set(requestId, (failure) => (failure ? reject(failure) : resolve()));\n        try {\n          this.port.postMessage({ type: \"acquire\", requestId, key } satisfies LockRequest);\n        } catch (cause) {\n          this.pending.delete(requestId);\n          reject(error.toError(cause));\n        }\n      });\n    } catch (cause) {\n      // Never granted, so there is nothing to release - just drop the ref.\n      this.release();\n      throw cause;\n    }\n    try {\n      return await fn();\n    } finally {\n      // Post before unref'ing: the release must be in flight while the port is\n      // still holding the loop open, or the next waiter is stranded.\n      if (!this.closed) {\n        this.port.postMessage({ type: \"release\", requestId, key } satisfies LockRequest);\n      }\n      this.release();\n    }\n  }\n}\n\n/** The coordinator, on the main thread only. */\nconst coordinator = isMainThread ? new LockCoordinator() : undefined;\n\n/**\n * This thread's client, created on first use.\n *\n * Lazy so importing this module costs nothing and, more importantly, so a worker\n * that never locks anything is never forced to have been started through\n * {@link processLockWorkerOptions}. The main thread wires a channel to its own\n * coordinator; a worker adopts the port it was handed.\n */\nlet client: LockClient | undefined;\n\nfunction lockClient(): LockClient {\n  if (client) return client;\n  if (coordinator) {\n    const { port1, port2 } = new MessageChannel();\n    coordinator.addPort(port1);\n    client = new LockClient(port2);\n    return client;\n  }\n  const port = (workerData as LockWorkerData | undefined)?.[LOCK_PORT_KEY];\n  if (!port) {\n    throw new Error(\n      \"This worker has no process-lock port. Start it with processLockWorkerOptions() \" +\n        \"(or call attachProcessLock(worker) and await processLockAttached()).\",\n    );\n  }\n  client = new LockClient(port);\n  return client;\n}\n\n/**\n * Run `fn` while holding the lock named by `key`, releasing it when `fn`\n * settles.\n *\n * Callers sharing a key are serialized across the main thread and every worker\n * started through {@link processLockWorkerOptions}; distinct keys never block\n * each other. Returns whatever `fn` returns and propagates what it throws, so it\n * drops into an existing expression without restructuring.\n *\n * `key` is any value with a stable identity - a string, a `[\"invoice\", id]`\n * tuple, a config object - canonicalized by `object.toStableKey`, the same rule\n * `@dbx-tools/postgres` uses for advisory-lock ids and channel names. Structure\n * is part of the identity: `[\"invoice\", 7]` and `\"invoice_7\"` are different\n * locks.\n *\n * @example\n * await withProcessLock([\"cache\", name], async () => {\n *   if (!(await exists(name))) await build(name);\n * });\n */\nexport function withProcessLock<T>(key: unknown, fn: () => T | Promise<T>): Promise<T> {\n  return lockClient().run(lockKey(key), fn);\n}\n\n/** Canonical string identity for a lock key (see `object.toStableKey`). */\nfunction lockKey(key: unknown): string {\n  return object\n    .toOneOrMany(key)\n    .map((part) => object.toStableKey(part))\n    .join(\"\\u0000\");\n}\n\n/**\n * Add the coordinator port to a `Worker`'s options so the worker can lock\n * immediately - during module initialization, before any message is handled.\n *\n * Preserves the caller's `workerData` and `transferList`; the port is\n * transferred, as `MessagePort` cannot be cloned.\n *\n * @example\n * new Worker(url, processLockWorkerOptions({ workerData: { tenant } }));\n */\nexport function processLockWorkerOptions(options: WorkerOptions = {}): WorkerOptions {\n  const port = createCoordinatorPort(\"processLockWorkerOptions\");\n  const existing = object.isRecord(options.workerData) ? options.workerData : {};\n  return {\n    ...options,\n    workerData: { ...existing, [LOCK_PORT_KEY]: port },\n    transferList: [...(options.transferList ?? []), port],\n  };\n}\n\n/**\n * Wire an ALREADY-RUNNING worker into the lock, for a worker this code did not\n * construct (a pool from a library, say).\n *\n * Prefer {@link processLockWorkerOptions}: the port arrives with a message, so\n * the worker cannot lock during module initialization and must await\n * {@link processLockAttached} first. The worker side needs no other change -\n * `withProcessLock` works normally once the port lands.\n */\nexport function attachProcessLock(worker: Worker): void {\n  const port = createCoordinatorPort(\"attachProcessLock\");\n  worker.postMessage({ type: ATTACH_MESSAGE_TYPE, port } satisfies AttachMessage, [port]);\n}\n\n/** A fresh coordinator-side channel, or a clear error off the main thread. */\nfunction createCoordinatorPort(caller: string): MessagePort {\n  if (!coordinator) {\n    throw new Error(`${caller}() must be called from the main thread`);\n  }\n  const { port1, port2 } = new MessageChannel();\n  coordinator.addPort(port1);\n  return port2;\n}\n\n/**\n * In a worker, resolve once the {@link attachProcessLock} port has arrived.\n *\n * Only needed on the attach path, and safe to await regardless: it returns\n * immediately when the worker already has a port (the\n * {@link processLockWorkerOptions} case) or when called on the main thread, so\n * shared worker code does not branch on how it was started.\n *\n * A `parentPort` listener keeps the worker alive, which is CORRECT here and\n * deliberately not unref'd: this promise is pending work, and a worker allowed to\n * exit while awaiting its port would die silently instead of locking. The\n * listener is removed as soon as the port lands, so the worker is free to exit\n * again the moment the wait is over.\n */\nexport function processLockAttached(): Promise<void> {\n  if (isMainThread || client || (workerData as LockWorkerData | undefined)?.[LOCK_PORT_KEY]) {\n    return Promise.resolve();\n  }\n  const port = parentPort;\n  if (!port) {\n    return Promise.reject(new Error(\"processLockAttached() must be called from a worker thread\"));\n  }\n  return new Promise<void>((resolve) => {\n    const onMessage = (message: unknown): void => {\n      if (!object.isRecord(message) || message.type !== ATTACH_MESSAGE_TYPE) return;\n      port.off(\"message\", onMessage);\n      client = new LockClient((message as unknown as AttachMessage).port);\n      resolve();\n    };\n    port.on(\"message\", onMessage);\n  });\n}\n"]}

package/lib/tsconfig.tsbuildinfo

@@ -1 +1 @@
-{"root":["../src/brand.ts","../src/exec.ts","../src/file.ts","../src/project.ts","../index.ts"],"version":"5.9.3"}
+{"root":["../src/bin.ts","../src/brand.ts","../src/exec.ts","../src/file.ts","../src/process-lock.ts","../src/project.ts","../index.ts"],"version":"5.9.3"}

package/package.json

@@ -23,7 +23,9 @@
     "typescript": "^5.9.3"
   },
   "dependencies": {
-    "@dbx-tools/shared-core": "0.6.65",
+    "@dbx-tools/shared-core": "0.6.67",
+    "extract-zip": "^2.0.1",
+    "tar": "^7.5.22",
     "yaml": "^2.9.0"
   },
   "main": "./lib/index.js",
@@ -40,7 +42,7 @@
       "./package.json": "./package.json"
     }
   },
-  "version": "0.6.65",
+  "version": "0.6.67",
   "types": "./lib/index.d.ts",
   "type": "module",
   "exports": {