@planet-matrix/mobius-model 0.4.0 → 0.6.0

package/tests/unit/log/logger.spec.ts

@@ -0,0 +1,222 @@
+import { expect, test } from "vitest"
+
+import type { LogEmitter, LogEmitterItem } from "#Source/log/index.ts"
+import {
+  Logger,
+  getGlobalLogger,
+} from "#Source/log/index.ts"
+
+const makeMemoryEmitter = (sink: string[]): LogEmitterItem => {
+  class InternalMemoryEmitter implements LogEmitter {
+    readonly tags: string[]
+    readonly messages: unknown[]
+    readonly formattedMessages: string[]
+
+    constructor(options: { tags?: string[] | undefined, messages?: unknown[] | undefined }) {
+      this.tags = options.tags ?? []
+      this.messages = options.messages ?? []
+      this.formattedMessages = [
+        this.tags.map(tag => `[${tag}]`).join(""),
+        this.messages.map(message => String(message)).join(" "),
+      ]
+    }
+
+    emit(): void {
+      sink.push(this.formattedMessages.join(" "))
+    }
+  }
+
+  return {
+    logType: "info",
+    LogEmitter: InternalMemoryEmitter,
+  }
+}
+
+test("Logger.fromOptions returns provided logger and otherwise derives from global logger", () => {
+  const explicit = new Logger({ name: "Explicit" })
+  const resolvedExplicit = Logger.fromOptions({ logger: explicit })
+  const resolvedDerived = Logger.fromOptions({})
+
+  expect(resolvedExplicit).toBe(explicit)
+  expect(resolvedDerived.hasParent()).toBe(true)
+  expect(resolvedDerived.getNameTags()).toContain(getGlobalLogger().getName())
+})
+
+test("Logger.derive creates child logger with inherited configs", () => {
+  const parent = new Logger({ name: "Parent" })
+  const child = Logger.derive(parent)
+
+  expect(child.hasParent()).toBe(true)
+  expect(child.getNameTags()).toEqual(["Parent", "Unnamed"])
+})
+
+test("Logger config APIs merge and apply parent configs", () => {
+  const parent = new Logger({
+    name: "Parent",
+    configs: {
+      enabled: true,
+      autoSend: true,
+      filter: (): boolean => true,
+      emitters: [],
+    },
+  })
+  const child = new Logger({
+    name: "Child",
+    parent,
+    configs: {
+      enabled: false,
+    },
+  })
+
+  expect(child.getConfigs().enabled).toBe(true)
+
+  child.setConfigs({ enabled: false })
+  expect(child.getConfigs().enabled).toBe(false)
+
+  child.useParentConfigs()
+  expect(child.getConfigs().enabled).toBe(true)
+})
+
+test("Logger emitter APIs add, deduplicate and remove emitters", () => {
+  const sink: string[] = []
+  const emitter = makeMemoryEmitter(sink)
+  const logger = new Logger({
+    name: "EmitterLogger",
+    configs: {
+      emitters: [],
+      enabled: true,
+      autoSend: true,
+      filter: (): boolean => true,
+    },
+  })
+
+  logger.addLogEmitters([emitter, emitter])
+  expect(logger.getAllLogEmitters()).toHaveLength(1)
+  expect(logger.getLogEmitters("info")).toHaveLength(1)
+
+  logger.info("hello")
+  expect(sink).toHaveLength(1)
+
+  logger.removeLogEmitters([emitter])
+  expect(logger.getAllLogEmitters()).toHaveLength(0)
+})
+
+test("Logger tags APIs manage instance, session and once tags", () => {
+  const sink: string[] = []
+  const logger = new Logger({
+    name: "TagLogger",
+    configs: {
+      emitters: [makeMemoryEmitter(sink)],
+      enabled: true,
+      autoSend: true,
+      filter: (): boolean => true,
+    },
+  })
+
+  logger.addInstanceTags(["instance"]).tagStart(["session"]).addOnceTags(["once"])
+  logger.info("first")
+  logger.info("second")
+
+  expect(sink[0]).toContain("[instance]")
+  expect(sink[0]).toContain("[session]")
+  expect(sink[0]).toContain("[once]")
+  expect(sink[1]).toContain("[instance]")
+  expect(sink[1]).toContain("[session]")
+  expect(sink[1]).not.toContain("[once]")
+
+  logger.removeInstanceTags(["instance"]).tagEnd()
+  expect(logger.getInstanceTags()).toEqual([])
+  expect(logger.getSessionTags()).toEqual([])
+})
+
+test("Logger.autoTag adds temporary tags during disposable scope", () => {
+  const sink: string[] = []
+  const logger = new Logger({
+    name: "AutoTagLogger",
+    configs: {
+      emitters: [makeMemoryEmitter(sink)],
+      enabled: true,
+      autoSend: true,
+      filter: (): boolean => true,
+    },
+  })
+
+  const disposable = logger.autoTag(["scoped"])
+  logger.info("within")
+  disposable[Symbol.dispose]()
+  logger.info("outside")
+
+  expect(sink[0]).toContain("[scoped]")
+  expect(sink[1]).not.toContain("[scoped]")
+})
+
+test("Logger logging APIs respect enabled and filter configs", () => {
+  const sink: string[] = []
+  const logger = new Logger({
+    name: "FilterLogger",
+    configs: {
+      emitters: [makeMemoryEmitter(sink)],
+      enabled: false,
+      autoSend: true,
+      filter: (): boolean => true,
+    },
+  })
+
+  logger.log("a").info("b").warn("c").error("d").debug("e")
+  expect(sink).toHaveLength(0)
+
+  logger.setConfigs({ enabled: true, filter: () => false })
+  logger.info("blocked")
+  expect(sink).toHaveLength(0)
+
+  logger.setConfigs({ filter: () => true })
+  logger.info("allowed")
+  expect(sink).toHaveLength(1)
+})
+
+test("Logger.send flushes queued logs when autoSend is disabled", () => {
+  const sink: string[] = []
+  const logger = new Logger({
+    name: "BatchLogger",
+    configs: {
+      emitters: [makeMemoryEmitter(sink)],
+      enabled: true,
+      autoSend: false,
+      filter: (): boolean => true,
+    },
+  })
+
+  logger.info("queued")
+  expect(sink).toHaveLength(0)
+
+  logger.send()
+  expect(sink).toHaveLength(1)
+})
+
+test("Logger.batch creates manual child logger and supports disposal send", () => {
+  const sink: string[] = []
+  const logger = new Logger({
+    name: "ParentLogger",
+    configs: {
+      emitters: [makeMemoryEmitter(sink)],
+      enabled: true,
+      autoSend: true,
+      filter: (): boolean => true,
+    },
+  })
+
+  const child = logger.batch("batch-id")
+  child.info("queued")
+  expect(sink).toHaveLength(0)
+
+  child[Symbol.dispose]()
+  expect(sink).toHaveLength(1)
+  expect(sink[0]).toContain("[batch-id]")
+})
+
+test("getGlobalLogger returns singleton instance", () => {
+  const logger1 = getGlobalLogger()
+  const logger2 = getGlobalLogger()
+
+  expect(logger1).toBe(logger2)
+})

package/tests/unit/orchestration/coordination/barrier.spec.ts

@@ -0,0 +1,96 @@
+import { afterEach, expect, test, vi } from "vitest"
+
+import { Barrier, BrokenBarrierError, CoordinationAbortError, CoordinationTimeoutError } from "#Source/orchestration/index.ts"
+
+const getRejectedReason = async (promise: Promise<unknown>): Promise<unknown> => {
+  try {
+    await promise
+  }
+  catch (error: unknown) {
+    return error
+  }
+
+  throw new Error("Expected promise to reject.")
+}
+
+afterEach(() => {
+  vi.clearAllTimers()
+  vi.useRealTimers()
+})
+
+test("Barrier completes generations and can be reused", async () => {
+  const barrier = new Barrier(2)
+  const firstGenerationWait = barrier.signalAndWait()
+
+  expect(barrier.getParticipantCount()).toBe(2)
+  expect(barrier.getGeneration()).toBe(0)
+  expect(barrier.getPendingCount()).toBe(1)
+  expect(barrier.getRemainingCount()).toBe(1)
+
+  const secondArrivalGeneration = await barrier.signalAndWait()
+  const firstArrivalGeneration = await firstGenerationWait
+
+  expect(firstArrivalGeneration).toBe(0)
+  expect(secondArrivalGeneration).toBe(0)
+  expect(barrier.getGeneration()).toBe(1)
+  expect(barrier.getPendingCount()).toBe(0)
+  expect(barrier.getRemainingCount()).toBe(2)
+
+  const thirdArrivalGenerationPromise = barrier.signalAndWait()
+  const fourthArrivalGeneration = await barrier.signalAndWait()
+
+  expect(await thirdArrivalGenerationPromise).toBe(1)
+  expect(fourthArrivalGeneration).toBe(1)
+  expect(barrier.getGeneration()).toBe(2)
+})
+
+test("Barrier timeout breaks the current generation for all waiting participants", async () => {
+  vi.useFakeTimers()
+
+  const barrier = new Barrier(3)
+  const firstWait = barrier.signalAndWait()
+  const secondWait = barrier.signalAndWait({ timeout: 25 })
+
+  expect(barrier.getPendingCount()).toBe(2)
+  expect(barrier.getRemainingCount()).toBe(1)
+
+  await vi.advanceTimersByTimeAsync(25)
+
+  const timeoutError = await getRejectedReason(secondWait)
+  const brokenError = await getRejectedReason(firstWait)
+
+  expect(timeoutError).toBeInstanceOf(CoordinationTimeoutError)
+  expect(brokenError).toBeInstanceOf(BrokenBarrierError)
+
+  if (!(brokenError instanceof BrokenBarrierError)) {
+    throw new Error("Expected brokenError to be an instance of BrokenBarrierError.")
+  }
+
+  expect(brokenError.reason).toBe(timeoutError)
+  expect(barrier.getGeneration()).toBe(1)
+  expect(barrier.getPendingCount()).toBe(0)
+  expect(barrier.getRemainingCount()).toBe(3)
+})
+
+test("Barrier abort rejects the failing participant and breaks peers", async () => {
+  const barrier = new Barrier(3)
+  const abortController = new AbortController()
+  const firstWait = barrier.signalAndWait()
+  const secondWait = barrier.signalAndWait({ abortSignal: abortController.signal })
+
+  abortController.abort("cancelled")
+
+  const abortError = await getRejectedReason(secondWait)
+  const brokenError = await getRejectedReason(firstWait)
+
+  expect(abortError).toBeInstanceOf(CoordinationAbortError)
+  expect(brokenError).toBeInstanceOf(BrokenBarrierError)
+
+  if (!(brokenError instanceof BrokenBarrierError)) {
+    throw new Error("Expected brokenError to be an instance of BrokenBarrierError.")
+  }
+
+  expect(brokenError.reason).toBe(abortError)
+  expect(barrier.getGeneration()).toBe(1)
+  expect(barrier.getPendingCount()).toBe(0)
+})

package/tests/unit/orchestration/coordination/count-down-latch.spec.ts

@@ -0,0 +1,63 @@
+import { afterEach, expect, test, vi } from "vitest"
+
+import { CoordinationAbortError, CoordinationTimeoutError, CountDownLatch } from "#Source/orchestration/index.ts"
+
+afterEach(() => {
+  vi.clearAllTimers()
+  vi.useRealTimers()
+})
+
+test("CountDownLatch opens when the count reaches zero and resolves waiters", async () => {
+  const countDownLatch = new CountDownLatch(2)
+  const firstWait = countDownLatch.wait()
+  const secondWait = countDownLatch.wait()
+
+  expect(countDownLatch.isOpen()).toBe(false)
+  expect(countDownLatch.tryWait()).toBe(false)
+  expect(countDownLatch.getRemainingCount()).toBe(2)
+  expect(countDownLatch.getPendingCount()).toBe(2)
+
+  expect(countDownLatch.countDown()).toBe(1)
+  expect(countDownLatch.arrive()).toBe(0)
+
+  await Promise.all([firstWait, secondWait])
+
+  expect(countDownLatch.isOpen()).toBe(true)
+  expect(countDownLatch.tryWait()).toBe(true)
+  expect(countDownLatch.getRemainingCount()).toBe(0)
+  expect(countDownLatch.getPendingCount()).toBe(0)
+  await expect(countDownLatch.wait()).resolves.toBeUndefined()
+})
+
+test("CountDownLatch wait rejects on timeout and abort without leaking pending entries", async () => {
+  vi.useFakeTimers()
+
+  const countDownLatch = new CountDownLatch(1)
+  const timeoutPromise = countDownLatch.wait({ timeout: 30 })
+
+  expect(countDownLatch.getPendingCount()).toBe(1)
+
+  await vi.advanceTimersByTimeAsync(30)
+
+  await expect(timeoutPromise).rejects.toBeInstanceOf(CoordinationTimeoutError)
+  expect(countDownLatch.getPendingCount()).toBe(0)
+
+  const abortController = new AbortController()
+  const abortPromise = countDownLatch.wait({ abortSignal: abortController.signal })
+
+  expect(countDownLatch.getPendingCount()).toBe(1)
+
+  abortController.abort("cancelled")
+
+  await expect(abortPromise).rejects.toBeInstanceOf(CoordinationAbortError)
+  expect(countDownLatch.getPendingCount()).toBe(0)
+})
+
+test("CountDownLatch ignores further countdowns after opening", () => {
+  const countDownLatch = new CountDownLatch(1)
+
+  expect(countDownLatch.countDown()).toBe(0)
+  expect(countDownLatch.countDown()).toBe(0)
+  expect(countDownLatch.arrive()).toBe(0)
+  expect(countDownLatch.isOpen()).toBe(true)
+})

package/tests/unit/orchestration/coordination/errors.spec.ts

@@ -0,0 +1,29 @@
+import { expect, test } from "vitest"
+
+import { BrokenBarrierError, CoordinationAbortError, CoordinationTimeoutError } from "#Source/orchestration/index.ts"
+
+test("CoordinationAbortError stores operation, reason and formatted message", () => {
+  const error = new CoordinationAbortError("Mutex acquire", "cancelled")
+
+  expect(error.name).toBe("CoordinationAbortError")
+  expect(error.operation).toBe("Mutex acquire")
+  expect(error.reason).toBe("cancelled")
+  expect(error.message).toBe("Mutex acquire aborted. cancelled")
+})
+
+test("CoordinationTimeoutError stores operation, timeout and formatted message", () => {
+  const error = new CoordinationTimeoutError("Semaphore acquire", 25)
+
+  expect(error.name).toBe("CoordinationTimeoutError")
+  expect(error.operation).toBe("Semaphore acquire")
+  expect(error.timeout).toBe(25)
+  expect(error.message).toBe("Semaphore acquire timeout after 25ms.")
+})
+
+test("BrokenBarrierError stores reason and formatted message", () => {
+  const error = new BrokenBarrierError("peer aborted")
+
+  expect(error.name).toBe("BrokenBarrierError")
+  expect(error.reason).toBe("peer aborted")
+  expect(error.message).toBe("Barrier generation was broken by another participant. peer aborted")
+})

package/tests/unit/orchestration/coordination/keyed-lock.spec.ts

@@ -0,0 +1,109 @@
+import { expect, test, vi } from "vitest"
+
+import { CoordinationAbortError, KeyedLock } from "#Source/orchestration/index.ts"
+
+test("KeyedLock isolates different keys and cleans state after release", () => {
+  const keyedLock = new KeyedLock<string>()
+
+  expect(keyedLock.getKeyCount()).toBe(0)
+  expect(keyedLock.hasKey("alpha")).toBe(false)
+
+  const alphaPermit = keyedLock.tryAcquire("alpha")
+  const betaPermit = keyedLock.tryAcquire("beta")
+
+  expect(alphaPermit?.details).toEqual({ coordination: "keyed-lock", key: "alpha" })
+  expect(betaPermit?.details).toEqual({ coordination: "keyed-lock", key: "beta" })
+  expect(keyedLock.tryAcquire("alpha")).toBeUndefined()
+  expect(keyedLock.hasKey("alpha")).toBe(true)
+  expect(keyedLock.hasKey("beta")).toBe(true)
+  expect(keyedLock.getKeyCount()).toBe(2)
+
+  alphaPermit?.release()
+  betaPermit?.release()
+
+  expect(keyedLock.hasKey("alpha")).toBe(false)
+  expect(keyedLock.hasKey("beta")).toBe(false)
+  expect(keyedLock.getKeyCount()).toBe(0)
+})
+
+test("KeyedLock acquire cleans aborted waiters and releases state when idle", async () => {
+  const keyedLock = new KeyedLock<string>()
+  const blockingPermit = keyedLock.tryAcquire("alpha")
+  const abortController = new AbortController()
+
+  expect(blockingPermit).toBeDefined()
+
+  const waitingPermitPromise = keyedLock.acquire("alpha", { abortSignal: abortController.signal })
+
+  expect(keyedLock.hasKey("alpha")).toBe(true)
+  expect(keyedLock.getKeyCount()).toBe(1)
+
+  abortController.abort("cancelled")
+
+  await expect(waitingPermitPromise).rejects.toBeInstanceOf(CoordinationAbortError)
+
+  expect(keyedLock.hasKey("alpha")).toBe(true)
+
+  blockingPermit?.release()
+
+  expect(keyedLock.hasKey("alpha")).toBe(false)
+  expect(keyedLock.getKeyCount()).toBe(0)
+})
+
+test("KeyedLock runExclusive serializes callbacks for the same key", async () => {
+  const keyedLock = new KeyedLock<string>()
+  let activeCount = 0
+  let peakCount = 0
+
+  await Promise.all([
+    keyedLock.runExclusive("alpha", async () => {
+      activeCount = activeCount + 1
+      peakCount = Math.max(peakCount, activeCount)
+      await Promise.resolve()
+      activeCount = activeCount - 1
+    }),
+    keyedLock.runExclusive("alpha", async () => {
+      activeCount = activeCount + 1
+      peakCount = Math.max(peakCount, activeCount)
+      await Promise.resolve()
+      activeCount = activeCount - 1
+    }),
+  ])
+
+  expect(peakCount).toBe(1)
+  expect(keyedLock.hasKey("alpha")).toBe(false)
+})
+
+test("KeyedLock duplicate release stays silent by default and uses custom handler when provided", () => {
+  const warnSpy = vi.spyOn(console, "warn").mockImplementation(() => {
+    // no-op to silence warnings during test
+  })
+  const silentKeyedLock = new KeyedLock<string>()
+  const silentPermit = silentKeyedLock.tryAcquire("alpha")
+
+  expect(silentPermit).toBeDefined()
+
+  silentPermit?.release()
+  silentPermit?.release()
+  silentPermit?.release()
+
+  expect(silentKeyedLock.hasKey("alpha")).toBe(false)
+  expect(warnSpy).not.toHaveBeenCalled()
+
+  const onDuplicateRelease = vi.fn()
+  const customKeyedLock = new KeyedLock<string>({ onDuplicateRelease })
+  const customPermit = customKeyedLock.tryAcquire("alpha")
+
+  expect(customPermit).toBeDefined()
+
+  customPermit?.release()
+  customPermit?.release()
+  customPermit?.release()
+
+  expect(customKeyedLock.hasKey("alpha")).toBe(false)
+  expect(onDuplicateRelease).toHaveBeenCalledTimes(2)
+  expect(onDuplicateRelease).toHaveBeenCalledWith("KeyedLock permit release was called more than once.")
+  expect(warnSpy).not.toHaveBeenCalled()
+
+  warnSpy.mockRestore()
+})

package/tests/unit/orchestration/coordination/mutex.spec.ts

@@ -0,0 +1,132 @@
+import { afterEach, expect, test, vi } from "vitest"
+
+import { CoordinationAbortError, CoordinationTimeoutError, Mutex } from "#Source/orchestration/index.ts"
+
+afterEach(() => {
+  vi.clearAllTimers()
+  vi.useRealTimers()
+  vi.restoreAllMocks()
+})
+
+test("Mutex reports lock state and wakes queued acquirers in FIFO order", async () => {
+  const mutex = new Mutex()
+
+  expect(mutex.isLocked()).toBe(false)
+  expect(mutex.getPendingCount()).toBe(0)
+
+  const firstPermit = mutex.tryAcquire()
+
+  expect(firstPermit).toBeDefined()
+  expect(mutex.isLocked()).toBe(true)
+
+  const secondPermitPromise = mutex.acquire()
+  const thirdPermitPromise = mutex.acquire()
+
+  expect(mutex.getPendingCount()).toBe(2)
+  expect(mutex.tryAcquire()).toBeUndefined()
+
+  firstPermit?.release()
+
+  const secondPermit = await secondPermitPromise
+  let thirdResolved = false
+  void thirdPermitPromise.then(() => {
+    thirdResolved = true
+  })
+
+  await Promise.resolve()
+
+  expect(mutex.isLocked()).toBe(true)
+  expect(mutex.getPendingCount()).toBe(1)
+  expect(thirdResolved).toBe(false)
+
+  secondPermit.release()
+
+  const thirdPermit = await thirdPermitPromise
+
+  expect(mutex.getPendingCount()).toBe(0)
+  expect(mutex.isLocked()).toBe(true)
+
+  thirdPermit.release()
+
+  expect(mutex.isLocked()).toBe(false)
+})
+
+test("Mutex acquire rejects on timeout and abort while cleaning pending state", async () => {
+  vi.useFakeTimers()
+
+  const mutex = new Mutex()
+  const blockingPermit = mutex.tryAcquire()
+
+  expect(blockingPermit).toBeDefined()
+
+  const timeoutPromise = mutex.acquire({ timeout: 10 })
+
+  expect(mutex.getPendingCount()).toBe(1)
+
+  await vi.advanceTimersByTimeAsync(10)
+
+  await expect(timeoutPromise).rejects.toBeInstanceOf(CoordinationTimeoutError)
+  expect(mutex.getPendingCount()).toBe(0)
+
+  const abortController = new AbortController()
+  const abortPromise = mutex.acquire({ abortSignal: abortController.signal })
+
+  expect(mutex.getPendingCount()).toBe(1)
+
+  abortController.abort("cancelled")
+
+  await expect(abortPromise).rejects.toBeInstanceOf(CoordinationAbortError)
+  expect(mutex.getPendingCount()).toBe(0)
+
+  blockingPermit?.release()
+})
+
+test("Mutex runExclusive releases the lock after callback success or failure", async () => {
+  const mutex = new Mutex()
+
+  await expect(mutex.runExclusive(() => "done")).resolves.toBe("done")
+  expect(mutex.isLocked()).toBe(false)
+
+  const error = new Error("boom")
+
+  await expect(mutex.runExclusive(() => {
+    throw error
+  })).rejects.toThrow(error)
+
+  expect(mutex.isLocked()).toBe(false)
+})
+
+test("Mutex is silent by default when release is called more than once", () => {
+  const warnSpy = vi.spyOn(console, "warn").mockImplementation(() => {
+    // no-op to silence warnings during test
+  })
+  const mutex = new Mutex()
+
+  const permit = mutex.tryAcquire()
+  expect(permit).toBeDefined()
+
+  permit?.release()
+  permit?.release()
+  permit?.release()
+
+  expect(warnSpy).not.toHaveBeenCalled()
+})
+
+test("Mutex uses custom duplicate-release handler when provided", () => {
+  const warnSpy = vi.spyOn(console, "warn").mockImplementation(() => {
+    // no-op to silence warnings during test
+  })
+  const onDuplicateRelease = vi.fn()
+  const mutex = new Mutex({ onDuplicateRelease })
+
+  const permit = mutex.tryAcquire()
+  expect(permit).toBeDefined()
+
+  permit?.release()
+  permit?.release()
+  permit?.release()
+
+  expect(onDuplicateRelease).toHaveBeenCalledTimes(2)
+  expect(onDuplicateRelease).toHaveBeenCalledWith("Mutex permit release was called more than once.")
+  expect(warnSpy).not.toHaveBeenCalled()
+})

package/tests/unit/orchestration/coordination/permit.spec.ts

@@ -0,0 +1,43 @@
+import { expect, test, vi } from "vitest"
+
+import { Permit } from "#Source/orchestration/index.ts"
+
+test("Permit release updates lifecycle state and only calls handlers once", () => {
+  const onRelease = vi.fn()
+  const onDuplicateRelease = vi.fn()
+  const permit = new Permit({
+    details: { coordination: "custom" },
+    duplicateReleaseMessage: "duplicate release",
+    onDuplicateRelease,
+    onRelease,
+  })
+
+  expect(permit.details).toEqual({ coordination: "custom" })
+  expect(permit.isActive()).toBe(true)
+  expect(permit.isReleased()).toBe(false)
+
+  permit.release()
+
+  expect(onRelease).toHaveBeenCalledTimes(1)
+  expect(permit.isActive()).toBe(false)
+  expect(permit.isReleased()).toBe(true)
+
+  permit.release()
+
+  expect(onDuplicateRelease).toHaveBeenCalledTimes(1)
+  expect(onDuplicateRelease).toHaveBeenCalledWith("duplicate release")
+  expect(onRelease).toHaveBeenCalledTimes(1)
+})
+
+test("Permit dispose and Symbol.dispose delegate to release", () => {
+  const onRelease = vi.fn()
+  const onDuplicateRelease = vi.fn()
+  const permit = new Permit({ onDuplicateRelease, onRelease })
+
+  permit.dispose()
+  permit[Symbol.dispose]()
+
+  expect(onRelease).toHaveBeenCalledTimes(1)
+  expect(onDuplicateRelease).toHaveBeenCalledTimes(1)
+  expect(permit.isReleased()).toBe(true)
+})