@planet-matrix/mobius-model 0.5.0 → 0.6.0

package/tests/unit/exception/browser.spec.ts

@@ -0,0 +1,213 @@
+import { afterEach, expect, test, vi } from "vitest"
+
+import {
+  observeBrowserExceptions,
+  onBrowserGlobalError,
+  onBrowserUnhandledRejection,
+  onBrowserWindowOnError,
+} from "#Source/exception/index.ts"
+
+class WindowMock extends EventTarget {
+  onerror: OnErrorEventHandler | null = null
+  document = {}
+}
+
+const createBrowserErrorEvent = (options: {
+  message: string
+  filename?: string | undefined
+  lineno?: number | undefined
+  colno?: number | undefined
+  error?: unknown
+}): Event => {
+  const event = new Event("error")
+  Object.defineProperties(event, {
+    message: { value: options.message, configurable: true },
+    filename: { value: options.filename, configurable: true },
+    lineno: { value: options.lineno, configurable: true },
+    colno: { value: options.colno, configurable: true },
+    error: { value: options.error, configurable: true },
+  })
+  return event
+}
+
+const createBrowserUnhandledRejectionEvent = (options: {
+  reason: unknown
+  promise: Promise<unknown>
+}): Event => {
+  const event = new Event("unhandledrejection")
+  Object.defineProperties(event, {
+    reason: { value: options.reason, configurable: true },
+    promise: { value: options.promise, configurable: true },
+  })
+  return event
+}
+
+afterEach(() => {
+  vi.unstubAllGlobals()
+  vi.restoreAllMocks()
+})
+
+test("onBrowserGlobalError listens and cleans up window error events", () => {
+  const browserWindow = new WindowMock()
+  const listener = vi.fn()
+  vi.stubGlobal("window", browserWindow)
+  vi.stubGlobal("self", browserWindow)
+  vi.stubGlobal("document", browserWindow.document)
+
+  const cleanup = onBrowserGlobalError(listener)
+  const event = createBrowserErrorEvent({
+    message: "boom",
+    filename: "app.ts",
+    lineno: 8,
+    colno: 9,
+    error: new Error("boom"),
+  })
+  browserWindow.dispatchEvent(event)
+
+  expect(listener).toHaveBeenCalledTimes(1)
+  expect(listener).toHaveBeenCalledWith(expect.objectContaining({
+    runtime: "browser",
+    source: "browser.global-error",
+    message: "boom",
+    filename: "app.ts",
+    lineno: 8,
+    colno: 9,
+  }))
+
+  cleanup()
+  browserWindow.dispatchEvent(event)
+  expect(listener).toHaveBeenCalledTimes(1)
+})
+
+test("onBrowserWindowOnError composes listeners and restores window.onerror after the last cleanup", () => {
+  const browserWindow = new WindowMock()
+  const previousOnError = vi.fn(() => false)
+  const listener1 = vi.fn()
+  const listener2 = vi.fn()
+  // oxlint-disable-next-line prefer-add-event-listener
+  browserWindow.onerror = previousOnError
+  vi.stubGlobal("window", browserWindow)
+  vi.stubGlobal("self", browserWindow)
+  vi.stubGlobal("document", browserWindow.document)
+
+  const cleanup1 = onBrowserWindowOnError(listener1)
+  const cleanup2 = onBrowserWindowOnError(listener2)
+  browserWindow.onerror?.("boom", "app.ts", 3, 5, new Error("boom"))
+
+  expect(listener1).toHaveBeenCalledTimes(1)
+  expect(listener1).toHaveBeenCalledWith(expect.objectContaining({
+    runtime: "browser",
+    source: "browser.window-onerror",
+    filename: "app.ts",
+    lineno: 3,
+    colno: 5,
+  }))
+  expect(listener2).toHaveBeenCalledTimes(1)
+  expect(listener2).toHaveBeenCalledWith(expect.objectContaining({
+    runtime: "browser",
+    source: "browser.window-onerror",
+    filename: "app.ts",
+    lineno: 3,
+    colno: 5,
+  }))
+  expect(previousOnError).toHaveBeenCalledTimes(1)
+
+  cleanup1()
+  browserWindow.onerror?.("again", "next.ts", 7, 11, new Error("again"))
+
+  expect(listener1).toHaveBeenCalledTimes(1)
+  expect(listener2).toHaveBeenCalledTimes(2)
+  expect(previousOnError).toHaveBeenCalledTimes(2)
+
+  cleanup2()
+  expect(browserWindow.onerror).toBe(previousOnError)
+})
+
+test("onBrowserUnhandledRejection listens and cleans up promise rejection events", () => {
+  const browserWindow = new WindowMock()
+  const listener = vi.fn()
+  vi.stubGlobal("window", browserWindow)
+  vi.stubGlobal("self", browserWindow)
+  vi.stubGlobal("document", browserWindow.document)
+
+  const cleanup = onBrowserUnhandledRejection(listener)
+  const promise = Promise.resolve("ok")
+  const rejectionEvent = createBrowserUnhandledRejectionEvent({
+    promise,
+    reason: new Error("reject"),
+  })
+  browserWindow.dispatchEvent(rejectionEvent)
+
+  expect(listener).toHaveBeenCalledWith(expect.objectContaining({
+    runtime: "browser",
+    source: "browser.unhandled-rejection",
+    message: "reject",
+  }))
+
+  cleanup()
+  browserWindow.dispatchEvent(rejectionEvent)
+  expect(listener).toHaveBeenCalledTimes(1)
+})
+
+test("observeBrowserExceptions listens to all browser sources by default and supports explicit opt-out", () => {
+  const browserWindow = new WindowMock()
+  const listener = vi.fn()
+  vi.stubGlobal("window", browserWindow)
+  vi.stubGlobal("self", browserWindow)
+  vi.stubGlobal("document", browserWindow.document)
+
+  const cleanup1 = observeBrowserExceptions(listener, {
+    captureTimestamp: () => 777,
+  })
+  const promise = Promise.resolve("ok")
+
+  browserWindow.dispatchEvent(createBrowserErrorEvent({
+    message: "again",
+    error: new Error("again"),
+  }))
+  browserWindow.onerror?.("window boom", "page.ts", 1, 2, new Error("window boom"))
+  browserWindow.dispatchEvent(createBrowserUnhandledRejectionEvent({
+    promise,
+    reason: "reason-text",
+  }))
+
+  expect(listener).toHaveBeenCalledTimes(3)
+  expect(listener).toHaveBeenCalledWith(expect.objectContaining({
+    source: "browser.global-error",
+    timestamp: 777,
+  }))
+  expect(listener).toHaveBeenCalledWith(expect.objectContaining({
+    source: "browser.window-onerror",
+    timestamp: 777,
+    filename: "page.ts",
+  }))
+  expect(listener).toHaveBeenCalledWith(expect.objectContaining({
+    source: "browser.unhandled-rejection",
+    timestamp: 777,
+    message: "reason-text",
+  }))
+
+  cleanup1()
+
+  listener.mockClear()
+
+  const cleanup2 = observeBrowserExceptions(listener, {
+    includeWindowOnError: false,
+  })
+  browserWindow.dispatchEvent(createBrowserErrorEvent({
+    message: "still-on",
+    error: new Error("still-on"),
+  }))
+  browserWindow.onerror?.("ignored", "page.ts", 1, 2, new Error("ignored"))
+  browserWindow.dispatchEvent(createBrowserUnhandledRejectionEvent({
+    promise,
+    reason: "still-on",
+  }))
+
+  expect(listener).toHaveBeenCalledTimes(2)
+  expect(listener).not.toHaveBeenCalledWith(expect.objectContaining({
+    source: "browser.window-onerror",
+  }))
+
+  cleanup2()
+})

package/tests/unit/exception/nodejs.spec.ts

@@ -0,0 +1,144 @@
+import { afterEach, expect, test, vi } from "vitest"
+
+import {
+  observeNodejsExceptions,
+  onNodejsUncaughtException,
+  onNodejsUncaughtExceptionMonitor,
+  onNodejsUnhandledRejection,
+} from "#Source/exception/index.ts"
+
+class ProcessMock {
+  protected listeners = new Map<string, Set<(...args: unknown[]) => void>>()
+  versions = { node: "20.0.0" }
+
+  on(eventName: string, listener: (...args: unknown[]) => void): this {
+    const eventListeners = this.listeners.get(eventName) ?? new Set()
+    eventListeners.add(listener)
+    this.listeners.set(eventName, eventListeners)
+    return this
+  }
+
+  off(eventName: string, listener: (...args: unknown[]) => void): this {
+    this.listeners.get(eventName)?.delete(listener)
+    return this
+  }
+
+  emit(eventName: string, ...args: unknown[]): void {
+    for (const listener of this.listeners.get(eventName) ?? []) {
+      listener(...args)
+    }
+  }
+}
+
+afterEach(() => {
+  vi.unstubAllGlobals()
+  vi.restoreAllMocks()
+})
+
+test("onNodejsUncaughtExceptionMonitor listens and cleans up monitor events", () => {
+  const mockedProcess = new ProcessMock()
+  const listener = vi.fn()
+  vi.stubGlobal("process", mockedProcess)
+
+  const cleanup = onNodejsUncaughtExceptionMonitor(listener)
+  mockedProcess.emit("uncaughtExceptionMonitor", new Error("boom"), "uncaughtException")
+
+  expect(listener).toHaveBeenCalledWith(expect.objectContaining({
+    runtime: "nodejs",
+    source: "nodejs.uncaught-exception-monitor",
+    message: "boom",
+    origin: "uncaughtException",
+  }))
+
+  cleanup()
+  mockedProcess.emit("uncaughtExceptionMonitor", new Error("boom"), "uncaughtException")
+  expect(listener).toHaveBeenCalledTimes(1)
+})
+
+test("onNodejsUncaughtException normalizes records and cleans up listeners", () => {
+  const mockedProcess = new ProcessMock()
+  const listener = vi.fn()
+  vi.stubGlobal("process", mockedProcess)
+
+  const cleanup = onNodejsUncaughtException(listener)
+
+  mockedProcess.emit("uncaughtException", new Error("broken"), "uncaughtException")
+
+  expect(listener).toHaveBeenCalledWith(expect.objectContaining({
+    source: "nodejs.uncaught-exception",
+    message: "broken",
+    origin: "uncaughtException",
+  }))
+
+  cleanup()
+  mockedProcess.emit("uncaughtException", new Error("ignored"), "uncaughtException")
+  expect(listener).toHaveBeenCalledTimes(1)
+})
+
+test("onNodejsUnhandledRejection normalizes records and cleans up listeners", () => {
+  const mockedProcess = new ProcessMock()
+  const listener = vi.fn()
+  vi.stubGlobal("process", mockedProcess)
+
+  const cleanup = onNodejsUnhandledRejection(listener)
+  const promise = Promise.resolve("ok")
+
+  mockedProcess.emit("unhandledRejection", "reason-text", promise)
+
+  expect(listener).toHaveBeenCalledWith(expect.objectContaining({
+    source: "nodejs.unhandled-rejection",
+    message: "reason-text",
+    promise,
+  }))
+
+  cleanup()
+  mockedProcess.emit("unhandledRejection", "ignored", promise)
+  expect(listener).toHaveBeenCalledTimes(1)
+})
+
+test("observeNodejsExceptions listens to all Node.js sources by default and supports explicit opt-out", () => {
+  const mockedProcess = new ProcessMock()
+  const listener = vi.fn()
+  vi.stubGlobal("process", mockedProcess)
+
+  const cleanup1 = observeNodejsExceptions(listener, {
+    captureTimestamp: () => 456,
+  })
+
+  const promise = Promise.resolve("ok")
+  mockedProcess.emit("uncaughtExceptionMonitor", new Error("watch"), "uncaughtException")
+  mockedProcess.emit("uncaughtException", new Error("boom"), "uncaughtException")
+  mockedProcess.emit("unhandledRejection", new Error("reject"), promise)
+
+  expect(listener).toHaveBeenCalledTimes(3)
+  expect(listener).toHaveBeenNthCalledWith(1, expect.objectContaining({
+    source: "nodejs.uncaught-exception-monitor",
+    timestamp: 456,
+  }))
+  expect(listener).toHaveBeenNthCalledWith(2, expect.objectContaining({
+    source: "nodejs.uncaught-exception",
+    timestamp: 456,
+  }))
+  expect(listener).toHaveBeenNthCalledWith(3, expect.objectContaining({
+    source: "nodejs.unhandled-rejection",
+    timestamp: 456,
+  }))
+
+  cleanup1()
+
+  listener.mockClear()
+
+  const cleanup2 = observeNodejsExceptions(listener, {
+    includeUncaughtExceptionMonitor: false,
+  })
+  mockedProcess.emit("uncaughtExceptionMonitor", new Error("ignored"), "uncaughtException")
+  mockedProcess.emit("uncaughtException", new Error("kept"), "uncaughtException")
+  mockedProcess.emit("unhandledRejection", "kept", promise)
+
+  expect(listener).toHaveBeenCalledTimes(2)
+  expect(listener).not.toHaveBeenCalledWith(expect.objectContaining({
+    source: "nodejs.uncaught-exception-monitor",
+  }))
+
+  cleanup2()
+})

package/tests/unit/exception/normalize.spec.ts

@@ -0,0 +1,57 @@
+import { expect, test, vi } from "vitest"
+
+import {
+  normalizeBrowserExceptionRecord,
+  normalizeExceptionRecord,
+  normalizeNodejsExceptionRecord,
+} from "#Source/exception/index.ts"
+
+test("normalizeExceptionRecord infers message and timestamp", () => {
+  vi.spyOn(Date, "now").mockReturnValue(123)
+
+  const example1 = normalizeExceptionRecord({
+    runtime: "unknown",
+    source: "custom",
+    exception: new Error("boom"),
+  })
+  const example2 = normalizeExceptionRecord({
+    runtime: "unknown",
+    source: "custom",
+    exception: "text-error",
+  })
+
+  expect(example1.message).toBe("boom")
+  expect(example1.timestamp).toBe(123)
+  expect(example2.message).toBe("text-error")
+})
+
+test("normalizeBrowserExceptionRecord preserves browser-specific fields", () => {
+  const example1 = normalizeBrowserExceptionRecord({
+    source: "browser.global-error",
+    exception: new Error("boom"),
+    filename: "app.ts",
+    lineno: 8,
+    colno: 13,
+    timestamp: 10,
+  })
+
+  expect(example1.runtime).toBe("browser")
+  expect(example1.filename).toBe("app.ts")
+  expect(example1.lineno).toBe(8)
+  expect(example1.colno).toBe(13)
+})
+
+test("normalizeNodejsExceptionRecord preserves nodejs-specific fields", () => {
+  const promise = Promise.resolve("ok")
+  const example1 = normalizeNodejsExceptionRecord({
+    source: "nodejs.unhandled-rejection",
+    exception: new Error("boom"),
+    origin: "unhandledRejection",
+    promise,
+    timestamp: 11,
+  })
+
+  expect(example1.runtime).toBe("nodejs")
+  expect(example1.origin).toBe("unhandledRejection")
+  expect(example1.promise).toBe(promise)
+})

package/tests/unit/identifier/id.spec.ts

@@ -0,0 +1,71 @@
+import { expect, test } from "vitest"
+
+import {
+  assertId,
+  generateId,
+  idToString,
+  isEqualId,
+  isId,
+  isSameId,
+} from "#Source/identifier/index.ts"
+
+test("generateId is seed-stable and no-seed calls are uncached", () => {
+  const first = generateId("user:42")
+  const second = generateId("user:42")
+  const third = generateId("user:43")
+  const withoutSeed1 = generateId()
+  const withoutSeed2 = generateId()
+  const undefinedSeed1 = generateId(undefined)
+  const undefinedSeed2 = generateId(undefined)
+
+  expect(first).toBe(second)
+  expect(first).not.toBe(third)
+  expect(withoutSeed1).not.toBe(withoutSeed2)
+  expect(undefinedSeed1).not.toBe(undefinedSeed2)
+  expect(withoutSeed1).not.toBe(undefinedSeed1)
+})
+
+test("isId validates generated Id values", () => {
+  const id = generateId(1)
+
+  expect(isId(id)).toBe(true)
+  expect(isId(null)).toBe(false)
+  expect(isId(undefined)).toBe(false)
+  expect(isId("plain-string")).toBe(false)
+  expect(isId({})).toBe(false)
+})
+
+test("assertId throws for non-Id inputs", () => {
+  const id = generateId(Symbol("seed"))
+
+  expect(() => assertId(id)).not.toThrow()
+  expect(() => assertId("plain-string")).toThrow(TypeError)
+  expect(() => assertId(1)).toThrow(TypeError)
+})
+
+test("isSameId compares by instance identity", () => {
+  const id = generateId("same")
+  const sameReference = id
+  const another = generateId("another")
+
+  expect(isSameId(id, sameReference)).toBe(true)
+  expect(isSameId(id, another)).toBe(false)
+})
+
+test("isEqualId compares internal ID value", () => {
+  const first = generateId("equal-seed")
+  const second = generateId("equal-seed")
+  const third = generateId("different-seed")
+
+  expect(isEqualId(first, second)).toBe(true)
+  expect(isEqualId(first, third)).toBe(false)
+})
+
+test("idToString serializes Id to readable label", () => {
+  const id = generateId("to-string")
+  const asString = idToString(id)
+
+  expect(asString.startsWith("Symbol-ID-")).toBe(true)
+  // oxlint-disable-next-line typescript/no-base-to-string
+  expect(asString).toBe(String(id))
+})

package/tests/unit/identifier/uuid.spec.ts

@@ -0,0 +1,85 @@
+import { afterEach, expect, test, vi } from "vitest"
+
+import { assertUuid, generateUuidV4, generateUuidV4FromUrl, generateUuidV7, getUuidVersion, isUuid } from "#Source/identifier/index.ts"
+
+afterEach(() => {
+  vi.restoreAllMocks()
+})
+
+test("isUuid validates UUID input", () => {
+  expect(isUuid("550e8400-e29b-41d4-a716-446655440000")).toBe(true)
+  expect(isUuid("550E8400-E29B-41D4-A716-446655440000")).toBe(true)
+  expect(isUuid("123e4567-e89b-12d3-a456-426614174000")).toBe(true)
+
+  expect(isUuid("not-a-uuid")).toBe(false)
+  expect(isUuid("550e8400e29b41d4a716446655440000")).toBe(false)
+  expect(isUuid("550e8400-e29b-91d4-a716-446655440000")).toBe(false)
+  expect(isUuid("550e8400-e29b-41d4-c716-446655440000")).toBe(false)
+})
+
+test("assertUuid throws on malformed input", () => {
+  expect(() => assertUuid("550e8400-e29b-41d4-a716-446655440000")).not.toThrow()
+  expect(() => assertUuid("not-a-uuid")).toThrow(TypeError)
+  expect(() => assertUuid("550e8400e29b41d4a716446655440000")).toThrow(TypeError)
+})
+
+test("getUuidVersion returns UUID version and throws on malformed input", () => {
+  expect(getUuidVersion("550e8400-e29b-41d4-a716-446655440000")).toBe(4)
+  expect(getUuidVersion("123e4567-e89b-12d3-a456-426614174000")).toBe(1)
+
+  expect(() => getUuidVersion("not-a-uuid")).toThrow(TypeError)
+})
+
+test("generateUuid returns RFC 4122 version-4 UUID format", () => {
+  const UUID_V4_REGEXP = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i
+  const value1 = generateUuidV4()
+  const value2 = generateUuidV4()
+
+  expect(value1).toMatch(UUID_V4_REGEXP)
+  expect(value2).toMatch(UUID_V4_REGEXP)
+  expect(value1).not.toBe(value2)
+})
+
+test("generateUuidV4FromUrl extracts UUID from object URL and revokes URL", () => {
+  const mockedUuid = "1e34c01e-ab7c-4e60-b6f3-a6101e8c0d2d"
+  const mockedObjectUrl = `blob:https://www.cigaret.world/${mockedUuid}`
+  const createObjectUrlSpy = vi.spyOn(URL, "createObjectURL").mockReturnValue(mockedObjectUrl)
+  const revokeObjectUrlSpy = vi.spyOn(URL, "revokeObjectURL").mockImplementation(() => {
+    return undefined
+  })
+
+  const value = generateUuidV4FromUrl()
+
+  expect(value).toBe(mockedUuid)
+  expect(isUuid(value)).toBe(true)
+  expect(createObjectUrlSpy).toHaveBeenCalledTimes(1)
+  expect(revokeObjectUrlSpy).toHaveBeenCalledTimes(1)
+  expect(revokeObjectUrlSpy).toHaveBeenCalledWith(mockedObjectUrl)
+})
+
+test("generateUuidV7 returns UUIDv7 format and is monotonic within the same millisecond", () => {
+  const UUID_V7_REGEXP = /^[0-9a-f]{8}-[0-9a-f]{4}-7[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i
+
+  vi.spyOn(Date, "now").mockReturnValue(1_700_000_000_000)
+  vi.spyOn(crypto, "getRandomValues").mockImplementation(buffer => {
+    if (buffer === null) {
+      return buffer
+    }
+
+    // oxlint-disable-next-line typescript/no-unsafe-type-assertion
+    const target = buffer as Uint8Array
+    target.fill(0)
+    return buffer
+  })
+
+  const value1 = generateUuidV7()
+  const value2 = generateUuidV7()
+  const value3 = generateUuidV7()
+
+  expect(value1).toMatch(UUID_V7_REGEXP)
+  expect(value2).toMatch(UUID_V7_REGEXP)
+  expect(value3).toMatch(UUID_V7_REGEXP)
+
+  expect(value1 < value2).toBe(true)
+  expect(value2 < value3).toBe(true)
+})

package/tests/unit/log/log-emitter.spec.ts

@@ -0,0 +1,33 @@
+import { afterEach, expect, test, vi } from "vitest"
+
+import {
+  ConsoleDebugLogEmitter,
+  ConsoleErrorLogEmitter,
+  ConsoleInfoLogEmitter,
+  ConsoleLogLogEmitter,
+  ConsoleWarnLogEmitter,
+} from "#Source/log/index.ts"
+
+afterEach(() => {
+  vi.restoreAllMocks()
+})
+
+test("console log emitters format tags and messages before output", () => {
+  const logSpy = vi.spyOn(console, "log").mockImplementation(() => undefined)
+  const infoSpy = vi.spyOn(console, "info").mockImplementation(() => undefined)
+  const warnSpy = vi.spyOn(console, "warn").mockImplementation(() => undefined)
+  const errorSpy = vi.spyOn(console, "error").mockImplementation(() => undefined)
+  const debugSpy = vi.spyOn(console, "debug").mockImplementation(() => undefined)
+
+  new ConsoleLogLogEmitter({ tags: ["scope", "unit"], messages: ["hello", 1] }).emit()
+  new ConsoleInfoLogEmitter({ tags: ["scope"], messages: ["info"] }).emit()
+  new ConsoleWarnLogEmitter({ tags: ["scope"], messages: ["warn"] }).emit()
+  new ConsoleErrorLogEmitter({ tags: ["scope"], messages: ["error"] }).emit()
+  new ConsoleDebugLogEmitter({ tags: ["scope"], messages: ["debug"] }).emit()
+
+  expect(logSpy).toHaveBeenCalledWith("[scope][unit] hello 1")
+  expect(infoSpy).toHaveBeenCalledWith("[scope] info")
+  expect(warnSpy).toHaveBeenCalledWith("[scope] warn")
+  expect(errorSpy).toHaveBeenCalledWith("[scope] error")
+  expect(debugSpy).toHaveBeenCalledWith("[scope] debug")
+})

package/tests/unit/log/log-scheduler.spec.ts

@@ -0,0 +1,40 @@
+import { expect, test, vi } from "vitest"
+
+import { LogScheduler, getGlobalLogScheduler } from "#Source/log/index.ts"
+
+test("LogScheduler enqueue dispatches immediately in immediate strategy", () => {
+  const scheduler = new LogScheduler({ strategy: "immediate" })
+  const emit1 = vi.fn()
+  const emit2 = vi.fn()
+
+  scheduler.enqueue([
+    { record: { type: "log", tags: ["a"], messages: ["one"] }, emit: emit1 },
+    { record: { type: "info", tags: ["a"], messages: ["two"] }, emit: emit2 },
+  ])
+
+  expect(emit1).toHaveBeenCalledTimes(1)
+  expect(emit2).toHaveBeenCalledTimes(1)
+})
+
+test("LogScheduler run flushes queued tasks", () => {
+  const scheduler = new LogScheduler({ strategy: "immediate" })
+  const emit1 = vi.fn()
+  const emit2 = vi.fn()
+
+  scheduler.enqueue([
+    { record: { type: "log", tags: ["a"], messages: ["one"] }, emit: emit1 },
+    { record: { type: "info", tags: ["a"], messages: ["two"] }, emit: emit2 },
+  ])
+  scheduler.run()
+
+  expect(emit1).toHaveBeenCalledTimes(1)
+  expect(emit2).toHaveBeenCalledTimes(1)
+  expect(scheduler.hasTasks()).toEqual(false)
+})
+
+test("getGlobalLogScheduler returns singleton instance", () => {
+  const scheduler1 = getGlobalLogScheduler()
+  const scheduler2 = getGlobalLogScheduler()
+
+  expect(scheduler1).toBe(scheduler2)
+})

package/tests/unit/log/log-type.spec.ts

@@ -0,0 +1,7 @@
+import { expect, test } from "vitest"
+
+import { LOG_TYPES } from "#Source/log/index.ts"
+
+test("LOG_TYPES exposes supported log levels", () => {
+  expect(LOG_TYPES).toEqual(["log", "info", "warn", "error", "debug"])
+})