clauderipple 0.9.5 → 0.11.0

package/dist/remote/src/sidebar-storage.js

@@ -0,0 +1,211 @@
+// Read Chromium Local Storage without opening LevelDB (opening it takes a lock and writes).
+// Only the requested key escapes this boundary. SST blocks use LevelDB's raw Snappy format.
+import fs from "node:fs";
+import path from "node:path";
+function varint(b, cursor) {
+    let n = 0, scale = 1;
+    for (let i = 0; i < 8; i++) {
+        if (cursor.at >= b.length)
+            throw new Error("Truncated LevelDB varint");
+        const v = b[cursor.at++];
+        n += (v & 127) * scale;
+        if (!(v & 128))
+            return n;
+        scale *= 128;
+    }
+    throw new Error("Invalid LevelDB varint");
+}
+function slice(b, c) {
+    const size = varint(b, c), end = c.at + size;
+    if (end > b.length)
+        throw new Error("Truncated LevelDB value");
+    const value = b.subarray(c.at, end);
+    c.at = end;
+    return value;
+}
+function snappy(b) {
+    const c = { at: 0 }, size = varint(b, c);
+    if (size > 16 * 1024 * 1024)
+        throw new Error("Oversized LevelDB block");
+    const out = Buffer.alloc(size);
+    let at = 0;
+    while (c.at < b.length) {
+        const tag = b[c.at++], kind = tag & 3;
+        let length = (tag >>> 2) + 1, offset = 0;
+        if (kind === 0) {
+            if (length >= 61) {
+                const bytes = length - 60;
+                if (c.at + bytes > b.length)
+                    throw new Error("Truncated Snappy literal");
+                length = b.readUIntLE(c.at, bytes) + 1;
+                c.at += bytes;
+            }
+            if (c.at + length > b.length || at + length > size)
+                throw new Error("Invalid Snappy literal");
+            b.copy(out, at, c.at, c.at + length);
+            c.at += length;
+        }
+        else {
+            const bytes = kind === 1 ? 1 : kind === 2 ? 2 : 4;
+            if (c.at + bytes > b.length)
+                throw new Error("Truncated Snappy copy");
+            offset = b.readUIntLE(c.at, bytes);
+            c.at += bytes;
+            if (kind === 1) {
+                offset += (tag & 224) << 3;
+                length = 4 + ((tag >>> 2) & 7);
+            }
+            if (!offset || offset > at || at + length > size)
+                throw new Error("Invalid Snappy copy");
+            for (let i = 0; i < length; i++)
+                out[at + i] = out[at + i - offset];
+        }
+        at += length;
+    }
+    if (at !== size)
+        throw new Error("Incomplete Snappy block");
+    return out;
+}
+function entries(b, visit) {
+    if (b.length < 4)
+        throw new Error("Invalid LevelDB block");
+    const end = b.length - 4 - b.readUInt32LE(b.length - 4) * 4;
+    let key = Buffer.alloc(0);
+    const c = { at: 0 };
+    while (c.at < end) {
+        const shared = varint(b, c), suffix = varint(b, c), size = varint(b, c);
+        if (shared > key.length || c.at + suffix + size > end)
+            throw new Error("Invalid LevelDB entry");
+        key = Buffer.concat([key.subarray(0, shared), b.subarray(c.at, c.at + suffix)]);
+        c.at += suffix;
+        const value = b.subarray(c.at, c.at + size);
+        c.at += size;
+        visit(key, value);
+    }
+}
+function table(b, visit) {
+    if (b.length < 48 || b.readBigUInt64LE(b.length - 8) !== 0xdb4775248b80fb57n)
+        throw new Error("Invalid LevelDB table");
+    const block = (handle) => {
+        const c = { at: 0 }, offset = varint(handle, c), size = varint(handle, c);
+        if (offset + size + 5 > b.length)
+            throw new Error("Truncated LevelDB block");
+        const data = b.subarray(offset, offset + size), compression = b[offset + size];
+        if (compression === 0)
+            return data;
+        if (compression === 1)
+            return snappy(data);
+        throw new Error("Unsupported LevelDB compression");
+    };
+    const footer = { at: b.length - 48 };
+    varint(b, footer);
+    varint(b, footer); // metaindex handle
+    entries(block(b.subarray(footer.at)), (_key, handle) => entries(block(handle), (key, value) => {
+        if (key.length < 8)
+            throw new Error("Invalid LevelDB internal key");
+        const tag = key.readBigUInt64LE(key.length - 8);
+        visit(key.subarray(0, -8), (tag & 255n) === 0n ? Buffer.alloc(0) : value, tag >> 8n);
+    }));
+}
+function wal(b, visit) {
+    let chunks = [];
+    const batch = (data) => {
+        if (data.length < 12)
+            throw new Error("Invalid LevelDB batch");
+        const sequence = data.readBigUInt64LE(), count = data.readUInt32LE(8), c = { at: 12 };
+        for (let i = 0; i < count; i++) {
+            const type = data[c.at++];
+            if (type !== 0 && type !== 1)
+                throw new Error("Invalid LevelDB batch type");
+            const key = slice(data, c), value = type === 1 ? slice(data, c) : Buffer.alloc(0);
+            visit(key, value, sequence + BigInt(i));
+        }
+    };
+    for (let at = 0; at + 7 <= b.length;) {
+        const remaining = 32768 - (at % 32768);
+        if (remaining < 7) {
+            at += remaining;
+            continue;
+        }
+        const size = b.readUInt16LE(at + 4), type = b[at + 6];
+        if (!size && !type) {
+            at += remaining;
+            continue;
+        }
+        if (size + 7 > remaining)
+            throw new Error("Invalid LevelDB WAL record");
+        if (at + 7 + size > b.length)
+            break; // An in-flight append is retried on the next poll.
+        const data = b.subarray(at + 7, at + 7 + size);
+        at += 7 + size;
+        if (type === 1) {
+            batch(data);
+            chunks = [];
+        }
+        else if (type === 2)
+            chunks = [data];
+        else if (type === 3 && chunks.length)
+            chunks.push(data);
+        else if (type === 4 && chunks.length) {
+            chunks.push(data);
+            batch(Buffer.concat(chunks));
+            chunks = [];
+        }
+        else
+            throw new Error("Invalid LevelDB WAL fragment");
+    }
+}
+export class SidebarStorage {
+    files = new Map();
+    dir;
+    constructor(dir) { this.dir = dir; }
+    read(keyName) {
+        const wanted = Buffer.from(`_https://claude.ai\0\x01${keyName}`);
+        let names;
+        try {
+            names = fs.readdirSync(this.dir).filter(n => /^\d+\.(ldb|log)$/.test(n));
+        }
+        catch (error) {
+            if (error.code === "ENOENT")
+                return null;
+            throw error;
+        }
+        for (const name of this.files.keys())
+            if (!names.includes(name))
+                this.files.delete(name);
+        for (const name of names) {
+            const file = path.join(this.dir, name);
+            try {
+                const stat = fs.lstatSync(file), stamp = `${stat.mtimeMs}:${stat.size}`;
+                if (!stat.isFile() || this.files.get(name)?.stamp === stamp)
+                    continue;
+                let sequence = -1n;
+                let value = Buffer.alloc(0);
+                const visit = (key, data, seq) => { if (key.equals(wanted) && seq > sequence) {
+                    sequence = seq;
+                    value = data;
+                } };
+                const fd = fs.openSync(file, fs.constants.O_RDONLY | fs.constants.O_NOFOLLOW);
+                try {
+                    const data = fs.readFileSync(fd);
+                    name.endsWith(".log") ? wal(data, visit) : table(data, visit);
+                }
+                finally {
+                    fs.closeSync(fd);
+                }
+                this.files.set(name, { stamp, sequence, value });
+            }
+            catch (error) {
+                if (error.code !== "ENOENT")
+                    throw error;
+            }
+        }
+        const latest = [...this.files.values()].sort((a, b) => a.sequence > b.sequence ? -1 : a.sequence < b.sequence ? 1 : 0)[0];
+        if (!latest || latest.sequence < 0n || !latest.value.length)
+            return null;
+        const encoding = latest.value[0];
+        if (encoding !== 0 && encoding !== 1)
+            throw new Error("Unsupported Chromium storage encoding");
+        return JSON.parse(latest.value.subarray(1).toString(encoding === 0 ? "utf16le" : "latin1"));
+    }
+}

package/dist/remote/src/sidebar.js

@@ -0,0 +1,173 @@
+// Claude's files are read-only. Group IDs refer to app sessionId, not cliSessionId.
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { object } from "./bridge-client.js";
+import { SidebarStorage } from "./sidebar-storage.js";
+const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+const number = (v) => typeof v === "number" && Number.isFinite(v) ? v : 0;
+const string = (v) => typeof v === "string" ? v : "";
+const array = (v) => Array.isArray(v) ? v : [];
+export const UNGROUPED = "sidebar:ungrouped";
+export const PHONE_GROUP = "sidebar:phone";
+export class DesktopSidebar {
+    root;
+    storage;
+    cache = new Map();
+    at = -Infinity;
+    current = { groups: [], sessions: new Map(), superseded: new Set() };
+    opts;
+    constructor(opts = {}) {
+        this.opts = opts;
+        this.root = opts.root ?? path.join(os.homedir(), "Library", "Application Support", "Claude");
+        this.storage = new SidebarStorage(path.join(this.root, "Local Storage", "leveldb"));
+    }
+    json(file) {
+        try {
+            const stat = fs.lstatSync(file);
+            if (!stat.isFile())
+                throw new Error("Non-regular desktop sidebar file");
+            const stamp = `${stat.mtimeMs}:${stat.size}`, cached = this.cache.get(file);
+            if (cached?.stamp === stamp)
+                return cached.value;
+            const fd = fs.openSync(file, fs.constants.O_RDONLY | fs.constants.O_NOFOLLOW);
+            let value;
+            try {
+                value = JSON.parse(fs.readFileSync(fd, "utf8"));
+            }
+            finally {
+                fs.closeSync(fd);
+            }
+            this.cache.set(file, { stamp, value });
+            return value;
+        }
+        catch (error) {
+            if (error.code !== "ENOENT")
+                throw error;
+            this.cache.delete(file);
+            return null;
+        }
+    }
+    read() {
+        const now = (this.opts.now ?? Date.now)();
+        if (now - this.at < 3000)
+            return this.current;
+        try {
+            return this.refresh(now);
+        }
+        catch (error) {
+            this.at = now;
+            if (!this.opts.onError)
+                throw error;
+            this.opts.onError(error);
+            return this.current;
+        }
+    }
+    refresh(now) {
+        // Publish atomically; a racing/invalid external file never replaces a good snapshot.
+        const prefs = object(object(this.json(path.join(this.root, "claude_desktop_config.json")))?.preferences);
+        const epitaxy = object(prefs?.epitaxyPrefs);
+        const scopes = object(epitaxy?.["dframe-group-scopes"]);
+        const sections = object(epitaxy?.["dframe-code-sections"]);
+        const config = object(this.json(path.join(this.root, "config.json")));
+        const account = string(config?.lastKnownAccountUuid);
+        const scopeKeys = [...new Set([...Object.keys(scopes ?? {}), ...Object.keys(sections ?? {})])]
+            .filter(k => k.split("/").every(v => UUID.test(v)) && k.split("/").length === 2 && (!account || k.startsWith(account + "/")));
+        const unreadState = object(object(this.storage.read("epitaxy-unread-v1"))?.state);
+        const unread = new Set(array(unreadState?.unreadIds).filter((v) => typeof v === "string"));
+        const result = { groups: [], sessions: new Map(), superseded: new Set() };
+        for (const scope of scopeKeys)
+            this.scope(scope, object(scopes?.[scope]), object(sections?.[scope]), epitaxy, unread, result);
+        this.current = result;
+        this.at = now;
+        return result;
+    }
+    scope(scope, groups, layout, prefs, unread, result) {
+        const dir = path.join(this.root, "claude-code-sessions", scope);
+        let names;
+        try {
+            names = fs.readdirSync(dir);
+        }
+        catch (error) {
+            if (error.code === "ENOENT")
+                return;
+            throw error;
+        }
+        const archiveIndex = object(this.json(path.join(dir, "archived-sessions.idx")));
+        const archived = new Set(array(archiveIndex?.archived).filter((v) => typeof v === "string"));
+        const assignments = object(groups?.assignments), orders = object(groups?.order);
+        const manual = array(groups?.groups).map(object).filter(g => g && typeof g.id === "string");
+        const rows = [];
+        for (const name of names.filter(n => /^local_[0-9a-f-]+\.json$/i.test(n))) {
+            const v = object(this.json(path.join(dir, name)));
+            if (!v || !UUID.test(string(v.cliSessionId)))
+                continue;
+            const sessionId = string(v.sessionId) || name.slice(0, -5), group = string(assignments?.[`code:${sessionId}`]);
+            for (const prior of array(v.priorCliSessionIds))
+                if (typeof prior === "string" && UUID.test(prior))
+                    result.superseded.add(prior);
+            const routine = typeof v.scheduledTaskId === "string" && v.scheduledTaskId.length > 0;
+            // The app persists its unread set to Local Storage late; a session focused in the app after
+            // its last activity is read even while the stored set still lists it (2026-10-13: 데이리플
+            // showed yellow on the phone while the Mac, which had it open, showed it working).
+            const focused = number(v.lastFocusedAt), active = number(v.lastActivityAt);
+            const seen = focused > 0 && active > 0 && focused >= active;
+            rows.push({ cliSessionId: string(v.cliSessionId), sessionId, title: string(v.title), unread: unread.has(sessionId) && !seen,
+                archived: v.isArchived === true || archived.has(sessionId), group: routine ? "routines" : manual.some(g => g?.id === group) ? group : "sessions",
+                order: 0, activity: number(v.lastActivityAt) || number(v.createdAt), created: number(v.createdAt) });
+        }
+        const pinned = new Set(array(prefs?.["starred-local-code-sessions"]).filter((v) => typeof v === "string"));
+        const configured = array(layout?.sections).map(object).filter((v) => v !== null);
+        const sectionList = configured.length ? configured.sort((a, b) => number(a.order) - number(b.order)) :
+            [...manual.map(g => ({ id: g?.id, kind: "manual", name: g?.name })), { id: "sessions", kind: "sessions", name: "" }];
+        const consumed = new Set();
+        for (const section of sectionList) {
+            if (section.shown === false)
+                continue;
+            const id = string(section.id), groupName = section.kind === "pinned" ? "sidebar:pinned" : section.kind === "routines" ? "sidebar:routines" : section.kind === "sessions" ? UNGROUPED : string(section.name);
+            if (!groupName)
+                continue;
+            const members = new Set(array(section.members).filter((v) => typeof v === "string"));
+            const selected = rows.filter(r => !r.archived && !consumed.has(r.cliSessionId) && (section.kind === "pinned" ? pinned.has(r.sessionId) : r.group === id || members.has(`code:${r.sessionId}`)));
+            const order = array(orders?.[id]);
+            selected.sort((a, b) => {
+                let delta;
+                if (section.sortBy === "manual") {
+                    const rank = (r) => { const i = order.indexOf(`code:${r.sessionId}`); return i < 0 ? Number.MAX_SAFE_INTEGER : i; };
+                    delta = rank(a) - rank(b);
+                }
+                else if (section.sortBy === "title" || section.sortBy === "name")
+                    delta = a.title.localeCompare(b.title);
+                else if (section.sortBy === "created")
+                    delta = b.created - a.created;
+                else
+                    delta = b.activity - a.activity;
+                return (section.ascending === true ? -delta : delta) || a.sessionId.localeCompare(b.sessionId);
+            });
+            const group = { name: groupName, sessions: selected.map(r => r.cliSessionId) };
+            result.groups.push(group);
+            selected.forEach((r, order) => { consumed.add(r.cliSessionId); result.sessions.set(r.cliSessionId, { ...r, group: groupName, order }); });
+        }
+        // Archived and hidden rows remain in the index so joins can exclude them.
+        for (const r of rows)
+            if (!result.sessions.has(r.cliSessionId))
+                result.sessions.set(r.cliSessionId, { ...r, archived: true });
+    }
+    join(sessions, cliId) {
+        const sidebar = this.read();
+        if (!sidebar.groups.length)
+            return sessions;
+        return sessions.flatMap(s => {
+            const row = sidebar.sessions.get(cliId(s.id));
+            if (row?.archived)
+                return [];
+            // The host keeps one record per CLI session id; an app session that has moved on from one
+            // (2026-10-13: 클로드리플 and 클로드리플2 each listed twice, the old half stuck at "42 min").
+            if (!row && sidebar.superseded.has(cliId(s.id)))
+                return [];
+            if (!row)
+                return [{ ...s, group: s.origin === "desktop" ? UNGROUPED : PHONE_GROUP }];
+            return [{ ...s, title: row.title || s.title, unread: row.unread, group: row.group, order: row.order, updatedAt: row.activity }];
+        });
+    }
+}

package/dist/remote/src/tool-details.js

@@ -0,0 +1,205 @@
+export function record(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+export function toolInput(value) {
+    if (typeof value !== "string")
+        return null;
+    try {
+        return record(JSON.parse(value));
+    }
+    catch {
+        return null;
+    } // Legacy tools may store a plain prompt, not JSON.
+}
+export const stringField = (input, key) => typeof input?.[key] === "string" ? input[key] : "";
+function lines(text) {
+    if (!text)
+        return [];
+    const list = text.replace(/\r\n/g, "\n").split("\n");
+    if (list.at(-1) === "")
+        list.pop();
+    return list;
+}
+/** A linear-space line diff. Common edges are peeled before finding the next shared line,
+ * avoiding an N×M matrix for large writes. Equal-distance anchors prefer removals. */
+export function diffLines(before, after) {
+    const a = lines(before), b = lines(after);
+    const positions = new Map();
+    b.forEach((line, i) => { const at = positions.get(line) ?? []; at.push(i); positions.set(line, at); });
+    const out = [];
+    let i = 0, j = 0;
+    const remove = () => out.push({ kind: "remove", text: a[i], old: ++i, next: null });
+    const add = () => out.push({ kind: "add", text: b[j], old: null, next: ++j });
+    const context = () => out.push({ kind: "context", text: a[i], old: ++i, next: ++j });
+    while (i < a.length && j < b.length) {
+        if (a[i] === b[j]) {
+            context();
+            continue;
+        }
+        let anchor = null;
+        for (let k = i; k < a.length; k++) {
+            if (anchor && k - i > anchor.distance)
+                break;
+            const candidates = positions.get(a[k]);
+            if (!candidates)
+                continue;
+            // Binary search: the same repeated line can occur thousands of times.
+            let lo = 0, hi = candidates.length;
+            while (lo < hi) {
+                const mid = (lo + hi) >>> 1;
+                if (candidates[mid] < j)
+                    lo = mid + 1;
+                else
+                    hi = mid;
+            }
+            const next = candidates[lo];
+            if (next === undefined)
+                continue;
+            const distance = k - i + next - j;
+            if (!anchor || distance < anchor.distance)
+                anchor = { i: k, j: next, distance };
+        }
+        if (!anchor) {
+            while (i < a.length)
+                remove();
+            while (j < b.length)
+                add();
+            break;
+        }
+        while (i < anchor.i)
+            remove();
+        while (j < anchor.j)
+            add();
+    }
+    while (i < a.length)
+        remove();
+    while (j < b.length)
+        add();
+    // A changed final newline is a real edit, even if every visible line is equal.
+    if (before !== after && before.endsWith("\n") !== after.endsWith("\n") && a.length && b.length && a.at(-1) === b.at(-1)) {
+        const last = out.at(-1);
+        if (last?.kind === "context")
+            out.splice(out.length - 1, 1, { kind: "remove", text: last.text + (before.endsWith("\n") ? "" : "\n\"), old: last.old, next: null }, { kind: "add", text: last.text + (after.endsWith("\n") ? "" : "\n\"), old: null, next: last.next });
+    }
+    return out;
+}
+export function toolDiffs(name, input) {
+    if (!input || !["Edit", "MultiEdit", "Write"].includes(name))
+        return [];
+    const path = stringField(input, "file_path") || stringField(input, "path") || "file";
+    const edits = name === "MultiEdit" && Array.isArray(input.edits) ? input.edits.map(record).filter(e => e !== null) : [input];
+    return edits.map(edit => {
+        const before = name === "Write" ? stringField(edit, "old_content") : stringField(edit, "old_string");
+        const after = name === "Write" ? stringField(edit, "content") : stringField(edit, "new_string");
+        const diff = diffLines(before, after);
+        return { path, header: `@@ -${before ? 1 : 0},${lines(before).length} +${after ? 1 : 0},${lines(after).length} @@`, lines: diff };
+    });
+}
+export function changeCount(name, input) {
+    return toolDiffs(name, input).flatMap(d => d.lines).reduce((sum, line) => ({
+        added: sum.added + Number(line.kind === "add"), removed: sum.removed + Number(line.kind === "remove"),
+    }), { added: 0, removed: 0 });
+}
+function category(name) {
+    if (["Bash", "BashOutput", "KillShell"].includes(name))
+        return "command";
+    if (name === "Read")
+        return "read";
+    if (["Edit", "MultiEdit", "Write", "NotebookEdit"].includes(name))
+        return "edit";
+    if (["Grep", "Glob", "LS"].includes(name))
+        return "search";
+    if (["WebSearch", "WebFetch"].includes(name))
+        return "web";
+    if (["Task", "Agent"].includes(name))
+        return "agent";
+    return "other";
+}
+const completed = {
+    ko: { command: (n) => `명령어 ${n}개 실행함`, read: (n) => `파일 ${n}개 읽음`, edit: (n) => `파일 ${n}개를 편집함`, search: (n) => `검색 ${n}회`, web: (n) => `웹 ${n}회`, agent: (n) => `에이전트 ${n}개`, other: (n) => `도구 ${n}개 사용함` },
+    en: { command: (n) => `Ran ${n} command${n === 1 ? "" : "s"}`, read: (n) => `Read ${n} file${n === 1 ? "" : "s"}`, edit: (n) => `Edited ${n} file${n === 1 ? "" : "s"}`, search: (n) => `${n} search${n === 1 ? "" : "es"}`, web: (n) => `${n} web request${n === 1 ? "" : "s"}`, agent: (n) => `${n} agent${n === 1 ? "" : "s"}`, other: (n) => `Used ${n} tool${n === 1 ? "" : "s"}` },
+};
+const active = {
+    ko: { command: "명령어 실행 중…", read: "파일 읽는 중…", edit: "파일 편집 중…", search: "검색 중…", web: "웹 검색 중…", agent: "에이전트 실행 중…", other: "도구 실행 중…" },
+    en: { command: "Running command…", read: "Reading file…", edit: "Editing file…", search: "Searching…", web: "Searching the web…", agent: "Running agent…", other: "Running tool…" },
+};
+const more = { ko: (n) => `그 외 작업 ${n}개`, en: (n) => `and ${n} more action${n === 1 ? "" : "s"}` };
+/** Like the Claude app: kinds in the order they first appear, files counted once per path, five or more kinds cut to three. */
+export function activitySummary(rows, running, language) {
+    const counts = new Map();
+    const paths = new Set();
+    let added = 0, removed = 0, failed = false, pending = null;
+    for (const row of rows) {
+        const kind = row.type === "subagent" ? "agent" : category(row.tool.name);
+        const input = row.type === "tool" ? toolInput(row.tool.input) : null;
+        const path = stringField(input, "file_path") || stringField(input, "path") || (row.type === "tool" ? row.tool.summary : "");
+        const file = (kind === "edit" || kind === "read") && path ? `${kind}:${path}` : "";
+        if (!file || !paths.has(file))
+            counts.set(kind, (counts.get(kind) ?? 0) + 1);
+        if (file)
+            paths.add(file);
+        if (row.type === "subagent") {
+            failed ||= row.status === "failed";
+            if (row.status === "running")
+                pending = kind;
+            continue;
+        }
+        failed ||= row.tool.result?.ok === false;
+        if (!row.tool.result)
+            pending = kind;
+        const changes = row.tool.changes ?? changeCount(row.tool.name, input);
+        added += changes.added;
+        removed += changes.removed;
+    }
+    const parts = [...counts];
+    const shown = parts.length >= 5 ? parts.slice(0, 3) : parts;
+    const rest = parts.slice(shown.length).reduce((sum, [, n]) => sum + n, 0);
+    const text = running && pending ? active[language][pending] : [...shown.map(([kind, n]) => completed[language][kind](n)), ...(rest ? [more[language](rest)] : [])].join(", ");
+    return { text, added, removed, failed };
+}
+export function numberedRead(text, input) {
+    const offset = typeof input?.offset === "number" && input.offset > 0 ? Math.floor(input.offset) : 1;
+    return lines(text).map((line, i) => {
+        const match = /^\s*(\d+)[→\t](.*)$/.exec(line);
+        return match ? { number: Number(match[1]), text: match[2] } : { number: offset + i, text: line };
+    });
+}
+export function pretty(text) {
+    try {
+        return JSON.stringify(JSON.parse(text), null, 2);
+    }
+    catch {
+        return text;
+    }
+}
+export function webLinks(text) {
+    const out = new Map();
+    const add = (url, title) => { if (/^https?:\/\//.test(url))
+        out.set(url, title || url); };
+    function walk(value) {
+        if (Array.isArray(value)) {
+            value.forEach(walk);
+            return;
+        }
+        const obj = record(value);
+        if (!obj)
+            return;
+        const url = stringField(obj, "url") || stringField(obj, "link");
+        if (url)
+            add(url, stringField(obj, "title") || stringField(obj, "name"));
+        Object.values(obj).forEach(v => { if (typeof v === "object")
+            walk(v); });
+    }
+    try {
+        walk(JSON.parse(text));
+    }
+    catch { /* Text/Markdown output is normal. */ }
+    for (const match of text.matchAll(/\[([^\]]+)\]\((https?:\/\/[^\s)]+)\)/g))
+        add(match[2], match[1]);
+    for (const match of text.matchAll(/https?:\/\/[^\s<>"\])]+/g)) {
+        const url = match[0].replace(/[.,;]+$/, "");
+        if (!out.has(url))
+            add(url, url);
+    }
+    return [...out].map(([url, title]) => ({ title, url }));
+}