@50arms/ui 0.0.0-stage → 35.1.0

package/dist/lib/paged-window/records-binding.js

@@ -0,0 +1,239 @@
+import { registerActiveRead as K } from "../reads/refetch.js";
+import { subscribeToLayers as v, writeAll as N, readState as L, readBaseState as P, layeredKeys as m, readBaseVersion as y, hasKeptLayer as C, subscribeToKey as E, retainKeys as I, getRecordStoreTenant as q } from "../records/store.js";
+import { payloadIdentity as x } from "../records/wire.js";
+const h = /* @__PURE__ */ Symbol("unknown"), d = /* @__PURE__ */ Symbol("deleted");
+class A {
+  constructor(e, s, n) {
+    if (this.getKey = n, typeof e.toPayload != "function" || typeof e.fromRecord != "function")
+      throw new Error("PagedWindowStore: records needs toPayload and fromRecord.");
+    if (typeof e.tag != "string" || e.tag === "")
+      throw new Error("PagedWindowStore: records needs a tag, the field set a page fetch satisfies.");
+    this.typeName = e.type.type, this.tag = e.tag, this.options = e, this.onChange = s;
+  }
+  getKey;
+  typeName;
+  tag;
+  options;
+  onChange;
+  /** key -> the row built from the stored state last seen; the same state gives the same row object. */
+  rowCache = /* @__PURE__ */ new Map();
+  placed = /* @__PURE__ */ new Map();
+  /** Keys carrying a layer that mattered at the last look (placed, or held and left out): the ones whose last layer going means a re-read. */
+  watched = /* @__PURE__ */ new Set();
+  subscriptions = /* @__PURE__ */ new Map();
+  retainedKeys = /* @__PURE__ */ new Set();
+  releaseRetain = null;
+  stopLayers = null;
+  unregisterRead = null;
+  /** The functions may close over fresh state; the type and the tag are fixed for the life of the window. */
+  update(e) {
+    if (e.type.type !== this.typeName || e.tag !== this.tag)
+      throw new Error("PagedWindowStore: the record type and the tag cannot change after the window is created; mount a new list.");
+    this.options = e;
+  }
+  /** Start hearing layers, and let a staleness event on a held record re-read the window. */
+  attach(e, s) {
+    this.stopLayers ??= v(this.typeName, this.onChange), this.unregisterRead ??= K({ roots: () => this.options.reReadOnStale === !1 ? [] : e(), request: s });
+  }
+  detach() {
+    this.stopLayers?.(), this.stopLayers = null, this.unregisterRead?.(), this.unregisterRead = null, this.reset(), this.reconcile(/* @__PURE__ */ new Set(), /* @__PURE__ */ new Set());
+  }
+  /** A query change or a stop: nothing placed, nothing remembered. */
+  reset() {
+    this.placed.clear(), this.watched = /* @__PURE__ */ new Set();
+  }
+  /* --- Writing ------------------------------------------------------------- */
+  /** Whether an answer stamped with `tenant` may still be written: the store's own rule, so an empty page is judged like any other. */
+  static tenantIsCurrent(e) {
+    const s = q();
+    return s === void 0 || e === s;
+  }
+  /** Write a page's rows; the keys come back in page order. */
+  write(e, s) {
+    const n = e.map((a) => this.options.toPayload(a)), { results: t } = N(n, { source: "fetch", tag: this.tag, tenant: s });
+    return n.map((a, o) => {
+      const i = x(a);
+      if (!i || i.type !== this.typeName)
+        throw new Error(
+          `PagedWindowStore: toPayload gave a payload that is not a ${this.typeName} record with an id (${t[o].reason ?? "no __type or id"}).`
+        );
+      return i.key;
+    });
+  }
+  /* --- Reading ------------------------------------------------------------- */
+  read(e) {
+    const s = L(e, this.tag);
+    if (s.status === "deleted") return d;
+    if (s.status !== "present") return h;
+    const n = this.rowCache.get(e);
+    if (n && n.state === s) return n.row;
+    const t = this.options.fromRecord(s.record);
+    return this.rowCache.set(e, { state: s, row: t }), t;
+  }
+  /** The store has nothing (never written, swept, or cleared) for a held key: not a deletion. */
+  isUnknown(e) {
+    return this.read(e) === h;
+  }
+  belongs(e) {
+    return this.options.membership?.belongs(e) ?? !0;
+  }
+  /** The record without its writes in flight is a row of this list already. */
+  baseBelongs(e) {
+    const s = P(e, this.tag);
+    return s.status === "present" && this.belongs(this.options.fromRecord(s.record));
+  }
+  /** The rows of one page that are drawn from its own position: present, not deleted, belonging here. */
+  rowsOf(e) {
+    const s = [];
+    for (const n of e) {
+      const t = this.read(n);
+      t !== h && t !== d && this.belongs(t) && s.push(t);
+    }
+    return s;
+  }
+  /** Every present row of a page, belonging or not: what a consumer's row test asks about. */
+  loadedRowsOf(e) {
+    const s = [];
+    for (const n of e) {
+      const t = this.read(n);
+      t !== h && t !== d && s.push(t);
+    }
+    return s;
+  }
+  /** Held keys that are deleted, or that no longer belong: they are out of their page, and the list is one shorter for each. */
+  countLeftOut(e) {
+    let s = 0;
+    for (const n of e) {
+      const t = this.read(n);
+      (t === d || t !== h && !this.belongs(t)) && (s += 1);
+    }
+    return s;
+  }
+  /** Arrived rows no page holds yet: the list is one longer for each, until a read sent after the change answers. */
+  countArrived(e) {
+    let s = 0;
+    for (const [n, t] of this.placed) t.arrived && !e.has(n) && (s += 1);
+    return s;
+  }
+  placedKeys() {
+    return [...this.placed.keys()];
+  }
+  /* --- Membership: placed rows ----------------------------------------------- */
+  /**
+   * A layer moved, or a held record changed: who joined the window, who left, and whether a record's last layer went.
+   * Returns true when the window must be re-read (a displaced placed row's, or a left-out row's, last layer went).
+   * `waitSeq` is the token counter now: a read sent from here on is a read sent after the removal.
+   */
+  followLayers(e, s) {
+    if (!this.options.membership) return !1;
+    const n = new Set(m(this.typeName));
+    let t = !1;
+    for (const o of this.watched) {
+      if (n.has(o)) continue;
+      const i = this.placed.get(o);
+      if (!i) {
+        t = !0;
+        continue;
+      }
+      if (!i.displaced) {
+        this.placed.delete(o);
+        continue;
+      }
+      if (t = !0, y(o) === i.baseVersion && !C(o)) {
+        this.placed.delete(o);
+        continue;
+      }
+      i.waitSeq = s;
+    }
+    this.refreshPlacement(e, n);
+    const a = /* @__PURE__ */ new Set();
+    for (const o of n) {
+      const i = this.placed.get(o);
+      if (i) {
+        i.baseVersion = y(o), a.add(o);
+        continue;
+      }
+      if (!e.has(o)) continue;
+      const f = this.read(o);
+      f !== h && f !== d && !this.belongs(f) && a.add(o);
+    }
+    return this.watched = a, t;
+  }
+  /** Joins and drops, from the layers now; called whenever the window is rebuilt, so a record that becomes readable later still joins. */
+  refreshPlacement(e, s = new Set(m(this.typeName))) {
+    if (this.options.membership) {
+      for (const n of s) {
+        const t = this.placed.get(n);
+        if (t) {
+          t.waitSeq = null;
+          continue;
+        }
+        const a = this.read(n);
+        if (a === h || a === d || !this.belongs(a)) continue;
+        const o = !e.has(n);
+        o && this.baseBelongs(n) || (this.placed.set(n, { arrived: o, displaced: o, waitSeq: null, drawn: null, baseVersion: y(n) }), this.watched.add(n));
+      }
+      for (const n of [...this.placed.keys()]) {
+        const t = this.read(n);
+        (t === h || t === d || !this.belongs(t)) && this.placed.delete(n);
+      }
+    }
+  }
+  /** A placed row leaves the set once every page has been answered by a read sent after its last layer went. `answeredSince(seq)` says so. */
+  settlePlacement(e) {
+    for (const [s, n] of this.placed)
+      n.waitSeq !== null && e(n.waitSeq) && this.placed.delete(s);
+  }
+  /**
+   * Draw the placed rows into the loaded run. `run` is the shown pages' rows in order; the result is the same rows with each placed row at the
+   * place `placeIn` gives, or `run` itself when nothing moved. A row whose last layer has gone is not asked: it is redrawn where it was (below the
+   * row that was above it, else at its index), or left at its page position / undrawn when it had no place.
+   */
+  place(e, s, n, t) {
+    const a = this.options.membership;
+    if (!a || this.placed.size === 0) return e;
+    const o = { startsList: s === 0, endsList: n >= t };
+    let i = e, f = !1;
+    for (const [b, u] of this.placed) {
+      const p = this.read(b);
+      if (p === h || p === d) continue;
+      const w = i.findIndex((l) => l.row === p), c = w === -1 ? i : [...i.slice(0, w), ...i.slice(w + 1)];
+      let r;
+      if (u.waitSeq === null) {
+        if (r = a.placeIn(p, c.map((l) => l.row), o), r !== null && (!Number.isInteger(r) || r < 0 || r > c.length))
+          throw new Error(`PagedWindowStore: membership.placeIn answered ${String(r)}; it must be null or an integer from 0 to ${c.length}.`);
+        r === w && (r = null), u.drawn = r === null ? null : { above: r === 0 ? null : this.getKey(c[r - 1].row), index: r };
+      } else if (u.drawn === null)
+        r = null;
+      else {
+        const { above: l, index: R } = u.drawn, g = l === null ? -1 : c.findIndex((k) => this.getKey(k.row) === l);
+        r = l === null ? 0 : g === -1 ? Math.min(R, c.length) : g + 1;
+      }
+      if (r === null) continue;
+      u.displaced = !0;
+      const S = r < c.length ? c[r].page : n;
+      i = [...c.slice(0, r), { row: p, page: S }, ...c.slice(r)], f = !0;
+    }
+    return f ? i : e;
+  }
+  /* --- Subscriptions and retention -------------------------------------------- */
+  /**
+   * Keep the store subscriptions on `subscribe` (the resident pages' keys and the placed ones) and the roots on
+   * `retain` (every key held, resident or retained) in step with what the window holds now.
+   */
+  reconcile(e, s) {
+    for (const [t, a] of this.subscriptions)
+      e.has(t) || (a(), this.subscriptions.delete(t));
+    for (const t of e)
+      this.subscriptions.has(t) || this.subscriptions.set(t, E(t, this.onChange));
+    if (!(s.size === this.retainedKeys.size && [...s].every((t) => this.retainedKeys.has(t)))) {
+      const t = s.size > 0 ? I([...s]) : null;
+      this.releaseRetain?.(), this.releaseRetain = t, this.retainedKeys = new Set(s);
+    }
+    for (const t of [...this.rowCache.keys()]) s.has(t) || this.rowCache.delete(t);
+  }
+}
+export {
+  A as RecordsBinding
+};
+//# sourceMappingURL=records-binding.js.map

package/dist/lib/paged-window/records-binding.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"records-binding.js","sources":["../../../src/lib/paged-window/records-binding.ts"],"sourcesContent":["import { registerActiveRead } from \"../reads/refetch\";\nimport {\n  getRecordStoreTenant,\n  hasKeptLayer,\n  layeredKeys,\n  readBaseState,\n  readBaseVersion,\n  readState,\n  retainKeys,\n  subscribeToKey,\n  subscribeToLayers,\n  writeAll,\n} from \"../records/store\";\nimport { payloadIdentity } from \"../records/wire\";\nimport type { RecordPayload, RecordTypeToken } from \"../records/types\";\n\n/* ============================================================================\n   THE PAGED WINDOW'S RECORD MODE (DXUI-77, PLAN-32 R-1).\n\n   A component never keeps its own copy of database data. In this mode a window holds the KEYS (`Type:id`) of\n   the rows each page loaded, and draws them from the record store; the store is the one copy, so an edit to a\n   record shows in every window that holds it with no page read.\n\n   What lives here, so `store.ts` keeps its own subject (pages, the settle, freeze):\n   - writing a page's rows into the store and getting their keys back;\n   - reading a held key as a row (`fromRecord`, cached per stored state so an unchanged record is the same row);\n   - keeping the store subscriptions and the retained roots in step with the keys the window holds;\n   - MEMBERSHIP: which rows belong in this window and where, so a record moved by an optimistic layer leaves one\n     window and appears in another with no overlay of the consumer's own (see PLACED ROWS).\n\n   PLACED ROWS. A layer changes a record's fields, not a window's keys, so a window needs a rule for membership\n   and a way to find a record it does not hold. `membership.belongs` is the rule (the library cannot evaluate a\n   server-side filter) and `layeredKeys(type)` is the way. A layered record that belongs and that no page holds,\n   and whose BASE (the record without its writes in flight) did not belong, is an ARRIVED row; a held one that\n   carries a layer and belongs is a candidate MOVED row. A layered record already in the list whose page the window\n   does not hold changes nothing: it is no arrival. Both are PLACED when `membership.placeIn(row, run, edges)`\n   answers an index of the loaded run (without the row), not a page position. The answer is the consumer's: a\n   null for a held row, or its own index, leaves it at its page position and costs no read when its layer goes; a\n   null for an arrived row draws it nowhere (it still counts). A placed row stays where it was drawn after its\n   last layer goes (the commit): the window does not ask `placeIn` again, because the place may have lived only in\n   the layer, until every page has been answered by a read SENT after the removal (a read sent before it reflects\n   the server before the write and would make the row flicker out) or another layer lands on it. A refused write\n   is told from a commit by the record's base: a commit writes it, a refusal only removes the layer, so a\n   refusal drops the entry at once.\n   ========================================================================= */\n\nexport interface PagedWindowRecordsOptions<T> {\n  /** The record type the rows are stored as. */\n  type: RecordTypeToken<T>;\n  /** The field-set tag the page fetch satisfies (the `needs` of a read). */\n  tag: string;\n  /** A loaded row as the store's payload shape: the app's `toRecord`, which stamps `__type` and `__timestamp`. */\n  toPayload: (row: T) => RecordPayload;\n  /** A hydrated record (the payload shape, nested records resolved) as the row type. Called once per stored state of a record. */\n  fromRecord: (hydrated: unknown) => T;\n  /**\n   * Which rows belong in this window and where. Without it a layer never moves a row between windows.\n   * `placeIn(row, run, edges)` answers where the row is drawn: an index from 0 to `run.length` in `run` (the loaded run's rows in drawn order, without\n   * the row, rows placed earlier in the same build included), or null for no place in it. Anything else throws. `edges` says whether the run starts\n   * and ends the list, so a consumer that places by sort order can still answer null past an unloaded edge. A held row answered null or its own\n   * index stays at its page position; an arrived row answered null is not drawn and still counts.\n   */\n  membership?: {\n    belongs: (row: T) => boolean;\n    placeIn: (row: T, run: readonly T[], edges: PlacementEdges) => number | null;\n  };\n  /**\n   * Whether a staleness mark on a held record re-reads the window. Default true. A window whose consumer answers an event itself sets false;\n   * `reissueMountedReads` (events were missed) still reaches it.\n   */\n  reReadOnStale?: boolean;\n}\n\n/** Whether the loaded run reaches the list's first and last row. */\nexport interface PlacementEdges {\n  startsList: boolean;\n  endsList: boolean;\n}\n\nconst UNKNOWN = Symbol(\"unknown\");\nconst DELETED = Symbol(\"deleted\");\n\ninterface PlacedEntry {\n  /** Not held by any page when it joined. Decides whether it adds one to the window's total. */\n  arrived: boolean;\n  /**\n   * Drawn somewhere other than its page position at the last build (an arrived row always is; a moved one once `placeIn` has given it another place; it never falls back).\n   * Only a displaced row needs the commit race guarded, and the window re-read that follows it.\n   */\n  displaced: boolean;\n  /** The token counter when the last layer on the record went; null while a layer is on it. Every page must answer a read SENT at or after it. */\n  waitSeq: number | null;\n  /** While a layer is on it: where it was drawn (the key of the row above it, null at the top, and its index), or null when `placeIn` gave it no place. The commit hold redraws it there. */\n  drawn: { above: string | number | null; index: number } | null;\n  /** The record's base version at the last look: a last layer going with it unchanged is a refused write, not a commit. */\n  baseVersion: number;\n}\n\n/** One drawn row of the loaded run, and the page whose items it is drawn in. */\nexport interface RunRow<T> {\n  row: T;\n  page: number;\n}\n\nexport class RecordsBinding<T> {\n  private readonly typeName: string;\n  private readonly tag: string;\n  private options: PagedWindowRecordsOptions<T>;\n  private readonly onChange: () => void;\n  /** key -> the row built from the stored state last seen; the same state gives the same row object. */\n  private readonly rowCache = new Map<string, { state: unknown; row: T }>();\n  private readonly placed = new Map<string, PlacedEntry>();\n  /** Keys carrying a layer that mattered at the last look (placed, or held and left out): the ones whose last layer going means a re-read. */\n  private watched = new Set<string>();\n  private readonly subscriptions = new Map<string, () => void>();\n  private retainedKeys = new Set<string>();\n  private releaseRetain: (() => void) | null = null;\n  private stopLayers: (() => void) | null = null;\n  private unregisterRead: (() => void) | null = null;\n\n  constructor(\n    options: PagedWindowRecordsOptions<T>,\n    onChange: () => void,\n    private readonly getKey: (row: T) => string | number,\n  ) {\n    if (typeof options.toPayload !== \"function\" || typeof options.fromRecord !== \"function\") {\n      throw new Error(\"PagedWindowStore: records needs toPayload and fromRecord.\");\n    }\n    if (typeof options.tag !== \"string\" || options.tag === \"\") {\n      throw new Error(\"PagedWindowStore: records needs a tag, the field set a page fetch satisfies.\");\n    }\n    this.typeName = options.type.type;\n    this.tag = options.tag;\n    this.options = options;\n    this.onChange = onChange;\n  }\n\n  /** The functions may close over fresh state; the type and the tag are fixed for the life of the window. */\n  update(options: PagedWindowRecordsOptions<T>): void {\n    if (options.type.type !== this.typeName || options.tag !== this.tag) {\n      throw new Error(\"PagedWindowStore: the record type and the tag cannot change after the window is created; mount a new list.\");\n    }\n    this.options = options;\n  }\n\n  /** Start hearing layers, and let a staleness event on a held record re-read the window. */\n  attach(roots: () => readonly string[], request: () => void): void {\n    this.stopLayers ??= subscribeToLayers(this.typeName, this.onChange);\n    this.unregisterRead ??= registerActiveRead({ roots: () => (this.options.reReadOnStale === false ? [] : roots()), request });\n  }\n\n  detach(): void {\n    this.stopLayers?.();\n    this.stopLayers = null;\n    this.unregisterRead?.();\n    this.unregisterRead = null;\n    this.reset();\n    this.reconcile(new Set(), new Set());\n  }\n\n  /** A query change or a stop: nothing placed, nothing remembered. */\n  reset(): void {\n    this.placed.clear();\n    this.watched = new Set();\n  }\n\n  /* --- Writing ------------------------------------------------------------- */\n\n  /** Whether an answer stamped with `tenant` may still be written: the store's own rule, so an empty page is judged like any other. */\n  static tenantIsCurrent(tenant: string | number | undefined): boolean {\n    const current = getRecordStoreTenant();\n    return current === undefined || tenant === current;\n  }\n\n  /** Write a page's rows; the keys come back in page order. */\n  write(rows: readonly T[], tenant: string | number | undefined): string[] {\n    const payloads = rows.map((row) => this.options.toPayload(row));\n    const { results } = writeAll(payloads, { source: \"fetch\", tag: this.tag, tenant });\n    return payloads.map((payload, index) => {\n      const identity = payloadIdentity(payload);\n      if (!identity || identity.type !== this.typeName) {\n        throw new Error(\n          `PagedWindowStore: toPayload gave a payload that is not a ${this.typeName} record with an id (${results[index].reason ?? \"no __type or id\"}).`,\n        );\n      }\n      return identity.key;\n    });\n  }\n\n  /* --- Reading ------------------------------------------------------------- */\n\n  private read(key: string): T | typeof UNKNOWN | typeof DELETED {\n    const state = readState(key, this.tag);\n    if (state.status === \"deleted\") return DELETED;\n    if (state.status !== \"present\") return UNKNOWN;\n    const cached = this.rowCache.get(key);\n    if (cached && cached.state === state) return cached.row;\n    const row = this.options.fromRecord(state.record);\n    this.rowCache.set(key, { state, row });\n    return row;\n  }\n\n  /** The store has nothing (never written, swept, or cleared) for a held key: not a deletion. */\n  isUnknown(key: string): boolean {\n    return this.read(key) === UNKNOWN;\n  }\n\n  private belongs(row: T): boolean {\n    return this.options.membership?.belongs(row) ?? true;\n  }\n\n  /** The record without its writes in flight is a row of this list already. */\n  private baseBelongs(key: string): boolean {\n    const base = readBaseState(key, this.tag);\n    return base.status === \"present\" && this.belongs(this.options.fromRecord(base.record));\n  }\n\n  /** The rows of one page that are drawn from its own position: present, not deleted, belonging here. */\n  rowsOf(keys: readonly string[]): T[] {\n    const rows: T[] = [];\n    for (const key of keys) {\n      const row = this.read(key);\n      if (row !== UNKNOWN && row !== DELETED && this.belongs(row)) rows.push(row);\n    }\n    return rows;\n  }\n\n  /** Every present row of a page, belonging or not: what a consumer's row test asks about. */\n  loadedRowsOf(keys: readonly string[]): T[] {\n    const rows: T[] = [];\n    for (const key of keys) {\n      const row = this.read(key);\n      if (row !== UNKNOWN && row !== DELETED) rows.push(row);\n    }\n    return rows;\n  }\n\n  /** Held keys that are deleted, or that no longer belong: they are out of their page, and the list is one shorter for each. */\n  countLeftOut(held: ReadonlySet<string>): number {\n    let left = 0;\n    for (const key of held) {\n      const row = this.read(key);\n      if (row === DELETED || (row !== UNKNOWN && !this.belongs(row))) left += 1;\n    }\n    return left;\n  }\n\n  /** Arrived rows no page holds yet: the list is one longer for each, until a read sent after the change answers. */\n  countArrived(held: ReadonlySet<string>): number {\n    let arrived = 0;\n    for (const [key, entry] of this.placed) if (entry.arrived && !held.has(key)) arrived += 1;\n    return arrived;\n  }\n\n  placedKeys(): string[] {\n    return [...this.placed.keys()];\n  }\n\n  /* --- Membership: placed rows ----------------------------------------------- */\n\n  /**\n   * A layer moved, or a held record changed: who joined the window, who left, and whether a record's last layer went.\n   * Returns true when the window must be re-read (a displaced placed row's, or a left-out row's, last layer went).\n   * `waitSeq` is the token counter now: a read sent from here on is a read sent after the removal.\n   */\n  followLayers(held: ReadonlySet<string>, waitSeq: number): boolean {\n    if (!this.options.membership) return false;\n    const layered = new Set(layeredKeys(this.typeName));\n    let removed = false;\n    for (const key of this.watched) {\n      if (layered.has(key)) continue;\n      const entry = this.placed.get(key);\n      if (!entry) {\n        removed = true;\n        continue;\n      }\n      /* A moved row that never left its page position has no commit to guard: nothing was drawn anywhere else. */\n      if (!entry.displaced) {\n        this.placed.delete(key);\n        continue;\n      }\n      removed = true;\n      /* A refused write only removed its layer; a commit also wrote the base. Nothing to hold: the row goes back to its page position. */\n      if (readBaseVersion(key) === entry.baseVersion && !hasKeptLayer(key)) {\n        this.placed.delete(key);\n        continue;\n      }\n      entry.waitSeq = waitSeq;\n    }\n    this.refreshPlacement(held, layered);\n    const watched = new Set<string>();\n    for (const key of layered) {\n      const entry = this.placed.get(key);\n      if (entry) {\n        entry.baseVersion = readBaseVersion(key);\n        watched.add(key);\n        continue;\n      }\n      if (!held.has(key)) continue;\n      const row = this.read(key);\n      if (row !== UNKNOWN && row !== DELETED && !this.belongs(row)) watched.add(key);\n    }\n    this.watched = watched;\n    return removed;\n  }\n\n  /** Joins and drops, from the layers now; called whenever the window is rebuilt, so a record that becomes readable later still joins. */\n  refreshPlacement(held: ReadonlySet<string>, layered: ReadonlySet<string> = new Set(layeredKeys(this.typeName))): void {\n    if (!this.options.membership) return;\n    for (const key of layered) {\n      const entry = this.placed.get(key);\n      if (entry) {\n        entry.waitSeq = null;\n        continue;\n      }\n      const row = this.read(key);\n      if (row === UNKNOWN || row === DELETED || !this.belongs(row)) continue;\n      const arrived = !held.has(key);\n      /* A record arrives only when its base did not belong: a layer on a card already in this list, on a page no window holds, adds nothing. */\n      if (arrived && this.baseBelongs(key)) continue;\n      this.placed.set(key, { arrived, displaced: arrived, waitSeq: null, drawn: null, baseVersion: readBaseVersion(key) });\n      /* A row that joins on a rebuild has seen no layer event: watch it, or its commit is never noticed and a count window counts it for good. */\n      this.watched.add(key);\n    }\n    for (const key of [...this.placed.keys()]) {\n      const row = this.read(key);\n      /* A rollback or a refused write: the record no longer belongs, so nothing keeps it here. */\n      if (row === UNKNOWN || row === DELETED || !this.belongs(row)) this.placed.delete(key);\n    }\n  }\n\n  /** A placed row leaves the set once every page has been answered by a read sent after its last layer went. `answeredSince(seq)` says so. */\n  settlePlacement(answeredSince: (seq: number) => boolean): void {\n    for (const [key, entry] of this.placed) {\n      if (entry.waitSeq !== null && answeredSince(entry.waitSeq)) this.placed.delete(key);\n    }\n  }\n\n  /**\n   * Draw the placed rows into the loaded run. `run` is the shown pages' rows in order; the result is the same rows with each placed row at the\n   * place `placeIn` gives, or `run` itself when nothing moved. A row whose last layer has gone is not asked: it is redrawn where it was (below the\n   * row that was above it, else at its index), or left at its page position / undrawn when it had no place.\n   */\n  place(run: RunRow<T>[], firstPage: number, lastPage: number, lastPageOfList: number): RunRow<T>[] {\n    const membership = this.options.membership;\n    if (!membership || this.placed.size === 0) return run;\n    const edges: PlacementEdges = { startsList: firstPage === 0, endsList: lastPage >= lastPageOfList };\n    let flat = run;\n    let changed = false;\n    for (const [key, entry] of this.placed) {\n      const row = this.read(key);\n      if (row === UNKNOWN || row === DELETED) continue;\n      const at = flat.findIndex((each) => each.row === row);\n      const without = at === -1 ? flat : [...flat.slice(0, at), ...flat.slice(at + 1)];\n      let index: number | null;\n      if (entry.waitSeq === null) {\n        index = membership.placeIn(row, without.map((each) => each.row), edges);\n        if (index !== null && (!Number.isInteger(index) || index < 0 || index > without.length)) {\n          throw new Error(`PagedWindowStore: membership.placeIn answered ${String(index)}; it must be null or an integer from 0 to ${without.length}.`);\n        }\n        if (index === at) index = null;\n        entry.drawn = index === null ? null : { above: index === 0 ? null : this.getKey(without[index - 1].row), index };\n      } else if (entry.drawn === null) {\n        index = null;\n      } else {\n        const { above, index: recorded } = entry.drawn;\n        const aboveAt = above === null ? -1 : without.findIndex((each) => this.getKey(each.row) === above);\n        index = above === null ? 0 : aboveAt === -1 ? Math.min(recorded, without.length) : aboveAt + 1;\n      }\n      /* A held row stays at its page position (`displaced` only rises); an arrived one is not drawn. */\n      if (index === null) continue;\n      entry.displaced = true;\n      const page = index < without.length ? without[index].page : lastPage;\n      flat = [...without.slice(0, index), { row, page }, ...without.slice(index)];\n      changed = true;\n    }\n    return changed ? flat : run;\n  }\n\n  /* --- Subscriptions and retention -------------------------------------------- */\n\n  /**\n   * Keep the store subscriptions on `subscribe` (the resident pages' keys and the placed ones) and the roots on\n   * `retain` (every key held, resident or retained) in step with what the window holds now.\n   */\n  reconcile(subscribe: ReadonlySet<string>, retain: ReadonlySet<string>): void {\n    for (const [key, stop] of this.subscriptions) {\n      if (subscribe.has(key)) continue;\n      stop();\n      this.subscriptions.delete(key);\n    }\n    for (const key of subscribe) {\n      if (!this.subscriptions.has(key)) this.subscriptions.set(key, subscribeToKey(key, this.onChange));\n    }\n    const sameRoots = retain.size === this.retainedKeys.size && [...retain].every((key) => this.retainedKeys.has(key));\n    if (!sameRoots) {\n      const next = retain.size > 0 ? retainKeys([...retain]) : null;\n      this.releaseRetain?.();\n      this.releaseRetain = next;\n      this.retainedKeys = new Set(retain);\n    }\n    for (const key of [...this.rowCache.keys()]) if (!retain.has(key)) this.rowCache.delete(key);\n  }\n}\n"],"names":["UNKNOWN","DELETED","RecordsBinding","options","onChange","getKey","roots","request","subscribeToLayers","registerActiveRead","tenant","current","getRecordStoreTenant","rows","payloads","row","results","writeAll","payload","index","identity","payloadIdentity","key","state","readState","cached","base","readBaseState","keys","held","left","arrived","entry","waitSeq","layered","layeredKeys","removed","readBaseVersion","hasKeptLayer","watched","answeredSince","run","firstPage","lastPage","lastPageOfList","membership","edges","flat","changed","at","each","without","above","recorded","aboveAt","page","subscribe","retain","stop","subscribeToKey","next","retainKeys"],"mappings":"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"}