@dbx-tools/core 0.6.223 → 0.6.225

package/README.md

@@ -22,8 +22,8 @@ Key features:
   Databricks bundle's App `config.env`.
 - YAML/JSON brand-context discovery and loading with shared Zod validation.
 - Idempotent executable downloads with zip/tar extraction and atomic installs.
-- Cross-process file locks with a Bun `flock(2)` fast path and a portable,
-  stale-reclaiming lock-directory fallback.
+- Cross-process file locks with one portable, stale-reclaiming lock-directory
+  protocol shared by Bun and Node.
 - Keyed mutual exclusion across the main thread and its worker threads.
 
 ## Install A Binary
@@ -285,12 +285,16 @@ await fileLock.withFileLock(["cache", name], async () => {
 ```
 
 `withFileLock()` serializes processes on the same machine or shared filesystem.
-Under Bun on Unix it prefers a kernel `flock(2)` lock, which the OS releases if
-the process dies. Plain Node, Windows, and systems without the FFI path use
-atomic lock-directory creation with a heartbeat and stale-lock reclamation.
-Callers can select the lock directory, restrict the backend cascade, observe the
-chosen backend, or set a wait timeout. Lock keys use the same stable structured
-identity as process and Postgres advisory locks.
+Bun and Node both use `proper-lockfile` atomic lock-directory creation,
+heartbeats, stale-lock reclamation, and ownership-safe release. Callers can
+select the lock directory, explicitly request the legacy Bun `flock` backend,
+observe the chosen backend, or set a wait timeout. Lock keys use the same stable
+structured identity as process and Postgres advisory locks.
+
+Drain long-running processes that still use the legacy default before starting
+an upgraded process against the same shared state. The explicit `flock` backend
+remains available for compatibility, but it does not coordinate with the
+portable directory protocol.
 
 Use `processLock.withProcessLock()` when only threads in one process compete,
 `fileLock.withFileLock()` when local processes compete, and Postgres advisory
@@ -328,8 +332,8 @@ cached too.
 - `config` - scoped environment, dotenv, and validated Databricks bundle lookup,
   including runtime detection and typed coercion helpers.
 - `file` - best-effort filesystem stat.
-- `fileLock` - cascading cross-process locks using `flock` or portable lock
-  directories.
+- `fileLock` - portable cross-process lock directories shared by Bun and Node,
+  with an explicit legacy `flock` option.
 - `processLock` - keyed mutual exclusion across the main thread and its workers,
   with worker wiring (`processLockWorkerOptions`, `attachProcessLock`,
   `processLockAttached`).

package/index.ts

@@ -3,7 +3,7 @@
 // Hand edits are overwritten on the next watch; this file is read-only.
 
 export const PACKAGE_IDENTIFIER = "@dbx-tools/core";
-export const PACKAGE_VERSION = "0.6.223";
+export const PACKAGE_VERSION = "0.6.225";
 export * as bin from "./src/bin.ts";
 export * as brand from "./src/brand.ts";
 export * as bundle from "./src/bundle.ts";

package/lib/index.d.ts

@@ -1,5 +1,5 @@
 export declare const PACKAGE_IDENTIFIER = "@dbx-tools/core";
-export declare const PACKAGE_VERSION = "0.6.223";
+export declare const PACKAGE_VERSION = "0.6.225";
 export * as bin from "./src/bin.ts";
 export * as brand from "./src/brand.ts";
 export * as bundle from "./src/bundle.ts";

package/lib/index.js

@@ -2,7 +2,7 @@
 // Regenerated from the exporting modules in ./src.
 // Hand edits are overwritten on the next watch; this file is read-only.
 export const PACKAGE_IDENTIFIER = "@dbx-tools/core";
-export const PACKAGE_VERSION = "0.6.223";
+export const PACKAGE_VERSION = "0.6.225";
 export * as bin from "./src/bin.js";
 export * as brand from "./src/brand.js";
 export * as bundle from "./src/bundle.js";
@@ -15,4 +15,4 @@ export * as project from "./src/project.js";
 export { BrandContextSchema, defaultBrandContext, parseBrandContext, brandContextJsonSchema, brandContextPrompt } from "./src/brand.js";
 export { MAX_TCP_PORT, ENV_ONLY, valueSchema, bundleResourceSchema, bundleEnvEntrySchema, bundleAppSchema, appEnvEntrySchema, appSchema } from "./src/config.js";
 export { COMMAND_NOT_FOUND_EXIT_CODE } from "./src/exec.js";
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/lib/src/file-lock.d.ts

@@ -5,16 +5,14 @@
  * server) on the same key. For in-process / worker-thread exclusion use
  * {@link withProcessLock} from `./process-lock.ts` instead.
  *
- * Backends, in order:
+ * Backends:
  *
- * 1. **flock** — `flock(2)` via Bun FFI on Unix when `bun:ffi` can load libc.
- *    Not available on Windows, and not available under plain Node (no FFI).
- *    Kernel releases the lock when the fd closes (including process death).
- * 2. **file** — atomic lock-directory creation. This is the strategy used by
- *    `proper-lockfile`: `mkdir` is atomic on Windows, Unix, and network file
- *    systems where `open(..., "wx")` may not be reliable. Stale detection is
- *    always on (fixed {@link STALE_MS} + heartbeat) so a crashed holder on this
- *    backend can be reclaimed.
+ * 1. **file** (default) — `proper-lockfile` atomic lock-directory creation,
+ *    heartbeat, stale recovery, and ownership-safe release. Bun and Node use
+ *    this same protocol.
+ * 2. **flock** (explicit compatibility option) — `flock(2)` via Bun FFI on
+ *    Unix. It remains available to callers that selected it explicitly, but a
+ *    runtime-dependent cascade cannot coordinate Bun and Node.
  *
  * The first backend that can be *initialized* is used for the whole call. A busy
  * lock waits; an unavailable backend falls through to the next. Callers may only
@@ -34,7 +32,7 @@ export interface FileLockOptions {
      * Directory for lockfiles. Defaults to `$TMPDIR/dbx-tools-locks`.
      */
     dir?: string;
-    /** Override the cascade. Defaults to `flock` → `file`. */
+    /** Override the backend list. Defaults to the portable `file` protocol. */
     backends?: readonly FileLockBackend[];
     /**
      * Stop waiting and throw after this many milliseconds. Omit to poll forever.

package/lib/src/file-lock.js

@@ -5,16 +5,14 @@
  * server) on the same key. For in-process / worker-thread exclusion use
  * {@link withProcessLock} from `./process-lock.ts` instead.
  *
- * Backends, in order:
+ * Backends:
  *
- * 1. **flock** — `flock(2)` via Bun FFI on Unix when `bun:ffi` can load libc.
- *    Not available on Windows, and not available under plain Node (no FFI).
- *    Kernel releases the lock when the fd closes (including process death).
- * 2. **file** — atomic lock-directory creation. This is the strategy used by
- *    `proper-lockfile`: `mkdir` is atomic on Windows, Unix, and network file
- *    systems where `open(..., "wx")` may not be reliable. Stale detection is
- *    always on (fixed {@link STALE_MS} + heartbeat) so a crashed holder on this
- *    backend can be reclaimed.
+ * 1. **file** (default) — `proper-lockfile` atomic lock-directory creation,
+ *    heartbeat, stale recovery, and ownership-safe release. Bun and Node use
+ *    this same protocol.
+ * 2. **flock** (explicit compatibility option) — `flock(2)` via Bun FFI on
+ *    Unix. It remains available to callers that selected it explicitly, but a
+ *    runtime-dependent cascade cannot coordinate Bun and Node.
  *
  * The first backend that can be *initialized* is used for the whole call. A busy
  * lock waits; an unavailable backend falls through to the next. Callers may only
@@ -31,12 +29,13 @@ var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExte
     }
     return path;
 };
-import { mkdir, open, rm, stat, utimes } from "node:fs/promises";
+import { mkdir, open } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { dirname, join } from "node:path";
 import { async, error, functionModule, hash, log, object } from "@dbx-tools/shared-core";
+import lockfile from "proper-lockfile";
 const logger = log.logger("core:file-lock");
-const DEFAULT_BACKENDS = ["flock", "file"];
+const DEFAULT_BACKENDS = ["file"];
 /** Poll interval while waiting for a contended OS lock. */
 const POLL_MS = 50;
 /**
@@ -84,7 +83,7 @@ export async function withFileLock(key, fn, options = {}) {
                 return holdFlock(lockPath, flock, deadline, fn);
             }
             case "file": {
-                const lockPath = join(dir, `${id}.lock`);
+                const lockPath = join(dir, id);
                 logger.debug("acquiring lock", { backend, key: id, path: lockPath });
                 options.onAcquire?.({ backend });
                 return holdLockDirectory(lockPath, deadline, fn);
@@ -162,69 +161,37 @@ async function waitForFlock(fd, flock, lockPath, deadline) {
     }
 }
 /**
- * Atomic lock-directory creation — the portable / Windows path.
- *
- * `mkdir` is the same primitive used by `proper-lockfile`: it is atomic across
- * supported local and network filesystems. The holder refreshes mtime on a fixed
- * heartbeat so a live long-running lock is never reclaimed; a crashed holder's
- * directory becomes reclaimable after {@link STALE_MS}.
+ * Portable lock-directory ownership through `proper-lockfile`.
  */
 async function holdLockDirectory(lockPath, deadline, fn) {
     await ensureParentDir(lockPath);
-    await acquireLockDirectory(lockPath, deadline);
-    const stopHeartbeat = startHeartbeat(lockPath);
+    const release = await acquireLockDirectory(lockPath, deadline);
     try {
         return await fn();
     }
     finally {
-        stopHeartbeat();
-        await rm(lockPath, { recursive: true, force: true }).catch(() => { });
+        await release();
     }
 }
 async function acquireLockDirectory(lockPath, deadline) {
     for (;;) {
         try {
-            await mkdir(lockPath);
-            return;
+            return await lockfile.lock(lockPath, {
+                realpath: false,
+                stale: STALE_MS,
+                update: UPDATE_MS,
+                retries: 0,
+            });
         }
         catch (cause) {
             const err = cause;
-            if (err.code !== "EEXIST")
+            if (err.code !== "ELOCKED")
                 throw error.toError(cause);
-            await maybeReclaimStale(lockPath);
             assertBeforeDeadline(lockPath, deadline);
             await async.sleep(POLL_MS);
         }
     }
 }
-async function maybeReclaimStale(lockPath) {
-    try {
-        const { mtimeMs } = await stat(lockPath);
-        const age = Date.now() - mtimeMs;
-        if (age < STALE_MS)
-            return;
-        logger.debug("reclaiming stale lock directory", { path: lockPath, ageMs: age });
-        await rm(lockPath, { recursive: true, force: true });
-    }
-    catch (cause) {
-        const err = cause;
-        if (err.code !== "ENOENT")
-            throw error.toError(cause);
-    }
-}
-function startHeartbeat(lockPath) {
-    const timer = setInterval(() => {
-        const now = new Date();
-        void utimes(lockPath, now, now).catch((cause) => {
-            logger.warn("file lock heartbeat failed", {
-                path: lockPath,
-                error: error.errorMessage(cause),
-            });
-        });
-    }, UPDATE_MS);
-    timer.unref();
-    return () => clearInterval(timer);
-}
 function assertBeforeDeadline(lockPath, deadline) {
     if (deadline !== undefined && Date.now() >= deadline) {
         throw new Error(`Timed out waiting for file lock: ${lockPath}`);
@@ -233,4 +200,4 @@ function assertBeforeDeadline(lockPath, deadline) {
 async function ensureParentDir(lockPath) {
     await mkdir(dirname(lockPath), { recursive: true });
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"file-lock.js","sourceRoot":"","sources":["../../src/file-lock.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Cascading cross-process mutual exclusion via a lockfile.\n *\n * Serializes concurrent *processes* (two `bun run demo` shells, a CLI beside a\n * server) on the same key. For in-process / worker-thread exclusion use\n * {@link withProcessLock} from `./process-lock.ts` instead.\n *\n * Backends, in order:\n *\n * 1. **flock** — `flock(2)` via Bun FFI on Unix when `bun:ffi` can load libc.\n *    Not available on Windows, and not available under plain Node (no FFI).\n *    Kernel releases the lock when the fd closes (including process death).\n * 2. **file** — atomic lock-directory creation. This is the strategy used by\n *    `proper-lockfile`: `mkdir` is atomic on Windows, Unix, and network file\n *    systems where `open(..., \"wx\")` may not be reliable. Stale detection is\n *    always on (fixed {@link STALE_MS} + heartbeat) so a crashed holder on this\n *    backend can be reclaimed.\n *\n * The first backend that can be *initialized* is used for the whole call. A busy\n * lock waits; an unavailable backend falls through to the next. Callers may only\n * bound how long to wait ({@link FileLockOptions.timeoutMs}); stale timing is\n * not configurable so every holder and waiter agrees.\n *\n * @module\n */\n\nimport { mkdir, open, rm, stat, utimes } from \"node:fs/promises\";\nimport { tmpdir } from \"node:os\";\nimport { dirname, join } from \"node:path\";\n\nimport { async, error, functionModule, hash, log, object } from \"@dbx-tools/shared-core\";\n\nconst logger = log.logger(\"core:file-lock\");\n\n/** Backends {@link withFileLock} can attempt, in cascade order. */\nexport type FileLockBackend = \"flock\" | \"file\";\n\nconst DEFAULT_BACKENDS: readonly FileLockBackend[] = [\"flock\", \"file\"];\n\n/** Poll interval while waiting for a contended OS lock. */\nconst POLL_MS = 50;\n\n/**\n * Age after which an unrefreshed lock directory may be removed.\n * Matches `proper-lockfile`'s default. Not caller-configurable: every process\n * must share the same threshold or a live holder can be mistaken for stale.\n */\nconst STALE_MS = object.toNumber(process.env.FILE_LOCK_STALE_MS) ?? 10_000;\n\n/** Heartbeat interval for refreshing lock-directory mtime (`STALE_MS / 2`). */\nconst UPDATE_MS = object.toNumber(process.env.FILE_LOCK_UPDATE_MS) ?? STALE_MS / 2;\n\n/** `flock(2)` operation bits (Linux / macOS / BSD). */\nconst LOCK_EX = 2;\nconst LOCK_NB = 4;\nconst LOCK_UN = 8;\n\n/** Result metadata when a caller wants to know which backend ran. */\nexport interface FileLockAcquisition {\n  backend: FileLockBackend;\n}\n\nexport interface FileLockOptions {\n  /**\n   * Directory for lockfiles. Defaults to `$TMPDIR/dbx-tools-locks`.\n   */\n  dir?: string;\n  /** Override the cascade. Defaults to `flock` → `file`. */\n  backends?: readonly FileLockBackend[];\n  /**\n   * Stop waiting and throw after this many milliseconds. Omit to poll forever.\n   * This is the only wait-loop knob; stale reclaim timing is fixed.\n   */\n  timeoutMs?: number;\n  /** Invoked once the backend for this call has been chosen. */\n  onAcquire?: (acquisition: FileLockAcquisition) => void;\n}\n\ntype FlockFn = (fd: number, operation: number) => number;\n\ninterface BunFfiModule {\n  dlopen: (\n    path: string,\n    symbols: Record<string, { args: string[]; returns: string }>,\n  ) => { symbols: { flock: FlockFn } };\n  suffix: string;\n}\n\n/**\n * Run `fn` while holding a cross-process lock named by `key`.\n *\n * `key` is canonicalized with `object.toStableKey`, the same identity rule as\n * process and Postgres advisory locks.\n *\n * @example\n * await withFileLock([\"cache\", \"appkit\"], async () => {\n *   await migrate();\n * });\n */\nexport async function withFileLock<T>(\n  key: unknown,\n  fn: () => T | Promise<T>,\n  options: FileLockOptions = {},\n): Promise<T> {\n  if (options.timeoutMs !== undefined && options.timeoutMs < 0) {\n    throw new TypeError(\"timeoutMs must be non-negative\");\n  }\n  const id = lockId(key);\n  const backends = options.backends ?? DEFAULT_BACKENDS;\n  const dir = options.dir ?? join(tmpdir(), \"dbx-tools-locks\");\n  const deadline = options.timeoutMs === undefined ? undefined : Date.now() + options.timeoutMs;\n\n  for (const backend of backends) {\n    switch (backend) {\n      case \"flock\": {\n        const lockPath = join(dir, `${id}.flock`);\n        const flock = await resolveFlock();\n        if (!flock) {\n          logger.debug(\"lock backend unavailable\", { backend, key: id });\n          continue;\n        }\n        logger.debug(\"acquiring lock\", { backend, key: id, path: lockPath });\n        options.onAcquire?.({ backend });\n        return holdFlock(lockPath, flock, deadline, fn);\n      }\n      case \"file\": {\n        const lockPath = join(dir, `${id}.lock`);\n        logger.debug(\"acquiring lock\", { backend, key: id, path: lockPath });\n        options.onAcquire?.({ backend });\n        return holdLockDirectory(lockPath, deadline, fn);\n      }\n      default: {\n        const _exhaustive: never = backend;\n        throw new Error(`unknown file-lock backend: ${String(_exhaustive)}`);\n      }\n    }\n  }\n\n  throw new Error(\"withFileLock: no lock backend available\");\n}\n\n/** Canonical filesystem-safe id for a lock key. */\nfunction lockId(key: unknown): string {\n  const stable = object\n    .toOneOrMany(key)\n    .map((part) => object.toStableKey(part))\n    .join(\"\\u0000\");\n  // Short digest so paths stay well under OS limits; collisions are fine — they\n  // only merge critical sections that already shared a key string.\n  return hash.fnvHash(stable);\n}\n\n/**\n * Resolve `flock(2)` through Bun FFI when possible.\n *\n * Memoized: the FFI import + libc `dlopen` run once per process. Returns\n * `undefined` on Windows, under plain Node, or when libc cannot be loaded —\n * callers fall through to the next backend. A miss is cached too, so a process\n * that cannot flock never retries the load.\n */\nconst resolveFlock = functionModule.memoize(async (): Promise<FlockFn | undefined> => {\n  if (process.platform === \"win32\") return undefined;\n  if (!process.versions.bun) return undefined;\n\n  try {\n    // Dynamic specifier so `tsc` (no `@types` for `bun:ffi`) does not resolve it;\n    // the import only succeeds under Bun at runtime.\n    const specifier = \"bun:ffi\";\n    const ffi = (await import(specifier)) as unknown as BunFfiModule;\n    const libPath = process.platform === \"darwin\" ? \"libSystem.B.dylib\" : `libc.${ffi.suffix}`;\n    const lib = ffi.dlopen(libPath, {\n      flock: { args: [\"i32\", \"i32\"], returns: \"i32\" },\n    });\n    return lib.symbols.flock;\n  } catch (cause) {\n    logger.debug(\"flock FFI unavailable\", { error: error.errorMessage(cause) });\n    return undefined;\n  }\n});\n\nasync function holdFlock<T>(\n  lockPath: string,\n  flock: FlockFn,\n  deadline: number | undefined,\n  fn: () => T | Promise<T>,\n): Promise<T> {\n  await ensureParentDir(lockPath);\n  const handle = await open(lockPath, \"a+\");\n  try {\n    await waitForFlock(handle.fd, flock, lockPath, deadline);\n    try {\n      return await fn();\n    } finally {\n      flock(handle.fd, LOCK_UN);\n    }\n  } finally {\n    await handle.close().catch(() => {});\n  }\n}\n\nasync function waitForFlock(\n  fd: number,\n  flock: FlockFn,\n  lockPath: string,\n  deadline: number | undefined,\n): Promise<void> {\n  for (;;) {\n    const rc = flock(fd, LOCK_EX | LOCK_NB);\n    if (rc === 0) return;\n    assertBeforeDeadline(lockPath, deadline);\n    await async.sleep(POLL_MS);\n  }\n}\n\n/**\n * Atomic lock-directory creation — the portable / Windows path.\n *\n * `mkdir` is the same primitive used by `proper-lockfile`: it is atomic across\n * supported local and network filesystems. The holder refreshes mtime on a fixed\n * heartbeat so a live long-running lock is never reclaimed; a crashed holder's\n * directory becomes reclaimable after {@link STALE_MS}.\n */\nasync function holdLockDirectory<T>(\n  lockPath: string,\n  deadline: number | undefined,\n  fn: () => T | Promise<T>,\n): Promise<T> {\n  await ensureParentDir(lockPath);\n  await acquireLockDirectory(lockPath, deadline);\n  const stopHeartbeat = startHeartbeat(lockPath);\n  try {\n    return await fn();\n  } finally {\n    stopHeartbeat();\n    await rm(lockPath, { recursive: true, force: true }).catch(() => {});\n  }\n}\n\nasync function acquireLockDirectory(lockPath: string, deadline: number | undefined): Promise<void> {\n  for (;;) {\n    try {\n      await mkdir(lockPath);\n      return;\n    } catch (cause) {\n      const err = cause as NodeJS.ErrnoException;\n      if (err.code !== \"EEXIST\") throw error.toError(cause);\n      await maybeReclaimStale(lockPath);\n      assertBeforeDeadline(lockPath, deadline);\n      await async.sleep(POLL_MS);\n    }\n  }\n}\n\nasync function maybeReclaimStale(lockPath: string): Promise<void> {\n  try {\n    const { mtimeMs } = await stat(lockPath);\n    const age = Date.now() - mtimeMs;\n    if (age < STALE_MS) return;\n    logger.debug(\"reclaiming stale lock directory\", { path: lockPath, ageMs: age });\n    await rm(lockPath, { recursive: true, force: true });\n  } catch (cause) {\n    const err = cause as NodeJS.ErrnoException;\n    if (err.code !== \"ENOENT\") throw error.toError(cause);\n  }\n}\n\nfunction startHeartbeat(lockPath: string): () => void {\n  const timer = setInterval(() => {\n    const now = new Date();\n    void utimes(lockPath, now, now).catch((cause) => {\n      logger.warn(\"file lock heartbeat failed\", {\n        path: lockPath,\n        error: error.errorMessage(cause),\n      });\n    });\n  }, UPDATE_MS);\n  timer.unref();\n  return () => clearInterval(timer);\n}\n\nfunction assertBeforeDeadline(lockPath: string, deadline: number | undefined): void {\n  if (deadline !== undefined && Date.now() >= deadline) {\n    throw new Error(`Timed out waiting for file lock: ${lockPath}`);\n  }\n}\n\nasync function ensureParentDir(lockPath: string): Promise<void> {\n  await mkdir(dirname(lockPath), { recursive: true });\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"file-lock.js","sourceRoot":"","sources":["../../src/file-lock.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Cascading cross-process mutual exclusion via a lockfile.\n *\n * Serializes concurrent *processes* (two `bun run demo` shells, a CLI beside a\n * server) on the same key. For in-process / worker-thread exclusion use\n * {@link withProcessLock} from `./process-lock.ts` instead.\n *\n * Backends:\n *\n * 1. **file** (default) — `proper-lockfile` atomic lock-directory creation,\n *    heartbeat, stale recovery, and ownership-safe release. Bun and Node use\n *    this same protocol.\n * 2. **flock** (explicit compatibility option) — `flock(2)` via Bun FFI on\n *    Unix. It remains available to callers that selected it explicitly, but a\n *    runtime-dependent cascade cannot coordinate Bun and Node.\n *\n * The first backend that can be *initialized* is used for the whole call. A busy\n * lock waits; an unavailable backend falls through to the next. Callers may only\n * bound how long to wait ({@link FileLockOptions.timeoutMs}); stale timing is\n * not configurable so every holder and waiter agrees.\n *\n * @module\n */\n\nimport { mkdir, open } from \"node:fs/promises\";\nimport { tmpdir } from \"node:os\";\nimport { dirname, join } from \"node:path\";\n\nimport { async, error, functionModule, hash, log, object } from \"@dbx-tools/shared-core\";\nimport lockfile from \"proper-lockfile\";\n\nconst logger = log.logger(\"core:file-lock\");\n\n/** Backends {@link withFileLock} can attempt, in cascade order. */\nexport type FileLockBackend = \"flock\" | \"file\";\n\nconst DEFAULT_BACKENDS: readonly FileLockBackend[] = [\"file\"];\n\n/** Poll interval while waiting for a contended OS lock. */\nconst POLL_MS = 50;\n\n/**\n * Age after which an unrefreshed lock directory may be removed.\n * Matches `proper-lockfile`'s default. Not caller-configurable: every process\n * must share the same threshold or a live holder can be mistaken for stale.\n */\nconst STALE_MS = object.toNumber(process.env.FILE_LOCK_STALE_MS) ?? 10_000;\n\n/** Heartbeat interval for refreshing lock-directory mtime (`STALE_MS / 2`). */\nconst UPDATE_MS = object.toNumber(process.env.FILE_LOCK_UPDATE_MS) ?? STALE_MS / 2;\n\n/** `flock(2)` operation bits (Linux / macOS / BSD). */\nconst LOCK_EX = 2;\nconst LOCK_NB = 4;\nconst LOCK_UN = 8;\n\n/** Result metadata when a caller wants to know which backend ran. */\nexport interface FileLockAcquisition {\n  backend: FileLockBackend;\n}\n\nexport interface FileLockOptions {\n  /**\n   * Directory for lockfiles. Defaults to `$TMPDIR/dbx-tools-locks`.\n   */\n  dir?: string;\n  /** Override the backend list. Defaults to the portable `file` protocol. */\n  backends?: readonly FileLockBackend[];\n  /**\n   * Stop waiting and throw after this many milliseconds. Omit to poll forever.\n   * This is the only wait-loop knob; stale reclaim timing is fixed.\n   */\n  timeoutMs?: number;\n  /** Invoked once the backend for this call has been chosen. */\n  onAcquire?: (acquisition: FileLockAcquisition) => void;\n}\n\ntype FlockFn = (fd: number, operation: number) => number;\n\ninterface BunFfiModule {\n  dlopen: (\n    path: string,\n    symbols: Record<string, { args: string[]; returns: string }>,\n  ) => { symbols: { flock: FlockFn } };\n  suffix: string;\n}\n\n/**\n * Run `fn` while holding a cross-process lock named by `key`.\n *\n * `key` is canonicalized with `object.toStableKey`, the same identity rule as\n * process and Postgres advisory locks.\n *\n * @example\n * await withFileLock([\"cache\", \"appkit\"], async () => {\n *   await migrate();\n * });\n */\nexport async function withFileLock<T>(\n  key: unknown,\n  fn: () => T | Promise<T>,\n  options: FileLockOptions = {},\n): Promise<T> {\n  if (options.timeoutMs !== undefined && options.timeoutMs < 0) {\n    throw new TypeError(\"timeoutMs must be non-negative\");\n  }\n  const id = lockId(key);\n  const backends = options.backends ?? DEFAULT_BACKENDS;\n  const dir = options.dir ?? join(tmpdir(), \"dbx-tools-locks\");\n  const deadline = options.timeoutMs === undefined ? undefined : Date.now() + options.timeoutMs;\n\n  for (const backend of backends) {\n    switch (backend) {\n      case \"flock\": {\n        const lockPath = join(dir, `${id}.flock`);\n        const flock = await resolveFlock();\n        if (!flock) {\n          logger.debug(\"lock backend unavailable\", { backend, key: id });\n          continue;\n        }\n        logger.debug(\"acquiring lock\", { backend, key: id, path: lockPath });\n        options.onAcquire?.({ backend });\n        return holdFlock(lockPath, flock, deadline, fn);\n      }\n      case \"file\": {\n        const lockPath = join(dir, id);\n        logger.debug(\"acquiring lock\", { backend, key: id, path: lockPath });\n        options.onAcquire?.({ backend });\n        return holdLockDirectory(lockPath, deadline, fn);\n      }\n      default: {\n        const _exhaustive: never = backend;\n        throw new Error(`unknown file-lock backend: ${String(_exhaustive)}`);\n      }\n    }\n  }\n\n  throw new Error(\"withFileLock: no lock backend available\");\n}\n\n/** Canonical filesystem-safe id for a lock key. */\nfunction lockId(key: unknown): string {\n  const stable = object\n    .toOneOrMany(key)\n    .map((part) => object.toStableKey(part))\n    .join(\"\\u0000\");\n  // Short digest so paths stay well under OS limits; collisions are fine — they\n  // only merge critical sections that already shared a key string.\n  return hash.fnvHash(stable);\n}\n\n/**\n * Resolve `flock(2)` through Bun FFI when possible.\n *\n * Memoized: the FFI import + libc `dlopen` run once per process. Returns\n * `undefined` on Windows, under plain Node, or when libc cannot be loaded —\n * callers fall through to the next backend. A miss is cached too, so a process\n * that cannot flock never retries the load.\n */\nconst resolveFlock = functionModule.memoize(async (): Promise<FlockFn | undefined> => {\n  if (process.platform === \"win32\") return undefined;\n  if (!process.versions.bun) return undefined;\n\n  try {\n    // Dynamic specifier so `tsc` (no `@types` for `bun:ffi`) does not resolve it;\n    // the import only succeeds under Bun at runtime.\n    const specifier = \"bun:ffi\";\n    const ffi = (await import(specifier)) as unknown as BunFfiModule;\n    const libPath = process.platform === \"darwin\" ? \"libSystem.B.dylib\" : `libc.${ffi.suffix}`;\n    const lib = ffi.dlopen(libPath, {\n      flock: { args: [\"i32\", \"i32\"], returns: \"i32\" },\n    });\n    return lib.symbols.flock;\n  } catch (cause) {\n    logger.debug(\"flock FFI unavailable\", { error: error.errorMessage(cause) });\n    return undefined;\n  }\n});\n\nasync function holdFlock<T>(\n  lockPath: string,\n  flock: FlockFn,\n  deadline: number | undefined,\n  fn: () => T | Promise<T>,\n): Promise<T> {\n  await ensureParentDir(lockPath);\n  const handle = await open(lockPath, \"a+\");\n  try {\n    await waitForFlock(handle.fd, flock, lockPath, deadline);\n    try {\n      return await fn();\n    } finally {\n      flock(handle.fd, LOCK_UN);\n    }\n  } finally {\n    await handle.close().catch(() => {});\n  }\n}\n\nasync function waitForFlock(\n  fd: number,\n  flock: FlockFn,\n  lockPath: string,\n  deadline: number | undefined,\n): Promise<void> {\n  for (;;) {\n    const rc = flock(fd, LOCK_EX | LOCK_NB);\n    if (rc === 0) return;\n    assertBeforeDeadline(lockPath, deadline);\n    await async.sleep(POLL_MS);\n  }\n}\n\n/**\n * Portable lock-directory ownership through `proper-lockfile`.\n */\nasync function holdLockDirectory<T>(\n  lockPath: string,\n  deadline: number | undefined,\n  fn: () => T | Promise<T>,\n): Promise<T> {\n  await ensureParentDir(lockPath);\n  const release = await acquireLockDirectory(lockPath, deadline);\n  try {\n    return await fn();\n  } finally {\n    await release();\n  }\n}\n\nasync function acquireLockDirectory(\n  lockPath: string,\n  deadline: number | undefined,\n): Promise<() => Promise<void>> {\n  for (;;) {\n    try {\n      return await lockfile.lock(lockPath, {\n        realpath: false,\n        stale: STALE_MS,\n        update: UPDATE_MS,\n        retries: 0,\n      });\n    } catch (cause) {\n      const err = cause as NodeJS.ErrnoException;\n      if (err.code !== \"ELOCKED\") throw error.toError(cause);\n      assertBeforeDeadline(lockPath, deadline);\n      await async.sleep(POLL_MS);\n    }\n  }\n}\n\nfunction assertBeforeDeadline(lockPath: string, deadline: number | undefined): void {\n  if (deadline !== undefined && Date.now() >= deadline) {\n    throw new Error(`Timed out waiting for file lock: ${lockPath}`);\n  }\n}\n\nasync function ensureParentDir(lockPath: string): Promise<void> {\n  await mkdir(dirname(lockPath), { recursive: true });\n}\n"]}

package/package.json

@@ -21,11 +21,13 @@
   "devDependencies": {
     "@types/bun": "1.3.14",
     "@types/node": "^24.6.0",
+    "@types/proper-lockfile": "^4.1.4",
     "typescript": "^5.9.3"
   },
   "dependencies": {
-    "@dbx-tools/shared-core": "0.6.223",
+    "@dbx-tools/shared-core": "0.6.225",
     "extract-zip": "^2.0.1",
+    "proper-lockfile": "^4.1.2",
     "tar": "^7.5.22",
     "yaml": "^2.9.0",
     "zod": "4.3.6"
@@ -44,7 +46,7 @@
       "./package.json": "./package.json"
     }
   },
-  "version": "0.6.223",
+  "version": "0.6.225",
   "types": "./lib/index.d.ts",
   "type": "module",
   "exports": {

package/src/file-lock.ts

@@ -5,16 +5,14 @@
  * server) on the same key. For in-process / worker-thread exclusion use
  * {@link withProcessLock} from `./process-lock.ts` instead.
  *
- * Backends, in order:
+ * Backends:
  *
- * 1. **flock** — `flock(2)` via Bun FFI on Unix when `bun:ffi` can load libc.
- *    Not available on Windows, and not available under plain Node (no FFI).
- *    Kernel releases the lock when the fd closes (including process death).
- * 2. **file** — atomic lock-directory creation. This is the strategy used by
- *    `proper-lockfile`: `mkdir` is atomic on Windows, Unix, and network file
- *    systems where `open(..., "wx")` may not be reliable. Stale detection is
- *    always on (fixed {@link STALE_MS} + heartbeat) so a crashed holder on this
- *    backend can be reclaimed.
+ * 1. **file** (default) — `proper-lockfile` atomic lock-directory creation,
+ *    heartbeat, stale recovery, and ownership-safe release. Bun and Node use
+ *    this same protocol.
+ * 2. **flock** (explicit compatibility option) — `flock(2)` via Bun FFI on
+ *    Unix. It remains available to callers that selected it explicitly, but a
+ *    runtime-dependent cascade cannot coordinate Bun and Node.
  *
  * The first backend that can be *initialized* is used for the whole call. A busy
  * lock waits; an unavailable backend falls through to the next. Callers may only
@@ -24,18 +22,19 @@
  * @module
  */
 
-import { mkdir, open, rm, stat, utimes } from "node:fs/promises";
+import { mkdir, open } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { dirname, join } from "node:path";
 
 import { async, error, functionModule, hash, log, object } from "@dbx-tools/shared-core";
+import lockfile from "proper-lockfile";
 
 const logger = log.logger("core:file-lock");
 
 /** Backends {@link withFileLock} can attempt, in cascade order. */
 export type FileLockBackend = "flock" | "file";
 
-const DEFAULT_BACKENDS: readonly FileLockBackend[] = ["flock", "file"];
+const DEFAULT_BACKENDS: readonly FileLockBackend[] = ["file"];
 
 /** Poll interval while waiting for a contended OS lock. */
 const POLL_MS = 50;
@@ -65,7 +64,7 @@ export interface FileLockOptions {
    * Directory for lockfiles. Defaults to `$TMPDIR/dbx-tools-locks`.
    */
   dir?: string;
-  /** Override the cascade. Defaults to `flock` → `file`. */
+  /** Override the backend list. Defaults to the portable `file` protocol. */
   backends?: readonly FileLockBackend[];
   /**
    * Stop waiting and throw after this many milliseconds. Omit to poll forever.
@@ -124,7 +123,7 @@ export async function withFileLock<T>(
         return holdFlock(lockPath, flock, deadline, fn);
       }
       case "file": {
-        const lockPath = join(dir, `${id}.lock`);
+        const lockPath = join(dir, id);
         logger.debug("acquiring lock", { backend, key: id, path: lockPath });
         options.onAcquire?.({ backend });
         return holdLockDirectory(lockPath, deadline, fn);
@@ -213,12 +212,7 @@ async function waitForFlock(
 }
 
 /**
- * Atomic lock-directory creation — the portable / Windows path.
- *
- * `mkdir` is the same primitive used by `proper-lockfile`: it is atomic across
- * supported local and network filesystems. The holder refreshes mtime on a fixed
- * heartbeat so a live long-running lock is never reclaimed; a crashed holder's
- * directory becomes reclaimable after {@link STALE_MS}.
+ * Portable lock-directory ownership through `proper-lockfile`.
  */
 async function holdLockDirectory<T>(
   lockPath: string,
@@ -226,58 +220,35 @@ async function holdLockDirectory<T>(
   fn: () => T | Promise<T>,
 ): Promise<T> {
   await ensureParentDir(lockPath);
-  await acquireLockDirectory(lockPath, deadline);
-  const stopHeartbeat = startHeartbeat(lockPath);
+  const release = await acquireLockDirectory(lockPath, deadline);
   try {
     return await fn();
   } finally {
-    stopHeartbeat();
-    await rm(lockPath, { recursive: true, force: true }).catch(() => {});
+    await release();
   }
 }
 
-async function acquireLockDirectory(lockPath: string, deadline: number | undefined): Promise<void> {
+async function acquireLockDirectory(
+  lockPath: string,
+  deadline: number | undefined,
+): Promise<() => Promise<void>> {
   for (;;) {
     try {
-      await mkdir(lockPath);
-      return;
+      return await lockfile.lock(lockPath, {
+        realpath: false,
+        stale: STALE_MS,
+        update: UPDATE_MS,
+        retries: 0,
+      });
     } catch (cause) {
       const err = cause as NodeJS.ErrnoException;
-      if (err.code !== "EEXIST") throw error.toError(cause);
-      await maybeReclaimStale(lockPath);
+      if (err.code !== "ELOCKED") throw error.toError(cause);
       assertBeforeDeadline(lockPath, deadline);
       await async.sleep(POLL_MS);
     }
   }
 }
 
-async function maybeReclaimStale(lockPath: string): Promise<void> {
-  try {
-    const { mtimeMs } = await stat(lockPath);
-    const age = Date.now() - mtimeMs;
-    if (age < STALE_MS) return;
-    logger.debug("reclaiming stale lock directory", { path: lockPath, ageMs: age });
-    await rm(lockPath, { recursive: true, force: true });
-  } catch (cause) {
-    const err = cause as NodeJS.ErrnoException;
-    if (err.code !== "ENOENT") throw error.toError(cause);
-  }
-}
-
-function startHeartbeat(lockPath: string): () => void {
-  const timer = setInterval(() => {
-    const now = new Date();
-    void utimes(lockPath, now, now).catch((cause) => {
-      logger.warn("file lock heartbeat failed", {
-        path: lockPath,
-        error: error.errorMessage(cause),
-      });
-    });
-  }, UPDATE_MS);
-  timer.unref();
-  return () => clearInterval(timer);
-}
-
 function assertBeforeDeadline(lockPath: string, deadline: number | undefined): void {
   if (deadline !== undefined && Date.now() >= deadline) {
     throw new Error(`Timed out waiting for file lock: ${lockPath}`);