@fitchmultz/pi-subagents 0.49.1 → 0.50.0

package/dist/history/store.js

@@ -1,243 +0,0 @@
-import * as path from "node:path";
-import { openGeneration } from "./database-generation.js";
-import { OutputDigests } from "./output-digests.js";
-import { historyTransaction, openHistoryDatabase } from "./database.js";
-import { hash, safeText, hasText } from "./text.js";
-export { hash, exactTextDigest, safeText, integer, pageLimit } from "./text.js";
-import { HistoryIndexError, } from "./types.js";
-import { sourceRow, indexRow, number, text, } from "./rows.js";
-import { parseObject, errorMessage } from "./values.js";
-export class HistoryStore {
-    db;
-    generation;
-    file;
-    owner;
-    counters = {
-        sourceChecks: 0,
-        sourceOpens: 0,
-        sourceBytesRead: 0,
-        runProjections: 0,
-        queries: 0,
-    };
-    get operations() {
-        return { ...this.counters };
-    }
-    count(operation, amount = 1) {
-        this.counters[operation] += amount;
-    }
-    ingestLock;
-    statements = new Map();
-    outputDigests = new OutputDigests();
-    constructor(agentDir, owner) {
-        this.owner = owner;
-        const { db, file } = openGeneration(agentDir, owner);
-        this.db = db;
-        this.file = file;
-        try {
-            this.generation = text(this.require("SELECT value FROM meta WHERE key='generation'"), "value");
-            this.db.exec("CREATE TEMP TABLE pending_text(field TEXT, position INTEGER, end_position INTEGER, text TEXT)");
-        }
-        catch (error) {
-            this.db.close();
-            throw error;
-        }
-    }
-    require(sql, ...params) {
-        const row = this.get(sql, ...params);
-        if (!row) {
-            throw new HistoryIndexError("CORRUPT", "Missing required index row.");
-        }
-        return row;
-    }
-    get(sql, ...params) {
-        const row = this.statement(sql).get(...params);
-        return row === undefined ? undefined : indexRow(row);
-    }
-    all(sql, ...params) {
-        return this.statement(sql)
-            .all(...params)
-            .map(indexRow);
-    }
-    run(sql, ...params) {
-        return this.statement(sql).run(...params);
-    }
-    statement(sql) {
-        let statement = this.statements.get(sql);
-        if (!statement) {
-            statement = this.db.prepare(sql);
-            // Dynamic browse/filter shapes cannot grow this connection's cache indefinitely.
-            if (this.statements.size >= 128) {
-                const oldest = this.statements.keys().next().value;
-                if (oldest !== undefined) {
-                    this.statements.delete(oldest);
-                }
-            }
-            this.statements.set(sql, statement);
-        }
-        return statement;
-    }
-    deleteDocuments(sourceId, unpublishedOnly = false) {
-        const where = `entry_rowid IN (SELECT rowid FROM entries WHERE source_id=?${unpublishedOnly ? " AND published=0" : ""})`;
-        this.run(`DELETE FROM corpus WHERE rowid IN (SELECT id FROM documents WHERE ${where})`, sourceId);
-        this.run(`DELETE FROM documents WHERE ${where}`, sourceId);
-    }
-    transaction(work) {
-        return historyTransaction(this.db, work);
-    }
-    bump() {
-        this.run("UPDATE meta SET value=CAST(value AS INTEGER)+1 WHERE key='version'");
-        this.run("UPDATE meta SET value=? WHERE key='indexedAt'", String(Date.now()));
-    }
-    source(id) {
-        const row = this.get("SELECT * FROM sources WHERE id=?", id);
-        return row ? sourceRow(row) : undefined;
-    }
-    resetSource(id, state = "pending", error = null) {
-        this.transaction(() => {
-            this.deleteDocuments(id);
-            this.run("DELETE FROM entries WHERE source_id=?", id);
-            this.run("UPDATE sources SET generation=generation+1,identity=NULL,stamp=NULL,session_id=NULL,header_digest=NULL,format_version=NULL,cursor=0,prefix_digest=NULL,state=?,error=?,malformed=0,complexity=0,checked_at=? WHERE id=?", state, error, Date.now(), id);
-            this.bump();
-        });
-    }
-    clearUnpublished(id) {
-        this.transaction(() => {
-            this.deleteDocuments(id, true);
-            this.run("DELETE FROM entries WHERE source_id=? AND published=0", id);
-        });
-    }
-    putView(view, full = view) {
-        const attention = attentionRank(view);
-        const json = JSON.stringify(view), filters = new Map(full.children.map((child) => [
-            child.index,
-            safeText(`${child.agent} ${child.label ?? ""} ${child.task ?? full.task}`, Infinity).toLowerCase(),
-        ]));
-        const filterText = safeText(`${full.task} ${[...filters.values()].join(" ")}`, Infinity).toLowerCase();
-        const digests = new Map(full.children.map((child) => [child.index, this.outputDigests.read(child.result)]));
-        const saved = this.get("SELECT view,filter_text FROM runs WHERE id=?", view.runId);
-        if (saved?.view === json &&
-            saved.filter_text === filterText &&
-            this.all("SELECT child_index,output_digest FROM children WHERE run_id=?", view.runId).every((child) => child.output_digest === digests.get(number(child, "child_index")))) {
-            return;
-        }
-        this.transaction(() => {
-            this.run("INSERT INTO runs VALUES (?,?,?,?,?,?,?,?,?) ON CONFLICT(id) DO UPDATE SET attention=excluded.attention,updated=excluded.updated,negative_updated=excluded.negative_updated,state=excluded.state,filter_text=excluded.filter_text,view=excluded.view,predecessor_id=excluded.predecessor_id,predecessor_index=excluded.predecessor_index", view.runId, attention, view.updatedAt, -view.updatedAt, view.state, filterText, json, view.predecessorRunId ?? null, view.predecessorIndex ?? 0);
-            this.putChildren(view, filters, digests);
-            this.bump();
-        });
-    }
-    putChildren(view, filters, digests) {
-        this.run("DELETE FROM children WHERE run_id=?", view.runId);
-        for (const child of view.children) {
-            let source = null;
-            if (hasText(child.sessionFile)) {
-                const file = path.resolve(child.sessionFile);
-                source = hash(file);
-                this.run("INSERT INTO sources(id,path) VALUES (?,?) ON CONFLICT(id) DO NOTHING", source, file);
-            }
-            const terminal = child.state !== "live" && child.state !== "unknown";
-            const boundary = terminalBoundary(child, view.updatedAt, terminal);
-            this.run("INSERT INTO children VALUES (?,?,?,?,?,?,?,?)", view.runId, child.index, child.agent, source, filters.get(child.index) ?? "", digests.get(child.index) ?? null, boundary.entry, boundary.endedAt);
-        }
-    }
-    info(pending, projectionErrors = 0) {
-        const sources = this.require("SELECT COUNT(*) AS total,SUM(state IN ('pending','indexing')) AS pending,SUM(state IN ('degraded','missing','error')) AS errors FROM sources WHERE id IN (SELECT source_id FROM children)");
-        const indexedAtValue = Number(text(this.require("SELECT value FROM meta WHERE key='indexedAt'"), "value"));
-        const indexedAt = indexedAtValue === 0 ? null : indexedAtValue;
-        const errors = Number(sources.errors ?? 0) + projectionErrors;
-        const remaining = pending + Number(sources.pending ?? 0);
-        const freshness = {
-            authoritative: false,
-            state: freshnessState(remaining, errors),
-            pending: remaining,
-            errors,
-            indexedAt,
-        };
-        return {
-            version: Number(text(this.require("SELECT value FROM meta WHERE key='version'"), "value")),
-            indexedAt,
-            freshness,
-        };
-    }
-    status(pending) {
-        return {
-            ...this.info(pending),
-            databaseFile: this.file,
-            physicalSources: number(this.require("SELECT COUNT(*) AS count FROM sources"), "count"),
-            publishedEntries: number(this.require("SELECT COUNT(*) AS count FROM entries WHERE published=1"), "count"),
-            operations: this.operations,
-        };
-    }
-    entry(row) {
-        return {
-            id: row.id,
-            nativeId: row.native_id,
-            parentId: row.parent_id,
-            sequence: row.start,
-            timestamp: row.timestamp,
-            type: row.type,
-            ref: {
-                sourceId: row.source_id,
-                generation: row.generation,
-                start: row.start,
-                end: row.end,
-                digest: row.digest,
-            },
-            entry: parseObject(row.preview),
-        };
-    }
-    /** A separate SQLite transaction serializes incremental staging without blocking browse queries.
-     * SQLite releases it on process death; no PID lease, expiry, or stale-file deletion is needed. */
-    beginIngest() {
-        if (!this.ingestLock) {
-            this.ingestLock = openHistoryDatabase(`${this.file}.ingest.sqlite`);
-            this.ingestLock.exec("PRAGMA busy_timeout=0");
-        }
-        try {
-            this.ingestLock.exec("BEGIN IMMEDIATE");
-        }
-        catch (error) {
-            if (/locked|busy/i.test(errorMessage(error))) {
-                throw new HistoryIndexError("INDEX_BUSY", "Another worker is indexing this generation.");
-            }
-            throw error;
-        }
-    }
-    endIngest() {
-        if (this.ingestLock?.isTransaction === true) {
-            this.ingestLock.exec("ROLLBACK");
-        }
-    }
-    close() {
-        this.statements.clear();
-        this.ingestLock?.close();
-        this.db.close();
-    }
-}
-function terminalBoundary(child, updatedAt, terminal) {
-    if (!terminal) {
-        return { entry: null, endedAt: null };
-    }
-    return {
-        entry: child.result?.terminalEntryId ?? null,
-        endedAt: hasText(child.result?.terminalEntryId) ? null : updatedAt,
-    };
-}
-function attentionRank(view) {
-    if (view.attention.includes("awaiting_input")) {
-        return 0;
-    }
-    if (view.attention.some((reason) => reason !== "unreviewed")) {
-        return 1;
-    }
-    if (view.state === "live") {
-        return 2;
-    }
-    return view.attention.length > 0 ? 3 : 4;
-}
-function freshnessState(pending, errors) {
-    if (pending > 0) {
-        return "catching-up";
-    }
-    return errors > 0 ? "degraded" : "current";
-}

package/dist/history/text-chunks.js

@@ -1,168 +0,0 @@
-import { HistoryIndexError } from "./types.js";
-import { candidate } from "./preview.js";
-/** Streaming ECMA-48 removal, retaining original UTF-16 positions without buffering control payloads. */
-class TerminalText {
-    state = "text";
-    escape(char) {
-        if (char === "[") {
-            this.state = "csi";
-        }
-        else if ("]PX^_".includes(char)) {
-            this.state = "string";
-        }
-        else {
-            this.state = char >= " " && char <= "/" ? "intermediate" : "text";
-        }
-    }
-    control(char) {
-        if (this.state === "escape") {
-            this.escape(char);
-        }
-        else if (this.state === "intermediate") {
-            if (char >= "0" && char <= "~") {
-                this.state = "text";
-            }
-        }
-        else if (this.state === "csi") {
-            if (char >= "@" && char <= "~") {
-                this.state = "text";
-            }
-        }
-        else {
-            this.stringControl(char);
-        }
-    }
-    stringControl(char) {
-        if (char === "\x07" || char === "\x9c" || (this.state === "stringEscape" && char === "\\")) {
-            this.state = "text";
-        }
-        else {
-            this.state = char === "\x1b" ? "stringEscape" : "string";
-        }
-    }
-    write(text, visible) {
-        let position = 0;
-        while (position < text.length) {
-            if (this.state !== "text") {
-                this.control(text.charAt(position++));
-                continue;
-            }
-            // ECMA-48 introducers intentionally identify terminal controls before lexical indexing.
-            // oxlint-disable-next-line no-control-regex
-            const next = text.slice(position).search(/[\x1b\x90\x98\x9b\x9d-\x9f]/);
-            if (next < 0) {
-                visible(text.slice(position), position);
-                return;
-            }
-            visible(text.slice(position, position + next), position);
-            position += next;
-            const control = text.charAt(position++);
-            if (control === "\x1b") {
-                this.state = "escape";
-            }
-            else {
-                this.state = control === "\x9b" ? "csi" : "string";
-            }
-        }
-    }
-}
-/** Owns one lexical stream and its overlap; no caller can mutate its token buffer. */
-class FieldText {
-    word = "";
-    wordStart = 0;
-    received = 0;
-    tokens = [];
-    length = 0;
-    terminal = new TerminalText();
-    field;
-    emit;
-    constructor(field, emit) {
-        this.field = field;
-        this.emit = emit;
-    }
-    window(final = false) {
-        const first = this.tokens.at(0);
-        const last = this.tokens.at(-1);
-        if (!first || !last) {
-            return;
-        }
-        this.emit({
-            field: this.field,
-            start: first.start,
-            end: last.end,
-            text: this.tokens.map((token) => token.text).join(" "),
-        });
-        this.tokens = final ? [] : this.tokens.slice(-12);
-        this.length = this.tokens.reduce((length, token) => length + token.text.length + 1, 0);
-    }
-    token(end) {
-        if (this.word.length === 0) {
-            return;
-        }
-        this.tokens.push({ text: this.word, start: this.wordStart, end });
-        this.length += this.word.length + 1;
-        this.word = "";
-        if (this.tokens.length >= 256 || (this.length >= 8192 && this.tokens.length > 12)) {
-            this.window();
-        }
-    }
-    write(text) {
-        this.terminal.write(text, (visible, offset) => {
-            for (const part of visible.matchAll(/[\p{L}\p{N}\p{M}]+|[^\p{L}\p{N}\p{M}]+/gu)) {
-                const start = this.received + offset + part.index;
-                if (!/^[\p{L}\p{N}\p{M}]/u.test(part[0])) {
-                    this.token(start);
-                    continue;
-                }
-                if (this.word.length === 0) {
-                    this.wordStart = start;
-                }
-                this.word += part[0];
-                if (this.word.length > 65_536) {
-                    throw new HistoryIndexError("RECORD_COMPLEXITY", "Record contains a lexical token exceeding the 64 KiB indexing budget.");
-                }
-            }
-        });
-        this.received += text.length;
-    }
-    finish() {
-        this.token(this.received);
-        this.window(true);
-    }
-}
-/** Token windows overlap 12 tokens, including phrases across arbitrarily long whitespace. */
-export class TextChunks {
-    fields = new Map();
-    staged = [];
-    write(keys, text) {
-        if (!candidate(keys)) {
-            return;
-        }
-        const field = JSON.stringify(keys);
-        let buffer = this.fields.get(field);
-        if (!buffer) {
-            if (this.fields.size >= 4096) {
-                throw new HistoryIndexError("RECORD_COMPLEXITY", "Record exceeds the 4096 visible text-field indexing budget.");
-            }
-            buffer = new FieldText(field, (window) => {
-                this.staged.push(window);
-            });
-            this.fields.set(field, buffer);
-        }
-        buffer.write(text);
-    }
-    flush(store, finish = false) {
-        if (finish) {
-            for (const buffer of this.fields.values()) {
-                buffer.finish();
-            }
-            this.fields.clear();
-        }
-        if (this.staged.length > 0) {
-            for (const item of this.staged) {
-                store.run("INSERT INTO pending_text VALUES (?,?,?,?)", item.field, item.start, item.end, item.text);
-            }
-            this.staged = [];
-        }
-    }
-}

package/dist/history/text.js

@@ -1,35 +0,0 @@
-import { createHash } from "node:crypto";
-import { stripTerminalSequences } from "../shared/native-tui.js";
-import { HistoryIndexError } from "./types.js";
-export const hash = (text) => createHash("sha256").update(text).digest("hex");
-export const exactTextDigest = (text) => hash(stripTerminalSequences(text).trim());
-export function hasText(value) {
-    return typeof value === "string" && value.length > 0;
-}
-export function safeText(value, limit = 1024) {
-    if (typeof value !== "string") {
-        return "";
-    }
-    const controls = 
-    // Bounded UI/SQLite previews deliberately remove terminal escapes and C0/C1 controls.
-    // oxlint-disable-next-line no-control-regex
-    /\x1b\][^\x07]*(?:\x07|\x1b\\)|\x1b\[[0-?]*[ -/]*[@-~]|[\u0000-\u0008\u000b-\u001f\u007f-\u009f]/g;
-    return value.replace(controls, "").slice(0, limit);
-}
-export function integer(value, fallback, maximum = Number.MAX_SAFE_INTEGER) {
-    const result = value === undefined ? fallback : value;
-    if (typeof result !== "number" ||
-        !Number.isSafeInteger(result) ||
-        result < 0 ||
-        result > maximum) {
-        throw new HistoryIndexError("INVALID", "Expected a bounded non-negative integer.");
-    }
-    return result;
-}
-export function pageLimit(value, fallback = 100) {
-    const limit = integer(value, fallback, 100);
-    if (limit === 0) {
-        throw new HistoryIndexError("INVALID", "Page limit must be from 1 to 100.");
-    }
-    return limit;
-}

package/dist/history/transcript-queries.js

@@ -1,183 +0,0 @@
-import { HistoryIndexError } from "./types.js";
-import { integer, pageLimit } from "./text.js";
-import { entryRow, number, nullableText } from "./rows.js";
-function validate(input) {
-    if (input.before !== undefined && input.after !== undefined) {
-        throw new HistoryIndexError("INVALID", "Use before or after, not both.");
-    }
-    if (input.messageIds &&
-        (!Array.isArray(input.messageIds) ||
-            input.messageIds.length > 1000 ||
-            input.messageIds.some((id) => typeof id !== "string" || id.length > 512))) {
-        throw new HistoryIndexError("INVALID", "Invalid scoped message metadata request.");
-    }
-    validateReadThrough(input.readThrough);
-}
-function validateReadThrough(value) {
-    if (value !== undefined && value !== null && (typeof value !== "string" || value.length > 1024)) {
-        throw new HistoryIndexError("INVALID", "Invalid scoped read metadata request.");
-    }
-}
-function emptyPage(scope, source) {
-    return {
-        ...scope.info(),
-        entries: [],
-        count: 0,
-        hasMore: false,
-        sourceId: source?.id ?? null,
-        generation: source?.generation ?? null,
-        sessionId: source?.session_id ?? null,
-        sourceState: source?.state ?? "unlinked",
-        configuration: {},
-        deliveredMessages: [],
-        latestEntryId: null,
-    };
-}
-function queryKey(scope, input, source) {
-    return scope.key([
-        "history",
-        input.runId,
-        input.index,
-        source.id,
-        source.generation,
-        input.terminalEntryId ?? null,
-        input.endedAt ?? null,
-        input.leaf ?? null,
-    ]);
-}
-export class TranscriptQueries {
-    scope;
-    constructor(scope) {
-        this.scope = scope;
-    }
-    delivered(boundary, ids) {
-        const humans = [];
-        const where = boundary.clauses.join(" AND ");
-        for (const id of new Set(ids)) {
-            const human = this.scope.store.get(`SELECT start FROM entries WHERE ${where} AND human_id=? ORDER BY start DESC LIMIT 1`, ...boundary.params, id);
-            if (human) {
-                humans.push([id, number(human, "start")]);
-            }
-        }
-        if (humans.length === 0) {
-            return [];
-        }
-        // One tail lookup answers every ID, without scanning before the earliest requested human.
-        const assistant = this.scope.store.get(`SELECT start FROM entries WHERE ${where} AND start>? AND assistant_text=1 ORDER BY start DESC LIMIT 1`, ...boundary.params, Math.min(...humans.map(([, start]) => start)));
-        const assistantStart = assistant ? number(assistant, "start") : undefined;
-        return humans.map(([id, start]) => [
-            id,
-            assistantStart !== undefined && start < assistantStart,
-        ]);
-    }
-    readMetadata(boundary, readThrough) {
-        const where = boundary.clauses.join(" AND ");
-        const latest = this.scope.store.get(`SELECT start,visible_id FROM entries WHERE ${where} AND visible_id IS NOT NULL ORDER BY start DESC LIMIT 1`, ...boundary.params);
-        const latestEntryId = latest ? nullableText(latest, "visible_id") : null;
-        if (readThrough === undefined) {
-            return { latestEntryId };
-        }
-        const marker = typeof readThrough === "string"
-            ? this.scope.store.get(`SELECT start,visible_id FROM entries WHERE ${where} AND id=?`, ...boundary.params, readThrough.replace(/:(?:\d+|error)$/, ""))
-            : undefined;
-        let unreadAfter = false;
-        if (latest) {
-            unreadAfter =
-                !marker ||
-                    number(latest, "start") > number(marker, "start") ||
-                    (number(latest, "start") === number(marker, "start") && latestEntryId !== readThrough);
-        }
-        return { latestEntryId, unreadAfter };
-    }
-    pageRows(boundary, before, input) {
-        const clauses = [...boundary.clauses];
-        const params = [...boundary.params];
-        if (before !== undefined) {
-            clauses.push("start<?");
-            params.push(integer(before, 0));
-        }
-        if (input.after !== undefined) {
-            clauses.push("start>?");
-            params.push(integer(input.after, 0));
-        }
-        return this.scope.store
-            .all(`SELECT * FROM entries WHERE ${clauses.join(" AND ")} ORDER BY start ${input.after !== undefined ? "ASC" : "DESC"} LIMIT ?`, ...params, pageLimit(input.limit) + 1)
-            .map(entryRow);
-    }
-    pageMetadata(input, boundary, rows) {
-        const first = rows.at(0);
-        const last = rows.at(-1);
-        const where = boundary.clauses.join(" AND ");
-        const count = number(this.scope.store.require(`SELECT COUNT(*) AS count FROM entries WHERE ${where}`, ...boundary.params), "count");
-        const child = this.scope.store.get("SELECT output_digest FROM children WHERE run_id=? AND child_index=?", input.runId, input.index);
-        const outputDigest = child ? nullableText(child, "output_digest") : null;
-        const finalResultId = outputDigest !== null && outputDigest.length > 0
-            ? this.scope.finalResultId(input, outputDigest, first && last ? [first.start, last.start] : undefined)
-            : undefined;
-        const previous = first !== undefined &&
-            this.scope.store.get(`SELECT start FROM entries WHERE ${where} AND start<? LIMIT 1`, ...boundary.params, first.start) !== undefined;
-        return {
-            count,
-            hasMore: previous,
-            previous,
-            finalResultId,
-            ...(last ? { nextAfter: last.start } : {}),
-        };
-    }
-    navigation(query, rows, metadata, forwardMore) {
-        const first = rows.at(0);
-        return {
-            hasMore: forwardMore ?? metadata.previous,
-            ...(metadata.finalResultId === undefined ? {} : { finalResultId: metadata.finalResultId }),
-            ...(metadata.previous && first
-                ? {
-                    previousBefore: first.start,
-                    previousCursor: this.scope.cursor(query, [first.start], 0),
-                }
-                : {}),
-            ...(metadata.nextAfter === undefined ? {} : { nextAfter: metadata.nextAfter }),
-        };
-    }
-    page(input) {
-        validate(input);
-        const { source } = this.scope.child(input.runId, input.index);
-        const empty = emptyPage(this.scope, source);
-        if (!source) {
-            return {
-                ...empty,
-                unavailable: "This legacy or unstarted child has no linked native conversation.",
-            };
-        }
-        const query = queryKey(this.scope, input, source);
-        const cursor = this.scope.parseCursor(input.cursor, query);
-        if (cursor && (input.before !== undefined || input.after !== undefined)) {
-            throw new HistoryIndexError("INVALID", "Use cursor or sequence, not both.");
-        }
-        const boundary = this.scope.boundary(source, input);
-        const before = cursor ? integer(cursor.keys[0], 0) : input.before;
-        const fetched = this.pageRows(boundary, before, input);
-        const limit = pageLimit(input.limit);
-        const rows = fetched.slice(0, limit);
-        if (input.after === undefined) {
-            rows.reverse();
-        }
-        const metadata = this.pageMetadata(input, boundary, rows);
-        return {
-            ...empty,
-            configuration: this.scope.configuration(source, input),
-            deliveredMessages: this.delivered(boundary, input.messageIds ?? []),
-            ...this.readMetadata(boundary, input.readThrough),
-            terminalSequence: boundary.terminalSequence,
-            count: metadata.count,
-            ...this.navigation(query, rows, metadata, input.after === undefined ? undefined : fetched.length > limit),
-            entries: rows.map((row) => this.scope.store.entry(row)),
-            ...unavailable(source.error, source.state),
-        };
-    }
-}
-function unavailable(error, state) {
-    if (error !== null && error.length > 0) {
-        return { unavailable: error };
-    }
-    return state === "missing" ? { unavailable: "Linked conversation is missing." } : {};
-}

package/dist/history/types.js

@@ -1,8 +0,0 @@
-export class HistoryIndexError extends Error {
-    code;
-    constructor(code, message) {
-        super(message);
-        this.name = "HistoryIndexError";
-        this.code = code;
-    }
-}

package/dist/history/values.js

@@ -1,36 +0,0 @@
-import { HistoryIndexError } from "./types.js";
-import { isRecord } from "../shared/unknown.js";
-export { errorMessage } from "../shared/unknown.js";
-export function object(value) {
-    return isRecord(value) ? value : {};
-}
-export function objects(value) {
-    if (!Array.isArray(value)) {
-        return [];
-    }
-    const items = value;
-    return items.map(object);
-}
-export function parseObject(text) {
-    const value = JSON.parse(text);
-    if (!isRecord(value)) {
-        throw new HistoryIndexError("INVALID", "Expected a JSON object.");
-    }
-    return value;
-}
-export function at(value, keys) {
-    let current = value;
-    for (const key of keys) {
-        if (Array.isArray(current) && typeof key === "number") {
-            const items = current;
-            current = items[key];
-        }
-        else {
-            current = object(current)[String(key)];
-        }
-    }
-    return current;
-}
-export function string(value) {
-    return typeof value === "string" ? value : undefined;
-}