diff --git a/docs/multiplayer-schema.md b/docs/multiplayer-schema.md index 8fe4e58..f60b490 100644 --- a/docs/multiplayer-schema.md +++ b/docs/multiplayer-schema.md @@ -2602,3 +2602,15 @@ persists, so KA-11 does not require a layout bump or migration. An opt-in `dynamic_groups` catalog entry expands a saved row-count controller into indexed widget identities. These use the existing name-keyed registers; no op kind or on-document key changes. The new catalog hash requires coordinated reader adoption. Existing documents retain their original catalog and are re-minted to adopt the new layout. Count writes change the projected layout, retaining hidden registers and applying fresh-row defaults only at read time. They do not delete rows or links. Explicit `widgets_values_form` declarations remain authoritative; supplied group metadata adds row-count bound validation (`min` to the allocation bound) and rejects a count change requiring a new declaration before mutation. This validation applies to the addressed occurrence in top-level, interior, and promoted writes. A count outside that range is rejected `dynamic_group_count_out_of_range`, whether it arrives as a `set_widget` value or as a saved count in an `add_node` or `insert_workflow` payload (including its definitions); a count change against a declared form is rejected `dynamic_group_form_mismatch`. Both are new rejection codes, so callers can count DynamicGroup refusals without parsing messages. A row-field name that no group row can address keeps `unknown_widget`, as any other unknown widget name does. Without group metadata, the package cannot identify count fields; compatible producer/catalog/reader admission remains the caller's responsibility. See [DynamicGroup catalog support](dynamic-groups.md) for the producer contract, bounds, and fixture provenance. + +## Amendment A27 — 2026-11-01 — Lamport floor reads past companion rows; opt-in lenient read (no schema change) + +§1.6 says `observedDocCounter()` validates every tuple and that a malformed entry fails the entire scan. The applier itself writes two `__stamps` rows that are not stamp tuples and carry no counter: +- `["grow_request", to_node, grow_id, family]`: an autogrow connect's requested slot shape, `[name, widget | null, isInputcount]`. +- `["interior_route", instance_id, incarnation]`: a deleted subgraph instance's retained definition id, a string. + +So one autogrow connect or one subgraph-instance delete made the floor unreadable for every later producer admission on that document. + +`observedDocCounter()` now passes over `__stamps` rows whose key begins with either tag and whose value has the shape the applier stores there (a string for `interior_route`; an array whose first element is not a number for `grow_request`, whose rows are `[name, widget, isInputcount]` with the grow's widget stored as sent). A companion-keyed row holding anything else is read as an ordinary row, so a counter can never hide behind a companion-looking key. The tags are `GROW_REQUEST_TAG` and `INTERIOR_ROUTE_TAG` in `doc.ts`, shared with the applier's key builders, and are matched on the canonical `JSON.stringify` key prefix. Every other row is validated exactly as §1.6 says, so the default read still fails closed. `__clock_reservations` rows are never skipped. The counters those operations carry are still counted through their own stamps (`["grow", …]`, `["node", …]`). + +A producer that must keep minting rather than refuse may call `observedDocCounter(doc, { skipMalformed: true })`. It returns `{ counter, skipped }`: the maximum over the readable counters of both ledgers, and the number of malformed rows (companion rows are not counted). A malformed row whose first element is still a valid counter raises the floor: over-estimating the floor is safe, under-estimating it would let the producer mint under a counter already in the document. A caller that sees `skipped > 0` should log it. An unreadable `__clock_reservations` root counts as one skipped entry in this mode, since the winning counters live in `__stamps`; an unreadable schema or `__stamps` root still throws. The strict read and `DocDerivedLamportClockStore` refuse both. `DocDerivedLamportClockStore` keeps the strict read. diff --git a/src/applier.ts b/src/applier.ts index 078d907..a061ce6 100644 --- a/src/applier.ts +++ b/src/applier.ts @@ -101,6 +101,8 @@ import { resolveDefinition, stampsMap, widgetStorageOf, + GROW_REQUEST_TAG, + INTERIOR_ROUTE_TAG, } from "./doc.js"; import { declaresWidgetForm, @@ -2173,7 +2175,7 @@ interface InteriorResolution { } function interiorRouteKey(instanceId: string, incarnation: string): string { - return JSON.stringify(["interior_route", instanceId, incarnation]); + return JSON.stringify([INTERIOR_ROUTE_TAG, instanceId, incarnation]); } function resolveInteriorNode( @@ -3083,7 +3085,7 @@ type GrowRequest = [string, string | null, boolean]; /** `__stamps` key holding a grow's own request, companion to its `["grow", ...]` stamp. */ function growRequestKey(toNode: unknown, growId: unknown, family: string): string { - return JSON.stringify(["grow_request", String(toNode), String(growId), family]); + return JSON.stringify([GROW_REQUEST_TAG, String(toNode), String(growId), family]); } /** diff --git a/src/clock.ts b/src/clock.ts index ead003e..447bf76 100644 --- a/src/clock.ts +++ b/src/clock.ts @@ -1,5 +1,5 @@ import * as Y from "yjs"; -import { ROOT_CLOCK_RESERVATIONS, ROOT_STAMPS } from "./doc.js"; +import { GROW_REQUEST_TAG, INTERIOR_ROUTE_TAG, ROOT_CLOCK_RESERVATIONS, ROOT_STAMPS } from "./doc.js"; import { assertReadableSchema } from "./schema-version.js"; import type { Actor } from "./types.js"; @@ -29,13 +29,14 @@ const documentTransactionTails = new WeakMap>(); * counter: the Y.Doc is the caller-owned lineage snapshot and this store's * transaction queue is the serialization boundary. * - * Both ledgers are validated rather than silently skipped. Malformed state + * Both ledgers are validated rather than silently skipped; only `__stamps` + * companion rows, which hold no counter, are passed over. Malformed state * must fail closed before a producer mints an unsafe counter. * Incarnation-qualified target keys all belong to this document lineage, so * old node lives remain part of the observed floor (DQ-11 / ADR-ORDERING-0021). A * successful transaction writes `__clock_reservations` so the next transaction * observes it even before the producer's semantic op is applied. `__stamps` - * remains exclusively the semantic write-target ledger exposed by readStamps. + * remains the semantic write-target ledger exposed by readStamps. */ export class DocDerivedLamportClockStore implements LamportClockStore { public constructor(private readonly doc: Y.Doc) {} @@ -70,32 +71,100 @@ export class DocDerivedLamportClockStore implements LamportClockStore { } } +// Counterless `__stamps` rows (doc.ts companion tags), matched on the canonical +// JSON.stringify key prefix the applier writes AND on the value shape the +// applier stores there, so a counter under a companion-looking key is never +// silently dropped from the floor. +const GROW_REQUEST_PREFIX = `["${GROW_REQUEST_TAG}",`; +const INTERIOR_ROUTE_PREFIX = `["${INTERIOR_ROUTE_TAG}",`; + +function isCompanionRow(key: string, value: unknown): boolean { + if (key.startsWith(INTERIOR_ROUTE_PREFIX)) return typeof value === "string"; + // applier GrowRequest: [name, widget, isInputcount]. The applier stores the + // grow's widget field as sent, so only the leading position is load-bearing: + // a row whose first element is not a number cannot carry a counter. + if (key.startsWith(GROW_REQUEST_PREFIX)) return Array.isArray(value) && typeof value[0] !== "number"; + return false; +} + +// A malformed row still raises a lenient floor when its first element is a +// valid counter: over-estimating the floor is safe, under-estimating it lets a +// producer mint under a counter already in the document. +function salvageCounter(value: unknown): number | undefined { + if (!Array.isArray(value)) return undefined; + const counter: unknown = value[0]; + return typeof counter === "number" && Number.isSafeInteger(counter) && counter >= 0 ? counter : undefined; +} + +/** Result of a lenient floor read: the maximum valid counter and how many rows were unreadable. */ +export interface LenientDocCounter { + counter: number | undefined; + skipped: number; +} + /** * Maximum counter across winning stamps and reservations in a current-schema * document. Missing ledgers are empty; missing/unsupported schema is refused. + * Companion rows in `__stamps` carry no counter and are skipped. * Reads neither write structs nor create absent roots. + * + * By default a malformed row throws (fail closed, ADR-021). With + * `skipMalformed`, a producer that must keep minting gets the maximum over the + * readable counters instead (a malformed row whose first element is a valid + * counter still raises it), plus the count of malformed rows (companion rows + * are not counted). A caller that sees `skipped > 0` should log it. An + * unreadable reservations root counts as one skipped entry; an unreadable + * schema or `__stamps` root still throws. */ -export function observedDocCounter(doc: Y.Doc): number | undefined { +export function observedDocCounter(doc: Y.Doc): number | undefined; +export function observedDocCounter(doc: Y.Doc, options: { skipMalformed: true }): LenientDocCounter; +export function observedDocCounter( + doc: Y.Doc, + options?: { skipMalformed: true }, +): number | undefined | LenientDocCounter { assertReadableSchema(doc, "observedDocCounter"); let maximum: number | undefined; + let skipped = 0; for (const name of [ROOT_STAMPS, ROOT_CLOCK_RESERVATIONS]) { const root = doc.share.get(name); if (root === undefined) continue; // Snapshot roots arrive as AbstractType, not Y.Map. Type only an existing // root; reject sequence content before getMap can hide it in a map view. - if (root._start !== null) throw new TypeError(`${name} root contains non-map content`); - const ledger = doc.getMap(name); // throws for a different concrete Y type + let ledger: Y.Map; + try { + if (root._start !== null) throw new TypeError(`${name} root contains non-map content`); + ledger = doc.getMap(name); // throws for a different concrete Y type + } catch (error) { + // Lenient mode passes over an unreadable reservations root as one skipped + // entry. Winning counters live in __stamps, whose root must stay readable. + if (options?.skipMalformed !== true || name !== ROOT_CLOCK_RESERVATIONS) throw error; + skipped++; + continue; + } ledger.forEach((value, key) => { - if (!Array.isArray(value) || value.length !== 3 || typeof value[1] !== "string" || - typeof value[2] !== "string" || value[2].length === 0) { - throw new TypeError(`${name} contains a malformed stamp tuple`); + if (name === ROOT_STAMPS && isCompanionRow(key, value)) return; + let counter: number | undefined; + try { + counter = ledgerRowCounter(name, key, value); + } catch (error) { + if (options?.skipMalformed !== true) throw error; + skipped++; + counter = salvageCounter(value); + if (counter === undefined) return; } - if (name === ROOT_CLOCK_RESERVATIONS) validateReservation(key, value[1], value[2]); - const counter = validateLamportCounter(value[0], name === ROOT_STAMPS); maximum = maximum === undefined ? counter : Math.max(maximum, counter); }); } - return maximum; + return options?.skipMalformed === true ? { counter: maximum, skipped } : maximum; +} + +function ledgerRowCounter(name: string, key: string, value: unknown): number { + if (!Array.isArray(value) || value.length !== 3 || typeof value[1] !== "string" || + typeof value[2] !== "string" || value[2].length === 0) { + throw new TypeError(`${name} contains a malformed stamp tuple`); + } + if (name === ROOT_CLOCK_RESERVATIONS) validateReservation(key, value[1], value[2]); + return validateLamportCounter(value[0], name === ROOT_STAMPS); } function validateReservation(key: string, producer: string, storedKey: string): void { diff --git a/src/doc.ts b/src/doc.ts index e4b93b4..2e5eb2d 100644 --- a/src/doc.ts +++ b/src/doc.ts @@ -17,7 +17,8 @@ * ├── Y.Map '__applied' — op_id → sha256 of the canonical op payload * │ (idempotency + op_id-reuse detection, §4 * │ amendment A8; a legacy `1` is a pre-A8 record) - * ├── Y.Map '__stamps' — write-target key → [base_version, actor, op_id] (§4) + * ├── Y.Map '__stamps' — write-target key → [base_version, actor, op_id] (§4), + * │ plus counterless grow_request / interior_route rows * ├── Y.Map '__link_state' — normalized link id → durable descriptor (§1.5) * └── Y.Map '__clock_reservations' — producer identity → reserved counter tuple (§1.6) */ @@ -278,6 +279,9 @@ export const ROOT_META = "meta"; export const ROOT_APPLIED = "__applied"; export const ROOT_STAMPS = "__stamps"; export const ROOT_LINK_STATE = "__link_state"; +/** `__stamps` companion-row key tags: counterless rows written beside a stamp. */ +export const GROW_REQUEST_TAG = "grow_request"; +export const INTERIOR_ROUTE_TAG = "interior_route"; /** Created lazily by a successful clock admission, never exported from the entrypoint. */ export const ROOT_CLOCK_RESERVATIONS = "__clock_reservations"; diff --git a/src/read.ts b/src/read.ts index 07b33e1..34a7b29 100644 --- a/src/read.ts +++ b/src/read.ts @@ -472,7 +472,8 @@ export function readApplied(doc: Y.Doc): Readonly> { * The LWW ledger as plain frozen data: write-target key → * `[base_version, actor, op_id]` (schema §3/§4). This is where per-op actor * attribution is durably observable, and it is what a cross-language - * conformance harness compares — no projection contains it. + * conformance harness compares — no projection contains it. It also carries + * counterless `grow_request` / `interior_route` companion rows. */ export function readStamps(doc: Y.Doc): Readonly> { assertSnapshotReadable(doc, "readStamps"); diff --git a/test/clock.test.ts b/test/clock.test.ts index 5e34128..484d8df 100644 --- a/test/clock.test.ts +++ b/test/clock.test.ts @@ -2,10 +2,12 @@ import * as Y from "yjs"; import { describe, expect, it, vi } from "vitest"; import { applyOps, DocDerivedLamportClockStore, freezeLamportEnvelope, MAX_LAMPORT_COUNTER, mint, migrate, observedDocCounter, observeLamport, persistLamportTick, project, readStamps, - SCHEMA_VERSION, tickLamport, validateLamportCounter, type LamportClockStore } from "../src/index.js"; + SCHEMA_VERSION, tickLamport, validateLamportCounter, type LamportClockStore, type WidgetCatalog, + type WorkflowJSON } from "../src/index.js"; import { loadCatalog } from "./helpers.js"; const catalog = loadCatalog(); +const growCatalog: WidgetCatalog = { types: { Source: { widget_order: [] }, Destination: { widget_order: [] } } }; const identity = { workflow_id: "w", lineage_id: "l", producer_id: "agent:clock" }; const reservationKey = '["__lamport_clock","w","l","agent:clock"]'; @@ -117,6 +119,120 @@ describe("creator-owned Lamport counter", () => { )).rejects.toThrow(/Lamport counter/); }); + it("skips autogrow request rows when taking the floor of a real document", () => { + const io = (name: string, links: object) => ({ name, type: "IMAGE", ...links }); + const doc = mint({ + nodes: [ + { id: 1, type: "Source", pos: [0, 0], inputs: [], outputs: [io("out", { links: [] })], widgets_values: [] }, + { id: 2, type: "Destination", pos: [0, 0], inputs: [io("fixed", { link: null })], outputs: [], widgets_values: [] }, + ], + links: [], + } as unknown as WorkflowJSON, growCatalog); + applyOps(doc, [{ + op: "connect", op_id: "c".repeat(32), actor: "agent:t:1", base_version: 7, stamp: [7, "agent:t:1"], + link_id: 9, from_node: 1, from_slot: 0, to_node: 2, link_type: "IMAGE", + grow: { name: "images.image0", type: "IMAGE", widget: "upload" }, + }], growCatalog); + expect([...doc.getMap("__stamps").keys()].some((key) => key.startsWith('["grow_request",'))).toBe(true); + expect(observedDocCounter(doc)).toBe(7); + expect(observedDocCounter(replicaOf(doc))).toBe(7); + + // The skip covers only the request row: the grow's own stamp still counts and still fails closed. + const stamps = doc.getMap("__stamps"); + const growKey = [...stamps.keys()].find((key) => key.startsWith('["grow",')); + if (growKey === undefined) throw new Error("the autogrow connect wrote no grow stamp"); + stamps.set(growKey, [9, "agent:t:1", "c".repeat(32)]); + expect(observedDocCounter(doc)).toBe(9); + stamps.set(growKey, ["images.image0", null, false]); + expect(() => observedDocCounter(doc)).toThrow(/malformed stamp tuple/); + // Only an exact leading companion tag is skipped: a neighbouring tag or a nested one still fails closed. + for (const key of ['["grow_request_x","1"]', '["widget",["grow_request","1"]]']) { + const neighbour = mint({ nodes: [], links: [] }, catalog); + neighbour.getMap("__stamps").set(key, ["not", "a", "stamp"]); + expect(() => observedDocCounter(neighbour), key).toThrow(/Lamport counter/); + } + // Reservations are never companion rows, whatever their key. + const reserved = mint({ nodes: [], links: [] }, catalog); + reserved.getMap("__clock_reservations").set('["grow_request","1","9","images"]', [3, "agent:clock", "x"]); + expect(() => observedDocCounter(reserved)).toThrow(TypeError); + }); + + it("skips malformed rows only when asked, across both ledgers", async () => { + const doc = mint({ nodes: [], links: [] }, catalog); + await persistLamportTick(new DocDerivedLamportClockStore(doc), identity, [19]); + const stamps = doc.getMap("__stamps"); + stamps.set('["widget","1","0","seed"]', [12, "agent:t:1", "a".repeat(32)]); + stamps.set('["grow_request","1","9","images"]', ["images.image0", null, false]); + stamps.set("bad", [Number.NaN, "agent:bad", "c".repeat(32)]); + stamps.set("null-row", null); + doc.getMap("__clock_reservations").set('["__lamport_clock","w","l","other"]', [99, "someone", "x"]); + doc.getMap("__clock_reservations").set("not json", [98, "someone", "not json"]); + + expect(() => observedDocCounter(doc)).toThrow(/Lamport counter|malformed stamp tuple/); + // The mis-keyed reservation (producer "someone" vs key "other") is malformed but its counter 99 is + // readable: a floor below it would let the producer mint under a counter already in the document. + expect(observedDocCounter(doc, { skipMalformed: true })).toEqual({ counter: 99, skipped: 4 }); + expect(observedDocCounter(replicaOf(doc), { skipMalformed: true })).toEqual({ counter: 99, skipped: 4 }); + expect(observedDocCounter(mint({ nodes: [], links: [] }, catalog), { skipMalformed: true })) + .toEqual({ counter: undefined, skipped: 0 }); + expect(() => observedDocCounter(new Y.Doc(), { skipMalformed: true })).toThrow(/schema/); + // An unreadable reservations root is one more skipped entry in lenient mode (the strict read and + // the clock store still refuse it); an unreadable __stamps root still throws in either mode. + const brokenRoot = mint({ nodes: [], links: [] }, catalog); + brokenRoot.getMap("__stamps").set('["widget","1","0","seed"]', [12, "agent:t:1", "a".repeat(32)]); + brokenRoot.getArray("__clock_reservations").push([[5, "agent:clock", "x"]]); + expect(() => observedDocCounter(replicaOf(brokenRoot))).toThrow(/non-map content/); + expect(observedDocCounter(replicaOf(brokenRoot), { skipMalformed: true })).toEqual({ counter: 12, skipped: 1 }); + const brokenStamps = replicaOf(mint({ nodes: [], links: [] }, catalog)); + brokenStamps.getArray("__stamps").push([[5, "agent:clock", "x"]]); + expect(() => observedDocCounter(replicaOf(brokenStamps), { skipMalformed: true })).toThrow(/non-map content/); + }); + + it("keeps a malformed row's readable counter in the lenient floor", () => { + const doc = mint({ nodes: [], links: [] }, catalog); + const stamps = doc.getMap("__stamps"); + stamps.set('["widget","1","0","seed"]', [50, "agent:t:1", "a".repeat(32)]); + stamps.set('["widget","1","0","cfg"]', [900, 42, "b".repeat(32)]); + expect(() => observedDocCounter(doc)).toThrow(/malformed stamp tuple/); + expect(observedDocCounter(doc, { skipMalformed: true })).toEqual({ counter: 900, skipped: 1 }); + expect(observedDocCounter(replicaOf(doc), { skipMalformed: true })).toEqual({ counter: 900, skipped: 1 }); + }); + + it("skips a companion-keyed row only when its value has the companion shape", () => { + const counted = mint({ nodes: [], links: [] }, catalog); + counted.getMap("__stamps").set('["grow_request","1","9","images"]', [50, "agent:t:1", "a".repeat(32)]); + counted.getMap("__stamps").set('["interior_route","3","inc"]', [60, "agent:t:1", "b".repeat(32)]); + expect(observedDocCounter(counted)).toBe(60); + for (const value of [{ x: 1 }, 5, [7, null, false]]) { + const odd = mint({ nodes: [], links: [] }, catalog); + odd.getMap("__stamps").set('["grow_request","1","9","images"]', value); + expect(() => observedDocCounter(odd), JSON.stringify(value)).toThrow(TypeError); + } + const route = mint({ nodes: [], links: [] }, catalog); + route.getMap("__stamps").set('["interior_route","3","inc"]', ["images.image0", null, false]); + expect(() => observedDocCounter(route)).toThrow(TypeError); + route.getMap("__stamps").set('["interior_route","3","inc"]', "definition-id"); + expect(observedDocCounter(route)).toBeUndefined(); + }); + + it("keeps the strict floor readable after a real grow whose widget is not a string", () => { + const io = (name: string, links: object) => ({ name, type: "IMAGE", ...links }); + const doc = mint({ + nodes: [ + { id: 1, type: "Source", pos: [0, 0], inputs: [], outputs: [io("out", { links: [] })], widgets_values: [] }, + { id: 2, type: "Destination", pos: [0, 0], inputs: [io("fixed", { link: null })], outputs: [], widgets_values: [] }, + ], + links: [], + } as unknown as WorkflowJSON, growCatalog); + applyOps(doc, [{ + op: "connect", op_id: "d".repeat(32), actor: "agent:t:1", base_version: 7, stamp: [7, "agent:t:1"], + link_id: 9, from_node: 1, from_slot: 0, to_node: 2, link_type: "IMAGE", + grow: { name: "images.image0", type: "IMAGE", widget: 5 }, + } as unknown as Parameters[1][number]], growCatalog); + expect(observedDocCounter(doc)).toBe(7); + expect(observedDocCounter(replicaOf(doc))).toBe(7); + }); + it("keeps reservations out of public readStamps and preserves their identity tuple", async () => { const doc = mint({ nodes: [], links: [] }, catalog); const store = new DocDerivedLamportClockStore(doc); diff --git a/test/define-subgraph.test.ts b/test/define-subgraph.test.ts index 824b7b5..2f39d05 100644 --- a/test/define-subgraph.test.ts +++ b/test/define-subgraph.test.ts @@ -4,7 +4,10 @@ import { describe, expect, it } from "vitest" import { applyOps, + DocDerivedLamportClockStore, mint, + observedDocCounter, + persistLamportTick, project, type DefineSubgraphOp, type Op, @@ -384,6 +387,26 @@ describe("define_subgraph application", () => { expect(results.map(({ retainedRoute }) => retainedRoute)).toEqual([subgraphId, subgraphId]) }) + it("keeps the Lamport floor readable after a subgraph instance is deleted", async () => { + const instanceId = "dddddddd-dddd-4ddd-8ddd-dddddddddddd" + const doc = mint({ + nodes: [{ id: instanceId, type: subgraphId, inputs: [], outputs: [] }], + links: [], definitions: { subgraphs: [definition()] }, + } as unknown as WorkflowJSON, catalog) + const remove = { + op: "delete_node", node_id: instanceId, removed_links: [], + op_id: "f".repeat(32), actor: "human:delete", base_version: 5, stamp: [5, "human:delete"], + } as Op + expect(applyOps(doc, [remove], catalog).outcomes[0]?.outcome).toBe("applied") + expect(stampsMap(doc).get(JSON.stringify(["interior_route", instanceId, "0"]))).toBe(subgraphId) + + const replica = new Y.Doc() + Y.applyUpdate(replica, Y.encodeStateAsUpdate(doc)) + expect([observedDocCounter(doc), observedDocCounter(replica)]).toEqual([5, 5]) + const identity = { workflow_id: "w", lineage_id: "l", producer_id: "agent:clock" } + await expect(persistLamportTick(new DocDerivedLamportClockStore(doc), identity, [])).resolves.toBe(6) + }) + it("shares the canonical register between a retained instance route and a direct definition path", () => { const instanceId = "cccccccc-cccc-4ccc-8ccc-cccccccccccc" const doc = mint({ diff --git a/test/permutation/full-op-pool.permutation.test.ts b/test/permutation/full-op-pool.permutation.test.ts index 44e5440..e55d617 100644 --- a/test/permutation/full-op-pool.permutation.test.ts +++ b/test/permutation/full-op-pool.permutation.test.ts @@ -26,6 +26,7 @@ import { FROZEN_OPS, applyOps, mint, + observedDocCounter, project, type Op, type WireOp, @@ -287,6 +288,8 @@ function run( } } for (const group of groups) applyGroup(group); + // Every document this pool produces must keep a readable Lamport floor. + expect(() => observedDocCounter(doc)).not.toThrow(); const appliedIds = new Set(doc.getMap("__applied").keys()); for (const outcome of outcomes) { if (outcome.outcome === "rejected") expect(appliedIds.has(outcome.opId)).toBe(false);