@threadbase-sh/streamer 1.62.0 → 1.64.0

package/dist/utils/canonicalizeFilePath.d.ts

@@ -0,0 +1,75 @@
+/**
+ * File-path identity across the scanner/cache boundary.
+ *
+ * Two path forms exist in this process and they are NOT interchangeable on
+ * Windows:
+ *
+ *   - **canonical** (forward slashes) — every cache key: conversation_meta
+ *     .file_path, the fileIndex, watcher keys, externalTails.
+ *   - **native** (the platform separator) — what the scanner emits in
+ *     ConversationMeta.filePath, and what chokidar delivers.
+ *
+ * Both writers of conversation_meta.file_path (upsertFull, insertSkeleton)
+ * store the canonical form, so the storage invariant is "cache keys are always
+ * canonical". The scanner has no such rule: it emits native paths, verified by
+ * measurement on win32.
+ *
+ * The rule when the two meet: **normalize for the comparison, emit in the
+ * consumer's form.** Canonicalize both sides to join them, then key the result
+ * with whichever form the code receiving it will look up by. Joining a
+ * scanner-derived path against a cache-derived one without normalizing fails
+ * silently — an empty map or a false, never an exception — and is invisible on
+ * POSIX, where the two forms are identical.
+ */
+/**
+ * Canonicalize a path for use as a cache/DB/watcher key.
+ *
+ * Rules:
+ *   - Trim surrounding whitespace
+ *   - Convert backslashes to forward slashes
+ *
+ * Do NOT lowercase: even on case-insensitive Windows filesystems, lowercasing
+ * would diverge the key from the scanner's case-preserved file_path. Only the
+ * separator is normalized; case is preserved.
+ */
+export declare function canonicalizeFilePath(filePath: string): string;
+/**
+ * Convert a canonical path back to the platform-native form.
+ *
+ * Use only when handing a path *back* to something that keys by native paths —
+ * in practice the scanner's statCache, whose entries it looks up by its own
+ * ConversationMeta.filePath. A no-op on POSIX; on win32 `normalize` rewrites
+ * forward slashes to backslashes.
+ */
+export declare function toNativeFilePath(filePath: string): string;
+/**
+ * Build the canonical live-path set that `reconcileDeletions` compares against
+ * `conversation_meta.file_path`.
+ *
+ * Exists as a named function rather than an inline `.map()` so the conversion
+ * has one place to be tested and one place to be got wrong: the scanner's
+ * filePath is native, the rows it is checked against are canonical, and a
+ * missed conversion here means every row falls through to the existsSync
+ * backstop instead of being recognised as live.
+ */
+export declare function canonicalLivePathSet(metas: Iterable<{
+    filePath?: string | null;
+}>): Set<string>;
+/**
+ * Join scanner metadata against canonically-keyed stat rows, producing the map
+ * the scanner expects back as `statCache`.
+ *
+ * This is the boundary rule made concrete: the lookup is done in canonical
+ * form (because that is how the rows are keyed) while the result is keyed by
+ * the meta's own native path (because that is what the scanner looks up by).
+ * Getting either half wrong yields an empty or unusable map and silently
+ * disables the scanner's stat cache — no error, just a full re-parse of every
+ * conversation on every rescan.
+ */
+export declare function joinStatCacheByNativePath<TStat, TMeta extends {
+    filePath?: string | null;
+}>(metas: Iterable<TMeta>, canonicalStats: Map<string, TStat>): Map<string, {
+    stat: TStat;
+    meta: TMeta;
+}>;
+//# sourceMappingURL=canonicalizeFilePath.d.ts.map

package/dist/utils/canonicalizeFilePath.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"canonicalizeFilePath.d.ts","sourceRoot":"","sources":["../../src/utils/canonicalizeFilePath.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH;;;;;;;;;;GAUG;AACH,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAE7D;AAED;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAEzD;AAED;;;;;;;;;GASG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,QAAQ,CAAC;IAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;CAAE,CAAC,GAAG,GAAG,CAAC,MAAM,CAAC,CAM/F;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,KAAK,SAAS;IAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;CAAE,EACzF,KAAK,EAAE,QAAQ,CAAC,KAAK,CAAC,EACtB,cAAc,EAAE,GAAG,CAAC,MAAM,EAAE,KAAK,CAAC,GACjC,GAAG,CAAC,MAAM,EAAE;IAAE,IAAI,EAAE,KAAK,CAAC;IAAC,IAAI,EAAE,KAAK,CAAA;CAAE,CAAC,CAQ3C"}

package/dist/utils/canonicalizeProjectPath.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Canonicalize a project path so the same project always dedupes to the
+ * same key, regardless of trailing slashes or surrounding whitespace.
+ *
+ * Rules:
+ *   - Trim surrounding whitespace
+ *   - Remove trailing forward or back slashes (one or more)
+ *
+ * Do NOT lowercase: project paths can be case-sensitive on Linux/macOS
+ * and lowercasing them would silently merge two distinct real projects.
+ */
+export declare function canonicalizeProjectPath(projectPath: string): string;
+//# sourceMappingURL=canonicalizeProjectPath.d.ts.map

package/dist/utils/canonicalizeProjectPath.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"canonicalizeProjectPath.d.ts","sourceRoot":"","sources":["../../src/utils/canonicalizeProjectPath.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,wBAAgB,uBAAuB,CAAC,WAAW,EAAE,MAAM,GAAG,MAAM,CAEnE"}

package/dist/utils/codexConversationLine.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Codex rollout JSONL → Claude-shaped conversation lines for WS clients.
+ *
+ * Mobile's `parseLineToMessage` only understands Claude Code JSONL
+ * (`type: "user"|"assistant"`, `message.role`, text blocks). Codex writes
+ * `response_item` / `event_msg` / `session_meta` instead, so raw Codex lines
+ * never become live bubbles. This helper normalizes chat-bearing Codex lines
+ * into the Claude shape and drops everything else (including the duplicate
+ * `event_msg` copies of each turn and `developer` role payloads).
+ */
+import type { NormalizeResult } from "../services/providers/capabilities";
+/**
+ * Classify one Codex rollout line (C2).
+ *
+ * Distinguishes "recognized, deliberately not rendered" (`ignored`) from "this
+ * adapter has never seen this shape" (`unknown`). Both were `null` before, which
+ * is why provider schema drift used to surface as an empty screen with no error.
+ */
+export declare function classifyCodexLine(line: string): NormalizeResult;
+/**
+ * Returns a Claude-shaped JSONL line, or null when the input is not a
+ * user/assistant chat message that clients should render.
+ *
+ * Thin wrapper over classifyCodexLine so existing callers keep their signature.
+ * New code should prefer classifyCodexLine, which explains WHY a line produced
+ * nothing.
+ */
+export declare function normalizeCodexLineToClaudeShape(line: string): string | null;
+/** True when a Codex rollout line is Codex-shaped (not Claude JSONL). */
+export declare function isCodexRolloutLine(line: string): boolean;
+/**
+ * Map a batch of raw JSONL lines to client-facing lines. Codex batches are
+ * normalized (and filtered); Claude batches pass through unchanged so seq
+ * alignment is preserved.
+ */
+export declare function toClientConversationLines(lines: string[]): string[];
+export declare function isCodexInjectedContext(text: string): boolean;
+//# sourceMappingURL=codexConversationLine.d.ts.map

package/dist/utils/codexConversationLine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"codexConversationLine.d.ts","sourceRoot":"","sources":["../../src/utils/codexConversationLine.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,oCAAoC,CAAC;AAkC1E;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,eAAe,CAuD/D;AAED;;;;;;;GAOG;AACH,wBAAgB,+BAA+B,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAG3E;AA6BD,yEAAyE;AACzE,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAYxD;AAED;;;;GAIG;AACH,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE,CAYnE;AAED,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAsB5D"}

package/dist/utils/conversationEtag.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Inputs that uniquely identify a conversation's current state for the
+ * purpose of a conditional fetch. These all live on the parsed `Conversation`
+ * and must be read AFTER `findConversationByUuid`'s staleness refresh — never
+ * from a pre-refresh snapshot — so the validator reflects the same state the
+ * response body would.
+ */
+export interface ConversationEtagInput {
+    filePath: string;
+    messageCount: number;
+    timestamp: string;
+}
+/**
+ * Derive a stable, opaque ETag for a conversation. The client never parses it;
+ * it only echoes the value back via `If-None-Match`. Wrapping the inputs in a
+ * hash keeps the formula changeable without the client caring.
+ */
+export declare function computeConversationEtag({ filePath, messageCount, timestamp, }: ConversationEtagInput): string;
+//# sourceMappingURL=conversationEtag.d.ts.map

package/dist/utils/conversationEtag.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"conversationEtag.d.ts","sourceRoot":"","sources":["../../src/utils/conversationEtag.ts"],"names":[],"mappings":"AAEA;;;;;;GAMG;AACH,MAAM,WAAW,qBAAqB;IACpC,QAAQ,EAAE,MAAM,CAAC;IACjB,YAAY,EAAE,MAAM,CAAC;IACrB,SAAS,EAAE,MAAM,CAAC;CACnB;AAED;;;;GAIG;AACH,wBAAgB,uBAAuB,CAAC,EACtC,QAAQ,EACR,YAAY,EACZ,SAAS,GACV,EAAE,qBAAqB,GAAG,MAAM,CAMhC"}

package/dist/utils/dates.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Parse an ISO timestamp string. Returns null for null/undefined input or
+ * an unparseable value rather than throwing — callers can fall back.
+ */
+export declare function parseIsoDateOrNull(value?: string | null): Date | null;
+/**
+ * Compare two ISO timestamp strings descending. Null/undefined values sort
+ * last regardless of order. Used for ProjectChat list ordering and latest
+ * conversation selection.
+ */
+export declare function compareIsoDesc(a?: string | null, b?: string | null): number;
+//# sourceMappingURL=dates.d.ts.map

package/dist/utils/dates.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dates.d.ts","sourceRoot":"","sources":["../../src/utils/dates.ts"],"names":[],"mappings":"AAEA;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,GAAG,IAAI,GAAG,IAAI,CAIrE;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,CAAC,CAAC,EAAE,MAAM,GAAG,IAAI,EAAE,CAAC,CAAC,EAAE,MAAM,GAAG,IAAI,GAAG,MAAM,CAS3E"}

package/dist/utils/debounce.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Trailing-edge debounce: collapses calls that arrive within `waitMs` of each
+ * other into a single invocation, scheduled `waitMs` after the most recent
+ * call. The last call's arguments win.
+ *
+ * The returned function carries two extra methods:
+ *   - cancel(): drop any pending invocation (use on shutdown so a timer
+ *     doesn't keep the process alive).
+ *   - flush():  run any pending invocation immediately (useful in tests).
+ */
+export declare function debounce<A extends unknown[]>(fn: (...args: A) => void, waitMs: number): ((...args: A) => void) & {
+    flush: () => void;
+    cancel: () => void;
+};
+//# sourceMappingURL=debounce.d.ts.map

package/dist/utils/debounce.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"debounce.d.ts","sourceRoot":"","sources":["../../src/utils/debounce.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,wBAAgB,QAAQ,CAAC,CAAC,SAAS,OAAO,EAAE,EAC1C,EAAE,EAAE,CAAC,GAAG,IAAI,EAAE,CAAC,KAAK,IAAI,EACxB,MAAM,EAAE,MAAM,GACb,CAAC,CAAC,GAAG,IAAI,EAAE,CAAC,KAAK,IAAI,CAAC,GAAG;IAAE,KAAK,EAAE,MAAM,IAAI,CAAC;IAAC,MAAM,EAAE,MAAM,IAAI,CAAA;CAAE,CAiCpE"}

package/dist/utils/deriveSessionName.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Derive a session title from its first user message.
+ *
+ * Mirrors `@threadbase-sh/scanner`'s `deriveSessionNameFromFirstMessage`
+ * (first line of the first user message, truncated) so a live session gets
+ * the same title a resumed/scanned one would compute from the same JSONL —
+ * without waiting on the scanner or cache to observe the line.
+ */
+export declare function deriveSessionName(firstMessageText: string): string;
+//# sourceMappingURL=deriveSessionName.d.ts.map

package/dist/utils/deriveSessionName.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deriveSessionName.d.ts","sourceRoot":"","sources":["../../src/utils/deriveSessionName.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAAC,gBAAgB,EAAE,MAAM,GAAG,MAAM,CAGlE"}

package/dist/utils/fileIdentity.d.ts

@@ -0,0 +1,36 @@
+import type { Stats } from "fs";
+/**
+ * Stable identity for a JSONL file, used to detect replacement (a new file at
+ * the same path) vs. mere growth. Prefer the inode (dev:ino) — cheap and exact.
+ * When the inode is unavailable (ino === 0, e.g. some network/virtual FS), fall
+ * back to a fingerprint of the first bytes supplied by the caller.
+ */
+export declare function fileIdentity(stat: Pick<Stats, "dev" | "ino">, headBytes?: Buffer): string;
+export interface LineSpan {
+    /** Absolute byte offset of the line's first byte in the file. */
+    byteOffset: number;
+    /** Byte length of the line content, excluding the trailing "\n". */
+    byteLength: number;
+    /** The decoded line text (no trailing "\n"). */
+    text: string;
+}
+export interface SplitResult {
+    spans: LineSpan[];
+    /**
+     * Bytes consumed = up to and including the last "\n" in `buf`. A trailing
+     * partial line (no newline yet) is NOT consumed, so the caller's byte offset
+     * never advances past an incomplete line. Those bytes arrive again, whole, on
+     * the next read.
+     */
+    consumed: number;
+}
+/**
+ * Split a buffer of appended bytes into complete-line spans with absolute byte
+ * offsets. `baseOffset` is the file position of `buf`'s first byte.
+ *
+ * Only lines terminated by "\n" produce a span; the remainder after the final
+ * newline is left for the next read (torn-write safety, design §7.5 #4). Empty
+ * lines (a bare "\n") produce no span but are still consumed.
+ */
+export declare function splitCompleteLines(buf: Buffer, baseOffset: number): SplitResult;
+//# sourceMappingURL=fileIdentity.d.ts.map

package/dist/utils/fileIdentity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fileIdentity.d.ts","sourceRoot":"","sources":["../../src/utils/fileIdentity.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,IAAI,CAAC;AAEhC;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,IAAI,CAAC,KAAK,EAAE,KAAK,GAAG,KAAK,CAAC,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,MAAM,CAIzF;AAED,MAAM,WAAW,QAAQ;IACvB,iEAAiE;IACjE,UAAU,EAAE,MAAM,CAAC;IACnB,oEAAoE;IACpE,UAAU,EAAE,MAAM,CAAC;IACnB,gDAAgD;IAChD,IAAI,EAAE,MAAM,CAAC;CACd;AAED,MAAM,WAAW,WAAW;IAC1B,KAAK,EAAE,QAAQ,EAAE,CAAC;IAClB;;;;;OAKG;IACH,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,WAAW,CAoB/E"}

package/dist/utils/isScannedSnapshotStale.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Decide whether a scanned conversation snapshot is stale relative to the
+ * JSONL on disk. The scanner memoizes both its metadata index and parsed
+ * conversations for the server's lifetime, so a conversation that grows after
+ * the initial scan keeps serving the startup snapshot from
+ * `/api/conversations/{id}`. We compare the file's mtime against the
+ * snapshot's last-activity timestamp to detect that drift.
+ *
+ * Returns true when the file is meaningfully newer than the snapshot (a
+ * re-scan is warranted). Returns false when the snapshot is current, when the
+ * snapshot timestamp is unparseable (nothing to compare against — leave it),
+ * or when mtime is null (stat failed — don't churn the index on a transient
+ * read error).
+ */
+export declare function isScannedSnapshotStale(snapshotTimestamp: string | null | undefined, fileMtimeMs: number | null): boolean;
+//# sourceMappingURL=isScannedSnapshotStale.d.ts.map

package/dist/utils/isScannedSnapshotStale.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isScannedSnapshotStale.d.ts","sourceRoot":"","sources":["../../src/utils/isScannedSnapshotStale.ts"],"names":[],"mappings":"AASA;;;;;;;;;;;;;GAaG;AACH,wBAAgB,sBAAsB,CACpC,iBAAiB,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,EAC5C,WAAW,EAAE,MAAM,GAAG,IAAI,GACzB,OAAO,CAKT"}

package/dist/utils/scanProgressThrottle.d.ts

@@ -0,0 +1,12 @@
+/**
+ * The scanner fires onProgress once per file, so a large scan would otherwise
+ * broadcast thousands of scan_progress WebSocket frames. This throttle collapses
+ * them to at most one per whole-percent step, plus a guaranteed final frame when
+ * the scan completes (scanned === total). Caps frames at ~101 regardless of the
+ * file count, while always delivering the terminal 100% update.
+ *
+ * Returns a predicate: call it with each (scanned, total) tick; it returns true
+ * when that tick should be broadcast. Stateful — create one per scan.
+ */
+export declare function createScanProgressThrottle(): (scanned: number, total: number) => boolean;
+//# sourceMappingURL=scanProgressThrottle.d.ts.map

package/dist/utils/scanProgressThrottle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scanProgressThrottle.d.ts","sourceRoot":"","sources":["../../src/utils/scanProgressThrottle.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,wBAAgB,0BAA0B,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,KAAK,OAAO,CAoBxF"}

package/dist/version.d.ts

@@ -0,0 +1,3 @@
+export declare function getVersion(): string;
+export declare function resetVersionCache(): void;
+//# sourceMappingURL=version.d.ts.map

package/dist/version.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"version.d.ts","sourceRoot":"","sources":["../src/version.ts"],"names":[],"mappings":"AAuBA,wBAAgB,UAAU,IAAI,MAAM,CAInC;AAGD,wBAAgB,iBAAiB,IAAI,IAAI,CAExC"}

package/dist/ws-hub.d.ts

@@ -0,0 +1,15 @@
+import type { WebSocket } from "ws";
+import type { WSMessage } from "./types";
+export declare class WSHub {
+    private clients;
+    private pingTimer;
+    private pongTimers;
+    addClient(ws: WebSocket): void;
+    broadcast(message: WSMessage): void;
+    broadcastToClients(clients: Iterable<WebSocket>, message: WSMessage): void;
+    unicast(ws: WebSocket, message: WSMessage): void;
+    get connectionCount(): number;
+    dispose(): void;
+    private startPing;
+}
+//# sourceMappingURL=ws-hub.d.ts.map

package/dist/ws-hub.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ws-hub.d.ts","sourceRoot":"","sources":["../src/ws-hub.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,IAAI,CAAC;AACpC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AAOzC,qBAAa,KAAK;IAChB,OAAO,CAAC,OAAO,CAAwB;IACvC,OAAO,CAAC,SAAS,CAA+C;IAEhE,OAAO,CAAC,UAAU,CAAuD;IAEzE,SAAS,CAAC,EAAE,EAAE,SAAS,GAAG,IAAI,CAgC7B;IAED,SAAS,CAAC,OAAO,EAAE,SAAS,GAAG,IAAI,CAmBlC;IAMD,kBAAkB,CAAC,OAAO,EAAE,QAAQ,CAAC,SAAS,CAAC,EAAE,OAAO,EAAE,SAAS,GAAG,IAAI,CAazE;IAED,OAAO,CAAC,EAAE,EAAE,SAAS,EAAE,OAAO,EAAE,SAAS,GAAG,IAAI,CAQ/C;IAED,IAAI,eAAe,IAAI,MAAM,CAE5B;IAED,OAAO,IAAI,IAAI,CAuBd;IAED,OAAO,CAAC,SAAS;CAsBlB"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@threadbase-sh/streamer",
-  "version": "1.62.0",
+  "version": "1.64.0",
   "description": "PTY session management, WebSocket streaming, and REST API server for Claude Code conversations",
   "license": "MIT",
   "author": "Ronen Mars",
@@ -46,7 +46,7 @@
     "node": ">=22 <25"
   },
   "scripts": {
-    "build": "tsup && node -e \"const{cpSync}=require('fs');cpSync('src/db/migrations','dist/migrations',{recursive:true});cpSync('src/db/runtime-migrations','dist/runtime-migrations',{recursive:true});cpSync('src/db/pg-migrations','dist/pg-migrations',{recursive:true})\"",
+    "build": "tsup && tsc -p tsconfig.build.json && node -e \"const{cpSync}=require('fs');cpSync('src/db/migrations','dist/migrations',{recursive:true});cpSync('src/db/runtime-migrations','dist/runtime-migrations',{recursive:true});cpSync('src/db/pg-migrations','dist/pg-migrations',{recursive:true})\"",
     "dev": "tsup --watch",
     "dev:verbose": "npm run build && mkdir -p ~/.threadbase/logs && node dist/cli.cjs serve --verbose 2>&1 | tee -a ~/.threadbase/logs/dev.log",
     "preinstall": "node scripts/check-node-version.mjs --warn && node scripts/check-native-abi.mjs --warn",
@@ -138,7 +138,7 @@
     "semantic-release": "^25.0.5",
     "tsup": "^8.0.0",
     "tsx": "^4.21.0",
-    "typescript": "^6.0.3",
+    "typescript": "^7.0.2",
     "vitest": "^4.1.10"
   },
   "overrides": {
@@ -147,7 +147,6 @@
     }
   },
   "allowScripts": {
-    "better-sqlite3": true,
     "node-pty": true
   }
 }