@earendil-works/pi-durable 1.3.0 → 1.5.0

package/dist/storage/store/queries.js

@@ -0,0 +1,93 @@
+// StoreStorage's reads as the store's queries (slice 6b D2, §2.4), compiled once from the store's query vocabulary
+// into SQL over the declared tables: no SQL is rendered per call, and a read selects only the record cell (by id, an
+// entry's commit seq too; each column returned costs) and parses one JSON text per record, as `SqliteStorage`'s do.
+const ASCENDING = { columns: ["id"], direction: "asc" };
+const DESCENDING = { columns: ["id"], direction: "desc" };
+/** The columns of a read of ids only. */
+const ID = ["id"];
+/** A placeholder value: a query's shape binds its values at each call. */
+const ANY = 0;
+/**
+ * One table's compiled reads: by id (with the `byIdExtra` columns), and by shape (conditions in binding order, an
+ * order; the record only), each shape compiled at its first use.
+ */
+export class TableQueries {
+    #table;
+    /** The record column's read of a cell at a version past 1; `undefined` while the column is at version 1. */
+    #versioned;
+    #byId;
+    #shapes = new Map();
+    #columns;
+    constructor(table, byIdExtra = []) {
+        this.#table = table;
+        const versioned = table.jsonVersion("record") > 1;
+        this.#versioned = versioned ? table.reader("record") : undefined;
+        this.#columns = versioned ? ["record", "record$v"] : ["record"];
+        this.#byId = table.prepareGet([...this.#columns, ...byIdExtra]);
+    }
+    /** The row with `id`, `undefined` when absent. */
+    byId(executor, id) {
+        return executor.get(this.#byId, id);
+    }
+    /** Up to `limit` rows whose `conditions` hold, by id in `direction`. */
+    select(executor, conditions, direction, limit) {
+        const sql = this.#shape(conditions, direction, "many");
+        return executor.all(sql, ...conditions.map(([, , value]) => value), limit);
+    }
+    /** The first row whose `conditions` hold, by id in `direction`; `undefined` when none does. */
+    first(executor, conditions, direction) {
+        const sql = this.#shape(conditions, direction, "first");
+        return executor.get(sql, ...conditions.map(([, , value]) => value));
+    }
+    /** A row's record, read as its column's (version checked, migrated on access). */
+    record(row, context) {
+        const versioned = this.#versioned;
+        // The cell holds a record of this table the storage wrote; at version 1 it is that JSON (`OwnerTable.reader`).
+        return (versioned === undefined ? JSON.parse(row.record) : versioned(row.record, row.record$v, context));
+    }
+    /** Appends the records of `rows` to `into`, in order, each read as `record` reads it (one check per call). */
+    records(rows, into, context) {
+        const versioned = this.#versioned;
+        if (versioned === undefined) {
+            for (const row of rows)
+                into.push(JSON.parse(row.record));
+            return;
+        }
+        for (const row of rows)
+            into.push(versioned(row.record, row.record$v, context));
+    }
+    /** The compiled read of a shape: its conditions' columns and comparisons, the direction, one row or many. */
+    #shape(conditions, direction, rows) {
+        let key = `${rows} ${direction}`;
+        for (const [column, condition] of conditions)
+            key += ` ${column} ${condition}`;
+        let sql = this.#shapes.get(key);
+        if (sql !== undefined)
+            return sql;
+        // One comparison per condition: the vocabulary's node of that name, its value a placeholder.
+        const nodes = conditions.map(([column, condition]) => ({ [condition]: [column, ANY] }));
+        const where = nodes.length === 0 ? undefined : { and: nodes };
+        const order = direction === "ascending" ? ASCENDING : DESCENDING;
+        sql =
+            rows === "first"
+                ? this.#table.prepareFirst(this.#columns, where, order)
+                : this.#table.prepare(this.#columns, where, order);
+        this.#shapes.set(key, sql);
+        return sql;
+    }
+}
+/** The reads of `tables`. */
+export function storageQueries(tables) {
+    const heads = tables.entryHeads;
+    return {
+        conversations: new TableQueries(tables.conversations),
+        entries: new TableQueries(tables.entries, ["commit_seq"]),
+        latestHead: {
+            any: heads.prepareFirst(ID, { eq: ["conversation_id", ANY] }, DESCENDING),
+            atOrBefore: heads.prepareFirst(ID, { and: [{ eq: ["conversation_id", ANY] }, { lte: ["id", ANY] }] }, DESCENDING),
+        },
+        tasks: new TableQueries(tables.tasks),
+        submissions: new TableQueries(tables.submissions),
+    };
+}
+//# sourceMappingURL=queries.js.map

package/dist/storage/store/queries.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"queries.js","sourceRoot":"","sources":["../../../src/storage/store/queries.ts"],"names":[],"mappings":"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","sourcesContent":["// StoreStorage's reads as the store's queries (slice 6b D2, §2.4), compiled once from the store's query vocabulary\n// into SQL over the declared tables: no SQL is rendered per call, and a read selects only the record cell (by id, an\n// entry's commit seq too; each column returned costs) and parses one JSON text per record, as `SqliteStorage`'s do.\n\nimport type { Context } from \"@earendil-works/chord\";\nimport type { Order, OwnerTable, WhereNode } from \"@earendil-works/chord/next\";\nimport type { SqliteExecutor, SqliteValue } from \"@earendil-works/chord/sqlite\";\nimport type { CommitTables } from \"./commit.ts\";\n\n/**\n * A stored row as a query selects it: the record cell, its version (selected only once the column has versions past\n * 1), and an entry's commit seq.\n */\ntype RecordRow = { readonly record: string; readonly record$v?: number; readonly commit_seq?: number };\n\n/** One condition of a read: a column, how it compares, its value; a call site keeps one order of them. */\nexport type Condition = readonly [string, \"eq\" | \"gt\" | \"lt\" | \"gte\" | \"lte\", SqliteValue];\n\nconst ASCENDING: Order = { columns: [\"id\"], direction: \"asc\" };\nconst DESCENDING: Order = { columns: [\"id\"], direction: \"desc\" };\n\n/** The columns of a read of ids only. */\nconst ID = [\"id\"];\n\n/** A placeholder value: a query's shape binds its values at each call. */\nconst ANY = 0;\n\n/**\n * One table's compiled reads: by id (with the `byIdExtra` columns), and by shape (conditions in binding order, an\n * order; the record only), each shape compiled at its first use.\n */\nexport class TableQueries {\n\treadonly #table: OwnerTable;\n\t/** The record column's read of a cell at a version past 1; `undefined` while the column is at version 1. */\n\treadonly #versioned: ((text: string, version: number, context: Context) => unknown) | undefined;\n\treadonly #byId: string;\n\treadonly #shapes = new Map<string, string>();\n\treadonly #columns: readonly string[];\n\n\tconstructor(table: OwnerTable, byIdExtra: readonly string[] = []) {\n\t\tthis.#table = table;\n\t\tconst versioned = table.jsonVersion(\"record\") > 1;\n\t\tthis.#versioned = versioned ? table.reader(\"record\") : undefined;\n\t\tthis.#columns = versioned ? [\"record\", \"record$v\"] : [\"record\"];\n\t\tthis.#byId = table.prepareGet([...this.#columns, ...byIdExtra]);\n\t}\n\n\t/** The row with `id`, `undefined` when absent. */\n\tbyId(executor: Pick<SqliteExecutor, \"get\">, id: number): Promise<RecordRow | undefined> {\n\t\treturn executor.get<RecordRow>(this.#byId, id);\n\t}\n\n\t/** Up to `limit` rows whose `conditions` hold, by id in `direction`. */\n\tselect(\n\t\texecutor: Pick<SqliteExecutor, \"all\">,\n\t\tconditions: readonly Condition[],\n\t\tdirection: \"ascending\" | \"descending\",\n\t\tlimit: number,\n\t): Promise<RecordRow[]> {\n\t\tconst sql = this.#shape(conditions, direction, \"many\");\n\t\treturn executor.all<RecordRow>(sql, ...conditions.map(([, , value]) => value), limit);\n\t}\n\n\t/** The first row whose `conditions` hold, by id in `direction`; `undefined` when none does. */\n\tfirst(\n\t\texecutor: Pick<SqliteExecutor, \"get\">,\n\t\tconditions: readonly Condition[],\n\t\tdirection: \"ascending\" | \"descending\",\n\t): Promise<RecordRow | undefined> {\n\t\tconst sql = this.#shape(conditions, direction, \"first\");\n\t\treturn executor.get<RecordRow>(sql, ...conditions.map(([, , value]) => value));\n\t}\n\n\t/** A row's record, read as its column's (version checked, migrated on access). */\n\trecord<T>(row: RecordRow, context: Context): T {\n\t\tconst versioned = this.#versioned;\n\t\t// The cell holds a record of this table the storage wrote; at version 1 it is that JSON (`OwnerTable.reader`).\n\t\treturn (versioned === undefined ? JSON.parse(row.record) : versioned(row.record, row.record$v!, context)) as T;\n\t}\n\n\t/** Appends the records of `rows` to `into`, in order, each read as `record` reads it (one check per call). */\n\trecords<T>(rows: readonly RecordRow[], into: T[], context: Context): void {\n\t\tconst versioned = this.#versioned;\n\t\tif (versioned === undefined) {\n\t\t\tfor (const row of rows) into.push(JSON.parse(row.record) as T);\n\t\t\treturn;\n\t\t}\n\t\tfor (const row of rows) into.push(versioned(row.record, row.record$v!, context) as T);\n\t}\n\n\t/** The compiled read of a shape: its conditions' columns and comparisons, the direction, one row or many. */\n\t#shape(conditions: readonly Condition[], direction: \"ascending\" | \"descending\", rows: \"first\" | \"many\"): string {\n\t\tlet key = `${rows} ${direction}`;\n\t\tfor (const [column, condition] of conditions) key += ` ${column} ${condition}`;\n\t\tlet sql = this.#shapes.get(key);\n\t\tif (sql !== undefined) return sql;\n\t\t// One comparison per condition: the vocabulary's node of that name, its value a placeholder.\n\t\tconst nodes = conditions.map(([column, condition]) => ({ [condition]: [column, ANY] }) as unknown as WhereNode);\n\t\tconst where: WhereNode | undefined = nodes.length === 0 ? undefined : { and: nodes };\n\t\tconst order = direction === \"ascending\" ? ASCENDING : DESCENDING;\n\t\tsql =\n\t\t\trows === \"first\"\n\t\t\t\t? this.#table.prepareFirst(this.#columns, where, order)\n\t\t\t\t: this.#table.prepare(this.#columns, where, order);\n\t\tthis.#shapes.set(key, sql);\n\t\treturn sql;\n\t}\n}\n\n/** The compiled reads of the storage's tables. */\nexport type StorageQueries = {\n\treadonly conversations: TableQueries;\n\treadonly entries: TableQueries;\n\t/** The id of a conversation's newest entry with a head marker: any, or at or before an id (bound second). */\n\treadonly latestHead: { readonly any: string; readonly atOrBefore: string };\n\treadonly tasks: TableQueries;\n\treadonly submissions: TableQueries;\n};\n\n/** The reads of `tables`. */\nexport function storageQueries(tables: CommitTables): StorageQueries {\n\tconst heads = tables.entryHeads;\n\treturn {\n\t\tconversations: new TableQueries(tables.conversations),\n\t\tentries: new TableQueries(tables.entries, [\"commit_seq\"]),\n\t\tlatestHead: {\n\t\t\tany: heads.prepareFirst(ID, { eq: [\"conversation_id\", ANY] }, DESCENDING),\n\t\t\tatOrBefore: heads.prepareFirst(\n\t\t\t\tID,\n\t\t\t\t{ and: [{ eq: [\"conversation_id\", ANY] }, { lte: [\"id\", ANY] }] },\n\t\t\t\tDESCENDING,\n\t\t\t),\n\t\t},\n\t\ttasks: new TableQueries(tables.tasks),\n\t\tsubmissions: new TableQueries(tables.submissions),\n\t};\n}\n"]}

package/dist/storage/store/storage.d.ts

@@ -0,0 +1,59 @@
+import type { Context, JsonValue } from "@earendil-works/chord";
+import { type Store } from "@earendil-works/chord/next";
+import type { CommitResult, ConversationId, ConversationQuery, ConversationRecord, Cursor, DocumentAddress, DocumentId, DocumentPoint, DocumentQuery, DocumentRecord, EntryId, EntryQuery, EntryRecord, Id, Page, Seq, Storage, StorageWrite, StoredDocument, SubmissionId, SubmissionQuery, SubmissionRecord, TaskId, TaskQuery, TaskRecord } from "../../types.ts";
+type StoredTask = TaskRecord<JsonValue, JsonValue, JsonValue>;
+type StoredEntry = {
+    readonly entry: EntryRecord;
+    readonly commitSeq: Seq;
+};
+/**
+ * Durable's `Storage` on Chord's store (slice 6b D1, D2, §2): its records as declared tables under an owner name, its
+ * documents in the store's documents engine, its ids from the store's one allocator, each commit call as one series
+ * of the store's commit queue (one backend transaction, one seq per batch), published in the host's batch. Several may share a store under distinct owner names
+ * (claims); the app owns the store, and `close` leaves it open.
+ */
+export declare class StoreStorage implements Storage {
+    #private;
+    private constructor();
+    /**
+     * Opens Durable's storage in `store` under `owner` (a lowercase `[a-z0-9@/._~-]` name): claims its tables and its
+     * document namespaces (a second claim is refused `invalid/args`), creates or migrates its tables, and raises the
+     * store's allocator above every id it holds (one index read). A failure releases what it claimed.
+     */
+    static open(store: Store, owner: string, context: Context): Promise<StoreStorage>;
+    /**
+     * Commit `batches` as one series of the store (`ChordStore.commitSeries`): one backend transaction, one seq per
+     * batch, each batch's checks (at staging, then against the state the earlier ones left) before its writes.
+     */
+    commit(batches: readonly (readonly StorageWrite[])[], receive: (index: number, seq: Seq) => void, context: Context): Promise<CommitResult>;
+    /**
+     * Run a commit's publication in the attached host's batch (`batch.within`: it joins a running batch, opens one, or
+     * runs next while one sends): Chord sources over Durable's views are marked in one batch per commit. Plainly without
+     * a host.
+     */
+    publishing(publish: () => void, context: Context): void;
+    mintId<I extends Id<string>>(): Promise<I>;
+    conversation(id: ConversationId, context: Context): Promise<ConversationRecord | undefined>;
+    scanConversations(query: ConversationQuery, limit: number, cursor: Cursor | undefined, context: Context): Promise<Page<ConversationRecord, Cursor>>;
+    entry(id: EntryId, context: Context): Promise<StoredEntry | undefined>;
+    entry(conversationId: ConversationId, id: EntryId, context: Context): Promise<StoredEntry | undefined>;
+    findLatestHeadMarker(conversationId: ConversationId, atOrBeforeEntryId: EntryId | undefined, context: Context): Promise<(EntryRecord & {
+        readonly head: EntryId;
+    }) | undefined>;
+    scanEntries(query: EntryQuery, limit: number, cursor: Cursor | undefined, context: Context): Promise<Page<EntryRecord, Cursor>>;
+    task(id: TaskId, context: Context): Promise<StoredTask | undefined>;
+    scanTasks(query: TaskQuery, limit: number, cursor: Cursor | undefined, context: Context): Promise<Page<StoredTask, Cursor>>;
+    submission(id: SubmissionId, context: Context): Promise<SubmissionRecord | undefined>;
+    scanSubmissions(query: SubmissionQuery, limit: number, cursor: Cursor | undefined, context: Context): Promise<Page<SubmissionRecord, Cursor>>;
+    submissionByRequest(conversationId: ConversationId, requestId: string, context: Context): Promise<SubmissionRecord | undefined>;
+    findDocument(address: DocumentAddress, at: DocumentPoint, context: Context): Promise<DocumentRecord | undefined>;
+    document(id: DocumentId, at: DocumentPoint, context: Context): Promise<StoredDocument | undefined>;
+    scanDocuments(query: DocumentQuery, limit: number, cursor: Cursor | undefined, context: Context): Promise<Page<DocumentRecord, Cursor>>;
+    /**
+     * Refuses new calls, waits for its commits underway, then releases its claims; the store stays open (the app's),
+     * and finishes the reads underway, which change nothing.
+     */
+    close(_context: Context): Promise<void>;
+}
+export {};
+//# sourceMappingURL=storage.d.ts.map

package/dist/storage/store/storage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"storage.d.ts","sourceRoot":"","sources":["../../../src/storage/store/storage.ts"],"names":[],"mappings":"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"}

package/dist/storage/store/storage.js

@@ -0,0 +1,438 @@
+// Durable's `Storage` on Chord's store (slice 6b D1, D2, §2): opening under an owner name (claims, tables, the
+// allocator), commits as one composite write of the store's commit step, and the reads, each one guarded read of the
+// store (several queries at one state in a read transaction), its request errors in a tagged result told after it.
+import { findDocumentEntry, listDocumentEntries, StoreOwnerTables, } from "@earendil-works/chord/next";
+import { StorageRequestError } from "../../errors.js";
+import { idFromNumber, seqFromNumber } from "../../ids.js";
+import { nextCursor, scanStart } from "../scan.js";
+import { DurableCommit } from "./commit.js";
+import { addressOf, namespaceOf, readAt, recordOfEntry, SCOPE_NAMESPACES } from "./documents.js";
+import { storageQueries } from "./queries.js";
+import { Conversations, Entries, EntryHeads, encodeIndexed, RecordIds, Submissions, Tasks } from "./tables.js";
+/** The id condition of a table scan from `start`. */
+function scanFrom(start) {
+    return start.order === "ascending"
+        ? ["id", "gt", start.after ?? -1]
+        : ["id", "lt", start.after ?? Number.MAX_SAFE_INTEGER];
+}
+function page(values, limit, order) {
+    const items = values.slice(0, limit);
+    if (values.length <= limit)
+        return { items };
+    return { items, next: nextCursor(items.at(-1).id, order) };
+}
+function cursorId(cursor) {
+    const after = cursor?.after;
+    if (after === undefined)
+        return undefined;
+    if (typeof after !== "number" || !Number.isSafeInteger(after))
+        throw new StorageRequestError("Invalid storage cursor");
+    return after;
+}
+/**
+ * Durable's `Storage` on Chord's store (slice 6b D1, D2, §2): its records as declared tables under an owner name, its
+ * documents in the store's documents engine, its ids from the store's one allocator, each commit call as one series
+ * of the store's commit queue (one backend transaction, one seq per batch), published in the host's batch. Several may share a store under distinct owner names
+ * (claims); the app owns the store, and `close` leaves it open.
+ */
+export class StoreStorage {
+    #store;
+    #owner;
+    #claimant;
+    #tables;
+    #queries;
+    #closed = false;
+    #closing;
+    /** Calls underway, which `close` waits for before it releases the claims (`#drained` once they reach 0). */
+    #underway = 0;
+    #drained;
+    constructor(store, owner, claimant, tables) {
+        this.#store = store;
+        this.#owner = owner;
+        this.#claimant = claimant;
+        this.#tables = tables;
+        this.#queries = storageQueries(tables);
+    }
+    /**
+     * Opens Durable's storage in `store` under `owner` (a lowercase `[a-z0-9@/._~-]` name): claims its tables and its
+     * document namespaces (a second claim is refused `invalid/args`), creates or migrates its tables, and raises the
+     * store's allocator above every id it holds (one index read). A failure releases what it claimed.
+     */
+    static async open(store, owner, context) {
+        // Chord's own: `openStore` or `importStore` made it.
+        const chord = store;
+        const claimant = { label: `StoreStorage(${owner})` };
+        try {
+            const declared = new StoreOwnerTables(chord, owner, claimant);
+            const tables = {
+                recordIds: declared.declare(RecordIds),
+                conversations: declared.declare(Conversations),
+                entries: declared.declare(Entries),
+                entryHeads: declared.declare(EntryHeads),
+                tasks: declared.declare(Tasks),
+                submissions: declared.declare(Submissions),
+            };
+            for (const namespace of SCOPE_NAMESPACES)
+                chord.claims.documents(owner, namespace, claimant);
+            await declared.prepare(context);
+            const highest = await chord.read((executor) => executor.get(`SELECT max("id") AS id FROM "${tables.recordIds.sql.table}"`), context);
+            if (highest?.id != null)
+                chord.ids.raise(highest.id);
+            return new StoreStorage(chord, owner, claimant, tables);
+        }
+        catch (error) {
+            chord.claims.release(claimant);
+            throw error;
+        }
+    }
+    /**
+     * Commit `batches` as one series of the store (`ChordStore.commitSeries`): one backend transaction, one seq per
+     * batch, each batch's checks (at staging, then against the state the earlier ones left) before its writes.
+     */
+    commit(batches, receive, context) {
+        return this.#call(() => {
+            const store = this.#store;
+            const raise = (id) => store.ids.raise(id);
+            const commits = [];
+            for (const writes of batches) {
+                try {
+                    commits.push(new DurableCommit(writes, this.#owner, this.#tables, raise, context));
+                }
+                catch (error) {
+                    // Staging runs Durable's checks of the batch itself: a refusal in its turn, the batches before it stored.
+                    commits.push({ check: () => Promise.reject(error), writes: [] });
+                    break;
+                }
+            }
+            return store.commitSeries(commits, (index, seq) => receive(index, seqFromNumber(seq)), context);
+        });
+    }
+    /**
+     * Run a commit's publication in the attached host's batch (`batch.within`: it joins a running batch, opens one, or
+     * runs next while one sends): Chord sources over Durable's views are marked in one batch per commit. Plainly without
+     * a host.
+     */
+    publishing(publish, context) {
+        const batch = this.#store.batch;
+        if (batch === undefined)
+            publish();
+        else
+            batch.within(publish, context);
+    }
+    mintId() {
+        return this.#call(async () => idFromNumber(this.#store.mintId()));
+    }
+    conversation(id, context) {
+        return this.#read((executor) => this.#conversation(executor, id, context), context);
+    }
+    scanConversations(query, limit, cursor, context) {
+        return this.#reading(() => {
+            const start = scanStart(query.order, cursor, "ascending");
+            const conditions = [scanFrom(start)];
+            if (query.ownerConversationId !== undefined) {
+                conditions.push(["owner_conversation_id", "eq", query.ownerConversationId]);
+            }
+            if (query.ownerTaskId !== undefined)
+                conditions.push(["owner_task_id", "eq", query.ownerTaskId]);
+            return this.#scan(this.#queries.conversations, conditions, start, limit, context);
+        });
+    }
+    entry(idOrConversationId, idOrContext, maybeContext) {
+        if (maybeContext === undefined) {
+            const context = idOrContext;
+            return this.#read((executor) => this.#entry(executor, idOrConversationId, context), context);
+        }
+        const context = maybeContext;
+        const id = typeof idOrContext === "number" ? idFromNumber(idOrContext) : undefined;
+        return this.#reading(() => {
+            if (id === undefined)
+                throw new StorageRequestError("Storage.entry() requires an entry ID");
+            const conversationId = idOrConversationId;
+            return this.#store
+                .read((executor) => this.#visibleEntry(executor, conversationId, id, context), context)
+                .then(told);
+        });
+    }
+    findLatestHeadMarker(conversationId, atOrBeforeEntryId, context) {
+        return this.#reading(() => this.#store
+            .read((executor) => this.#latestHeadMarker(executor, conversationId, atOrBeforeEntryId, context), context)
+            .then(told));
+    }
+    scanEntries(query, limit, cursor, context) {
+        return this.#reading(() => {
+            const { order, after } = scanStart(query.order, cursor, "descending");
+            const read = order === "ascending"
+                ? (executor) => this.#entriesAscending(executor, query, limit, after, context)
+                : (executor) => this.#entriesDescending(executor, query, limit, after, context);
+            return this.#store.read(read, context).then(told);
+        });
+    }
+    task(id, context) {
+        const tasks = this.#queries.tasks;
+        return this.#read(async (executor) => {
+            const row = await tasks.byId(executor, id);
+            return row === undefined ? undefined : tasks.record(row, context);
+        }, context);
+    }
+    scanTasks(query, limit, cursor, context) {
+        return this.#reading(() => {
+            const start = scanStart(query.order, cursor, "ascending");
+            const conditions = [scanFrom(start)];
+            if (query.conversationId !== undefined)
+                conditions.push(["conversation_id", "eq", query.conversationId]);
+            if (query.kind !== undefined)
+                conditions.push(["kind", "eq", encodeIndexed(query.kind)]);
+            if (query.status !== undefined)
+                conditions.push(["status", "eq", query.status]);
+            if (query.abortRequested !== undefined)
+                conditions.push(["abort_requested", "eq", query.abortRequested ? 1 : 0]);
+            if (query.background !== undefined)
+                conditions.push(["background", "eq", query.background ? 1 : 0]);
+            return this.#scan(this.#queries.tasks, conditions, start, limit, context);
+        });
+    }
+    submission(id, context) {
+        const submissions = this.#queries.submissions;
+        return this.#read(async (executor) => {
+            const row = await submissions.byId(executor, id);
+            return row === undefined ? undefined : submissions.record(row, context);
+        }, context);
+    }
+    scanSubmissions(query, limit, cursor, context) {
+        return this.#reading(() => {
+            const start = scanStart(query.order, cursor, "ascending");
+            const conditions = [scanFrom(start)];
+            if (query.conversationId !== undefined)
+                conditions.push(["conversation_id", "eq", query.conversationId]);
+            if (query.status !== undefined)
+                conditions.push(["status", "eq", query.status]);
+            return this.#scan(this.#queries.submissions, conditions, start, limit, context);
+        });
+    }
+    submissionByRequest(conversationId, requestId, context) {
+        const submissions = this.#queries.submissions;
+        const conditions = [
+            ["conversation_id", "eq", conversationId],
+            ["request_id", "eq", encodeIndexed(requestId)],
+        ];
+        return this.#read(async (executor) => {
+            const row = await submissions.first(executor, conditions, "ascending");
+            return row === undefined ? undefined : submissions.record(row, context);
+        }, context);
+    }
+    findDocument(address, at, context) {
+        return this.#read(async (executor) => {
+            const entry = await findDocumentEntry(executor, addressOf(address, this.#owner), at);
+            return entry === undefined ? undefined : recordOfEntry(entry);
+        }, context);
+    }
+    document(id, at, context) {
+        // The record and its revisions must come from one committed state (S4).
+        return this.#reading(() => this.#store.readTransaction((executor) => readAt(executor, id, at, this.#owner), context).then(documentOf));
+    }
+    scanDocuments(query, limit, cursor, context) {
+        return this.#reading(() => {
+            const after = cursorId(cursor) ?? -1;
+            const scope = {
+                owner: this.#owner,
+                namespace: namespaceOf(query.scope),
+                ...(query.kind === undefined ? {} : { kind: encodeIndexed(query.kind) }),
+            };
+            return this.#store
+                .read((executor) => listDocumentEntries(executor, scope, query.at, after, limit + 1), context)
+                .then((found) => page(found.map(recordOfEntry), limit, "ascending"));
+        });
+    }
+    /**
+     * Refuses new calls, waits for its commits underway, then releases its claims; the store stays open (the app's),
+     * and finishes the reads underway, which change nothing.
+     */
+    close(_context) {
+        if (this.#closing === undefined) {
+            this.#closed = true;
+            this.#closing = (async () => {
+                if (this.#underway > 0) {
+                    await new Promise((resolve) => {
+                        this.#drained = resolve;
+                    });
+                }
+                this.#store.claims.release(this.#claimant);
+            })();
+        }
+        return this.#closing;
+    }
+    /** Runs one commit or mint of this storage: refused once it closed, counted until it settles (`close` waits). */
+    async #call(run) {
+        if (this.#closed)
+            throw new Error("StoreStorage is closed");
+        this.#underway++;
+        try {
+            return await run();
+        }
+        finally {
+            if (--this.#underway === 0)
+                this.#drained?.();
+        }
+    }
+    /**
+     * A call that is one guarded read of the store: refused once closed; not waited for by `close` (a read changes
+     * nothing, and the store, which stays open, finishes it).
+     */
+    #read(read, context) {
+        return this.#reading(() => this.#store.read(read, context));
+    }
+    /**
+     * A read call: `read` prepares its guarded read (a request error thrown then, before it) and returns it. Refused
+     * once closed; one promise per call besides the guard's (no async wrapper).
+     */
+    #reading(read) {
+        try {
+            if (this.#closed)
+                throw new Error("StoreStorage is closed");
+            return read();
+        }
+        catch (error) {
+            return Promise.reject(error);
+        }
+    }
+    async #conversation(executor, id, context) {
+        const conversations = this.#queries.conversations;
+        const row = await conversations.byId(executor, id);
+        return row === undefined ? undefined : conversations.record(row, context);
+    }
+    #entry(executor, id, context) {
+        const entries = this.#queries.entries;
+        return entries.byId(executor, id).then((row) => {
+            if (row === undefined)
+                return undefined;
+            return { entry: entries.record(row, context), commitSeq: seqFromNumber(row.commit_seq) };
+        });
+    }
+    /** Entry `id` when visible through `conversationId`'s fork chain (`SqliteStorage.readEntry`). */
+    async #visibleEntry(executor, conversationId, id, context) {
+        let conversation = await this.#conversation(executor, conversationId, context);
+        if (conversation === undefined)
+            return unknownConversation(conversationId);
+        const stored = await this.#entry(executor, id, context);
+        if (stored === undefined)
+            return NOTHING_FOUND;
+        let upper = Number.POSITIVE_INFINITY;
+        while (conversation.id !== stored.entry.conversationId) {
+            if (conversation.parent === undefined)
+                return NOTHING_FOUND;
+            upper = Math.min(upper, conversation.parent.at);
+            conversation = (await this.#conversation(executor, conversation.parent.conversationId, context));
+        }
+        return stored.entry.id > upper ? NOTHING_FOUND : { kind: "found", value: stored };
+    }
+    async #latestHeadMarker(executor, conversationId, atOrBeforeEntryId, context) {
+        let conversation = await this.#conversation(executor, conversationId, context);
+        if (conversation === undefined)
+            return unknownConversation(conversationId);
+        let upper = atOrBeforeEntryId;
+        while (true) {
+            const { latestHead } = this.#queries;
+            const head = upper === undefined
+                ? await executor.get(latestHead.any, conversation.id)
+                : await executor.get(latestHead.atOrBefore, conversation.id, upper);
+            if (head !== undefined) {
+                // Written with its entry, in the same commit.
+                const row = (await this.#queries.entries.byId(executor, head.id));
+                const value = this.#queries.entries.record(row, context);
+                return { kind: "found", value };
+            }
+            if (conversation.parent === undefined)
+                return NOTHING_FOUND;
+            upper = upper === undefined ? conversation.parent.at : Math.min(upper, conversation.parent.at);
+            conversation = (await this.#conversation(executor, conversation.parent.conversationId, context));
+        }
+    }
+    /** Newest first: each conversation of the fork chain up to its fork point (`SqliteStorage.readEntries`). */
+    async #entriesDescending(executor, query, limit, after, context) {
+        let conversation = await this.#conversation(executor, query.conversationId, context);
+        if (conversation === undefined)
+            return unknownConversation(query.conversationId);
+        let upper = query.maxEntryId;
+        if (after !== undefined)
+            upper = Math.min(upper ?? Number.MAX_SAFE_INTEGER, after - 1);
+        const values = [];
+        while (true) {
+            const range = this.#range(conversation.id, query.minEntryId, upper);
+            const rows = await this.#queries.entries.select(executor, range, "descending", limit + 1 - values.length);
+            this.#queries.entries.records(rows, values, context);
+            if (values.length > limit || conversation.parent === undefined)
+                break;
+            upper = upper === undefined ? conversation.parent.at : Math.min(upper, conversation.parent.at);
+            if (query.minEntryId !== undefined && upper < query.minEntryId)
+                break;
+            conversation = (await this.#conversation(executor, conversation.parent.conversationId, context));
+        }
+        return { kind: "found", value: page(values, limit, "descending") };
+    }
+    /** Oldest first: the fork chain's segments from the root forward, each up to its fork point. */
+    async #entriesAscending(executor, query, limit, after, context) {
+        const segments = [];
+        let conversation = await this.#conversation(executor, query.conversationId, context);
+        if (conversation === undefined)
+            return unknownConversation(query.conversationId);
+        let upper = query.maxEntryId;
+        while (true) {
+            segments.push({ conversationId: conversation.id, upper });
+            if (conversation.parent === undefined)
+                break;
+            upper = upper === undefined ? conversation.parent.at : Math.min(upper, conversation.parent.at);
+            if (query.minEntryId !== undefined && upper < query.minEntryId)
+                break;
+            conversation = (await this.#conversation(executor, conversation.parent.conversationId, context));
+        }
+        let lower = query.minEntryId;
+        if (after !== undefined)
+            lower = Math.max(lower ?? after + 1, after + 1);
+        const values = [];
+        for (const segment of segments.reverse()) {
+            const range = this.#range(segment.conversationId, lower, segment.upper);
+            const rows = await this.#queries.entries.select(executor, range, "ascending", limit + 1 - values.length);
+            this.#queries.entries.records(rows, values, context);
+            if (values.length > limit)
+                break;
+        }
+        return { kind: "found", value: page(values, limit, "ascending") };
+    }
+    /** One conversation's entries with ids from `lower` to `upper` (inclusive, each optional). */
+    #range(conversationId, lower, upper) {
+        const conditions = [["conversation_id", "eq", conversationId]];
+        if (lower !== undefined)
+            conditions.push(["id", "gte", lower]);
+        if (upper !== undefined)
+            conditions.push(["id", "lte", upper]);
+        return conditions;
+    }
+    /** A page of a table scan: up to `limit` records of `queries`' table whose `conditions` hold, from `start`. */
+    #scan(queries, conditions, start, limit, context) {
+        return this.#store
+            .read((executor) => queries.select(executor, conditions, start.order, limit + 1), context)
+            .then((rows) => {
+            const values = [];
+            queries.records(rows, values, context);
+            return page(values, limit, start.order);
+        });
+    }
+}
+/** A read that found nothing. */
+const NOTHING_FOUND = { kind: "found", value: undefined };
+function unknownConversation(id) {
+    return { kind: "refused", message: `Unknown conversation: ${id}` };
+}
+/** A read's data, its request error thrown now that the guarded read returned (slice 6b §1.4). */
+function told(read) {
+    if (read.kind === "refused")
+        throw new StorageRequestError(read.message);
+    return read.value;
+}
+/** A document read's result, a record that keeps no history at the point thrown as Durable's request error. */
+function documentOf(read) {
+    if (read.kind === "current_only")
+        throw new StorageRequestError(`Document ${read.id} does not retain historical content`);
+    return read.document;
+}
+//# sourceMappingURL=storage.js.map