@threadbase-sh/streamer 1.62.0 → 1.64.0

package/dist/services/backup/backup.d.ts

@@ -0,0 +1,103 @@
+/**
+ * Metadata export and restore (C9).
+ *
+ * Threadbase owns very little durable state, and knowing exactly which parts
+ * matter is the whole design:
+ *
+ *  - **Provider history** (`~/.claude/projects/*.jsonl`, Codex rollouts) is the
+ *    authoritative record of every conversation, and it is NOT ours. It is
+ *    written by the provider CLIs and survives independently of this server.
+ *    Exporting it would duplicate gigabytes of data the user already has, in a
+ *    format we do not control.
+ *  - **Threadbase metadata** (the `projects` table: stable project ids,
+ *    names, and their mapping to paths) is ours, is small, and cannot be
+ *    reconstructed — a fresh scan invents new project ids, breaking every
+ *    deep link and per-project setting that referenced the old ones.
+ *  - **The cache** (conversation metadata, tails, offset index) is derived
+ *    entirely from provider history and is rebuilt by scanning. Exporting it
+ *    would bloat a backup with data that regenerates itself.
+ *
+ * So an export carries metadata only, and the restore path is explicit that
+ * conversations come back by rescanning provider history rather than from the
+ * archive.
+ *
+ * Credentials are never exported by default. The API key is a live credential
+ * whose disclosure grants full control of the server; a backup file gets copied
+ * to cloud storage, pasted into issues, and emailed around.
+ */
+export declare const BACKUP_FORMAT_VERSION = 1;
+export interface BackupProject {
+    id: string;
+    path: string;
+    name: string | null;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface BackupManifest {
+    formatVersion: number;
+    createdAt: string;
+    streamerVersion: string;
+    /** Identity of the machine this was taken from, for path-remap decisions. */
+    sourceHost: string;
+    /**
+     * True when the operator explicitly opted into including secrets. Recorded so
+     * a restore can warn, and so an archive's sensitivity is self-describing
+     * rather than inferred.
+     */
+    includesSecrets: boolean;
+    counts: {
+        projects: number;
+    };
+}
+export interface BackupArchive {
+    manifest: BackupManifest;
+    projects: BackupProject[];
+}
+export declare class BackupError extends Error {
+    readonly code: string;
+    constructor(message: string, code: string);
+}
+/**
+ * Validate an archive before any of it is applied.
+ *
+ * Restore is destructive in the sense that it rewrites project identity, so a
+ * malformed archive must be rejected whole rather than applied halfway. This
+ * checks shape and version up front; the caller applies inside a transaction.
+ */
+export declare function validateArchive(input: unknown): BackupArchive;
+/**
+ * Rewrite project paths from one machine's layout to another's.
+ *
+ * A backup restored onto a different machine — or the same machine after a home
+ * directory move — carries paths that no longer exist. Without remapping, every
+ * project points at nothing and the restore is useless.
+ *
+ * Longest-prefix wins, so a more specific rule beats a general one. Paths that
+ * match no rule are left untouched rather than mangled.
+ */
+export declare function remapPaths(projects: BackupProject[], rules: ReadonlyArray<{
+    from: string;
+    to: string;
+}>): BackupProject[];
+/**
+ * Classify how each incoming project relates to what already exists.
+ *
+ * Returned rather than applied so the caller can show the user what a restore
+ * would do before doing it — a restore that silently rewrites project identity
+ * is one the user cannot review.
+ */
+export interface RestorePlan {
+    create: BackupProject[];
+    /** Same id, different path — the machine-move case. */
+    update: BackupProject[];
+    /** Path already claimed by a DIFFERENT id. Requires an explicit decision. */
+    conflict: Array<{
+        incoming: BackupProject;
+        existingId: string;
+    }>;
+}
+export declare function planRestore(incoming: BackupProject[], existing: ReadonlyArray<{
+    id: string;
+    path: string;
+}>): RestorePlan;
+//# sourceMappingURL=backup.d.ts.map

package/dist/services/backup/backup.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"backup.d.ts","sourceRoot":"","sources":["../../../src/services/backup/backup.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAEH,eAAO,MAAM,qBAAqB,IAAI,CAAC;AAEvC,MAAM,WAAW,aAAa;IAC5B,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IACpB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,cAAc;IAC7B,aAAa,EAAE,MAAM,CAAC;IACtB,SAAS,EAAE,MAAM,CAAC;IAClB,eAAe,EAAE,MAAM,CAAC;IACxB,6EAA6E;IAC7E,UAAU,EAAE,MAAM,CAAC;IACnB;;;;OAIG;IACH,eAAe,EAAE,OAAO,CAAC;IACzB,MAAM,EAAE;QAAE,QAAQ,EAAE,MAAM,CAAA;KAAE,CAAC;CAC9B;AAED,MAAM,WAAW,aAAa;IAC5B,QAAQ,EAAE,cAAc,CAAC;IACzB,QAAQ,EAAE,aAAa,EAAE,CAAC;CAC3B;AAED,qBAAa,WAAY,SAAQ,KAAK;IAGlC,QAAQ,CAAC,IAAI,EAAE,MAAM;IAFvB,YACE,OAAO,EAAE,MAAM,EACN,IAAI,EAAE,MAAM,EAGtB;CACF;AAED;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,OAAO,GAAG,aAAa,CA2C7D;AAED;;;;;;;;;GASG;AACH,wBAAgB,UAAU,CACxB,QAAQ,EAAE,aAAa,EAAE,EACzB,KAAK,EAAE,aAAa,CAAC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAA;CAAE,CAAC,GACjD,aAAa,EAAE,CAOjB;AAED;;;;;;GAMG;AACH,MAAM,WAAW,WAAW;IAC1B,MAAM,EAAE,aAAa,EAAE,CAAC;IACxB,uDAAuD;IACvD,MAAM,EAAE,aAAa,EAAE,CAAC;IACxB,6EAA6E;IAC7E,QAAQ,EAAE,KAAK,CAAC;QAAE,QAAQ,EAAE,aAAa,CAAC;QAAC,UAAU,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CAClE;AAED,wBAAgB,WAAW,CACzB,QAAQ,EAAE,aAAa,EAAE,EACzB,QAAQ,EAAE,aAAa,CAAC;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC,GACpD,WAAW,CAuBb"}

package/dist/services/cache/cacheMetadata.d.ts

@@ -0,0 +1,8 @@
+import type { CacheMetadataKey, CacheMetadataRepository } from "../../db/repositories/cacheMetadata.repository";
+/**
+ * Functional accessors over the cache_metadata table. Repositories give us
+ * the SQL surface; these helpers give us the verbs the services use.
+ */
+export declare function getCacheMetadata(repo: CacheMetadataRepository, key: CacheMetadataKey): string | null;
+export declare function setCacheMetadata(repo: CacheMetadataRepository, key: CacheMetadataKey, value: string): void;
+//# sourceMappingURL=cacheMetadata.d.ts.map

package/dist/services/cache/cacheMetadata.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cacheMetadata.d.ts","sourceRoot":"","sources":["../../../src/services/cache/cacheMetadata.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,gBAAgB,EAChB,uBAAuB,EACxB,MAAM,gDAAgD,CAAC;AAExD;;;GAGG;AACH,wBAAgB,gBAAgB,CAC9B,IAAI,EAAE,uBAAuB,EAC7B,GAAG,EAAE,gBAAgB,GACpB,MAAM,GAAG,IAAI,CAEf;AAED,wBAAgB,gBAAgB,CAC9B,IAAI,EAAE,uBAAuB,EAC7B,GAAG,EAAE,gBAAgB,EACrB,KAAK,EAAE,MAAM,GACZ,IAAI,CAEN"}

package/dist/services/cache-integrity/alertStore.d.ts

@@ -0,0 +1,24 @@
+/** One missing conversation the alert covers. */
+export interface MissingEntry {
+    id: string;
+    filePath: string;
+    title: string | null;
+    tailed: boolean;
+}
+export interface PendingAlert {
+    fingerprint: string;
+    severity: "high" | "low";
+    detectedAt: string;
+    missingCount: number;
+    totalRows: number;
+    backupPath?: string;
+    /** Capped at 1000 entries in the persisted file. */
+    missing: MissingEntry[];
+}
+export interface AlertState {
+    pending?: PendingAlert;
+    ignoredIds?: string[];
+}
+export declare function loadAlertState(): AlertState;
+export declare function saveAlertState(state: AlertState): void;
+//# sourceMappingURL=alertStore.d.ts.map

package/dist/services/cache-integrity/alertStore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"alertStore.d.ts","sourceRoot":"","sources":["../../../src/services/cache-integrity/alertStore.ts"],"names":[],"mappings":"AASA,iDAAiD;AACjD,MAAM,WAAW,YAAY;IAC3B,EAAE,EAAE,MAAM,CAAC;IACX,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,MAAM,EAAE,OAAO,CAAC;CACjB;AAED,MAAM,WAAW,YAAY;IAC3B,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,EAAE,MAAM,GAAG,KAAK,CAAC;IACzB,UAAU,EAAE,MAAM,CAAC;IACnB,YAAY,EAAE,MAAM,CAAC;IACrB,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,oDAAoD;IACpD,OAAO,EAAE,YAAY,EAAE,CAAC;CACzB;AAED,MAAM,WAAW,UAAU;IACzB,OAAO,CAAC,EAAE,YAAY,CAAC;IACvB,UAAU,CAAC,EAAE,MAAM,EAAE,CAAC;CACvB;AAOD,wBAAgB,cAAc,IAAI,UAAU,CAO3C;AAED,wBAAgB,cAAc,CAAC,KAAK,EAAE,UAAU,GAAG,IAAI,CAItD"}

package/dist/services/cache-integrity/backup.d.ts

@@ -0,0 +1,8 @@
+import type Database from "better-sqlite3";
+/**
+ * Back up the cache DB to `<cacheDir>/backups/cache-<timestamp>.db`, then prune
+ * all but the newest THREADBASE_CACHE_BACKUP_RETAIN backups. Returns the path
+ * of the backup just created.
+ */
+export declare function backupCacheDb(db: Database.Database, cacheDir: string): Promise<string>;
+//# sourceMappingURL=backup.d.ts.map

package/dist/services/cache-integrity/backup.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"backup.d.ts","sourceRoot":"","sources":["../../../src/services/cache-integrity/backup.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,QAAQ,MAAM,gBAAgB,CAAC;AAoB3C;;;;GAIG;AACH,wBAAsB,aAAa,CAAC,EAAE,EAAE,QAAQ,CAAC,QAAQ,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAoB5F"}

package/dist/services/cache-integrity/cacheIntegrityMonitor.d.ts

@@ -0,0 +1,71 @@
+import type { ConversationCache, ScannerMeta } from "../../conversation-cache";
+import type { Logger } from "../../logger";
+import type { CacheAlertResolveAction, WSMessage } from "../../types";
+import type { WSHub } from "../../ws-hub";
+import { type PendingAlert } from "./alertStore";
+export type ResolveAction = CacheAlertResolveAction;
+/** The `cache_alert` WS variant, narrowed from the WSMessage union. */
+export type CacheAlertWsMessage = Extract<WSMessage, {
+    type: "cache_alert";
+}>;
+export type ResolveResult = {
+    ok: true;
+    action: ResolveAction;
+    pruned?: number;
+    backupPath?: string;
+} | {
+    alreadyResolved: true;
+} | {
+    conflict: true;
+    currentFingerprint: string;
+};
+export declare class CacheIntegrityMonitor {
+    private readonly cache;
+    private readonly wsHub;
+    private readonly log;
+    private readonly cacheDir;
+    private readonly rescan?;
+    private readonly runDuringReset?;
+    private _pending;
+    private ignoredIds;
+    private deferredUnlinks;
+    private unlinkTimes;
+    constructor(cache: ConversationCache, wsHub: WSHub, log: Logger, cacheDir: string, rescan?: (() => Promise<ScannerMeta[]>) | undefined, runDuringReset?: (<T>(operation: () => Promise<T>) => Promise<T>) | undefined);
+    get pending(): PendingAlert | null;
+    private persist;
+    private classifySeverity;
+    private sampleOf;
+    private buildWsMessage;
+    wsMessage(): CacheAlertWsMessage | null;
+    healthzField(): {
+        severity: "high" | "low";
+        missingCount: number;
+        fingerprint: string;
+        detectedAt: string;
+    } | undefined;
+    /**
+     * Scan the cache for rows whose file is gone, excluding ids the user chose to
+     * ignore. If none remain, clear any stale pending alert and return (the caller
+     * decides whether to run pruneGhostFiles). Otherwise classify severity, persist
+     * the pending record, back up on high severity, and broadcast the alert.
+     */
+    runDetection(detectedAt?: string): Promise<void>;
+    /** Queue an unlink while an alert is pending — the row is not invalidated. */
+    deferUnlink(filePath: string): void;
+    /**
+     * Record a live unlink while NO alert is pending. Crossing the storm threshold
+     * (>= 10 unlinks within 30s) re-triggers detection.
+     */
+    recordUnlink(filePath: string): void;
+    private ensureBackup;
+    private clearPending;
+    private applyDeferredUnlinks;
+    private broadcastResolved;
+    /**
+     * Apply the human's chosen resolution. Idempotent per fingerprint: no pending
+     * alert → alreadyResolved; a different fingerprint → conflict. See the spec's
+     * four-action semantics.
+     */
+    resolve(fingerprint: string, action: ResolveAction, ids?: string[]): Promise<ResolveResult>;
+}
+//# sourceMappingURL=cacheIntegrityMonitor.d.ts.map

package/dist/services/cache-integrity/cacheIntegrityMonitor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cacheIntegrityMonitor.d.ts","sourceRoot":"","sources":["../../../src/services/cache-integrity/cacheIntegrityMonitor.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,iBAAiB,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAC;AAC/E,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AAC3C,OAAO,KAAK,EAAE,uBAAuB,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AACtE,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,cAAc,CAAC;AAC1C,OAAO,EAIL,KAAK,YAAY,EAElB,MAAM,cAAc,CAAC;AAGtB,MAAM,MAAM,aAAa,GAAG,uBAAuB,CAAC;AAEpD,uEAAuE;AACvE,MAAM,MAAM,mBAAmB,GAAG,OAAO,CAAC,SAAS,EAAE;IAAE,IAAI,EAAE,aAAa,CAAA;CAAE,CAAC,CAAC;AAE9E,MAAM,MAAM,aAAa,GACrB;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,MAAM,EAAE,aAAa,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IAAC,UAAU,CAAC,EAAE,MAAM,CAAA;CAAE,GACzE;IAAE,eAAe,EAAE,IAAI,CAAA;CAAE,GACzB;IAAE,QAAQ,EAAE,IAAI,CAAC;IAAC,kBAAkB,EAAE,MAAM,CAAA;CAAE,CAAC;AAkBnD,qBAAa,qBAAqB;IAO9B,OAAO,CAAC,QAAQ,CAAC,KAAK;IACtB,OAAO,CAAC,QAAQ,CAAC,KAAK;IACtB,OAAO,CAAC,QAAQ,CAAC,GAAG;IACpB,OAAO,CAAC,QAAQ,CAAC,QAAQ;IAGzB,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAC;IACxB,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAC;IAblC,OAAO,CAAC,QAAQ,CAAsB;IACtC,OAAO,CAAC,UAAU,CAAc;IAChC,OAAO,CAAC,eAAe,CAAgB;IACvC,OAAO,CAAC,WAAW,CAAgB;IAEnC,YACmB,KAAK,EAAE,iBAAiB,EACxB,KAAK,EAAE,KAAK,EACZ,GAAG,EAAE,MAAM,EACX,QAAQ,EAAE,MAAM,EAGhB,MAAM,CAAC,GAAE,MAAM,OAAO,CAAC,WAAW,EAAE,CAAC,aAAA,EACrC,cAAc,CAAC,GAAE,CAAC,CAAC,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,KAAK,OAAO,CAAC,CAAC,CAAC,aAAA,EAKjF;IAED,IAAI,OAAO,IAAI,YAAY,GAAG,IAAI,CAEjC;IAED,OAAO,CAAC,OAAO;IAYf,OAAO,CAAC,gBAAgB;IAQxB,OAAO,CAAC,QAAQ;IAOhB,OAAO,CAAC,cAAc;IAYtB,SAAS,IAAI,mBAAmB,GAAG,IAAI,CAEtC;IAED,YAAY,IACR;QAAE,QAAQ,EAAE,MAAM,GAAG,KAAK,CAAC;QAAC,YAAY,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAA;KAAE,GAC3F,SAAS,CAQZ;IAED;;;;;OAKG;IACG,YAAY,CAAC,UAAU,GAAE,MAAiC,GAAG,OAAO,CAAC,IAAI,CAAC,CA8C/E;IAED,8EAA8E;IAC9E,WAAW,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAElC;IAED;;;OAGG;IACH,YAAY,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAcnC;YAEa,YAAY;IAa1B,OAAO,CAAC,YAAY;IAMpB,OAAO,CAAC,oBAAoB;IAK5B,OAAO,CAAC,iBAAiB;IAIzB;;;;OAIG;IACG,OAAO,CACX,WAAW,EAAE,MAAM,EACnB,MAAM,EAAE,aAAa,EACrB,GAAG,CAAC,EAAE,MAAM,EAAE,GACb,OAAO,CAAC,aAAa,CAAC,CAuFxB;CACF"}

package/dist/services/conversations/conversationWatcher.d.ts

@@ -0,0 +1,99 @@
+import { type LineSpan } from "../../utils/fileIdentity";
+export interface ConversationWatcherEvents {
+    /** Fires once per new newline-terminated line appended to a watched file. */
+    onNewLine?: (filePath: string, line: string) => void;
+    /**
+     * Fires once per chokidar read with ALL new lines from that read, batched.
+     * When set, it REPLACES the per-line onNewLine dispatch for that file —
+     * callers pick one. Lets a burst of appended lines collapse into a single
+     * downstream cache write + WebSocket broadcast.
+     */
+    onNewLines?: (filePath: string, lines: string[]) => void;
+    /**
+     * Like onNewLines but also carries each line's absolute byte span in the
+     * file (for the offset index). Fires ALONGSIDE onNewLines/onNewLine (it does
+     * not replace them) so the cache tail write and the index extend can both
+     * consume the same read. `readFrom` is the absolute byte offset the read
+     * started at; `spans` are complete lines only (a torn trailing line is held
+     * for the next read).
+     */
+    onNewLineSpans?: (filePath: string, spans: LineSpan[], readFrom: number, endOffset: number) => void;
+    /** Fires when chokidar reports an add/change/unlink at the directory level. */
+    onConversationChanged?: (filePath: string) => void | Promise<void>;
+    /** Fires when a tailed file is deleted (per-file watcher unlink event). */
+    onFileDeleted?: (filePath: string) => void;
+    /**
+     * Fires when a tailed file shrank below our read offset (in-place truncation
+     * or replacement by a shorter file). The tail has already reset to byte 0;
+     * the consumer must discard any byte-offset index built for the old content,
+     * which no longer describes this file.
+     */
+    onTruncated?: (filePath: string) => void;
+    /** Reported errors per file. */
+    onError?: (filePath: string, error: Error) => void;
+}
+/**
+ * Chokidar-backed replacement for src/file-watcher.ts.
+ *
+ *   - watch(filePath)      → tail a single JSONL file, emitting onNewLine
+ *                            for each appended line.
+ *   - watchDirectory(dir)  → mark cache dirty on add/change/unlink events
+ *                            for any file inside the directory.
+ *
+ * Per the refactor plan, file watching is an OPTIMIZATION; correctness
+ * still relies on refresh=1 / the latest HDD conversation id check.
+ */
+export declare class ConversationWatcher {
+    private files;
+    private directories;
+    private onNewLine;
+    private onNewLines;
+    private onNewLineSpans;
+    private onConversationChanged;
+    private onFileDeleted;
+    private onTruncated;
+    private onError;
+    constructor(events?: ConversationWatcherEvents);
+    watch(filePath: string): void;
+    unwatch(filePath: string): void;
+    /**
+     * Re-drive the tail read for a file that's already being tailed. A per-file
+     * chokidar handle can die silently (fs.watch stops firing after inode churn)
+     * while the coarser directory watcher keeps reporting changes — calling this
+     * from the directory-event path makes the tail self-healing. Reads are
+     * offset-based and coalesced, so a redundant poke after a normal change
+     * event is a cheap stat + no-op. Returns false for untailed paths.
+     */
+    poke(filePath: string): boolean;
+    /**
+     * Watch a directory of conversation JSONL files. Fires
+     * onConversationChanged for any add/change/unlink event so the caller
+     * can mark the cache dirty without scanning everything immediately.
+     *
+     * **This costs one OS watch handle per file under `directory`, not one per
+     * directory.** chokidar recurses the tree and registers a separate fs.watch
+     * per entry, because a directory watch alone does not report writes to files
+     * inside it — and per-file `change` events are exactly what the caller needs
+     * (they drive poke()'s tail self-heal and the external-tail attach). So the
+     * handle count tracks the size of the conversation corpus on disk, not the
+     * number of live sessions, and it does not shrink until transcripts are
+     * deleted. `ignoreInitial` suppresses the startup *events*, not the walk.
+     *
+     * Measured 2026-08-09 on the live macOS instance: 2131 open .jsonl fds
+     * against 2133 files under the watched roots — 1:1, ~88% of all fds on the
+     * process, at 2.0% of that box's 122 880 per-process ceiling. Comfortable
+     * there. **Linux is the tight one**: these are inotify watches billed to the
+     * per-user `max_user_watches`, which can be 8192 and is shared with every
+     * other watcher the user runs. Exhaustion surfaces as ENOSPC on the `error`
+     * event — which is why server.ts wires onError rather than leaving it unset.
+     *
+     * Before trading handles for a bound here, note the regression it invites: a
+     * conversation excluded from the walk (by age or by an LRU cap) is one whose
+     * external appends produce no event at all, and that failure is silent.
+     */
+    watchDirectory(directory: string): void;
+    unwatchDirectory(directory: string): void;
+    dispose(): void;
+    private readNewLines;
+}
+//# sourceMappingURL=conversationWatcher.d.ts.map

package/dist/services/conversations/conversationWatcher.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"conversationWatcher.d.ts","sourceRoot":"","sources":["../../../src/services/conversations/conversationWatcher.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,KAAK,QAAQ,EAAsB,MAAM,0BAA0B,CAAC;AAE7E,MAAM,WAAW,yBAAyB;IACxC,6EAA6E;IAC7E,SAAS,CAAC,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IACrD;;;;;OAKG;IACH,UAAU,CAAC,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,IAAI,CAAC;IACzD;;;;;;;OAOG;IACH,cAAc,CAAC,EAAE,CACf,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,QAAQ,EAAE,EACjB,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,MAAM,KACd,IAAI,CAAC;IACV,+EAA+E;IAC/E,qBAAqB,CAAC,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACnE,2EAA2E;IAC3E,aAAa,CAAC,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,IAAI,CAAC;IAC3C;;;;;OAKG;IACH,WAAW,CAAC,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,IAAI,CAAC;IACzC,gCAAgC;IAChC,OAAO,CAAC,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,KAAK,IAAI,CAAC;CACpD;AAiBD;;;;;;;;;;GAUG;AACH,qBAAa,mBAAmB;IAC9B,OAAO,CAAC,KAAK,CAAkC;IAC/C,OAAO,CAAC,WAAW,CAAgC;IACnD,OAAO,CAAC,SAAS,CAAyC;IAC1D,OAAO,CAAC,UAAU,CAA0C;IAC5D,OAAO,CAAC,cAAc,CAA8C;IACpE,OAAO,CAAC,qBAAqB,CAAqD;IAClF,OAAO,CAAC,aAAa,CAA6C;IAClE,OAAO,CAAC,WAAW,CAA2C;IAC9D,OAAO,CAAC,OAAO,CAAuC;IAEtD,YAAY,MAAM,GAAE,yBAA8B,EAQjD;IAED,KAAK,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAuC5B;IAED,OAAO,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAM9B;IAED;;;;;;;OAOG;IACH,IAAI,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAO9B;IAED;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACH,cAAc,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CAmBtC;IAED,gBAAgB,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CAKxC;IAED,OAAO,IAAI,IAAI,CAGd;YAEa,YAAY;CAyF3B"}

package/dist/services/conversations/findSearchTarget.d.ts

@@ -0,0 +1,30 @@
+export interface SearchTargetMatch {
+    messageIndex: number;
+    uuid: string | null;
+    snippet: string;
+    /**
+     * All matching message indexes, ascending. When any plain-text match exists
+     * only text matches are listed (they are the navigable/highlightable ones);
+     * otherwise the thinking/tool fallback matches are. Capped at the LAST
+     * MAX_MATCH_INDEXES entries — navigation starts at the tail-most match.
+     */
+    matchIndexes: number[];
+    /** Uncapped true match count (the "of M" in the client counter). */
+    totalMatches: number;
+}
+export interface SearchableMessage {
+    text?: string;
+    uuid?: string | null;
+    isThinking?: boolean;
+    thinkingContent?: string;
+    metadata?: {
+        toolUseBlocks?: Array<{
+            input?: unknown;
+        }>;
+        toolResults?: Array<{
+            content?: unknown;
+        }>;
+    };
+}
+export declare function findSearchTarget(messages: SearchableMessage[], query: string): SearchTargetMatch | null;
+//# sourceMappingURL=findSearchTarget.d.ts.map

package/dist/services/conversations/findSearchTarget.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"findSearchTarget.d.ts","sourceRoot":"","sources":["../../../src/services/conversations/findSearchTarget.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,iBAAiB;IAChC,YAAY,EAAE,MAAM,CAAC;IACrB,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IACpB,OAAO,EAAE,MAAM,CAAC;IAChB;;;;;OAKG;IACH,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,oEAAoE;IACpE,YAAY,EAAE,MAAM,CAAC;CACtB;AAID,MAAM,WAAW,iBAAiB;IAChC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,EAAE;QACT,aAAa,CAAC,EAAE,KAAK,CAAC;YAAE,KAAK,CAAC,EAAE,OAAO,CAAA;SAAE,CAAC,CAAC;QAC3C,WAAW,CAAC,EAAE,KAAK,CAAC;YAAE,OAAO,CAAC,EAAE,OAAO,CAAA;SAAE,CAAC,CAAC;KAC5C,CAAC;CACH;AA4CD,wBAAgB,gBAAgB,CAC9B,QAAQ,EAAE,iBAAiB,EAAE,EAC7B,KAAK,EAAE,MAAM,GACZ,iBAAiB,GAAG,IAAI,CAqB1B"}

package/dist/services/conversations/isAgentConversation.d.ts

@@ -0,0 +1,8 @@
+export declare const DEFAULT_AGENT_ENTRYPOINTS: ReadonlySet<string>;
+export declare function isAgentLine(line: {
+    entrypoint?: string;
+}, entrypoints?: ReadonlySet<string>): boolean;
+export declare function isAgentFile(filePath: string, entrypoints?: ReadonlySet<string>): boolean;
+export declare function parseAgentEntrypointsEnv(raw: string | undefined): ReadonlySet<string>;
+export declare function clearAgentFileCacheForTests(): void;
+//# sourceMappingURL=isAgentConversation.d.ts.map

package/dist/services/conversations/isAgentConversation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isAgentConversation.d.ts","sourceRoot":"","sources":["../../../src/services/conversations/isAgentConversation.ts"],"names":[],"mappings":"AAUA,eAAO,MAAM,yBAAyB,EAAE,WAAW,CAAC,MAAM,CAAyC,CAAC;AA8BpG,wBAAgB,WAAW,CACzB,IAAI,EAAE;IAAE,UAAU,CAAC,EAAE,MAAM,CAAA;CAAE,EAC7B,WAAW,GAAE,WAAW,CAAC,MAAM,CAA6B,GAC3D,OAAO,CAET;AAED,wBAAgB,WAAW,CACzB,QAAQ,EAAE,MAAM,EAChB,WAAW,GAAE,WAAW,CAAC,MAAM,CAA6B,GAC3D,OAAO,CA0DT;AAID,wBAAgB,wBAAwB,CAAC,GAAG,EAAE,MAAM,GAAG,SAAS,GAAG,WAAW,CAAC,MAAM,CAAC,CAOrF;AAED,wBAAgB,2BAA2B,IAAI,IAAI,CAElD"}

package/dist/services/conversations/pruneAgentConversations.d.ts

@@ -0,0 +1,8 @@
+import type { ConversationCache } from "../../conversation-cache";
+export interface PruneAgentConversationsResult {
+    scanned: number;
+    pruned: number;
+    missing: number;
+}
+export declare function pruneAgentConversations(cache: ConversationCache): PruneAgentConversationsResult;
+//# sourceMappingURL=pruneAgentConversations.d.ts.map

package/dist/services/conversations/pruneAgentConversations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pruneAgentConversations.d.ts","sourceRoot":"","sources":["../../../src/services/conversations/pruneAgentConversations.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAElE,MAAM,WAAW,6BAA6B;IAC5C,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;CACjB;AAKD,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,iBAAiB,GAAG,6BAA6B,CAqB/F"}

package/dist/services/conversations/refreshConversationCache.d.ts

@@ -0,0 +1,27 @@
+import type { ConversationCache } from "../../conversation-cache";
+import type { CacheMetadataRepository } from "../../db/repositories/cacheMetadata.repository";
+import type { ConversationsRepository } from "../../db/repositories/conversations.repository";
+import type { ProjectsRepository } from "../../db/repositories/projects.repository";
+export interface RefreshConversationCacheDeps {
+    cache: ConversationCache;
+    projectsRepo: ProjectsRepository;
+    conversationsRepo: ConversationsRepository;
+    cacheMetadataRepo: CacheMetadataRepository;
+}
+export interface RefreshConversationCacheResult {
+    projectsTouched: number;
+    conversationsBackfilled: number;
+    latestConversationId: string | null;
+}
+/**
+ * After a scanner-driven cache rebuild has run, walk the cache to:
+ *   1. Upsert one project row per unique canonical project_path.
+ *   2. Backfill conversation_meta.project_id for any rows missing it.
+ *   3. Update cache_metadata.last_conversation_id so subsequent freshness
+ *      checks can short-circuit.
+ *
+ * The scanner itself runs in `server.ts` today; this function picks up
+ * after it has populated `conversation_meta`.
+ */
+export declare function refreshConversationCache(deps: RefreshConversationCacheDeps): RefreshConversationCacheResult;
+//# sourceMappingURL=refreshConversationCache.d.ts.map

package/dist/services/conversations/refreshConversationCache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"refreshConversationCache.d.ts","sourceRoot":"","sources":["../../../src/services/conversations/refreshConversationCache.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAClE,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,gDAAgD,CAAC;AAC9F,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,gDAAgD,CAAC;AAC9F,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,2CAA2C,CAAC;AAKpF,MAAM,WAAW,4BAA4B;IAC3C,KAAK,EAAE,iBAAiB,CAAC;IACzB,YAAY,EAAE,kBAAkB,CAAC;IACjC,iBAAiB,EAAE,uBAAuB,CAAC;IAC3C,iBAAiB,EAAE,uBAAuB,CAAC;CAC5C;AAED,MAAM,WAAW,8BAA8B;IAC7C,eAAe,EAAE,MAAM,CAAC;IACxB,uBAAuB,EAAE,MAAM,CAAC;IAChC,oBAAoB,EAAE,MAAM,GAAG,IAAI,CAAC;CACrC;AAED;;;;;;;;;GASG;AACH,wBAAgB,wBAAwB,CACtC,IAAI,EAAE,4BAA4B,GACjC,8BAA8B,CA0ChC"}

package/dist/services/conversations/shouldRefreshProjectsFromHdd.d.ts

@@ -0,0 +1,33 @@
+import type { CacheMetadataRepository } from "../../db/repositories/cacheMetadata.repository";
+import type { ConversationsRepository } from "../../db/repositories/conversations.repository";
+export interface ShouldRefreshOptions {
+    /** Override the disk path checked for drift. Defaults to ~/.claude/projects. */
+    projectsDir?: string;
+    /** Additional project roots (e.g. per-profile `configDir/projects`). */
+    projectsDirs?: string[];
+}
+/**
+ * Newest mtime across a projects root and its immediate child directories.
+ *
+ * POSIX directory mtime updates when direct entries are added/removed/renamed,
+ * not when a file inside a child is appended. Checking one level of children
+ * catches new JSONLs in an existing project without stating every file.
+ */
+export declare function maxProjectsTreeMtimeMs(projectsDir: string): number | null;
+/**
+ * Decide whether the projects/conversations cache needs a refresh.
+ *
+ * Returns true when either:
+ *   1. The cache has orphan rows — conversations with a project_path but no
+ *      project_id. These need a backfill pass to become visible to
+ *      /project-chats (which filters out null project_id).
+ *   2. A watched projects tree on disk has changed since the last scanner pass —
+ *      max(root mtime, child-dir mtimes) is newer than
+ *      cache_metadata.conversations_last_indexed_at. This catches new JSONLs
+ *      that the file watcher missed (including under existing project dirs).
+ *
+ * Appends to existing JSONLs still rely on the directory watcher flipping
+ * scannerStale; this mtime gate does not see in-place file growth.
+ */
+export declare function shouldRefreshProjectsFromHdd(conversationsRepo: ConversationsRepository, cacheMetadataRepo: CacheMetadataRepository, opts?: ShouldRefreshOptions): boolean;
+//# sourceMappingURL=shouldRefreshProjectsFromHdd.d.ts.map

package/dist/services/conversations/shouldRefreshProjectsFromHdd.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shouldRefreshProjectsFromHdd.d.ts","sourceRoot":"","sources":["../../../src/services/conversations/shouldRefreshProjectsFromHdd.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,gDAAgD,CAAC;AAC9F,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,gDAAgD,CAAC;AAK9F,MAAM,WAAW,oBAAoB;IACnC,gFAAgF;IAChF,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,wEAAwE;IACxE,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;CACzB;AAED;;;;;;GAMG;AACH,wBAAgB,sBAAsB,CAAC,WAAW,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAuBzE;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,4BAA4B,CAC1C,iBAAiB,EAAE,uBAAuB,EAC1C,iBAAiB,EAAE,uBAAuB,EAC1C,IAAI,GAAE,oBAAyB,GAC9B,OAAO,CAwBT"}

package/dist/services/diagnostics/diagnostics.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Diagnostics contract (C6).
+ *
+ * `/healthz` answers one question — is the process up — and returns
+ * `{ ok, version }`. When a user's session will not start, that tells them
+ * nothing about why: the provider CLI may be missing, the database may have
+ * failed to migrate, the PTY subsystem may be unavailable, or the clock may be
+ * skewed enough to break token validation.
+ *
+ * This produces a structured report where each subsystem is checked
+ * independently, so one failure never masks another, and every failure carries a
+ * STABLE remediation code the client can map to instructions without parsing
+ * English.
+ *
+ * Redaction is a contract requirement, not a nicety: this endpoint is designed
+ * to be copied into a bug report. See `redactPath` below.
+ */
+export declare const DIAGNOSTICS_CONTRACT_VERSION = 1;
+export type CheckStatus = "ok" | "degraded" | "failed" | "unknown";
+/**
+ * Stable, machine-readable remediation identifiers.
+ *
+ * Clients map these to localized instructions, so they are part of the contract:
+ * renaming one is a breaking change. New codes may be added; existing ones must
+ * keep their meaning.
+ */
+export type RemediationCode = "PROVIDER_NOT_INSTALLED" | "PROVIDER_VERSION_UNVERIFIED" | "DB_UNAVAILABLE" | "DB_MIGRATION_PENDING" | "PTY_UNAVAILABLE" | "CACHE_DEGRADED" | "CLOCK_SKEWED" | "FS_SCOPE_MISSING" | "NONE";
+export interface DiagnosticCheck {
+    /** Stable identifier for the subsystem, e.g. "database". */
+    id: string;
+    status: CheckStatus;
+    /** Human-readable summary. Never contains secrets or full paths. */
+    summary: string;
+    remediation: RemediationCode;
+    /** Structured, redacted detail. Optional. */
+    detail?: Record<string, string | number | boolean | null>;
+}
+export interface DiagnosticsReport {
+    contractVersion: number;
+    generatedAt: string;
+    /** Worst status across all checks — a single field for a client to branch on. */
+    overall: CheckStatus;
+    checks: DiagnosticCheck[];
+}
+/**
+ * Reduce a filesystem path to its last two segments.
+ *
+ * A full path leaks the user's home directory layout, their username, and often
+ * client or project names. The tail is enough to recognize *which* directory is
+ * meant when you already know your own machine, which is all a diagnostic needs.
+ */
+export declare function redactPath(path: string | null | undefined): string | null;
+/** Worst status wins, so a single failure is never hidden by surrounding successes. */
+export declare function worstStatus(checks: DiagnosticCheck[]): CheckStatus;
+/**
+ * Clock skew against a trusted reference, in milliseconds.
+ *
+ * Matters because pair tokens carry a 180-second TTL: a device whose clock is
+ * far enough off will have every pairing attempt rejected as expired, with no
+ * indication that time is the cause.
+ */
+export declare const CLOCK_SKEW_WARN_MS = 60000;
+export declare function clockSkewCheck(localNow: number, referenceNow: number | null): DiagnosticCheck;
+export declare function buildReport(checks: DiagnosticCheck[], now?: Date): DiagnosticsReport;
+export declare function redactValue<T>(value: T): T;
+//# sourceMappingURL=diagnostics.d.ts.map

package/dist/services/diagnostics/diagnostics.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"diagnostics.d.ts","sourceRoot":"","sources":["../../../src/services/diagnostics/diagnostics.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,eAAO,MAAM,4BAA4B,IAAI,CAAC;AAE9C,MAAM,MAAM,WAAW,GAAG,IAAI,GAAG,UAAU,GAAG,QAAQ,GAAG,SAAS,CAAC;AAEnE;;;;;;GAMG;AACH,MAAM,MAAM,eAAe,GACvB,wBAAwB,GACxB,6BAA6B,GAC7B,gBAAgB,GAChB,sBAAsB,GACtB,iBAAiB,GACjB,gBAAgB,GAChB,cAAc,GACd,kBAAkB,GAClB,MAAM,CAAC;AAEX,MAAM,WAAW,eAAe;IAC9B,4DAA4D;IAC5D,EAAE,EAAE,MAAM,CAAC;IACX,MAAM,EAAE,WAAW,CAAC;IACpB,oEAAoE;IACpE,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,eAAe,CAAC;IAC7B,6CAA6C;IAC7C,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,IAAI,CAAC,CAAC;CAC3D;AAED,MAAM,WAAW,iBAAiB;IAChC,eAAe,EAAE,MAAM,CAAC;IACxB,WAAW,EAAE,MAAM,CAAC;IACpB,iFAAiF;IACjF,OAAO,EAAE,WAAW,CAAC;IACrB,MAAM,EAAE,eAAe,EAAE,CAAC;CAC3B;AAED;;;;;;GAMG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAAG,MAAM,GAAG,IAAI,CAKzE;AAED,uFAAuF;AACvF,wBAAgB,WAAW,CAAC,MAAM,EAAE,eAAe,EAAE,GAAG,WAAW,CAMlE;AAED;;;;;;GAMG;AACH,eAAO,MAAM,kBAAkB,QAAS,CAAC;AAEzC,wBAAgB,cAAc,CAAC,QAAQ,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,GAAG,IAAI,GAAG,eAAe,CA6B7F;AAED,wBAAgB,WAAW,CAAC,MAAM,EAAE,eAAe,EAAE,EAAE,GAAG,GAAE,IAAiB,GAAG,iBAAiB,CAOhG;AAcD,wBAAgB,WAAW,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,CAAC,CAY1C"}

package/dist/services/projectChats/deriveProjectChatTitle.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Resolve a user-visible title for a ProjectChat row.
+ *
+ * Mobile (ConversationListItem.tsx) renders `title?.trim() || pathSuffix ||
+ * ''`, so when title and projectPath are both blank the row appears empty.
+ * This helper produces a non-empty title for every input by falling back
+ * through title → slug-ish projectName → path suffix → short id.
+ */
+export declare function deriveProjectChatTitle(input: {
+    title: string | null | undefined;
+    projectName: string | null | undefined;
+    projectPath: string | null | undefined;
+    id: string;
+}): string;
+//# sourceMappingURL=deriveProjectChatTitle.d.ts.map

package/dist/services/projectChats/deriveProjectChatTitle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deriveProjectChatTitle.d.ts","sourceRoot":"","sources":["../../../src/services/projectChats/deriveProjectChatTitle.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,wBAAgB,sBAAsB,CAAC,KAAK,EAAE;IAC5C,KAAK,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC;IACjC,WAAW,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC;IACvC,WAAW,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC;IACvC,EAAE,EAAE,MAAM,CAAC;CACZ,GAAG,MAAM,CAUT"}

package/dist/services/projects/ensureProjectsForConversations.d.ts

@@ -0,0 +1,15 @@
+import type { ProjectsRepository } from "../../db/repositories/projects.repository";
+export interface ConversationLikeForProjects {
+    id: string;
+    projectPath: string | null | undefined;
+    createdAt?: string | null;
+    latestMessageAt?: string | null;
+}
+/**
+ * Group cached conversations by their canonical project path, find the
+ * latest conversation per project, then upsert one project row per unique
+ * path. Returns a map from canonical path → projectId so callers can
+ * backfill conversation/session project_id columns afterwards.
+ */
+export declare function ensureProjectsForConversations(repo: ProjectsRepository, conversations: ConversationLikeForProjects[]): Map<string, string>;
+//# sourceMappingURL=ensureProjectsForConversations.d.ts.map

package/dist/services/projects/ensureProjectsForConversations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ensureProjectsForConversations.d.ts","sourceRoot":"","sources":["../../../src/services/projects/ensureProjectsForConversations.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,2CAA2C,CAAC;AAIpF,MAAM,WAAW,2BAA2B;IAC1C,EAAE,EAAE,MAAM,CAAC;IACX,WAAW,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC;IACvC,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,eAAe,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CACjC;AAED;;;;;GAKG;AACH,wBAAgB,8BAA8B,CAC5C,IAAI,EAAE,kBAAkB,EACxB,aAAa,EAAE,2BAA2B,EAAE,GAC3C,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CA2BrB"}