edytor 1.0.0 → 3.0.0

package/dist/crdt/doc/gate.d.ts

@@ -86,20 +86,3 @@ export declare class SchemaMismatchError extends Error {
  * mutating a synced document.
  */
 export declare const assertSchema: (doc: EngineDoc, docName?: string) => void;
-/**
- * Error raised by {@link assertUsableDoc} — the doc cannot host a v14 facade:
- * a foreign engine object (a v13 `yjs` Doc — a different CRDT implementation
- * entirely).
- */
-export declare class UnsupportedDocError extends Error {
-    readonly kind: 'foreign';
-    constructor(kind: 'foreign');
-}
-/**
- * Document-boundary guard run by {@link EdytorDocBinding.create} before the
- * runs view attaches. The facade only speaks the v14 unified-node surface —
- * without this gate a foreign doc dies obscurely inside `buildView`
- * (`registry.forEachAttr is not a function`); it fails fast with an
- * actionable error instead.
- */
-export declare const assertUsableDoc: (doc: EngineDoc) => void;

package/dist/crdt/doc/gate.js

@@ -1,4 +1,4 @@
-import { isNodeLike, SCHEMA } from '../schema.js';
+import { SCHEMA } from '../schema.js';
 export const SCHEMA_VERSION = SCHEMA.version;
 export const SCHEMA_NAME = SCHEMA.name;
 export const META_KEY = SCHEMA.roots.meta;
@@ -51,13 +51,7 @@ export class SchemaMismatchError extends Error {
     docName;
     problem;
     constructor(docName, problem) {
-        super(problem.kind === 'unversioned'
-            ? `Document "${docName}" carries replicated registry state but no meta.v schema version — refusing to treat it as initialized.`
-            : problem.kind === 'unsupported'
-                ? `Document "${docName}" claims unsupported schema version ${problem.version} (this build speaks ${SCHEMA_VERSION}).`
-                : problem.schema === undefined
-                    ? `Document "${docName}" carries meta.v=${problem.version} but no meta.schema manifest name — refusing it as an "${SCHEMA_NAME}" document.`
-                    : `Document "${docName}" claims foreign schema "${String(problem.schema)}" (this build speaks "${SCHEMA_NAME}").`);
+        super(`${docName}: ${problem.kind} schema version ${problem.version} "${String(problem.schema)}" (this build speaks ${SCHEMA_VERSION} "${SCHEMA_NAME}")`);
         this.docName = docName;
         this.problem = problem;
         this.name = 'SchemaMismatchError';
@@ -73,36 +67,3 @@ export const assertSchema = (doc, docName = 'doc') => {
     if (problem !== null)
         throw new SchemaMismatchError(docName, problem);
 };
-/**
- * Error raised by {@link assertUsableDoc} — the doc cannot host a v14 facade:
- * a foreign engine object (a v13 `yjs` Doc — a different CRDT implementation
- * entirely).
- */
-export class UnsupportedDocError extends Error {
-    kind;
-    constructor(kind) {
-        super('Document is not a v14 engine doc — the `blocks` registry is not a ' +
-            'unified Y.Node. Use `crdt.createDoc()` (or `new Y.Doc()` from `edytor/crdt`).');
-        this.kind = kind;
-        this.name = 'UnsupportedDocError';
-    }
-}
-/**
- * Document-boundary guard run by {@link EdytorDocBinding.create} before the
- * runs view attaches. The facade only speaks the v14 unified-node surface —
- * without this gate a foreign doc dies obscurely inside `buildView`
- * (`registry.forEachAttr is not a function`); it fails fast with an
- * actionable error instead.
- */
-export const assertUsableDoc = (doc) => {
-    let registry;
-    try {
-        registry = typeof doc?.get === 'function' ? doc.get(SCHEMA.roots.registry) : undefined;
-    }
-    catch {
-        registry = undefined;
-    }
-    if (!isNodeLike(registry) || typeof registry.forEachAttr !== 'function') {
-        throw new UnsupportedDocError('foreign');
-    }
-};

package/dist/crdt/doc/history.js

@@ -15,7 +15,7 @@ import { readHorizon } from '../purge.js';
 import { BLOCK_NODE, DATA_LEAF_PREFIX, DOC_DATA_ROOT, HORIZON_ROOT, INLINE_NODE, LAST_CHANGED_ATTR, TYPE } from '../schema.js';
 import { changedUnder, collectable, collectNow, collects, dropSearchMarkers, engineOps, walkIdSet } from '../structs.js';
 import { isInitialized } from './gate.js';
-import { EdytorDocDisposedError } from './funnel.js';
+import { DocumentDestroyedError } from './funnel.js';
 import { registryOf, withdrawOnUndo } from '../placement/model.js';
 /** The undo steps a document's history keeps by default: older ones are released. */
 export const DEFAULT_HISTORY_LIMIT = 200;
@@ -367,7 +367,7 @@ export const docHistory = (c) => {
      */
     const createUndoManager = (options = {}) => {
         if (disposed()) {
-            throw new EdytorDocDisposedError('createUndoManager');
+            throw new DocumentDestroyedError('createUndoManager');
         }
         write(() => {
             if (!isInitialized(doc))

package/dist/crdt/doc/reads.d.ts

@@ -1,6 +1,7 @@
 import type { EngineApi, EngineDoc, EngineNode } from '../engine-api.js';
 import { type BlockId, type ContentItem, type Destination, type ModelView } from '../placement/model.js';
 import type { DisplayRoles, RunView } from '../text/runs.js';
+import { type DataPatch } from '../data.js';
 import { type JSONBlock } from '../../utils/json.js';
 import type { BlockRole, DataTarget, JsonObj, OrderPolicy } from './types.js';
 /** What every part of a document facade is built over: one doc, its engine layers, its index and its roles. */
@@ -25,6 +26,12 @@ export declare const docReads: (c: DocBase) => {
     blockDataOf: (id: BlockId) => Record<string, unknown> | undefined;
     docData: () => JsonObj;
     dataItemIds: (target: DataTarget, path: readonly string[]) => string[];
+    dataPreview: (target: DataTarget, pending: readonly DataPatch[]) => {
+        data: {
+            [x: string]: unknown;
+        };
+        ids: (path: readonly string[]) => string[];
+    } | null;
     childrenIds: (parent: BlockId | null) => BlockId[];
     positionOf: (id: BlockId) => Destination | null;
     pathOf: (id: BlockId) => number[] | null;

package/dist/crdt/doc/reads.js

@@ -9,7 +9,7 @@ import { DOC_DATA_ROOT, TYPE } from '../schema.js';
 import { blockNodeOf, displayParentOf, displaySlotOf, isLive, isLiveIn, positionInView, positionOf as modelPositionOf } from '../placement/model.js';
 import { DEAD, findAtom, ownedLength } from '../text/model.js';
 import { holdsPending } from '../structs.js';
-import { itemIds, readData } from '../data.js';
+import { itemIds, previewData, readData } from '../data.js';
 import { columnIds, listedColumns, unlistedOrder } from '../tables.js';
 import { cloneJsonSafe } from '../../utils/json.js';
 import { ref } from './plan.js';
@@ -69,6 +69,15 @@ export const docReads = (c) => {
         const node = dataNode(id && ref(id), atom && ref(atom));
         return node && Array.isArray(path) ? itemIds(node, path) : [];
     };
+    /**
+     * A block's, an atom's or the document's data once `pending` patches are
+     * applied, without writing them, and its array items' ids (`previewData`):
+     * what a view reads of its data writes not yet dispatched.
+     */
+    const dataPreview = (target, pending) => {
+        const [id, atom] = typeof target === 'object' && target ? [target.block, target.atom] : [target ?? undefined];
+        return previewData(dataNode(id && ref(id), atom && ref(atom)), pending);
+    };
     /** Ordered visible children of `parent` (`null` = root) — canonical read. */
     const childrenIds = (parent) => (view().kids.get(parent) ?? []).map((k) => k.id);
     const positionOf = (id) => modelPositionOf(doc, id);
@@ -302,6 +311,7 @@ export const docReads = (c) => {
         blockDataOf,
         docData,
         dataItemIds,
+        dataPreview,
         childrenIds,
         positionOf,
         pathOf,

package/dist/crdt/document.d.ts

@@ -64,7 +64,7 @@
  * - `createDocument` — the fresh doc is trivially admitted;
  * - `loadDocument` — the payload is decoded+integrated onto a SCRATCH
  *   doc first (`admitUpdate`) and the gate runs on the merged result; a
- *   refusal ({@link UndecodableUpdateError}, {@link UnsupportedDocError},
+ *   refusal ({@link UndecodableUpdateError},
  *   {@link SchemaMismatchError}) leaves nothing composed and never
  *   touches the caller's bytes;
  * - `attachDocument` — the borrowed doc is gated BEFORE any composition
@@ -144,7 +144,7 @@ import type { MarkEdge } from './text/marks.js';
 import type { EngineApi, EngineDoc, YDoc, YUndoManager } from './engine-api.js';
 import { type DocumentOperations } from './operations.js';
 import { type AttributionBinding, type DocumentAttribution } from './attribution/index.js';
-import { type BlockRole, type DocFacade, type EdytorDocConfig } from './edytor-doc.js';
+import { DocumentDestroyedError, type BlockRole, type DocFacade, type EdytorDocConfig } from './edytor-doc.js';
 import { Awareness } from './protocols/awareness.js';
 import type { EdytorSync, EdytorSyncCleanup } from './providers/index.js';
 import { SyncRefusedError } from './providers/room.js';
@@ -243,19 +243,11 @@ export type CreateDocumentOptions = DocumentOptions & {
     value?: JSONDoc;
 };
 export type LoadDocumentOptions = DocumentOptions;
+export { DocumentDestroyedError };
 /** Raised when a readiness-gated service is used on a pending document. */
 export declare class DocumentNotReadyError extends Error {
     constructor(service: string);
 }
-/**
- * Raised when an operation runs against a torn-down document — every
- * attach reference has been released and the facade/history/awareness
- * teardown already ran. Distinct from {@link DocumentNotReadyError}:
- * destroyed is terminal, pending may still resolve.
- */
-export declare class DocumentDestroyedError extends Error {
-    constructor(service?: string);
-}
 /**
  * How the document's content state was decided — the distinction the
  * readiness contract requires:
@@ -353,6 +345,14 @@ export declare class EdytorDocument {
     private _destroyed;
     /** {@link DocumentOptions.requireHydration}: an empty document waits for a provider's `synced`. */
     readonly requireHydration: boolean;
+    /**
+     * The document's properties as a live object (`crdt/props`): a read
+     * follows the document, and a write at any depth (`document.data.title
+     * = 'Notes'`, `document.data.tags.push('x')`, `delete …`) is the raw
+     * `patchData` operation at once, as `document.patchData(null, …)`. Not
+     * reactive by itself: a view's `edytor.data` is, and dispatches.
+     */
+    get data(): Record<string, any>;
     /** The replica id (`doc.clientID`) — identifies the replica, not the actor. */
     get clientID(): number;
     /**
@@ -633,9 +633,8 @@ export declare const bindDocument: (Y: EngineApi) => {
      * borrowed doc. Content state stays `pending` — the caller (view or
      * provider path) drives `sync()`.
      *
-     * Admission runs BEFORE any composition touches the doc: a
-     * foreign engine object refuses with {@link UnsupportedDocError}, an
-     * unversioned/unsupported/foreign schema claim with
+     * Admission runs BEFORE any composition touches the doc: an
+     * unversioned/unsupported/foreign schema claim refuses with
      * {@link SchemaMismatchError} — the borrowed doc is left
      * byte-identical (the gate reads are write-free) and can be
      * attached once its state heals (e.g. a remote update supplies the

package/dist/crdt/document.js

@@ -2,9 +2,10 @@ import { DEV } from 'esm-env';
 import { Y } from './engine.js';
 import { asEngineDoc } from './structs.js';
 import { DOCUMENT_OPERATIONS } from './operations.js';
+import { propsProxy } from './props.js';
 import { bindAttribution } from './attribution/index.js';
 import { profileOf } from './attribution/attribution.js';
-import { docFacade, DEFAULT_HISTORY_LIMIT, isInitialized } from './edytor-doc.js';
+import { docFacade, DocumentDestroyedError, DEFAULT_HISTORY_LIMIT, isInitialized } from './edytor-doc.js';
 import { assertAdmission, assertSchema, bindAdmission, checkSchema } from './admission.js';
 import { Awareness } from './protocols/awareness.js';
 import { callEach } from './protocols/observable.js';
@@ -17,27 +18,14 @@ const alive = (document, op) => {
     if (document.destroyed)
         throw new DocumentDestroyedError(op);
 };
+export { DocumentDestroyedError };
 /** Raised when a readiness-gated service is used on a pending document. */
 export class DocumentNotReadyError extends Error {
     constructor(service) {
-        super(`EdytorDocument.${service}: document is not ready — it is still pending ` +
-            `(created without a value, provider hydration may be in flight). ` +
-            `Wait for the sync callback / call document.sync() first.`);
+        super(`${service}: the document is not ready (call document.sync() first)`);
         this.name = 'DocumentNotReadyError';
     }
 }
-/**
- * Raised when an operation runs against a torn-down document — every
- * attach reference has been released and the facade/history/awareness
- * teardown already ran. Distinct from {@link DocumentNotReadyError}:
- * destroyed is terminal, pending may still resolve.
- */
-export class DocumentDestroyedError extends Error {
-    constructor(service) {
-        super(`EdytorDocument${service ? `.${service}` : ''}: document is destroyed.`);
-        this.name = 'DocumentDestroyedError';
-    }
-}
 /**
  * How long (ms) an empty document waits for a provider that has not
  * settled before it decides without it (settle-or-bound) — the bound a
@@ -237,6 +225,17 @@ export class EdytorDocument {
         else if (DEV)
             advertise(this.awareness, this.#capability.config, this.#defaultType);
     }
+    #data;
+    /**
+     * The document's properties as a live object (`crdt/props`): a read
+     * follows the document, and a write at any depth (`document.data.title
+     * = 'Notes'`, `document.data.tags.push('x')`, `delete …`) is the raw
+     * `patchData` operation at once, as `document.patchData(null, …)`. Not
+     * reactive by itself: a view's `edytor.data` is, and dispatches.
+     */
+    get data() {
+        return (this.#data ??= propsProxy(() => this.facade.docData(), (patches) => void this.facade.apply(this.facade.prepare.patchData(null, patches)), (path) => this.facade.dataItemIds(null, path)));
+    }
     /** The replica id (`doc.clientID`) — identifies the replica, not the actor. */
     get clientID() {
         return this.doc.clientID;
@@ -914,9 +913,8 @@ export const bindDocument = (Y) => {
          * borrowed doc. Content state stays `pending` — the caller (view or
          * provider path) drives `sync()`.
          *
-         * Admission runs BEFORE any composition touches the doc: a
-         * foreign engine object refuses with {@link UnsupportedDocError}, an
-         * unversioned/unsupported/foreign schema claim with
+         * Admission runs BEFORE any composition touches the doc: an
+         * unversioned/unsupported/foreign schema claim refuses with
          * {@link SchemaMismatchError} — the borrowed doc is left
          * byte-identical (the gate reads are write-free) and can be
          * attached once its state heals (e.g. a remote update supplies the

package/dist/crdt/edytor-doc.d.ts

@@ -5,7 +5,7 @@ import { bindText } from './text/model.js';
 import { type RunView } from './text/runs.js';
 import { type BlockAttribution } from './attribution/block.js';
 import type { JSONBlock, JSONDoc } from '../utils/json.js';
-import { assertSchema, assertUsableDoc, checkSchema, isInitialized, META_KEY, registryEmpty, SCHEMA_NAME, SCHEMA_VERSION, SchemaMismatchError, schemaVersion } from './doc/gate.js';
+import { assertSchema, checkSchema, isInitialized, META_KEY, registryEmpty, SCHEMA_NAME, SCHEMA_VERSION, SchemaMismatchError, schemaVersion } from './doc/gate.js';
 import type { EngineNode } from './engine-api.js';
 import type { ContentItem, InlineSpec, ModelView, SplitTail } from './placement/model.js';
 import type { Anchor } from './text/model.js';
@@ -14,10 +14,10 @@ import type { DocPosition } from './rangeDelete.js';
 import type { DataPatch } from './data.js';
 import type { AnchorAffinity, BlockRole, DataTarget, DocAnchor, DocChange, EdytorDocConfig, JsonObj, OpResult, OrderPolicy, Plan, PlanEffect, PlanStep, Prepared, TextRange } from './doc/types.js';
 export { SCHEMA };
-export { assertSchema, assertUsableDoc, checkSchema, isInitialized, META_KEY, registryEmpty, SCHEMA_NAME, SCHEMA_VERSION, SchemaMismatchError, schemaVersion };
-export { UnsupportedDocError, type SchemaProblem } from './doc/gate.js';
+export { assertSchema, checkSchema, isInitialized, META_KEY, registryEmpty, SCHEMA_NAME, SCHEMA_VERSION, SchemaMismatchError, schemaVersion };
+export type { SchemaProblem } from './doc/gate.js';
 export { SEED_ORIGIN } from './doc/seed.js';
-export { EdytorDocDisposedError } from './doc/funnel.js';
+export { DocumentDestroyedError } from './doc/funnel.js';
 export { DEFAULT_HISTORY_LIMIT } from './doc/history.js';
 export type { AnchorAffinity, BlockRole, DataTarget, DocAnchor, DocChange, EdytorDocConfig, OpResult, OrderPolicy, Plan, PlanEffect, PlanStep, Prepared, TextRange };
 export type EdytorDoc = ReturnType<EdytorDocBinding['create']>;
@@ -168,6 +168,12 @@ export declare const docFacade: <L extends Layers>(Y: EngineApi, layers: L) => (
     blockDataOf: (id: string) => Record<string, unknown> | undefined;
     docData: () => JsonObj;
     dataItemIds: (target: DataTarget, path: readonly string[]) => string[];
+    dataPreview: (target: DataTarget, pending: readonly DataPatch[]) => {
+        data: {
+            [x: string]: unknown;
+        };
+        ids: (path: readonly string[]) => string[];
+    } | null;
     /**
      * Compact per-block attribution (`{createdBy, contributors,
      * lastChangedBy}`), or `undefined` for unauthored/system blocks.
@@ -482,6 +488,12 @@ export declare const bindDocModel: (Y: EngineApi) => {
         blockDataOf: (id: string) => Record<string, unknown> | undefined;
         docData: () => JsonObj;
         dataItemIds: (target: DataTarget, path: readonly string[]) => string[];
+        dataPreview: (target: DataTarget, pending: readonly DataPatch[]) => {
+            data: {
+                [x: string]: unknown;
+            };
+            ids: (path: readonly string[]) => string[];
+        } | null;
         /**
          * Compact per-block attribution (`{createdBy, contributors,
          * lastChangedBy}`), or `undefined` for unauthored/system blocks.
@@ -882,6 +894,12 @@ export declare const bindEdytorDoc: (Y: EngineApi) => {
         blockDataOf: (id: string) => Record<string, unknown> | undefined;
         docData: () => JsonObj;
         dataItemIds: (target: DataTarget, path: readonly string[]) => string[];
+        dataPreview: (target: DataTarget, pending: readonly DataPatch[]) => {
+            data: {
+                [x: string]: unknown;
+            };
+            ids: (path: readonly string[]) => string[];
+        } | null;
         /**
          * Compact per-block attribution (`{createdBy, contributors,
          * lastChangedBy}`), or `undefined` for unauthored/system blocks.

package/dist/crdt/edytor-doc.js

@@ -58,7 +58,7 @@ import { bindRuns, indexOf } from './text/runs.js';
 import { bindBlockAttribution, blockAttributionOf } from './attribution/block.js';
 import { rangeDeleteOps } from './rangeDelete.js';
 import { flowOps } from './flow.js';
-import { assertSchema, assertUsableDoc, checkSchema, isInitialized, META_KEY, registryEmpty, SCHEMA_NAME, SCHEMA_VERSION, SchemaMismatchError, schemaVersion } from './doc/gate.js';
+import { assertSchema, checkSchema, isInitialized, META_KEY, registryEmpty, SCHEMA_NAME, SCHEMA_VERSION, SchemaMismatchError, schemaVersion } from './doc/gate.js';
 import { bindSeed, restore } from './doc/seed.js';
 import { applied, ref } from './doc/plan.js';
 import { docReads } from './doc/reads.js';
@@ -76,10 +76,9 @@ import { metaOps } from './doc/meta.js';
 import { contentOps } from './doc/content.js';
 // ── schema manifest and gate (`doc/gate.ts`) ────────────────────────────
 export { SCHEMA };
-export { assertSchema, assertUsableDoc, checkSchema, isInitialized, META_KEY, registryEmpty, SCHEMA_NAME, SCHEMA_VERSION, SchemaMismatchError, schemaVersion };
-export { UnsupportedDocError } from './doc/gate.js';
+export { assertSchema, checkSchema, isInitialized, META_KEY, registryEmpty, SCHEMA_NAME, SCHEMA_VERSION, SchemaMismatchError, schemaVersion };
 export { SEED_ORIGIN } from './doc/seed.js';
-export { EdytorDocDisposedError } from './doc/funnel.js';
+export { DocumentDestroyedError } from './doc/funnel.js';
 export { DEFAULT_HISTORY_LIMIT } from './doc/history.js';
 /**
  * The per-doc facade factory over the engine `Y` (the editor's documents
@@ -94,9 +93,6 @@ export const docFacade = (Y, layers) => {
     const { init, seed } = bindSeed(Y, BA);
     return (doc, config = {}) => {
         keepingReplaced(doc);
-        // Document-boundary check — foreign (v13-engine) and legacy-schema docs
-        // fail fast here rather than inside the runs view (see assertUsableDoc).
-        assertUsableDoc(doc);
         setMarkEdges(doc, config.markEdge ?? (() => undefined));
         const roleOf = config.roleOf ?? (() => undefined);
         const defaultType = config.defaultType ?? 'paragraph';
@@ -135,7 +131,7 @@ export const docFacade = (Y, layers) => {
         const base = { Y, doc, runsView, roles, roleOf, rendersContentOf };
         const reads = { ...base, ...docReads(base) };
         const shape = { ...reads, ...docCapability(reads) };
-        const { blockJSON, view, blockTypeOf, blockDataOf, docData, dataItemIds, childrenIds, positionOf, pathOf, ancestorsOf, slotOf, isVoid, isIsland, isLines, islandOf, insideIsland, isLayout, isLayoutItem, order, compare, next, previous, displayLength, contentItems, hasBlock, live } = reads;
+        const { blockJSON, view, blockTypeOf, blockDataOf, docData, dataItemIds, dataPreview, childrenIds, positionOf, pathOf, ancestorsOf, slotOf, isVoid, isIsland, isLines, islandOf, insideIsland, isLayout, isLayoutItem, order, compare, next, previous, displayLength, contentItems, hasBlock, live } = reads;
         const { canPlace, fits, nestParent, canMerge, defaultChild } = shape;
         const funnel = writeFunnel({ ...reads, BA, config });
         const { write, apply } = funnel;
@@ -262,6 +258,7 @@ export const docFacade = (Y, layers) => {
             blockDataOf: byRef(blockDataOf),
             docData,
             dataItemIds,
+            dataPreview,
             /**
              * Compact per-block attribution (`{createdBy, contributors,
              * lastChangedBy}`), or `undefined` for unauthored/system blocks.

package/dist/crdt/index.d.ts

@@ -62,7 +62,7 @@ export type { YDoc, YUndoManager, YTransaction } from './engine-api.js';
 export { type EdytorSync, type EdytorSyncPayload, type EdytorSyncCleanup, type IndexeddbSyncOptions, type WebsocketSync, type WebsocketSyncOptions, type ProviderStack, type PrefetchOptions, type PrefetchResult, type LastUpdatedOptions } from './providers/index.js';
 export { SyncRefusedError } from './providers/room.js';
 export { Awareness, type AwarenessDoc, type AwarenessStates, type AwarenessUpdate, type MetaClientState } from './protocols/awareness.js';
-export { SchemaMismatchError, UndecodableUpdateError, UnsupportedDocError } from './admission.js';
+export { SchemaMismatchError, UndecodableUpdateError } from './admission.js';
 export { type DocumentAttribution, type AttributionActor, type ActorProfile, type AttributionController } from './attribution/index.js';
 export { type ActorId, type BlockAttribution } from './attribution/index.js';
 import type { EngineApi, YDoc } from './engine-api.js';
@@ -280,6 +280,12 @@ export declare const bindCrdt: (Y: EngineApi) => {
             blockDataOf: (id: string) => Record<string, unknown> | undefined;
             docData: () => import("./doc/types.js").JsonObj;
             dataItemIds: (target: import("./edytor-doc.js").DataTarget, path: readonly string[]) => string[];
+            dataPreview: (target: import("./edytor-doc.js").DataTarget, pending: readonly import("./data.js").DataPatch[]) => {
+                data: {
+                    [x: string]: unknown;
+                };
+                ids: (path: readonly string[]) => string[];
+            } | null;
             blockAttribution: (id: string) => import("./index.js").BlockAttribution | undefined;
             crdtId: (id: string) => string | null;
             resolveBlock: (id: string) => import("./engine-api.js").EngineNode | null;
@@ -577,7 +583,7 @@ export declare const bindCrdt: (Y: EngineApi) => {
                 off<NAME extends "refused" | "status" | "failed" | "schema-mismatch" | "message-error" | "protocol-mismatch" | "synced" | "connection-close" | "connection-error" | "saved" | "permission-denied" | "expired" | "unreachable">(name: NAME, f: import("./protocol.js").WebsocketProviderEvents[NAME]): void;
             };
         };
-        watchComments: (server: string, roomName: string, listener: (message: import("./protocol.js").CommentMessage) => void) => (() => void);
+        watchComments: (server: string | null, roomName: string, listener: (message: import("./protocol.js").CommentMessage) => void) => (() => void);
         storeState: (idbPersistence: {
             db: IDBDatabase | null;
             name: string;
@@ -626,4 +632,4 @@ export declare const bindCrdt: (Y: EngineApi) => {
 };
 export type Crdt = ReturnType<typeof bindCrdt>;
 export type { EngineApi, EngineDoc, EngineNode, EngineTransaction, EngineItemRef, YNode, YItem } from './engine-api.js';
-export { EdytorDocDisposedError, DEFAULT_HISTORY_LIMIT } from './edytor-doc.js';
+export { DEFAULT_HISTORY_LIMIT } from './edytor-doc.js';

package/dist/crdt/index.js

@@ -101,7 +101,7 @@ export { Awareness } from './protocols/awareness.js';
 // every content-entry path crosses). The gates themselves
 // (`assertAdmission`, `inspectAdmission`, …) are diagnostics vocabulary:
 // `edytor/protocol`.
-export { SchemaMismatchError, UndecodableUpdateError, UnsupportedDocError } from './admission.js';
+export { SchemaMismatchError, UndecodableUpdateError } from './admission.js';
 // ── 5 · Attribution (read surface) ─────────────────────────────────────
 //
 // `document.attribution` hands back a `DocumentAttribution` — compact
@@ -145,4 +145,4 @@ export const bindCrdt = (Y) => {
 // The facade's disposal error and the history's default depth belong
 // to the document; the frame contract, message types and codecs are
 // `edytor/protocol`.
-export { EdytorDocDisposedError, DEFAULT_HISTORY_LIMIT } from './edytor-doc.js';
+export { DEFAULT_HISTORY_LIMIT } from './edytor-doc.js';

package/dist/crdt/operations.d.ts

@@ -149,4 +149,4 @@ export interface DocumentOperations extends DocumentWrites, DocumentReads {
 /** Every write of `DocumentWrites`: what a view dispatches under the same names (`edytor.insertBlocks(…)`). */
 export declare const DOCUMENT_WRITES: readonly ["insertBlocks", "moveBlocks", "nestBlock", "unNestBlock", "unNestBlocks", "liftOut", "wrapInLayout", "placeBeside", "splitBlock", "mergeBlocks", "mergeBackward", "mergeForward", "deleteBlock", "deleteBlocks", "setBlock", "setBlockType", "patchData", "duplicateBlock", "insertText", "deleteText", "formatRange", "clearMarks", "insertInline", "removeInline", "deleteRange", "replaceRange", "insertFlow"];
 /** Every name of `DocumentOperations`, for the document's own members (`EdytorDocument`). */
-export declare const DOCUMENT_OPERATIONS: readonly ["insertBlocks", "moveBlocks", "nestBlock", "unNestBlock", "unNestBlocks", "liftOut", "wrapInLayout", "placeBeside", "splitBlock", "mergeBlocks", "mergeBackward", "mergeForward", "deleteBlock", "deleteBlocks", "setBlock", "setBlockType", "patchData", "duplicateBlock", "insertText", "deleteText", "formatRange", "clearMarks", "insertInline", "removeInline", "deleteRange", "replaceRange", "insertFlow", "toJSON", "docData", "dataItemIds", "project", "blockJSON", "childrenIds", "parentOf", "ancestorsOf", "positionOf", "pathOf", "blockTypeOf", "blockDataOf", "blockText", "contentItems", "displayLength", "runs", "hasBlock", "isVisibleBlock", "listBlockIds", "blockAttribution", "isVoid", "isIsland", "isLines", "islandOf", "insideIsland", "isLayout", "isLayoutItem", "besideAt", "isTable", "isTableRow", "isTableCell", "tableOf", "tableColumns", "tableGrid", "order", "compare", "next", "previous", "canPlace", "canMerge", "fits", "nestParent", "landingOf", "anchorAt", "resolveAnchor", "prepare", "apply", "compose", "transact", "onChange", "version"];
+export declare const DOCUMENT_OPERATIONS: readonly ["insertBlocks", "moveBlocks", "nestBlock", "unNestBlock", "unNestBlocks", "liftOut", "wrapInLayout", "placeBeside", "splitBlock", "mergeBlocks", "mergeBackward", "mergeForward", "deleteBlock", "deleteBlocks", "setBlock", "setBlockType", "patchData", "duplicateBlock", "insertText", "deleteText", "formatRange", "clearMarks", "insertInline", "removeInline", "deleteRange", "replaceRange", "insertFlow", "toJSON", "docData", "dataItemIds", "dataPreview", "project", "blockJSON", "childrenIds", "parentOf", "ancestorsOf", "positionOf", "pathOf", "blockTypeOf", "blockDataOf", "blockText", "contentItems", "displayLength", "runs", "hasBlock", "isVisibleBlock", "listBlockIds", "blockAttribution", "isVoid", "isIsland", "isLines", "islandOf", "insideIsland", "isLayout", "isLayoutItem", "besideAt", "isTable", "isTableRow", "isTableCell", "tableOf", "tableColumns", "tableGrid", "order", "compare", "next", "previous", "canPlace", "canMerge", "fits", "nestParent", "landingOf", "anchorAt", "resolveAnchor", "prepare", "apply", "compose", "transact", "onChange", "version"];

package/dist/crdt/operations.js

@@ -34,6 +34,7 @@ export const DOCUMENT_OPERATIONS = [
     'toJSON',
     'docData',
     'dataItemIds',
+    'dataPreview',
     'project',
     'blockJSON',
     'childrenIds',

package/dist/crdt/props.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Properties: the deep proxy behind `block.data`, `atom.data`,
+ * `edytor.data` and `document.data` (SyncedStore's feel, one small module).
+ * It is sugar over the one write path: every mutation is a data patch
+ * handed to `write`, which is the `patchData` operation (dispatched on a
+ * view, raw on a bare document).
+ *
+ * A read goes to `read()` every time (the live source), so a reactive
+ * reader of `block.data.title` re-runs when anyone changes it, and a key a
+ * peer deletes is gone. Plain objects read as nested proxies, arrays as
+ * array proxies, everything else as the raw value; a proxy is cached per
+ * path, so its identity is stable. An object or array held in an array
+ * item is that item's (its path names the item by id, from `ids`): it
+ * stays on its item wherever peers move it, so `{#each list as item (item)}`
+ * keeps a row on its item; once the item is removed, its writes are
+ * refused. A key is a path segment as `keySegment` writes it.
+ *
+ * Writes, each the patch of only what it changes (per-leaf storage, so
+ * concurrent edits of other keys and items merge): `obj.key = v`,
+ * `arr[i] = v` and `delete obj.key` patch that path; `push`, `pop`,
+ * `shift`, `unshift`, `splice` and `length` are one `splice` (the items
+ * kept keep their ids), `sort` and `reverse` one `order` (the items move),
+ * `fill` and `copyWithin` writes of the items they change. Assigning a
+ * value equal to the one there writes nothing. `JSON.stringify` and
+ * `$state.snapshot` read plain JSON through it.
+ */
+import { type DataPatch } from './data.js';
+type Json = Record<string, unknown>;
+export declare const propsProxy: <T extends object = Json>(read: () => Json, write: (ops: DataPatch[]) => void, 
+/** The ids of the items of the array at a path (`facade.dataItemIds`). */
+ids?: (path: readonly string[]) => string[]) => T;
+export {};