@earendil-works/chord 1.4.0 → 1.5.1

package/dist/state/writable.js

@@ -0,0 +1,49 @@
+// Writables (slice 8 §2, design §17): `self.writable(initial)`, an in-process value its attempt sets, identity
+// compared; a contribution, a derive source and an `on` source, never a state member.
+import { FollowedSource } from "./native-source.js";
+/** A writable: its value, set by its owner's code, delivered through the host's batch. */
+export class WritableSource extends FollowedSource {
+    #value;
+    #ownership;
+    constructor(initial, owner, batch) {
+        super(batch);
+        this.#value = initial;
+        this.#ownership = { kind: "owned", owner };
+    }
+    get value() {
+        return this.#value;
+    }
+    set(value) {
+        const ownership = this.#ownership;
+        if (ownership.kind === "ended")
+            throw ownership.error;
+        ownership.owner.assertUsable();
+        // The cost guard: setting the value it has costs one comparison past the seal check.
+        if (value === this.#value)
+            return;
+        const batch = this.batch;
+        batch.assertNotComputing("writable.set");
+        this.#change(value, batch, ownership.owner.context);
+    }
+    /**
+     * Adopts `value` in the batch running now, or in one of its own. Apart from `set`: a closure there would make every
+     * `set` allocate its context, the same value's too.
+     */
+    #change(value, batch, context) {
+        batch.within(() => {
+            this.#value = value;
+            this.changed();
+        }, context);
+    }
+    /**
+     * Its attempt ended with `error`: its watches end `ended`, `set` throws `error`, its value stays readable; it keeps
+     * neither its attempt nor the host.
+     */
+    detach(error) {
+        // Kept by `set`: its stack is made text now, so it holds none of the frames' objects.
+        void error.stack;
+        this.#ownership = { kind: "ended", error };
+        this.end();
+    }
+}
+//# sourceMappingURL=writable.js.map

package/dist/state/writable.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"writable.js","sourceRoot":"","sources":["../../src/state/writable.ts"],"names":[],"mappings":"AAAA,+GAA+G;AAC/G,sFAAsF;AAKtF,OAAO,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAwBpD,0FAA0F;AAC1F,MAAM,OAAO,cAAkB,SAAQ,cAAiB;IACvD,MAAM,CAAI;IACV,UAAU,CAAY;IAEtB,YAAY,OAAU,EAAE,KAAoB,EAAE,KAAY;QACzD,KAAK,CAAC,KAAK,CAAC,CAAC;QACb,IAAI,CAAC,MAAM,GAAG,OAAO,CAAC;QACtB,IAAI,CAAC,UAAU,GAAG,EAAE,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,CAAC;IAC5C,CAAC;IAED,IAAI,KAAK;QACR,OAAO,IAAI,CAAC,MAAM,CAAC;IACpB,CAAC;IAED,GAAG,CAAC,KAAQ;QACX,MAAM,SAAS,GAAG,IAAI,CAAC,UAAU,CAAC;QAClC,IAAI,SAAS,CAAC,IAAI,KAAK,OAAO;YAAE,MAAM,SAAS,CAAC,KAAK,CAAC;QACtD,SAAS,CAAC,KAAK,CAAC,YAAY,EAAE,CAAC;QAC/B,qFAAqF;QACrF,IAAI,KAAK,KAAK,IAAI,CAAC,MAAM;YAAE,OAAO;QAClC,MAAM,KAAK,GAAG,IAAI,CAAC,KAAM,CAAC;QAC1B,KAAK,CAAC,kBAAkB,CAAC,cAAc,CAAC,CAAC;QACzC,IAAI,CAAC,OAAO,CAAC,KAAK,EAAE,KAAK,EAAE,SAAS,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;IACrD,CAAC;IAED;;;OAGG;IACH,OAAO,CAAC,KAAQ,EAAE,KAAY,EAAE,OAAgB;QAC/C,KAAK,CAAC,MAAM,CAAC,GAAG,EAAE;YACjB,IAAI,CAAC,MAAM,GAAG,KAAK,CAAC;YACpB,IAAI,CAAC,OAAO,EAAE,CAAC;QAChB,CAAC,EAAE,OAAO,CAAC,CAAC;IACb,CAAC;IAED;;;OAGG;IACH,MAAM,CAAC,KAAY;QAClB,sFAAsF;QACtF,KAAK,KAAK,CAAC,KAAK,CAAC;QACjB,IAAI,CAAC,UAAU,GAAG,EAAE,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,CAAC;QAC3C,IAAI,CAAC,GAAG,EAAE,CAAC;IACZ,CAAC;CACD","sourcesContent":["// Writables (slice 8 §2, design §17): `self.writable(initial)`, an in-process value its attempt sets, identity\n// compared; a contribution, a derive source and an `on` source, never a state member.\n\nimport type { Context } from \"../context/index.ts\";\nimport type { NativeWatchable } from \"../watch.ts\";\nimport type { Batch } from \"./batch.ts\";\nimport { FollowedSource } from \"./native-source.ts\";\n\n/** An in-process value that changes when its owner sets it; `set` of the same value notifies nobody. */\nexport interface Writable<T> extends NativeWatchable<T> {\n\t/**\n\t * Sets the value: a new value (by identity) is a new frame for its watches and marks the derives and registry\n\t * tables reading it, in the batch running now or in one of its own. Throws `released` once its attempt ended, and\n\t * `invalid/reentrant` inside a derive compute or a `compose`.\n\t */\n\tset(value: T): void;\n}\n\n/** Who owns a writable: the context its own batches run in, and the check that its attempt still runs. */\nexport type WritableOwner = {\n\treadonly context: Context;\n\t/** Throws `released` once the attempt that made it was sealed. */\n\tassertUsable(): void;\n};\n\n/** Whom a writable belongs to: its running attempt, or nothing once that attempt ended (its error kept). */\ntype Ownership =\n\t| { readonly kind: \"owned\"; readonly owner: WritableOwner }\n\t| { readonly kind: \"ended\"; readonly error: Error };\n\n/** A writable: its value, set by its owner's code, delivered through the host's batch. */\nexport class WritableSource<T> extends FollowedSource<T> implements Writable<T> {\n\t#value: T;\n\t#ownership: Ownership;\n\n\tconstructor(initial: T, owner: WritableOwner, batch: Batch) {\n\t\tsuper(batch);\n\t\tthis.#value = initial;\n\t\tthis.#ownership = { kind: \"owned\", owner };\n\t}\n\n\tget value(): T {\n\t\treturn this.#value;\n\t}\n\n\tset(value: T): void {\n\t\tconst ownership = this.#ownership;\n\t\tif (ownership.kind === \"ended\") throw ownership.error;\n\t\townership.owner.assertUsable();\n\t\t// The cost guard: setting the value it has costs one comparison past the seal check.\n\t\tif (value === this.#value) return;\n\t\tconst batch = this.batch!;\n\t\tbatch.assertNotComputing(\"writable.set\");\n\t\tthis.#change(value, batch, ownership.owner.context);\n\t}\n\n\t/**\n\t * Adopts `value` in the batch running now, or in one of its own. Apart from `set`: a closure there would make every\n\t * `set` allocate its context, the same value's too.\n\t */\n\t#change(value: T, batch: Batch, context: Context): void {\n\t\tbatch.within(() => {\n\t\t\tthis.#value = value;\n\t\t\tthis.changed();\n\t\t}, context);\n\t}\n\n\t/**\n\t * Its attempt ended with `error`: its watches end `ended`, `set` throws `error`, its value stays readable; it keeps\n\t * neither its attempt nor the host.\n\t */\n\tdetach(error: Error): void {\n\t\t// Kept by `set`: its stack is made text now, so it holds none of the frames' objects.\n\t\tvoid error.stack;\n\t\tthis.#ownership = { kind: \"ended\", error };\n\t\tthis.end();\n\t}\n}\n"]}

package/dist/store/adapter.d.ts

@@ -0,0 +1,67 @@
+import type { Context } from "../context/index.ts";
+import type { SqliteExecutor, SqliteValue } from "../sqlite/index.ts";
+import type { Claimant } from "./claims.ts";
+import type { WhereNode } from "./expression.ts";
+import type { EncodedRow } from "./rows.ts";
+import { type Order, TableSql } from "./sql.ts";
+import type { Step } from "./step.ts";
+import type { ChordStore } from "./store.ts";
+import type { TableDefinition } from "./table.ts";
+import type { TableWrite } from "./table-writes.ts";
+/** A stored row as reads decode it. */
+export type DecodedRow = {
+    readonly [column: string]: unknown;
+};
+/**
+ * The tables of one owner name in a store: each declared once (its SQL name `"<owner>:<table>"` claimed for
+ * `claimant`), then prepared together (created at their newest version or migrated, as `self.table`'s are).
+ */
+export declare class StoreOwnerTables {
+    #private;
+    readonly store: ChordStore;
+    readonly owner: string;
+    /** `owner` is a restricted name (lowercase `[a-z0-9@/._~-]`): it becomes the first part of SQL names. */
+    constructor(store: ChordStore, owner: string, claimant: Claimant);
+    /** Declares `definition` under the owner, claiming its SQL name (held by another: `invalid/args`). */
+    declare(definition: TableDefinition): OwnerTable;
+    /** Brings every declared table to its definition: created fresh, or migrated eagerly in their commits. */
+    prepare(context: Context): Promise<void>;
+}
+/** One declared table of an owner: its rows encoded and written in a step, its reads by key and by query. */
+export declare class OwnerTable {
+    readonly definition: TableDefinition;
+    readonly sql: TableSql;
+    constructor(definition: TableDefinition, table: string);
+    /** `row` checked and encoded for a `put` (a trust boundary, rule 8: at staging, before the queue). */
+    encode(row: unknown): EncodedRow;
+    /**
+     * Writes `encoded` in `step` (an upsert) and returns the `put` as recorded; `stamp` names an `int` column that takes
+     * the step's seq (Durable's `entries.commit_seq`), in the row and in the record.
+     */
+    put(step: Step, encoded: EncodedRow, stamp?: string): Promise<TableWrite>;
+    /** The row with the key `params` (in key order), decoded. */
+    get(executor: Pick<SqliteExecutor, "get">, params: readonly SqliteValue[], context: Context): Promise<DecodedRow | undefined>;
+    /**
+     * A read compiled once (the store's query vocabulary rendered to SQL): `columns` of the rows `where` matches in
+     * `order`. The values in `where` only shape it: each is a `?` the caller binds in the order the conditions take
+     * them, then the limit. Adapters keep their fixed reads so: no SQL is rendered per call.
+     */
+    prepare(columns: readonly string[], where: WhereNode | undefined, order: Order): string;
+    /** `prepare` for the first row only: the limit is a literal `1` (a bound one costs SQLite a plan step per call). */
+    prepareFirst(columns: readonly string[], where: WhereNode | undefined, order: Order): string;
+    /**
+     * The version of `json(...)` column `column`: at 1 every stored cell is at 1 (none is older, a newer one fails the
+     * owner when its table is prepared), so a read may leave the version column out.
+     */
+    jsonVersion(column: string): number;
+    /** A point lookup compiled once: `columns` of the row whose key the caller binds, in key order. */
+    prepareGet(columns: readonly string[]): string;
+    /**
+     * The read of `json(...)` column `column`'s stored cells (`text` written at `version`, migrated on access), made
+     * once: an adapter selecting the cell itself reads it so.
+     */
+    reader(column: string): (text: string, version: number, context: Context) => unknown;
+    /** Up to `limit` rows matching `where` in `order`, decoded. */
+    select(executor: Pick<SqliteExecutor, "all">, where: WhereNode | undefined, order: Order, limit: number, context: Context): Promise<DecodedRow[]>;
+}
+//# sourceMappingURL=adapter.d.ts.map

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

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

package/dist/store/adapter.js

@@ -0,0 +1,118 @@
+// The store for adapters (slice 6b §2.1, D1, D2): what an owner outside Chord's objects (Durable's `StoreStorage`) uses
+// to keep its data in the store as declared tables and engine documents: its tables declared and prepared under its
+// owner name (claimed, the path `self.table` takes), rows encoded at staging and written in a step with what only the
+// step knows, and its reads. Internal for adapters; apps use `openStore` and objects.
+import { checkName } from "../contracts/internal.js";
+import { TableSql, tableSqlName } from "./sql.js";
+import { prepareTables } from "./table-migration.js";
+/**
+ * The tables of one owner name in a store: each declared once (its SQL name `"<owner>:<table>"` claimed for
+ * `claimant`), then prepared together (created at their newest version or migrated, as `self.table`'s are).
+ */
+export class StoreOwnerTables {
+    store;
+    owner;
+    #claimant;
+    #tables = [];
+    /** `owner` is a restricted name (lowercase `[a-z0-9@/._~-]`): it becomes the first part of SQL names. */
+    constructor(store, owner, claimant) {
+        checkName(owner, "An owner name");
+        this.store = store;
+        this.owner = owner;
+        this.#claimant = claimant;
+    }
+    /** Declares `definition` under the owner, claiming its SQL name (held by another: `invalid/args`). */
+    declare(definition) {
+        const table = new OwnerTable(definition, tableSqlName(this.owner, definition.name));
+        this.store.claims.table(table.sql.table, this.#claimant);
+        this.#tables.push(table);
+        return table;
+    }
+    /** Brings every declared table to its definition: created fresh, or migrated eagerly in their commits. */
+    prepare(context) {
+        const tables = this.#tables.map(({ definition, sql }) => ({ definition, table: sql.table }));
+        const fence = { admit: () => true, adopt: () => { } };
+        return prepareTables(tables, this.store, fence, this.owner, context);
+    }
+}
+/** One declared table of an owner: its rows encoded and written in a step, its reads by key and by query. */
+export class OwnerTable {
+    definition;
+    sql;
+    constructor(definition, table) {
+        this.definition = definition;
+        this.sql = new TableSql(table, definition.columns, definition.rows.physical, definition.key);
+    }
+    /** `row` checked and encoded for a `put` (a trust boundary, rule 8: at staging, before the queue). */
+    encode(row) {
+        return this.definition.rows.put(row, this.definition.version);
+    }
+    /**
+     * Writes `encoded` in `step` (an upsert) and returns the `put` as recorded; `stamp` names an `int` column that takes
+     * the step's seq (Durable's `entries.commit_seq`), in the row and in the record.
+     */
+    async put(step, encoded, stamp) {
+        const { version } = this.definition;
+        const { table } = this.sql;
+        if (stamp === undefined) {
+            await step.run(this.sql.put, ...encoded.params);
+            return { kind: "put", table, row: encoded.row, version, columns: encoded.columns };
+        }
+        const params = [...encoded.params];
+        params[this.definition.rows.physical.indexOf(stamp)] = step.seq;
+        await step.run(this.sql.put, ...params);
+        return { kind: "put", table, row: { ...encoded.row, [stamp]: step.seq }, version, columns: encoded.columns };
+    }
+    /** The row with the key `params` (in key order), decoded. */
+    async get(executor, params, context) {
+        const stored = await executor.get(this.sql.get, ...params);
+        return stored === undefined ? undefined : this.definition.rows.decode(stored, context);
+    }
+    /**
+     * A read compiled once (the store's query vocabulary rendered to SQL): `columns` of the rows `where` matches in
+     * `order`. The values in `where` only shape it: each is a `?` the caller binds in the order the conditions take
+     * them, then the limit. Adapters keep their fixed reads so: no SQL is rendered per call.
+     */
+    prepare(columns, where, order) {
+        return this.sql.select(where, order, undefined, 0, columns).sql;
+    }
+    /** `prepare` for the first row only: the limit is a literal `1` (a bound one costs SQLite a plan step per call). */
+    prepareFirst(columns, where, order) {
+        return this.sql.select(where, order, undefined, 1, columns).sql.replace(/LIMIT \?$/, "LIMIT 1");
+    }
+    /**
+     * The version of `json(...)` column `column`: at 1 every stored cell is at 1 (none is older, a newer one fails the
+     * owner when its table is prepared), so a read may leave the version column out.
+     */
+    jsonVersion(column) {
+        const found = this.definition.column(column, "jsonVersion");
+        if (found.type !== "json")
+            throw new Error(`${this.definition.name}: column "${column}" is no json(...) column`);
+        return found.json.version;
+    }
+    /** A point lookup compiled once: `columns` of the row whose key the caller binds, in key order. */
+    prepareGet(columns) {
+        return this.sql.getColumns(columns);
+    }
+    /**
+     * The read of `json(...)` column `column`'s stored cells (`text` written at `version`, migrated on access), made
+     * once: an adapter selecting the cell itself reads it so.
+     */
+    reader(column) {
+        const found = this.definition.column(column, "reader");
+        if (found.type !== "json")
+            throw new Error(`${this.definition.name}: column "${column}" is no json(...) column`);
+        // At version 1 a cell is the JSON it was written as: no version to compare, nothing to migrate.
+        if (found.json.version === 1)
+            return (text) => JSON.parse(text);
+        const what = `${this.sql.table}.${column}`;
+        return (text, version, context) => found.json.read(text, version, what, context);
+    }
+    /** Up to `limit` rows matching `where` in `order`, decoded. */
+    async select(executor, where, order, limit, context) {
+        const statement = this.sql.select(where, order, undefined, limit);
+        const stored = await executor.all(statement.sql, ...statement.params);
+        return stored.map((row) => this.definition.rows.decode(row, context));
+    }
+}
+//# sourceMappingURL=adapter.js.map

package/dist/store/adapter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"adapter.js","sourceRoot":"","sources":["../../src/store/adapter.ts"],"names":[],"mappings":"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","sourcesContent":["// The store for adapters (slice 6b §2.1, D1, D2): what an owner outside Chord's objects (Durable's `StoreStorage`) uses\n// to keep its data in the store as declared tables and engine documents: its tables declared and prepared under its\n// owner name (claimed, the path `self.table` takes), rows encoded at staging and written in a step with what only the\n// step knows, and its reads. Internal for adapters; apps use `openStore` and objects.\n\nimport type { Context } from \"../context/index.ts\";\nimport { checkName } from \"../contracts/internal.ts\";\nimport type { SqliteExecutor, SqliteValue } from \"../sqlite/index.ts\";\nimport type { Claimant } from \"./claims.ts\";\nimport type { WhereNode } from \"./expression.ts\";\nimport type { EncodedRow } from \"./rows.ts\";\nimport { type Order, TableSql, tableSqlName } from \"./sql.ts\";\nimport type { Step } from \"./step.ts\";\nimport type { ChordStore } from \"./store.ts\";\nimport type { TableDefinition } from \"./table.ts\";\nimport { prepareTables } from \"./table-migration.ts\";\nimport type { TableWrite } from \"./table-writes.ts\";\n\n/** A stored row as reads decode it. */\nexport type DecodedRow = { readonly [column: string]: unknown };\n\n/**\n * The tables of one owner name in a store: each declared once (its SQL name `\"<owner>:<table>\"` claimed for\n * `claimant`), then prepared together (created at their newest version or migrated, as `self.table`'s are).\n */\nexport class StoreOwnerTables {\n\treadonly store: ChordStore;\n\treadonly owner: string;\n\treadonly #claimant: Claimant;\n\treadonly #tables: OwnerTable[] = [];\n\n\t/** `owner` is a restricted name (lowercase `[a-z0-9@/._~-]`): it becomes the first part of SQL names. */\n\tconstructor(store: ChordStore, owner: string, claimant: Claimant) {\n\t\tcheckName(owner, \"An owner name\");\n\t\tthis.store = store;\n\t\tthis.owner = owner;\n\t\tthis.#claimant = claimant;\n\t}\n\n\t/** Declares `definition` under the owner, claiming its SQL name (held by another: `invalid/args`). */\n\tdeclare(definition: TableDefinition): OwnerTable {\n\t\tconst table = new OwnerTable(definition, tableSqlName(this.owner, definition.name));\n\t\tthis.store.claims.table(table.sql.table, this.#claimant);\n\t\tthis.#tables.push(table);\n\t\treturn table;\n\t}\n\n\t/** Brings every declared table to its definition: created fresh, or migrated eagerly in their commits. */\n\tprepare(context: Context): Promise<void> {\n\t\tconst tables = this.#tables.map(({ definition, sql }) => ({ definition, table: sql.table }));\n\t\tconst fence = { admit: () => true, adopt: () => {} };\n\t\treturn prepareTables(tables, this.store, fence, this.owner, context);\n\t}\n}\n\n/** One declared table of an owner: its rows encoded and written in a step, its reads by key and by query. */\nexport class OwnerTable {\n\treadonly definition: TableDefinition;\n\treadonly sql: TableSql;\n\n\tconstructor(definition: TableDefinition, table: string) {\n\t\tthis.definition = definition;\n\t\tthis.sql = new TableSql(table, definition.columns, definition.rows.physical, definition.key);\n\t}\n\n\t/** `row` checked and encoded for a `put` (a trust boundary, rule 8: at staging, before the queue). */\n\tencode(row: unknown): EncodedRow {\n\t\treturn this.definition.rows.put(row, this.definition.version);\n\t}\n\n\t/**\n\t * Writes `encoded` in `step` (an upsert) and returns the `put` as recorded; `stamp` names an `int` column that takes\n\t * the step's seq (Durable's `entries.commit_seq`), in the row and in the record.\n\t */\n\tasync put(step: Step, encoded: EncodedRow, stamp?: string): Promise<TableWrite> {\n\t\tconst { version } = this.definition;\n\t\tconst { table } = this.sql;\n\t\tif (stamp === undefined) {\n\t\t\tawait step.run(this.sql.put, ...encoded.params);\n\t\t\treturn { kind: \"put\", table, row: encoded.row, version, columns: encoded.columns };\n\t\t}\n\t\tconst params = [...encoded.params];\n\t\tparams[this.definition.rows.physical.indexOf(stamp)] = step.seq;\n\t\tawait step.run(this.sql.put, ...params);\n\t\treturn { kind: \"put\", table, row: { ...encoded.row, [stamp]: step.seq }, version, columns: encoded.columns };\n\t}\n\n\t/** The row with the key `params` (in key order), decoded. */\n\tasync get(\n\t\texecutor: Pick<SqliteExecutor, \"get\">,\n\t\tparams: readonly SqliteValue[],\n\t\tcontext: Context,\n\t): Promise<DecodedRow | undefined> {\n\t\tconst stored = await executor.get<{ [column: string]: SqliteValue }>(this.sql.get, ...params);\n\t\treturn stored === undefined ? undefined : this.definition.rows.decode(stored, context);\n\t}\n\n\t/**\n\t * A read compiled once (the store's query vocabulary rendered to SQL): `columns` of the rows `where` matches in\n\t * `order`. The values in `where` only shape it: each is a `?` the caller binds in the order the conditions take\n\t * them, then the limit. Adapters keep their fixed reads so: no SQL is rendered per call.\n\t */\n\tprepare(columns: readonly string[], where: WhereNode | undefined, order: Order): string {\n\t\treturn this.sql.select(where, order, undefined, 0, columns).sql;\n\t}\n\n\t/** `prepare` for the first row only: the limit is a literal `1` (a bound one costs SQLite a plan step per call). */\n\tprepareFirst(columns: readonly string[], where: WhereNode | undefined, order: Order): string {\n\t\treturn this.sql.select(where, order, undefined, 1, columns).sql.replace(/LIMIT \\?$/, \"LIMIT 1\");\n\t}\n\n\t/**\n\t * The version of `json(...)` column `column`: at 1 every stored cell is at 1 (none is older, a newer one fails the\n\t * owner when its table is prepared), so a read may leave the version column out.\n\t */\n\tjsonVersion(column: string): number {\n\t\tconst found = this.definition.column(column, \"jsonVersion\");\n\t\tif (found.type !== \"json\") throw new Error(`${this.definition.name}: column \"${column}\" is no json(...) column`);\n\t\treturn found.json.version;\n\t}\n\n\t/** A point lookup compiled once: `columns` of the row whose key the caller binds, in key order. */\n\tprepareGet(columns: readonly string[]): string {\n\t\treturn this.sql.getColumns(columns);\n\t}\n\n\t/**\n\t * The read of `json(...)` column `column`'s stored cells (`text` written at `version`, migrated on access), made\n\t * once: an adapter selecting the cell itself reads it so.\n\t */\n\treader(column: string): (text: string, version: number, context: Context) => unknown {\n\t\tconst found = this.definition.column(column, \"reader\");\n\t\tif (found.type !== \"json\") throw new Error(`${this.definition.name}: column \"${column}\" is no json(...) column`);\n\t\t// At version 1 a cell is the JSON it was written as: no version to compare, nothing to migrate.\n\t\tif (found.json.version === 1) return (text) => JSON.parse(text) as unknown;\n\t\tconst what = `${this.sql.table}.${column}`;\n\t\treturn (text, version, context) => found.json.read(text, version, what, context);\n\t}\n\n\t/** Up to `limit` rows matching `where` in `order`, decoded. */\n\tasync select(\n\t\texecutor: Pick<SqliteExecutor, \"all\">,\n\t\twhere: WhereNode | undefined,\n\t\torder: Order,\n\t\tlimit: number,\n\t\tcontext: Context,\n\t): Promise<DecodedRow[]> {\n\t\tconst statement = this.sql.select(where, order, undefined, limit);\n\t\tconst stored = await executor.all<{ [column: string]: SqliteValue }>(statement.sql, ...statement.params);\n\t\treturn stored.map((row) => this.definition.rows.decode(row, context));\n\t}\n}\n"]}

package/dist/store/allocator.d.ts

@@ -0,0 +1,17 @@
+/** The first id the allocator gives: id 1 is Durable's root conversation. */
+export declare const FIRST_ID = 2;
+/**
+ * The allocator: `value` is the next id it gives. An id raised to `Number.MAX_SAFE_INTEGER` is accepted, the value
+ * stays there, and every later `mint` throws: no id past the safe range (it would stop counting exactly and repeat).
+ */
+export declare class IdAllocator {
+    #private;
+    constructor(next: number);
+    /** The next id `mint` gives; what each commit persists. */
+    get value(): number;
+    /** Takes the next id; throws "ID space is exhausted" once saturated (Durable's message). */
+    mint(): number;
+    /** Raises the counter above `id`, an id written explicitly (Durable mints ahead), saturating. */
+    raise(id: number): void;
+}
+//# sourceMappingURL=allocator.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"allocator.d.ts","sourceRoot":"","sources":["../../src/store/allocator.ts"],"names":[],"mappings":"AAGA,6EAA6E;AAC7E,eAAO,MAAM,QAAQ,IAAI,CAAC;AAE1B;;;GAGG;AACH,qBAAa,WAAW;;IAGvB,YAAY,IAAI,EAAE,MAAM,EAEvB;IAED,2DAA2D;IAC3D,IAAI,KAAK,IAAI,MAAM,CAElB;IAED,4FAA4F;IAC5F,IAAI,IAAI,MAAM,CAGb;IAED,iGAAiG;IACjG,KAAK,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI,CAEtB;CACD"}

package/dist/store/allocator.js

@@ -0,0 +1,30 @@
+// The store's id allocator (slice 6b D3, §1.2): one counter for every id in the store (Durable's `mintId`, Chord's
+// document ids), synchronous, raised by explicit ids, saturating at `Number.MAX_SAFE_INTEGER`.
+/** The first id the allocator gives: id 1 is Durable's root conversation. */
+export const FIRST_ID = 2;
+/**
+ * The allocator: `value` is the next id it gives. An id raised to `Number.MAX_SAFE_INTEGER` is accepted, the value
+ * stays there, and every later `mint` throws: no id past the safe range (it would stop counting exactly and repeat).
+ */
+export class IdAllocator {
+    #next;
+    constructor(next) {
+        this.#next = next;
+    }
+    /** The next id `mint` gives; what each commit persists. */
+    get value() {
+        return this.#next;
+    }
+    /** Takes the next id; throws "ID space is exhausted" once saturated (Durable's message). */
+    mint() {
+        if (this.#next >= Number.MAX_SAFE_INTEGER)
+            throw new Error("ID space is exhausted");
+        return this.#next++;
+    }
+    /** Raises the counter above `id`, an id written explicitly (Durable mints ahead), saturating. */
+    raise(id) {
+        if (id >= this.#next)
+            this.#next = Math.min(id + 1, Number.MAX_SAFE_INTEGER);
+    }
+}
+//# sourceMappingURL=allocator.js.map

package/dist/store/allocator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"allocator.js","sourceRoot":"","sources":["../../src/store/allocator.ts"],"names":[],"mappings":"AAAA,mHAAmH;AACnH,+FAA+F;AAE/F,6EAA6E;AAC7E,MAAM,CAAC,MAAM,QAAQ,GAAG,CAAC,CAAC;AAE1B;;;GAGG;AACH,MAAM,OAAO,WAAW;IACvB,KAAK,CAAS;IAEd,YAAY,IAAY;QACvB,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC;IACnB,CAAC;IAED,2DAA2D;IAC3D,IAAI,KAAK;QACR,OAAO,IAAI,CAAC,KAAK,CAAC;IACnB,CAAC;IAED,4FAA4F;IAC5F,IAAI;QACH,IAAI,IAAI,CAAC,KAAK,IAAI,MAAM,CAAC,gBAAgB;YAAE,MAAM,IAAI,KAAK,CAAC,uBAAuB,CAAC,CAAC;QACpF,OAAO,IAAI,CAAC,KAAK,EAAE,CAAC;IACrB,CAAC;IAED,iGAAiG;IACjG,KAAK,CAAC,EAAU;QACf,IAAI,EAAE,IAAI,IAAI,CAAC,KAAK;YAAE,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC,GAAG,CAAC,EAAE,GAAG,CAAC,EAAE,MAAM,CAAC,gBAAgB,CAAC,CAAC;IAC9E,CAAC;CACD","sourcesContent":["// The store's id allocator (slice 6b D3, §1.2): one counter for every id in the store (Durable's `mintId`, Chord's\n// document ids), synchronous, raised by explicit ids, saturating at `Number.MAX_SAFE_INTEGER`.\n\n/** The first id the allocator gives: id 1 is Durable's root conversation. */\nexport const FIRST_ID = 2;\n\n/**\n * The allocator: `value` is the next id it gives. An id raised to `Number.MAX_SAFE_INTEGER` is accepted, the value\n * stays there, and every later `mint` throws: no id past the safe range (it would stop counting exactly and repeat).\n */\nexport class IdAllocator {\n\t#next: number;\n\n\tconstructor(next: number) {\n\t\tthis.#next = next;\n\t}\n\n\t/** The next id `mint` gives; what each commit persists. */\n\tget value(): number {\n\t\treturn this.#next;\n\t}\n\n\t/** Takes the next id; throws \"ID space is exhausted\" once saturated (Durable's message). */\n\tmint(): number {\n\t\tif (this.#next >= Number.MAX_SAFE_INTEGER) throw new Error(\"ID space is exhausted\");\n\t\treturn this.#next++;\n\t}\n\n\t/** Raises the counter above `id`, an id written explicitly (Durable mints ahead), saturating. */\n\traise(id: number): void {\n\t\tif (id >= this.#next) this.#next = Math.min(id + 1, Number.MAX_SAFE_INTEGER);\n\t}\n}\n"]}

package/dist/store/applier.d.ts

@@ -0,0 +1,8 @@
+import type { Step } from "./step.ts";
+import type { StoreWrite } from "./writes.ts";
+/** A recorded write the store does not reproduce (a count, a revision): applying stops, the store diverged (S17). */
+export declare class Diverged extends Error {
+}
+/** Applies `write` in `step`; a write the records refuse throws `invalid/args`, one they do not reproduce `Diverged`. */
+export declare function applyWrite(step: Step, write: StoreWrite, what: string): Promise<void>;
+//# sourceMappingURL=applier.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"applier.d.ts","sourceRoot":"","sources":["../../src/store/applier.ts"],"names":[],"mappings":"AAwBA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AAGtC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAE9C,qHAAqH;AACrH,qBAAa,QAAS,SAAQ,KAAK;CAAG;AAEtC,yHAAyH;AACzH,wBAAsB,UAAU,CAAC,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,UAAU,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAkC3F"}