saeeol 1.4.2 → 1.4.3

package/src/boxes/err.ts

@@ -1,34 +0,0 @@
-/**
- * err.ts — Universal error message extraction
- * Zero deps.
- *
- * msg(new Error("fail")) → "fail"
- * msg({ message: "bad" }) → "bad"
- */
-export function isObj(v: unknown): v is Record<string, unknown> {
-  return !!v && typeof v === "object" && !Array.isArray(v)
-}
-
-export function msg(e: unknown): string {
-  if (e instanceof Error) {
-    if (e.message) return e.message
-    if (e.name) return e.name
-  }
-  if (isObj(e)) {
-    if (typeof e.message === "string" && e.message) return e.message
-    if (isObj(e.data) && typeof e.data.message === "string" && e.data.message) return e.data.message
-  }
-  const s = String(e)
-  if (s && s !== "[object Object]") return s
-  const f = fmt(e)
-  if (f && f !== "{}") return f
-  return "unknown error"
-}
-
-export function fmt(e: unknown): string {
-  if (e instanceof Error) return e.stack ?? `${e.name}: ${e.message}`
-  if (typeof e === "object" && e !== null) {
-    try { return JSON.stringify(e, null, 2) } catch { return "Unexpected error (unserializable)" }
-  }
-  return String(e)
-}

package/src/boxes/human.ts

@@ -1,47 +0,0 @@
-/**
- * human.ts — Human-readable formatting: duration, numbers, dates, truncate, plural
- * Zero deps.
- *
- * duration(150000) → "2m 30s"
- * compact(1500) → "1.5K"
- * truncate("hello world", 8) → "hello w…"
- */
-export function title(s: string) { return s.replace(/\b\w/g, c => c.toUpperCase()) }
-
-export function time(ms: number) { return new Date(ms).toLocaleTimeString(undefined, { timeStyle: "short" }) }
-
-export function datetime(ms: number) { return `${time(ms)} · ${new Date(ms).toLocaleDateString()}` }
-
-export function compact(n: number): string {
-  if (n >= 1_000_000) return (n / 1_000_000).toFixed(1) + "M"
-  if (n >= 1000) return (n / 1000).toFixed(1) + "K"
-  return n.toString()
-}
-
-export function duration(ms: number): string {
-  if (ms < 1000) return `${ms}ms`
-  if (ms < 60_000) return `${(ms / 1000).toFixed(1)}s`
-  if (ms < 3_600_000) return `${Math.floor(ms / 60_000)}m ${Math.floor((ms % 60_000) / 1000)}s`
-  if (ms < 86_400_000) return `${Math.floor(ms / 3_600_000)}h ${Math.floor((ms % 3_600_000) / 60_000)}m`
-  return `${Math.floor(ms / 3_600_000)}h`
-}
-
-export function truncate(s: string, len: number): string { return s.length <= len ? s : s.slice(0, len - 1) + "…" }
-
-export function truncateMid(s: string, max = 35): string {
-  if (s.length <= max) return s
-  const pre = Math.ceil((max - 1) / 2)
-  const suf = Math.floor((max - 1) / 2)
-  return s.slice(0, pre) + "…" + s.slice(-suf)
-}
-
-export function plural(n: number, one: string, many: string): string { return (n === 1 ? one : many).replace("{}", String(n)) }
-
-export function secsDuration(s: number): string {
-  if (s <= 0) return ""
-  if (s < 60) return `${s}s`
-  if (s < 3600) { const m = Math.floor(s / 60); const r = s % 60; return r > 0 ? `${m}m ${r}s` : `${m}m` }
-  if (s < 86400) { const h = Math.floor(s / 3600); const r = Math.floor((s % 3600) / 60); return r > 0 ? `${h}h ${r}m` : `${h}h` }
-  if (s < 604800) { const d = Math.floor(s / 86400); return d === 1 ? "~1 day" : `~${d} days` }
-  const w = Math.floor(s / 604800); return w === 1 ? "~1 week" : `~${w} weeks`
-}

package/src/boxes/iife.ts

@@ -1,9 +0,0 @@
-/**
- * iife.ts — Immediately-invoked function expression
- * Zero deps.
- *
- * const x = iife(() => compute())
- */
-export function iife<T>(fn: () => T) {
-  return fn()
-}

package/src/boxes/latch.ts

@@ -1,8 +0,0 @@
-export function latch() {
-  let resolve: () => void
-  const p = new Promise<void>((r) => { resolve = r })
-  return {
-    trip() { resolve() },
-    wait() { return p },
-  }
-}

package/src/boxes/memory.ts

@@ -1,198 +0,0 @@
-/**
- * memory.ts — File-based persistent memory with typed taxonomy
- * Deps: Node built-ins (os, path, fs/promises)
- * Ported from Claude Code memdir/
- */
-
-import { homedir } from "os"
-import { join, normalize, sep, basename } from "path"
-import { mkdir, readFile, writeFile, readdir, stat } from "fs/promises"
-
-// ── Types ──────────────────────────────────────────
-
-export const MEMORY_TYPES = ["user", "feedback", "project", "reference"] as const
-export type MemoryType = (typeof MEMORY_TYPES)[number]
-
-export function parseMemoryType(raw: unknown): MemoryType | undefined {
-  if (typeof raw !== "string") return undefined
-  return MEMORY_TYPES.find(t => t === raw)
-}
-
-export interface MemoryHeader {
-  filename: string
-  filePath: string
-  mtimeMs: number
-  description: string | null
-  type: MemoryType | undefined
-}
-
-// ── Age ────────────────────────────────────────────
-
-export function memoryAgeDays(mtimeMs: number): number {
-  return Math.max(0, Math.floor((Date.now() - mtimeMs) / 86_400_000))
-}
-
-export function memoryAge(mtimeMs: number): string {
-  const d = memoryAgeDays(mtimeMs)
-  if (d === 0) return "today"
-  if (d === 1) return "yesterday"
-  return `${d} days ago`
-}
-
-export function memoryFreshnessText(mtimeMs: number): string {
-  const d = memoryAgeDays(mtimeMs)
-  if (d <= 1) return ""
-  return `This memory is ${d} days old. Memories are point-in-time observations, not live state — verify against current code before asserting as fact.`
-}
-
-// ── Paths ──────────────────────────────────────────
-
-export const MAX_ENTRYPOINT_LINES = 200
-export const MAX_ENTRYPOINT_BYTES = 25_000
-
-export function getMemoryBaseDir(): string {
-  return process.env.KILO_MEMORY_DIR ?? join(homedir(), ".config", "saeeol")
-}
-
-export function getMemoryDir(projectRoot: string): string {
-  if (process.env.KILO_MEMORY_DIR) return process.env.KILO_MEMORY_DIR
-  return join(getMemoryBaseDir(), "projects", sanitize(projectRoot), "memory") + sep
-}
-
-export function getMemoryEntrypoint(projectRoot: string): string {
-  return join(getMemoryDir(projectRoot), "MEMORY.md")
-}
-
-export function isMemoryPath(absolutePath: string, projectRoot: string): boolean {
-  return normalize(absolutePath).startsWith(getMemoryDir(projectRoot))
-}
-
-function sanitize(p: string): string {
-  return p.replace(/[<>:"|?*]/g, "_").replace(/[/\\]+/g, "_")
-}
-
-// ── Scan ───────────────────────────────────────────
-
-const MAX_MEMORY_FILES = 200
-const FM_MAX_LINES = 30
-
-export async function scanMemoryFiles(dir: string): Promise<MemoryHeader[]> {
-  try {
-    const entries = await readdir(dir, { recursive: true })
-    const mds = entries.filter(
-      (f): f is string => typeof f === "string" && f.endsWith(".md") && basename(f) !== "MEMORY.md",
-    )
-    if (mds.length === 0) return []
-    const results = await Promise.allSettled(mds.map(async (rel): Promise<MemoryHeader> => {
-      const fp = join(dir, rel)
-      const s = await stat(fp)
-      const { description, type } = await parseFrontmatter(fp)
-      return { filename: rel, filePath: fp, mtimeMs: s.mtimeMs, description, type }
-    }))
-    return results
-      .filter((r): r is PromiseFulfilledResult<MemoryHeader> => r.status === "fulfilled")
-      .map(r => r.value)
-      .sort((a, b) => b.mtimeMs - a.mtimeMs)
-      .slice(0, MAX_MEMORY_FILES)
-  } catch { return [] }
-}
-
-export function formatMemoryManifest(memories: MemoryHeader[]): string {
-  return memories.map(m => {
-    const tag = m.type ? `[${m.type}] ` : ""
-    const ts = new Date(m.mtimeMs).toISOString()
-    return m.description ? `- ${tag}${m.filename} (${ts}): ${m.description}` : `- ${tag}${m.filename} (${ts})`
-  }).join("\n")
-}
-
-async function parseFrontmatter(
-  filePath: string,
-): Promise<{ description: string | null; type: MemoryType | undefined }> {
-  try {
-    const raw = await readFile(filePath, "utf-8")
-    const lines = raw.split("\n").slice(0, FM_MAX_LINES)
-    const acc = lines.reduce(
-      (s, line) => {
-        if (s.done) return s
-        if (line.trim() === "---") { if (s.inFm) return { ...s, done: true }; return { ...s, inFm: true } }
-        if (!s.inFm) return s
-        const desc = line.match(/^description:\s*(.+)$/i)?.[1]
-        const typ = line.match(/^type:\s*(.+)$/i)?.[1]
-        return { ...s, desc: desc ?? s.desc, typeRaw: typ ?? s.typeRaw }
-      },
-      { inFm: false, done: false, desc: null as string | null, typeRaw: undefined as string | undefined },
-    )
-    return { description: acc.desc, type: parseMemoryType(acc.typeRaw) }
-  } catch { return { description: null, type: undefined } }
-}
-
-// ── Entrypoint I/O ─────────────────────────────────
-
-export function truncateEntrypoint(raw: string): { content: string; wasTruncated: boolean } {
-  const trimmed = raw.trim()
-  const lines = trimmed.split("\n")
-  const wasLine = lines.length > MAX_ENTRYPOINT_LINES
-  const wasByte = trimmed.length > MAX_ENTRYPOINT_BYTES
-  if (!wasLine && !wasByte) return { content: trimmed, wasTruncated: false }
-  const afterLine = wasLine ? lines.slice(0, MAX_ENTRYPOINT_LINES).join("\n") : trimmed
-  const final = afterLine.length > MAX_ENTRYPOINT_BYTES
-    ? (() => { const cut = afterLine.lastIndexOf("\n", MAX_ENTRYPOINT_BYTES); return afterLine.slice(0, cut > 0 ? cut : MAX_ENTRYPOINT_BYTES) })()
-    : afterLine
-  return { content: final + "\n\n> WARNING: MEMORY.md was truncated. Keep entries concise.", wasTruncated: true }
-}
-
-export async function readEntrypoint(projectRoot: string): Promise<string> {
-  try { return await readFile(getMemoryEntrypoint(projectRoot), "utf-8") }
-  catch { return "" }
-}
-
-export async function writeEntrypoint(projectRoot: string, content: string): Promise<void> {
-  const { content: final } = truncateEntrypoint(content)
-  await writeFile(getMemoryEntrypoint(projectRoot), final, "utf-8")
-}
-
-export async function ensureDir(projectRoot: string): Promise<string> {
-  const dir = getMemoryDir(projectRoot)
-  try { await mkdir(dir, { recursive: true }) } catch { /* exists */ }
-  return dir
-}
-
-// ── Prompt builder ─────────────────────────────────
-
-const TYPES_SECTION = [
-  "## Types of memory", "",
-  "There are several discrete types of memory you can store:", "",
-  "<types>",
-  '<type><name>user</name><description>User preferences, role, and knowledge.</description><when_to_save>When you learn about the user\'s role, preferences, or knowledge.</when_to_save></type>',
-  '<type><name>feedback</name><description>Guidance about how to approach work — both corrections and confirmed approaches.</description><when_to_save>When the user corrects or confirms your approach.</when_to_save></type>',
-  '<type><name>project</name><description>Ongoing work, goals, bugs, or incidents not derivable from code.</description><when_to_save>When you learn who is doing what, why, or by when.</when_to_save></type>',
-  '<type><name>reference</name><description>Pointers to external systems and resources.</description><when_to_save>When you learn about external resources and their purpose.</when_to_save></type>',
-  "</types>", "",
-]
-
-export async function buildPrompt(projectRoot: string): Promise<string> {
-  const dir = getMemoryDir(projectRoot)
-  const ep = await readEntrypoint(projectRoot)
-  const lines = [
-    "# auto memory", "",
-    `You have a persistent memory system at \`${dir}\`. Write to it directly.`,
-    "", "Build up this memory so future conversations have context about the user, their preferences, and project decisions.",
-    "", ...TYPES_SECTION,
-    "## What NOT to save in memory", "",
-    "- Code patterns, architecture, file paths — derivable from current project state.",
-    "- Git history — `git log` / `git blame` are authoritative.",
-    "- Debugging solutions — the fix is in the code.",
-    "- Ephemeral task details: in-progress work, temporary state.", "",
-    "## When to access memories",
-    "- When memories seem relevant to the user's request.",
-    "- When the user explicitly asks you to recall something.",
-    "- Memory records can become stale. Verify against current state before asserting as fact.", "",
-  ]
-  const epContent = ep.trim() ? truncateEntrypoint(ep).content : "Your MEMORY.md is currently empty."
-  lines.push("## MEMORY.md", "", epContent)
-  return lines.join("\n")
-}
-
-export async function scan(projectRoot: string) {
-  return scanMemoryFiles(getMemoryDir(projectRoot))
-}

package/src/boxes/net.ts

@@ -1,16 +0,0 @@
-/**
- * net.ts — Network status checks
- * Zero deps.
- *
- * online() → true/false
- * proxied() → true/false
- */
-export function online(): boolean {
-  const n = globalThis.navigator
-  if (!n || typeof n.onLine !== "boolean") return true
-  return n.onLine
-}
-
-export function proxied(): boolean {
-  return !!(process.env.HTTP_PROXY || process.env.HTTPS_PROXY || process.env.http_proxy || process.env.https_proxy)
-}

package/src/boxes/plural.ts

@@ -1,4 +0,0 @@
-export function plural(n: number, one: string, many: string): string {
-  const tpl = n === 1 ? one : many
-  return tpl.replace("{}", String(n))
-}

package/src/boxes/puny.ts

@@ -1,21 +0,0 @@
-/**
- * puny.ts — Normalize IDN/Unicode URLs to punycode ASCII (anti-homograph)
- * Zero deps. Uses URL built-in.
- *
- * norm("https://аpitest.com/path") → "https://xn--pitest-2nf.com/path"
- */
-export function norm(text: string): string {
-  return text.replace(/https?:\/\/\S+/g, (match) => {
-    const stripped = match.replace(/[.,!?;:)"'\]>]+$/, "")
-    const tail = match.slice(stripped.length)
-    try {
-      const u = new URL(stripped)
-      const after = stripped.indexOf("//") + 2
-      const slash = stripped.indexOf("/", after)
-      const raw = slash === -1 ? stripped.slice(after) : stripped.slice(after, slash)
-      const host = raw.includes(":") ? raw.slice(0, raw.indexOf(":")) : raw
-      if (host === u.hostname) return match
-      return stripped.replace(host, u.hostname) + tail
-    } catch { return match }
-  })
-}

package/src/boxes/retry.ts

@@ -1,49 +0,0 @@
-import { expDelay } from "./schedule"
-
-const TRANSIENT = [
-  "load failed",
-  "network connection was lost",
-  "network request failed",
-  "failed to fetch",
-  "econnreset",
-  "econnrefused",
-  "etimedout",
-  "socket hang up",
-]
-
-function isTransient(err: unknown): boolean {
-  if (!err) return false
-  const msg = String(err instanceof Error ? err.message : err).toLowerCase()
-  return TRANSIENT.some((t) => msg.includes(t))
-}
-
-export interface RetryOpts {
-  attempts?: number
-  delay?: number
-  factor?: number
-  maxDelay?: number
-  retryIf?: (err: unknown) => boolean
-}
-
-export async function retry<T>(
-  fn: () => Promise<T>,
-  opts: RetryOpts = {},
-): Promise<T> {
-  const {
-    attempts = 3,
-    delay = 500,
-    factor = 2,
-    maxDelay = 10_000,
-    retryIf = isTransient,
-  } = opts
-  let last: unknown
-  for (let i = 0; i < attempts; i++) {
-    try { return await fn() } catch (err) {
-      last = err
-      if (i === attempts - 1 || !retryIf(err)) throw err
-      const wait = Math.min(expDelay(delay, i, factor), maxDelay)
-      await new Promise((r) => setTimeout(r, wait))
-    }
-  }
-  throw last
-}

package/src/boxes/rwlock.ts

@@ -1,41 +0,0 @@
-/**
- * rwlock.ts — Readers-writer lock map (writer priority, no starvation)
- * Zero deps.
- *
- * using r = await rwlock.read("key")
- * using w = await rwlock.write("key")
- */
-const map = new Map<string, { r: number; w: boolean; wr: (() => void)[]; ww: (() => void)[] }>()
-
-function get(k: string) {
-  if (!map.has(k)) map.set(k, { r: 0, w: false, wr: [], ww: [] })
-  return map.get(k)!
-}
-
-function drain(k: string) {
-  const l = map.get(k)
-  if (!l || l.w || l.r > 0) return
-  if (l.ww.length > 0) { l.ww.shift()!(); return }
-  while (l.wr.length > 0) l.wr.shift()!()
-  if (l.r === 0 && !l.w && l.wr.length === 0 && l.ww.length === 0) map.delete(k)
-}
-
-function mkRelease(k: string, mode: "r" | "w"): Disposable {
-  return { [Symbol.dispose]: () => { const l = map.get(k); if (!l) return; if (mode === "w") l.w = false; else l.r--; drain(k) } }
-}
-
-export async function read(k: string): Promise<Disposable> {
-  const l = get(k)
-  return new Promise<Disposable>((res) => {
-    if (!l.w && l.ww.length === 0) { l.r++; res(mkRelease(k, "r")) }
-    else l.wr.push(() => { l.r++; res(mkRelease(k, "r")) })
-  })
-}
-
-export async function write(k: string): Promise<Disposable> {
-  const l = get(k)
-  return new Promise<Disposable>((res) => {
-    if (!l.w && l.r === 0) { l.w = true; res(mkRelease(k, "w")) }
-    else l.ww.push(() => { l.w = true; res(mkRelease(k, "w")) })
-  })
-}

package/src/boxes/schedule.ts

@@ -1,71 +0,0 @@
-/**
- * schedule.ts — Retry schedule patterns (exponential/fibonacci)
- * Inspired by Effect-TS Schedule (MIT)
- * Deps: none
- */
-
-// ── Pure functions (stateless, safe for concurrent use) ──
-
-export function expDelay(baseMs: number, attempt: number, factor = 2): number {
-  return baseMs * Math.pow(factor, attempt)
-}
-
-export function fibDelay(oneMs: number, attempt: number): number {
-  if (attempt <= 0) return 0
-  let a = 0, b = 1
-  for (let i = 1; i < attempt; i++) { [a, b] = [b, a + b] }
-  return b * oneMs
-}
-
-// ── Stateful iterators (for retryWith / single-owner retry loops) ──
-
-export interface ScheduleStep {
-  delay: number
-  attempt: number
-  done: boolean
-}
-
-export interface ScheduleBuilder {
-  next(): ScheduleStep
-  reset(): void
-}
-
-export function exponential(baseMs: number, factor = 2, maxRetries = Infinity): ScheduleBuilder {
-  let attempt = 0
-  return {
-    next: () => {
-      if (attempt >= maxRetries) return { delay: 0, attempt, done: true }
-      const delay = expDelay(baseMs, attempt, factor)
-      return { delay, attempt: attempt++, done: false }
-    },
-    reset: () => { attempt = 0 },
-  }
-}
-
-export function fibonacci(oneMs: number, maxRetries = Infinity): ScheduleBuilder {
-  let a = 0, b = 1, attempt = 0
-  return {
-    next: () => {
-      if (attempt >= maxRetries) return { delay: 0, attempt, done: true }
-      const delay = a * oneMs; [a, b] = [b, a + b]
-      return { delay, attempt: attempt++, done: false }
-    },
-    reset: () => { a = 0; b = 1; attempt = 0 },
-  }
-}
-
-export function capDelay(maxMs: number, s: ScheduleBuilder): ScheduleBuilder {
-  return {
-    next: () => { const r = s.next(); return { ...r, delay: Math.min(r.delay, maxMs) } },
-    reset: () => { s.reset() },
-  }
-}
-
-export async function retryWith<T>(fn: (attempt: number) => Promise<T>, s: ScheduleBuilder): Promise<T> {
-  for (;;) {
-    const step = s.next()
-    if (step.done) throw new Error(`Retry exhausted after ${step.attempt} attempts`)
-    if (step.attempt > 0) await new Promise(r => setTimeout(r, step.delay))
-    try { const v = await fn(step.attempt); s.reset(); return v } catch { continue }
-  }
-}

package/src/boxes/scope.ts

@@ -1,21 +0,0 @@
-import { AsyncLocalStorage } from "async_hooks"
-
-export class NotFound extends Error {
-  constructor(public override readonly name: string) {
-    super(`no context for ${name}`)
-  }
-}
-
-export function scope<T>(label: string) {
-  const store = new AsyncLocalStorage<T>()
-  return {
-    use(): T {
-      const v = store.getStore()
-      if (!v) throw new NotFound(label)
-      return v
-    },
-    provide<R>(val: T, fn: () => R): R {
-      return store.run(val, fn)
-    },
-  }
-}

package/src/boxes/tokens.ts

@@ -1,9 +0,0 @@
-/**
- * tokens.ts — Rough token estimator
- * Zero deps.
- *
- * count("hello world") → 3
- */
-export function count(text: string): number {
-  return Math.max(0, Math.round((text || "").length / 4))
-}

package/src/boxes/ttl-cache.ts

@@ -1,63 +0,0 @@
-/**
- * ttl-cache.ts — Generic TTL cache with Map/WeakMap storage
- * Ported from gemini-cli CacheService (Apache-2.0)
- * Deps: none
- */
-export interface CacheOpts {
-  defaultTtl?: number
-  storage?: "map" | "weakmap"
-}
-
-interface Entry<V> { value: V; ts: number; ttl?: number }
-
-export class TTLCache<K extends object | string | undefined, V> {
-  private store: Map<K, Entry<V>> | WeakMap<WeakKey, Entry<V>>
-  private defaultTtl?: number
-
-  constructor(opts: CacheOpts = {}) {
-    this.store = opts.storage === "weakmap"
-      ? new WeakMap<WeakKey, Entry<V>>()
-      : new Map<K, Entry<V>>()
-    this.defaultTtl = opts.defaultTtl
-  }
-
-  get(key: K): V | undefined {
-    const e = (this.store as any).get(key) as Entry<V> | undefined
-    if (!e) return undefined
-    const ttl = e.ttl ?? this.defaultTtl
-    if (ttl !== undefined && Date.now() - e.ts > ttl) {
-      this.delete(key)
-      return undefined
-    }
-    return e.value
-  }
-
-  set(key: K, value: V, ttl?: number): void {
-    (this.store as any).set(key, { value, ts: Date.now(), ttl })
-  }
-
-  getOrCreate(key: K, creator: () => V, ttl?: number): V {
-    const v = this.get(key)
-    if (v !== undefined) return v
-    const created = creator()
-    this.set(key, created, ttl)
-    return created
-  }
-
-  delete(key: K): void { (this.store as any).delete(key) }
-
-  clear(): void {
-    if (this.store instanceof Map) this.store.clear()
-    else throw new Error("clear() not supported on WeakMap")
-  }
-}
-
-export function createCache<K extends string | undefined, V>(
-  opts: CacheOpts & { storage: "map" },
-): TTLCache<K, V>
-export function createCache<K extends object, V>(opts?: CacheOpts): TTLCache<K, V>
-export function createCache<K extends object | string | undefined, V>(
-  opts: CacheOpts = {},
-): TTLCache<K, V> {
-  return new TTLCache<K, V>(opts)
-}

package/src/boxes/typed-event.ts

@@ -1,51 +0,0 @@
-/**
- * typed-event.ts — Typed event emitter (pub/sub)
- * Inspired by superset EventBus + gemini-cli coreEvents
- * Deps: none
- */
-
-type Listener<T = any> = (data: T) => void
-
-export class TypedEventBus<Events extends Record<string, any> = Record<string, any>> {
-  private listeners = new Map<keyof Events, Set<Listener>>()
-  private maxListeners = Infinity
-
-  setMaxListeners(n: number): this { this.maxListeners = n; return this }
-
-  on<K extends keyof Events>(event: K, fn: Listener<Events[K]>): () => void {
-    if (!this.listeners.has(event)) this.listeners.set(event, new Set())
-    const set = this.listeners.get(event)!
-    if (set.size >= this.maxListeners && this.maxListeners > 0) {
-      process.stderr.write(`TypedEventBus: possible memory leak — ${String(event)} has ${set.size} listeners\n`)
-    }
-    set.add(fn)
-    return () => this.off(event, fn)
-  }
-
-  once<K extends keyof Events>(event: K, fn: Listener<Events[K]>): () => void {
-    const wrapped: Listener<Events[K]> = (data) => {
-      this.off(event, wrapped)
-      fn(data)
-    }
-    return this.on(event, wrapped)
-  }
-
-  off<K extends keyof Events>(event: K, fn: Listener<Events[K]>): void {
-    this.listeners.get(event)?.delete(fn)
-  }
-
-  emit<K extends keyof Events>(event: K, data: Events[K]): void {
-    const set = this.listeners.get(event)
-    if (!set) return
-    for (const fn of set) fn(data)
-  }
-
-  listenerCount<K extends keyof Events>(event: K): number {
-    return this.listeners.get(event)?.size ?? 0
-  }
-
-  removeAll(event?: keyof Events): void {
-    if (event) this.listeners.delete(event)
-    else this.listeners.clear()
-  }
-}