@ultimat3/realtime 30.8.0 → 31.0.0

package/src/index.ts

@@ -34,7 +34,6 @@ export type {
   ChannelRemove,
   ChannelSince,
   ChannelSubscribeTarget,
-  ChannelWireFrame,
   ReplayGapFrame,
 } from './channel-wire';
 // ---- the hooks: every read and write a component makes -----------------------------------------
@@ -42,7 +41,6 @@ export type { ChannelHandlers, ChannelRef, ChannelState } from './client-channel
 // ---- the shapes a hook hands back ----------------------------------------------------------------
 export type {
   LiveHandle,
-  LiveQueryRef,
   SignalFactory,
   Unsubscribe,
 } from './client-contract';
@@ -50,9 +48,7 @@ export type {
 export {
   advance,
   CURSOR_ID_LIMIT,
-  defaultReconnectBudget,
   type LiveCursor,
-  makeCursor,
   type ReconnectBudget,
   type ResumeDecision,
   type ResumeDeps,
@@ -64,31 +60,16 @@ export {
 } from './cursor';
 // ---- errors: one vocabulary for both halves, because every code reaches the wire ---------------
 export {
-  CursorStaleError,
-  FrameRateLimitError,
-  LiveQueryUnknownError,
-  LiveRowUnidentifiedError,
   OfflineQueueAbandonedError,
-  ProtocolVersionError,
-  REALTIME_ERROR_CODES,
+  OfflineQueueFullError,
   REALTIME_ERROR_TITLES,
+  REALTIME_PAGE_ERROR_TITLES,
   RealtimeError,
   type RealtimeErrorCode,
-  RealtimeUninstalledError,
-  RebaseConflictError,
-  RecordRejectedError,
-  ReplicaIdentityError,
-  ReplicationFailedError,
-  ReplicationProtocolError,
-  ReplicationTlsError,
   ReplicatorSlotHeldError,
-  ServerRenderLiveError,
   SubscriptionLimitError,
-  SyncUnconfiguredError,
   TopicForbiddenError,
-  TransportProtocolError,
   TransportUnavailableError,
-  WindowReadTimeoutError,
 } from './errors';
 // ---- the page: one record store, one socket, installed by the island bootstrap ------------------
 export {
@@ -102,11 +83,11 @@ export {
   isRow,
   type JsonObject,
   type JsonValue,
-  type Row,
+  type LiveRow,
   type RowOp,
   type RowPatch,
 } from './json';
-export { type LiveState, type Registration, RowWindows, unnamedType } from './live-rows';
+export { type LiveState, type Registration, unnamedType } from './live-rows';
 // ---- offline: the durable store, the persisted records, the one outbox (plan 101 slice 12) ------
 export {
   type LocalStore,
@@ -124,6 +105,7 @@ export {
   type MutationStatus,
   memoryQueueStore,
   OfflineQueue,
+  type OfflineQueueOptions,
   type QueuedMutation,
   type QueueState,
   type QueueStore,
@@ -139,7 +121,6 @@ export { resetPageRealtime } from './page-reset';
 export { hasPageSocket, type SyncTarget } from './page-store';
 export { pollEvery, type QueryPoll } from './query-poll';
 export { installRealtime, type RealtimeInstall } from './reactivity';
-export { persistedTypes, type RecordPersister, recordPersister } from './record-persister';
 export {
   DEFAULT_MAX_ROWS_PER_TYPE,
   type RecordKey,
@@ -172,15 +153,12 @@ export {
 } from './sync-protocol';
 // ---- the client's own reconnect: the backoff it computes and the timer it arms -----------------
 export {
-  type BackoffPolicy,
   BROWSER_RECONNECT_MAX_MS,
   browserBackoff,
   defaultBackoff,
   type JitterMode,
-  type ReconnectReason,
   type Rng,
   type Scheduler,
-  timeoutScheduler,
 } from './thundering-herd';
 export {
   type ChannelAccessor,

package/src/json.ts

@@ -20,8 +20,12 @@ export type JsonValue =
 
 export type JsonObject = { [key: string]: JsonValue };
 
-/** Every row that crosses the wire or lands in the local store is identified by `id`. */
-export type Row = JsonObject & { id: string };
+/**
+ * Every row that crosses the wire or lands in the local store is identified by `id`. `LiveRow`, not
+ * `Row`: core's `Row` (`conflict-policy.ts`) is any keyed record and entity's `Row` an expression
+ * row; three types under one name was an import that type-checked against the wrong one.
+ */
+export type LiveRow = JsonObject & { id: string };
 
 export type RowOp = 'insert' | 'update' | 'delete';
 
@@ -58,7 +62,7 @@ export function isParsedJsonObject(value: unknown): value is JsonObject {
   return isJsonObject(value);
 }
 
-export function isRow(value: unknown): value is Row {
+export function isRow(value: unknown): value is LiveRow {
   return isParsedJsonObject(value) && typeof value['id'] === 'string';
 }
 

package/src/live-contract.ts

@@ -12,11 +12,11 @@
 import type { Actor } from '@ultimat3/core';
 import type { LiveReadPhase } from '@ultimat3/query';
 import type { LiveCursor } from './cursor';
-import type { JsonValue, Row } from './json';
+import type { JsonValue, LiveRow } from './json';
 import type { IncrementalMatcher } from './matcher-bridge';
 import type { SyncSocket } from './socket';
 
-export interface SnapshotResult<R extends Row = Row> {
+export interface SnapshotResult<R extends LiveRow = LiveRow> {
   readonly rows: readonly R[];
   readonly lsn: string;
 }
@@ -34,7 +34,7 @@ export interface SnapshotArgs {
   readonly phase?: LiveReadPhase | undefined;
 }
 
-export interface LiveQueryDefinition<R extends Row = Row> {
+export interface LiveQueryDefinition<R extends LiveRow = LiveRow> {
   readonly name: string;
   /** Dependency set for the pre-filter. `x verify` rejects a `live: true` query without one. */
   readonly entities: readonly string[];
@@ -70,7 +70,7 @@ export interface LiveQueryDefinition<R extends Row = Row> {
    * The record key each row travels under, resolved with `rowEntity`: the entity's own projection.
    * `null` (or absent) is a plain table, whose rows are keyed by `id`.
    */
-  rowKey?(input: JsonValue): ((row: Row) => string) | null;
+  rowKey?(input: JsonValue): ((row: LiveRow) => string) | null;
   /**
    * Resolve whatever this input needs before an entry is built. `matcher` is synchronous by
    * design — a change event must not await anything — so a definition that has to compile a

package/src/live-definition.ts

@@ -24,7 +24,7 @@ import {
   traceLiveRead,
 } from '@ultimat3/query';
 import { LiveRowUnidentifiedError } from './errors';
-import { isRow, type JsonValue, type Row } from './json';
+import { isRow, type JsonValue, type LiveRow } from './json';
 import type { LiveQueryDefinition, SnapshotResult } from './live-contract';
 import { liveRecords } from './live-record-type';
 import { type IncrementalMatcher, matcherFor, type Projection } from './matcher-bridge';
@@ -64,8 +64,8 @@ interface SharedWindow {
   /** The compiled shape's root entity — the client's identity scope for every row of this read. */
   readonly rowEntity: string;
   /** Its projection's record key; `null` for a plain table keyed by `id`. */
-  readonly rowKey: ((row: Row) => string) | null;
-  read(): Promise<readonly Row[]>;
+  readonly rowKey: ((row: LiveRow) => string) | null;
+  read(): Promise<readonly LiveRow[]>;
 }
 
 /**
@@ -74,7 +74,10 @@ interface SharedWindow {
  * read it from. Learned once and kept, because the case the window's own rows cannot answer is an
  * EMPTY window: the first row to arrive would otherwise be sent as the whole table row.
  */
-const learnProjection = (): { read: () => Projection; teach: (rows: readonly Row[]) => void } => {
+const learnProjection = (): {
+  read: () => Projection;
+  teach: (rows: readonly LiveRow[]) => void;
+} => {
   let projection: Projection;
   return {
     read: () => projection,
@@ -227,8 +230,8 @@ function evictOldest(windows: Map<string, SharedWindow>, max: number): void {
  * same row (`pg-replication.ts`'s `toRow`), so a snapshot row and its later patch name one identity.
  * Anything else is refused here rather than delivered as a row nobody can patch.
  */
-function rowsOf(query: string, rows: readonly object[]): readonly Row[] {
-  const out: Row[] = [];
+function rowsOf(query: string, rows: readonly object[]): readonly LiveRow[] {
+  const out: LiveRow[] = [];
   for (const row of rows) {
     const id: unknown = (row as { id?: unknown }).id;
     const candidate =

package/src/live-deliver.ts

@@ -1,10 +1,37 @@
 // One change, fanned out over every live window on the node. Split from `live-query.ts` at its
 // size ceiling: the registry owns who holds which window, this owns the ordering of one delivery.
 
+import { finiteOption } from '@ultimat3/core';
 import type { ChangeEvent } from './changefeed';
 import { type FanoutDeps, fanoutChange } from './live-fanout';
+import { DEFAULT_MAX_LANE_DEPTH } from './live-query-options';
 import type { QueryEntry } from './query-window';
 
+/**
+ * The two counters every delivery on a node feeds, and the lane bound it sheds at. Owned by the
+ * registry, one per node; read back as `staleChanges` / `changesShed`.
+ */
+export class DeliveryCounts {
+  readonly maxLaneDepth: number;
+  /** `live.changes_stale`: a change at or below a window's own lsn, refused rather than folded. */
+  staleChanges = 0;
+  /** `live.changes_shed`: a change a full lane did not queue; its window re-reads instead. */
+  changesShed = 0;
+
+  constructor(maxLaneDepth: number | undefined) {
+    // At least two: depth counts the RUNNING task, and a shed is repaired by a task queued behind
+    // it finding the mark. A lane of one shed with nobody behind to read it.
+    this.maxLaneDepth = Math.max(
+      2,
+      finiteOption(
+        'the live-query registry',
+        'maxLaneDepth',
+        maxLaneDepth ?? DEFAULT_MAX_LANE_DEPTH,
+      ),
+    );
+  }
+}
+
 /**
  * Fan one change out. Matched once per query id, authorized once per subscriber. Returns the
  * number of frames sent — the metric the reconnect benchmark watches.
@@ -24,12 +51,23 @@ export async function deliverChange(
   entries: Iterable<QueryEntry>,
   fanout: FanoutDeps,
   change: ChangeEvent,
-  onStale: (count: number) => void,
+  counts: DeliveryCounts,
 ): Promise<number> {
   const lanes = [...entries].map(async (entry) => {
+    if (entry.lock.depth >= counts.maxLaneDepth) {
+      // Shed, never queued: the lane is a closure per change, and one slow policy pass would hold
+      // them all. Staled, not desynced, because the lane is still full of changes that will run —
+      // the first one in finds the mark and re-reads (`live-fanout.ts`), and that read began after
+      // this change was handed to the registry, so it holds it. Over-reading is the cost; losing
+      // the change is not one. Outside the lane, as `invalidate()` sets it: a read issued after
+      // this answers it, and one issued before cleared the mark already and cannot clear this.
+      entry.stale = true;
+      counts.changesShed += 1;
+      return 0;
+    }
     try {
       const result = await entry.lock.run(() => fanoutChange(fanout, entry, change));
-      onStale(result.stale);
+      counts.staleChanges += result.stale;
       return result.sent;
     } catch (error) {
       // The window advanced under a fanout that did not finish, so every subscriber of this one

package/src/live-entries.ts

@@ -0,0 +1,73 @@
+// The registry's windows, indexed by the relations each one reads. One owner for both, so an entry
+// added or forgotten can never be in the table and missing from the index (or the reverse): a
+// change then reaches only the windows that read its table, never every window on the node.
+
+import type { QueryEntry } from './query-window';
+
+export class LiveEntries {
+  readonly #byQid = new Map<string, QueryEntry>();
+  /** `shape.entities` → the entries reading it. A shape is fixed at birth, so this never moves. */
+  readonly #byTable = new Map<string, Set<QueryEntry>>();
+
+  get size(): number {
+    return this.#byQid.size;
+  }
+
+  get(qid: string): QueryEntry | undefined {
+    return this.#byQid.get(qid);
+  }
+
+  values(): IterableIterator<QueryEntry> {
+    return this.#byQid.values();
+  }
+
+  add(entry: QueryEntry): void {
+    this.delete(entry.qid);
+    this.#byQid.set(entry.qid, entry);
+    for (const table of entry.shape.entities) {
+      let readers = this.#byTable.get(table);
+      if (readers === undefined) {
+        readers = new Set();
+        this.#byTable.set(table, readers);
+      }
+      readers.add(entry);
+    }
+  }
+
+  delete(qid: string): void {
+    const entry = this.#byQid.get(qid);
+    if (entry === undefined) return;
+    this.#byQid.delete(qid);
+    for (const table of entry.shape.entities) {
+      const readers = this.#byTable.get(table);
+      if (readers === undefined) continue;
+      readers.delete(entry);
+      // An emptied bucket goes too: a client-chosen table name must not outlive its windows.
+      if (readers.size === 0) this.#byTable.delete(table);
+    }
+  }
+
+  /** The windows that read `table` — `invalidate(entity)`'s set, and a change's first. */
+  readersOf(table: string): ReadonlySet<QueryEntry> {
+    return this.#byTable.get(table) ?? EMPTY;
+  }
+
+  /**
+   * Every window one change is work for: its table's readers, plus every window that owes a
+   * read whatever it reads — a `stale` one is repaired by the next change to reach it, and one no
+   * read has landed in yet marks itself stale so its in-flight read is followed by a fresh one
+   * (`live-fanout.ts`). Those two are a boolean pair per entry, read without a lane; the expensive
+   * part — a lane entered, a closure queued, a fanout awaited — is paid by these entries only.
+   * Measured: 10k windows on other tables, 34.6 ms → 0.23 ms per change (29 → 4,430/s).
+   */
+  targets(table: string): QueryEntry[] {
+    const readers = this.readersOf(table);
+    const out = [...readers];
+    for (const entry of this.#byQid.values()) {
+      if ((entry.stale || entry.applied === 0) && !readers.has(entry)) out.push(entry);
+    }
+    return out;
+  }
+}
+
+const EMPTY: ReadonlySet<QueryEntry> = new Set();

package/src/live-fanout.ts

@@ -6,13 +6,19 @@
 import { type Clock, isWriteDigest } from '@ultimat3/core';
 import type { ChangeEvent } from './changefeed';
 import { advance, type LiveCursor, makeCursor, type ResumeSource } from './cursor';
-import type { Row, RowPatch } from './json';
+import type { LiveRow, RowPatch } from './json';
 import type { LiveSubscription } from './live-contract';
+import { encodePatchFrame, samePatches } from './live-patch-encode';
 import { applyToWindow, bridgeChange, type Projection, projectionOf } from './matcher-bridge';
 import { type QueryEntry, refillWindowInLane } from './query-window';
-import { type Subscriber, type SubscriberGate, windowIndex } from './subscriber-gate';
+import {
+  type Subscriber,
+  type SubscriberGate,
+  type WindowIndex,
+  windowIndex,
+} from './subscriber-gate';
 import { subscriptionKey } from './subscription-book';
-import { type Frame, PROTOCOL_VERSION } from './sync-protocol';
+import { encode, type Frame, PROTOCOL_VERSION } from './sync-protocol';
 import { FRAME_LIMITS } from './wire-version';
 
 export interface FanoutDeps {
@@ -101,8 +107,11 @@ export async function fanoutChange(
   else deps.source.floorAt?.(entry.qid, change.lsn, { exclusive: true });
 
   let sent = 0;
-  // Indexed once for every subscriber below, never searched per subscriber per patch.
-  const index = windowIndex(entry.rows);
+  // Indexed once for every subscriber below, never searched per subscriber per patch — and only
+  // once a subscriber reaches its gate: a change every subscriber is desynced for builds none.
+  let index: WindowIndex | null = null;
+  // The patch list as text, once per change for every subscriber the gate let see all of it.
+  let shared: string | null = null;
   for (const subscription of entry.subscribers.values()) {
     if (guessed) {
       // The window lost its tail: guessing is how a sync engine silently diverges. Checked BEFORE
@@ -126,6 +135,7 @@ export async function fanoutChange(
     }
     const who: Subscriber = { sid: subscription.sid, actor: subscription.socket.actor };
     let allowed: readonly RowPatch[];
+    index ??= windowIndex(entry.rows);
     try {
       allowed = await deps.gate.filterPatches(
         entry,
@@ -143,8 +153,14 @@ export async function fanoutChange(
       continue;
     }
     if (allowed.length === 0) continue;
-    const frame = patchFrame(subscription.sid, allowed, change.lsn, writes);
-    if (subscription.socket.send(frame)) {
+    let text: string;
+    if (samePatches(allowed, result.patches)) {
+      shared ??= JSON.stringify(result.patches);
+      text = encodePatchFrame(subscription.sid, shared, change.lsn, writes);
+    } else {
+      text = encode(patchFrame(subscription.sid, allowed, change.lsn, writes));
+    }
+    if (subscription.socket.sendEncoded(text)) {
       subscription.cursor = advance(subscription.cursor, allowed, change.lsn, change.at);
       sent += 1;
     } else {
@@ -244,7 +260,7 @@ async function resnapshot(
   named: readonly NamedWrite[],
 ): Promise<boolean> {
   const who: Subscriber = { sid: subscription.sid, actor: subscription.socket.actor };
-  let rows: readonly Row[];
+  let rows: readonly LiveRow[];
   try {
     rows = await deps.gate.filterRows(entry, who, entry.rows);
   } catch {
@@ -315,7 +331,7 @@ export interface NamedWrite {
 export function snapshotFrame(
   entry: QueryEntry,
   sid: string,
-  rows: readonly Row[],
+  rows: readonly LiveRow[],
   cursor: LiveCursor,
   named: readonly NamedWrite[] = [],
 ): Frame {

package/src/live-patch-encode.ts

@@ -0,0 +1,30 @@
+// A patch frame as text, built around a patch list encoded ONCE for every subscriber of a change.
+// The frame differs per subscriber by its `sid` alone when the gate let the whole list through, so
+// stringifying the list per subscriber was the fanout's cost growing with every viewer.
+
+import type { RowPatch } from './json';
+import { PROTOCOL_VERSION } from './sync-protocol';
+
+/**
+ * Byte-for-byte `encode(patchFrame(sid, patches, lsn, writes))` with `patches` already encoded:
+ * the same keys in the same order, and `JSON.stringify` is compositional with no indentation.
+ * Pinned against the unshared spelling by `live-fanout.test.ts`.
+ */
+export function encodePatchFrame(
+  sid: string,
+  patchesJson: string,
+  lsn: string,
+  writes: readonly string[],
+): string {
+  const head = `{"type":"patch","v":${JSON.stringify(PROTOCOL_VERSION)},"sid":${JSON.stringify(sid)}`;
+  const tail = writes.length === 0 ? '' : `,"writes":${JSON.stringify(writes)}`;
+  return `${head},"patches":${patchesJson},"lsn":${JSON.stringify(lsn)}${tail}}`;
+}
+
+/** The gate let every patch through untouched: the shared encoding is this subscriber's too. */
+export function samePatches(allowed: readonly RowPatch[], shared: readonly RowPatch[]): boolean {
+  if (allowed === shared) return true;
+  if (allowed.length !== shared.length) return false;
+  for (let at = 0; at < allowed.length; at += 1) if (allowed[at] !== shared[at]) return false;
+  return true;
+}

package/src/live-query-options.ts

@@ -34,8 +34,19 @@ export interface LiveQueryRegistryOptions extends SubscriberGateOptions {
   readonly readDeadlineMs?: number;
   /** Injected so that deadline is provable without waiting for one. Production uses `setTimeout`. */
   readonly schedule?: Scheduler;
+  /**
+   * Changes one window's lane may hold queued. Defaults to `DEFAULT_MAX_LANE_DEPTH`. Past it a
+   * change is SHED for that window: the window is marked stale, so the next change queued re-reads
+   * it and re-snapshots every subscriber — the documented gap recovery — and the shed is counted
+   * (`changesShed`). Without it one slow row policy queued a closure per change, unbounded.
+   * Floored at 2: the count includes the running task, and a shed needs one queued behind it.
+   */
+  readonly maxLaneDepth?: number;
 }
 
+/** Changes one window's lane holds before shedding to a re-read. */
+export const DEFAULT_MAX_LANE_DEPTH = 1_024;
+
 /**
  * Live `(query, input)` pairs one node holds. Reached, the next NEW pair is refused with
  * `X_SUBSCRIPTION_LIMIT`; subscribing to a pair that already exists keeps working, because the

package/src/live-query.ts

@@ -13,7 +13,8 @@ import { type LiveCursor, makeCursor } from './cursor';
 import { LiveQueryUnknownError, SubscriptionLimitError } from './errors';
 import type { JsonValue } from './json';
 import type { LiveQueryDefinition, LiveSubscription, SnapshotResult } from './live-contract';
-import { deliverChange } from './live-deliver';
+import { DeliveryCounts, deliverChange } from './live-deliver';
+import { LiveEntries } from './live-entries';
 import { type FanoutDeps, repairSubscriber, repairWindow, snapshotFrame } from './live-fanout';
 import { floorAfterRead } from './live-floor';
 import { DEFAULT_MAX_ENTRIES, type LiveQueryRegistryOptions } from './live-query-options';
@@ -27,11 +28,16 @@ import { type Subscriber, SubscriberGate } from './subscriber-gate';
 import { SubscriptionBook, subscriptionKey } from './subscription-book';
 import type { Frame } from './sync-protocol';
 
-export { DEFAULT_MAX_ENTRIES, type LiveQueryRegistryOptions } from './live-query-options';
+export {
+  DEFAULT_MAX_ENTRIES,
+  DEFAULT_MAX_LANE_DEPTH,
+  type LiveQueryRegistryOptions,
+} from './live-query-options';
 
 export class LiveQueryRegistry {
   readonly #definitions = new Map<string, LiveQueryDefinition>();
-  readonly #entries = new Map<string, QueryEntry>();
+  /** Indexed by the relations each window reads (`live-entries.ts`): a change is work for few. */
+  readonly #entries = new LiveEntries();
   /** Keyed by `(socket, sid)`, never by `sid` alone — `subscription-book.ts` owns why. */
   readonly #book: SubscriptionBook;
   readonly #options: LiveQueryRegistryOptions;
@@ -46,7 +52,7 @@ export class LiveQueryRegistry {
    * `!` sorts below every hex digit, so every real change is above it.
    */
   readonly #origin = `!${uuidV7()}`;
-  #staleChanges = 0;
+  readonly #counts: DeliveryCounts;
 
   constructor(options: LiveQueryRegistryOptions) {
     this.#options = options;
@@ -60,6 +66,7 @@ export class LiveQueryRegistry {
     // The book owns the caps because it is the only thing that can answer them in O(1).
     this.#book = new SubscriptionBook(options);
     this.#fanout = { gate: this.#gate, source: options.source, clock: this.#clock };
+    this.#counts = new DeliveryCounts(options.maxLaneDepth);
   }
 
   /** `live.rows_denied` for this node: rows a subscriber's policy refused since boot. */
@@ -74,7 +81,12 @@ export class LiveQueryRegistry {
 
   /** `live.changes_stale`: changes at or below a window's own lsn, refused rather than folded. */
   get staleChanges(): number {
-    return this.#staleChanges;
+    return this.#counts.staleChanges;
+  }
+
+  /** `live.changes_shed`: window deliveries a full lane refused, each repaired by a re-read. */
+  get changesShed(): number {
+    return this.#counts.changesShed;
   }
 
   /**
@@ -93,8 +105,8 @@ export class LiveQueryRegistry {
    */
   invalidate(entity?: string): number {
     let marked = 0;
-    for (const entry of this.#entries.values()) {
-      if (entity !== undefined && !entry.shape.entities.includes(entity)) continue;
+    const entries = entity === undefined ? this.#entries.values() : this.#entries.readersOf(entity);
+    for (const entry of entries) {
       entry.stale = true;
       for (const subscription of entry.subscribers.values()) {
         subscription.socket.markDesynced(subscription.sid);
@@ -333,9 +345,12 @@ export class LiveQueryRegistry {
   /** Fan one change out, every query id in its own lane — `live-deliver.ts` owns why. */
   async deliver(change: ChangeEvent): Promise<number> {
     if (change.lsn > this.#lastLsn) this.#lastLsn = change.lsn;
-    return await deliverChange(this.#entries.values(), this.#fanout, change, (stale) => {
-      this.#staleChanges += stale;
-    });
+    return await deliverChange(
+      this.#entries.targets(change.table),
+      this.#fanout,
+      change,
+      this.#counts,
+    );
   }
 
   /**
@@ -436,7 +451,7 @@ export class LiveQueryRegistry {
       schedule: this.#options.schedule,
       tenant,
     });
-    this.#entries.set(qid, created);
+    this.#entries.add(created);
     return created;
   }