migrate: move flock and hash utilities to shared package (#22640)

packages/opencode/src/acp/agent.ts

@@ -34,7 +34,7 @@ import {
 import { Log } from "../util/log"
 import { pathToFileURL } from "url"
 import { Filesystem } from "../util/filesystem"
-import { Hash } from "../util/hash"
+import { Hash } from "@opencode-ai/shared/util/hash"
 import { ACPSessionManager } from "./session"
 import type { ACPConfig } from "./types"
 import { Provider } from "../provider/provider"

packages/opencode/src/cli/cmd/tui/plugin/runtime.ts

@@ -34,7 +34,7 @@ import { hasTheme, upsertTheme } from "../context/theme"
 import { Global } from "@/global"
 import { Filesystem } from "@/util/filesystem"
 import { Process } from "@/util/process"
-import { Flock } from "@/util/flock"
+import { Flock } from "@opencode-ai/shared/util/flock"
 import { Flag } from "@/flag/flag"
 import { INTERNAL_TUI_PLUGINS, type InternalTuiPlugin } from "./internal"
 import { setupSlots, Slot as View } from "./slots"

packages/opencode/src/config/config.ts

@@ -34,7 +34,7 @@ import type { ConsoleState } from "./console-state"
 import { AppFileSystem } from "@opencode-ai/shared/filesystem"
 import { InstanceState } from "@/effect/instance-state"
 import { Context, Duration, Effect, Exit, Fiber, Layer, Option } from "effect"
-import { Flock } from "@/util/flock"
+import { Flock } from "@opencode-ai/shared/util/flock"
 import { isPathPluginSpec, parsePluginSpecifier, resolvePathPluginTarget } from "@/plugin/shared"
 import { Npm } from "../npm"
 import { InstanceRef } from "@/effect/instance-ref"

packages/opencode/src/global/index.ts

@@ -3,6 +3,7 @@ import { xdgData, xdgCache, xdgConfig, xdgState } from "xdg-basedir"
 import path from "path"
 import os from "os"
 import { Filesystem } from "../util/filesystem"
+import { Flock } from "@opencode-ai/shared/util/flock"
 
 const app = "opencode"
 
@@ -26,6 +27,9 @@ export namespace Global {
   }
 }
 
+// Initialize Flock with global state path
+Flock.setGlobal({ state })
+
 await Promise.all([
   fs.mkdir(Global.Path.data, { recursive: true }),
   fs.mkdir(Global.Path.config, { recursive: true }),

packages/opencode/src/npm/index.ts

@@ -6,7 +6,7 @@ import { Log } from "../util/log"
 import path from "path"
 import { readdir, rm } from "fs/promises"
 import { Filesystem } from "@/util/filesystem"
-import { Flock } from "@/util/flock"
+import { Flock } from "@opencode-ai/shared/util/flock"
 import { Arborist } from "@npmcli/arborist"
 
 export namespace Npm {

packages/opencode/src/plugin/install.ts

@@ -10,7 +10,7 @@ import {
 import { ConfigPaths } from "@/config/paths"
 import { Global } from "@/global"
 import { Filesystem } from "@/util/filesystem"
-import { Flock } from "@/util/flock"
+import { Flock } from "@opencode-ai/shared/util/flock"
 import { isRecord } from "@/util/record"
 
 import { parsePluginSpecifier, readPackageThemes, readPluginPackage, resolvePluginTarget } from "./shared"

packages/opencode/src/plugin/meta.ts

@@ -4,7 +4,7 @@ import { fileURLToPath } from "url"
 import { Flag } from "@/flag/flag"
 import { Global } from "@/global"
 import { Filesystem } from "@/util/filesystem"
-import { Flock } from "@/util/flock"
+import { Flock } from "@opencode-ai/shared/util/flock"
 
 import { parsePluginSpecifier, pluginSource } from "./shared"
 

packages/opencode/src/provider/models.ts

@@ -6,8 +6,8 @@ import { Installation } from "../installation"
 import { Flag } from "../flag/flag"
 import { lazy } from "@/util/lazy"
 import { Filesystem } from "../util/filesystem"
-import { Flock } from "@/util/flock"
-import { Hash } from "@/util/hash"
+import { Flock } from "@opencode-ai/shared/util/flock"
+import { Hash } from "@opencode-ai/shared/util/hash"
 
 // Try to import bundled snapshot (generated at build time)
 // Falls back to undefined in dev mode when snapshot doesn't exist

packages/opencode/src/provider/provider.ts

@@ -6,7 +6,7 @@ import { mapValues, mergeDeep, omit, pickBy, sortBy } from "remeda"
 import { NoSuchModelError, type Provider as SDK } from "ai"
 import { Log } from "../util/log"
 import { Npm } from "../npm"
-import { Hash } from "../util/hash"
+import { Hash } from "@opencode-ai/shared/util/hash"
 import { Plugin } from "../plugin"
 import { NamedError } from "@opencode-ai/shared/util/error"
 import { type LanguageModelV3 } from "@ai-sdk/provider"

packages/opencode/src/snapshot/index.ts

@@ -6,7 +6,7 @@ import z from "zod"
 import * as CrossSpawnSpawner from "@/effect/cross-spawn-spawner"
 import { InstanceState } from "@/effect/instance-state"
 import { AppFileSystem } from "@opencode-ai/shared/filesystem"
-import { Hash } from "@/util/hash"
+import { Hash } from "@opencode-ai/shared/util/hash"
 import { Config } from "../config/config"
 import { Global } from "../global"
 import { Log } from "../util/log"

packages/opencode/src/util/flock.ts

@@ -1,333 +0,0 @@
-import path from "path"
-import os from "os"
-import { randomBytes, randomUUID } from "crypto"
-import { mkdir, readFile, rm, stat, utimes, writeFile } from "fs/promises"
-import { Global } from "@/global"
-import { Hash } from "@/util/hash"
-
-export namespace Flock {
-  const root = path.join(Global.Path.state, "locks")
-  // Defaults for callers that do not provide timing options.
-  const defaultOpts = {
-    staleMs: 60_000,
-    timeoutMs: 5 * 60_000,
-    baseDelayMs: 100,
-    maxDelayMs: 2_000,
-  }
-
-  export interface WaitEvent {
-    key: string
-    attempt: number
-    delay: number
-    waited: number
-  }
-
-  export type Wait = (input: WaitEvent) => void | Promise<void>
-
-  export interface Options {
-    dir?: string
-    signal?: AbortSignal
-    staleMs?: number
-    timeoutMs?: number
-    baseDelayMs?: number
-    maxDelayMs?: number
-    onWait?: Wait
-  }
-
-  type Opts = {
-    staleMs: number
-    timeoutMs: number
-    baseDelayMs: number
-    maxDelayMs: number
-  }
-
-  type Owned = {
-    acquired: true
-    startHeartbeat: (intervalMs?: number) => void
-    release: () => Promise<void>
-  }
-
-  export interface Lease {
-    release: () => Promise<void>
-    [Symbol.asyncDispose]: () => Promise<void>
-  }
-
-  function code(err: unknown) {
-    if (typeof err !== "object" || err === null || !("code" in err)) return
-    const value = err.code
-    if (typeof value !== "string") return
-    return value
-  }
-
-  function sleep(ms: number, signal?: AbortSignal) {
-    return new Promise<void>((resolve, reject) => {
-      if (signal?.aborted) {
-        reject(signal.reason ?? new Error("Aborted"))
-        return
-      }
-
-      let timer: NodeJS.Timeout | undefined
-
-      const done = () => {
-        signal?.removeEventListener("abort", abort)
-        resolve()
-      }
-
-      const abort = () => {
-        if (timer) {
-          clearTimeout(timer)
-        }
-        signal?.removeEventListener("abort", abort)
-        reject(signal?.reason ?? new Error("Aborted"))
-      }
-
-      signal?.addEventListener("abort", abort, { once: true })
-      timer = setTimeout(done, ms)
-    })
-  }
-
-  function jitter(ms: number) {
-    const j = Math.floor(ms * 0.3)
-    const d = Math.floor(Math.random() * (2 * j + 1)) - j
-    return Math.max(0, ms + d)
-  }
-
-  function mono() {
-    return performance.now()
-  }
-
-  function wall() {
-    return performance.timeOrigin + mono()
-  }
-
-  async function stats(file: string) {
-    try {
-      return await stat(file)
-    } catch (err) {
-      const errCode = code(err)
-      if (errCode === "ENOENT" || errCode === "ENOTDIR") return
-      throw err
-    }
-  }
-
-  async function stale(lockDir: string, heartbeatPath: string, metaPath: string, staleMs: number) {
-    // Stale detection allows automatic recovery after crashed owners.
-    const now = wall()
-    const heartbeat = await stats(heartbeatPath)
-    if (heartbeat) {
-      return now - heartbeat.mtimeMs > staleMs
-    }
-
-    const meta = await stats(metaPath)
-    if (meta) {
-      return now - meta.mtimeMs > staleMs
-    }
-
-    const dir = await stats(lockDir)
-    if (!dir) {
-      return false
-    }
-
-    return now - dir.mtimeMs > staleMs
-  }
-
-  async function tryAcquireLockDir(lockDir: string, opts: Opts): Promise<Owned | { acquired: false }> {
-    const token = randomUUID?.() ?? randomBytes(16).toString("hex")
-    const metaPath = path.join(lockDir, "meta.json")
-    const heartbeatPath = path.join(lockDir, "heartbeat")
-
-    try {
-      await mkdir(lockDir, { mode: 0o700 })
-    } catch (err) {
-      if (code(err) !== "EEXIST") {
-        throw err
-      }
-
-      if (!(await stale(lockDir, heartbeatPath, metaPath, opts.staleMs))) {
-        return { acquired: false }
-      }
-
-      const breakerPath = lockDir + ".breaker"
-      try {
-        await mkdir(breakerPath, { mode: 0o700 })
-      } catch (claimErr) {
-        const errCode = code(claimErr)
-        if (errCode === "EEXIST") {
-          const breaker = await stats(breakerPath)
-          if (breaker && wall() - breaker.mtimeMs > opts.staleMs) {
-            await rm(breakerPath, { recursive: true, force: true }).catch(() => undefined)
-          }
-          return { acquired: false }
-        }
-
-        if (errCode === "ENOENT" || errCode === "ENOTDIR") {
-          return { acquired: false }
-        }
-
-        throw claimErr
-      }
-
-      try {
-        // Breaker ownership ensures only one contender performs stale cleanup.
-        if (!(await stale(lockDir, heartbeatPath, metaPath, opts.staleMs))) {
-          return { acquired: false }
-        }
-
-        await rm(lockDir, { recursive: true, force: true })
-
-        try {
-          await mkdir(lockDir, { mode: 0o700 })
-        } catch (retryErr) {
-          const errCode = code(retryErr)
-          if (errCode === "EEXIST" || errCode === "ENOTEMPTY") {
-            return { acquired: false }
-          }
-          throw retryErr
-        }
-      } finally {
-        await rm(breakerPath, { recursive: true, force: true }).catch(() => undefined)
-      }
-    }
-
-    const meta = {
-      token,
-      pid: process.pid,
-      hostname: os.hostname(),
-      createdAt: new Date().toISOString(),
-    }
-
-    await writeFile(heartbeatPath, "", { flag: "wx" }).catch(async () => {
-      await rm(lockDir, { recursive: true, force: true })
-      throw new Error("Lock acquired but heartbeat already existed (possible compromise).")
-    })
-
-    await writeFile(metaPath, JSON.stringify(meta, null, 2), { flag: "wx" }).catch(async () => {
-      await rm(lockDir, { recursive: true, force: true })
-      throw new Error("Lock acquired but meta.json already existed (possible compromise).")
-    })
-
-    let timer: NodeJS.Timeout | undefined
-
-    const startHeartbeat = (intervalMs = Math.max(100, Math.floor(opts.staleMs / 3))) => {
-      if (timer) return
-      // Heartbeat prevents long critical sections from being evicted as stale.
-      timer = setInterval(() => {
-        const t = new Date()
-        void utimes(heartbeatPath, t, t).catch(() => undefined)
-      }, intervalMs)
-      timer.unref?.()
-    }
-
-    const release = async () => {
-      if (timer) {
-        clearInterval(timer)
-        timer = undefined
-      }
-
-      const current = await readFile(metaPath, "utf8")
-        .then((raw) => {
-          const parsed = JSON.parse(raw)
-          if (!parsed || typeof parsed !== "object") return {}
-          return {
-            token: "token" in parsed && typeof parsed.token === "string" ? parsed.token : undefined,
-          }
-        })
-        .catch((err) => {
-          const errCode = code(err)
-          if (errCode === "ENOENT" || errCode === "ENOTDIR") {
-            throw new Error("Refusing to release: lock is compromised (metadata missing).")
-          }
-          if (err instanceof SyntaxError) {
-            throw new Error("Refusing to release: lock is compromised (metadata invalid).")
-          }
-          throw err
-        })
-      // Token check prevents deleting a lock that was re-acquired by another process.
-      if (current.token !== token) {
-        throw new Error("Refusing to release: lock token mismatch (not the owner).")
-      }
-
-      await rm(lockDir, { recursive: true, force: true })
-    }
-
-    return {
-      acquired: true,
-      startHeartbeat,
-      release,
-    }
-  }
-
-  async function acquireLockDir(
-    lockDir: string,
-    input: { key: string; onWait?: Wait; signal?: AbortSignal },
-    opts: Opts,
-  ) {
-    const stop = mono() + opts.timeoutMs
-    let attempt = 0
-    let waited = 0
-    let delay = opts.baseDelayMs
-
-    while (true) {
-      input.signal?.throwIfAborted()
-
-      const res = await tryAcquireLockDir(lockDir, opts)
-      if (res.acquired) {
-        return res
-      }
-
-      if (mono() > stop) {
-        throw new Error(`Timed out waiting for lock: ${input.key}`)
-      }
-
-      attempt += 1
-      const ms = jitter(delay)
-      await input.onWait?.({
-        key: input.key,
-        attempt,
-        delay: ms,
-        waited,
-      })
-      await sleep(ms, input.signal)
-      waited += ms
-      delay = Math.min(opts.maxDelayMs, Math.floor(delay * 1.7))
-    }
-  }
-
-  export async function acquire(key: string, input: Options = {}): Promise<Lease> {
-    input.signal?.throwIfAborted()
-    const cfg: Opts = {
-      staleMs: input.staleMs ?? defaultOpts.staleMs,
-      timeoutMs: input.timeoutMs ?? defaultOpts.timeoutMs,
-      baseDelayMs: input.baseDelayMs ?? defaultOpts.baseDelayMs,
-      maxDelayMs: input.maxDelayMs ?? defaultOpts.maxDelayMs,
-    }
-    const dir = input.dir ?? root
-
-    await mkdir(dir, { recursive: true })
-    const lockfile = path.join(dir, Hash.fast(key) + ".lock")
-    const lock = await acquireLockDir(
-      lockfile,
-      {
-        key,
-        onWait: input.onWait,
-        signal: input.signal,
-      },
-      cfg,
-    )
-    lock.startHeartbeat()
-
-    const release = () => lock.release()
-    return {
-      release,
-      [Symbol.asyncDispose]() {
-        return release()
-      },
-    }
-  }
-
-  export async function withLock<T>(key: string, fn: () => Promise<T>, input: Options = {}) {
-    await using _ = await acquire(key, input)
-    input.signal?.throwIfAborted()
-    return await fn()
-  }
-}

packages/opencode/src/util/hash.ts

@@ -1,7 +0,0 @@
-import { createHash } from "crypto"
-
-export namespace Hash {
-  export function fast(input: string | Buffer): string {
-    return createHash("sha1").update(input).digest("hex")
-  }
-}

packages/opencode/test/fixture/flock-worker.ts

@@ -1,5 +1,5 @@
 import fs from "fs/promises"
-import { Flock } from "../../src/util/flock"
+import { Flock } from "@opencode-ai/shared/util/flock"
 
 type Msg = {
   key: string

packages/opencode/test/util/flock.test.ts

@@ -1,383 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import fs from "fs/promises"
-import path from "path"
-import { Flock } from "../../src/util/flock"
-import { Hash } from "../../src/util/hash"
-import { Process } from "../../src/util/process"
-import { Filesystem } from "../../src/util/filesystem"
-import { tmpdir } from "../fixture/fixture"
-
-const root = path.join(import.meta.dir, "../..")
-const worker = path.join(import.meta.dir, "../fixture/flock-worker.ts")
-
-type Msg = {
-  key: string
-  dir: string
-  staleMs?: number
-  timeoutMs?: number
-  baseDelayMs?: number
-  maxDelayMs?: number
-  holdMs?: number
-  ready?: string
-  active?: string
-  done?: string
-}
-
-function lock(dir: string, key: string) {
-  return path.join(dir, Hash.fast(key) + ".lock")
-}
-
-function sleep(ms: number) {
-  return new Promise<void>((resolve) => {
-    setTimeout(resolve, ms)
-  })
-}
-
-async function exists(file: string) {
-  return fs
-    .stat(file)
-    .then(() => true)
-    .catch(() => false)
-}
-
-async function wait(file: string, timeout = 3_000) {
-  const stop = Date.now() + timeout
-  while (Date.now() < stop) {
-    if (await exists(file)) return
-    await sleep(20)
-  }
-
-  throw new Error(`Timed out waiting for file: ${file}`)
-}
-
-function run(msg: Msg) {
-  return Process.run([process.execPath, worker, JSON.stringify(msg)], {
-    cwd: root,
-    nothrow: true,
-  })
-}
-
-function spawn(msg: Msg) {
-  return Process.spawn([process.execPath, worker, JSON.stringify(msg)], {
-    cwd: root,
-    stdin: "ignore",
-    stdout: "pipe",
-    stderr: "pipe",
-  })
-}
-
-describe("util.flock", () => {
-  test("enforces mutual exclusion under process contention", async () => {
-    await using tmp = await tmpdir()
-    const dir = path.join(tmp.path, "locks")
-    const done = path.join(tmp.path, "done.log")
-    const active = path.join(tmp.path, "active")
-    const key = "flock:stress"
-    const n = 16
-
-    const out = await Promise.all(
-      Array.from({ length: n }, () =>
-        run({
-          key,
-          dir,
-          done,
-          active,
-          holdMs: 30,
-          staleMs: 1_000,
-          timeoutMs: 15_000,
-        }),
-      ),
-    )
-
-    expect(out.map((x) => x.code)).toEqual(Array.from({ length: n }, () => 0))
-    expect(out.map((x) => x.stderr.toString()).filter(Boolean)).toEqual([])
-
-    const lines = (await fs.readFile(done, "utf8"))
-      .split("\n")
-      .map((x) => x.trim())
-      .filter(Boolean)
-    expect(lines.length).toBe(n)
-  }, 20_000)
-
-  test("times out while waiting when lock is still healthy", async () => {
-    await using tmp = await tmpdir()
-    const dir = path.join(tmp.path, "locks")
-    const key = "flock:timeout"
-    const ready = path.join(tmp.path, "ready")
-    const proc = spawn({
-      key,
-      dir,
-      ready,
-      holdMs: 20_000,
-      staleMs: 10_000,
-      timeoutMs: 30_000,
-    })
-
-    try {
-      await wait(ready, 5_000)
-      const seen: string[] = []
-      const err = await Flock.withLock(key, async () => {}, {
-        dir,
-        staleMs: 10_000,
-        timeoutMs: 1_000,
-        onWait: (tick) => {
-          seen.push(tick.key)
-        },
-      }).catch((err) => err)
-
-      expect(err).toBeInstanceOf(Error)
-      if (!(err instanceof Error)) throw err
-      expect(err.message).toContain("Timed out waiting for lock")
-      expect(seen.length).toBeGreaterThan(0)
-      expect(seen.every((x) => x === key)).toBe(true)
-    } finally {
-      await Process.stop(proc).catch(() => undefined)
-      await proc.exited.catch(() => undefined)
-    }
-  }, 15_000)
-
-  test("recovers after a crashed lock owner", async () => {
-    await using tmp = await tmpdir()
-    const dir = path.join(tmp.path, "locks")
-    const key = "flock:crash"
-    const ready = path.join(tmp.path, "ready")
-    const proc = spawn({
-      key,
-      dir,
-      ready,
-      holdMs: 20_000,
-      staleMs: 500,
-      timeoutMs: 30_000,
-    })
-
-    await wait(ready, 5_000)
-    await Process.stop(proc)
-    await proc.exited.catch(() => undefined)
-
-    let hit = false
-    await Flock.withLock(
-      key,
-      async () => {
-        hit = true
-      },
-      {
-        dir,
-        staleMs: 500,
-        timeoutMs: 8_000,
-      },
-    )
-
-    expect(hit).toBe(true)
-  }, 20_000)
-
-  test("breaks stale lock dirs when heartbeat is missing", async () => {
-    await using tmp = await tmpdir()
-    const dir = path.join(tmp.path, "locks")
-    const key = "flock:missing-heartbeat"
-    const lockDir = lock(dir, key)
-
-    await fs.mkdir(lockDir, { recursive: true })
-    const old = new Date(Date.now() - 2_000)
-    await fs.utimes(lockDir, old, old)
-
-    let hit = false
-    await Flock.withLock(
-      key,
-      async () => {
-        hit = true
-      },
-      {
-        dir,
-        staleMs: 200,
-        timeoutMs: 3_000,
-      },
-    )
-
-    expect(hit).toBe(true)
-  })
-
-  test("recovers when a stale breaker claim was left behind", async () => {
-    await using tmp = await tmpdir()
-    const dir = path.join(tmp.path, "locks")
-    const key = "flock:stale-breaker"
-    const lockDir = lock(dir, key)
-    const breaker = lockDir + ".breaker"
-
-    await fs.mkdir(lockDir, { recursive: true })
-    await fs.mkdir(breaker)
-
-    const old = new Date(Date.now() - 2_000)
-    await fs.utimes(lockDir, old, old)
-    await fs.utimes(breaker, old, old)
-
-    let hit = false
-    await Flock.withLock(
-      key,
-      async () => {
-        hit = true
-      },
-      {
-        dir,
-        staleMs: 200,
-        timeoutMs: 3_000,
-      },
-    )
-
-    expect(hit).toBe(true)
-    expect(await exists(breaker)).toBe(false)
-  })
-
-  test("fails clearly if lock dir is removed while held", async () => {
-    await using tmp = await tmpdir()
-    const dir = path.join(tmp.path, "locks")
-    const key = "flock:compromised"
-    const lockDir = lock(dir, key)
-
-    const err = await Flock.withLock(
-      key,
-      async () => {
-        await fs.rm(lockDir, {
-          recursive: true,
-          force: true,
-        })
-      },
-      {
-        dir,
-        staleMs: 1_000,
-        timeoutMs: 3_000,
-      },
-    ).catch((err) => err)
-
-    expect(err).toBeInstanceOf(Error)
-    if (!(err instanceof Error)) throw err
-    expect(err.message).toContain("compromised")
-
-    let hit = false
-    await Flock.withLock(
-      key,
-      async () => {
-        hit = true
-      },
-      {
-        dir,
-        staleMs: 200,
-        timeoutMs: 3_000,
-      },
-    )
-    expect(hit).toBe(true)
-  })
-
-  test("writes owner metadata while lock is held", async () => {
-    await using tmp = await tmpdir()
-    const dir = path.join(tmp.path, "locks")
-    const key = "flock:meta"
-    const file = path.join(lock(dir, key), "meta.json")
-
-    await Flock.withLock(
-      key,
-      async () => {
-        const json = await Filesystem.readJson<{
-          token?: unknown
-          pid?: unknown
-          hostname?: unknown
-          createdAt?: unknown
-        }>(file)
-
-        expect(typeof json.token).toBe("string")
-        expect(typeof json.pid).toBe("number")
-        expect(typeof json.hostname).toBe("string")
-        expect(typeof json.createdAt).toBe("string")
-      },
-      {
-        dir,
-        staleMs: 1_000,
-        timeoutMs: 3_000,
-      },
-    )
-  })
-
-  test("supports acquire with await using", async () => {
-    await using tmp = await tmpdir()
-    const dir = path.join(tmp.path, "locks")
-    const key = "flock:acquire"
-    const lockDir = lock(dir, key)
-
-    {
-      await using _ = await Flock.acquire(key, {
-        dir,
-        staleMs: 1_000,
-        timeoutMs: 3_000,
-      })
-      expect(await exists(lockDir)).toBe(true)
-    }
-
-    expect(await exists(lockDir)).toBe(false)
-  })
-
-  test("refuses token mismatch release and recovers from stale", async () => {
-    await using tmp = await tmpdir()
-    const dir = path.join(tmp.path, "locks")
-    const key = "flock:token"
-    const lockDir = lock(dir, key)
-    const meta = path.join(lockDir, "meta.json")
-
-    const err = await Flock.withLock(
-      key,
-      async () => {
-        const json = await Filesystem.readJson<{ token?: string }>(meta)
-        json.token = "tampered"
-        await fs.writeFile(meta, JSON.stringify(json, null, 2))
-      },
-      {
-        dir,
-        staleMs: 500,
-        timeoutMs: 3_000,
-      },
-    ).catch((err) => err)
-
-    expect(err).toBeInstanceOf(Error)
-    if (!(err instanceof Error)) throw err
-    expect(err.message).toContain("token mismatch")
-    expect(await exists(lockDir)).toBe(true)
-
-    let hit = false
-    await Flock.withLock(
-      key,
-      async () => {
-        hit = true
-      },
-      {
-        dir,
-        staleMs: 500,
-        timeoutMs: 6_000,
-      },
-    )
-    expect(hit).toBe(true)
-  })
-
-  test("fails clearly on unwritable lock roots", async () => {
-    if (process.platform === "win32") return
-
-    await using tmp = await tmpdir()
-    const dir = path.join(tmp.path, "locks")
-    const key = "flock:perm"
-
-    await fs.mkdir(dir, { recursive: true })
-    await fs.chmod(dir, 0o500)
-
-    try {
-      const err = await Flock.withLock(key, async () => {}, {
-        dir,
-        staleMs: 100,
-        timeoutMs: 500,
-      }).catch((err) => err)
-
-      expect(err).toBeInstanceOf(Error)
-      if (!(err instanceof Error)) throw err
-      const text = err.message
-      expect(text.includes("EACCES") || text.includes("EPERM")).toBe(true)
-    } finally {
-      await fs.chmod(dir, 0o700)
-    }
-  })
-})