@earendil-works/chord 1.4.0 → 1.5.0

package/dist/next/state/watchable.js

@@ -0,0 +1,156 @@
+// Chord's JSON watchables: sources (documents and derives, with their watches and dependent derives) and constants.
+import { Watch } from "../../watch.js";
+/**
+ * An error Chord hands to apps (a failure call, a report), its stack made text first: until then V8 keeps the frames'
+ * receivers, which would keep the host behind the throw alive for as long as an app keeps the error.
+ */
+export function handedOut(error) {
+    if (error instanceof Error)
+        void error.stack;
+    return error;
+}
+const ENDED = { kind: "ended" };
+/**
+ * A changing value on a host (a singleton document, a derive, a replica): its watches and subscribers get one frame
+ * per batch that changed it, and the derives reading it are marked dirty when it changes.
+ */
+export class Source {
+    /** Derives reading this source (and references' members forwarding to some); each removes itself when it stops. */
+    dependents = new Set();
+    batch;
+    /** Its watches and subscribers, each made by its first: most sources (a reference's members) never have one. */
+    #watches;
+    #subscribers;
+    constructor(batch) {
+        this.batch = batch;
+    }
+    /** Whether a watch or a subscriber follows this source. */
+    get watched() {
+        return (this.#watches?.size ?? 0) > 0 || (this.#subscribers?.size ?? 0) > 0;
+    }
+    async watch(context) {
+        return this.openWatch(context);
+    }
+    /**
+     * `watch` without the Promise, for references, which must register the watch before anything else runs. On a failed
+     * source it opens at the last good value and its first call is the failure; with no value to start at it throws the
+     * failure.
+     */
+    openWatch(context) {
+        this.batch.assertOutside("watch");
+        const start = this.start();
+        if (start.kind === "failed" && start.last === undefined)
+            throw start.error;
+        const value = start.kind === "value" ? start.value : start.last;
+        this.#watches ??= new Set();
+        const watches = this.#watches;
+        const watch = new Watch(value, () => watches.delete(watch), this.batch.reportListener);
+        watches.add(watch);
+        if (context.abortSignal !== undefined)
+            watch.observeAbort(context.abortSignal);
+        if (start.kind === "failed")
+            watch.fail(start.error, context);
+        return watch;
+    }
+    /** What a new watch starts at; a source that can fail and recover tells its failure (`WatchStart`). */
+    start() {
+        return { kind: "value", value: this.value };
+    }
+    /** Feeds `subscriber` every frame from now on, inside each batch; the caller took the current value first. */
+    subscribe(subscriber) {
+        this.#subscribers ??= new Set();
+        this.#subscribers.add(subscriber);
+    }
+    unsubscribe(subscriber) {
+        this.#subscribers?.delete(subscriber);
+    }
+    /** Records a change in the current batch: listed for a frame when watched, and every dependent marked dirty. */
+    changed() {
+        if (this.watched)
+            this.batch.changed(this);
+        for (const derive of this.dependents)
+            derive.invalidate();
+    }
+    /**
+     * Records a retirement of this source's document in the current batch: every derive reading it, directly or
+     * through other derives, carries the flag on in its frame (rule 21). Called after `changed`.
+     */
+    retiredInBatch() {
+        // Allocated only for a retirement, which is rare.
+        const visited = new Set();
+        for (const derive of this.dependents)
+            derive.sourceRetired(visited);
+    }
+    /** Queues one frame on every watch and feeds it to every subscriber. */
+    publish(value, ops, retired, context) {
+        this.forward({ kind: "value", value, ops, retired }, context);
+    }
+    /** Queues `call` on every watch and feeds it to every subscriber, as it is (a reference's member passes one on). */
+    forward(call, context) {
+        if (this.#watches !== undefined)
+            for (const watch of this.#watches)
+                watch.advance(call, context);
+        if (this.#subscribers !== undefined)
+            for (const subscriber of this.#subscribers)
+                subscriber.advance(call, context);
+    }
+    /**
+     * Gives every watch and subscriber one failure call (design §11): the source cannot compute its value now and may
+     * recover; they stay open, and its next value is `[["r", value]]`.
+     */
+    failWatches(error, context) {
+        this.forward({ kind: "failed", error: handedOut(error) }, context);
+    }
+    /**
+     * Ends every watch and subscriber for good once what they were given is delivered (a followed runtime ended after a
+     * last call, Durable's `endAfterDelivery`): `ended`; nothing follows.
+     */
+    endWatchesAfterDelivery() {
+        if (this.#watches !== undefined)
+            for (const watch of [...this.#watches])
+                watch.endAfterDelivery();
+        if (this.#subscribers === undefined || this.#subscribers.size === 0)
+            return;
+        const subscribers = [...this.#subscribers];
+        this.#subscribers.clear();
+        for (const subscriber of subscribers)
+            subscriber.endAfterDelivery();
+    }
+    /** Ends every watch and subscriber for good (its owner ended): `ended`; nothing follows. */
+    endWatches() {
+        // Ending detaches, which deletes the current entry (safe while iterating) and runs no listener.
+        if (this.#watches !== undefined)
+            for (const watch of this.#watches)
+                watch.end(ENDED);
+        if (this.#subscribers === undefined || this.#subscribers.size === 0)
+            return;
+        // A copy: a subscriber may unsubscribe as it ends.
+        const subscribers = [...this.#subscribers];
+        this.#subscribers.clear();
+        for (const subscriber of subscribers)
+            subscriber.end(ENDED);
+    }
+}
+/** A watchable that never changes (start data, §18); usable as a state member and as a derive source. */
+export function constant(value) {
+    // The constant holds `value` as it was given.
+    return new Constant(value);
+}
+/** The watchable behind `constant(value)`: its watches never get a frame and end only by stop or cancellation. */
+export class Constant {
+    value;
+    constructor(value) {
+        this.value = value;
+    }
+    async watch(context) {
+        return this.openWatch(context);
+    }
+    /** As `Source.openWatch`; nothing is delivered, so nothing is reported. */
+    openWatch(context) {
+        const watch = new Watch(this.value, () => { }, () => { });
+        if (context.abortSignal !== undefined)
+            watch.observeAbort(context.abortSignal);
+        return watch;
+    }
+}
+//# sourceMappingURL=watchable.js.map

package/dist/next/state/watchable.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"watchable.js","sourceRoot":"","sources":["../../../src/next/state/watchable.ts"],"names":[],"mappings":"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","sourcesContent":["// Chord's JSON watchables: sources (documents and derives, with their watches and dependent derives) and constants.\n\nimport type { Context } from \"../../context/index.ts\";\nimport type { Op } from \"../../delta/index.ts\";\nimport type { JsonValue } from \"../../json.ts\";\nimport { Watch, type Watchable, type WatchCall, type WatchEnd } from \"../../watch.ts\";\nimport type { Batch } from \"./batch.ts\";\n\n/**\n * A synchronous subscriber of a source (a hold over a link, a reference's member): fed the source's call inside the batch\n * that made it, before the batch ends, so everything one commit changed can leave in one message. The watch's own sink\n * shape (`Watch.advance`, `Watch.end`).\n */\nexport interface Subscriber {\n\t/**\n\t * The source's call of this batch, in its batch's `context`: a value (the ops from the previous one, and whether its\n\t * document was retired in it, or for a derive one of its sources' documents), or a failure it may recover from; the\n\t * next value after a failure is `[[\"r\", value]]`.\n\t */\n\tadvance(call: WatchCall<JsonValue>, context: Context): void;\n\t/** The source ended for good with `end`; nothing follows, and the subscriber is dropped. */\n\tend(end: WatchEnd): void;\n\t/**\n\t * The source ended for good after its last call (a followed runtime ended): a subscriber delivering later (a watch)\n\t * ends `ended` once it delivered what it was given, others end now.\n\t */\n\tendAfterDelivery(): void;\n}\n\n/**\n * What a new watch of a source starts at (design §11): its value, or, while it is failed, the failure and its last good\n * value (`undefined` when it never had one: a watch cannot start then, there is nothing to start at).\n */\nexport type WatchStart =\n\t| { readonly kind: \"value\"; readonly value: JsonValue }\n\t| { readonly kind: \"failed\"; readonly error: unknown; readonly last: JsonValue | undefined };\n\n/**\n * An error Chord hands to apps (a failure call, a report), its stack made text first: until then V8 keeps the frames'\n * receivers, which would keep the host behind the throw alive for as long as an app keeps the error.\n */\nexport function handedOut<E>(error: E): E {\n\tif (error instanceof Error) void error.stack;\n\treturn error;\n}\n\n/**\n * What reads a source and is marked by its changes: a derive, or a reference's member forwarding to derives (`Source.\n * dependents`).\n */\nexport interface Dependent {\n\t/** The source changed in the current batch: flags only, no compute. */\n\tinvalidate(): void;\n\t/** A source's document was retired in the current batch (rule 21); `visited` keeps a diamond walked once. */\n\tsourceRetired(visited: Set<Dependent>): void;\n}\n\nconst ENDED: WatchEnd = { kind: \"ended\" };\n\n/**\n * A changing value on a host (a singleton document, a derive, a replica): its watches and subscribers get one frame\n * per batch that changed it, and the derives reading it are marked dirty when it changes.\n */\nexport abstract class Source implements Watchable<JsonValue> {\n\t/** Derives reading this source (and references' members forwarding to some); each removes itself when it stops. */\n\treadonly dependents = new Set<Dependent>();\n\tprotected readonly batch: Batch;\n\t/** Its watches and subscribers, each made by its first: most sources (a reference's members) never have one. */\n\t#watches: Set<Watch<JsonValue>> | undefined;\n\t#subscribers: Set<Subscriber> | undefined;\n\n\tconstructor(batch: Batch) {\n\t\tthis.batch = batch;\n\t}\n\n\tabstract get value(): JsonValue;\n\n\t/** Whether a watch or a subscriber follows this source. */\n\tget watched(): boolean {\n\t\treturn (this.#watches?.size ?? 0) > 0 || (this.#subscribers?.size ?? 0) > 0;\n\t}\n\n\tasync watch(context: Context): Promise<Watch<JsonValue>> {\n\t\treturn this.openWatch(context);\n\t}\n\n\t/**\n\t * `watch` without the Promise, for references, which must register the watch before anything else runs. On a failed\n\t * source it opens at the last good value and its first call is the failure; with no value to start at it throws the\n\t * failure.\n\t */\n\topenWatch(context: Context): Watch<JsonValue> {\n\t\tthis.batch.assertOutside(\"watch\");\n\t\tconst start = this.start();\n\t\tif (start.kind === \"failed\" && start.last === undefined) throw start.error;\n\t\tconst value = start.kind === \"value\" ? start.value : start.last!;\n\t\tthis.#watches ??= new Set();\n\t\tconst watches = this.#watches;\n\t\tconst watch: Watch<JsonValue> = new Watch(value, () => watches.delete(watch), this.batch.reportListener);\n\t\twatches.add(watch);\n\t\tif (context.abortSignal !== undefined) watch.observeAbort(context.abortSignal);\n\t\tif (start.kind === \"failed\") watch.fail(start.error, context);\n\t\treturn watch;\n\t}\n\n\t/** What a new watch starts at; a source that can fail and recover tells its failure (`WatchStart`). */\n\tstart(): WatchStart {\n\t\treturn { kind: \"value\", value: this.value };\n\t}\n\n\t/** Feeds `subscriber` every frame from now on, inside each batch; the caller took the current value first. */\n\tsubscribe(subscriber: Subscriber): void {\n\t\tthis.#subscribers ??= new Set();\n\t\tthis.#subscribers.add(subscriber);\n\t}\n\n\tunsubscribe(subscriber: Subscriber): void {\n\t\tthis.#subscribers?.delete(subscriber);\n\t}\n\n\t/** Delivers this batch's frame to its watches; called once per batch that listed it with `changed`. */\n\tabstract deliver(context: Context): void;\n\n\t/** Records a change in the current batch: listed for a frame when watched, and every dependent marked dirty. */\n\tprotected changed(): void {\n\t\tif (this.watched) this.batch.changed(this);\n\t\tfor (const derive of this.dependents) derive.invalidate();\n\t}\n\n\t/**\n\t * Records a retirement of this source's document in the current batch: every derive reading it, directly or\n\t * through other derives, carries the flag on in its frame (rule 21). Called after `changed`.\n\t */\n\tprotected retiredInBatch(): void {\n\t\t// Allocated only for a retirement, which is rare.\n\t\tconst visited = new Set<Dependent>();\n\t\tfor (const derive of this.dependents) derive.sourceRetired(visited);\n\t}\n\n\t/** Queues one frame on every watch and feeds it to every subscriber. */\n\tprotected publish(value: JsonValue, ops: readonly Op[], retired: boolean, context: Context): void {\n\t\tthis.forward({ kind: \"value\", value, ops, retired }, context);\n\t}\n\n\t/** Queues `call` on every watch and feeds it to every subscriber, as it is (a reference's member passes one on). */\n\tprotected forward(call: WatchCall<JsonValue>, context: Context): void {\n\t\tif (this.#watches !== undefined) for (const watch of this.#watches) watch.advance(call, context);\n\t\tif (this.#subscribers !== undefined)\n\t\t\tfor (const subscriber of this.#subscribers) subscriber.advance(call, context);\n\t}\n\n\t/**\n\t * Gives every watch and subscriber one failure call (design §11): the source cannot compute its value now and may\n\t * recover; they stay open, and its next value is `[[\"r\", value]]`.\n\t */\n\tprotected failWatches(error: unknown, context: Context): void {\n\t\tthis.forward({ kind: \"failed\", error: handedOut(error) }, context);\n\t}\n\n\t/**\n\t * Ends every watch and subscriber for good once what they were given is delivered (a followed runtime ended after a\n\t * last call, Durable's `endAfterDelivery`): `ended`; nothing follows.\n\t */\n\tprotected endWatchesAfterDelivery(): void {\n\t\tif (this.#watches !== undefined) for (const watch of [...this.#watches]) watch.endAfterDelivery();\n\t\tif (this.#subscribers === undefined || this.#subscribers.size === 0) return;\n\t\tconst subscribers = [...this.#subscribers];\n\t\tthis.#subscribers.clear();\n\t\tfor (const subscriber of subscribers) subscriber.endAfterDelivery();\n\t}\n\n\t/** Ends every watch and subscriber for good (its owner ended): `ended`; nothing follows. */\n\tprotected endWatches(): void {\n\t\t// Ending detaches, which deletes the current entry (safe while iterating) and runs no listener.\n\t\tif (this.#watches !== undefined) for (const watch of this.#watches) watch.end(ENDED);\n\t\tif (this.#subscribers === undefined || this.#subscribers.size === 0) return;\n\t\t// A copy: a subscriber may unsubscribe as it ends.\n\t\tconst subscribers = [...this.#subscribers];\n\t\tthis.#subscribers.clear();\n\t\tfor (const subscriber of subscribers) subscriber.end(ENDED);\n\t}\n}\n\n/** A watchable that never changes (start data, §18); usable as a state member and as a derive source. */\nexport function constant<const T extends JsonValue>(value: T): Watchable<T> {\n\t// The constant holds `value` as it was given.\n\treturn new Constant(value) as unknown as Watchable<T>;\n}\n\n/** The watchable behind `constant(value)`: its watches never get a frame and end only by stop or cancellation. */\nexport class Constant implements Watchable<JsonValue> {\n\treadonly value: JsonValue;\n\n\tconstructor(value: JsonValue) {\n\t\tthis.value = value;\n\t}\n\n\tasync watch(context: Context): Promise<Watch<JsonValue>> {\n\t\treturn this.openWatch(context);\n\t}\n\n\t/** As `Source.openWatch`; nothing is delivered, so nothing is reported. */\n\topenWatch(context: Context): Watch<JsonValue> {\n\t\tconst watch = new Watch<JsonValue>(\n\t\t\tthis.value,\n\t\t\t() => {},\n\t\t\t() => {},\n\t\t);\n\t\tif (context.abortSignal !== undefined) watch.observeAbort(context.abortSignal);\n\t\treturn watch;\n\t}\n}\n"]}

package/dist/next/state/writable.d.ts

@@ -0,0 +1,32 @@
+import type { Context } from "../../context/index.ts";
+import type { NativeWatchable } from "../../watch.ts";
+import type { Batch } from "./batch.ts";
+import { FollowedSource } from "./native-source.ts";
+/** An in-process value that changes when its owner sets it; `set` of the same value notifies nobody. */
+export interface Writable<T> extends NativeWatchable<T> {
+    /**
+     * Sets the value: a new value (by identity) is a new frame for its watches and marks the derives and registry
+     * tables reading it, in the batch running now or in one of its own. Throws `released` once its attempt ended, and
+     * `invalid/reentrant` inside a derive compute or a `compose`.
+     */
+    set(value: T): void;
+}
+/** Who owns a writable: the context its own batches run in, and the check that its attempt still runs. */
+export type WritableOwner = {
+    readonly context: Context;
+    /** Throws `released` once the attempt that made it was sealed. */
+    assertUsable(): void;
+};
+/** A writable: its value, set by its owner's code, delivered through the host's batch. */
+export declare class WritableSource<T> extends FollowedSource<T> implements Writable<T> {
+    #private;
+    constructor(initial: T, owner: WritableOwner, batch: Batch);
+    get value(): T;
+    set(value: T): void;
+    /**
+     * 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: Error): void;
+}
+//# sourceMappingURL=writable.d.ts.map

package/dist/next/state/writable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"writable.d.ts","sourceRoot":"","sources":["../../../src/next/state/writable.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,wBAAwB,CAAC;AACtD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AACtD,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AACxC,OAAO,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAEpD,wGAAwG;AACxG,MAAM,WAAW,QAAQ,CAAC,CAAC,CAAE,SAAQ,eAAe,CAAC,CAAC,CAAC;IACtD;;;;OAIG;IACH,GAAG,CAAC,KAAK,EAAE,CAAC,GAAG,IAAI,CAAC;CACpB;AAED,0GAA0G;AAC1G,MAAM,MAAM,aAAa,GAAG;IAC3B,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,kEAAkE;IAClE,YAAY,IAAI,IAAI,CAAC;CACrB,CAAC;AAOF,0FAA0F;AAC1F,qBAAa,cAAc,CAAC,CAAC,CAAE,SAAQ,cAAc,CAAC,CAAC,CAAE,YAAW,QAAQ,CAAC,CAAC,CAAC;;IAI9E,YAAY,OAAO,EAAE,CAAC,EAAE,KAAK,EAAE,aAAa,EAAE,KAAK,EAAE,KAAK,EAIzD;IAED,IAAI,KAAK,IAAI,CAAC,CAEb;IAED,GAAG,CAAC,KAAK,EAAE,CAAC,GAAG,IAAI,CASlB;IAaD;;;OAGG;IACH,MAAM,CAAC,KAAK,EAAE,KAAK,GAAG,IAAI,CAKzB;CACD"}

package/dist/next/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/next/state/writable.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"writable.js","sourceRoot":"","sources":["../../../src/next/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/next/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/next/store/adapter.d.ts.map

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

package/dist/next/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/next/store/adapter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"adapter.js","sourceRoot":"","sources":["../../../src/next/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 type { SqliteExecutor, SqliteValue } from \"../../sqlite/index.ts\";\nimport { checkName } from \"../contracts/internal.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/next/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/next/store/allocator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"allocator.d.ts","sourceRoot":"","sources":["../../../src/next/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/next/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/next/store/allocator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"allocator.js","sourceRoot":"","sources":["../../../src/next/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/next/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/next/store/applier.d.ts.map

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