js-bao 0.11.1 → 0.12.0-alpha.0

package/dist/browser.cjs

@@ -9106,16 +9106,11 @@ var init_BaseModel = __esm({
         this.format2Documents.clear();
       }
       /**
-       * The SYNCHRONOUS record store for `docId`, when one runs in this thread.
-       *
-       * `null` for a format-1 document, and `null` for a format-2 document whose
-       * store lives in a worker (#3429) — there is no such object here to hand
-       * out. The ORM drives {@link getFormat2StoreAsync}; this is kept for the
-       * direct reaches that predate the boundary (tests, diagnostics).
+       * Return the synchronous record store for a document, or `null` for a
+       * legacy document or a store running in a worker.
        *
-       * A write made through it is visible to the facade's reads and marks at
-       * once — it is the same database — but it does NOT refresh row-cache entries
-       * live instances are already holding; those follow the next settlement.
+       * Direct writes update the store but do not immediately refresh cached model
+       * instances. Use model methods for application writes.
        */
       static getFormat2Store(docId) {
         return resolveOrmContext(this).getFormat2Store(docId);
@@ -9236,16 +9231,9 @@ var init_BaseModel = __esm({
         );
       }
       /**
-       * Run an epoch move with `docId`'s local writes held back (#2816,
-       * behavior 10).
-       *
-       * A move replaces the document's overlay: the sealed Y.Doc is destroyed once
-       * the fresh one is bound. A write that resolved its target document before
-       * the move and lands its overlay entry after would land it in the doomed
-       * doc — and it could never be recovered, because `_pending_ops` records
-       * which fields a write touched, not the values it wrote. A write that starts
-       * during the move therefore waits here and resolves the document again on
-       * the other side. (Concurrent moves are serialized for the same reason.)
+       * Run an operation while local writes to this large document are paused.
+       * Concurrent operations are serialized. Writes resume against the current
+       * document state after the operation completes.
        */
       static async holdFormat2Writes(docId, run2) {
         return resolveOrmContext(this).holdFormat2Writes(docId, run2);
@@ -9258,13 +9246,8 @@ var init_BaseModel = __esm({
         return resolveOrmContext(this).format2WritesHeld(docId);
       }
       /**
-       * The record store, Y.Doc and model map a format-2 write should land on,
-       * having waited out any epoch move in flight (#2816, behavior 10).
-       *
-       * Resolves to the callers' own values in the overwhelmingly common case that
-       * no move is running, so an ordinary write pays one map lookup. When a move
-       * IS running, the write waits for it and the freshly bound overlay — and its
-       * rebuilt store — are what it lands on.
+       * Wait for any document transition to finish, then return the current
+       * record store, Y.Doc, and model map for the write.
        */
       static async resolveFormat2Target(docId, modelName, store, yDoc, modelYMap) {
         const held = this.format2WritesHeld(docId);
@@ -9857,11 +9840,9 @@ var init_BaseModel = __esm({
         resolveOrmContext(this).trackDocumentIndexing(docId, work);
       }
       /**
-       * Resolve once `docId`'s applied changes have reached this class's instance
-       * of the query tables (#3023). See
-       * {@link OrmContext.whenDocumentIndexed} — an `open()` that waited for the
-       * initial sync waits for this too, otherwise it resolves on the sync signal
-       * and the caller's first `query()` sees a partly-written table.
+       * Wait for applied document changes to reach the query tables.
+       * Stops waiting and logs a warning if indexing has not settled after
+       * 50 drain passes.
        */
       static async whenDocumentIndexed(docId) {
         const drained = await resolveOrmContext(this).whenDocumentIndexed(docId);
@@ -9874,14 +9855,9 @@ var init_BaseModel = __esm({
       /**
        * Initialize this model for a connected document.
        *
-       * `documentFormat` (#2816) decides where the records come from. On a legacy
-       * document the Y.Map IS the records, so this loads them into the query
-       * tables and observes the map. On a format-2 document the Y.Map is an epoch
-       * OVERLAY of flat `recordId/field` entries — walking it as records would
-       * read a scalar (or a `null` unset) as a record and mint junk rows, and
-       * observing it would run every overlay change through the legacy
-       * record-shaped path. There the tables are prepared here and hydrated and
-       * observed by `Format2DocumentBinding` from the merged view instead.
+       * For legacy documents, load records and observe their changes. For large
+       * documents, prepare the query tables; the document binding loads records
+       * and observes changes.
        */
       static async initializeForDocument(yDoc, db, docId, permissionHint, documentFormat = 1) {
         const schema = this.getSchema?.();
@@ -10418,23 +10394,8 @@ var init_BaseModel = __esm({
         );
       }
       /**
-       * Re-index ONE record of a document from its current Y.Map state (#3615).
-       *
-       * A legacy document's initial load walks the Y.Map before the permanent
-       * observers are installed, so an update that lands in that window reaches
-       * Yjs and misses the query tables. For a document connected long ago — which
-       * is exactly what a model registered at runtime is initialized against —
-       * that window is open on a live document. `registerModel` collects the
-       * record ids touched while it runs and brings each of them here afterwards,
-       * writing the same row the permanent per-record observer would have written.
-       *
-       * A record the window DELETED is deleted here for the same reason.
-       *
-       * A storage failure REJECTS rather than being logged and passed over, the
-       * way the permanent observers' writes are: this write is part of what a
-       * registration promises before it resolves, so swallowing it would resolve a
-       * registration whose query tables are missing the very updates this call
-       * exists to catch, and mark the pair complete so no retry would repair it.
+       * Refresh one record in the query tables from its current Y.Map state.
+       * Remove the indexed record if it was deleted. Reject on storage failure.
        */
       static async reindexDocumentRecord(docId, recordId) {
         const modelConstructor = this;
@@ -10494,20 +10455,9 @@ var init_BaseModel = __esm({
         ctx.notifyListeners(modelName);
       }
       /**
-       * Withdraw ONE document's registration of this model (#3615).
-       *
-       * A `registerModel` that fails part-way through a document keeps the class
-       * registered, because retrying is the recovery. This is what keeps that
-       * half-finished pair from LOOKING finished in the meantime: without the
-       * Y.Map mapping a save raises the same `YMap not found` an unregistered
-       * model raises, instead of writing into a document whose observers were
-       * never installed, and clearing the rows the failed load managed to write
-       * keeps a query from answering out of a document nothing is watching. The
-       * retry's `initializeForDocument` publishes both again.
-       *
-       * `connectedDocuments` is deliberately left alone: it is the CONTEXT's map,
-       * shared by every model on the instance, so the document itself is still
-       * connected for everything else.
+       * Remove this model's registration and indexed rows for one document
+       * after a failed initialization. The document stays connected for other
+       * models. Retry initialization to restore this model's registration.
        */
       static async withdrawDocumentRegistration(docId) {
         const modelConstructor = this;
@@ -11711,12 +11661,8 @@ var init_BaseModel = __esm({
         return true;
       }
       /**
-       * Remove a PAGE of records from the query tables, without consulting the
-       * merged view (#2816).
-       *
-       * The discard path: the rows are erased BEFORE the merged view is thrown
-       * away, because the view is the only place that still names them. Projecting
-       * would re-insert them — the record is still there at that point.
+       * Remove records from the query tables before discarding their document
+       * state. Notify listeners after the rows are removed.
        */
       static async deleteFormat2QueryRows(docId, recordIds) {
         if (recordIds.length === 0) return;
@@ -11730,12 +11676,8 @@ var init_BaseModel = __esm({
         modelConstructor.notifyListeners();
       }
       /**
-       * Project a PAGE of merged-view rows into the query tables (#2816).
-       *
-       * The hydration path: one notification for the page rather than one per
-       * record, because a model being hydrated has no intermediate states worth
-       * telling anyone about — and on a large document the per-record version is a
-       * subscriber callback per row of the document.
+       * Update the query tables for a page of large-document records.
+       * Notify listeners once after the page is indexed.
        */
       static async projectFormat2Records(docId, recordIds) {
         if (recordIds.length === 0) return;

package/dist/browser.d.cts

@@ -4029,8 +4029,7 @@ declare class BaseModel implements StringSetChangeTracker {
      */
     static registerFormat2Document(docId: string, 
     /**
-     * The facade, or a bare synchronous store — which is wrapped in an
-     * in-process host so the ORM has one thing to drive either way (#3429).
+     * The asynchronous store, or a synchronous store to wrap for asynchronous use.
      */
     store: Format2RecordStoreAsync | Format2RecordStore, 
     /**
@@ -4047,16 +4046,11 @@ declare class BaseModel implements StringSetChangeTracker {
      */
     static clearFormat2Documents(): void;
     /**
-     * The SYNCHRONOUS record store for `docId`, when one runs in this thread.
-     *
-     * `null` for a format-1 document, and `null` for a format-2 document whose
-     * store lives in a worker (#3429) — there is no such object here to hand
-     * out. The ORM drives {@link getFormat2StoreAsync}; this is kept for the
-     * direct reaches that predate the boundary (tests, diagnostics).
+     * Return the synchronous record store for a document, or `null` for a
+     * legacy document or a store running in a worker.
      *
-     * A write made through it is visible to the facade's reads and marks at
-     * once — it is the same database — but it does NOT refresh row-cache entries
-     * live instances are already holding; those follow the next settlement.
+     * Direct writes update the store but do not immediately refresh cached model
+     * instances. Use model methods for application writes.
      */
     static getFormat2Store(docId: string | null | undefined): Format2RecordStore | null;
     /** The asynchronous facade for `docId`, or `null` when it is format 1. */
@@ -4111,16 +4105,9 @@ declare class BaseModel implements StringSetChangeTracker {
     /** Every connected format-2 document, or just the ones a caller scoped to. */
     protected static format2DocumentsInScope(documents?: string | readonly string[] | null): string[];
     /**
-     * Run an epoch move with `docId`'s local writes held back (#2816,
-     * behavior 10).
-     *
-     * A move replaces the document's overlay: the sealed Y.Doc is destroyed once
-     * the fresh one is bound. A write that resolved its target document before
-     * the move and lands its overlay entry after would land it in the doomed
-     * doc — and it could never be recovered, because `_pending_ops` records
-     * which fields a write touched, not the values it wrote. A write that starts
-     * during the move therefore waits here and resolves the document again on
-     * the other side. (Concurrent moves are serialized for the same reason.)
+     * Run an operation while local writes to this large document are paused.
+     * Concurrent operations are serialized. Writes resume against the current
+     * document state after the operation completes.
      */
     static holdFormat2Writes<T>(docId: string, run: () => Promise<T>): Promise<T>;
     /**
@@ -4129,13 +4116,8 @@ declare class BaseModel implements StringSetChangeTracker {
      */
     static format2WritesHeld(docId: string | null | undefined): Promise<void> | null;
     /**
-     * The record store, Y.Doc and model map a format-2 write should land on,
-     * having waited out any epoch move in flight (#2816, behavior 10).
-     *
-     * Resolves to the callers' own values in the overwhelmingly common case that
-     * no move is running, so an ordinary write pays one map lookup. When a move
-     * IS running, the write waits for it and the freshly bound overlay — and its
-     * rebuilt store — are what it lands on.
+     * Wait for any document transition to finish, then return the current
+     * record store, Y.Doc, and model map for the write.
      */
     static resolveFormat2Target(docId: string, modelName: string, store: Format2RecordStoreAsync, yDoc: Y.Doc, modelYMap: Y.Map<any>): Promise<{
         store: Format2RecordStoreAsync;
@@ -4213,61 +4195,28 @@ declare class BaseModel implements StringSetChangeTracker {
      */
     protected static trackDocumentIndexing(docId: string, work: Promise<void>): void;
     /**
-     * Resolve once `docId`'s applied changes have reached this class's instance
-     * of the query tables (#3023). See
-     * {@link OrmContext.whenDocumentIndexed} — an `open()` that waited for the
-     * initial sync waits for this too, otherwise it resolves on the sync signal
-     * and the caller's first `query()` sees a partly-written table.
+     * Wait for applied document changes to reach the query tables.
+     * Stops waiting and logs a warning if indexing has not settled after
+     * 50 drain passes.
      */
     static whenDocumentIndexed(docId: string): Promise<void>;
     /**
      * Initialize this model for a connected document.
      *
-     * `documentFormat` (#2816) decides where the records come from. On a legacy
-     * document the Y.Map IS the records, so this loads them into the query
-     * tables and observes the map. On a format-2 document the Y.Map is an epoch
-     * OVERLAY of flat `recordId/field` entries — walking it as records would
-     * read a scalar (or a `null` unset) as a record and mint junk rows, and
-     * observing it would run every overlay change through the legacy
-     * record-shaped path. There the tables are prepared here and hydrated and
-     * observed by `Format2DocumentBinding` from the merged view instead.
+     * For legacy documents, load records and observe their changes. For large
+     * documents, prepare the query tables; the document binding loads records
+     * and observes changes.
      */
     static initializeForDocument(yDoc: Y.Doc, db: DatabaseEngine, docId: string, permissionHint: DocumentPermissionHint, documentFormat?: 1 | 2): Promise<void>;
     /**
-     * Re-index ONE record of a document from its current Y.Map state (#3615).
-     *
-     * A legacy document's initial load walks the Y.Map before the permanent
-     * observers are installed, so an update that lands in that window reaches
-     * Yjs and misses the query tables. For a document connected long ago — which
-     * is exactly what a model registered at runtime is initialized against —
-     * that window is open on a live document. `registerModel` collects the
-     * record ids touched while it runs and brings each of them here afterwards,
-     * writing the same row the permanent per-record observer would have written.
-     *
-     * A record the window DELETED is deleted here for the same reason.
-     *
-     * A storage failure REJECTS rather than being logged and passed over, the
-     * way the permanent observers' writes are: this write is part of what a
-     * registration promises before it resolves, so swallowing it would resolve a
-     * registration whose query tables are missing the very updates this call
-     * exists to catch, and mark the pair complete so no retry would repair it.
+     * Refresh one record in the query tables from its current Y.Map state.
+     * Remove the indexed record if it was deleted. Reject on storage failure.
      */
     static reindexDocumentRecord(docId: string, recordId: string): Promise<void>;
     /**
-     * Withdraw ONE document's registration of this model (#3615).
-     *
-     * A `registerModel` that fails part-way through a document keeps the class
-     * registered, because retrying is the recovery. This is what keeps that
-     * half-finished pair from LOOKING finished in the meantime: without the
-     * Y.Map mapping a save raises the same `YMap not found` an unregistered
-     * model raises, instead of writing into a document whose observers were
-     * never installed, and clearing the rows the failed load managed to write
-     * keeps a query from answering out of a document nothing is watching. The
-     * retry's `initializeForDocument` publishes both again.
-     *
-     * `connectedDocuments` is deliberately left alone: it is the CONTEXT's map,
-     * shared by every model on the instance, so the document itself is still
-     * connected for everything else.
+     * Remove this model's registration and indexed rows for one document
+     * after a failed initialization. The document stays connected for other
+     * models. Retry initialization to restore this model's registration.
      */
     static withdrawDocumentRegistration(docId: string): Promise<void>;
     static cleanupDocumentData(docId: string): Promise<void>;
@@ -4433,10 +4382,8 @@ declare class BaseModel implements StringSetChangeTracker {
      */
     static projectFormat2Record(docId: string, recordId: string, 
     /**
-     * `notify: false` withholds the listener notification, for a caller
-     * projecting many records at once (#2816): hydrating a model would
-     * otherwise tell every subscriber once per record, which on a large
-     * document is a re-render per row of the document.
+     * Set `notify: false` to suppress listener notifications when indexing
+     * several records together.
      */
     options?: {
         notify?: boolean;
@@ -4458,21 +4405,13 @@ declare class BaseModel implements StringSetChangeTracker {
     /** Project `recordIds` through the store's host; whether anything was sent. */
     private static projectFormat2Ids;
     /**
-     * Remove a PAGE of records from the query tables, without consulting the
-     * merged view (#2816).
-     *
-     * The discard path: the rows are erased BEFORE the merged view is thrown
-     * away, because the view is the only place that still names them. Projecting
-     * would re-insert them — the record is still there at that point.
+     * Remove records from the query tables before discarding their document
+     * state. Notify listeners after the rows are removed.
      */
     static deleteFormat2QueryRows(docId: string, recordIds: readonly string[]): Promise<void>;
     /**
-     * Project a PAGE of merged-view rows into the query tables (#2816).
-     *
-     * The hydration path: one notification for the page rather than one per
-     * record, because a model being hydrated has no intermediate states worth
-     * telling anyone about — and on a large document the per-record version is a
-     * subscriber callback per row of the document.
+     * Update the query tables for a page of large-document records.
+     * Notify listeners once after the page is indexed.
      */
     static projectFormat2Records(docId: string, recordIds: readonly string[]): Promise<void>;
     delete(): Promise<void>;

package/dist/browser.d.ts

@@ -4029,8 +4029,7 @@ declare class BaseModel implements StringSetChangeTracker {
      */
     static registerFormat2Document(docId: string, 
     /**
-     * The facade, or a bare synchronous store — which is wrapped in an
-     * in-process host so the ORM has one thing to drive either way (#3429).
+     * The asynchronous store, or a synchronous store to wrap for asynchronous use.
      */
     store: Format2RecordStoreAsync | Format2RecordStore, 
     /**
@@ -4047,16 +4046,11 @@ declare class BaseModel implements StringSetChangeTracker {
      */
     static clearFormat2Documents(): void;
     /**
-     * The SYNCHRONOUS record store for `docId`, when one runs in this thread.
-     *
-     * `null` for a format-1 document, and `null` for a format-2 document whose
-     * store lives in a worker (#3429) — there is no such object here to hand
-     * out. The ORM drives {@link getFormat2StoreAsync}; this is kept for the
-     * direct reaches that predate the boundary (tests, diagnostics).
+     * Return the synchronous record store for a document, or `null` for a
+     * legacy document or a store running in a worker.
      *
-     * A write made through it is visible to the facade's reads and marks at
-     * once — it is the same database — but it does NOT refresh row-cache entries
-     * live instances are already holding; those follow the next settlement.
+     * Direct writes update the store but do not immediately refresh cached model
+     * instances. Use model methods for application writes.
      */
     static getFormat2Store(docId: string | null | undefined): Format2RecordStore | null;
     /** The asynchronous facade for `docId`, or `null` when it is format 1. */
@@ -4111,16 +4105,9 @@ declare class BaseModel implements StringSetChangeTracker {
     /** Every connected format-2 document, or just the ones a caller scoped to. */
     protected static format2DocumentsInScope(documents?: string | readonly string[] | null): string[];
     /**
-     * Run an epoch move with `docId`'s local writes held back (#2816,
-     * behavior 10).
-     *
-     * A move replaces the document's overlay: the sealed Y.Doc is destroyed once
-     * the fresh one is bound. A write that resolved its target document before
-     * the move and lands its overlay entry after would land it in the doomed
-     * doc — and it could never be recovered, because `_pending_ops` records
-     * which fields a write touched, not the values it wrote. A write that starts
-     * during the move therefore waits here and resolves the document again on
-     * the other side. (Concurrent moves are serialized for the same reason.)
+     * Run an operation while local writes to this large document are paused.
+     * Concurrent operations are serialized. Writes resume against the current
+     * document state after the operation completes.
      */
     static holdFormat2Writes<T>(docId: string, run: () => Promise<T>): Promise<T>;
     /**
@@ -4129,13 +4116,8 @@ declare class BaseModel implements StringSetChangeTracker {
      */
     static format2WritesHeld(docId: string | null | undefined): Promise<void> | null;
     /**
-     * The record store, Y.Doc and model map a format-2 write should land on,
-     * having waited out any epoch move in flight (#2816, behavior 10).
-     *
-     * Resolves to the callers' own values in the overwhelmingly common case that
-     * no move is running, so an ordinary write pays one map lookup. When a move
-     * IS running, the write waits for it and the freshly bound overlay — and its
-     * rebuilt store — are what it lands on.
+     * Wait for any document transition to finish, then return the current
+     * record store, Y.Doc, and model map for the write.
      */
     static resolveFormat2Target(docId: string, modelName: string, store: Format2RecordStoreAsync, yDoc: Y.Doc, modelYMap: Y.Map<any>): Promise<{
         store: Format2RecordStoreAsync;
@@ -4213,61 +4195,28 @@ declare class BaseModel implements StringSetChangeTracker {
      */
     protected static trackDocumentIndexing(docId: string, work: Promise<void>): void;
     /**
-     * Resolve once `docId`'s applied changes have reached this class's instance
-     * of the query tables (#3023). See
-     * {@link OrmContext.whenDocumentIndexed} — an `open()` that waited for the
-     * initial sync waits for this too, otherwise it resolves on the sync signal
-     * and the caller's first `query()` sees a partly-written table.
+     * Wait for applied document changes to reach the query tables.
+     * Stops waiting and logs a warning if indexing has not settled after
+     * 50 drain passes.
      */
     static whenDocumentIndexed(docId: string): Promise<void>;
     /**
      * Initialize this model for a connected document.
      *
-     * `documentFormat` (#2816) decides where the records come from. On a legacy
-     * document the Y.Map IS the records, so this loads them into the query
-     * tables and observes the map. On a format-2 document the Y.Map is an epoch
-     * OVERLAY of flat `recordId/field` entries — walking it as records would
-     * read a scalar (or a `null` unset) as a record and mint junk rows, and
-     * observing it would run every overlay change through the legacy
-     * record-shaped path. There the tables are prepared here and hydrated and
-     * observed by `Format2DocumentBinding` from the merged view instead.
+     * For legacy documents, load records and observe their changes. For large
+     * documents, prepare the query tables; the document binding loads records
+     * and observes changes.
      */
     static initializeForDocument(yDoc: Y.Doc, db: DatabaseEngine, docId: string, permissionHint: DocumentPermissionHint, documentFormat?: 1 | 2): Promise<void>;
     /**
-     * Re-index ONE record of a document from its current Y.Map state (#3615).
-     *
-     * A legacy document's initial load walks the Y.Map before the permanent
-     * observers are installed, so an update that lands in that window reaches
-     * Yjs and misses the query tables. For a document connected long ago — which
-     * is exactly what a model registered at runtime is initialized against —
-     * that window is open on a live document. `registerModel` collects the
-     * record ids touched while it runs and brings each of them here afterwards,
-     * writing the same row the permanent per-record observer would have written.
-     *
-     * A record the window DELETED is deleted here for the same reason.
-     *
-     * A storage failure REJECTS rather than being logged and passed over, the
-     * way the permanent observers' writes are: this write is part of what a
-     * registration promises before it resolves, so swallowing it would resolve a
-     * registration whose query tables are missing the very updates this call
-     * exists to catch, and mark the pair complete so no retry would repair it.
+     * Refresh one record in the query tables from its current Y.Map state.
+     * Remove the indexed record if it was deleted. Reject on storage failure.
      */
     static reindexDocumentRecord(docId: string, recordId: string): Promise<void>;
     /**
-     * Withdraw ONE document's registration of this model (#3615).
-     *
-     * A `registerModel` that fails part-way through a document keeps the class
-     * registered, because retrying is the recovery. This is what keeps that
-     * half-finished pair from LOOKING finished in the meantime: without the
-     * Y.Map mapping a save raises the same `YMap not found` an unregistered
-     * model raises, instead of writing into a document whose observers were
-     * never installed, and clearing the rows the failed load managed to write
-     * keeps a query from answering out of a document nothing is watching. The
-     * retry's `initializeForDocument` publishes both again.
-     *
-     * `connectedDocuments` is deliberately left alone: it is the CONTEXT's map,
-     * shared by every model on the instance, so the document itself is still
-     * connected for everything else.
+     * Remove this model's registration and indexed rows for one document
+     * after a failed initialization. The document stays connected for other
+     * models. Retry initialization to restore this model's registration.
      */
     static withdrawDocumentRegistration(docId: string): Promise<void>;
     static cleanupDocumentData(docId: string): Promise<void>;
@@ -4433,10 +4382,8 @@ declare class BaseModel implements StringSetChangeTracker {
      */
     static projectFormat2Record(docId: string, recordId: string, 
     /**
-     * `notify: false` withholds the listener notification, for a caller
-     * projecting many records at once (#2816): hydrating a model would
-     * otherwise tell every subscriber once per record, which on a large
-     * document is a re-render per row of the document.
+     * Set `notify: false` to suppress listener notifications when indexing
+     * several records together.
      */
     options?: {
         notify?: boolean;
@@ -4458,21 +4405,13 @@ declare class BaseModel implements StringSetChangeTracker {
     /** Project `recordIds` through the store's host; whether anything was sent. */
     private static projectFormat2Ids;
     /**
-     * Remove a PAGE of records from the query tables, without consulting the
-     * merged view (#2816).
-     *
-     * The discard path: the rows are erased BEFORE the merged view is thrown
-     * away, because the view is the only place that still names them. Projecting
-     * would re-insert them — the record is still there at that point.
+     * Remove records from the query tables before discarding their document
+     * state. Notify listeners after the rows are removed.
      */
     static deleteFormat2QueryRows(docId: string, recordIds: readonly string[]): Promise<void>;
     /**
-     * Project a PAGE of merged-view rows into the query tables (#2816).
-     *
-     * The hydration path: one notification for the page rather than one per
-     * record, because a model being hydrated has no intermediate states worth
-     * telling anyone about — and on a large document the per-record version is a
-     * subscriber callback per row of the document.
+     * Update the query tables for a page of large-document records.
+     * Notify listeners once after the page is indexed.
      */
     static projectFormat2Records(docId: string, recordIds: readonly string[]): Promise<void>;
     delete(): Promise<void>;