@dbx-tools/core 0.6.64 → 0.6.66

package/README.md

@@ -1,6 +1,7 @@
 # @dbx-tools/core
 
-Node-only core helpers for process execution and project discovery.
+Node-only core helpers for binary installation, process execution, and project
+discovery.
 
 Import this package when code needs `node:child_process`, `node:fs`, or
 `node:path`. Browser-safe utilities live in
@@ -16,6 +17,36 @@ Key features:
   the current working directory.
 - Safe filesystem stat and project naming helpers for CLIs and projen synth.
 - YAML/JSON brand-context discovery and loading with shared Zod validation.
+- Idempotent executable downloads with zip/tar extraction and atomic installs.
+- Keyed mutual exclusion across the main thread and its worker threads.
+
+## Install A Binary
+
+```ts
+import { chmod } from "node:fs/promises";
+import { join } from "node:path";
+
+import { bin } from "@dbx-tools/core";
+
+const executable = await bin.ensure("tool", releaseUrl, {
+  autoUnpackage: true,
+  selector: async ({ source }) => {
+    const path = join(source, "tool");
+    await chmod(path, 0o755);
+    return path;
+  },
+});
+```
+
+`bin.ensure()` installs to `$HOME/.<name>/bin/<name>` and returns its `root`,
+`binDir`, and executable `path`. An existing executable returns immediately, so
+a URL resolver is only called when installation is necessary. Concurrent
+callers use `processLock` with a check-lock-check-load sequence, preventing
+duplicate downloads across the main thread and wired workers. Direct downloads
+are selected by default. Zip, tar, tar.gz, and tgz archives can be unpacked
+automatically; a single-file archive needs no selector, while a selector can
+choose and prepare a binary from a larger archive. The selected file must be
+executable before it is atomically moved into place.
 
 ## Load Brand Context
 
@@ -80,6 +111,50 @@ const argv = exec.shlex('pnpm exec prettier --write "README.md"');
 `shlex()` is a small parser for command strings that need to become argv arrays.
 Prefer explicit argv arrays when possible.
 
+## Serialize Work Across Threads
+
+```ts
+import { processLock } from "@dbx-tools/core";
+
+await processLock.withProcessLock(["cache", name], async () => {
+  if (!(await exists(name))) await build(name);
+});
+```
+
+`withProcessLock()` runs the callback while holding the named lock, releasing it
+when the callback settles. Callers sharing a key are serialized; distinct keys
+run concurrently. The key is any value with a stable identity - a string, a
+`["invoice", id]` tuple, a config object - canonicalized by `object.toStableKey`,
+so structure counts: `["invoice", 7]` and `"invoice_7"` are different locks.
+
+Use it instead of a module-level promise chain when worker threads are involved.
+A promise chain only serializes the thread it lives on, so a worker pool runs one
+callback per thread; the coordinator here is shared, so the key admits one
+callback for the whole process.
+
+Workers opt in when they are constructed:
+
+```ts
+import { Worker } from "node:worker_threads";
+
+new Worker(url, processLock.processLockWorkerOptions({ workerData: { tenant } }));
+```
+
+That preserves your own `workerData` and `transferList`, and lets the worker lock
+during module initialization. For a worker you did not construct, call
+`attachProcessLock(worker)` and have the worker `await processLockAttached()`
+first - the port arrives by message, so it is not available quite as early.
+
+A thread that exits while holding a lock releases it, so a crashed worker cannot
+wedge a key. Locks are held only as long as the callback runs, and an idle lock
+never keeps the process from exiting.
+
+The scope is the THREADS of one process - `withProcessLock` shares nothing with a
+second `node` invocation or another replica. When the critical section spans a
+deployment, use
+[`@dbx-tools/postgres`](../postgres)'s `withAdvisoryLock`, which puts the arbiter
+in PostgreSQL where every replica can see it.
+
 ## Discover Project Roots
 
 ```ts
@@ -97,6 +172,11 @@ basename. `project.stat()` returns `undefined` instead of throwing.
 ## Modules
 
 - `exec` - async/sync process spawning, stdio handling, abort wiring, and shlex.
+- `bin` - executable download, optional archive extraction, selection, and
+  atomic installation.
 - `project` - root discovery, project naming, git-remote parsing, and safe
   filesystem stat.
 - `brand` - YAML/JSON discovery, parsing, validation, and asset path resolution.
+- `processLock` - keyed mutual exclusion across the main thread and its workers,
+  with worker wiring (`processLockWorkerOptions`, `attachProcessLock`,
+  `processLockAttached`).

package/index.ts

@@ -2,10 +2,13 @@
 // Regenerated from the exporting modules in ./src.
 // Hand edits are overwritten on the next watch; this file is read-only.
 
+export * as bin from "./src/bin.ts";
 export * as brand from "./src/brand.ts";
 export * as exec from "./src/exec.ts";
 export * as file from "./src/file.ts";
+export * as processLock from "./src/process-lock.ts";
 export * as project from "./src/project.ts";
+export type { BinContext, BinSelectionContext, BinSelector, BinOptions, BinUrl } from "./src/bin.ts";
 export { BrandContextSchema, defaultBrandContext, parseBrandContext, brandContextJsonSchema, brandContextPrompt } from "./src/brand.ts";
 export type { BrandContext, BrandContextInput } from "./src/brand.ts";
 export { COMMAND_NOT_FOUND_EXIT_CODE } from "./src/exec.ts";

package/lib/index.d.ts

@@ -1,7 +1,10 @@
+export * as bin from "./src/bin.ts";
 export * as brand from "./src/brand.ts";
 export * as exec from "./src/exec.ts";
 export * as file from "./src/file.ts";
+export * as processLock from "./src/process-lock.ts";
 export * as project from "./src/project.ts";
+export type { BinContext, BinSelectionContext, BinSelector, BinOptions, BinUrl } from "./src/bin.ts";
 export { BrandContextSchema, defaultBrandContext, parseBrandContext, brandContextJsonSchema, brandContextPrompt } from "./src/brand.ts";
 export type { BrandContext, BrandContextInput } from "./src/brand.ts";
 export { COMMAND_NOT_FOUND_EXIT_CODE } from "./src/exec.ts";

package/lib/index.js

@@ -1,10 +1,12 @@
 // GENERATED by projen watch - DO NOT EDIT.
 // Regenerated from the exporting modules in ./src.
 // Hand edits are overwritten on the next watch; this file is read-only.
+export * as bin from "./src/bin.js";
 export * as brand from "./src/brand.js";
 export * as exec from "./src/exec.js";
 export * as file from "./src/file.js";
+export * as processLock from "./src/process-lock.js";
 export * as project from "./src/project.js";
 export { BrandContextSchema, defaultBrandContext, parseBrandContext, brandContextJsonSchema, brandContextPrompt } from "./src/brand.js";
 export { COMMAND_NOT_FOUND_EXIT_CODE } from "./src/exec.js";
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSwyQ0FBMkM7QUFDM0MsbURBQW1EO0FBQ25ELHdFQUF3RTtBQUV4RSxPQUFPLEtBQUssS0FBSyxNQUFNLGdCQUFnQixDQUFDO0FBQ3hDLE9BQU8sS0FBSyxJQUFJLE1BQU0sZUFBZSxDQUFDO0FBQ3RDLE9BQU8sS0FBSyxJQUFJLE1BQU0sZUFBZSxDQUFDO0FBQ3RDLE9BQU8sS0FBSyxPQUFPLE1BQU0sa0JBQWtCLENBQUM7QUFDNUMsT0FBTyxFQUFFLGtCQUFrQixFQUFFLG1CQUFtQixFQUFFLGlCQUFpQixFQUFFLHNCQUFzQixFQUFFLGtCQUFrQixFQUFFLE1BQU0sZ0JBQWdCLENBQUM7QUFFeEksT0FBTyxFQUFFLDJCQUEyQixFQUFFLE1BQU0sZUFBZSxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLy8gR0VORVJBVEVEIGJ5IHByb2plbiB3YXRjaCAtIERPIE5PVCBFRElULlxuLy8gUmVnZW5lcmF0ZWQgZnJvbSB0aGUgZXhwb3J0aW5nIG1vZHVsZXMgaW4gLi9zcmMuXG4vLyBIYW5kIGVkaXRzIGFyZSBvdmVyd3JpdHRlbiBvbiB0aGUgbmV4dCB3YXRjaDsgdGhpcyBmaWxlIGlzIHJlYWQtb25seS5cblxuZXhwb3J0ICogYXMgYnJhbmQgZnJvbSBcIi4vc3JjL2JyYW5kLnRzXCI7XG5leHBvcnQgKiBhcyBleGVjIGZyb20gXCIuL3NyYy9leGVjLnRzXCI7XG5leHBvcnQgKiBhcyBmaWxlIGZyb20gXCIuL3NyYy9maWxlLnRzXCI7XG5leHBvcnQgKiBhcyBwcm9qZWN0IGZyb20gXCIuL3NyYy9wcm9qZWN0LnRzXCI7XG5leHBvcnQgeyBCcmFuZENvbnRleHRTY2hlbWEsIGRlZmF1bHRCcmFuZENvbnRleHQsIHBhcnNlQnJhbmRDb250ZXh0LCBicmFuZENvbnRleHRKc29uU2NoZW1hLCBicmFuZENvbnRleHRQcm9tcHQgfSBmcm9tIFwiLi9zcmMvYnJhbmQudHNcIjtcbmV4cG9ydCB0eXBlIHsgQnJhbmRDb250ZXh0LCBCcmFuZENvbnRleHRJbnB1dCB9IGZyb20gXCIuL3NyYy9icmFuZC50c1wiO1xuZXhwb3J0IHsgQ09NTUFORF9OT1RfRk9VTkRfRVhJVF9DT0RFIH0gZnJvbSBcIi4vc3JjL2V4ZWMudHNcIjtcbmV4cG9ydCB0eXBlIHsgRXhlY1N0ZGlvLCBMaW5lSGFuZGxlciwgU3RkaW9PcHRpb24sIEV4ZWNSZXN1bHQsIENoaWxkUHJvY2Vzc1Jlc3VsdCwgRXhlY09wdGlvbnMsIFN5bmNFeGVjU3RkaW8sIFN5bmNFeGVjT3B0aW9ucywgU3Bhd25BcmdzIH0gZnJvbSBcIi4vc3JjL2V4ZWMudHNcIjtcbmV4cG9ydCB0eXBlIHsgUHJvamVjdENvbnRleHQgfSBmcm9tIFwiLi9zcmMvcHJvamVjdC50c1wiO1xuIl19
+//# sourceMappingURL=data:application/json;base64,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

package/lib/src/bin.d.ts

@@ -0,0 +1,31 @@
+/** Stable paths for an installed binary. */
+export interface BinContext {
+    root: string;
+    binDir: string;
+    path: string;
+}
+/** Temporary download and extraction paths supplied to a custom selector. */
+export interface BinSelectionContext {
+    destination: BinContext;
+    downloadPath: string;
+    source: string;
+}
+/**
+ * Select the executable from a download or unpacked archive. A selector may
+ * also prepare the file, such as applying its executable mode.
+ */
+export type BinSelector = (context: BinSelectionContext) => string | Promise<string>;
+/** Options for {@link ensure}. */
+export interface BinOptions {
+    autoUnpackage?: boolean;
+    selector?: BinSelector;
+    homeDir?: string;
+}
+/** A URL resolved only when the executable is not already installed. */
+export type BinUrl = string | (() => string | Promise<string>);
+/**
+ * Return an existing executable or install it atomically under
+ * `$HOME/.<name>/bin/<name>`. Installation uses a check-lock-check-load
+ * sequence so concurrent callers resolve and download the binary only once.
+ */
+export declare function ensure(name: string, url: BinUrl, options?: BinOptions): Promise<BinContext>;

package/lib/src/bin.js

@@ -0,0 +1,130 @@
+/**
+ * Install and reuse executable binaries under a per-tool home directory.
+ *
+ * @module
+ */
+import { randomUUID } from "node:crypto";
+import { constants } from "node:fs";
+import { access, chmod, copyFile, mkdir, mkdtemp, readdir, rename, rm, stat, writeFile, } from "node:fs/promises";
+import { homedir, tmpdir } from "node:os";
+import { basename, join } from "node:path";
+import extractZip from "extract-zip";
+import { x as extractTar } from "tar";
+import { withProcessLock } from "./process-lock.js";
+function context(name, homeDir) {
+    if (!name || basename(name) !== name || name === "." || name === "..") {
+        throw new TypeError(`invalid binary name: ${name}`);
+    }
+    const root = join(homeDir, `.${name}`);
+    const binDir = join(root, "bin");
+    return { root, binDir, path: join(binDir, name) };
+}
+async function isExecutable(path) {
+    try {
+        if (!(await stat(path)).isFile())
+            return false;
+        await access(path, constants.F_OK | constants.X_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function downloadName(url, name) {
+    try {
+        const candidate = basename(decodeURIComponent(new URL(url).pathname));
+        return candidate && Buffer.byteLength(candidate) <= 200 ? candidate : name;
+    }
+    catch {
+        return name;
+    }
+}
+async function unpack(archive, destination) {
+    const filename = archive.toLowerCase();
+    if (filename.endsWith(".zip")) {
+        await extractZip(archive, { dir: destination });
+        return;
+    }
+    if (filename.endsWith(".tar") || filename.endsWith(".tar.gz") || filename.endsWith(".tgz")) {
+        await extractTar({ file: archive, cwd: destination });
+        return;
+    }
+    throw new Error(`unsupported binary archive: ${basename(archive)}`);
+}
+async function filesUnder(root) {
+    const entries = await readdir(root, { withFileTypes: true });
+    const files = [];
+    for (const entry of entries) {
+        const path = join(root, entry.name);
+        if (entry.isDirectory()) {
+            files.push(...(await filesUnder(path)));
+        }
+        else if (entry.isFile()) {
+            files.push(path);
+        }
+    }
+    return files;
+}
+async function selectSingleFile(source) {
+    const files = await filesUnder(source);
+    const selected = files.at(0);
+    if (files.length !== 1 || !selected) {
+        throw new Error(`binary archive must contain one file, found ${files.length}`);
+    }
+    return selected;
+}
+async function selectedBin(destination, url, temp, options) {
+    const name = downloadName(url, basename(destination.path));
+    const downloadPath = join(temp, name);
+    const response = await fetch(url);
+    if (!response.ok) {
+        throw new Error(`binary download failed (${response.status})`);
+    }
+    await writeFile(downloadPath, Buffer.from(await response.arrayBuffer()), { mode: 0o755 });
+    let source = downloadPath;
+    if (options.autoUnpackage) {
+        source = join(temp, `unpacked-${randomUUID()}`);
+        await mkdir(source);
+        await unpack(downloadPath, source);
+    }
+    if (options.selector) {
+        return options.selector({ destination, downloadPath, source });
+    }
+    return options.autoUnpackage ? selectSingleFile(source) : source;
+}
+/**
+ * Return an existing executable or install it atomically under
+ * `$HOME/.<name>/bin/<name>`. Installation uses a check-lock-check-load
+ * sequence so concurrent callers resolve and download the binary only once.
+ */
+export async function ensure(name, url, options = {}) {
+    const destination = context(name, options.homeDir ?? homedir());
+    if (await isExecutable(destination.path))
+        return destination;
+    return withProcessLock(["bin.ensure", destination.path], async () => {
+        if (await isExecutable(destination.path))
+            return destination;
+        const resolvedUrl = typeof url === "function" ? await url() : url;
+        const temp = await mkdtemp(join(tmpdir(), `${name}-`));
+        let staged;
+        try {
+            const selected = await selectedBin(destination, resolvedUrl, temp, options);
+            if (!(await isExecutable(selected))) {
+                throw new Error(`selected binary is not executable: ${selected}`);
+            }
+            await mkdir(destination.binDir, { recursive: true });
+            staged = join(destination.binDir, `.${name}-${randomUUID()}`);
+            await copyFile(selected, staged);
+            await chmod(staged, (await stat(selected)).mode);
+            await rename(staged, destination.path);
+            staged = undefined;
+            return destination;
+        }
+        finally {
+            if (staged)
+                await rm(staged, { force: true });
+            await rm(temp, { recursive: true, force: true });
+        }
+    });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"bin.js","sourceRoot":"","sources":["../../src/bin.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Install and reuse executable binaries under a per-tool home directory.\n *\n * @module\n */\nimport { randomUUID } from \"node:crypto\";\nimport { constants } from \"node:fs\";\nimport {\n  access,\n  chmod,\n  copyFile,\n  mkdir,\n  mkdtemp,\n  readdir,\n  rename,\n  rm,\n  stat,\n  writeFile,\n} from \"node:fs/promises\";\nimport { homedir, tmpdir } from \"node:os\";\nimport { basename, join } from \"node:path\";\n\nimport extractZip from \"extract-zip\";\nimport { x as extractTar } from \"tar\";\n\nimport { withProcessLock } from \"./process-lock.ts\";\n\n/** Stable paths for an installed binary. */\nexport interface BinContext {\n  root: string;\n  binDir: string;\n  path: string;\n}\n\n/** Temporary download and extraction paths supplied to a custom selector. */\nexport interface BinSelectionContext {\n  destination: BinContext;\n  downloadPath: string;\n  source: string;\n}\n\n/**\n * Select the executable from a download or unpacked archive. A selector may\n * also prepare the file, such as applying its executable mode.\n */\nexport type BinSelector = (context: BinSelectionContext) => string | Promise<string>;\n\n/** Options for {@link ensure}. */\nexport interface BinOptions {\n  autoUnpackage?: boolean;\n  selector?: BinSelector;\n  homeDir?: string;\n}\n\n/** A URL resolved only when the executable is not already installed. */\nexport type BinUrl = string | (() => string | Promise<string>);\n\nfunction context(name: string, homeDir: string): BinContext {\n  if (!name || basename(name) !== name || name === \".\" || name === \"..\") {\n    throw new TypeError(`invalid binary name: ${name}`);\n  }\n  const root = join(homeDir, `.${name}`);\n  const binDir = join(root, \"bin\");\n  return { root, binDir, path: join(binDir, name) };\n}\n\nasync function isExecutable(path: string): Promise<boolean> {\n  try {\n    if (!(await stat(path)).isFile()) return false;\n    await access(path, constants.F_OK | constants.X_OK);\n    return true;\n  } catch {\n    return false;\n  }\n}\n\nfunction downloadName(url: string, name: string): string {\n  try {\n    const candidate = basename(decodeURIComponent(new URL(url).pathname));\n    return candidate && Buffer.byteLength(candidate) <= 200 ? candidate : name;\n  } catch {\n    return name;\n  }\n}\n\nasync function unpack(archive: string, destination: string): Promise<void> {\n  const filename = archive.toLowerCase();\n  if (filename.endsWith(\".zip\")) {\n    await extractZip(archive, { dir: destination });\n    return;\n  }\n  if (filename.endsWith(\".tar\") || filename.endsWith(\".tar.gz\") || filename.endsWith(\".tgz\")) {\n    await extractTar({ file: archive, cwd: destination });\n    return;\n  }\n  throw new Error(`unsupported binary archive: ${basename(archive)}`);\n}\n\nasync function filesUnder(root: string): Promise<string[]> {\n  const entries = await readdir(root, { withFileTypes: true });\n  const files: string[] = [];\n  for (const entry of entries) {\n    const path = join(root, entry.name);\n    if (entry.isDirectory()) {\n      files.push(...(await filesUnder(path)));\n    } else if (entry.isFile()) {\n      files.push(path);\n    }\n  }\n  return files;\n}\n\nasync function selectSingleFile(source: string): Promise<string> {\n  const files = await filesUnder(source);\n  const selected = files.at(0);\n  if (files.length !== 1 || !selected) {\n    throw new Error(`binary archive must contain one file, found ${files.length}`);\n  }\n  return selected;\n}\n\nasync function selectedBin(\n  destination: BinContext,\n  url: string,\n  temp: string,\n  options: BinOptions,\n): Promise<string> {\n  const name = downloadName(url, basename(destination.path));\n  const downloadPath = join(temp, name);\n  const response = await fetch(url);\n  if (!response.ok) {\n    throw new Error(`binary download failed (${response.status})`);\n  }\n  await writeFile(downloadPath, Buffer.from(await response.arrayBuffer()), { mode: 0o755 });\n\n  let source = downloadPath;\n  if (options.autoUnpackage) {\n    source = join(temp, `unpacked-${randomUUID()}`);\n    await mkdir(source);\n    await unpack(downloadPath, source);\n  }\n\n  if (options.selector) {\n    return options.selector({ destination, downloadPath, source });\n  }\n  return options.autoUnpackage ? selectSingleFile(source) : source;\n}\n\n/**\n * Return an existing executable or install it atomically under\n * `$HOME/.<name>/bin/<name>`. Installation uses a check-lock-check-load\n * sequence so concurrent callers resolve and download the binary only once.\n */\nexport async function ensure(\n  name: string,\n  url: BinUrl,\n  options: BinOptions = {},\n): Promise<BinContext> {\n  const destination = context(name, options.homeDir ?? homedir());\n  if (await isExecutable(destination.path)) return destination;\n\n  return withProcessLock([\"bin.ensure\", destination.path], async () => {\n    if (await isExecutable(destination.path)) return destination;\n\n    const resolvedUrl = typeof url === \"function\" ? await url() : url;\n    const temp = await mkdtemp(join(tmpdir(), `${name}-`));\n    let staged: string | undefined;\n    try {\n      const selected = await selectedBin(destination, resolvedUrl, temp, options);\n      if (!(await isExecutable(selected))) {\n        throw new Error(`selected binary is not executable: ${selected}`);\n      }\n\n      await mkdir(destination.binDir, { recursive: true });\n      staged = join(destination.binDir, `.${name}-${randomUUID()}`);\n      await copyFile(selected, staged);\n      await chmod(staged, (await stat(selected)).mode);\n      await rename(staged, destination.path);\n      staged = undefined;\n      return destination;\n    } finally {\n      if (staged) await rm(staged, { force: true });\n      await rm(temp, { recursive: true, force: true });\n    }\n  });\n}\n"]}

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

@@ -0,0 +1,88 @@
+/**
+ * Keyed mutual exclusion across the main thread and its worker threads.
+ *
+ * {@link withProcessLock} serializes callbacks that share a key: one runs at a
+ * time, the rest queue in arrival order, and different keys proceed
+ * concurrently. Unlike a plain in-module `Promise` chain, the queue is shared by
+ * every thread wired up through {@link processLockWorkerOptions}, so a worker
+ * pool cannot run two callbacks for the same key at once.
+ *
+ * The name says `process`: this coordinates the THREADS of one Node process. It
+ * is not cross-process and not cross-host - a second `node` invocation, or a
+ * second app replica, has its own coordinator and shares nothing. When the scope
+ * is a deployment rather than a process, use
+ * `@dbx-tools/postgres`'s `withAdvisoryLock`, which puts the arbiter in
+ * PostgreSQL where every replica can see it.
+ *
+ * The main thread owns the only coordinator. Each participating thread gets one
+ * `MessagePort` to it, and a lock is granted by a message back over that port.
+ * Consequently:
+ *
+ *   - the lock is ADVISORY, like Postgres advisory locks - it protects a
+ *     critical section only insofar as every writer takes the same key;
+ *   - fairness is FIFO per key, since the coordinator queues waiters in the
+ *     order their requests arrive;
+ *   - a thread that dies while holding a lock releases it, because its port
+ *     closing is what hands the key to the next waiter (see
+ *     {@link LockCoordinator.removePort}).
+ *
+ * @module
+ */
+import { type Worker, type WorkerOptions } from "node:worker_threads";
+/**
+ * Run `fn` while holding the lock named by `key`, releasing it when `fn`
+ * settles.
+ *
+ * Callers sharing a key are serialized across the main thread and every worker
+ * started through {@link processLockWorkerOptions}; distinct keys never block
+ * each other. Returns whatever `fn` returns and propagates what it throws, so it
+ * drops into an existing expression without restructuring.
+ *
+ * `key` is any value with a stable identity - a string, a `["invoice", id]`
+ * tuple, a config object - canonicalized by `object.toStableKey`, the same rule
+ * `@dbx-tools/postgres` uses for advisory-lock ids and channel names. Structure
+ * is part of the identity: `["invoice", 7]` and `"invoice_7"` are different
+ * locks.
+ *
+ * @example
+ * await withProcessLock(["cache", name], async () => {
+ *   if (!(await exists(name))) await build(name);
+ * });
+ */
+export declare function withProcessLock<T>(key: unknown, fn: () => T | Promise<T>): Promise<T>;
+/**
+ * Add the coordinator port to a `Worker`'s options so the worker can lock
+ * immediately - during module initialization, before any message is handled.
+ *
+ * Preserves the caller's `workerData` and `transferList`; the port is
+ * transferred, as `MessagePort` cannot be cloned.
+ *
+ * @example
+ * new Worker(url, processLockWorkerOptions({ workerData: { tenant } }));
+ */
+export declare function processLockWorkerOptions(options?: WorkerOptions): WorkerOptions;
+/**
+ * Wire an ALREADY-RUNNING worker into the lock, for a worker this code did not
+ * construct (a pool from a library, say).
+ *
+ * Prefer {@link processLockWorkerOptions}: the port arrives with a message, so
+ * the worker cannot lock during module initialization and must await
+ * {@link processLockAttached} first. The worker side needs no other change -
+ * `withProcessLock` works normally once the port lands.
+ */
+export declare function attachProcessLock(worker: Worker): void;
+/**
+ * In a worker, resolve once the {@link attachProcessLock} port has arrived.
+ *
+ * Only needed on the attach path, and safe to await regardless: it returns
+ * immediately when the worker already has a port (the
+ * {@link processLockWorkerOptions} case) or when called on the main thread, so
+ * shared worker code does not branch on how it was started.
+ *
+ * A `parentPort` listener keeps the worker alive, which is CORRECT here and
+ * deliberately not unref'd: this promise is pending work, and a worker allowed to
+ * exit while awaiting its port would die silently instead of locking. The
+ * listener is removed as soon as the port lands, so the worker is free to exit
+ * again the moment the wait is over.
+ */
+export declare function processLockAttached(): Promise<void>;