@procedures/mongo 0.54.0 → 0.55.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package",
   "name": "@procedures/mongo",
-  "version": "0.54.0",
+  "version": "0.55.0",
   "description": "MongoDB as typed procedures: documents, bulk writes, distinct, explain, collections, indexes, aggregation, change streams and database info, with safe update and delete targets.",
   "keywords": [
     "mongodb",
@@ -66,10 +66,11 @@
   "devDependencies": {
     "@mark1russell7/cue": "^2.1.1",
     "@mark1russell7/rigor-bench": "^0.2.33",
+    "@mark1russell7/rigor-chaos": "^0.1.0",
     "@mark1russell7/rigor-generators": "^0.1.5",
     "@mark1russell7/rigor-statistics": "^0.1.9",
-    "@procedures/peer": "0.54.0",
-    "@procedures/store": "0.54.0",
+    "@procedures/peer": "0.55.0",
+    "@procedures/store": "0.55.0",
     "@types/node": "^22.0.0",
     "typescript": "^7.0.2",
     "vitest": "^5.0.3"
@@ -79,8 +80,8 @@
   },
   "dependencies": {
     "@mark1russell7/collections": "^0.10.0",
-    "@procedures/client": "0.54.0",
-    "@procedures/collections": "0.54.0",
+    "@procedures/client": "0.55.0",
+    "@procedures/collections": "0.55.0",
     "@mark1russell7/service": "^0.8.3",
     "mongodb": "^7.0.0",
     "zod": "^4.6.5",

package/src/storage/document-storage.ts

@@ -230,6 +230,26 @@ export interface MongoDocumentStorageOptions<T = unknown> {
   queryPolicy?: StorageQueryPolicy | undefined;
   /** The collection of the sequence counters (default `__storage_counters`). */
   counters?: string | undefined;
+  /**
+   * The sequence of the numbers of the writes (roadmap CLI-96). `collection` (the default): one counter for the collection.
+   * `partition`: one counter and one write queue for each partition, so the writes of two partitions share no document.
+   *
+   * - Give the same value to each store of a collection. A store refuses a collection that has the other sequence, with a clear error.
+   * - A store with `partition` refuses a collection with numbers on its counter of the collection. Use it for a new collection.
+   * - One partition keeps the limit of one collection with the default: approximately 400 writes a second, and a stated limit of 200.
+   */
+  sequence?: "collection" | "partition" | undefined;
+  /**
+   * The most writes of each client at one time, over the stores with the same value (roadmap CLI-96). The default is 8.
+   * A write waits for a permit after its turn in the write queue of its counter.
+   *
+   * - With `sequence: "partition"`, each partition has its own queue. Without this bound, each partition of a process has a transaction open at once.
+   * - A whole number of 1 or more, or `Infinity` for no bound. Another value is a `RangeError`.
+   * - The sweeps of 2, 4, 8, 16 and `Infinity` at the bench cases `400-p2` and `4000-p2` set the default of 8.
+   * - With `sequence: "partition"`, `Infinity` costs approximately 30 % of the writes a second. The bench run 42428048767
+   *   gives 638.5 against 916.5 of the default sequence at `4000-p2`. The store emits a process warning one time for it.
+   */
+  writesInFlight?: number | undefined;
   /**
    * The time after which a pending number of a write no longer holds the watermark (default 60 s):
    * a writer that stopped does not stop the change reads. A plain number is a `TypeError`.
@@ -286,13 +306,31 @@ interface PendingRange {
   at: Date;
 }
 
-/** A document of the counters: the sequence of a collection, or the floor of the log of a partition. */
+/** A document of the counters: the sequence of a collection or of a partition, or the floor of the log of a partition. */
 interface CounterDoc {
   _id: string;
   seq?: number;
   epoch?: string;
   floor?: number;
   pending?: PendingRange[];
+  /** `partition` on the counter of a collection whose stores have the option `sequence: "partition"` (roadmap CLI-96). */
+  sequence?: string;
+}
+
+/**
+ * The checks of the sequence of each collection (roadmap CLI-96): by the client, then by the names of the database, the
+ * counters and the collection. A check that fails leaves no entry, so the next call tries again.
+ */
+const SEQUENCE_CHECKS = new WeakMap<object, Map<string, Promise<void>>>();
+
+/** The error of a store whose sequence is not the sequence of its collection (roadmap CLI-96). */
+function sequenceMismatch(collection: string, sequence: "collection" | "partition"): Error {
+  return sequence === "partition"
+    ? new Error(
+        `The collection ${collection} has numbers on its counter of the collection, so the option sequence "partition" refuses it. ` +
+          "The option is for a collection with no writes. The move of a live collection is a step with all processes stopped."
+      )
+    : new Error(`The collection ${collection} has a counter for each partition. Give the option sequence "partition" to each store of it.`);
 }
 
 /** True when a client is on a replica set or a sharded cluster: it has transactions. */
@@ -328,6 +366,37 @@ const QUEUES = new WeakMap<object, Map<string, Promise<unknown>>>();
 /** The change reads of each client at one time. A burst of reads leaves the pool to the other operations. */
 const READS = new WeakMap<object, Semaphore>();
 
+/** The default of the option `writesInFlight`: the most writes of each client at one time (roadmap CLI-96). */
+export const DEFAULT_WRITES_IN_FLIGHT = 8;
+
+/** The code of the process warning for a store with `sequence: "partition"` and no bound on its writes. */
+export const UNBOUNDED_PARTITION_WARNING = "PROCEDURES_MONGO_UNBOUNDED_PARTITION";
+
+let warnedUnboundedPartition = false;
+
+/** This function emits the process warning of an unbounded store with a counter for each partition, one time. */
+function warnUnboundedPartition(): void {
+  if (warnedUnboundedPartition) return;
+  warnedUnboundedPartition = true;
+  process.emitWarning(
+    'writesInFlight: Infinity with sequence: "partition" costs approximately 30 % of the writes a second. Use the default bound of 8.',
+    { code: UNBOUNDED_PARTITION_WARNING },
+  );
+}
+
+/** The permits of the writes of each client, by the value of `writesInFlight`: the stores with one value share the permits. */
+const WRITES = new WeakMap<object, Map<number, Semaphore>>();
+
+/** This function gives the permits of the writes of a client for a bound. */
+function writePermitsOf(db: Db, bound: number): Semaphore {
+  const owner = ownerOf(db);
+  let byBound = WRITES.get(owner);
+  if (!byBound) WRITES.set(owner, (byBound = new Map()));
+  let permits = byBound.get(bound);
+  if (!permits) byBound.set(bound, (permits = semaphore(bound)));
+  return permits;
+}
+
 /** This function starts a write after each earlier write of the collection. */
 function enqueueWrite<R>(db: Db, name: string, task: () => Promise<R>): Promise<R> {
   const owner = ownerOf(db);
@@ -639,6 +708,8 @@ export interface StorageWriteTarget {
   withPendingNumbers<R>(db: Db, count: number, write: (first: number) => Promise<R>): Promise<R>;
   /** This method writes the floor document of the partition once (roadmap O66). */
   noteFloor(db: Db): Promise<void>;
+  /** The sequence of the numbers: one counter for the collection, or one for each partition (roadmap CLI-96). */
+  readonly sequence: "collection" | "partition";
   /** This method drops the oldest tombstones over the limit, and raises the floor of the change log. */
   prune(db: Db): Promise<void>;
 }
@@ -756,10 +827,11 @@ function prefilter(selector: StorageSelector, options: SelectorPrefilterOptions,
   return parts.length === 1 ? parts[0] : { $and: parts };
 }
 
-/** The sequence counter of a collection. */
+/** The sequence counter of a collection or of a partition. */
 interface Counter {
   seq: number;
   epoch: string;
+  sequence?: string;
 }
 
 /** The watermark of a collection, with the floor of the log of a partition. */
@@ -787,6 +859,8 @@ export class MongoDocumentStorage<T> implements CollectionStorage<T> {
   private readonly maxTombstones: number;
   private readonly countersName: string;
   private readonly writeLeaseMs: number;
+  /** The most writes of each client at one time, over the stores with this value. `Infinity` is no bound. */
+  private readonly writesInFlight: number;
   /** The storages of the partitions, for `forPartition`: the same storage for the same partition. */
   private readonly partitions: Map<string, MongoDocumentStorage<T>>;
   /** The stored form of the documents (roadmap CLI-76). A `ViewMaterializer` of the collection takes the same form. */
@@ -800,6 +874,12 @@ export class MongoDocumentStorage<T> implements CollectionStorage<T> {
   private indexes: Promise<void> | undefined;
   /** True after this storage wrote (or found) the floor document of its partition (roadmap O66). A failed write leaves it false. */
   private floorNoted = false;
+  /** The sequence of the numbers (roadmap CLI-96). */
+  private readonly sequence: "collection" | "partition";
+  /** The `_id` of the counter of the numbers: the collection, or the partition with the option `sequence: "partition"`. */
+  private readonly counterId: string;
+  /** The partition of the notes of the own numbers with a counter for each partition, else `undefined` (roadmap CLI-96). */
+  private readonly ownScope: string | undefined;
   private closed = false;
 
   static {
@@ -818,6 +898,7 @@ export class MongoDocumentStorage<T> implements CollectionStorage<T> {
     writeTargetOfStorage = <S>(storage: MongoDocumentStorage<S>): StorageWriteTarget => ({
       collection: storage.collectionName,
       counters: storage.countersName,
+      sequence: storage.sequence,
       form: storage.form,
       partition: storage.partition,
       writeLeaseMs: storage.writeLeaseMs,
@@ -862,8 +943,18 @@ export class MongoDocumentStorage<T> implements CollectionStorage<T> {
     this.maxTombstones = options.maxTombstones ?? 10_000;
     if (!Number.isSafeInteger(this.maxTombstones) || this.maxTombstones < 0) throw new Error("maxTombstones must be a whole number of 0 or more");
     this.countersName = options.counters ?? "__storage_counters";
+    const sequence = options.sequence ?? "collection";
+    if (sequence !== "collection" && sequence !== "partition") throw new TypeError(`sequence must be "collection" or "partition", not ${JSON.stringify(sequence)}`);
+    this.sequence = sequence;
+    this.counterId = sequence === "partition" ? `seq${SEPARATOR}${this.collectionName}${SEPARATOR}${this.partition ?? ""}` : this.collectionName;
+    this.ownScope = sequence === "partition" ? (this.partition ?? "") : undefined;
     this.writeLeaseMs = Math.round(optionalMs(options.writeLease, "writeLease") ?? 60_000);
     if (!Number.isSafeInteger(this.writeLeaseMs) || this.writeLeaseMs < 1) throw new Error("writeLease must be 1 ms or more");
+    this.writesInFlight = options.writesInFlight ?? DEFAULT_WRITES_IN_FLIGHT;
+    if (!(this.writesInFlight === Infinity || (Number.isSafeInteger(this.writesInFlight) && this.writesInFlight >= 1))) {
+      throw new RangeError(`writesInFlight must be a whole number of 1 or more, or Infinity, not ${String(options.writesInFlight)}`);
+    }
+    if (this.writesInFlight === Infinity && this.sequence === "partition") warnUnboundedPartition();
     this.partitions = partitions ?? new Map();
   }
 
@@ -1011,7 +1102,7 @@ export class MongoDocumentStorage<T> implements CollectionStorage<T> {
    */
   private async allocate(db: Db, count: number): Promise<{ first: number; epoch: string }> {
     const counter = (await db.collection<CounterDoc>(this.countersName).findOneAndUpdate(
-      { _id: this.collectionName },
+      { _id: this.counterId },
       [
         { $set: { seq: { $add: [{ $ifNull: ["$seq", 0] }, count] }, epoch: { $ifNull: ["$epoch", randomUUID()] } } },
         {
@@ -1025,7 +1116,12 @@ export class MongoDocumentStorage<T> implements CollectionStorage<T> {
       { upsert: true, returnDocument: "after" }
     )) as unknown as Counter | null;
     if (!counter) throw new Error(`The sequence of ${this.collectionName} is not available`);
-    return { first: counter.seq - count + 1, epoch: counter.epoch };
+    const first = counter.seq - count + 1;
+    if (this.sequence === "collection" && counter.sequence === "partition") {
+      await this.release(db, first).catch(() => undefined);
+      throw sequenceMismatch(this.collectionName, "collection");
+    }
+    return { first, epoch: counter.epoch };
   }
 
   /**
@@ -1037,7 +1133,7 @@ export class MongoDocumentStorage<T> implements CollectionStorage<T> {
   private async release(db: Db, first: number): Promise<boolean> {
     const live = { $gt: ["$$this.at", { $subtract: ["$$NOW", this.writeLeaseMs] }] };
     const after = (await db.collection<CounterDoc>(this.countersName).findOneAndUpdate(
-      { _id: this.collectionName },
+      { _id: this.counterId },
       [
         {
           $set: {
@@ -1093,19 +1189,22 @@ export class MongoDocumentStorage<T> implements CollectionStorage<T> {
     own = true
   ): Promise<R> {
     const noteOwn = own ? noteOwnNumbers : (): void => undefined;
+    await this.checkSequence(db);
     const client = await this.transactionClient(db);
     if (client) {
       const session = client.startSession();
       try {
         return await session.withTransaction(async () => {
           const counter = (await db.collection<CounterDoc>(this.countersName).findOneAndUpdate(
-            { _id: this.collectionName },
+            { _id: this.counterId },
             { $inc: { seq: count }, $setOnInsert: { epoch: randomUUID() } },
             { upsert: true, returnDocument: "after", session }
           )) as unknown as Counter | null;
           if (!counter) throw new Error(`The sequence of ${this.collectionName} is not available`);
+          // The error aborts the transaction, so the counter keeps its number
+          if (this.sequence === "collection" && counter.sequence === "partition") throw sequenceMismatch(this.collectionName, "collection");
           // A watcher of the collection in this process skips the events of these numbers (roadmap CLI-77)
-          noteOwn(db, this.collectionName, counter.seq - count + 1, count);
+          noteOwn(db, this.collectionName, counter.seq - count + 1, count, this.ownScope);
           return write(counter.seq - count + 1, session);
         });
       } finally {
@@ -1126,10 +1225,11 @@ export class MongoDocumentStorage<T> implements CollectionStorage<T> {
     collection: Collection<Stored>,
     count: number,
     write: (first: number) => Promise<R>,
-    noteOwn: (db: Db, collection: string, first: number, count: number) => void
+    noteOwn: (db: Db, collection: string, first: number, count: number, scope?: string) => void
   ): Promise<R> {
+    await this.checkSequence(db);
     let { first } = await this.allocate(db, count);
-    noteOwn(db, this.collectionName, first, count);
+    noteOwn(db, this.collectionName, first, count, this.ownScope);
     let result: R;
     try {
       result = await write(first);
@@ -1141,7 +1241,7 @@ export class MongoDocumentStorage<T> implements CollectionStorage<T> {
       if (moves >= MAX_MOVES) throw new Error(`A write of ${this.collectionName} stayed late after ${MAX_MOVES} moves to new numbers`);
       // Late: a reader can have passed these numbers. The write takes new ones.
       const next = (await this.allocate(db, count)).first;
-      noteOwn(db, this.collectionName, next, count);
+      noteOwn(db, this.collectionName, next, count, this.ownScope);
       await this.move(collection, first, count, next);
       first = next;
     }
@@ -1151,20 +1251,23 @@ export class MongoDocumentStorage<T> implements CollectionStorage<T> {
   /**
    * The watermark of the collection: the highest number below each pending number of a write whose
    * lease has not ended, the epoch, and the floor of the partition. Each number up to it is written
-   * or abandoned. One command reads them. Only the first read of a collection writes: it makes the counter.
+   * or abandoned. One command reads them. Only the first read of a store writes: it makes the counter. With the
+   * option `sequence: "partition"`, the first read of each process also marks the counter of the collection.
    */
   private async watermark(db: Db): Promise<Watermark> {
+    await this.checkSequence(db);
     const counters = db.collection<CounterDoc>(this.countersName);
     const floorId = this.floorId();
-    const read = (): Promise<Array<{ _id: string; seq: number; epoch: string; floor?: number; low: number | null }>> =>
+    const read = (): Promise<Array<{ _id: string; seq: number; epoch: string; floor?: number; low: number | null; sequence?: string }>> =>
       counters
-        .aggregate<{ _id: string; seq: number; epoch: string; floor?: number; low: number | null }>([
-          { $match: { _id: { $in: [this.collectionName, floorId] } } },
+        .aggregate<{ _id: string; seq: number; epoch: string; floor?: number; low: number | null; sequence?: string }>([
+          { $match: { _id: { $in: [this.counterId, floorId] } } },
           {
             $project: {
               seq: 1,
               epoch: 1,
               floor: 1,
+              sequence: 1,
               low: {
                 $min: {
                   $map: {
@@ -1180,20 +1283,54 @@ export class MongoDocumentStorage<T> implements CollectionStorage<T> {
         ])
         .toArray();
     let docs = await read();
-    if (!docs.some((doc) => doc._id === this.collectionName)) {
+    if (!docs.some((doc) => doc._id === this.counterId)) {
       // A duplicate key: another read made the counter at the same time
-      await counters.updateOne({ _id: this.collectionName }, { $setOnInsert: { seq: 0, epoch: randomUUID() } }, { upsert: true }).catch((error: unknown) => {
+      await counters.updateOne({ _id: this.counterId }, { $setOnInsert: { seq: 0, epoch: randomUUID() } }, { upsert: true }).catch((error: unknown) => {
         if (!isDuplicateKey(error)) throw error;
       });
       docs = await read();
     }
-    const mark = docs.find((doc) => doc._id === this.collectionName);
+    const mark = docs.find((doc) => doc._id === this.counterId);
     if (!mark) throw new Error(`The sequence of ${this.collectionName} is not available`);
+    if (this.sequence === "collection" && mark.sequence === "partition") throw sequenceMismatch(this.collectionName, "collection");
     const seq = typeof mark.low === "number" ? Math.min(mark.seq, mark.low - 1) : mark.seq;
     const floor = docs.find((doc) => doc._id === floorId)?.floor;
     return { seq, epoch: mark.epoch, floor: typeof floor === "number" ? floor : 0, held: seq < mark.seq };
   }
 
+  /**
+   * This method checks once for each collection that a store with the option `sequence: "partition"` can use it (roadmap
+   * CLI-96). One atomic step marks the counter of the collection, unless that counter has numbers. A store with the default
+   * reads the mark in its own steps on that counter, so it needs no check of its own.
+   */
+  private checkSequence(db: Db): Promise<void> {
+    if (this.sequence === "collection") return Promise.resolve();
+    const owner = ownerOf(db);
+    let checks = SEQUENCE_CHECKS.get(owner);
+    if (!checks) SEQUENCE_CHECKS.set(owner, (checks = new Map()));
+    const key = `${db.databaseName}\u0000${this.countersName}\u0000${this.collectionName}`;
+    let check = checks.get(key);
+    if (!check) {
+      const mark = async (): Promise<void> => {
+        const counter = await db.collection<CounterDoc>(this.countersName).findOneAndUpdate(
+          { _id: this.collectionName },
+          // A counter with numbers keeps its mark as it is: absent for a collection of the default sequence
+          [{ $set: { sequence: { $cond: [{ $gt: [{ $ifNull: ["$seq", 0] }, 0] }, "$sequence", "partition"] } } }],
+          { upsert: true, returnDocument: "after" }
+        );
+        if (counter?.sequence !== "partition") throw sequenceMismatch(this.collectionName, "partition");
+      };
+      // Two processes can insert the counter at the same time: the second finds it at its next try
+      check = mark().catch((error: unknown) => (isDuplicateKey(error) ? mark() : Promise.reject(error)));
+      checks.set(key, check);
+      const own = checks;
+      check.catch(() => {
+        if (own.get(key) === check) own.delete(key);
+      });
+    }
+    return check;
+  }
+
   /** The id of the document of the oldest kept change of the partition. */
   private async floorOf(db: Db): Promise<number> {
     const doc = await db.collection<CounterDoc>(this.countersName).findOne({ _id: this.floorId() });
@@ -1460,11 +1597,15 @@ export class MongoDocumentStorage<T> implements CollectionStorage<T> {
 
   private async write<R>(task: (db: Db, items: Collection<Stored>) => Promise<R>): Promise<R> {
     const { db, items } = await this.collection();
-    return enqueueWrite(db, this.collectionName, async () => {
+    const run = async (): Promise<R> => {
       // The floor document of the partition, outside each transaction of the task (roadmap O66)
       await this.noteFloor(db);
       return task(db, items);
-    });
+    };
+    // The permit comes after the turn in the queue, so a write that waits for an earlier write of its counter holds no permit
+    if (this.writesInFlight === Infinity) return enqueueWrite(db, this.counterId, run);
+    const permits = writePermitsOf(db, this.writesInFlight);
+    return enqueueWrite(db, this.counterId, () => permits.run(run));
   }
 
   async set(id: string, value: T, options?: StorageItemWriteOptions): Promise<void> {

package/src/storage/materializer.ts

@@ -360,6 +360,7 @@ function contentHash(doc: Document): string {
 interface StorageTargetValues {
   readonly form: StoredForm;
   readonly counters: string | undefined;
+  readonly sequence: "collection" | "partition" | undefined;
   readonly writeLeaseMs: number | undefined;
   readonly maxTombstones: number | undefined;
 }
@@ -557,7 +558,7 @@ export class ViewMaterializer {
   /**
    * A target of `storageTargets` as a storage on the database of the materializer, so its writes
    * and the transaction of a run use one client. A given storage gives its form, its counters,
-   * `writeLease` and `maxTombstones`.
+   * its sequence, `writeLease` and `maxTombstones`.
    */
   private storageTargetOf(collection: string, entry: ViewStorageTargetEntry): StorageTargetEntry {
     const wrapped = typeof entry === "object" && entry !== null && "target" in entry ? entry : { target: entry };
@@ -568,15 +569,15 @@ export class ViewMaterializer {
     if (target instanceof MongoDocumentStorage) {
       const parts = storageWriteTarget(target);
       if (parts.collection !== collection) throw new TypeError(`The storage target ${collection} has a storage of the collection ${parts.collection}`);
-      values = { form: parts.form, counters: parts.counters, writeLeaseMs: parts.writeLeaseMs, maxTombstones: parts.maxTombstones };
+      values = { form: parts.form, counters: parts.counters, sequence: parts.sequence, writeLeaseMs: parts.writeLeaseMs, maxTombstones: parts.maxTombstones };
     } else if (typeof target === "object" && target !== null && typeof (target as Partial<StoredForm>).storedId === "function") {
-      values = { form: target as StoredForm, counters: undefined, writeLeaseMs: undefined, maxTombstones: undefined };
+      values = { form: target as StoredForm, counters: undefined, sequence: undefined, writeLeaseMs: undefined, maxTombstones: undefined };
     } else {
       throw new TypeError(`The storage target ${collection} needs a MongoDocumentStorage, a stored form or a ViewStorageTarget`);
     }
     // The same values give the storage of the last run: its partitions keep their state (the floor document of O66)
     const cached = this.storageTargetCache.get(collection);
-    if (cached && cached.form === values.form && cached.counters === values.counters && cached.writeLeaseMs === values.writeLeaseMs && cached.maxTombstones === values.maxTombstones) {
+    if (cached && cached.form === values.form && cached.counters === values.counters && cached.sequence === values.sequence && cached.writeLeaseMs === values.writeLeaseMs && cached.maxTombstones === values.maxTombstones) {
       return { storage: cached.storage, storagePartitionOf };
     }
     const db = (): Db => {
@@ -589,6 +590,7 @@ export class ViewMaterializer {
       form: values.form,
       transactions: "never",
       ...(values.counters !== undefined ? { counters: values.counters } : {}),
+      ...(values.sequence !== undefined ? { sequence: values.sequence } : {}),
       ...(values.writeLeaseMs !== undefined ? { writeLease: ms(values.writeLeaseMs) } : {}),
       ...(values.maxTombstones !== undefined ? { maxTombstones: values.maxTombstones } : {}),
     });

package/src/storage/own-writes.ts

@@ -35,8 +35,11 @@ const MAX_OWN_WRITES = 100_000;
 
 /** The noted writes of one watcher of one collection. */
 export interface OwnNumbers {
-  /** True when a write of this process noted the number and no event took it yet. The number is then taken. */
-  take(seq: number): boolean;
+  /**
+   * True when a write of this process noted the number and no event took it yet. The number is then taken. With a counter for
+   * each partition (roadmap CLI-96), two partitions can have the same number, so give the partition of the event too.
+   */
+  take(seq: number, partition?: string): boolean;
   /** True when this process pruned the tombstone of the stored `_id` and no event took it yet. The entry is then taken. */
   takePruned(storedId: unknown): boolean;
   /** This method ends the tracking: the storage notes no more entries for it. */
@@ -52,7 +55,8 @@ export interface TrackOwnNumbersOptions {
 }
 
 interface Tracker {
-  readonly numbers: Map<number, number> | undefined;
+  /** The numbers: a number for the counter of the collection, and the partition with the number for a counter of each partition. */
+  readonly numbers: Map<number | string, number> | undefined;
   readonly pruned: Map<string, number>;
   readonly now: () => number;
 }
@@ -121,8 +125,9 @@ export function trackOwnNumbers(db: Db, collection: string, options: TrackOwnNum
     return until > tracker.now();
   };
   return {
-    take(seq: number): boolean {
-      return tracker.numbers !== undefined && live(tracker.numbers as Map<unknown, number>, seq);
+    take(seq: number, partition?: string): boolean {
+      const numbers = tracker.numbers as Map<unknown, number> | undefined;
+      return numbers !== undefined && (live(numbers, seq) || live(numbers, scopedKey(partition ?? "", seq)));
     },
     takePruned(storedId: unknown): boolean {
       return live(tracker.pruned as Map<unknown, number>, idKey(storedId));
@@ -137,14 +142,22 @@ export function trackOwnNumbers(db: Db, collection: string, options: TrackOwnNum
   };
 }
 
-/** This function notes the numbers `first` to `first + count - 1` of a write of this process, for each open tracker of the collection. */
-export function noteOwnNumbers(db: Db, collection: string, first: number, count: number): void {
+/** The key of a number of a counter of a partition (roadmap CLI-96). The partition of a store without a partition is the empty text. */
+function scopedKey(partition: string, seq: number): string {
+  return `${partition}\u001f${String(seq)}`;
+}
+
+/**
+ * This function notes the numbers `first` to `first + count - 1` of a write of this process, for each open tracker of the
+ * collection. `scope` is the partition of a counter of each partition (roadmap CLI-96), and absent for the counter of the collection.
+ */
+export function noteOwnNumbers(db: Db, collection: string, first: number, count: number, scope?: string): void {
   const trackers = trackersOf(db, collection);
   if (!trackers) return;
   for (const tracker of trackers) {
     if (!tracker.numbers) continue;
-    const numbers: number[] = [];
-    for (let seq = first; seq < first + count; seq++) numbers.push(seq);
+    const numbers: Array<number | string> = [];
+    for (let seq = first; seq < first + count; seq++) numbers.push(scope === undefined ? seq : scopedKey(scope, seq));
     noteAll(tracker.numbers, numbers, tracker.now());
   }
 }

package/src/storage/storage-hints.ts

@@ -868,7 +868,7 @@ export function watchStorageChanges<T>(storage: MongoDocumentStorage<T>, publish
     if (source.partition !== undefined && item.partition !== source.partition) return;
     if (!item.raw) {
       // The event of a write of this process: the collection procedures publish it
-      if (skipOwn && own && item.seq !== undefined && own.take(item.seq)) return;
+      if (skipOwn && own && item.seq !== undefined && own.take(item.seq, item.partition)) return;
       return publishItem(item);
     }
     const before = asDocument(change["fullDocumentBeforeChange"]);