edytor 3.0.0 → 4.0.0

package/README.md

@@ -17,7 +17,7 @@
 
 Edytor aims to be for Svelte what Slate.js is for React: a heavily customizable editor with an API to build any kind of collaborative rich text editor.
 
-> **3.0.** Edytor `3.0.0` is on npm as `edytor`: its API follows semantic versioning, and every change is listed in the changelog. It has no production track record yet: read the [limitations](https://edytor.dev/docs/reference/limitations) before you build on it. Issues and PRs are welcome: when you report a bug, include the document's JSON value.
+> **4.0.** Edytor `4.0.0` is on npm as `edytor`: its API follows semantic versioning, and every change is listed in the changelog. It has no production track record yet: read the [limitations](https://edytor.dev/docs/reference/limitations) before you build on it. Issues and PRs are welcome: when you report a bug, include the document's JSON value.
 
 ## Features
 
@@ -40,7 +40,7 @@ Edytor aims to be for Svelte what Slate.js is for React: a heavily customizable
 
 ## Install
 
-Edytor `3.0.0` is on npm under `latest`:
+Edytor `4.0.0` is on npm under `latest`:
 
 ```bash
 pnpm add edytor

package/dist/cloudflare/DocumentRoom.d.ts

@@ -121,9 +121,11 @@ export declare const DEFAULT_SAVE_AFTER = 2000;
  * Room quotas, each refused with `4413` (`quota: <name>`). The
  * document's size: what its records hold (uncompressed) and the updates the
  * engine holds waiting. An isolate has 128 MB, and the live document takes
- * 18 to 46 bytes of heap per stored byte (prose to one short line per
- * block, its index included; `bench/room-memory.mjs`): 2 MiB is
- * about 100 MB at worst. Raise it for documents of long text.
+ * 15 to 77 bytes of heap per stored byte in Node (prose to one short line
+ * per block, its index included; `bench/room-memory.mjs`; a Worker takes
+ * less): 2 MiB is about 150 to 160 MB at worst, a list of some 23,000 short
+ * blocks (1.25 MiB keeps that near 100 MB). Raise it for documents of long
+ * text, lower it for long lists of short blocks.
  */
 export declare const DEFAULT_MAX_DOCUMENT_BYTES: number;
 /** The share of the document quota past which the room logs its size, by default. */
@@ -364,7 +366,7 @@ export type RoomLogEntry = {
     user: string;
 } | ({
     edytor: 'purge';
-    horizon: number;
+    horizon: number | null;
     bytes: number;
 } & PurgeReport) | {
     edytor: 'quota';
@@ -801,12 +803,14 @@ export declare class AttachedDocument {
      * The purge task, also over RPC (`room.purge.timing`): record an epoch
      * (the state vector, now) when the document changed since the last one,
      * purge what was deleted before the horizon — the newest epoch at least
-     * `purgeAfterDays` old — when it is newer than the last purged, and
-     * re-arm for the next epoch to pass it. Returns what the purge wrote, or
-     * `null` when nothing was past the horizon.
+     * `purgeAfterDays` old — when it is newer than the last purged, with what
+     * the sessions whose history ended deleted (`hist.release.end`; with no
+     * epoch due, those alone, `horizon: null`), and re-arm for the next epoch
+     * to pass it. Returns what the purge wrote, or `null` when nothing was
+     * past the horizon and no session had ended.
      */
     purge(): (PurgeReport & {
-        horizon: number;
+        horizon: number | null;
     }) | null;
     /** The room's counters, also over RPC — see {@link RoomMetrics}. */
     metrics(): RoomMetrics;
@@ -968,7 +972,7 @@ export declare class DocumentRoom<Env = DocumentRoomEnv> extends DurableObject<E
     };
     /** Run the purge task now, also over RPC — see {@link AttachedDocument.purge}. */
     purge(): (PurgeReport & {
-        horizon: number;
+        horizon: number | null;
     }) | null;
     /** Every comment thread, also over RPC — see {@link AttachedDocument.listComments}. */
     listComments(): CommentSnapshot;

package/dist/cloudflare/DocumentRoom.js

@@ -130,9 +130,11 @@ export const DEFAULT_SAVE_AFTER = 2000;
  * Room quotas, each refused with `4413` (`quota: <name>`). The
  * document's size: what its records hold (uncompressed) and the updates the
  * engine holds waiting. An isolate has 128 MB, and the live document takes
- * 18 to 46 bytes of heap per stored byte (prose to one short line per
- * block, its index included; `bench/room-memory.mjs`): 2 MiB is
- * about 100 MB at worst. Raise it for documents of long text.
+ * 15 to 77 bytes of heap per stored byte in Node (prose to one short line
+ * per block, its index included; `bench/room-memory.mjs`; a Worker takes
+ * less): 2 MiB is about 150 to 160 MB at worst, a list of some 23,000 short
+ * blocks (1.25 MiB keeps that near 100 MB). Raise it for documents of long
+ * text, lower it for long lists of short blocks.
  */
 export const DEFAULT_MAX_DOCUMENT_BYTES = 2 * 1024 * 1024;
 /** The share of the document quota past which the room logs its size, by default. */
@@ -480,9 +482,11 @@ export class AttachedDocument {
      * The purge task, also over RPC (`room.purge.timing`): record an epoch
      * (the state vector, now) when the document changed since the last one,
      * purge what was deleted before the horizon — the newest epoch at least
-     * `purgeAfterDays` old — when it is newer than the last purged, and
-     * re-arm for the next epoch to pass it. Returns what the purge wrote, or
-     * `null` when nothing was past the horizon.
+     * `purgeAfterDays` old — when it is newer than the last purged, with what
+     * the sessions whose history ended deleted (`hist.release.end`; with no
+     * epoch due, those alone, `horizon: null`), and re-arm for the next epoch
+     * to pass it. Returns what the purge wrote, or `null` when nothing was
+     * past the horizon and no session had ended.
      */
     purge() {
         return this.room.purge.tick();

package/dist/cloudflare/room/context.d.ts

@@ -28,7 +28,7 @@ export declare const crdt: {
     Awareness: typeof import("../../index.js").Awareness;
     doc: {
         SCHEMA: {
-            readonly version: 6;
+            readonly version: 10;
             readonly name: "edytor-doc";
             readonly roots: {
                 readonly registry: "blocks";
@@ -39,7 +39,7 @@ export declare const crdt: {
                 readonly schema: "schema";
             };
         };
-        SCHEMA_VERSION: 6;
+        SCHEMA_VERSION: 10;
         SCHEMA_NAME: "edytor-doc";
         META_KEY: "meta";
         init: (doc: E.EngineDoc, opts?: {
@@ -103,29 +103,30 @@ export declare const crdt: {
                 blockNodeOf: (doc: E.EngineDoc, id: import("../../index.js").BlockId) => E.EngineNode | null;
                 liveNodeOf: (doc: E.EngineDoc, id: import("../../index.js").BlockId) => E.EngineNode | null;
                 isLive: (doc: E.EngineDoc, id: import("../../index.js").BlockId) => boolean;
-                candidatesOf: (node: E.EngineNode) => import("../../crdt/placement/model.js").PlacementCand[];
                 view: (doc: E.EngineDoc) => import("../../crdt/placement/model.js").ModelView;
-                resolvePlacements: (blocks: Map<import("../../index.js").BlockId, import("../../crdt/placement/model.js").BlockRec>, ownerOf?: (b: import("../../index.js").BlockId) => import("../../crdt/text/model.js").Owner) => Map<import("../../index.js").BlockId, import("../../crdt/placement/model.js").ResolvedPlacement>;
                 childrenIndex: (placements: Map<import("../../index.js").BlockId, import("../../crdt/placement/model.js").ResolvedPlacement>, own: import("../../crdt/placement/model.js").DisplayOwnership) => Map<import("../../index.js").BlockId | null, import("../../crdt/placement/model.js").ChildSlot[]>;
                 positionInView: (v: import("../../crdt/placement/model.js").ModelView, id: import("../../index.js").BlockId) => import("../../index.js").Destination | null;
                 buildInline: (atom: import("../../index.js").InlineSpec) => E.EngineNode;
                 isSelfOrDescendant: (placements: Map<import("../../index.js").BlockId, import("../../crdt/placement/model.js").ResolvedPlacement>, own: import("../../crdt/text/model.js").Ownership, id: import("../../index.js").BlockId, maybeAncestor: import("../../index.js").BlockId) => boolean;
-                ranksAt: (siblings: readonly {
-                    rank: string;
-                }[], index: number, count: number, clientId: number, rand?: () => number, run?: boolean) => string[];
-                writePlacement: (doc: E.EngineDoc, node: E.EngineNode, p: import("../../index.js").BlockId | null, r: string) => void;
+                placeBlocks: (doc: E.EngineDoc, v: import("../../crdt/placement/model.js").ModelView, parent: import("../../index.js").BlockId | null, left: import("../../index.js").BlockId | null, right: import("../../index.js").BlockId | null, slots: readonly import("../../crdt/placement/slots.js").BlockSlot[] | null, moved?: readonly number[] | null, side?: number, part?: number, at?: import("../../crdt/placement/slots.js").Unit | null) => void;
+                moveBlocksTo: (doc: E.EngineDoc, v: import("../../crdt/placement/model.js").ModelView, ids: readonly import("../../index.js").BlockId[], parent: import("../../index.js").BlockId | null, index: number, side?: number, part?: number, at?: import("../../index.js").BlockId | null) => void;
+                insertSpecsAt: (doc: E.EngineDoc, v: import("../../crdt/placement/model.js").ModelView, parent: import("../../index.js").BlockId | null, index: number, specs: readonly import("../../index.js").BlockSpec[], split?: import("../../crdt/placement/slots.js").Unit | null) => void;
                 withdrawOnUndo: (doc: E.EngineDoc) => (item: E.EngineItemRef, stackItem: {
                     inserts: {
                         has(client: number, clock: number): boolean;
                     };
                 }) => boolean;
-                materializeSpec: (doc: E.EngineDoc, sp: import("../../index.js").BlockSpec, parent: import("../../index.js").BlockId | null, rank: string) => void;
                 collides: (doc: E.EngineDoc, specs: readonly import("../../index.js").BlockSpec[]) => boolean;
-                writeSplit: (doc: E.EngineDoc, id: import("../../index.js").BlockId, offset: number, newId: import("../../index.js").BlockId, tail: import("../../index.js").SplitTail, place: import("../../crdt/placement/model.js").PlacementValue) => void;
+                writeSplit: (doc: E.EngineDoc, id: import("../../index.js").BlockId, offset: number, newId: import("../../index.js").BlockId, tail: import("../../index.js").SplitTail, parent: import("../../index.js").BlockId | null, index: number) => import("../../crdt/placement/slots.js").Unit;
                 ownText: (doc: E.EngineDoc, id: import("../../index.js").BlockId) => {
                     from: unknown;
                     to: number;
                 };
+                recordsOf: (doc: E.EngineDoc, node: E.EngineNode, v?: import("../../crdt/placement/model.js").ModelView) => {
+                    item: import("../../crdt/placement/slots.js").SeqItem;
+                    stamp: import("../../crdt/placement/slots.js").Stamp;
+                    wins: boolean;
+                }[];
                 insertBlocks: (doc: E.EngineDoc, dest: import("../../index.js").Destination, specs: import("../../index.js").BlockSpec[]) => boolean;
                 insertBlock: (doc: E.EngineDoc, dest: import("../../index.js").Destination, spec: import("../../index.js").BlockSpec) => boolean;
                 restoreBlocks: (doc: E.EngineDoc, specs: import("../../index.js").BlockSpec[]) => void;
@@ -157,8 +158,8 @@ export declare const crdt: {
                     at: number;
                     node: E.EngineNode;
                 } | null;
-                splitAt: (blocks: ReadonlyMap<import("../../crdt/text/model.js").BlockId, import("../../crdt/text/model.js").TextBlockRec>, own: import("../../crdt/text/model.js").Ownership, b: import("../../crdt/text/model.js").BlockId, offset: number, newId: import("../../crdt/text/model.js").BlockId, n: number) => import("../../crdt/text/model.js").MergeClaim[];
-                claimInto: (blocks: ReadonlyMap<import("../../crdt/text/model.js").BlockId, import("../../crdt/text/model.js").TextBlockRec>, own: Pick<import("../../crdt/text/model.js").Ownership, "streamOf">, from: import("../../crdt/text/model.js").BlockId, into: import("../../crdt/text/model.js").BlockId) => void;
+                splitAt: (doc: E.EngineDoc, blocks: ReadonlyMap<import("../../crdt/text/model.js").BlockId, import("../../crdt/text/model.js").TextBlockRec>, own: import("../../crdt/text/model.js").Ownership, b: import("../../crdt/text/model.js").BlockId, offset: number, newId: import("../../crdt/text/model.js").BlockId, n: number) => void;
+                claimInto: (own: Pick<import("../../crdt/text/model.js").Ownership, "streamOf">, from: import("../../crdt/text/model.js").BlockId, into: import("../../crdt/text/model.js").BlockId) => void;
                 ownText: (doc: E.EngineDoc, rec: import("../../crdt/text/model.js").TextBlockRec) => {
                     from: unknown;
                     to: number;
@@ -178,7 +179,7 @@ export declare const crdt: {
                 keep?: boolean;
                 after?: readonly import("../../index.js").BlockSpec[];
             } | undefined) => import("../../index.js").OpResult;
-            placeBeside: (ids: readonly string[], target: string, side: "right" | "left", kind?: string | undefined) => import("../../index.js").OpResult;
+            placeBeside: (ids: readonly string[], target: string, side: "left" | "right", kind?: string | undefined) => import("../../index.js").OpResult;
             wrapInLayout: (ids: readonly string[], kind?: string | undefined, columns?: number | undefined) => import("../../index.js").OpResult;
             splitBlock: (id: string, offset: number, newId: string, tail?: import("../../index.js").SplitTail | undefined) => import("../../index.js").OpResult;
             mergeBlocks: (fromId: string, intoId: string) => import("../../index.js").OpResult;
@@ -301,11 +302,10 @@ export declare const crdt: {
             onChange: (cb: (change: import("../../index.js").DocChange) => void) => (() => void);
         };
         newDoc: (opts?: ConstructorParameters<E.EngineApi["Doc"]>[0]) => YDoc;
-        keepCopies: (doc: E.EngineDoc) => void;
         purge: (doc: E.EngineDoc, facade: {
             model: import("../../crdt/placement/model.js").PlacementModel;
             text: import("../../crdt/text/model.js").TextEngine;
-        }, horizon: import("../../crdt/purge.js").Horizon) => import("../index.js").PurgeReport;
+        }, horizon: import("../../crdt/purge.js").Horizon | null) => import("../index.js").PurgeReport;
         horizonOf: (doc: E.EngineDoc) => import("../../crdt/purge.js").Horizon | null;
         restoreTo: <Plan>(doc: E.EngineDoc, facade: import("../../crdt/restore.js").RestoreFacade<Plan>, json: JSONDoc) => import("../../crdt/restore.js").RestoreReport;
         model: {
@@ -314,29 +314,30 @@ export declare const crdt: {
             blockNodeOf: (doc: E.EngineDoc, id: import("../../index.js").BlockId) => E.EngineNode | null;
             liveNodeOf: (doc: E.EngineDoc, id: import("../../index.js").BlockId) => E.EngineNode | null;
             isLive: (doc: E.EngineDoc, id: import("../../index.js").BlockId) => boolean;
-            candidatesOf: (node: E.EngineNode) => import("../../crdt/placement/model.js").PlacementCand[];
             view: (doc: E.EngineDoc) => import("../../crdt/placement/model.js").ModelView;
-            resolvePlacements: (blocks: Map<import("../../index.js").BlockId, import("../../crdt/placement/model.js").BlockRec>, ownerOf?: (b: import("../../index.js").BlockId) => import("../../crdt/text/model.js").Owner) => Map<import("../../index.js").BlockId, import("../../crdt/placement/model.js").ResolvedPlacement>;
             childrenIndex: (placements: Map<import("../../index.js").BlockId, import("../../crdt/placement/model.js").ResolvedPlacement>, own: import("../../crdt/placement/model.js").DisplayOwnership) => Map<import("../../index.js").BlockId | null, import("../../crdt/placement/model.js").ChildSlot[]>;
             positionInView: (v: import("../../crdt/placement/model.js").ModelView, id: import("../../index.js").BlockId) => import("../../index.js").Destination | null;
             buildInline: (atom: import("../../index.js").InlineSpec) => E.EngineNode;
             isSelfOrDescendant: (placements: Map<import("../../index.js").BlockId, import("../../crdt/placement/model.js").ResolvedPlacement>, own: import("../../crdt/text/model.js").Ownership, id: import("../../index.js").BlockId, maybeAncestor: import("../../index.js").BlockId) => boolean;
-            ranksAt: (siblings: readonly {
-                rank: string;
-            }[], index: number, count: number, clientId: number, rand?: () => number, run?: boolean) => string[];
-            writePlacement: (doc: E.EngineDoc, node: E.EngineNode, p: import("../../index.js").BlockId | null, r: string) => void;
+            placeBlocks: (doc: E.EngineDoc, v: import("../../crdt/placement/model.js").ModelView, parent: import("../../index.js").BlockId | null, left: import("../../index.js").BlockId | null, right: import("../../index.js").BlockId | null, slots: readonly import("../../crdt/placement/slots.js").BlockSlot[] | null, moved?: readonly number[] | null, side?: number, part?: number, at?: import("../../crdt/placement/slots.js").Unit | null) => void;
+            moveBlocksTo: (doc: E.EngineDoc, v: import("../../crdt/placement/model.js").ModelView, ids: readonly import("../../index.js").BlockId[], parent: import("../../index.js").BlockId | null, index: number, side?: number, part?: number, at?: import("../../index.js").BlockId | null) => void;
+            insertSpecsAt: (doc: E.EngineDoc, v: import("../../crdt/placement/model.js").ModelView, parent: import("../../index.js").BlockId | null, index: number, specs: readonly import("../../index.js").BlockSpec[], split?: import("../../crdt/placement/slots.js").Unit | null) => void;
             withdrawOnUndo: (doc: E.EngineDoc) => (item: E.EngineItemRef, stackItem: {
                 inserts: {
                     has(client: number, clock: number): boolean;
                 };
             }) => boolean;
-            materializeSpec: (doc: E.EngineDoc, sp: import("../../index.js").BlockSpec, parent: import("../../index.js").BlockId | null, rank: string) => void;
             collides: (doc: E.EngineDoc, specs: readonly import("../../index.js").BlockSpec[]) => boolean;
-            writeSplit: (doc: E.EngineDoc, id: import("../../index.js").BlockId, offset: number, newId: import("../../index.js").BlockId, tail: import("../../index.js").SplitTail, place: import("../../crdt/placement/model.js").PlacementValue) => void;
+            writeSplit: (doc: E.EngineDoc, id: import("../../index.js").BlockId, offset: number, newId: import("../../index.js").BlockId, tail: import("../../index.js").SplitTail, parent: import("../../index.js").BlockId | null, index: number) => import("../../crdt/placement/slots.js").Unit;
             ownText: (doc: E.EngineDoc, id: import("../../index.js").BlockId) => {
                 from: unknown;
                 to: number;
             };
+            recordsOf: (doc: E.EngineDoc, node: E.EngineNode, v?: import("../../crdt/placement/model.js").ModelView) => {
+                item: import("../../crdt/placement/slots.js").SeqItem;
+                stamp: import("../../crdt/placement/slots.js").Stamp;
+                wins: boolean;
+            }[];
             insertBlocks: (doc: E.EngineDoc, dest: import("../../index.js").Destination, specs: import("../../index.js").BlockSpec[]) => boolean;
             insertBlock: (doc: E.EngineDoc, dest: import("../../index.js").Destination, spec: import("../../index.js").BlockSpec) => boolean;
             restoreBlocks: (doc: E.EngineDoc, specs: import("../../index.js").BlockSpec[]) => void;
@@ -368,8 +369,8 @@ export declare const crdt: {
                 at: number;
                 node: E.EngineNode;
             } | null;
-            splitAt: (blocks: ReadonlyMap<import("../../crdt/text/model.js").BlockId, import("../../crdt/text/model.js").TextBlockRec>, own: import("../../crdt/text/model.js").Ownership, b: import("../../crdt/text/model.js").BlockId, offset: number, newId: import("../../crdt/text/model.js").BlockId, n: number) => import("../../crdt/text/model.js").MergeClaim[];
-            claimInto: (blocks: ReadonlyMap<import("../../crdt/text/model.js").BlockId, import("../../crdt/text/model.js").TextBlockRec>, own: Pick<import("../../crdt/text/model.js").Ownership, "streamOf">, from: import("../../crdt/text/model.js").BlockId, into: import("../../crdt/text/model.js").BlockId) => void;
+            splitAt: (doc: E.EngineDoc, blocks: ReadonlyMap<import("../../crdt/text/model.js").BlockId, import("../../crdt/text/model.js").TextBlockRec>, own: import("../../crdt/text/model.js").Ownership, b: import("../../crdt/text/model.js").BlockId, offset: number, newId: import("../../crdt/text/model.js").BlockId, n: number) => void;
+            claimInto: (own: Pick<import("../../crdt/text/model.js").Ownership, "streamOf">, from: import("../../crdt/text/model.js").BlockId, into: import("../../crdt/text/model.js").BlockId) => void;
             ownText: (doc: E.EngineDoc, rec: import("../../crdt/text/model.js").TextBlockRec) => {
                 from: unknown;
                 to: number;
@@ -691,9 +692,9 @@ export declare class RoomContext {
             emptied: number;
             marks: number;
             records: number;
-            candidates: number;
             claims: number;
             merged: number;
+            released: number;
         };
         since: number;
     };

package/dist/cloudflare/room/context.js

@@ -51,9 +51,9 @@ const counters = () => ({
         emptied: 0,
         marks: 0,
         records: 0,
-        candidates: 0,
         claims: 0,
-        merged: 0
+        merged: 0,
+        released: 0
     },
     since: Date.now()
 });

package/dist/cloudflare/room/purge.d.ts

@@ -1,4 +1,4 @@
-import type { PurgeReport } from '../../crdt/purge.js';
+import { type PurgeReport } from '../../crdt/purge.js';
 import { type RoomContext } from './context.js';
 export declare class RoomPurge {
     #private;
@@ -8,8 +8,11 @@ export declare class RoomPurge {
     get days(): number | null;
     /** A change was stored at `at`: the purge tick runs a day later at the latest. */
     noteChange(at: number): void;
-    /** The purge task (`AttachedDocument.purge`). */
+    /**
+     * The purge task (`AttachedDocument.purge`): its report, `horizon` the
+     * epoch it purged to (`null`: only ended sessions' deletes).
+     */
     tick(): (PurgeReport & {
-        horizon: number;
+        horizon: number | null;
     }) | null;
 }

package/dist/cloudflare/room/purge.js

@@ -1,10 +1,13 @@
 /**
  * The purge (`room.purge.*`): the daily tick records an epoch (the state
  * vector) when the document changed, and purges what was deleted before
- * the horizon — the newest epoch at least `purgeAfterDays` old — as the
- * room's own transaction (`crdt/purge.ts`), then compacts.
+ * the horizon — the newest epoch at least `purgeAfterDays` old — and what
+ * the sessions whose history ended deleted (`hist.release.end`), as the
+ * room's own transaction (`crdt/purge.ts`), then compacts. With no epoch
+ * due, a tick still purges the ended sessions' deletes.
  */
 import { Y } from '../../crdt/engine.js';
+import { releasesOf } from '../../crdt/purge.js';
 import { asEngineDoc } from '../../crdt/structs.js';
 import { PURGE_ORIGIN, noTimers } from './shared.js';
 import { DEFAULT_RETENTION_DAYS } from '../history.js';
@@ -27,7 +30,10 @@ export class RoomPurge {
         if (this.days !== null)
             this.room.scheduler.schedule('purge', at + DAY, 'earlier');
     }
-    /** The purge task (`AttachedDocument.purge`). */
+    /**
+     * The purge task (`AttachedDocument.purge`): its report, `horizon` the
+     * epoch it purged to (`null`: only ended sessions' deletes).
+     */
     tick() {
         const room = this.room;
         const { scheduler, sql, tables } = room;
@@ -61,6 +67,10 @@ export class RoomPurge {
             if (horizon !== undefined && horizon.at > purged) {
                 result = this.#purgeTo({ at: horizon.at, sv: new Uint8Array(horizon.sv) });
             }
+            else if (releasesOf(asEngineDoc(doc)).size > 0) {
+                // No epoch is due: the ended sessions' deletes go all the same.
+                result = this.#purgeTo(null);
+            }
             // The next epoch to pass the horizon, or the next change, arms it again.
             const next = sql
                 .exec(`SELECT at FROM ${tables.epochs} WHERE at > ? ORDER BY at LIMIT 1`, Math.max(purged, horizon?.at ?? -1))
@@ -72,18 +82,27 @@ export class RoomPurge {
             return result;
         });
     }
-    /** Purge what was deleted before `horizon`, as the room's own transaction, then compact. */
+    /**
+     * Purge what was deleted before `horizon` and what ended sessions deleted
+     * (`null`: only those), as the room's own transaction, then compact. A
+     * purge of ended sessions' deletes that finds none left compacts nothing
+     * and reports `null`.
+     */
     #purgeTo(horizon) {
         const room = this.room;
         const doc = room.requireDoc();
         // A restore past the horizon can no longer be undone (`room.history.undo`).
-        room.history.expireRestore(horizon.at);
+        if (horizon !== null)
+            room.history.expireRestore(horizon.at);
         room.history.closeSlotIfPast();
         let report;
+        let wrote = true;
         room.transacting = true;
         try {
             room.facade.transact(() => {
                 report = crdt.doc.purge(asEngineDoc(doc), room.facade, horizon);
+                const tr = asEngineDoc(doc)._transaction;
+                wrote = !tr.insertSet.isEmpty() || !tr.deleteSet.isEmpty();
             }, PURGE_ORIGIN);
         }
         finally {
@@ -94,30 +113,36 @@ export class RoomPurge {
             room.storage.heal();
             throw error;
         }
-        room.ctx.storage.transactionSync(() => {
-            room.sql.exec(`INSERT OR REPLACE INTO ${room.tables.meta} (key, value) VALUES ('purged', ?)`, horizon.at);
-            room.sql.exec(`DELETE FROM ${room.tables.epochs} WHERE at < ?`, horizon.at);
-        });
-        room.storage.compact();
-        const counters = room.counters.purge;
-        counters.runs++;
-        counters.horizon = horizon.at;
-        for (const key of [
+        if (horizon !== null)
+            room.ctx.storage.transactionSync(() => {
+                room.sql.exec(`INSERT OR REPLACE INTO ${room.tables.meta} (key, value) VALUES ('purged', ?)`, horizon.at);
+                room.sql.exec(`DELETE FROM ${room.tables.epochs} WHERE at < ?`, horizon.at);
+            });
+        const keys = [
             'removed',
             'emptied',
             'marks',
             'records',
-            'candidates',
             'claims',
-            'merged'
-        ])
+            'merged',
+            'released'
+        ];
+        // Nothing an ended session deleted was left: no compaction, no run.
+        if (horizon === null && !wrote)
+            return null;
+        room.storage.compact();
+        const counters = room.counters.purge;
+        counters.runs++;
+        if (horizon !== null)
+            counters.horizon = horizon.at;
+        for (const key of keys)
             counters[key] += report[key];
         room.log({
             edytor: 'purge',
-            horizon: horizon.at,
+            horizon: horizon?.at ?? null,
             bytes: room.counters.compaction.lastBytes,
             ...report
         });
-        return { ...report, horizon: horizon.at };
+        return { ...report, horizon: horizon?.at ?? null };
     }
 }

package/dist/cloudflare/room/updates.d.ts

@@ -77,10 +77,9 @@ export declare const heldDeletes: (doc: YDoc, ds: Decoded["ds"]) => Decoded["ds"
 export declare const withoutPending: <T>(doc: YDoc, read: () => T) => T;
 /**
  * The live document as one update: its healed state — the engine
- * merged what each keystroke wrote and collected deleted content, sparing
- * the text a replica may copy again (`keepCopies`) —, without what
- * waits (`withoutPending`). Memory never runs ahead of storage, so it
- * holds exactly what the stored records hold, collected.
+ * merged what each keystroke wrote and collected deleted content —,
+ * without what waits (`withoutPending`). Memory never runs ahead of
+ * storage, so it holds exactly what the stored records hold, collected.
  */
 export declare const liveState: (doc: YDoc) => Uint8Array;
 /** A fresh room document (`prepareRoomDoc`'s collection rules). */

package/dist/cloudflare/room/updates.js

@@ -5,7 +5,7 @@
  */
 import * as encoding from 'lib0-v14/encoding';
 import { Y } from '../../crdt/engine.js';
-import { asEngineDoc, keepFromCollection, structAt as storeStructAt } from '../../crdt/structs.js';
+import { keepFromCollection, structAt as storeStructAt } from '../../crdt/structs.js';
 import { ROOM_ORIGIN } from './shared.js';
 import { crdt } from './context.js';
 export const stateVector = (doc) => Y.decodeStateVector(Y.encodeStateVector(doc));
@@ -295,19 +295,17 @@ export const withoutPending = (doc, read) => {
 };
 /**
  * The live document as one update: its healed state — the engine
- * merged what each keystroke wrote and collected deleted content, sparing
- * the text a replica may copy again (`keepCopies`) —, without what
- * waits (`withoutPending`). Memory never runs ahead of storage, so it
- * holds exactly what the stored records hold, collected.
+ * merged what each keystroke wrote and collected deleted content —,
+ * without what waits (`withoutPending`). Memory never runs ahead of
+ * storage, so it holds exactly what the stored records hold, collected.
  */
 export const liveState = (doc) => withoutPending(doc, () => Y.encodeStateAsUpdate(doc));
 /**
  * A room document's collection rules, before any update applies: it keeps
- * what an editing replica keeps, and the content the last restore
- * deleted while its undo stands (`keep`, `room.history.undo`).
+ * the content the last restore deleted while its undo stands (`keep`,
+ * `room.history.undo`).
  */
 const prepareRoomDoc = (doc, keep) => {
-    crdt.doc.keepCopies(asEngineDoc(doc));
     keepFromCollection(doc, (it) => !(keep()?.intersects(it.id.client, it.id.clock, it.length) ?? false));
 };
 /** A fresh room document (`prepareRoomDoc`'s collection rules). */

package/dist/crdt/attribution/attribution.d.ts

@@ -17,10 +17,13 @@
  *     `u/<actorId>`          → profile `{name?, color?}` — one record per
  *                              stable application actor, referenced by id.
  *
- *   Published once per attach (inside an `ATTRIBUTION_ORIGIN`
- *   transaction) and readable through `actors`/`actorOf`. These records
- *   also travel inside `encode()` output, so `loadDocument` restores the
- *   dictionary without republishing.
+ *   Published with the replica's first write: inside the first local
+ *   transaction that writes under its client id (the engine's
+ *   `beforeCommit`, fork patch YP30), so a replica that only reads writes
+ *   nothing, and every struct it writes travels with its binding. Readable
+ *   through `actors`/`actorOf`. These records also travel inside `encode()`
+ *   output, so `loadDocument` restores the dictionary without
+ *   republishing.
  *
  *   LEGACY RECORDS — documents saved by early builds carry `a/` per-edit
  *   records under the same root. They are plain replicated state, preserved
@@ -35,9 +38,10 @@ import { type BlockAttribution } from './block.js';
 /** Reserved replicated root for all attribution metadata (`SCHEMA.roots.attribution`). */
 export { ATTRIBUTION_ROOT };
 /**
- * Origin of every metadata write this module performs (`u/`/`c/`
- * dictionary publishes only — per-edit record writes are retired). Kept
- * out of undo capture; tooling classifies it as bookkeeping.
+ * Origin of the profile writes this module performs on its own
+ * (`setProfile`; the binding joins the transaction of the replica's first
+ * write, whatever its origin). Kept out of undo capture; tooling classifies
+ * it as bookkeeping.
  */
 export declare const ATTRIBUTION_ORIGIN: unique symbol;
 /** The stable application-level author identity (mirrors `DocumentActor`). */
@@ -57,14 +61,23 @@ export type ActorProfile = {
  * records identically and stay correct as old replicas append records.
  */
 export type DocumentAttribution = {
-    /** actorId → profile — the replicated actor dictionary (`u/` records). */
+    /**
+     * actorId → profile — the replicated actor dictionary (`u/` records): the
+     * actors whose replicas wrote, each published with its replica's first
+     * write (or `setProfile`).
+     */
     readonly actors: ReadonlyMap<string, ActorProfile>;
-    /** Resolve an item's inserting replica (clientID) to an actor id (`c/` records). */
+    /**
+     * Resolve an item's inserting replica (clientID) to an actor id (`c/`
+     * records). A replica's binding is written with its first write, so every
+     * client id that wrote a struct resolves; one that never wrote does not.
+     */
     actorOf(client: number): string | undefined;
     /**
-     * Re-publish the local actor's profile record (`u/<actorId>` — LWW).
-     * Attribution is never relabeled: historical records keep the stable
-     * actor id; only the resolvable profile changes.
+     * Re-publish the local actor's profile record (`u/<actorId>` — LWW), a
+     * write of this replica (its binding goes with it, as with any first
+     * write). Attribution is never relabeled: historical records keep the
+     * stable actor id; only the resolvable profile changes.
      */
     setProfile(profile: ActorProfile): void;
     /**
@@ -94,6 +107,12 @@ export type AttributionController = {
 type AttachOptions = {
     actor: AttributionActor;
 };
+/**
+ * The actor `doc`'s own replica writes for: its binding (`c/<clientID>`),
+ * else, before its first write, the actor its attribution controller was
+ * attached with (`undefined`: a raw doc). The provider's `saved` reads it.
+ */
+export declare const writerOf: (doc: EngineDoc) => string | undefined;
 /** The display profile of `actor`: its name and color, those it has. */
 export declare const profileOf: (actor: AttributionActor) => ActorProfile;
 /**