kokoirc 0.2.3 → 0.2.4

package/src/core/irc/events.ts

@@ -1,7 +1,8 @@
 import type { Client } from "kofany-irc-framework"
 import { useStore } from "@/core/state/store"
 import { makeBufferId, BufferType, ActivityLevel } from "@/types"
-import type { Message } from "@/types"
+import type { Message, NickEntry } from "@/types"
+import { nextMsgId } from "@/core/utils/id"
 import { formatDuration, formatDate, buildModeString, buildPrefixMap, buildModeOrder, getHighestPrefix, getNickMode } from "./formatting"
 import { handleNetsplitQuit, handleNetsplitJoin, destroyNetsplitState } from "./netsplit"
 import { shouldSuppressNickFlood, destroyAntifloodState } from "./antiflood"
@@ -145,10 +146,8 @@ export function bindEvents(client: Client, connectionId: string) {
       .filter(([_, buf]) => buf.connectionId === connectionId && buf.users.has(event.nick))
       .map(([id]) => id)
 
-    // Remove nick from all affected channels
-    for (const id of affected) {
-      getStore().removeNick(id, event.nick)
-    }
+    // Batch-remove nick from all affected channels (1 set() call)
+    getStore().batchRemoveNick(affected.map(id => ({ bufferId: id, nick: event.nick })))
 
     // Check if this is a netsplit — if so, batch it instead of showing individual quits
     if (handleNetsplitQuit(connectionId, event.nick, event.message || "", affected)) {
@@ -157,11 +156,12 @@ export function bindEvents(client: Client, connectionId: string) {
 
     if (shouldIgnore(event.nick, event.ident, event.hostname, "QUITS")) return
 
-    for (const id of affected) {
-      getStore().addMessage(id, makeFormattedEvent("quit", [
+    getStore().batchAddMessage(affected.map(id => ({
+      bufferId: id,
+      message: makeFormattedEvent("quit", [
         event.nick, event.ident || "", event.hostname || "", event.message || "",
-      ]))
-    }
+      ]),
+    })))
   })
 
   client.on("kick", (event) => {
@@ -232,14 +232,13 @@ export function bindEvents(client: Client, connectionId: string) {
       : false
 
     s.addMessage(bufferId, {
-      id: crypto.randomUUID(),
+      id: nextMsgId(),
       timestamp: new Date(event.time || Date.now()),
       type: "message",
       nick: event.nick,
       nickMode: getNickMode(s.buffers, bufferId, event.nick),
       text: event.message,
       highlight: isMention,
-      tags: event.tags,
     })
 
     if (s.activeBufferId !== bufferId && !isOwnMsg) {
@@ -262,13 +261,12 @@ export function bindEvents(client: Client, connectionId: string) {
     const bufferId = makeBufferId(connectionId, bufferName)
 
     s.addMessage(bufferId, {
-      id: crypto.randomUUID(),
+      id: nextMsgId(),
       timestamp: new Date(event.time || Date.now()),
       type: "action",
       nick: event.nick,
       text: event.message,
       highlight: false,
-      tags: event.tags,
     })
   })
 
@@ -288,7 +286,7 @@ export function bindEvents(client: Client, connectionId: string) {
       // Fallback to server status buffer
       const statusId = makeBufferId(connectionId, "Status")
       s.addMessage(statusId, {
-        id: crypto.randomUUID(),
+        id: nextMsgId(),
         timestamp: new Date(event.time || Date.now()),
         type: "notice",
         nick: event.nick,
@@ -299,7 +297,7 @@ export function bindEvents(client: Client, connectionId: string) {
     }
 
     s.addMessage(bufferId, {
-      id: crypto.randomUUID(),
+      id: nextMsgId(),
       timestamp: new Date(event.time || Date.now()),
       type: "notice",
       nick: event.nick,
@@ -327,14 +325,24 @@ export function bindEvents(client: Client, connectionId: string) {
       .filter(([_, buf]) => buf.connectionId === connectionId && buf.users.has(event.nick))
       .map(([id]) => id)
 
+    // Batch-update nick across all affected buffers (1 set() call)
+    getStore().batchUpdateNick(affected.map(id => ({
+      bufferId: id, oldNick: event.nick, newNick: event.new_nick,
+    })))
+
     const nickIgnored = shouldIgnore(event.nick, event.ident, event.hostname, "NICKS")
-    for (const id of affected) {
-      getStore().updateNick(id, event.nick, event.new_nick)
-      if (nickIgnored) continue
-      if (shouldSuppressNickFlood(connectionId, id)) continue
-      getStore().addMessage(id, makeFormattedEvent("nick_change", [
-        event.nick, event.new_nick,
-      ]))
+    if (!nickIgnored) {
+      const msgEntries: Array<{ bufferId: string; message: Message }> = []
+      for (const id of affected) {
+        if (shouldSuppressNickFlood(connectionId, id)) continue
+        msgEntries.push({
+          bufferId: id,
+          message: makeFormattedEvent("nick_change", [event.nick, event.new_nick]),
+        })
+      }
+      if (msgEntries.length > 0) {
+        getStore().batchAddMessage(msgEntries)
+      }
     }
   })
 
@@ -369,11 +377,12 @@ export function bindEvents(client: Client, connectionId: string) {
     const prefixMap = buildPrefixMap(conn?.isupport?.PREFIX)
     const modeOrder = buildModeOrder(conn?.isupport?.PREFIX)
 
+    const nickEntries: Array<{ bufferId: string; entry: NickEntry }> = []
     for (const user of event.users) {
       // irc-framework gives modes as array of chars (["o","v"]) or prefix symbols (["@","+"])
       // Normalize to mode chars and store all of them
       const rawModes = (user.modes ?? [])
-        .map((m) => {
+        .map((m: string) => {
           // If it's already a mode char in the order list, keep it
           if (modeOrder.includes(m)) return m
           // Otherwise it's a prefix symbol — reverse-lookup
@@ -385,14 +394,14 @@ export function bindEvents(client: Client, connectionId: string) {
         .filter(Boolean)
         .join("")
       const prefix = getHighestPrefix(rawModes, modeOrder, prefixMap)
-      getStore().addNick(bufferId, {
-        nick: user.nick,
-        prefix,
-        modes: rawModes,
-        away: !!user.away,
-        account: user.account,
+      nickEntries.push({
+        bufferId,
+        entry: { nick: user.nick, prefix, modes: rawModes, away: !!user.away, account: user.account },
       })
     }
+    if (nickEntries.length > 0) {
+      getStore().batchAddNick(nickEntries)
+    }
   })
 
   client.on("mode", (event) => {
@@ -597,18 +606,22 @@ export function bindEvents(client: Client, connectionId: string) {
     }
     if (!event.nick) return
 
-    // Update nick away status in all shared channels
+    // Batch-update nick away status in all shared channels (1 set() call)
+    const nickEntries: Array<{ bufferId: string; entry: NickEntry }> = []
     for (const [bufId, buf] of s.buffers) {
       if (buf.connectionId === connectionId && buf.users.has(event.nick)) {
         const entry = buf.users.get(event.nick)!
-        getStore().addNick(bufId, { ...entry, away: true })
+        nickEntries.push({ bufferId: bufId, entry: { ...entry, away: true } })
       }
     }
+    if (nickEntries.length > 0) {
+      getStore().batchAddNick(nickEntries)
+    }
 
     // Show in query buffer if we have one open (RPL_AWAY response to messaging)
     const queryId = makeBufferId(connectionId, event.nick)
     if (s.buffers.has(queryId)) {
-      s.addMessage(queryId, makeEventMessage(
+      getStore().addMessage(queryId, makeEventMessage(
         `%Z565f89${event.nick} is away${event.message ? ": " + event.message : ""}%N`
       ))
     }
@@ -622,13 +635,17 @@ export function bindEvents(client: Client, connectionId: string) {
     }
     if (!event.nick) return
 
-    // Update nick away status in all shared channels
+    // Batch-update nick away status in all shared channels (1 set() call)
+    const nickEntries: Array<{ bufferId: string; entry: NickEntry }> = []
     for (const [bufId, buf] of s.buffers) {
       if (buf.connectionId === connectionId && buf.users.has(event.nick)) {
         const entry = buf.users.get(event.nick)!
-        getStore().addNick(bufId, { ...entry, away: false })
+        nickEntries.push({ bufferId: bufId, entry: { ...entry, away: false } })
       }
     }
+    if (nickEntries.length > 0) {
+      getStore().batchAddNick(nickEntries)
+    }
   })
 
   // ─── Channel redirect ─────────────────────────────────────
@@ -717,15 +734,19 @@ export function bindEvents(client: Client, connectionId: string) {
   // ACCOUNT-NOTIFY — a user's account changed (requires account-notify cap)
   client.on("account", (event) => {
     const s = getStore()
+    const nickEntries: Array<{ bufferId: string; entry: NickEntry }> = []
     for (const [bufId, buf] of s.buffers) {
       if (buf.connectionId === connectionId && buf.users.has(event.nick)) {
         const entry = buf.users.get(event.nick)!
-        getStore().addNick(bufId, {
-          ...entry,
-          account: event.account === false ? undefined : event.account,
+        nickEntries.push({
+          bufferId: bufId,
+          entry: { ...entry, account: event.account === false ? undefined : event.account },
         })
       }
     }
+    if (nickEntries.length > 0) {
+      getStore().batchAddNick(nickEntries)
+    }
   })
 
   // ─── Displayed host ────────────────────────────────────────
@@ -1013,7 +1034,7 @@ function displayNumberedList(
 /** System/inline event — text may contain %Z color codes. */
 function makeEventMessage(text: string): Message {
   return {
-    id: crypto.randomUUID(),
+    id: nextMsgId(),
     timestamp: new Date(),
     type: "event",
     text,
@@ -1024,7 +1045,7 @@ function makeEventMessage(text: string): Message {
 /** IRC event with theme format key — rendered via [formats.events] in MessageLine. */
 function makeFormattedEvent(key: string, params: string[]): Message {
   return {
-    id: crypto.randomUUID(),
+    id: nextMsgId(),
     timestamp: new Date(),
     type: "event",
     text: params.join(" "),

package/src/core/irc/netsplit.ts

@@ -1,6 +1,7 @@
 import { useStore } from "@/core/state/store"
 import { makeBufferId } from "@/types"
 import type { Message } from "@/types"
+import { nextMsgId } from "@/core/utils/id"
 
 // ─── Types ───────────────────────────────────────────────────
 
@@ -232,7 +233,7 @@ function tick(connId: string) {
 
 function makeEventMessage(text: string): Message {
   return {
-    id: crypto.randomUUID(),
+    id: nextMsgId(),
     timestamp: new Date(),
     type: "event",
     text,

package/src/core/scripts/api.ts

@@ -1,6 +1,7 @@
 import { useStore } from "@/core/state/store"
 import { getClient } from "@/core/irc"
 import { makeBufferId } from "@/types"
+import { nextMsgId } from "@/core/utils/id"
 import { eventBus } from "./event-bus"
 import { EventPriority } from "./types"
 import type {
@@ -106,7 +107,7 @@ export function createScriptAPI(meta: ScriptMeta, scriptDefaults: Record<string,
       const buf = s.activeBufferId
       if (!buf) return
       s.addMessage(buf, {
-        id: crypto.randomUUID(),
+        id: nextMsgId(),
         timestamp: new Date(),
         type: "event",
         text,
@@ -115,7 +116,7 @@ export function createScriptAPI(meta: ScriptMeta, scriptDefaults: Record<string,
     },
     addMessage(bufferId, partial) {
       useStore.getState().addMessage(bufferId, {
-        id: crypto.randomUUID(),
+        id: nextMsgId(),
         timestamp: new Date(),
         ...partial,
       })

package/src/core/state/store.ts

@@ -1,8 +1,20 @@
 import { create } from "zustand"
-import type { Connection, Buffer, Message, NickEntry, ActivityLevel, ListEntry, ListModeKey } from "@/types"
+import { BufferType, ActivityLevel, makeBufferId } from "@/types"
+import type { Connection, Buffer, Message, NickEntry, ListEntry, ListModeKey } from "@/types"
 import type { AppConfig } from "@/types/config"
 import type { ThemeFile } from "@/types/theme"
 import { logMessage, updateReadMarker } from "@/core/storage"
+import { nextMsgId } from "@/core/utils/id"
+
+export interface ImagePreviewState {
+  url: string
+  status: "loading" | "ready" | "error"
+  error?: string
+  width: number
+  height: number
+  title?: string
+  protocol?: string  // needed for cleanup on dismiss
+}
 
 interface AppState {
   // Data
@@ -13,6 +25,12 @@ interface AppState {
   config: AppConfig | null
   theme: ThemeFile | null
 
+  // Image preview
+  imagePreview: ImagePreviewState | null
+  showImagePreview: (url: string) => void
+  updateImagePreview: (updates: Partial<ImagePreviewState>) => void
+  hideImagePreview: () => void
+
   // Connection actions
   addConnection: (conn: Connection) => void
   updateConnection: (id: string, updates: Partial<Connection>) => void
@@ -21,11 +39,13 @@ interface AppState {
   // Buffer actions
   addBuffer: (buffer: Buffer) => void
   removeBuffer: (id: string) => void
+  closeConnection: (connectionId: string) => void
   setActiveBuffer: (id: string) => void
   updateBufferActivity: (id: string, level: ActivityLevel) => void
 
   // Message actions
   addMessage: (bufferId: string, message: Message) => void
+  clearMessages: (bufferId: string) => void
 
   // Nicklist actions
   addNick: (bufferId: string, entry: NickEntry) => void
@@ -41,6 +61,12 @@ interface AppState {
   addListEntry: (bufferId: string, modeChar: ListModeKey, entry: ListEntry) => void
   removeListEntry: (bufferId: string, modeChar: ListModeKey, mask: string) => void
 
+  // Batch actions (single set() for N mutations)
+  batchRemoveNick: (entries: Array<{ bufferId: string; nick: string }>) => void
+  batchAddNick: (entries: Array<{ bufferId: string; entry: NickEntry }>) => void
+  batchUpdateNick: (entries: Array<{ bufferId: string; oldNick: string; newNick: string; prefix?: string }>) => void
+  batchAddMessage: (entries: Array<{ bufferId: string; message: Message }>) => void
+
   // Config/Theme
   setConfig: (config: AppConfig) => void
   setTheme: (theme: ThemeFile) => void
@@ -59,6 +85,96 @@ export const useStore = create<AppState>((set, get) => ({
   config: null,
   theme: null,
 
+  // Image preview
+  imagePreview: null,
+  showImagePreview: (url) => {
+    // Concurrency guard — ignore if already loading
+    const current = get().imagePreview
+    if (current?.status === "loading") return
+
+    set({
+      imagePreview: { url, status: "loading", width: 0, height: 0 },
+    })
+    // Kick off the async render pipeline
+    import("@/core/image-preview/render").then(({ preparePreview }) => {
+      preparePreview(url)
+    }).catch((err) => {
+      const s = get()
+      const buf = s.activeBufferId
+      if (buf) {
+        s.addMessage(buf, {
+          id: nextMsgId(),
+          timestamp: new Date(),
+          type: "event",
+          text: `%Zf7768e[img] import failed: ${err.message}%N`,
+          highlight: false,
+        })
+      }
+      set({ imagePreview: null })
+    })
+  },
+  updateImagePreview: (updates) => set((s) => {
+    if (!s.imagePreview) return s
+    return { imagePreview: { ...s.imagePreview, ...updates } }
+  }),
+  hideImagePreview: () => {
+    const prev = get().imagePreview
+    if (!prev) { set({ imagePreview: null }); return }
+
+    try {
+      const { writeSync } = require("node:fs")
+      const { flushStdin } = require("@/core/image-preview/stdin-guard")
+      const inTmux = !!process.env.TMUX
+
+      // Disable mouse tracking + flush kernel input buffer.
+      // Do NOT call process.stdin.pause()/resume() — triggers Bun malloc crash.
+      writeSync(1, "\x1b[?1003l\x1b[?1006l\x1b[?1002l\x1b[?1000l")
+      flushStdin()
+
+      if (prev.protocol === "kitty") {
+        // Kitty: image is on separate graphics layer — delete command removes it
+        const deleteCmd = "\x1b_Ga=d,q=2\x1b\\"
+        if (inTmux) {
+          const escaped = deleteCmd.replace(/\x1b/g, "\x1b\x1b")
+          writeSync(1, `\x1bPtmux;${escaped}\x1b\\`)
+        } else {
+          writeSync(1, deleteCmd)
+        }
+      } else {
+        // iTerm2/Sixel/Symbols: image is in the cell buffer — overwrite with
+        // spaces using theme bg color. OpenTUI's diff renderer skips empty
+        // cells (they look "unchanged"), so we must fill them with the correct
+        // bg to avoid a default-bg hole where the image was.
+        const termCols = process.stdout.columns || 80
+        const termRows = process.stdout.rows || 24
+        const popupW = prev.width || 0
+        const popupH = prev.height || 0
+        if (popupW > 0 && popupH > 0) {
+          const left = Math.max(0, Math.floor((termCols - popupW) / 2))
+          const top = Math.max(0, Math.floor((termRows - popupH) / 2))
+          // Use theme bg color for spaces so empty cells match the UI
+          const theme = get().theme
+          const hex = theme?.colors?.bg ?? "#1a1b26"
+          const r = parseInt(hex.slice(1, 3), 16)
+          const g = parseInt(hex.slice(3, 5), 16)
+          const b = parseInt(hex.slice(5, 7), 16)
+          const bgSeq = `\x1b[48;2;${r};${g};${b}m`
+          const blankLine = bgSeq + " ".repeat(popupW) + "\x1b[0m"
+          writeSync(1, "\x1b7") // save cursor
+          for (let row = 0; row < popupH; row++) {
+            writeSync(1, `\x1b[${top + row + 1};${left + 1}H${blankLine}`)
+          }
+          writeSync(1, "\x1b8") // restore cursor
+        }
+      }
+
+      flushStdin()
+      writeSync(1, "\x1b[?1000h\x1b[?1002h\x1b[?1003h\x1b[?1006h")
+    } catch {}
+
+    set({ imagePreview: null })
+  },
+
   addConnection: (conn) => set((s) => {
     const connections = new Map(s.connections)
     connections.set(conn.id, conn)
@@ -87,13 +203,82 @@ export const useStore = create<AppState>((set, get) => ({
   removeBuffer: (id) => set((s) => {
     const buffers = new Map(s.buffers)
     buffers.delete(id)
+
+    // If no buffers left, recreate the default welcome state
+    if (buffers.size === 0) {
+      const defaultId = makeBufferId("_default", "Status")
+      buffers.set(defaultId, {
+        id: defaultId,
+        connectionId: "_default",
+        type: BufferType.Server,
+        name: "Status",
+        messages: [{
+          id: nextMsgId(),
+          timestamp: new Date(),
+          type: "event" as const,
+          text: "Welcome to kokoIRC. Type /connect to connect to a server.",
+          highlight: false,
+        }],
+        activity: ActivityLevel.None,
+        unreadCount: 0,
+        lastRead: new Date(),
+        users: new Map(),
+        listModes: new Map(),
+      })
+      return { buffers, activeBufferId: defaultId, previousActiveBufferId: null }
+    }
+
     if (s.activeBufferId !== id) return { buffers }
-    // Fall back to previous buffer if it still exists, otherwise null
+    // Fall back to previous buffer if it still exists, otherwise first available
     const fallback = s.previousActiveBufferId && buffers.has(s.previousActiveBufferId)
-      ? s.previousActiveBufferId : null
+      ? s.previousActiveBufferId : buffers.keys().next().value ?? null
     return { buffers, activeBufferId: fallback }
   }),
 
+  closeConnection: (connectionId) => set((s) => {
+    const buffers = new Map(s.buffers)
+    const connections = new Map(s.connections)
+
+    // Remove all buffers for this connection
+    for (const [id, buf] of buffers) {
+      if (buf.connectionId === connectionId) buffers.delete(id)
+    }
+    // Remove the connection entry
+    connections.delete(connectionId)
+
+    // If no buffers left, recreate the default welcome state
+    if (buffers.size === 0) {
+      const defaultId = makeBufferId("_default", "Status")
+      buffers.set(defaultId, {
+        id: defaultId,
+        connectionId: "_default",
+        type: BufferType.Server,
+        name: "Status",
+        messages: [{
+          id: nextMsgId(),
+          timestamp: new Date(),
+          type: "event" as const,
+          text: "Welcome to kokoIRC. Type /connect to connect to a server.",
+          highlight: false,
+        }],
+        activity: ActivityLevel.None,
+        unreadCount: 0,
+        lastRead: new Date(),
+        users: new Map(),
+        listModes: new Map(),
+      })
+      return { buffers, connections, activeBufferId: defaultId, previousActiveBufferId: null }
+    }
+
+    // If active buffer was removed, fall back
+    const needsFallback = !buffers.has(s.activeBufferId ?? "")
+    const fallback = needsFallback
+      ? (s.previousActiveBufferId && buffers.has(s.previousActiveBufferId)
+        ? s.previousActiveBufferId : buffers.keys().next().value ?? null)
+      : s.activeBufferId
+    return { buffers, connections, activeBufferId: fallback }
+  }),
+
   setActiveBuffer: (id) => {
     // Persist read marker for TUI client
     const slashIdx = id.indexOf("/")
@@ -145,6 +330,14 @@ export const useStore = create<AppState>((set, get) => ({
     })
   },
 
+  clearMessages: (bufferId) => set((s) => {
+    const buffers = new Map(s.buffers)
+    const buf = buffers.get(bufferId)
+    if (!buf) return s
+    buffers.set(bufferId, { ...buf, messages: [] })
+    return { buffers }
+  }),
+
   addNick: (bufferId, entry) => set((s) => {
     const buffers = new Map(s.buffers)
     const buf = buffers.get(bufferId)
@@ -230,6 +423,71 @@ export const useStore = create<AppState>((set, get) => ({
     return { buffers }
   }),
 
+  batchRemoveNick: (entries) => set((s) => {
+    const buffers = new Map(s.buffers)
+    for (const { bufferId, nick } of entries) {
+      const buf = buffers.get(bufferId)
+      if (!buf) continue
+      const users = new Map(buf.users)
+      users.delete(nick)
+      buffers.set(bufferId, { ...buf, users })
+    }
+    return { buffers }
+  }),
+
+  batchAddNick: (entries) => set((s) => {
+    const buffers = new Map(s.buffers)
+    for (const { bufferId, entry } of entries) {
+      const buf = buffers.get(bufferId)
+      if (!buf) continue
+      const users = new Map(buf.users)
+      users.set(entry.nick, entry)
+      buffers.set(bufferId, { ...buf, users })
+    }
+    return { buffers }
+  }),
+
+  batchUpdateNick: (entries) => set((s) => {
+    const buffers = new Map(s.buffers)
+    for (const { bufferId, oldNick, newNick, prefix } of entries) {
+      const buf = buffers.get(bufferId)
+      if (!buf) continue
+      const users = new Map(buf.users)
+      const existing = users.get(oldNick)
+      if (existing) {
+        users.delete(oldNick)
+        users.set(newNick, { ...existing, nick: newNick, prefix: prefix ?? existing.prefix })
+      }
+      buffers.set(bufferId, { ...buf, users })
+    }
+    return { buffers }
+  }),
+
+  batchAddMessage: (entries) => {
+    // Log each message to persistent storage before the set() call
+    for (const { bufferId, message } of entries) {
+      const slashIdx = bufferId.indexOf("/")
+      if (slashIdx > 0) {
+        const network = bufferId.slice(0, slashIdx)
+        const buffer = bufferId.slice(slashIdx + 1)
+        logMessage(network, buffer, message.id, message.type, message.text, message.nick ?? null, message.highlight, message.timestamp)
+      }
+    }
+
+    return set((s) => {
+      const buffers = new Map(s.buffers)
+      const maxLines = s.config?.display.scrollback_lines ?? 2000
+      for (const { bufferId, message } of entries) {
+        const buf = buffers.get(bufferId)
+        if (!buf) continue
+        const messages = [...buf.messages, message]
+        if (messages.length > maxLines) messages.splice(0, messages.length - maxLines)
+        buffers.set(bufferId, { ...buf, messages })
+      }
+      return { buffers }
+    })
+  },
+
   setConfig: (config) => set({ config }),
   setTheme: (theme) => set({ theme }),
 

package/src/core/storage/index.ts

@@ -35,7 +35,7 @@ export async function initStorage(config: LoggingConfig): Promise<void> {
 export function logMessage(
   network: string,
   buffer: string,
-  msgId: string,
+  msgId: string | number,
   type: MessageType,
   text: string,
   nick: string | null,
@@ -45,7 +45,7 @@ export function logMessage(
   if (!writer) return
 
   const row: LogRow = {
-    msg_id: msgId,
+    msg_id: String(msgId),
     network,
     buffer,
     timestamp: timestamp.getTime(),

package/src/core/storage/writer.ts

@@ -14,6 +14,8 @@ export class LogWriter {
   private cryptoKey: CryptoKey | null = null
   private hasFts: boolean
   private listeners: MessageListener[] = []
+  private insertStmt: ReturnType<Database["prepare"]> | null = null
+  private insertFtsStmt: ReturnType<Database["prepare"]> | null = null
 
   constructor(db: Database, config: LoggingConfig) {
     this.db = db
@@ -25,6 +27,14 @@ export class LogWriter {
     if (this.config.encrypt) {
       this.cryptoKey = await loadOrCreateKey()
     }
+    this.insertStmt = this.db.prepare(
+      "INSERT INTO messages (msg_id, network, buffer, timestamp, type, nick, text, highlight, iv) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)"
+    )
+    if (this.hasFts) {
+      this.insertFtsStmt = this.db.prepare(
+        "INSERT INTO messages_fts (rowid, nick, text) VALUES (?, ?, ?)"
+      )
+    }
   }
 
   /** Subscribe to new messages (for WebSocket real-time push). */
@@ -70,16 +80,8 @@ export class LogWriter {
     this.flushing = true
     const batch = this.queue.splice(0)
 
-    const insert = this.db.prepare(
-      "INSERT INTO messages (msg_id, network, buffer, timestamp, type, nick, text, highlight, iv) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)"
-    )
-
-    // Prepare FTS insert if available
-    const insertFts = this.hasFts
-      ? this.db.prepare(
-          "INSERT INTO messages_fts (rowid, nick, text) VALUES (?, ?, ?)"
-        )
-      : null
+    const insert = this.insertStmt!
+    const insertFts = this.insertFtsStmt
 
     try {
       // bun:sqlite transactions are sync, but encrypt is async — handle both modes