@dbx-tools/core 0.9.19 → 0.9.28

package/lib/src/file-lock.js

@@ -32,7 +32,12 @@ var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExte
 import { mkdir, open } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { dirname, join } from "node:path";
-import { asyncUtils, errorUtils, functionUtils, hash, log, object } from "@dbx-tools/shared-core";
+import * as asyncUtils from "@dbx-tools/shared-core/async-utils";
+import * as errorUtils from "@dbx-tools/shared-core/error-utils";
+import * as functionUtils from "@dbx-tools/shared-core/function-utils";
+import * as hash from "@dbx-tools/shared-core/hash";
+import * as log from "@dbx-tools/shared-core/log";
+import * as object from "@dbx-tools/shared-core/object";
 import lockfile from "proper-lockfile";
 const logger = log.logger("core:file-lock");
 const DEFAULT_BACKENDS = ["file"];
@@ -98,6 +103,51 @@ export async function withFileLock(key, fn, options = {}) {
     }
     throw new Error("withFileLock: no lock backend available");
 }
+/**
+ * Acquire a cross-process lock and return an explicit lease.
+ *
+ * Prefer {@link withFileLock} for ordinary JavaScript callers. This lower-level
+ * shape exists for storage adapters and cross-language bridges that cannot
+ * conveniently pass an async callback through their FFI boundary.
+ */
+export async function acquireFileLock(key, options = {}) {
+    let acquisition;
+    let resolveAcquired;
+    let rejectAcquired;
+    let resolveRelease;
+    const acquired = new Promise((resolve, reject) => {
+        resolveAcquired = resolve;
+        rejectAcquired = reject;
+    });
+    const released = new Promise((resolve) => {
+        resolveRelease = resolve;
+    });
+    const run = withFileLock(key, async () => {
+        resolveAcquired();
+        await released;
+    }, {
+        ...options,
+        onAcquire: (value) => {
+            acquisition = value;
+            options.onAcquire?.(value);
+        },
+    });
+    void run.catch(rejectAcquired);
+    await acquired;
+    if (!acquisition)
+        throw new Error("File-lock backend was not recorded");
+    let active = true;
+    return {
+        ...acquisition,
+        async release() {
+            if (!active)
+                return;
+            active = false;
+            resolveRelease();
+            await run;
+        },
+    };
+}
 /** Canonical filesystem-safe id for a lock key. */
 function lockId(key) {
     const stable = object
@@ -227,4 +277,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:\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 { asyncUtils, errorUtils, functionUtils, 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  /** Invoked once when the selected lock is already held by another process. */\n  onWait?: (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        const acquisition = { backend } as const;\n        options.onAcquire?.(acquisition);\n        return holdFlock(lockPath, flock, deadline, fn, () => options.onWait?.(acquisition));\n      }\n      case \"file\": {\n        const lockPath = join(dir, id);\n        logger.debug(\"acquiring lock\", { backend, key: id, path: lockPath });\n        const acquisition = { backend } as const;\n        options.onAcquire?.(acquisition);\n        return holdLockDirectory(lockPath, deadline, fn, () => options.onWait?.(acquisition));\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 = functionUtils.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: errorUtils.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  onWait: () => void,\n): Promise<T> {\n  await ensureParentDir(lockPath);\n  const handle = await open(lockPath, \"a+\");\n  try {\n    await waitForFlock(handle.fd, flock, lockPath, deadline, onWait);\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  onWait: () => void,\n): Promise<void> {\n  let waiting = false;\n  for (;;) {\n    const rc = flock(fd, LOCK_EX | LOCK_NB);\n    if (rc === 0) return;\n    if (!waiting) {\n      waiting = true;\n      onWait();\n    }\n    assertBeforeDeadline(lockPath, deadline);\n    await asyncUtils.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  onWait: () => void,\n): Promise<T> {\n  await ensureParentDir(lockPath);\n  const release = await acquireLockDirectory(lockPath, deadline, onWait);\n  let callbackError: unknown;\n  try {\n    return await fn();\n  } catch (error) {\n    callbackError = error;\n    throw error;\n  } finally {\n    try {\n      await release();\n    } catch (cause) {\n      if (callbackError === undefined || (cause as NodeJS.ErrnoException).code !== \"ERELEASED\") {\n        throw cause;\n      }\n      logger.warn(\"lock release was already completed after callback failure\", {\n        path: lockPath,\n      });\n    }\n  }\n}\n\nasync function acquireLockDirectory(\n  lockPath: string,\n  deadline: number | undefined,\n  onWait: () => void,\n): Promise<() => Promise<void>> {\n  let waiting = false;\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 errorUtils.toError(cause);\n      if (!waiting) {\n        waiting = true;\n        onWait();\n      }\n      assertBeforeDeadline(lockPath, deadline);\n      await asyncUtils.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"]}
+//# 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 * as asyncUtils from \"@dbx-tools/shared-core/async-utils\";\nimport * as errorUtils from \"@dbx-tools/shared-core/error-utils\";\nimport * as functionUtils from \"@dbx-tools/shared-core/function-utils\";\nimport * as hash from \"@dbx-tools/shared-core/hash\";\nimport * as log from \"@dbx-tools/shared-core/log\";\nimport * as object from \"@dbx-tools/shared-core/object\";\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  /** Invoked once when the selected lock is already held by another process. */\n  onWait?: (acquisition: FileLockAcquisition) => void;\n}\n\n/** Explicit cross-process lease returned by {@link acquireFileLock}. */\nexport interface FileLockLease extends FileLockAcquisition {\n  /** Release the held lock. Repeated calls are safe. */\n  release(): Promise<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        const acquisition = { backend } as const;\n        options.onAcquire?.(acquisition);\n        return holdFlock(lockPath, flock, deadline, fn, () => options.onWait?.(acquisition));\n      }\n      case \"file\": {\n        const lockPath = join(dir, id);\n        logger.debug(\"acquiring lock\", { backend, key: id, path: lockPath });\n        const acquisition = { backend } as const;\n        options.onAcquire?.(acquisition);\n        return holdLockDirectory(lockPath, deadline, fn, () => options.onWait?.(acquisition));\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/**\n * Acquire a cross-process lock and return an explicit lease.\n *\n * Prefer {@link withFileLock} for ordinary JavaScript callers. This lower-level\n * shape exists for storage adapters and cross-language bridges that cannot\n * conveniently pass an async callback through their FFI boundary.\n */\nexport async function acquireFileLock(\n  key: unknown,\n  options: FileLockOptions = {},\n): Promise<FileLockLease> {\n  let acquisition: FileLockAcquisition | undefined;\n  let resolveAcquired!: () => void;\n  let rejectAcquired!: (error: unknown) => void;\n  let resolveRelease!: () => void;\n  const acquired = new Promise<void>((resolve, reject) => {\n    resolveAcquired = resolve;\n    rejectAcquired = reject;\n  });\n  const released = new Promise<void>((resolve) => {\n    resolveRelease = resolve;\n  });\n  const run = withFileLock(\n    key,\n    async () => {\n      resolveAcquired();\n      await released;\n    },\n    {\n      ...options,\n      onAcquire: (value) => {\n        acquisition = value;\n        options.onAcquire?.(value);\n      },\n    },\n  );\n  void run.catch(rejectAcquired);\n  await acquired;\n  if (!acquisition) throw new Error(\"File-lock backend was not recorded\");\n\n  let active = true;\n  return {\n    ...acquisition,\n    async release() {\n      if (!active) return;\n      active = false;\n      resolveRelease();\n      await run;\n    },\n  };\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 = functionUtils.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: errorUtils.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  onWait: () => void,\n): Promise<T> {\n  await ensureParentDir(lockPath);\n  const handle = await open(lockPath, \"a+\");\n  try {\n    await waitForFlock(handle.fd, flock, lockPath, deadline, onWait);\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  onWait: () => void,\n): Promise<void> {\n  let waiting = false;\n  for (;;) {\n    const rc = flock(fd, LOCK_EX | LOCK_NB);\n    if (rc === 0) return;\n    if (!waiting) {\n      waiting = true;\n      onWait();\n    }\n    assertBeforeDeadline(lockPath, deadline);\n    await asyncUtils.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  onWait: () => void,\n): Promise<T> {\n  await ensureParentDir(lockPath);\n  const release = await acquireLockDirectory(lockPath, deadline, onWait);\n  let callbackError: unknown;\n  try {\n    return await fn();\n  } catch (error) {\n    callbackError = error;\n    throw error;\n  } finally {\n    try {\n      await release();\n    } catch (cause) {\n      if (callbackError === undefined || (cause as NodeJS.ErrnoException).code !== \"ERELEASED\") {\n        throw cause;\n      }\n      logger.warn(\"lock release was already completed after callback failure\", {\n        path: lockPath,\n      });\n    }\n  }\n}\n\nasync function acquireLockDirectory(\n  lockPath: string,\n  deadline: number | undefined,\n  onWait: () => void,\n): Promise<() => Promise<void>> {\n  let waiting = false;\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 errorUtils.toError(cause);\n      if (!waiting) {\n        waiting = true;\n        onWait();\n      }\n      assertBeforeDeadline(lockPath, deadline);\n      await asyncUtils.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

@@ -26,8 +26,7 @@
     "typescript": "^5.9.3"
   },
   "dependencies": {
-    "@dbx-tools/core-rs": "^0.9.19",
-    "@dbx-tools/shared-core": "^0.9.19",
+    "@dbx-tools/shared-core": "^0.9.28",
     "extract-zip": "^2.0.1",
     "proper-lockfile": "^4.1.2",
     "semver": "^7.7.3",
@@ -69,7 +68,7 @@
       "./package.json": "./package.json"
     }
   },
-  "version": "0.9.19",
+  "version": "0.9.28",
   "types": "./lib/index.d.ts",
   "type": "module",
   "exports": {

package/src/bin.ts

@@ -21,8 +21,10 @@ import { basename, join } from "node:path";
 import { fileURLToPath } from "node:url";
 import { promisify } from "node:util";
 
-import { errorUtils, log } from "@dbx-tools/shared-core";
+import * as errorUtils from "@dbx-tools/shared-core/error-utils";
+import * as log from "@dbx-tools/shared-core/log";
 import extractZip from "extract-zip";
+import { coerce, gte, type SemVer } from "semver";
 import { x as extractTar } from "tar";
 
 import { withFileLock } from "./file-lock.ts";
@@ -95,11 +97,6 @@ export interface BinUrlResolveContext {
 export interface BinSource {
   url: string;
   sha256?: string;
-  /**
-   * Skip `--version` on this candidate. Use when the source already identified
-   * the requested version, such as `cargo install --version`.
-   */
-  trustVersion?: boolean;
 }
 
 /** A download source resolved only when the executable is not already installed. */
@@ -172,25 +169,20 @@ export function parseVersion({ stdout, stderr }: BinVersionOutput): string | und
   return detectedVersions(stdout).at(0)?.raw ?? detectedVersions(stderr).at(0)?.raw;
 }
 
-function numericVersion(version: string, strict: boolean): number[] | undefined {
-  const pattern = strict ? /^\s*v?(\d+(?:\.\d+){0,2})\s*$/i : /\bv?(\d+(?:\.\d+){0,2})/i;
-  const match = pattern.exec(version);
-  return match?.[1]?.split(".").map(Number);
+function minimumSemVer(version: string): SemVer | undefined {
+  if (!/^\s*v?\d+(?:\.\d+){0,2}\s*$/i.test(version)) return undefined;
+  return coerce(version, { loose: true }) ?? undefined;
 }
 
-function meetsMinVersion(version: string, minVersion: string | undefined): boolean {
-  if (!minVersion) return true;
-  const actual = numericVersion(version, false);
-  const minimum = numericVersion(minVersion, true);
+/** Compare a detected tool version against a one-to-three-component minimum. */
+export function isVersionAtLeast(version: string, minVersion: string): boolean {
+  const minimum = minimumSemVer(minVersion);
   if (!minimum) {
     throw new TypeError(`invalid minimum binary version: ${minVersion}`);
   }
+  const actual = coerce(version, { loose: true });
   if (!actual) return false;
-  for (let index = 0; index < Math.max(actual.length, minimum.length); index += 1) {
-    const difference = (actual[index] ?? 0) - (minimum[index] ?? 0);
-    if (difference !== 0) return difference > 0;
-  }
-  return true;
+  return gte(actual, minimum);
 }
 
 async function isValidBin(path: string, options: BinOptions): Promise<boolean> {
@@ -227,7 +219,9 @@ async function isValidBin(path: string, options: BinOptions): Promise<boolean> {
     stdout,
     stderr,
   });
-  const valid = version !== undefined && meetsMinVersion(version, options.minVersion);
+  const valid =
+    version !== undefined &&
+    (options.minVersion === undefined || isVersionAtLeast(version, options.minVersion));
   logger.debug("binary version checked", {
     path,
     version,
@@ -367,7 +361,7 @@ export async function ensure(
   url: BinUrl,
   options: BinOptions = {},
 ): Promise<BinContext> {
-  if (options.minVersion && !numericVersion(options.minVersion, true)) {
+  if (options.minVersion && !minimumSemVer(options.minVersion)) {
     throw new TypeError(`invalid minimum binary version: ${options.minVersion}`);
   }
   const destination = context(name, options.homeDir ?? homedir(), options.destination);
@@ -400,13 +394,8 @@ export async function ensure(
       logger.debug("resolved binary source", { name, from });
       const selected = await selectedBin(destination, source, temp, options);
       await chmod(selected, 0o755);
-      const accepted = source.trustVersion ? { ...options, skipVersionCheck: true } : options;
-      if (!(await isValidBin(selected, accepted))) {
-        throw new Error(
-          source.trustVersion
-            ? `selected binary is not executable: ${selected}`
-            : `selected binary has no acceptable version: ${selected}`,
-        );
+      if (!(await isValidBin(selected, options))) {
+        throw new Error(`selected binary has no acceptable version: ${selected}`);
       }
 
       await mkdir(destination.binDir, { recursive: true });
@@ -415,7 +404,7 @@ export async function ensure(
       await chmod(staged, 0o755);
       await rename(staged, destination.path);
       staged = undefined;
-      if (!(await isValidBin(destination.path, accepted))) {
+      if (!(await isValidBin(destination.path, options))) {
         throw new Error(`installed binary is invalid after rename: ${destination.path}`);
       }
       logger.info("installed binary", {

package/src/config-utils.ts

@@ -30,8 +30,7 @@ import { spawnSync } from "node:child_process";
 import { readFileSync } from "node:fs";
 import { dirname, isAbsolute, relative, resolve, sep } from "node:path";
 import { parseEnv } from "node:util";
-import { isDatabricksAppEnvironment } from "@dbx-tools/core-rs";
-import { json, log, object, stringUtils } from "@dbx-tools/shared-core";
+import { environmentUtils, json, log, object, stringUtils } from "@dbx-tools/shared-core";
 import { parse as parseYaml } from "yaml";
 import { z } from "zod";
 import { cachedRecord, statSync } from "./file.ts";
@@ -251,11 +250,7 @@ export function getBundlePath(data: Record<string, unknown>, path: string): stri
 export function isDatabricksAppEnv(
   source: Record<string, string | undefined> = process.env,
 ): boolean {
-  return isDatabricksAppEnvironment(
-    new Map(
-      Object.entries(source).filter((entry): entry is [string, string] => entry[1] !== undefined),
-    ),
-  );
+  return environmentUtils.isDatabricksAppEnv(source);
 }
 
 /** Exact, uppercase, and tokenized-uppercase names for a human-friendly key. */

package/src/exec.ts

@@ -554,8 +554,15 @@ export function spawn(...args: SpawnArgs<ExecOptions>): ChildProcessResult {
       exitCode = await waitForExit(proc);
       await Promise.all([stdinWrite, ...reads]);
     } catch (err) {
-      await Promise.allSettled([stdinWrite, ...reads]);
-      if (!isCommandNotFoundError(err)) throw err;
+      if (!isCommandNotFoundError(err)) {
+        await Promise.allSettled([stdinWrite, ...reads]);
+        throw err;
+      }
+      proc.stdin?.destroy();
+      proc.stdout?.destroy();
+      proc.stderr?.destroy();
+      await Promise.allSettled([stdinWrite]);
+      for (const read of reads) void read.catch(() => undefined);
       commandNotFoundError = err;
       exitCode = COMMAND_NOT_FOUND_EXIT_CODE;
     }

package/src/file-lock.ts

@@ -26,7 +26,12 @@ import { mkdir, open } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { dirname, join } from "node:path";
 
-import { asyncUtils, errorUtils, functionUtils, hash, log, object } from "@dbx-tools/shared-core";
+import * as asyncUtils from "@dbx-tools/shared-core/async-utils";
+import * as errorUtils from "@dbx-tools/shared-core/error-utils";
+import * as functionUtils from "@dbx-tools/shared-core/function-utils";
+import * as hash from "@dbx-tools/shared-core/hash";
+import * as log from "@dbx-tools/shared-core/log";
+import * as object from "@dbx-tools/shared-core/object";
 import lockfile from "proper-lockfile";
 
 const logger = log.logger("core:file-lock");
@@ -77,6 +82,12 @@ export interface FileLockOptions {
   onWait?: (acquisition: FileLockAcquisition) => void;
 }
 
+/** Explicit cross-process lease returned by {@link acquireFileLock}. */
+export interface FileLockLease extends FileLockAcquisition {
+  /** Release the held lock. Repeated calls are safe. */
+  release(): Promise<void>;
+}
+
 type FlockFn = (fd: number, operation: number) => number;
 
 interface BunFfiModule {
@@ -142,6 +153,58 @@ export async function withFileLock<T>(
   throw new Error("withFileLock: no lock backend available");
 }
 
+/**
+ * Acquire a cross-process lock and return an explicit lease.
+ *
+ * Prefer {@link withFileLock} for ordinary JavaScript callers. This lower-level
+ * shape exists for storage adapters and cross-language bridges that cannot
+ * conveniently pass an async callback through their FFI boundary.
+ */
+export async function acquireFileLock(
+  key: unknown,
+  options: FileLockOptions = {},
+): Promise<FileLockLease> {
+  let acquisition: FileLockAcquisition | undefined;
+  let resolveAcquired!: () => void;
+  let rejectAcquired!: (error: unknown) => void;
+  let resolveRelease!: () => void;
+  const acquired = new Promise<void>((resolve, reject) => {
+    resolveAcquired = resolve;
+    rejectAcquired = reject;
+  });
+  const released = new Promise<void>((resolve) => {
+    resolveRelease = resolve;
+  });
+  const run = withFileLock(
+    key,
+    async () => {
+      resolveAcquired();
+      await released;
+    },
+    {
+      ...options,
+      onAcquire: (value) => {
+        acquisition = value;
+        options.onAcquire?.(value);
+      },
+    },
+  );
+  void run.catch(rejectAcquired);
+  await acquired;
+  if (!acquisition) throw new Error("File-lock backend was not recorded");
+
+  let active = true;
+  return {
+    ...acquisition,
+    async release() {
+      if (!active) return;
+      active = false;
+      resolveRelease();
+      await run;
+    },
+  };
+}
+
 /** Canonical filesystem-safe id for a lock key. */
 function lockId(key: unknown): string {
   const stable = object