@stringsync/splates 0.0.61 → 1.13.3

package/vendor/@stringsync/splates-server/stats/stats.d.ts

@@ -0,0 +1,176 @@
+import { type MergeFailure, type RemoveReason } from "../tasks/browser";
+import type { Judged } from "./adherence";
+import { type Baseline } from "./baselines";
+import type { Outcome } from "./outcomes";
+/** What the Stats page shows: how tasks ended, bar by bar and by who did them. */
+export interface Stats {
+    /**
+     * Each bar of the period, oldest first, those with nothing ended among
+     * them: `start` is when it starts, as an ISO time.
+     */
+    buckets: ({
+        start: string;
+    } & Tally)[];
+    /**
+     * The as long a span before the period, summed, to compare it with; null
+     * for all time, which has nothing before it.
+     */
+    previous: Tally | null;
+    /** By the model that ended each task in the period, the most first; null for unknown. */
+    models: ({
+        model: string | null;
+    } & Tally)[];
+    /**
+     * By where the person worked each task in the period from, the most
+     * first: null for none, as for an external agent, or one that ended
+     * before it was kept.
+     */
+    devices: ({
+        device: WorkedFrom | null;
+    } & Tally)[];
+    /** By the main tree each task in the period was in, the most first. */
+    projects: ({
+        project: string;
+    } & Tally)[];
+    /** When the first outcome was written, the start of what there is to show. */
+    since: string | null;
+    /**
+     * How conversations followed the splates skill, by the version each started
+     * on, newest first: over all time, since a version is its own span.
+     */
+    skill: SkillVersion[];
+    /** Each project's recent merged tasks, to hold one against: over the week before now, whatever the period. */
+    baselines: Baseline[];
+}
+/** How a group of ended tasks went, summed. */
+export interface Tally {
+    /** Merged tasks sharing a landing gate with at least one other task. */
+    batchedMerges: number;
+    /** Shared landing gates, counted when their leading task lands. Failed attempts are excluded. */
+    batchGates: number;
+    merged: number;
+    removed: number;
+    /** Of `merged`, those that landed without a person answering a question. */
+    clean: number;
+    /** Over every task in the group, merged and removed alike. */
+    questionRounds: number;
+    reviewRounds: number;
+    failedMerges: number;
+    /** Questions that offered the agent's pick and were answered with a choice. */
+    picksAsked: number;
+    /** Of `picksAsked`, those answered with another choice. */
+    picksOverturned: number;
+    /** Of `picksAsked`, those answered with the agent's choice and words added. */
+    picksAmended: number;
+    /** Tasks whose time waiting on a person was kept; older ones were not. */
+    timed: number;
+    /** Of the `timed` tasks, how long they waited on a person, in milliseconds. */
+    waitedMs: number;
+    /** Of the `timed` tasks, how long they took from add to end, in milliseconds. */
+    spentMs: number;
+    /** Merged tasks whose landing merge was timed; older ones were not. */
+    mergeTimed: number;
+    /** Of the `mergeTimed` tasks, how long their merges waited for the premerge lock. */
+    mergeQueuedMs: number;
+    /** Of the `mergeTimed` tasks, how long their merges ran once it was theirs. */
+    mergeRanMs: number;
+    /** Tasks whose own usage was kept; older ones and external agents' were not. */
+    used: number;
+    /** Of the `used` tasks, tokens read, those from cache among them, and written. */
+    inputTokens: number;
+    outputTokens: number;
+    /** Of the `used` tasks, those with a said or list-priced cost. */
+    costed: number;
+    /** Of the `costed` tasks, what they cost, summed. */
+    cost: number;
+    /** Of the `used` tasks, how long their agents worked, in milliseconds. */
+    workedMs: number;
+    /** Tasks that held slots on made workers, as far as it was kept. */
+    workerCosted: number;
+    /** Of the `workerCosted` tasks, those whose figure is the bill rather than list price. */
+    workerBilled: number;
+    /** Of the `workerCosted` tasks, what made workers cost them, summed. */
+    workerCost: number;
+    /** Of the `workerCosted` tasks, the slot-hours they held on made workers. */
+    workerSlotHours: number;
+    /** Tasks whose diff size was kept. */
+    sized: number;
+    /** Of the `sized` tasks, the files and lines they changed. */
+    filesChanged: number;
+    linesAdded: number;
+    linesRemoved: number;
+    /** Failed merges by why, where it was kept. */
+    failedBy: Record<MergeFailure, number>;
+    /** Each file merges conflicted in: how many conflicts, and in how many tasks. */
+    conflictedIn: Record<string, ConflictedFile>;
+    /** Removed tasks by why; `unsaid` for one removed without `--reason`, or before it was kept. */
+    removedFor: Record<RemoveReason | "unsaid", number>;
+}
+export interface ConflictedFile {
+    conflicts: number;
+    tasks: number;
+}
+/** Where the person spoke to a task's conversation from: a phone, a desktop, or both. */
+export type WorkedFrom = "phone" | "desktop" | "both";
+/** Where `outcome`'s prompts came from, or null when none was said from the page. */
+export declare function workedFrom(outcome: Outcome): WorkedFrom | null;
+/**
+ * The spans the page can look at, as `?period=` names them: how long each
+ * runs back from now, and how long each of its bars is.
+ */
+export declare const PERIODS: {
+    readonly "6h": {
+        readonly span: number;
+        readonly bucket: number;
+    };
+    readonly "1d": {
+        readonly span: number;
+        readonly bucket: number;
+    };
+    readonly "3d": {
+        readonly span: number;
+        readonly bucket: number;
+    };
+    readonly "7d": {
+        readonly span: number;
+        readonly bucket: number;
+    };
+};
+/** A span in `PERIODS`, or `all` for all time, a bar a week. */
+export type PeriodId = keyof typeof PERIODS | "all";
+export declare function isPeriodId(value: string): value is PeriodId;
+/** How long each bar of `period` is, in milliseconds: a week for all time. */
+export declare function bucketOf(period: PeriodId): number;
+export interface SummarizeOptions {
+    period?: PeriodId;
+    now?: Date;
+    /** Each conversation's skill checks as last judged. */
+    judged?: Judged[];
+    /** Narrows every figure but `Stats.projects` to the tasks of this main tree. */
+    project?: string;
+}
+/**
+ * Sums the outcomes written so far for the Stats page, over `period`. Parts
+ * are left out, since each is counted with the task that called it.
+ */
+export declare function summarize(outcomes: Outcome[], { period, now, judged, project, }?: SummarizeOptions): Stats;
+/** Tallies added up, as for the bars of a period. */
+export declare function combine(tallies: Tally[]): Tally;
+/** How one check went over the conversations on one skill version. */
+export interface CheckRate {
+    id: string;
+    rule: string;
+    /** The conversations it applied in. */
+    applied: number;
+    /** Of `applied`, those where it passed every time. */
+    passed: number;
+}
+/** How the conversations on one splates skill version followed it. */
+export interface SkillVersion {
+    /** Null for conversations whose version is unknown. */
+    skill: string | null;
+    conversations: number;
+    checks: CheckRate[];
+}
+/** Each skill version's pass rates, the newest version first and unknown last. */
+export declare function rates(judged: Judged[]): SkillVersion[];

package/vendor/@stringsync/splates-server/stats/task-log.d.ts

@@ -0,0 +1,67 @@
+import type { Entry } from "../conversations";
+import { type Catalog } from "../prices";
+import type { Log } from "../storage";
+/** What a task's turns used, apart from the rest of its conversation's. */
+export interface TaskUsage {
+    /** Tokens read, those from cache among them. */
+    input: number;
+    cached: number;
+    output: number;
+    /**
+     * What it cost at the API's list price: as Claude says, or for Codex, Kimi
+     * and OpenCode, which say none or their plan's, its tokens at the model's
+     * public price. Null when neither is known.
+     */
+    cost: {
+        amount: number;
+        currency: string;
+        /** True when splates priced its tokens, rather than the agent saying. */
+        listPrice?: boolean;
+    } | null;
+}
+/** What a task's stretch of its conversation shows of how the work went. */
+export interface TaskLog {
+    /** What the task's turns used, when its agent reported any. */
+    usage: TaskUsage | undefined;
+    /** Each agent turn's span, start to last move, summed. */
+    workedMs: number;
+    /** The agent turns that ran in it, the one it ended in among them. */
+    turns: number;
+    /** When the person stopped the agent's turn, each time. */
+    stopped: string[];
+    /** When a lost connection cut the agent's turn short, each time. */
+    interrupted: string[];
+    /** How many times each command failed. */
+    failedCommands: Record<string, number>;
+    /** Lines the agent's edits took out and put in, its plan's aside. */
+    editedLines: number;
+    /** Turns that ended asking the person questions. */
+    questionRounds: number;
+    /** Turns that ended asking the person to review the work. */
+    reviewRounds: number;
+    /**
+     * How long those turns waited on the person, each until the next thing
+     * they said, or the task's end.
+     */
+    waitedMs: number;
+    /** What the person set the model or effort to after Auto pick, in order. */
+    overrides: {
+        aspect: "model" | "effort";
+        value: string;
+        at: string;
+    }[];
+}
+/**
+ * What the conversation logged in `log` did for a task from `since` to
+ * `until`, since a conversation can outlive the task or come to it already
+ * under way; null when there is no such log. Turns of an agent that says no
+ * API cost of its own are priced from `opts.catalog`.
+ */
+export declare function taskLog(log: Log<Entry>, since: string, until: string, opts?: TaskLogOptions): Promise<TaskLog | null>;
+export interface TaskLogOptions {
+    /**
+     * The API list prices to price an agent's turns at when it says no cost
+     * of its own, asked for only then; none prices nothing.
+     */
+    catalog?: () => Promise<Catalog | null>;
+}

package/vendor/@stringsync/splates-server/storage/atomic.d.ts

@@ -0,0 +1,13 @@
+import type { Fs } from "../../../core/system/index.js";
+/**
+ * Writes `data` to `path` through a file beside it renamed into place, so a
+ * reader, or a crash mid-write, never leaves half of it there.
+ */
+export declare function replace(fs: Fs, path: string, data: string | Uint8Array): Promise<void>;
+/**
+ * What `read` gives of `path`, or null when nothing is there: an error
+ * reading a file that is there is still thrown, so a store never takes an
+ * unreadable file for a missing one and writes over it. A file another
+ * writer moved into place after the read missed it is read again.
+ */
+export declare function readIfThere<T>(fs: Fs, path: string, read: (path: string) => Promise<T>): Promise<T | null>;

package/vendor/@stringsync/splates-server/storage/collection.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Records and blobs kept by name, flat: a record is text, as a task's
+ * markdown, and a blob is bytes, as an attached file. A name holds one or
+ * the other, and never a `/`; what nests goes in a collection of its own.
+ */
+export interface Collection {
+    readonly key: string;
+    /** Makes the collection exist while empty, so a watch on it can start. */
+    ensure(): Promise<void>;
+    /** The record under `name`, or null when there is none. */
+    read(name: string): Promise<string | null>;
+    /** Keeps `text` under `name`; a reader never sees it half written. */
+    write(name: string, text: string): Promise<void>;
+    readBytes(name: string): Promise<Uint8Array | null>;
+    writeBytes(name: string, bytes: Uint8Array): Promise<void>;
+    /** Every name held, sorted. */
+    list(): Promise<string[]>;
+    /** Every name held with the bytes it takes, sorted by name. */
+    entries(): Promise<CollectionEntry[]>;
+    /** Removes what is under `name`; nothing there is no error. */
+    remove(name: string): Promise<void>;
+    /** Removes everything held. */
+    clear(): Promise<void>;
+    /** The bytes everything held takes, for a quota. */
+    size(): Promise<number>;
+}
+export interface CollectionEntry {
+    name: string;
+    size: number;
+}

package/vendor/@stringsync/splates-server/storage/document.d.ts

@@ -0,0 +1,26 @@
+import type { Schema } from "./schema";
+/**
+ * One value kept whole, as JSON: a settings file, a registry. A reader never
+ * sees a write half done.
+ */
+export interface Document<T> {
+    readonly key: string;
+    /** The value, or null when none was ever written or it was removed. */
+    read(): Promise<T | null>;
+    write(value: T): Promise<void>;
+    /**
+     * Writes what `edit` makes of the value, holding the document's lock, so
+     * two processes updating at once each build on the other's write.
+     */
+    update(edit: (current: T | null) => T | Promise<T>): Promise<T>;
+    remove(): Promise<void>;
+}
+export interface DocumentOptions<T> {
+    /**
+     * Checks what is read, throwing on a value that is not a `T`; by default
+     * it is trusted as one.
+     */
+    schema?: Schema<T>;
+    /** The lock `update` holds; `<key>.lock` by default. */
+    lock?: string;
+}

package/vendor/@stringsync/splates-server/storage/fs-collection.d.ts

@@ -0,0 +1,26 @@
+import type { Fs } from "../../../core/system/index.js";
+import type { Collection, CollectionEntry } from "./collection";
+/**
+ * A collection kept as a directory, a file per name. Directories in it, as a
+ * task's folder of attachments beside its record, are another collection's
+ * and left out.
+ */
+export declare class FsCollection implements Collection {
+    readonly key: string;
+    readonly dir: string;
+    private readonly fs;
+    constructor(key: string, dir: string, fs: Fs);
+    ensure(): Promise<void>;
+    read(name: string): Promise<string | null>;
+    write(name: string, text: string): Promise<void>;
+    readBytes(name: string): Promise<Uint8Array | null>;
+    writeBytes(name: string, bytes: Uint8Array): Promise<void>;
+    list(): Promise<string[]>;
+    entries(): Promise<CollectionEntry[]>;
+    remove(name: string): Promise<void>;
+    clear(): Promise<void>;
+    size(): Promise<number>;
+    private at;
+    /** Each file held, sorted, leaving out directories and writes in flight. */
+    private files;
+}

package/vendor/@stringsync/splates-server/storage/fs-document.d.ts

@@ -0,0 +1,16 @@
+import type { Fs, Lock } from "../../../core/system/index.js";
+import type { Document } from "./document";
+import type { Schema } from "./schema";
+/** A document kept as one JSON file, replaced whole on each write. */
+export declare class FsDocument<T> implements Document<T> {
+    readonly key: string;
+    readonly path: string;
+    private readonly fs;
+    private readonly lock;
+    private readonly schema?;
+    constructor(key: string, path: string, fs: Fs, lock: Lock, schema?: Schema<T> | undefined);
+    read(): Promise<T | null>;
+    write(value: T): Promise<void>;
+    update(edit: (current: T | null) => T | Promise<T>): Promise<T>;
+    remove(): Promise<void>;
+}

package/vendor/@stringsync/splates-server/storage/fs-log.d.ts

@@ -0,0 +1,31 @@
+import type { Fs } from "../../../core/system/index.js";
+import type { Log, Segment } from "./log";
+import type { Schema } from "./schema";
+/** A log for `FsStorage`: open one with `FsStorage.log` and use it as any `Log`. */
+export declare class FsLog<T> implements Log<T> {
+    readonly key: string;
+    readonly path: string;
+    /** The directory its segments are kept in. */
+    readonly segmentsDir: string;
+    private readonly fs;
+    private readonly schema?;
+    /** Whether the file's directory is known to be there. */
+    private made;
+    /** Whether the file last read back ended mid-line, as a crash mid-append leaves it. */
+    private torn;
+    constructor(key: string, path: string, 
+    /** The directory its segments are kept in. */
+    segmentsDir: string, fs: Fs, schema?: Schema<T> | undefined);
+    exists(): Promise<boolean>;
+    append(...entries: T[]): Promise<void>;
+    replay(): Promise<T[]>;
+    first(): Promise<T | null>;
+    compact(merge: (entries: T[]) => T[]): Promise<void>;
+    rotate(): Promise<Segment | null>;
+    segments(): Promise<Segment[]>;
+    replaySegment(segment: Segment): Promise<T[]>;
+    dropSegment(segment: Segment): Promise<void>;
+    remove(): Promise<void>;
+    private at;
+    private read;
+}

package/vendor/@stringsync/splates-server/storage/fs.d.ts

@@ -0,0 +1,48 @@
+import type { Logger } from "../../../core/log/index.js";
+import { type Fs, type Lock, type Ps } from "../../../core/system/index.js";
+import type { Collection } from "./collection";
+import type { Document, DocumentOptions } from "./document";
+import type { Log, LogOptions } from "./log";
+import type { Kept, Storage, Watch, WatchOptions } from "./storage";
+/** What makes the lock at a path. */
+export interface Locks {
+    at(path: string): Lock;
+}
+export interface FsStorageOptions {
+    /** `FileLock`s on `fs` by default. */
+    locks?: Locks;
+}
+export declare class FsStorage implements Storage {
+    readonly root: string;
+    private readonly fs;
+    private readonly locks;
+    constructor(root: string, fs: Fs, opts?: FsStorageOptions);
+    /**
+     * The storage every project on this machine shares, under the splates
+     * home: the registry, settings, the machine's workers.
+     */
+    static ofMachine({ fs, ps, log, home, stalenessMs, }: {
+        fs: Fs;
+        ps: Ps;
+        log: Logger;
+        /** The machine's home, `SPLATES_HOME` by default. */
+        home?: string;
+        /** After how long a lock counts as stale. */
+        stalenessMs?: number;
+    }): FsStorage;
+    /** Where `key` is kept on disk. */
+    path(key: string): string;
+    locate(key: string): string;
+    materialize(key: string): Promise<string>;
+    document<T>(key: string, opts?: DocumentOptions<T>): Document<T>;
+    log<T>(key: string, opts?: LogOptions<T>): Log<T>;
+    collection(key: string): Collection;
+    lock(key: string): Lock;
+    watch(key: string, opts?: WatchOptions): Watch;
+    children(key: string): Promise<string[]>;
+    size(key: string): Promise<number>;
+    keys(key: string): Promise<string[]>;
+    copy(key: string, from?: number): Promise<Kept | null>;
+    remove(key: string): Promise<void>;
+    within(key: string): Storage;
+}

package/vendor/@stringsync/splates-server/storage/index.d.ts

@@ -0,0 +1,11 @@
+export { replace } from "./atomic";
+export type { Collection, CollectionEntry } from "./collection";
+export type { Document, DocumentOptions } from "./document";
+export type { FsStorageOptions, Locks } from "./fs";
+export { FsStorage } from "./fs";
+export { keyIn } from "./key";
+export type { Log, LogOptions, Segment } from "./log";
+export type { Schema } from "./schema";
+export type { SqliteStorageOptions } from "./sqlite";
+export { SqliteStorage } from "./sqlite";
+export type { Kept, Storage, StorageChanges, Watch, WatchOptions, } from "./storage";

package/vendor/@stringsync/splates-server/storage/index.js

@@ -0,0 +1,18 @@
+import {
+  replace2,
+  keyIn2,
+  FsStorage2,
+  SqliteStorage2
+} from "../index-caep3sde.js";
+import"../index-01z7ycdk.js";
+import"../index-e9z7s5hh.js";
+import"../index-kmzdvvt0.js";
+import"../index-t9w5a8ed.js";
+import"../index-0jttnv86.js";
+import"../index-g18nxyn7.js";
+export {
+  FsStorage2 as FsStorage,
+  SqliteStorage2 as SqliteStorage,
+  keyIn2 as keyIn,
+  replace2 as replace
+};

package/vendor/@stringsync/splates-server/storage/json.d.ts

@@ -0,0 +1,10 @@
+import type { Schema } from "./schema";
+/** `value` as a document keeps it: tab-indented, ending in a newline. */
+export declare function documentText(value: unknown): string;
+/** `entries` as a log keeps them, one JSON line each. */
+export declare function logLines(entries: unknown[]): string;
+/**
+ * The entries in `raw`, one per line, leaving out any line torn by a crash
+ * mid-append or that `schema` refuses.
+ */
+export declare function entriesOf<T>(raw: string, schema?: Schema<T>): T[];

package/vendor/@stringsync/splates-server/storage/key.d.ts

@@ -0,0 +1,7 @@
+/**
+ * `key` under `base`, refusing one that would reach outside it, so a key
+ * built from what a user typed cannot name another storage's things.
+ */
+export declare function keyIn(base: string, key: string): string;
+/** `name`, refusing one that is not a single part of a key. */
+export declare function checkName(name: string): string;

package/vendor/@stringsync/splates-server/storage/log.d.ts

@@ -0,0 +1,60 @@
+import type { Schema } from "./schema";
+/**
+ * Entries a store keeps in order: `append` to it, even from two writers at
+ * once, `replay` it, `rotate` it once full, and `compact` it once its entries
+ * fold into fewer.
+ */
+export interface Log<T> {
+    readonly key: string;
+    /**
+     * Whether anything was appended since the log was made, last rotated or
+     * removed, without reading it.
+     */
+    exists(): Promise<boolean>;
+    /** Adds `entries` at the end, in one write. */
+    append(...entries: T[]): Promise<void>;
+    /**
+     * The entries since the last rotation, oldest first. A torn or unreadable
+     * entry is left out, so it loses one entry rather than the log, and the
+     * next append keeps clear of it.
+     */
+    replay(): Promise<T[]>;
+    /** The first entry since the last rotation, as `replay` reads it, without reading the rest; null for none. */
+    first(): Promise<T | null>;
+    /**
+     * Rewrites the entries since the last rotation as `merge` folds them into
+     * fewer, in one write, for entries that say no more than fewer would:
+     * those appended meanwhile stay after them. Nothing changes when `merge`
+     * returns as many as it was given.
+     */
+    compact(merge: (entries: T[]) => T[]): Promise<void>;
+    /**
+     * Moves the entries since the last rotation aside as a segment, returning
+     * it, or null when there were none. Two rotating at once is harmless: the
+     * second moves nothing, or the few entries written since.
+     */
+    rotate(): Promise<Segment | null>;
+    /** The segments rotated out, oldest first. */
+    segments(): Promise<Segment[]>;
+    /** The entries of one segment, as `replay` reads them. */
+    replaySegment(segment: Segment): Promise<T[]>;
+    dropSegment(segment: Segment): Promise<void>;
+    /** Removes the log and every segment of it. */
+    remove(): Promise<void>;
+}
+/** Entries rotated out of a log together. */
+export interface Segment {
+    /** Unique within its log, and sorting by when it was rotated. */
+    name: string;
+    /** When it was rotated, as epoch ms. */
+    at: number;
+}
+export interface LogOptions<T> {
+    /** Checks each entry read, throwing on one that is not a `T`. */
+    schema?: Schema<T>;
+    /**
+     * The key its segments are kept under, as the journal keeps its in `log`;
+     * `<key>.segments` by default.
+     */
+    segments?: string;
+}

package/vendor/@stringsync/splates-server/storage/schema.d.ts

@@ -0,0 +1,7 @@
+/**
+ * What checks a value read back is the type it was stored as, throwing when
+ * it is not: a zod schema is one.
+ */
+export interface Schema<T> {
+    parse(raw: unknown): T;
+}

package/vendor/@stringsync/splates-server/storage/sqlite-collection.d.ts

@@ -0,0 +1,31 @@
+import type { Collection, CollectionEntry } from "./collection";
+import type { SqliteDb } from "./sqlite-db";
+/**
+ * A collection for `SqliteStorage`: open one with `SqliteStorage.collection`,
+ * `list` to name what is in it, logs included, and `read` a log as its lines.
+ */
+export declare class SqliteCollection implements Collection {
+    readonly key: string;
+    /** The collection's key in the whole database. */
+    readonly at: string;
+    private readonly db;
+    /** Drops the copy written out for an agent to read, when a record goes. */
+    private readonly forget;
+    constructor(key: string, 
+    /** The collection's key in the whole database. */
+    at: string, db: SqliteDb, 
+    /** Drops the copy written out for an agent to read, when a record goes. */
+    forget?: (key: string) => Promise<void>);
+    ensure(): Promise<void>;
+    read(name: string): Promise<string | null>;
+    write(name: string, text: string): Promise<void>;
+    readBytes(name: string): Promise<Uint8Array | null>;
+    writeBytes(name: string, bytes: Uint8Array): Promise<void>;
+    list(): Promise<string[]>;
+    entries(): Promise<CollectionEntry[]>;
+    remove(name: string): Promise<void>;
+    clear(): Promise<void>;
+    size(): Promise<number>;
+    private keyOf;
+    private put;
+}

package/vendor/@stringsync/splates-server/storage/sqlite-db.d.ts

@@ -0,0 +1,62 @@
+import { Database } from "bun:sqlite";
+import { type Resource } from "../../../core/disposable/index.js";
+import { type Timer } from "../../../core/time/index.js";
+import type { Watch, WatchOptions } from "./storage";
+export interface SqliteDbOptions {
+    timer?: Timer;
+    /** How often a watch looks for what another process wrote. */
+    pollMs?: number;
+}
+/** What `SqliteDb.write` runs inside a transaction: the keys it changed, for the watches. */
+export type Write = () => string[];
+/**
+ * The database a `SqliteStorage` and every view `within` it share. Run each
+ * change through `write`, so the watches hear of it, and `dispose` the one
+ * opened to close the file.
+ */
+export declare class SqliteDb implements Resource {
+    readonly path: string;
+    readonly db: Database;
+    /** Which process's writes these are, so the poll skips what was told here already. */
+    readonly token: `${string}-${string}-${string}-${string}-${string}`;
+    private readonly watches;
+    private readonly timer;
+    private readonly pollMs;
+    private readonly open;
+    private poll;
+    /** The database's version as of the last poll, which only another connection's commit moves. */
+    private version;
+    /** The last change seq a poll took in. */
+    private seen;
+    private lastPruned;
+    constructor(path: string, opts?: SqliteDbOptions);
+    /**
+     * Runs `write` as one transaction, records each key it changed for other
+     * processes' watches, and tells this process's at once.
+     */
+    write(write: Write): void;
+    watch(root: string, at: string, opts?: WatchOptions): Watch;
+    dispose(): void;
+    /** Polls for other processes' writes while any watch is open. */
+    private startPolling;
+    /** Tells the watches of what another process wrote since the last poll. */
+    private pollChanges;
+    private dataVersion;
+    private lastSeq;
+    /**
+     * Drops change notes older than any poll could still need, now and then,
+     * and gives the file's free pages back once they add up.
+     */
+    private prune;
+    /**
+     * Turns a database made before it gave space back into one that does,
+     * shrinking it to what it holds. Rewriting the file holds every other
+     * writer off for as long, about a second for a few hundred megabytes, so
+     * it runs once, as the database first opens; a writer waiting longer than
+     * the busy timeout fails it, and it is tried at the next open.
+     */
+    private reclaim;
+    private pragma;
+    /** Tells each watch whose reach `at` is in, as one on the disk would. */
+    private tell;
+}