@dbx-tools/core 0.9.154 → 0.9.157

package/src/bundle.ts

@@ -11,7 +11,7 @@
 
 import { opendir, realpath, stat } from "node:fs/promises";
 import { dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
-import { json, object, stringUtils } from "@dbx-tools/shared-core";
+import { parseRecord, isRecord, optional, trimToNull } from "@dbx-tools/shared-core";
 import { spawn } from "./exec.ts";
 import { resolveWorkingDirectory, root } from "./project-utils.ts";
 
@@ -68,17 +68,14 @@ export async function* appResources(
   for await (const bundlePath of bundlePaths(boundary, startDirectory)) {
     const validated = await validateBundle(bundlePath, profile);
     for (const [key, config] of Object.entries(bundleApps(validated.data))) {
-      if (!object.isRecord(config)) continue;
+      if (!isRecord(config)) continue;
       yield {
         bundlePath,
         key,
         config,
         data: validated.data,
-        ...object.optional(
-          "sourceCodePath",
-          resolveSourceCodePath(bundlePath, config.source_code_path),
-        ),
-        ...object.optional("bundleFailure", validated.bundleFailure),
+        ...optional("sourceCodePath", resolveSourceCodePath(bundlePath, config.source_code_path)),
+        ...optional("bundleFailure", validated.bundleFailure),
       };
     }
   }
@@ -174,7 +171,7 @@ async function validateBundle(
       stderr: "capture",
     },
   );
-  const detail = stringUtils.trimToNull(result.stderr) ?? stringUtils.trimToNull(result.stdout);
+  const detail = trimToNull(result.stderr) ?? trimToNull(result.stdout);
   const bundleFailure =
     result.exitCode === 0
       ? undefined
@@ -184,17 +181,17 @@ async function validateBundle(
           }`,
         );
 
-  const parsed = json.parseRecord(result.stdout);
+  const parsed = parseRecord(result.stdout);
   if (!parsed) {
     if (bundleFailure) return { data: {}, bundleFailure };
     throw new Error(`Databricks CLI returned invalid bundle JSON for ${bundlePath}`);
   }
-  return { data: parsed, ...object.optional("bundleFailure", bundleFailure) };
+  return { data: parsed, ...optional("bundleFailure", bundleFailure) };
 }
 
 function bundleApps(bundle: Record<string, unknown>): Record<string, unknown> {
-  const resources = object.isRecord(bundle.resources) ? bundle.resources : undefined;
-  return object.isRecord(resources?.apps) ? resources.apps : {};
+  const resources = isRecord(bundle.resources) ? bundle.resources : undefined;
+  return isRecord(resources?.apps) ? resources.apps : {};
 }
 
 async function isFile(path: string): Promise<boolean> {

package/src/config-utils.ts

@@ -36,12 +36,19 @@ import { readFileSync } from "node:fs";
 import { dirname, isAbsolute, relative, resolve, sep } from "node:path";
 import { parseEnv } from "node:util";
 import {
-  environmentUtils,
-  json,
   log,
-  object,
-  options as sharedOptions,
-  stringUtils,
+  isDatabricksAppEnv,
+  parseRecord,
+  isRecord,
+  sequence,
+  type Sequence,
+  toBoolean,
+  tcpPortSchema,
+  tokenize,
+  trimToEmpty,
+  trimToNull,
+  parseList,
+  toNumber,
 } from "@dbx-tools/shared-core";
 import { parse as parseYaml } from "yaml";
 import { z } from "zod";
@@ -106,9 +113,6 @@ const NODE_ENV_ALTERNATIVES = {
   development: ["dev"],
 } as const satisfies Record<string, readonly string[]>;
 
-/** Highest valid TCP port number. */
-export const MAX_TCP_PORT = sharedOptions.MAX_TCP_PORT;
-
 /** Boolean environment override for project `.env` reads. */
 const CONFIG_DOTENV_KEY = "DBX_TOOLS_CONFIG_DOTENV";
 
@@ -130,9 +134,9 @@ export const valueSchema = z
     message: "Interpolated values are not allowed",
   });
 
-const portValueSchema = sharedOptions.tcpPortSchema;
+const portValueSchema = tcpPortSchema;
 
-const positiveNumberValue = z.preprocess((input) => object.toNumber(input), z.number().positive());
+const positiveNumberValue = z.preprocess((input) => toNumber(input), z.number().positive());
 const positiveIntValue = positiveNumberValue.transform(Math.floor);
 
 /** A named bundle or App resource; concrete resource fields pass through. */
@@ -228,7 +232,7 @@ function resourceValue(resource: unknown): string | undefined {
     ["postgres", "branch"],
   ] as const) {
     let value = resource;
-    for (const part of path) value = object.isRecord(value) ? value[part] : undefined;
+    for (const part of path) value = isRecord(value) ? value[part] : undefined;
     const parsed = valueSchema.safeParse(value);
     if (parsed.success) return parsed.data;
   }
@@ -241,12 +245,12 @@ export function getBundlePath(data: Record<string, unknown>, path: string): stri
   if (parts.length === 0) return undefined;
   let current: unknown = data;
   for (let index = 0; index < parts.length; index++) {
-    if (!object.isRecord(current)) return undefined;
+    if (!isRecord(current)) return undefined;
     const next = current[parts[index]!];
     if (index === parts.length - 1) {
       const direct = valueSchema.safeParse(next);
       if (direct.success) return direct.data;
-      if (object.isRecord(next)) {
+      if (isRecord(next)) {
         const nested = valueSchema.safeParse(next.value);
         return nested.success ? nested.data : undefined;
       }
@@ -261,12 +265,11 @@ export function getBundlePath(data: Record<string, unknown>, path: string): stri
 export function environmentKeys(name: string): readonly string[] {
   const trimmed = name.trim();
   if (!trimmed) return [];
-  return object
-    .sequence(
-      trimmed,
-      trimmed.toUpperCase(),
-      Array.from(stringUtils.tokenize(trimmed)).join("_").toUpperCase(),
-    )
+  return sequence(
+    trimmed,
+    trimmed.toUpperCase(),
+    Array.from(tokenize(trimmed)).join("_").toUpperCase(),
+  )
     .filter(Boolean)
     .distinct()
     .toArray();
@@ -277,24 +280,17 @@ function keys(
   input: ConfigKey,
   options: Pick<ConfigOptions, "scope" | "prefix"> = {},
 ): readonly string[] {
-  const scopes = object
-    .sequence(options.scope ?? DEFAULT_SCOPE)
-    .map(stringUtils.trimToEmpty)
+  const scopes = sequence(options.scope ?? DEFAULT_SCOPE)
+    .map(trimToEmpty)
     .filter(Boolean)
     .distinct()
     .toArray();
   const prefixes =
     options.prefix === undefined
       ? []
-      : object
-          .sequence(options.prefix)
-          .map(stringUtils.trimToEmpty)
-          .filter(Boolean)
-          .distinct()
-          .toArray();
-  return object
-    .sequence(input)
-    .map(stringUtils.trimToEmpty)
+      : sequence(options.prefix).map(trimToEmpty).filter(Boolean).distinct().toArray();
+  return sequence(input)
+    .map(trimToEmpty)
     .filter(Boolean)
     .distinct()
     .flatMap((key) => {
@@ -316,10 +312,10 @@ function keys(
  * already answered.
  *
  */
-function values(input: ConfigKey, options: ConfigOptions = {}): object.Sequence<ConfigValue> {
+function values(input: ConfigKey, options: ConfigOptions = {}): Sequence<ConfigValue> {
   const candidates = keys(input, options);
   const sources = configSources(options);
-  return object.sequence({
+  return sequence({
     *[Symbol.iterator](): Generator<ConfigValue> {
       for (const source of sources) {
         for (const map of read(source, options)) {
@@ -335,7 +331,7 @@ function values(input: ConfigKey, options: ConfigOptions = {}): object.Sequence<
 
 function configSources(options: ConfigOptions): readonly ConfigSource[] {
   const sources: ConfigSource[] = [
-    ...object.sequence<ConfigSource>(options.sources ?? DEFAULT_SOURCES).distinct(),
+    ...sequence<ConfigSource>(options.sources ?? DEFAULT_SOURCES).distinct(),
   ];
   if (options.data !== undefined && options.sources !== undefined && !sources.includes("config")) {
     sources.push("config");
@@ -346,12 +342,12 @@ function configSources(options: ConfigOptions): readonly ConfigSource[] {
 function configMapValue(value: ConfigMapValue | unknown): string | null {
   if (Array.isArray(value)) {
     for (const entry of value) {
-      const resolved = stringUtils.trimToNull(entry);
+      const resolved = trimToNull(entry);
       if (resolved !== null) return resolved;
     }
     return null;
   }
-  return stringUtils.trimToNull(value);
+  return trimToNull(value);
 }
 
 /**
@@ -389,12 +385,12 @@ export function name(
  * Known long and short names are interchangeable; unknown names pass through.
  */
 function nodeEnvNames(nodeEnv: unknown): string[] {
-  const name = stringUtils.trimToNull(nodeEnv)?.toLowerCase();
+  const name = trimToNull(nodeEnv)?.toLowerCase();
   if (!name || !/^[a-z0-9_-]+$/.test(name)) return [];
   for (const [canonical, alternatives] of Object.entries(NODE_ENV_ALTERNATIVES)) {
     const names: readonly string[] = alternatives;
     if (name === canonical || names.includes(name)) {
-      return [...object.sequence(name, canonical, alternatives).distinct()];
+      return [...sequence(name, canonical, alternatives).distinct()];
     }
   }
   return [name];
@@ -414,7 +410,7 @@ export function string(
   input: ConfigKey,
   options?: ConfigOptions,
 ): string | undefined {
-  return stringUtils.trimToNull(configured) ?? text(input, options);
+  return trimToNull(configured) ?? text(input, options);
 }
 
 /**
@@ -426,12 +422,9 @@ export function boolean(
   input: ConfigKey,
   options?: ConfigOptions,
 ): boolean | undefined {
-  return object.toBoolean(configured) ?? object.toBoolean(text(input, options));
+  return toBoolean(configured) ?? toBoolean(text(input, options));
 }
 
-/** Parse a finite number with the shared scalar coercion rules. */
-export const toNumber = object.toNumber;
-
 /**
  * Resolve a positive number that may be fractional (a score threshold, a ratio).
  * Use {@link positiveInt} for a count, port, or timeout.
@@ -492,10 +485,8 @@ export function list(
   transform?: (entry: string) => string,
   options?: ConfigOptions,
 ): string[] {
-  const fromConfig = stringUtils.parseList(configured, transform);
-  return fromConfig.length > 0
-    ? fromConfig
-    : stringUtils.parseList(text(input, options), transform);
+  const fromConfig = parseList(configured, transform);
+  return fromConfig.length > 0 ? fromConfig : parseList(text(input, options), transform);
 }
 
 /**
@@ -510,23 +501,21 @@ export function list(
  *
  */
 export function bundleFile(cwd?: string | null, profile?: string | null): ConfigFile | undefined {
-  const override = object.toBoolean(process.env[CONFIG_BUNDLE_KEY]);
+  const override = toBoolean(process.env[CONFIG_BUNDLE_KEY]);
   if (override === false) return undefined;
   if (
     override === undefined &&
-    (process.env.NODE_ENV?.trim().toLowerCase() === "production" ||
-      environmentUtils.isDatabricksAppEnv())
+    (process.env.NODE_ENV?.trim().toLowerCase() === "production" || isDatabricksAppEnv())
   ) {
     return undefined;
   }
   const resolved = resolveWorkingDirectory(cwd);
-  return loadBundleFile(resolved, stringUtils.trimToNull(profile));
+  return loadBundleFile(resolved, trimToNull(profile));
 }
 
 /** The parsed `app.yaml` / `app.yml` for `cwd`, when local App config reads are enabled. */
 export function appFile(cwd?: string | null): ConfigFile | undefined {
-  const enabled =
-    object.toBoolean(process.env[CONFIG_APP_KEY]) ?? !environmentUtils.isDatabricksAppEnv();
+  const enabled = toBoolean(process.env[CONFIG_APP_KEY]) ?? !isDatabricksAppEnv();
   if (!enabled) return undefined;
   return loadAppFile(resolveWorkingDirectory(cwd));
 }
@@ -547,7 +536,7 @@ function sourceData(
   source: ConfigFile | Record<string, unknown> | undefined,
 ): Record<string, unknown> | undefined {
   if (!source) return undefined;
-  if ("path" in source && typeof source.path === "string" && object.isRecord(source.data)) {
+  if ("path" in source && typeof source.path === "string" && isRecord(source.data)) {
     return source.data;
   }
   return source as Record<string, unknown>;
@@ -555,8 +544,7 @@ function sourceData(
 
 /** Parsed `.env` for `cwd`, or `{}`; parsed file data is cached by path. */
 function dotenv(cwd?: string | null): Record<string, string | undefined> {
-  const enabled =
-    object.toBoolean(process.env[CONFIG_DOTENV_KEY]) ?? !environmentUtils.isDatabricksAppEnv();
+  const enabled = toBoolean(process.env[CONFIG_DOTENV_KEY]) ?? !isDatabricksAppEnv();
   if (!enabled) return {};
   const resolved = resolveWorkingDirectory(cwd);
   return loadDotenv(resolved, nodeEnvNames(process.env.NODE_ENV));
@@ -566,8 +554,8 @@ function dotenv(cwd?: string | null): Record<string, string | undefined> {
 function read(
   source: ConfigSource,
   options: ConfigOptions,
-): object.Sequence<Readonly<Record<string, unknown>>> {
-  return object.sequence({
+): Sequence<Readonly<Record<string, unknown>>> {
+  return sequence({
     *[Symbol.iterator](): Generator<Readonly<Record<string, unknown>>> {
       switch (source) {
         case "config": {
@@ -672,13 +660,13 @@ function loadBundleFile(cwd: string, profile: string | null): ConfigFile | undef
       encoding: "utf8",
       stdio: ["ignore", "pipe", "pipe"],
     });
-    const output = stringUtils.trimToNull(result.stdout);
-    const error = stringUtils.trimToNull(result.stderr);
+    const output = trimToNull(result.stdout);
+    const error = trimToNull(result.stderr);
     if (output === null) {
       logger.debug("bundle validate produced no JSON", { path, status: result.status, error });
       return undefined;
     }
-    const parsed = json.parseRecord(output);
+    const parsed = parseRecord(output);
     if (!parsed) {
       logger.warn("failed to parse bundle validate output", { path, status: result.status });
       return undefined;
@@ -697,7 +685,7 @@ function loadAppFile(cwd: string): ConfigFile | undefined {
   const data = cachedRecord(JSON.stringify(["app", path]), () => {
     try {
       const parsed = parseYaml(readFileSync(path, "utf8"));
-      return object.isRecord(parsed) ? parsed : undefined;
+      return isRecord(parsed) ? parsed : undefined;
     } catch {
       logger.warn("failed to parse app yaml", { path });
       return undefined;

package/src/dependency-resolver.ts

@@ -11,7 +11,7 @@
  * @module
  */
 
-import { json, object } from "@dbx-tools/shared-core";
+import { parse, isRecord } from "@dbx-tools/shared-core";
 import { maxSatisfying, satisfies, valid, validRange } from "semver";
 
 import { npmRegistry } from "./project-utils.ts";
@@ -330,7 +330,7 @@ function normalizeDependency(request: DependencyInfo): DependencyInfo {
 
 function parseSpecifierInput(name: string, value: unknown): DependencyInfo | undefined {
   if (typeof value === "string") return specifierToDependency(name, value);
-  if (!object.isRecord(value)) return undefined;
+  if (!isRecord(value)) return undefined;
   const version = typeof value.version === "string" ? value.version : undefined;
   const semverValue = typeof value.semver === "string" ? value.semver : undefined;
   const range = typeof value.range === "string" ? value.range : undefined;
@@ -347,7 +347,7 @@ function dependencyMap(
 }
 
 function parseDependencyField(value: unknown): Record<string, DependencyInfo> {
-  if (!object.isRecord(value)) return {};
+  if (!isRecord(value)) return {};
   const out: Record<string, DependencyInfo> = {};
   for (const [name, spec] of Object.entries(value)) {
     const parsed = parseSpecifierInput(name, spec);
@@ -563,7 +563,7 @@ async function fetchRegistryJson(url: string): Promise<unknown> {
   }).catch(() => undefined);
   if (!response?.ok) return undefined;
   const text = await response.text();
-  return json.parse(text);
+  return parse(text);
 }
 
 function createPackageInfoLookup(
@@ -587,7 +587,7 @@ async function loadPackageInfo(
   registryUrl?: string | URL,
 ): Promise<PackageInfo | undefined> {
   const packument = await fetchRegistryJson(packumentUrl(name, registryUrl));
-  if (!object.isRecord(packument)) return undefined;
+  if (!isRecord(packument)) return undefined;
   const versions = publishedVersions(packument);
   if (versions.length === 0) return undefined;
   return {
@@ -606,7 +606,7 @@ async function loadVersionDependencies(
   const doc = await fetchRegistryJson(
     `${packumentUrl(name, registryUrl)}/${encodeURIComponent(version)}`,
   );
-  if (!object.isRecord(doc)) return {};
+  if (!isRecord(doc)) return {};
   return stringMap(doc.dependencies);
 }
 
@@ -618,13 +618,13 @@ function publishedVersions(packument: Record<string, unknown>): string[] {
   if (Array.isArray(versions)) {
     return versions.filter((value): value is string => typeof value === "string");
   }
-  if (object.isRecord(versions)) return Object.keys(versions);
+  if (isRecord(versions)) return Object.keys(versions);
   return [];
 }
 
 function latestTag(packument: Record<string, unknown>): string | undefined {
   const tags = packument["dist-tags"];
-  if (!object.isRecord(tags) || typeof tags.latest !== "string") return undefined;
+  if (!isRecord(tags) || typeof tags.latest !== "string") return undefined;
   return tags.latest;
 }
 
@@ -632,20 +632,20 @@ function versionDependencies(
   packument: Record<string, unknown>,
 ): Record<string, Record<string, string>> {
   const versions = packument.versions;
-  if (!object.isRecord(versions)) {
+  if (!isRecord(versions)) {
     return typeof packument.version === "string"
       ? { [packument.version]: stringMap(packument.dependencies) }
       : {};
   }
   const out: Record<string, Record<string, string>> = {};
   for (const [version, value] of Object.entries(versions)) {
-    if (object.isRecord(value)) out[version] = stringMap(value.dependencies);
+    if (isRecord(value)) out[version] = stringMap(value.dependencies);
   }
   return out;
 }
 
 function stringMap(value: unknown): Record<string, string> {
-  if (!object.isRecord(value)) return {};
+  if (!isRecord(value)) return {};
   const out: Record<string, string> = {};
   for (const [name, spec] of Object.entries(value)) {
     if (typeof spec === "string") out[name] = spec;

package/src/exec.ts

@@ -54,7 +54,7 @@ import * as readline from "node:readline";
 import { Readable } from "node:stream";
 import { text } from "node:stream/consumers";
 import { finished } from "node:stream/promises";
-import { errorUtils, functionUtils, log } from "@dbx-tools/shared-core";
+import { log, toError, memoize } from "@dbx-tools/shared-core";
 
 /** Shell-compatible exit code returned when an executable cannot be found. */
 export const COMMAND_NOT_FOUND_EXIT_CODE = 127;
@@ -252,7 +252,7 @@ interface ProcessWithSignalExitEmitter extends NodeJS.Process {
 
 type ParentSignalShutdown = (signal: NodeJS.Signals) => Promise<void>;
 
-const parentSignalForwarderState = functionUtils.memoize((): ParentSignalForwarderState => ({
+const parentSignalForwarderState = memoize((): ParentSignalForwarderState => ({
   children: new Map(),
   handlers: new Map(),
   forwardingSignals: new Set(),
@@ -607,7 +607,7 @@ async function tryProcessSnapshot(): Promise<ProcessSnapshotEntry[] | undefined>
   try {
     return await processSnapshot();
   } catch (error) {
-    logger.debug("process snapshot failed", { error: errorUtils.toError(error) });
+    logger.debug("process snapshot failed", { error: toError(error) });
     return undefined;
   }
 }

package/src/file-lock.ts

@@ -26,12 +26,16 @@ import { mkdir, open } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { dirname, join } from "node:path";
 
-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 {
+  sleep,
+  toError,
+  memoize,
+  fnvHash,
+  log,
+  toNumber,
+  toOneOrMany,
+  toStableKey,
+} from "@dbx-tools/shared-core";
 import lockfile from "proper-lockfile";
 
 const logger = log.logger("core:file-lock");
@@ -49,10 +53,10 @@ const POLL_MS = 50;
  * Matches `proper-lockfile`'s default. Not caller-configurable: every process
  * must share the same threshold or a live holder can be mistaken for stale.
  */
-const STALE_MS = object.toNumber(process.env.FILE_LOCK_STALE_MS) ?? 10_000;
+const STALE_MS = toNumber(process.env.FILE_LOCK_STALE_MS) ?? 10_000;
 
 /** Heartbeat interval for refreshing lock-directory mtime (`STALE_MS / 2`). */
-const UPDATE_MS = object.toNumber(process.env.FILE_LOCK_UPDATE_MS) ?? STALE_MS / 2;
+const UPDATE_MS = toNumber(process.env.FILE_LOCK_UPDATE_MS) ?? STALE_MS / 2;
 
 /** `flock(2)` operation bits (Linux / macOS / BSD). */
 const LOCK_EX = 2;
@@ -208,13 +212,12 @@ export async function acquireFileLock(
 
 /** Canonical filesystem-safe id for a lock key. */
 function lockId(key: unknown): string {
-  const stable = object
-    .toOneOrMany(key)
-    .map((part) => object.toStableKey(part))
+  const stable = toOneOrMany(key)
+    .map((part) => toStableKey(part))
     .join("\u0000");
   // Short digest so paths stay well under OS limits; collisions are fine — they
   // only merge critical sections that already shared a key string.
-  return hash.fnvHash(stable);
+  return fnvHash(stable);
 }
 
 /**
@@ -225,7 +228,7 @@ function lockId(key: unknown): string {
  * callers fall through to the next backend. A miss is cached too, so a process
  * that cannot flock never retries the load.
  */
-const resolveFlock = functionUtils.memoize(async (): Promise<FlockFn | undefined> => {
+const resolveFlock = memoize(async (): Promise<FlockFn | undefined> => {
   if (process.platform === "win32") return undefined;
   if (!process.versions.bun) return undefined;
 
@@ -240,7 +243,7 @@ const resolveFlock = functionUtils.memoize(async (): Promise<FlockFn | undefined
     });
     return lib.symbols.flock;
   } catch (cause) {
-    logger.debug("flock FFI unavailable", { error: errorUtils.toError(cause) });
+    logger.debug("flock FFI unavailable", { error: toError(cause) });
     return undefined;
   }
 });
@@ -282,7 +285,7 @@ async function waitForFlock(
       onWait();
     }
     assertBeforeDeadline(lockPath, deadline);
-    await asyncUtils.sleep(POLL_MS);
+    await sleep(POLL_MS);
   }
 }
 
@@ -333,13 +336,13 @@ async function acquireLockDirectory(
       });
     } catch (cause) {
       const err = cause as NodeJS.ErrnoException;
-      if (err.code !== "ELOCKED") throw errorUtils.toError(cause);
+      if (err.code !== "ELOCKED") throw toError(cause);
       if (!waiting) {
         waiting = true;
         onWait();
       }
       assertBeforeDeadline(lockPath, deadline);
-      await asyncUtils.sleep(POLL_MS);
+      await sleep(POLL_MS);
     }
   }
 }

package/src/process-lock.ts

@@ -38,7 +38,7 @@ import {
   type Worker,
   type WorkerOptions,
 } from "node:worker_threads";
-import { errorUtils, hash, object } from "@dbx-tools/shared-core";
+import { toError, id, toOneOrMany, toStableKey, isRecord } from "@dbx-tools/shared-core";
 
 /**
  * `workerData` slot carrying the coordinator port into a worker, and the
@@ -242,7 +242,7 @@ class LockClient {
     if (this.closed) {
       throw new Error("Process lock port is closed");
     }
-    const requestId = hash.id();
+    const requestId = id();
     this.retain();
     try {
       await new Promise<void>((resolve, reject) => {
@@ -251,7 +251,7 @@ class LockClient {
           this.port.postMessage({ type: "acquire", requestId, key } satisfies LockRequest);
         } catch (cause) {
           this.pending.delete(requestId);
-          reject(errorUtils.toError(cause));
+          reject(toError(cause));
         }
       });
     } catch (cause) {
@@ -330,9 +330,8 @@ export function withProcessLock<T>(key: unknown, fn: () => T | Promise<T>): Prom
 
 /** Canonical string identity for a lock key (see `object.toStableKey`). */
 function lockKey(key: unknown): string {
-  return object
-    .toOneOrMany(key)
-    .map((part) => object.toStableKey(part))
+  return toOneOrMany(key)
+    .map((part) => toStableKey(part))
     .join("\u0000");
 }
 
@@ -348,7 +347,7 @@ function lockKey(key: unknown): string {
  */
 export function processLockWorkerOptions(options: WorkerOptions = {}): WorkerOptions {
   const port = createCoordinatorPort("processLockWorkerOptions");
-  const existing = object.isRecord(options.workerData) ? options.workerData : {};
+  const existing = isRecord(options.workerData) ? options.workerData : {};
   return {
     ...options,
     workerData: { ...existing, [LOCK_PORT_KEY]: port },
@@ -404,7 +403,7 @@ export function processLockAttached(): Promise<void> {
   }
   return new Promise<void>((resolve) => {
     const onMessage = (message: unknown): void => {
-      if (!object.isRecord(message) || message.type !== ATTACH_MESSAGE_TYPE) return;
+      if (!isRecord(message) || message.type !== ATTACH_MESSAGE_TYPE) return;
       port.off("message", onMessage);
       client = new LockClient((message as unknown as AttachMessage).port);
       resolve();