dflockd-client 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Matthew Francis-Landau
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,152 @@
+# dflockd-client
+
+TypeScript client for the [dflockd](https://github.com/mtingers/dflockd) distributed lock daemon.
+
+## Installation
+
+```bash
+npm install dflockd-client
+```
+
+## Usage
+
+Start the dflockd server first:
+
+```bash
+uv run dflockd
+```
+
+### `withLock` (recommended)
+
+The simplest way to use a lock. Acquires, runs your callback, and releases
+automatically — even if the callback throws.
+
+```ts
+import { DistributedLock } from "dflockd-client";
+
+const lock = new DistributedLock({ key: "my-resource" });
+
+await lock.withLock(async () => {
+  // critical section — lock is held here
+});
+// lock is released
+```
+
+### Manual `acquire` / `release`
+
+```ts
+import { DistributedLock } from "dflockd-client";
+
+const lock = new DistributedLock({
+  key: "my-resource",
+  acquireTimeoutS: 10, // wait up to 10 s (default)
+  leaseTtlS: 20,       // server-side lease duration
+});
+
+const ok = await lock.acquire(); // true on success, false on timeout
+if (!ok) {
+  console.error("could not acquire lock");
+  process.exit(1);
+}
+
+try {
+  // critical section — lock is held and auto-renewed
+} finally {
+  await lock.release();
+}
+```
+
+### Two-phase lock (enqueue / wait)
+
+Split acquisition into two steps so you can notify an external system
+(webhook, database, queue) between joining the FIFO queue and blocking.
+
+```ts
+import { DistributedLock } from "dflockd-client";
+
+const lock = new DistributedLock({
+  key: "my-resource",
+  acquireTimeoutS: 10,
+  leaseTtlS: 20,
+});
+
+// Step 1: join the queue (non-blocking, returns immediately)
+const status = await lock.enqueue(); // "acquired" or "queued"
+
+// Step 2: do something between enqueue and blocking
+console.log(`enqueue status: ${status}`);
+notifyExternalSystem(status);
+
+// Step 3: block until the lock is granted (or timeout)
+const granted = await lock.wait(10); // true on success, false on timeout
+if (!granted) {
+  console.error("timed out waiting for lock");
+  process.exit(1);
+}
+
+try {
+  // critical section — lock is held and auto-renewed
+} finally {
+  await lock.release();
+}
+```
+
+If the lock is free when `enqueue()` is called, it returns `"acquired"` and
+the lock is already held (fast path). `wait()` then returns `true` immediately
+without blocking. If the lock is contended, `enqueue()` returns `"queued"` and
+`wait()` blocks until the lock is granted or the timeout expires.
+
+### Options
+
+| Option           | Type     | Default       | Description                                      |
+|------------------|----------|---------------|--------------------------------------------------|
+| `key`            | `string` | *(required)*  | Lock name                                        |
+| `acquireTimeoutS`| `number` | `10`          | Seconds to wait for the lock before giving up    |
+| `leaseTtlS`      | `number` | server default| Server-side lease duration in seconds             |
+| `host`           | `string` | `127.0.0.1`   | Server host                                      |
+| `port`           | `number` | `6388`        | Server port                                      |
+| `renewRatio`     | `number` | `0.5`         | Renew at `lease * ratio` seconds (e.g. 50% of TTL)|
+
+### Error handling
+
+```ts
+import { DistributedLock, AcquireTimeoutError, LockError } from "dflockd-client";
+
+try {
+  await lock.withLock(async () => { /* ... */ });
+} catch (err) {
+  if (err instanceof AcquireTimeoutError) {
+    // lock could not be acquired within acquireTimeoutS
+  } else if (err instanceof LockError) {
+    // protocol-level error (bad token, server disconnect, etc.)
+  }
+}
+```
+
+### Low-level functions
+
+For cases where you manage the socket yourself:
+
+```ts
+import * as net from "net";
+import { acquire, enqueue, waitForLock, renew, release } from "dflockd-client";
+
+const sock = net.createConnection({ host: "127.0.0.1", port: 6388 });
+
+// Single-phase
+const { token, lease } = await acquire(sock, "my-key", 10);
+const remaining = await renew(sock, "my-key", token, 60);
+await release(sock, "my-key", token);
+
+// Two-phase
+const result = await enqueue(sock, "another-key");   // { status, token, lease }
+if (result.status === "queued") {
+  const granted = await waitForLock(sock, "another-key", 10); // { token, lease }
+}
+
+sock.destroy();
+```
+
+## License
+
+MIT

package/dist/client.cjs

@@ -0,0 +1,329 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/client.ts
+var client_exports = {};
+__export(client_exports, {
+  AcquireTimeoutError: () => AcquireTimeoutError,
+  DistributedLock: () => DistributedLock,
+  LockError: () => LockError,
+  acquire: () => acquire,
+  enqueue: () => enqueue,
+  release: () => release,
+  renew: () => renew,
+  waitForLock: () => waitForLock
+});
+module.exports = __toCommonJS(client_exports);
+var net = __toESM(require("net"), 1);
+var DEFAULT_HOST = "127.0.0.1";
+var DEFAULT_PORT = 6388;
+var AcquireTimeoutError = class extends Error {
+  constructor(key) {
+    super(`timeout acquiring '${key}'`);
+    this.name = "AcquireTimeoutError";
+  }
+};
+var LockError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "LockError";
+  }
+};
+function encodeLines(...lines) {
+  return Buffer.from(lines.map((l) => l + "\n").join(""), "utf-8");
+}
+function readline(sock) {
+  return new Promise((resolve, reject) => {
+    let buf = "";
+    const onData = (chunk) => {
+      buf += chunk.toString("utf-8");
+      const idx = buf.indexOf("\n");
+      if (idx !== -1) {
+        cleanup();
+        resolve(buf.slice(0, idx).replace(/\r$/, ""));
+      }
+    };
+    const onError = (err) => {
+      cleanup();
+      reject(err);
+    };
+    const onClose = () => {
+      cleanup();
+      reject(new LockError("server closed connection"));
+    };
+    const cleanup = () => {
+      sock.removeListener("data", onData);
+      sock.removeListener("error", onError);
+      sock.removeListener("close", onClose);
+    };
+    sock.on("data", onData);
+    sock.on("error", onError);
+    sock.on("close", onClose);
+  });
+}
+function connect(host, port) {
+  return new Promise((resolve, reject) => {
+    const sock = net.createConnection({ host, port }, () => resolve(sock));
+    sock.on("error", reject);
+  });
+}
+async function acquire(sock, key, acquireTimeoutS, leaseTtlS) {
+  const arg = leaseTtlS == null ? String(acquireTimeoutS) : `${acquireTimeoutS} ${leaseTtlS}`;
+  sock.write(encodeLines("l", key, arg));
+  const resp = await readline(sock);
+  if (resp === "timeout") {
+    throw new AcquireTimeoutError(key);
+  }
+  if (!resp.startsWith("ok ")) {
+    throw new LockError(`acquire failed: '${resp}'`);
+  }
+  const parts = resp.split(" ");
+  if (parts.length < 2) {
+    throw new LockError(`bad ok response: '${resp}'`);
+  }
+  const token = parts[1];
+  const lease = parts.length >= 3 ? parseInt(parts[2], 10) : 30;
+  return { token, lease };
+}
+async function renew(sock, key, token, leaseTtlS) {
+  const arg = leaseTtlS == null ? token : `${token} ${leaseTtlS}`;
+  sock.write(encodeLines("n", key, arg));
+  const resp = await readline(sock);
+  if (!resp.startsWith("ok")) {
+    throw new LockError(`renew failed: '${resp}'`);
+  }
+  const parts = resp.split(" ");
+  if (parts.length >= 2 && /^\d+$/.test(parts[1])) {
+    return parseInt(parts[1], 10);
+  }
+  return -1;
+}
+async function enqueue(sock, key, leaseTtlS) {
+  const arg = leaseTtlS == null ? "" : String(leaseTtlS);
+  sock.write(encodeLines("e", key, arg));
+  const resp = await readline(sock);
+  if (resp.startsWith("acquired ")) {
+    const parts = resp.split(" ");
+    const token = parts[1];
+    const lease = parts.length >= 3 ? parseInt(parts[2], 10) : 33;
+    return { status: "acquired", token, lease };
+  }
+  if (resp === "queued") {
+    return { status: "queued", token: null, lease: null };
+  }
+  throw new LockError(`enqueue failed: '${resp}'`);
+}
+async function waitForLock(sock, key, waitTimeoutS) {
+  sock.write(encodeLines("w", key, String(waitTimeoutS)));
+  const resp = await readline(sock);
+  if (resp === "timeout") {
+    throw new AcquireTimeoutError(key);
+  }
+  if (!resp.startsWith("ok ")) {
+    throw new LockError(`wait failed: '${resp}'`);
+  }
+  const parts = resp.split(" ");
+  const token = parts[1];
+  const lease = parts.length >= 3 ? parseInt(parts[2], 10) : 33;
+  return { token, lease };
+}
+async function release(sock, key, token) {
+  sock.write(encodeLines("r", key, token));
+  const resp = await readline(sock);
+  if (resp !== "ok") {
+    throw new LockError(`release failed: '${resp}'`);
+  }
+}
+var DistributedLock = class {
+  key;
+  acquireTimeoutS;
+  leaseTtlS;
+  host;
+  port;
+  renewRatio;
+  token = null;
+  lease = 0;
+  sock = null;
+  renewTimer = null;
+  closed = false;
+  constructor(opts) {
+    this.key = opts.key;
+    this.acquireTimeoutS = opts.acquireTimeoutS ?? 10;
+    this.leaseTtlS = opts.leaseTtlS;
+    this.host = opts.host ?? DEFAULT_HOST;
+    this.port = opts.port ?? DEFAULT_PORT;
+    this.renewRatio = opts.renewRatio ?? 0.5;
+  }
+  /** Acquire the lock. Returns `true` on success, `false` on timeout. */
+  async acquire() {
+    this.closed = false;
+    this.sock = await connect(this.host, this.port);
+    try {
+      const result = await acquire(
+        this.sock,
+        this.key,
+        this.acquireTimeoutS,
+        this.leaseTtlS
+      );
+      this.token = result.token;
+      this.lease = result.lease;
+    } catch (err) {
+      await this.close();
+      if (err instanceof AcquireTimeoutError) return false;
+      throw err;
+    }
+    this.startRenew();
+    return true;
+  }
+  /** Release the lock and close the connection. */
+  async release() {
+    try {
+      this.stopRenew();
+      if (this.sock && this.token) {
+        await release(this.sock, this.key, this.token);
+      }
+    } finally {
+      await this.close();
+    }
+  }
+  /**
+   * Two-phase step 1: connect and join the FIFO queue.
+   * Returns `"acquired"` (fast-path, lock is already held) or `"queued"`.
+   * If acquired immediately, the renew loop starts automatically.
+   */
+  async enqueue() {
+    this.closed = false;
+    this.sock = await connect(this.host, this.port);
+    try {
+      const result = await enqueue(this.sock, this.key, this.leaseTtlS);
+      if (result.status === "acquired") {
+        this.token = result.token;
+        this.lease = result.lease ?? 0;
+        this.startRenew();
+      }
+      return result.status;
+    } catch (err) {
+      await this.close();
+      throw err;
+    }
+  }
+  /**
+   * Two-phase step 2: block until the lock is granted.
+   * Returns `true` if granted, `false` on timeout.
+   * If already acquired during `enqueue()`, returns `true` immediately.
+   */
+  async wait(timeoutS) {
+    if (this.token !== null) {
+      return true;
+    }
+    if (!this.sock) {
+      throw new LockError("not connected; call enqueue() first");
+    }
+    const timeout = timeoutS ?? this.acquireTimeoutS;
+    try {
+      const result = await waitForLock(this.sock, this.key, timeout);
+      this.token = result.token;
+      this.lease = result.lease;
+    } catch (err) {
+      await this.close();
+      if (err instanceof AcquireTimeoutError) return false;
+      throw err;
+    }
+    this.startRenew();
+    return true;
+  }
+  /**
+   * Run `fn` while holding the lock, then release automatically.
+   *
+   * ```ts
+   * const lock = new DistributedLock({ key: "my-resource" });
+   * await lock.withLock(async () => {
+   *   // critical section
+   * });
+   * ```
+   */
+  async withLock(fn) {
+    const ok = await this.acquire();
+    if (!ok) {
+      throw new AcquireTimeoutError(this.key);
+    }
+    try {
+      return await fn();
+    } finally {
+      await this.release();
+    }
+  }
+  /** Close the underlying socket (idempotent). */
+  async close() {
+    if (this.closed) return;
+    this.closed = true;
+    this.stopRenew();
+    if (this.sock) {
+      this.sock.destroy();
+      this.sock = null;
+    }
+    this.token = null;
+  }
+  // -- internals --
+  startRenew() {
+    const interval = Math.max(1, this.lease * this.renewRatio) * 1e3;
+    const loop = async () => {
+      if (!this.sock || !this.token) return;
+      try {
+        await renew(this.sock, this.key, this.token, this.leaseTtlS);
+      } catch {
+        console.error(
+          `lock lost (renew failed): key=${this.key} token=${this.token}`
+        );
+        this.token = null;
+        return;
+      }
+      this.renewTimer = setTimeout(loop, interval);
+    };
+    this.renewTimer = setTimeout(loop, interval);
+  }
+  stopRenew() {
+    if (this.renewTimer != null) {
+      clearTimeout(this.renewTimer);
+      this.renewTimer = null;
+    }
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AcquireTimeoutError,
+  DistributedLock,
+  LockError,
+  acquire,
+  enqueue,
+  release,
+  renew,
+  waitForLock
+});
+//# sourceMappingURL=client.cjs.map

package/dist/client.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/client.ts"],"sourcesContent":["import * as net from \"net\";\n\nconst DEFAULT_HOST = \"127.0.0.1\";\nconst DEFAULT_PORT = 6388;\n\n// ---------------------------------------------------------------------------\n// Errors\n// ---------------------------------------------------------------------------\n\nexport class AcquireTimeoutError extends Error {\n  constructor(key: string) {\n    super(`timeout acquiring '${key}'`);\n    this.name = \"AcquireTimeoutError\";\n  }\n}\n\nexport class LockError extends Error {\n  constructor(message: string) {\n    super(message);\n    this.name = \"LockError\";\n  }\n}\n\n// ---------------------------------------------------------------------------\n// Low-level helpers\n// ---------------------------------------------------------------------------\n\nfunction encodeLines(...lines: string[]): Buffer {\n  return Buffer.from(lines.map((l) => l + \"\\n\").join(\"\"), \"utf-8\");\n}\n\n/**\n * Read one newline-terminated line from the socket.\n * Resolves with the line (without trailing \\r\\n).\n * Rejects if the connection closes before a full line arrives.\n */\nfunction readline(sock: net.Socket): Promise<string> {\n  return new Promise((resolve, reject) => {\n    let buf = \"\";\n\n    const onData = (chunk: Buffer) => {\n      buf += chunk.toString(\"utf-8\");\n      const idx = buf.indexOf(\"\\n\");\n      if (idx !== -1) {\n        cleanup();\n        resolve(buf.slice(0, idx).replace(/\\r$/, \"\"));\n      }\n    };\n\n    const onError = (err: Error) => {\n      cleanup();\n      reject(err);\n    };\n\n    const onClose = () => {\n      cleanup();\n      reject(new LockError(\"server closed connection\"));\n    };\n\n    const cleanup = () => {\n      sock.removeListener(\"data\", onData);\n      sock.removeListener(\"error\", onError);\n      sock.removeListener(\"close\", onClose);\n    };\n\n    sock.on(\"data\", onData);\n    sock.on(\"error\", onError);\n    sock.on(\"close\", onClose);\n  });\n}\n\nfunction connect(host: string, port: number): Promise<net.Socket> {\n  return new Promise((resolve, reject) => {\n    const sock = net.createConnection({ host, port }, () => resolve(sock));\n    sock.on(\"error\", reject);\n  });\n}\n\n// ---------------------------------------------------------------------------\n// Protocol functions\n// ---------------------------------------------------------------------------\n\nexport async function acquire(\n  sock: net.Socket,\n  key: string,\n  acquireTimeoutS: number,\n  leaseTtlS?: number,\n): Promise<{ token: string; lease: number }> {\n  const arg =\n    leaseTtlS == null\n      ? String(acquireTimeoutS)\n      : `${acquireTimeoutS} ${leaseTtlS}`;\n\n  sock.write(encodeLines(\"l\", key, arg));\n\n  const resp = await readline(sock);\n  if (resp === \"timeout\") {\n    throw new AcquireTimeoutError(key);\n  }\n  if (!resp.startsWith(\"ok \")) {\n    throw new LockError(`acquire failed: '${resp}'`);\n  }\n\n  const parts = resp.split(\" \");\n  if (parts.length < 2) {\n    throw new LockError(`bad ok response: '${resp}'`);\n  }\n  const token = parts[1];\n  const lease = parts.length >= 3 ? parseInt(parts[2], 10) : 30;\n  return { token, lease };\n}\n\nexport async function renew(\n  sock: net.Socket,\n  key: string,\n  token: string,\n  leaseTtlS?: number,\n): Promise<number> {\n  const arg = leaseTtlS == null ? token : `${token} ${leaseTtlS}`;\n  sock.write(encodeLines(\"n\", key, arg));\n\n  const resp = await readline(sock);\n  if (!resp.startsWith(\"ok\")) {\n    throw new LockError(`renew failed: '${resp}'`);\n  }\n\n  const parts = resp.split(\" \");\n  if (parts.length >= 2 && /^\\d+$/.test(parts[1])) {\n    return parseInt(parts[1], 10);\n  }\n  return -1;\n}\n\nexport async function enqueue(\n  sock: net.Socket,\n  key: string,\n  leaseTtlS?: number,\n): Promise<{ status: \"acquired\" | \"queued\"; token: string | null; lease: number | null }> {\n  const arg = leaseTtlS == null ? \"\" : String(leaseTtlS);\n  sock.write(encodeLines(\"e\", key, arg));\n\n  const resp = await readline(sock);\n  if (resp.startsWith(\"acquired \")) {\n    const parts = resp.split(\" \");\n    const token = parts[1];\n    const lease = parts.length >= 3 ? parseInt(parts[2], 10) : 33;\n    return { status: \"acquired\", token, lease };\n  }\n  if (resp === \"queued\") {\n    return { status: \"queued\", token: null, lease: null };\n  }\n  throw new LockError(`enqueue failed: '${resp}'`);\n}\n\nexport async function waitForLock(\n  sock: net.Socket,\n  key: string,\n  waitTimeoutS: number,\n): Promise<{ token: string; lease: number }> {\n  sock.write(encodeLines(\"w\", key, String(waitTimeoutS)));\n\n  const resp = await readline(sock);\n  if (resp === \"timeout\") {\n    throw new AcquireTimeoutError(key);\n  }\n  if (!resp.startsWith(\"ok \")) {\n    throw new LockError(`wait failed: '${resp}'`);\n  }\n\n  const parts = resp.split(\" \");\n  const token = parts[1];\n  const lease = parts.length >= 3 ? parseInt(parts[2], 10) : 33;\n  return { token, lease };\n}\n\nexport async function release(\n  sock: net.Socket,\n  key: string,\n  token: string,\n): Promise<void> {\n  sock.write(encodeLines(\"r\", key, token));\n\n  const resp = await readline(sock);\n  if (resp !== \"ok\") {\n    throw new LockError(`release failed: '${resp}'`);\n  }\n}\n\n// ---------------------------------------------------------------------------\n// DistributedLock\n// ---------------------------------------------------------------------------\n\nexport interface DistributedLockOptions {\n  key: string;\n  acquireTimeoutS?: number;\n  leaseTtlS?: number;\n  host?: string;\n  port?: number;\n  renewRatio?: number;\n}\n\nexport class DistributedLock {\n  readonly key: string;\n  readonly acquireTimeoutS: number;\n  readonly leaseTtlS: number | undefined;\n  readonly host: string;\n  readonly port: number;\n  readonly renewRatio: number;\n\n  token: string | null = null;\n  lease: number = 0;\n\n  private sock: net.Socket | null = null;\n  private renewTimer: ReturnType<typeof setTimeout> | null = null;\n  private closed = false;\n\n  constructor(opts: DistributedLockOptions) {\n    this.key = opts.key;\n    this.acquireTimeoutS = opts.acquireTimeoutS ?? 10;\n    this.leaseTtlS = opts.leaseTtlS;\n    this.host = opts.host ?? DEFAULT_HOST;\n    this.port = opts.port ?? DEFAULT_PORT;\n    this.renewRatio = opts.renewRatio ?? 0.5;\n  }\n\n  /** Acquire the lock. Returns `true` on success, `false` on timeout. */\n  async acquire(): Promise<boolean> {\n    this.closed = false;\n    this.sock = await connect(this.host, this.port);\n    try {\n      const result = await acquire(\n        this.sock,\n        this.key,\n        this.acquireTimeoutS,\n        this.leaseTtlS,\n      );\n      this.token = result.token;\n      this.lease = result.lease;\n    } catch (err) {\n      await this.close();\n      if (err instanceof AcquireTimeoutError) return false;\n      throw err;\n    }\n    this.startRenew();\n    return true;\n  }\n\n  /** Release the lock and close the connection. */\n  async release(): Promise<void> {\n    try {\n      this.stopRenew();\n      if (this.sock && this.token) {\n        await release(this.sock, this.key, this.token);\n      }\n    } finally {\n      await this.close();\n    }\n  }\n\n  /**\n   * Two-phase step 1: connect and join the FIFO queue.\n   * Returns `\"acquired\"` (fast-path, lock is already held) or `\"queued\"`.\n   * If acquired immediately, the renew loop starts automatically.\n   */\n  async enqueue(): Promise<\"acquired\" | \"queued\"> {\n    this.closed = false;\n    this.sock = await connect(this.host, this.port);\n    try {\n      const result = await enqueue(this.sock, this.key, this.leaseTtlS);\n      if (result.status === \"acquired\") {\n        this.token = result.token;\n        this.lease = result.lease ?? 0;\n        this.startRenew();\n      }\n      return result.status;\n    } catch (err) {\n      await this.close();\n      throw err;\n    }\n  }\n\n  /**\n   * Two-phase step 2: block until the lock is granted.\n   * Returns `true` if granted, `false` on timeout.\n   * If already acquired during `enqueue()`, returns `true` immediately.\n   */\n  async wait(timeoutS?: number): Promise<boolean> {\n    if (this.token !== null) {\n      // Already acquired during enqueue (fast path)\n      return true;\n    }\n    if (!this.sock) {\n      throw new LockError(\"not connected; call enqueue() first\");\n    }\n    const timeout = timeoutS ?? this.acquireTimeoutS;\n    try {\n      const result = await waitForLock(this.sock, this.key, timeout);\n      this.token = result.token;\n      this.lease = result.lease;\n    } catch (err) {\n      await this.close();\n      if (err instanceof AcquireTimeoutError) return false;\n      throw err;\n    }\n    this.startRenew();\n    return true;\n  }\n\n  /**\n   * Run `fn` while holding the lock, then release automatically.\n   *\n   * ```ts\n   * const lock = new DistributedLock({ key: \"my-resource\" });\n   * await lock.withLock(async () => {\n   *   // critical section\n   * });\n   * ```\n   */\n  async withLock<T>(fn: () => T | Promise<T>): Promise<T> {\n    const ok = await this.acquire();\n    if (!ok) {\n      throw new AcquireTimeoutError(this.key);\n    }\n    try {\n      return await fn();\n    } finally {\n      await this.release();\n    }\n  }\n\n  /** Close the underlying socket (idempotent). */\n  async close(): Promise<void> {\n    if (this.closed) return;\n    this.closed = true;\n    this.stopRenew();\n    if (this.sock) {\n      this.sock.destroy();\n      this.sock = null;\n    }\n    this.token = null;\n  }\n\n  // -- internals --\n\n  private startRenew(): void {\n    const interval = Math.max(1, this.lease * this.renewRatio) * 1000;\n    const loop = async () => {\n      if (!this.sock || !this.token) return;\n      try {\n        await renew(this.sock, this.key, this.token, this.leaseTtlS);\n      } catch {\n        console.error(\n          `lock lost (renew failed): key=${this.key} token=${this.token}`,\n        );\n        this.token = null;\n        return;\n      }\n      this.renewTimer = setTimeout(loop, interval);\n    };\n    this.renewTimer = setTimeout(loop, interval);\n  }\n\n  private stopRenew(): void {\n    if (this.renewTimer != null) {\n      clearTimeout(this.renewTimer);\n      this.renewTimer = null;\n    }\n  }\n}\n"],"mappings":"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","names":[]}

package/dist/client.d.cts

@@ -0,0 +1,78 @@
+import * as net from 'net';
+
+declare class AcquireTimeoutError extends Error {
+    constructor(key: string);
+}
+declare class LockError extends Error {
+    constructor(message: string);
+}
+declare function acquire(sock: net.Socket, key: string, acquireTimeoutS: number, leaseTtlS?: number): Promise<{
+    token: string;
+    lease: number;
+}>;
+declare function renew(sock: net.Socket, key: string, token: string, leaseTtlS?: number): Promise<number>;
+declare function enqueue(sock: net.Socket, key: string, leaseTtlS?: number): Promise<{
+    status: "acquired" | "queued";
+    token: string | null;
+    lease: number | null;
+}>;
+declare function waitForLock(sock: net.Socket, key: string, waitTimeoutS: number): Promise<{
+    token: string;
+    lease: number;
+}>;
+declare function release(sock: net.Socket, key: string, token: string): Promise<void>;
+interface DistributedLockOptions {
+    key: string;
+    acquireTimeoutS?: number;
+    leaseTtlS?: number;
+    host?: string;
+    port?: number;
+    renewRatio?: number;
+}
+declare class DistributedLock {
+    readonly key: string;
+    readonly acquireTimeoutS: number;
+    readonly leaseTtlS: number | undefined;
+    readonly host: string;
+    readonly port: number;
+    readonly renewRatio: number;
+    token: string | null;
+    lease: number;
+    private sock;
+    private renewTimer;
+    private closed;
+    constructor(opts: DistributedLockOptions);
+    /** Acquire the lock. Returns `true` on success, `false` on timeout. */
+    acquire(): Promise<boolean>;
+    /** Release the lock and close the connection. */
+    release(): Promise<void>;
+    /**
+     * Two-phase step 1: connect and join the FIFO queue.
+     * Returns `"acquired"` (fast-path, lock is already held) or `"queued"`.
+     * If acquired immediately, the renew loop starts automatically.
+     */
+    enqueue(): Promise<"acquired" | "queued">;
+    /**
+     * Two-phase step 2: block until the lock is granted.
+     * Returns `true` if granted, `false` on timeout.
+     * If already acquired during `enqueue()`, returns `true` immediately.
+     */
+    wait(timeoutS?: number): Promise<boolean>;
+    /**
+     * Run `fn` while holding the lock, then release automatically.
+     *
+     * ```ts
+     * const lock = new DistributedLock({ key: "my-resource" });
+     * await lock.withLock(async () => {
+     *   // critical section
+     * });
+     * ```
+     */
+    withLock<T>(fn: () => T | Promise<T>): Promise<T>;
+    /** Close the underlying socket (idempotent). */
+    close(): Promise<void>;
+    private startRenew;
+    private stopRenew;
+}
+
+export { AcquireTimeoutError, DistributedLock, type DistributedLockOptions, LockError, acquire, enqueue, release, renew, waitForLock };

package/dist/client.d.ts

@@ -0,0 +1,78 @@
+import * as net from 'net';
+
+declare class AcquireTimeoutError extends Error {
+    constructor(key: string);
+}
+declare class LockError extends Error {
+    constructor(message: string);
+}
+declare function acquire(sock: net.Socket, key: string, acquireTimeoutS: number, leaseTtlS?: number): Promise<{
+    token: string;
+    lease: number;
+}>;
+declare function renew(sock: net.Socket, key: string, token: string, leaseTtlS?: number): Promise<number>;
+declare function enqueue(sock: net.Socket, key: string, leaseTtlS?: number): Promise<{
+    status: "acquired" | "queued";
+    token: string | null;
+    lease: number | null;
+}>;
+declare function waitForLock(sock: net.Socket, key: string, waitTimeoutS: number): Promise<{
+    token: string;
+    lease: number;
+}>;
+declare function release(sock: net.Socket, key: string, token: string): Promise<void>;
+interface DistributedLockOptions {
+    key: string;
+    acquireTimeoutS?: number;
+    leaseTtlS?: number;
+    host?: string;
+    port?: number;
+    renewRatio?: number;
+}
+declare class DistributedLock {
+    readonly key: string;
+    readonly acquireTimeoutS: number;
+    readonly leaseTtlS: number | undefined;
+    readonly host: string;
+    readonly port: number;
+    readonly renewRatio: number;
+    token: string | null;
+    lease: number;
+    private sock;
+    private renewTimer;
+    private closed;
+    constructor(opts: DistributedLockOptions);
+    /** Acquire the lock. Returns `true` on success, `false` on timeout. */
+    acquire(): Promise<boolean>;
+    /** Release the lock and close the connection. */
+    release(): Promise<void>;
+    /**
+     * Two-phase step 1: connect and join the FIFO queue.
+     * Returns `"acquired"` (fast-path, lock is already held) or `"queued"`.
+     * If acquired immediately, the renew loop starts automatically.
+     */
+    enqueue(): Promise<"acquired" | "queued">;
+    /**
+     * Two-phase step 2: block until the lock is granted.
+     * Returns `true` if granted, `false` on timeout.
+     * If already acquired during `enqueue()`, returns `true` immediately.
+     */
+    wait(timeoutS?: number): Promise<boolean>;
+    /**
+     * Run `fn` while holding the lock, then release automatically.
+     *
+     * ```ts
+     * const lock = new DistributedLock({ key: "my-resource" });
+     * await lock.withLock(async () => {
+     *   // critical section
+     * });
+     * ```
+     */
+    withLock<T>(fn: () => T | Promise<T>): Promise<T>;
+    /** Close the underlying socket (idempotent). */
+    close(): Promise<void>;
+    private startRenew;
+    private stopRenew;
+}
+
+export { AcquireTimeoutError, DistributedLock, type DistributedLockOptions, LockError, acquire, enqueue, release, renew, waitForLock };

package/dist/client.js

@@ -0,0 +1,287 @@
+// src/client.ts
+import * as net from "net";
+var DEFAULT_HOST = "127.0.0.1";
+var DEFAULT_PORT = 6388;
+var AcquireTimeoutError = class extends Error {
+  constructor(key) {
+    super(`timeout acquiring '${key}'`);
+    this.name = "AcquireTimeoutError";
+  }
+};
+var LockError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "LockError";
+  }
+};
+function encodeLines(...lines) {
+  return Buffer.from(lines.map((l) => l + "\n").join(""), "utf-8");
+}
+function readline(sock) {
+  return new Promise((resolve, reject) => {
+    let buf = "";
+    const onData = (chunk) => {
+      buf += chunk.toString("utf-8");
+      const idx = buf.indexOf("\n");
+      if (idx !== -1) {
+        cleanup();
+        resolve(buf.slice(0, idx).replace(/\r$/, ""));
+      }
+    };
+    const onError = (err) => {
+      cleanup();
+      reject(err);
+    };
+    const onClose = () => {
+      cleanup();
+      reject(new LockError("server closed connection"));
+    };
+    const cleanup = () => {
+      sock.removeListener("data", onData);
+      sock.removeListener("error", onError);
+      sock.removeListener("close", onClose);
+    };
+    sock.on("data", onData);
+    sock.on("error", onError);
+    sock.on("close", onClose);
+  });
+}
+function connect(host, port) {
+  return new Promise((resolve, reject) => {
+    const sock = net.createConnection({ host, port }, () => resolve(sock));
+    sock.on("error", reject);
+  });
+}
+async function acquire(sock, key, acquireTimeoutS, leaseTtlS) {
+  const arg = leaseTtlS == null ? String(acquireTimeoutS) : `${acquireTimeoutS} ${leaseTtlS}`;
+  sock.write(encodeLines("l", key, arg));
+  const resp = await readline(sock);
+  if (resp === "timeout") {
+    throw new AcquireTimeoutError(key);
+  }
+  if (!resp.startsWith("ok ")) {
+    throw new LockError(`acquire failed: '${resp}'`);
+  }
+  const parts = resp.split(" ");
+  if (parts.length < 2) {
+    throw new LockError(`bad ok response: '${resp}'`);
+  }
+  const token = parts[1];
+  const lease = parts.length >= 3 ? parseInt(parts[2], 10) : 30;
+  return { token, lease };
+}
+async function renew(sock, key, token, leaseTtlS) {
+  const arg = leaseTtlS == null ? token : `${token} ${leaseTtlS}`;
+  sock.write(encodeLines("n", key, arg));
+  const resp = await readline(sock);
+  if (!resp.startsWith("ok")) {
+    throw new LockError(`renew failed: '${resp}'`);
+  }
+  const parts = resp.split(" ");
+  if (parts.length >= 2 && /^\d+$/.test(parts[1])) {
+    return parseInt(parts[1], 10);
+  }
+  return -1;
+}
+async function enqueue(sock, key, leaseTtlS) {
+  const arg = leaseTtlS == null ? "" : String(leaseTtlS);
+  sock.write(encodeLines("e", key, arg));
+  const resp = await readline(sock);
+  if (resp.startsWith("acquired ")) {
+    const parts = resp.split(" ");
+    const token = parts[1];
+    const lease = parts.length >= 3 ? parseInt(parts[2], 10) : 33;
+    return { status: "acquired", token, lease };
+  }
+  if (resp === "queued") {
+    return { status: "queued", token: null, lease: null };
+  }
+  throw new LockError(`enqueue failed: '${resp}'`);
+}
+async function waitForLock(sock, key, waitTimeoutS) {
+  sock.write(encodeLines("w", key, String(waitTimeoutS)));
+  const resp = await readline(sock);
+  if (resp === "timeout") {
+    throw new AcquireTimeoutError(key);
+  }
+  if (!resp.startsWith("ok ")) {
+    throw new LockError(`wait failed: '${resp}'`);
+  }
+  const parts = resp.split(" ");
+  const token = parts[1];
+  const lease = parts.length >= 3 ? parseInt(parts[2], 10) : 33;
+  return { token, lease };
+}
+async function release(sock, key, token) {
+  sock.write(encodeLines("r", key, token));
+  const resp = await readline(sock);
+  if (resp !== "ok") {
+    throw new LockError(`release failed: '${resp}'`);
+  }
+}
+var DistributedLock = class {
+  key;
+  acquireTimeoutS;
+  leaseTtlS;
+  host;
+  port;
+  renewRatio;
+  token = null;
+  lease = 0;
+  sock = null;
+  renewTimer = null;
+  closed = false;
+  constructor(opts) {
+    this.key = opts.key;
+    this.acquireTimeoutS = opts.acquireTimeoutS ?? 10;
+    this.leaseTtlS = opts.leaseTtlS;
+    this.host = opts.host ?? DEFAULT_HOST;
+    this.port = opts.port ?? DEFAULT_PORT;
+    this.renewRatio = opts.renewRatio ?? 0.5;
+  }
+  /** Acquire the lock. Returns `true` on success, `false` on timeout. */
+  async acquire() {
+    this.closed = false;
+    this.sock = await connect(this.host, this.port);
+    try {
+      const result = await acquire(
+        this.sock,
+        this.key,
+        this.acquireTimeoutS,
+        this.leaseTtlS
+      );
+      this.token = result.token;
+      this.lease = result.lease;
+    } catch (err) {
+      await this.close();
+      if (err instanceof AcquireTimeoutError) return false;
+      throw err;
+    }
+    this.startRenew();
+    return true;
+  }
+  /** Release the lock and close the connection. */
+  async release() {
+    try {
+      this.stopRenew();
+      if (this.sock && this.token) {
+        await release(this.sock, this.key, this.token);
+      }
+    } finally {
+      await this.close();
+    }
+  }
+  /**
+   * Two-phase step 1: connect and join the FIFO queue.
+   * Returns `"acquired"` (fast-path, lock is already held) or `"queued"`.
+   * If acquired immediately, the renew loop starts automatically.
+   */
+  async enqueue() {
+    this.closed = false;
+    this.sock = await connect(this.host, this.port);
+    try {
+      const result = await enqueue(this.sock, this.key, this.leaseTtlS);
+      if (result.status === "acquired") {
+        this.token = result.token;
+        this.lease = result.lease ?? 0;
+        this.startRenew();
+      }
+      return result.status;
+    } catch (err) {
+      await this.close();
+      throw err;
+    }
+  }
+  /**
+   * Two-phase step 2: block until the lock is granted.
+   * Returns `true` if granted, `false` on timeout.
+   * If already acquired during `enqueue()`, returns `true` immediately.
+   */
+  async wait(timeoutS) {
+    if (this.token !== null) {
+      return true;
+    }
+    if (!this.sock) {
+      throw new LockError("not connected; call enqueue() first");
+    }
+    const timeout = timeoutS ?? this.acquireTimeoutS;
+    try {
+      const result = await waitForLock(this.sock, this.key, timeout);
+      this.token = result.token;
+      this.lease = result.lease;
+    } catch (err) {
+      await this.close();
+      if (err instanceof AcquireTimeoutError) return false;
+      throw err;
+    }
+    this.startRenew();
+    return true;
+  }
+  /**
+   * Run `fn` while holding the lock, then release automatically.
+   *
+   * ```ts
+   * const lock = new DistributedLock({ key: "my-resource" });
+   * await lock.withLock(async () => {
+   *   // critical section
+   * });
+   * ```
+   */
+  async withLock(fn) {
+    const ok = await this.acquire();
+    if (!ok) {
+      throw new AcquireTimeoutError(this.key);
+    }
+    try {
+      return await fn();
+    } finally {
+      await this.release();
+    }
+  }
+  /** Close the underlying socket (idempotent). */
+  async close() {
+    if (this.closed) return;
+    this.closed = true;
+    this.stopRenew();
+    if (this.sock) {
+      this.sock.destroy();
+      this.sock = null;
+    }
+    this.token = null;
+  }
+  // -- internals --
+  startRenew() {
+    const interval = Math.max(1, this.lease * this.renewRatio) * 1e3;
+    const loop = async () => {
+      if (!this.sock || !this.token) return;
+      try {
+        await renew(this.sock, this.key, this.token, this.leaseTtlS);
+      } catch {
+        console.error(
+          `lock lost (renew failed): key=${this.key} token=${this.token}`
+        );
+        this.token = null;
+        return;
+      }
+      this.renewTimer = setTimeout(loop, interval);
+    };
+    this.renewTimer = setTimeout(loop, interval);
+  }
+  stopRenew() {
+    if (this.renewTimer != null) {
+      clearTimeout(this.renewTimer);
+      this.renewTimer = null;
+    }
+  }
+};
+export {
+  AcquireTimeoutError,
+  DistributedLock,
+  LockError,
+  acquire,
+  enqueue,
+  release,
+  renew,
+  waitForLock
+};
+//# sourceMappingURL=client.js.map

package/dist/client.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/client.ts"],"sourcesContent":["import * as net from \"net\";\n\nconst DEFAULT_HOST = \"127.0.0.1\";\nconst DEFAULT_PORT = 6388;\n\n// ---------------------------------------------------------------------------\n// Errors\n// ---------------------------------------------------------------------------\n\nexport class AcquireTimeoutError extends Error {\n  constructor(key: string) {\n    super(`timeout acquiring '${key}'`);\n    this.name = \"AcquireTimeoutError\";\n  }\n}\n\nexport class LockError extends Error {\n  constructor(message: string) {\n    super(message);\n    this.name = \"LockError\";\n  }\n}\n\n// ---------------------------------------------------------------------------\n// Low-level helpers\n// ---------------------------------------------------------------------------\n\nfunction encodeLines(...lines: string[]): Buffer {\n  return Buffer.from(lines.map((l) => l + \"\\n\").join(\"\"), \"utf-8\");\n}\n\n/**\n * Read one newline-terminated line from the socket.\n * Resolves with the line (without trailing \\r\\n).\n * Rejects if the connection closes before a full line arrives.\n */\nfunction readline(sock: net.Socket): Promise<string> {\n  return new Promise((resolve, reject) => {\n    let buf = \"\";\n\n    const onData = (chunk: Buffer) => {\n      buf += chunk.toString(\"utf-8\");\n      const idx = buf.indexOf(\"\\n\");\n      if (idx !== -1) {\n        cleanup();\n        resolve(buf.slice(0, idx).replace(/\\r$/, \"\"));\n      }\n    };\n\n    const onError = (err: Error) => {\n      cleanup();\n      reject(err);\n    };\n\n    const onClose = () => {\n      cleanup();\n      reject(new LockError(\"server closed connection\"));\n    };\n\n    const cleanup = () => {\n      sock.removeListener(\"data\", onData);\n      sock.removeListener(\"error\", onError);\n      sock.removeListener(\"close\", onClose);\n    };\n\n    sock.on(\"data\", onData);\n    sock.on(\"error\", onError);\n    sock.on(\"close\", onClose);\n  });\n}\n\nfunction connect(host: string, port: number): Promise<net.Socket> {\n  return new Promise((resolve, reject) => {\n    const sock = net.createConnection({ host, port }, () => resolve(sock));\n    sock.on(\"error\", reject);\n  });\n}\n\n// ---------------------------------------------------------------------------\n// Protocol functions\n// ---------------------------------------------------------------------------\n\nexport async function acquire(\n  sock: net.Socket,\n  key: string,\n  acquireTimeoutS: number,\n  leaseTtlS?: number,\n): Promise<{ token: string; lease: number }> {\n  const arg =\n    leaseTtlS == null\n      ? String(acquireTimeoutS)\n      : `${acquireTimeoutS} ${leaseTtlS}`;\n\n  sock.write(encodeLines(\"l\", key, arg));\n\n  const resp = await readline(sock);\n  if (resp === \"timeout\") {\n    throw new AcquireTimeoutError(key);\n  }\n  if (!resp.startsWith(\"ok \")) {\n    throw new LockError(`acquire failed: '${resp}'`);\n  }\n\n  const parts = resp.split(\" \");\n  if (parts.length < 2) {\n    throw new LockError(`bad ok response: '${resp}'`);\n  }\n  const token = parts[1];\n  const lease = parts.length >= 3 ? parseInt(parts[2], 10) : 30;\n  return { token, lease };\n}\n\nexport async function renew(\n  sock: net.Socket,\n  key: string,\n  token: string,\n  leaseTtlS?: number,\n): Promise<number> {\n  const arg = leaseTtlS == null ? token : `${token} ${leaseTtlS}`;\n  sock.write(encodeLines(\"n\", key, arg));\n\n  const resp = await readline(sock);\n  if (!resp.startsWith(\"ok\")) {\n    throw new LockError(`renew failed: '${resp}'`);\n  }\n\n  const parts = resp.split(\" \");\n  if (parts.length >= 2 && /^\\d+$/.test(parts[1])) {\n    return parseInt(parts[1], 10);\n  }\n  return -1;\n}\n\nexport async function enqueue(\n  sock: net.Socket,\n  key: string,\n  leaseTtlS?: number,\n): Promise<{ status: \"acquired\" | \"queued\"; token: string | null; lease: number | null }> {\n  const arg = leaseTtlS == null ? \"\" : String(leaseTtlS);\n  sock.write(encodeLines(\"e\", key, arg));\n\n  const resp = await readline(sock);\n  if (resp.startsWith(\"acquired \")) {\n    const parts = resp.split(\" \");\n    const token = parts[1];\n    const lease = parts.length >= 3 ? parseInt(parts[2], 10) : 33;\n    return { status: \"acquired\", token, lease };\n  }\n  if (resp === \"queued\") {\n    return { status: \"queued\", token: null, lease: null };\n  }\n  throw new LockError(`enqueue failed: '${resp}'`);\n}\n\nexport async function waitForLock(\n  sock: net.Socket,\n  key: string,\n  waitTimeoutS: number,\n): Promise<{ token: string; lease: number }> {\n  sock.write(encodeLines(\"w\", key, String(waitTimeoutS)));\n\n  const resp = await readline(sock);\n  if (resp === \"timeout\") {\n    throw new AcquireTimeoutError(key);\n  }\n  if (!resp.startsWith(\"ok \")) {\n    throw new LockError(`wait failed: '${resp}'`);\n  }\n\n  const parts = resp.split(\" \");\n  const token = parts[1];\n  const lease = parts.length >= 3 ? parseInt(parts[2], 10) : 33;\n  return { token, lease };\n}\n\nexport async function release(\n  sock: net.Socket,\n  key: string,\n  token: string,\n): Promise<void> {\n  sock.write(encodeLines(\"r\", key, token));\n\n  const resp = await readline(sock);\n  if (resp !== \"ok\") {\n    throw new LockError(`release failed: '${resp}'`);\n  }\n}\n\n// ---------------------------------------------------------------------------\n// DistributedLock\n// ---------------------------------------------------------------------------\n\nexport interface DistributedLockOptions {\n  key: string;\n  acquireTimeoutS?: number;\n  leaseTtlS?: number;\n  host?: string;\n  port?: number;\n  renewRatio?: number;\n}\n\nexport class DistributedLock {\n  readonly key: string;\n  readonly acquireTimeoutS: number;\n  readonly leaseTtlS: number | undefined;\n  readonly host: string;\n  readonly port: number;\n  readonly renewRatio: number;\n\n  token: string | null = null;\n  lease: number = 0;\n\n  private sock: net.Socket | null = null;\n  private renewTimer: ReturnType<typeof setTimeout> | null = null;\n  private closed = false;\n\n  constructor(opts: DistributedLockOptions) {\n    this.key = opts.key;\n    this.acquireTimeoutS = opts.acquireTimeoutS ?? 10;\n    this.leaseTtlS = opts.leaseTtlS;\n    this.host = opts.host ?? DEFAULT_HOST;\n    this.port = opts.port ?? DEFAULT_PORT;\n    this.renewRatio = opts.renewRatio ?? 0.5;\n  }\n\n  /** Acquire the lock. Returns `true` on success, `false` on timeout. */\n  async acquire(): Promise<boolean> {\n    this.closed = false;\n    this.sock = await connect(this.host, this.port);\n    try {\n      const result = await acquire(\n        this.sock,\n        this.key,\n        this.acquireTimeoutS,\n        this.leaseTtlS,\n      );\n      this.token = result.token;\n      this.lease = result.lease;\n    } catch (err) {\n      await this.close();\n      if (err instanceof AcquireTimeoutError) return false;\n      throw err;\n    }\n    this.startRenew();\n    return true;\n  }\n\n  /** Release the lock and close the connection. */\n  async release(): Promise<void> {\n    try {\n      this.stopRenew();\n      if (this.sock && this.token) {\n        await release(this.sock, this.key, this.token);\n      }\n    } finally {\n      await this.close();\n    }\n  }\n\n  /**\n   * Two-phase step 1: connect and join the FIFO queue.\n   * Returns `\"acquired\"` (fast-path, lock is already held) or `\"queued\"`.\n   * If acquired immediately, the renew loop starts automatically.\n   */\n  async enqueue(): Promise<\"acquired\" | \"queued\"> {\n    this.closed = false;\n    this.sock = await connect(this.host, this.port);\n    try {\n      const result = await enqueue(this.sock, this.key, this.leaseTtlS);\n      if (result.status === \"acquired\") {\n        this.token = result.token;\n        this.lease = result.lease ?? 0;\n        this.startRenew();\n      }\n      return result.status;\n    } catch (err) {\n      await this.close();\n      throw err;\n    }\n  }\n\n  /**\n   * Two-phase step 2: block until the lock is granted.\n   * Returns `true` if granted, `false` on timeout.\n   * If already acquired during `enqueue()`, returns `true` immediately.\n   */\n  async wait(timeoutS?: number): Promise<boolean> {\n    if (this.token !== null) {\n      // Already acquired during enqueue (fast path)\n      return true;\n    }\n    if (!this.sock) {\n      throw new LockError(\"not connected; call enqueue() first\");\n    }\n    const timeout = timeoutS ?? this.acquireTimeoutS;\n    try {\n      const result = await waitForLock(this.sock, this.key, timeout);\n      this.token = result.token;\n      this.lease = result.lease;\n    } catch (err) {\n      await this.close();\n      if (err instanceof AcquireTimeoutError) return false;\n      throw err;\n    }\n    this.startRenew();\n    return true;\n  }\n\n  /**\n   * Run `fn` while holding the lock, then release automatically.\n   *\n   * ```ts\n   * const lock = new DistributedLock({ key: \"my-resource\" });\n   * await lock.withLock(async () => {\n   *   // critical section\n   * });\n   * ```\n   */\n  async withLock<T>(fn: () => T | Promise<T>): Promise<T> {\n    const ok = await this.acquire();\n    if (!ok) {\n      throw new AcquireTimeoutError(this.key);\n    }\n    try {\n      return await fn();\n    } finally {\n      await this.release();\n    }\n  }\n\n  /** Close the underlying socket (idempotent). */\n  async close(): Promise<void> {\n    if (this.closed) return;\n    this.closed = true;\n    this.stopRenew();\n    if (this.sock) {\n      this.sock.destroy();\n      this.sock = null;\n    }\n    this.token = null;\n  }\n\n  // -- internals --\n\n  private startRenew(): void {\n    const interval = Math.max(1, this.lease * this.renewRatio) * 1000;\n    const loop = async () => {\n      if (!this.sock || !this.token) return;\n      try {\n        await renew(this.sock, this.key, this.token, this.leaseTtlS);\n      } catch {\n        console.error(\n          `lock lost (renew failed): key=${this.key} token=${this.token}`,\n        );\n        this.token = null;\n        return;\n      }\n      this.renewTimer = setTimeout(loop, interval);\n    };\n    this.renewTimer = setTimeout(loop, interval);\n  }\n\n  private stopRenew(): void {\n    if (this.renewTimer != null) {\n      clearTimeout(this.renewTimer);\n      this.renewTimer = null;\n    }\n  }\n}\n"],"mappings":"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","names":[]}

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "dflockd-client",
+  "version": "1.0.0",
+  "description": "TypeScript client for the dflockd distributed lock daemon",
+  "type": "module",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/client.d.ts",
+        "default": "./dist/client.js"
+      },
+      "require": {
+        "types": "./dist/client.d.cts",
+        "default": "./dist/client.cjs"
+      }
+    }
+  },
+  "main": "dist/client.cjs",
+  "module": "dist/client.js",
+  "types": "dist/client.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "typecheck": "tsc --noEmit",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "distributed-lock",
+    "lock",
+    "mutex",
+    "dflockd",
+    "distributed"
+  ],
+  "author": "",
+  "license": "MIT",
+  "engines": {
+    "node": ">=16"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/mtingers/dflockd-client-ts.git"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "tsup": "^8.0.0",
+    "typescript": "^5.7.0"
+  }
+}