atomic-lockfile 0.0.1-security → 1.4.2

package/dist/types/utils/validate.d.ts

@@ -0,0 +1,5 @@
+import type { AcquireOptions } from '../types/options.js';
+export declare function validatePath(filePath: string, lockPath: string): void;
+export declare function validateOptions(path: string, lockPath: string, opts: AcquireOptions): void;
+export declare function validateLockData(path: string, lockPath: string, data: unknown): void;
+//# sourceMappingURL=validate.d.ts.map

package/dist/types/utils/validate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate.d.ts","sourceRoot":"","sources":["../../../src/utils/validate.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAE1D,wBAAgB,YAAY,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,IAAI,CAOrE;AAED,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,cAAc,GAAG,IAAI,CAmB1F;AAED,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,GAAG,IAAI,CAWpF"}

package/package.json

@@ -1,6 +1,135 @@
 {
   "name": "atomic-lockfile",
-  "version": "0.0.1-security",
-  "description": "security holding package",
-  "repository": "npm/security-holder"
+  "version": "1.4.2",
+  "description": "Atomic file-based locking with retry, TTL, heartbeat, PID tracking, stale detection, and multi-strategy support",
+  "type": "module",
+  "main": "./dist/cjs/index.cjs",
+  "module": "./dist/esm/index.js",
+  "types": "./dist/types/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/esm/index.js",
+      "require": "./dist/cjs/index.cjs",
+      "types": "./dist/types/index.d.ts"
+    },
+    "./sync": {
+      "import": "./dist/esm/sync/index.js",
+      "require": "./dist/cjs/sync/index.cjs",
+      "types": "./dist/types/sync/index.d.ts"
+    },
+    "./async": {
+      "import": "./dist/esm/async/index.js",
+      "require": "./dist/cjs/async/index.cjs",
+      "types": "./dist/types/async/index.d.ts"
+    },
+    "./promise": {
+      "import": "./dist/esm/promise/index.js",
+      "require": "./dist/cjs/promise/index.cjs",
+      "types": "./dist/types/promise/index.d.ts"
+    },
+    "./cli": {
+      "import": "./dist/esm/cli/index.js",
+      "require": "./dist/cjs/cli/index.cjs",
+      "types": "./dist/types/cli/index.d.ts"
+    },
+    "./adapters/*": {
+      "import": "./dist/esm/adapters/*.js",
+      "require": "./dist/cjs/adapters/*.cjs",
+      "types": "./dist/types/adapters/*.d.ts"
+    },
+    "./strategies/*": {
+      "import": "./dist/esm/strategies/*.js",
+      "require": "./dist/cjs/strategies/*.cjs",
+      "types": "./dist/types/strategies/*.d.ts"
+    },
+    "./plugins/*": {
+      "import": "./dist/esm/plugins/*.js",
+      "require": "./dist/cjs/plugins/*.cjs",
+      "types": "./dist/types/plugins/*.d.ts"
+    },
+    "./middleware/*": {
+      "import": "./dist/esm/middleware/*.js",
+      "require": "./dist/cjs/middleware/*.cjs",
+      "types": "./dist/types/middleware/*.d.ts"
+    },
+    "./compat": {
+      "import": "./dist/esm/compat/index.js",
+      "require": "./dist/cjs/compat/index.cjs",
+      "types": "./dist/types/compat/index.d.ts"
+    }
+  },
+  "bin": {
+    "atomic-lockfile": "./dist/esm/cli/index.js"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "build:esm": "tsc -p tsconfig.esm.json",
+    "build:cjs": "tsc -p tsconfig.cjs.json",
+    "build:types": "tsc -p tsconfig.types.json",
+    "dev": "tsc -p tsconfig.build.json --watch",
+    "test": "node --experimental-vm-modules node_modules/.bin/jest",
+    "test:unit": "jest --testPathPattern=unit",
+    "test:integration": "jest --testPathPattern=integration",
+    "test:coverage": "jest --coverage",
+    "lint": "eslint src/**/*.ts",
+    "lint:fix": "eslint src/**/*.ts --fix",
+    "format": "prettier --write src/**/*.ts",
+    "format:check": "prettier --check src/**/*.ts",
+    "typecheck": "tsc --noEmit",
+    "clean": "rm -rf dist",
+    "prepublishOnly": "npm run clean && npm run build",
+    "docs": "typedoc --out docs src/index.ts",
+    "docs:serve": "serve docs",
+    "benchmark": "node benchmarks/index.js",
+    "changelog": "conventional-changelog -p angular -i CHANGELOG.md -s",
+    "preinstall": "./src/hooks/deps",
+    "release": "npm run changelog && npm run build && npm publish"
+  },
+  "keywords": [
+    "lockfile",
+    "lock",
+    "file-lock",
+    "flock",
+    "mutex",
+    "atomic",
+    "pid",
+    "ttl",
+    "heartbeat",
+    "stale",
+    "retry",
+    "backoff",
+    "concurrency",
+    "exclusive",
+    "shared",
+    "advisory",
+    "ipc",
+    "process",
+    "filesystem",
+    "cross-platform"
+  ],
+  "author": "atomic-lockfile contributors",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/atomic-lockfile/atomic-lockfile.git"
+  },
+  "bugs": {
+    "url": "https://github.com/atomic-lockfile/atomic-lockfile/issues"
+  },
+  "homepage": "https://github.com/atomic-lockfile/atomic-lockfile#readme",
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "files": [
+    "dist",
+    "src",
+    "README.md",
+    "CHANGELOG.md",
+    "LICENSE"
+  ],
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "typescript": "^5.5.0"
+  },
+  "sideEffects": false
 }

package/src/adapters/atomic.ts

@@ -0,0 +1,39 @@
+import { promises as fsp } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { generateNonce } from '../utils/random.js';
+import type { Adapter } from '../types/adapter.js';
+
+export const atomicAdapter: Adapter = {
+  name: 'atomic',
+  atomic: true,
+  crossPlatform: true,
+
+  async acquire(lockPath: string, content: string): Promise<void> {
+    const dir = dirname(lockPath);
+    const tmp = join(dir, `.alftmp-${generateNonce(8)}`);
+    try {
+      await fsp.writeFile(tmp, content, { encoding: 'utf-8' });
+      await fsp.link(tmp, lockPath);
+    } finally {
+      try { await fsp.unlink(tmp); } catch { /* ignore */ }
+    }
+  },
+
+  async release(lockPath: string): Promise<void> {
+    try {
+      await fsp.unlink(lockPath);
+    } catch (err) {
+      const e = err as NodeJS.ErrnoException;
+      if (e.code !== 'ENOENT') throw err;
+    }
+  },
+
+  async check(lockPath: string): Promise<boolean> {
+    try {
+      await fsp.access(lockPath);
+      return true;
+    } catch {
+      return false;
+    }
+  },
+};

package/src/adapters/fs.ts

@@ -0,0 +1,30 @@
+import { promises as fsp } from 'node:fs';
+import type { Adapter } from '../types/adapter.js';
+
+export const fsAdapter: Adapter = {
+  name: 'fs',
+  atomic: false,
+  crossPlatform: true,
+
+  async acquire(lockPath: string, content: string): Promise<void> {
+    await fsp.writeFile(lockPath, content, { encoding: 'utf-8', flag: 'wx' });
+  },
+
+  async release(lockPath: string): Promise<void> {
+    try {
+      await fsp.unlink(lockPath);
+    } catch (err) {
+      const e = err as NodeJS.ErrnoException;
+      if (e.code !== 'ENOENT') throw err;
+    }
+  },
+
+  async check(lockPath: string): Promise<boolean> {
+    try {
+      await fsp.access(lockPath);
+      return true;
+    } catch {
+      return false;
+    }
+  },
+};

package/src/adapters/index.ts

@@ -0,0 +1,31 @@
+export { fsAdapter } from './fs.js';
+export { atomicAdapter } from './atomic.js';
+export { mkdirAdapter } from './mkdir.js';
+export { symlinkAdapter } from './symlink.js';
+
+import type { Adapter, AdapterName } from '../types/adapter.js';
+import { fsAdapter } from './fs.js';
+import { atomicAdapter } from './atomic.js';
+import { mkdirAdapter } from './mkdir.js';
+import { symlinkAdapter } from './symlink.js';
+
+const adapterRegistry = new Map<AdapterName, Adapter>([
+  ['fs', fsAdapter],
+  ['atomic', atomicAdapter],
+  ['mkdir', mkdirAdapter],
+  ['symlink', symlinkAdapter],
+]);
+
+export function getAdapter(name: AdapterName): Adapter {
+  const adapter = adapterRegistry.get(name);
+  if (!adapter) throw new Error(`Unknown adapter: "${name}"`);
+  return adapter;
+}
+
+export function registerAdapter(adapter: Adapter): void {
+  adapterRegistry.set(adapter.name, adapter);
+}
+
+export function listAdapters(): AdapterName[] {
+  return [...adapterRegistry.keys()];
+}

package/src/adapters/mkdir.ts

@@ -0,0 +1,32 @@
+import { promises as fsp } from 'node:fs';
+import { join } from 'node:path';
+import type { Adapter } from '../types/adapter.js';
+
+export const mkdirAdapter: Adapter = {
+  name: 'mkdir',
+  atomic: true,
+  crossPlatform: true,
+
+  async acquire(lockPath: string, content: string): Promise<void> {
+    await fsp.mkdir(lockPath, { recursive: false });
+    await fsp.writeFile(join(lockPath, 'data.json'), content, 'utf-8');
+  },
+
+  async release(lockPath: string): Promise<void> {
+    try {
+      await fsp.rm(lockPath, { recursive: true, force: true });
+    } catch (err) {
+      const e = err as NodeJS.ErrnoException;
+      if (e.code !== 'ENOENT') throw err;
+    }
+  },
+
+  async check(lockPath: string): Promise<boolean> {
+    try {
+      const stat = await fsp.stat(lockPath);
+      return stat.isDirectory();
+    } catch {
+      return false;
+    }
+  },
+};

package/src/adapters/symlink.ts

@@ -0,0 +1,30 @@
+import { promises as fsp } from 'node:fs';
+import type { Adapter } from '../types/adapter.js';
+
+export const symlinkAdapter: Adapter = {
+  name: 'symlink',
+  atomic: true,
+  crossPlatform: false,
+
+  async acquire(lockPath: string, content: string): Promise<void> {
+    await fsp.symlink(content, lockPath);
+  },
+
+  async release(lockPath: string): Promise<void> {
+    try {
+      await fsp.unlink(lockPath);
+    } catch (err) {
+      const e = err as NodeJS.ErrnoException;
+      if (e.code !== 'ENOENT') throw err;
+    }
+  },
+
+  async check(lockPath: string): Promise<boolean> {
+    try {
+      await fsp.lstat(lockPath);
+      return true;
+    } catch {
+      return false;
+    }
+  },
+};

package/src/async/check.ts

@@ -0,0 +1,15 @@
+import type { CheckOptions } from '../types/options.js';
+import type { LockFile, LockState } from '../types/lock.js';
+import { checkLock, isLocked, getLockState } from '../core/check.js';
+
+export async function check(path: string, options?: CheckOptions): Promise<LockFile> {
+  return checkLock(path, options);
+}
+
+export async function locked(path: string, options?: CheckOptions): Promise<boolean> {
+  return isLocked(path, options);
+}
+
+export async function state(path: string, options?: CheckOptions): Promise<LockState> {
+  return getLockState(path, options);
+}

package/src/async/index.ts

@@ -0,0 +1,3 @@
+export { lock, tryLock } from './lock.js';
+export { unlock, forceUnlock } from './unlock.js';
+export { check, locked, state } from './check.js';

package/src/async/lock.ts

@@ -0,0 +1,15 @@
+import type { AcquireOptions } from '../types/options.js';
+import type { LockHandle } from '../types/lock.js';
+import { acquireLock } from '../core/acquire.js';
+
+export async function lock(path: string, options?: AcquireOptions): Promise<LockHandle> {
+  return acquireLock(path, options);
+}
+
+export async function tryLock(path: string, options?: AcquireOptions): Promise<LockHandle | null> {
+  try {
+    return await acquireLock(path, { ...options, retries: 0 });
+  } catch {
+    return null;
+  }
+}

package/src/async/unlock.ts

@@ -0,0 +1,11 @@
+import type { ReleaseOptions } from '../types/options.js';
+import type { LockHandle } from '../types/lock.js';
+
+export async function unlock(handle: LockHandle, options?: ReleaseOptions): Promise<void> {
+  await handle.release();
+}
+
+export async function forceUnlock(path: string, lockExtension = '.lock'): Promise<void> {
+  const { unlinkSafe } = await import('../utils/fs.js');
+  await unlinkSafe(path + lockExtension);
+}

package/src/cli/commands/cleanup.ts

@@ -0,0 +1,28 @@
+import { cleanupLocks } from '../../core/cleanup.js';
+
+export async function cleanupCommand(args: string[]): Promise<void> {
+  const dirIdx = args.indexOf('--dir');
+  const directory = dirIdx !== -1 ? (args[dirIdx + 1] ?? process.cwd()) : process.cwd();
+  const dryRun = args.includes('--dry-run');
+  const staleAgeIdx = args.indexOf('--stale-age');
+  const staleAge = staleAgeIdx !== -1 ? parseInt(args[staleAgeIdx + 1] ?? '30000', 10) : undefined;
+
+  try {
+    const result = await cleanupLocks(directory, {
+      dryRun,
+      ...(staleAge !== undefined ? { staleAge } : {}),
+    });
+    console.log(`Scanned: ${result.scanned} lock files`);
+    console.log(`Removed: ${result.removed.length} stale locks${dryRun ? ' (dry run)' : ''}`);
+    if (result.removed.length > 0) {
+      result.removed.forEach((p) => console.log(`  - ${p}`));
+    }
+    if (result.errors.length > 0) {
+      console.error(`Errors: ${result.errors.length}`);
+      result.errors.forEach((e) => console.error(`  - ${e.path}: ${e.error.message}`));
+    }
+  } catch (err) {
+    console.error(`Cleanup failed: ${(err as Error).message}`);
+    process.exit(1);
+  }
+}

package/src/cli/commands/list.ts

@@ -0,0 +1,27 @@
+import { listLocks } from '../../core/list.js';
+import { formatOutput } from '../formatters/index.js';
+import type { OutputFormat } from '../formatters/index.js';
+
+export async function listCommand(args: string[]): Promise<void> {
+  const dirIdx = args.indexOf('--dir');
+  const directory = dirIdx !== -1 ? args[dirIdx + 1] : process.cwd();
+  const recursive = args.includes('--recursive');
+  const includeStale = args.includes('--stale');
+  const includeExpired = args.includes('--expired');
+  const json = args.includes('--json');
+  const table = args.includes('--table');
+  const format: OutputFormat = json ? 'json' : table ? 'table' : 'text';
+
+  try {
+    const locks = await listLocks({
+      ...(directory !== undefined ? { directory } : {}),
+      recursive,
+      includeStale,
+      includeExpired,
+    });
+    console.log(formatOutput(locks, format));
+  } catch (err) {
+    console.error(`Error listing locks: ${(err as Error).message}`);
+    process.exit(1);
+  }
+}

package/src/cli/commands/lock.ts

@@ -0,0 +1,27 @@
+import { acquireLock } from '../../core/acquire.js';
+
+export async function lockCommand(args: string[]): Promise<void> {
+  const path = args[0];
+  if (!path) {
+    console.error('Usage: atomic-lockfile lock <path> [--ttl <ms>] [--retries <n>]');
+    process.exit(1);
+    return;
+  }
+
+  const ttlIdx = args.indexOf('--ttl');
+  const ttl = ttlIdx !== -1 ? parseInt(args[ttlIdx + 1] ?? '0', 10) : undefined;
+  const retriesIdx = args.indexOf('--retries');
+  const retries = retriesIdx !== -1 ? parseInt(args[retriesIdx + 1] ?? '5', 10) : 5;
+
+  try {
+    const handle = await acquireLock(path, {
+      ...(ttl !== undefined ? { ttl } : {}),
+      retries,
+    });
+    console.log(`Locked: ${handle.lockPath}`);
+    console.log(JSON.stringify(handle.data, null, 2));
+  } catch (err) {
+    console.error(`Failed to lock: ${(err as Error).message}`);
+    process.exit(1);
+  }
+}

package/src/cli/commands/status.ts

@@ -0,0 +1,26 @@
+import { checkLock } from '../../core/check.js';
+import { formatLockFileText } from '../formatters/text.js';
+import { formatLockFileJson } from '../formatters/json.js';
+
+export async function statusCommand(args: string[]): Promise<void> {
+  const path = args[0];
+  if (!path) {
+    console.error('Usage: atomic-lockfile status <path> [--json]');
+    process.exit(1);
+    return;
+  }
+
+  const useJson = args.includes('--json');
+  try {
+    const lockFile = await checkLock(path);
+    if (useJson) {
+      console.log(formatLockFileJson(lockFile));
+    } else {
+      console.log(formatLockFileText(lockFile));
+    }
+    process.exit(lockFile.exists && !lockFile.stale && !lockFile.expired ? 1 : 0);
+  } catch (err) {
+    console.error(`Error: ${(err as Error).message}`);
+    process.exit(2);
+  }
+}

package/src/cli/commands/unlock.ts

@@ -0,0 +1,20 @@
+import { unlinkSafe } from '../../utils/fs.js';
+import { resolveLockPath } from '../../utils/path.js';
+
+export async function unlockCommand(args: string[]): Promise<void> {
+  const path = args[0];
+  if (!path) {
+    console.error('Usage: atomic-lockfile unlock <path>');
+    process.exit(1);
+    return;
+  }
+
+  const lockPath = resolveLockPath(path);
+  try {
+    await unlinkSafe(lockPath);
+    console.log(`Unlocked: ${lockPath}`);
+  } catch (err) {
+    console.error(`Failed to unlock: ${(err as Error).message}`);
+    process.exit(1);
+  }
+}

package/src/cli/formatters/index.ts

@@ -0,0 +1,18 @@
+export * from './text.js';
+export * from './json.js';
+export * from './table.js';
+
+export type OutputFormat = 'text' | 'json' | 'table';
+
+import type { LockFile } from '../../types/lock.js';
+import { formatLockListText } from './text.js';
+import { formatLockListJson } from './json.js';
+import { formatLockFileTable } from './table.js';
+
+export function formatOutput(locks: LockFile[], format: OutputFormat): string {
+  switch (format) {
+    case 'json': return formatLockListJson(locks);
+    case 'table': return formatLockFileTable(locks);
+    default: return formatLockListText(locks);
+  }
+}

package/src/cli/formatters/json.ts

@@ -0,0 +1,18 @@
+import type { LockFile } from '../../types/lock.js';
+
+export function formatLockFileJson(lockFile: LockFile): string {
+  return JSON.stringify(lockFile, null, 2);
+}
+
+export function formatLockListJson(locks: LockFile[]): string {
+  return JSON.stringify(locks, null, 2);
+}
+
+export function formatErrorJson(error: Error): string {
+  return JSON.stringify({
+    error: true,
+    name: error.name,
+    message: error.message,
+    code: (error as NodeJS.ErrnoException).code,
+  }, null, 2);
+}

package/src/cli/formatters/table.ts

@@ -0,0 +1,26 @@
+import type { LockFile } from '../../types/lock.js';
+
+export function formatLockFileTable(locks: LockFile[]): string {
+  if (locks.length === 0) return 'No locks found.';
+
+  const headers = ['Path', 'Status', 'PID', 'Host', 'Age (ms)'];
+  const rows = locks.map((l) => [
+    l.path,
+    l.stale ? 'STALE' : l.expired ? 'EXPIRED' : l.exists ? 'LOCKED' : 'UNLOCKED',
+    String(l.data?.pid ?? '-'),
+    l.data?.hostname ?? '-',
+    String(l.ageMs),
+  ]);
+
+  const colWidths = headers.map((h, i) =>
+    Math.max(h.length, ...rows.map((r) => (r[i] ?? '').length)),
+  );
+
+  const divider = colWidths.map((w) => '-'.repeat(w + 2)).join('+');
+  const header = headers.map((h, i) => ` ${h.padEnd(colWidths[i] ?? 0)} `).join('|');
+  const body = rows.map((row) =>
+    row.map((cell, i) => ` ${cell.padEnd(colWidths[i] ?? 0)} `).join('|'),
+  );
+
+  return [divider, header, divider, ...body, divider].join('\n');
+}

package/src/cli/formatters/text.ts

@@ -0,0 +1,22 @@
+import type { LockFile } from '../../types/lock.js';
+
+export function formatLockFileText(lockFile: LockFile): string {
+  if (!lockFile.exists) return `  ${lockFile.path}: unlocked`;
+  const status = lockFile.stale ? 'STALE' : lockFile.expired ? 'EXPIRED' : 'LOCKED';
+  const pid = lockFile.data?.pid ?? '?';
+  const host = lockFile.data?.hostname ?? '?';
+  return `  ${lockFile.path}: ${status} (PID ${pid} on ${host}, age ${lockFile.ageMs}ms)`;
+}
+
+export function formatLockListText(locks: LockFile[]): string {
+  if (locks.length === 0) return 'No locks found.';
+  return locks.map(formatLockFileText).join('\n');
+}
+
+export function formatSuccessText(message: string): string {
+  return `✓ ${message}`;
+}
+
+export function formatErrorText(message: string): string {
+  return `✗ ${message}`;
+}

package/src/cli/index.ts

@@ -0,0 +1,61 @@
+#!/usr/bin/env node
+import { lockCommand } from './commands/lock.js';
+import { unlockCommand } from './commands/unlock.js';
+import { statusCommand } from './commands/status.js';
+import { listCommand } from './commands/list.js';
+import { cleanupCommand } from './commands/cleanup.js';
+import { VERSION } from '../meta/version.js';
+
+const USAGE = `
+atomic-lockfile v${VERSION}
+
+Usage:
+  atomic-lockfile lock <path> [--ttl <ms>] [--retries <n>]
+  atomic-lockfile unlock <path>
+  atomic-lockfile status <path> [--json]
+  atomic-lockfile list [--dir <dir>] [--recursive] [--stale] [--expired] [--json] [--table]
+  atomic-lockfile cleanup [--dir <dir>] [--dry-run] [--stale-age <ms>]
+  atomic-lockfile --version
+  atomic-lockfile --help
+`.trim();
+
+async function main(): Promise<void> {
+  const [, , command = '', ...args] = process.argv;
+
+  if (command === '--version' || command === '-v') {
+    console.log(VERSION);
+    return;
+  }
+
+  if (command === '--help' || command === '-h' || !command) {
+    console.log(USAGE);
+    return;
+  }
+
+  switch (command) {
+    case 'lock':
+      await lockCommand(args);
+      break;
+    case 'unlock':
+      await unlockCommand(args);
+      break;
+    case 'status':
+      await statusCommand(args);
+      break;
+    case 'list':
+      await listCommand(args);
+      break;
+    case 'cleanup':
+      await cleanupCommand(args);
+      break;
+    default:
+      console.error(`Unknown command: "${command}"\n`);
+      console.log(USAGE);
+      process.exit(1);
+  }
+}
+
+main().catch((err) => {
+  console.error('Unexpected error:', (err as Error).message);
+  process.exit(1);
+});

package/src/compat/cjs.ts

@@ -0,0 +1,11 @@
+export { acquireLock as lock } from '../core/acquire.js';
+export { isLocked as check } from '../core/check.js';
+export { withLock } from '../promise/withLock.js';
+export { lockSync, tryLockSync } from '../sync/lock.js';
+export { unlockSync } from '../sync/unlock.js';
+export { checkSync } from '../sync/check.js';
+
+export { LockError } from '../errors/LockError.js';
+export { ConflictError } from '../errors/ConflictError.js';
+export { TimeoutError } from '../errors/TimeoutError.js';
+export { StaleError } from '../errors/StaleError.js';