edytor 2.0.0 → 3.0.0

package/dist/crdt/admission.d.ts

@@ -4,14 +4,12 @@
  * Every way content enters an {@link EdytorDocument} crosses the same
  * gate here, in the same order, with the same refusal semantics:
  *
- *   1. **`assertUsableDoc`** — is this a v14 engine doc at all
- *      ({@link UnsupportedDocError} `'foreign'`)?
- *   2. **`assertSchema`** — does the committed schema manifest allow
+ *   1. **`assertSchema`** — does the committed schema manifest allow
  *      this build to own the doc ({@link SchemaMismatchError}:
  *      `'unversioned'` content with no version stamp, `'unsupported'`
  *      version this build cannot speak, `'foreign'` manifest naming
  *      another schema)?
- *   3. **Verdict** — `'fresh'` (registry empty — seeding is legal) or
+ *   2. **Verdict** — `'fresh'` (registry empty — seeding is legal) or
  *      `'initialized'` (supported schema content present — assert and
  *      adopt, never seed).
  *
@@ -59,10 +57,10 @@
  * readiness transition, and a pending document never writes or
  * broadcasts a bootstrap block.
  */
-import { assertSchema, assertUsableDoc, checkSchema, isInitialized, registryEmpty, schemaVersion, SchemaMismatchError, UnsupportedDocError } from './edytor-doc.js';
+import { assertSchema, checkSchema, isInitialized, registryEmpty, schemaVersion, SchemaMismatchError } from './edytor-doc.js';
 import type { SchemaProblem } from './edytor-doc.js';
 import type { EngineApi, EngineDoc, YDoc } from './engine-api.js';
-export { assertSchema, assertUsableDoc, checkSchema, isInitialized, registryEmpty, schemaVersion, SchemaMismatchError, UnsupportedDocError };
+export { assertSchema, checkSchema, isInitialized, registryEmpty, schemaVersion, SchemaMismatchError };
 export type { SchemaProblem };
 /**
  * What an admitted doc carries — the `sync()` readiness decision:
@@ -83,7 +81,7 @@ export type AdmissionResult = {
     verdict: AdmissionVerdict;
 } | {
     admitted: false;
-    error: UnsupportedDocError | SchemaMismatchError;
+    error: SchemaMismatchError;
 };
 /**
  * Raised when a candidate update cannot even be decoded or integrated —
@@ -102,9 +100,6 @@ export declare class UndecodableUpdateError extends Error {
  * The document-level admission gate — runs the ordered checks and throws
  * the typed refusal:
  *
- * - {@link UnsupportedDocError} `'foreign'` — not a v14 engine doc
- *   (foreign roots/engines may still attach *content* later; this is
- *   about doc shape);
  * - {@link SchemaMismatchError} `'unversioned' | 'unsupported' |
  *   'foreign'` — a schema claim this build cannot own.
  *

package/dist/crdt/admission.js

@@ -4,14 +4,12 @@
  * Every way content enters an {@link EdytorDocument} crosses the same
  * gate here, in the same order, with the same refusal semantics:
  *
- *   1. **`assertUsableDoc`** — is this a v14 engine doc at all
- *      ({@link UnsupportedDocError} `'foreign'`)?
- *   2. **`assertSchema`** — does the committed schema manifest allow
+ *   1. **`assertSchema`** — does the committed schema manifest allow
  *      this build to own the doc ({@link SchemaMismatchError}:
  *      `'unversioned'` content with no version stamp, `'unsupported'`
  *      version this build cannot speak, `'foreign'` manifest naming
  *      another schema)?
- *   3. **Verdict** — `'fresh'` (registry empty — seeding is legal) or
+ *   2. **Verdict** — `'fresh'` (registry empty — seeding is legal) or
  *      `'initialized'` (supported schema content present — assert and
  *      adopt, never seed).
  *
@@ -59,11 +57,11 @@
  * readiness transition, and a pending document never writes or
  * broadcasts a bootstrap block.
  */
-import { assertSchema, assertUsableDoc, checkSchema, isInitialized, registryEmpty, schemaVersion, SchemaMismatchError, UnsupportedDocError } from './edytor-doc.js';
+import { assertSchema, checkSchema, isInitialized, registryEmpty, schemaVersion, SchemaMismatchError } from './edytor-doc.js';
 import { asEngineDoc } from './structs.js';
 import { keepingReplaced } from './incarnations.js';
 // ── shared gate vocabulary (one doorway for document + transport layers) ──
-export { assertSchema, assertUsableDoc, checkSchema, isInitialized, registryEmpty, schemaVersion, SchemaMismatchError, UnsupportedDocError };
+export { assertSchema, checkSchema, isInitialized, registryEmpty, schemaVersion, SchemaMismatchError };
 /**
  * Raised when a candidate update cannot even be decoded or integrated —
  * refused before the schema question is ever asked. Distinct from the
@@ -86,9 +84,6 @@ export class UndecodableUpdateError extends Error {
  * The document-level admission gate — runs the ordered checks and throws
  * the typed refusal:
  *
- * - {@link UnsupportedDocError} `'foreign'` — not a v14 engine doc
- *   (foreign roots/engines may still attach *content* later; this is
- *   about doc shape);
  * - {@link SchemaMismatchError} `'unversioned' | 'unsupported' |
  *   'foreign'` — a schema claim this build cannot own.
  *
@@ -98,7 +93,6 @@ export class UndecodableUpdateError extends Error {
  * readiness decision.
  */
 export const assertAdmission = (doc, docName = 'document') => {
-    assertUsableDoc(doc);
     assertSchema(doc, docName);
     return isInitialized(doc) ? 'initialized' : 'fresh';
 };
@@ -112,7 +106,7 @@ export const inspectAdmission = (doc, docName = 'document') => {
         return { admitted: true, verdict: assertAdmission(doc, docName) };
     }
     catch (error) {
-        if (error instanceof UnsupportedDocError || error instanceof SchemaMismatchError) {
+        if (error instanceof SchemaMismatchError) {
             return { admitted: false, error };
         }
         throw error;

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

@@ -2,13 +2,14 @@ import type { BlockAttributionApi } from '../attribution/block.js';
 import type { EdytorDocConfig, OpResult, Prepared } from './types.js';
 import type { DocBase, DocReads } from './reads.js';
 /**
- * Raised when a mutating facade op runs after `dispose()` — disposal is
- * terminal for writes (reads stay dead-safe: a stale handle may still be
- * inspected while its document outlives the facade). The facade-level
- * counterpart of `DocumentDestroyedError` — kept in this module because a
- * bare `bindEdytorDoc` facade has no document layer above it.
+ * Raised when an operation runs against a torn-down document: every attach
+ * reference released, or its facade disposed (terminal for writes; reads
+ * stay dead-safe: a stale handle may still be inspected). Distinct from
+ * `DocumentNotReadyError`: destroyed is terminal, pending may still resolve.
+ * Kept in this module because a bare `bindEdytorDoc` facade has no document
+ * layer above it.
  */
-export declare class EdytorDocDisposedError extends Error {
+export declare class DocumentDestroyedError extends Error {
     constructor(service?: string);
 }
 /** What the write funnel writes with: the reads, the attribution writer and the facade's configuration. */

package/dist/crdt/doc/funnel.js

@@ -11,16 +11,17 @@ import { writeLeaves } from '../data.js';
 import { NOOP } from './plan.js';
 import { claimInto, deleteRange, formatRangeIn, insertIntoText } from '../text/model.js';
 /**
- * Raised when a mutating facade op runs after `dispose()` — disposal is
- * terminal for writes (reads stay dead-safe: a stale handle may still be
- * inspected while its document outlives the facade). The facade-level
- * counterpart of `DocumentDestroyedError` — kept in this module because a
- * bare `bindEdytorDoc` facade has no document layer above it.
+ * Raised when an operation runs against a torn-down document: every attach
+ * reference released, or its facade disposed (terminal for writes; reads
+ * stay dead-safe: a stale handle may still be inspected). Distinct from
+ * `DocumentNotReadyError`: destroyed is terminal, pending may still resolve.
+ * Kept in this module because a bare `bindEdytorDoc` facade has no document
+ * layer above it.
  */
-export class EdytorDocDisposedError extends Error {
+export class DocumentDestroyedError extends Error {
     constructor(service) {
-        super(`EdytorDoc${service ? `.${service}` : ''}: facade is disposed.`);
-        this.name = 'EdytorDocDisposedError';
+        super(`${service ?? 'document'}: the document is destroyed`);
+        this.name = 'DocumentDestroyedError';
     }
 }
 /** The write funnel of one facade. */
@@ -37,7 +38,7 @@ export const writeFunnel = (c) => {
     /** Mutation boundary — every facade write funnels through `write`. */
     const write = (fn) => {
         if (disposed) {
-            throw new EdytorDocDisposedError();
+            throw new DocumentDestroyedError();
         }
         config.assertWritable?.();
         return fn();

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/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:
@@ -641,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

@@ -5,7 +5,7 @@ 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';
@@ -18,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
@@ -926,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']>;

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';

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';
@@ -583,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;
@@ -632,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/protocol.d.ts

@@ -27,14 +27,14 @@
 export { bindCrdt, type Crdt, type EngineApi, type EngineDoc, type EngineNode, type EngineTransaction, type EngineItemRef, type YNode, type YItem, type YDoc, type YUndoManager, type YTransaction } from './index.js';
 export { SCHEMA_VERSION, META_KEY } from './edytor-doc.js';
 export { GENERATION, generationWord, frame, PROTOCOL_VERSION, GENERATION_RECORD, GenerationMismatchError, readProtocolVersion, type GenerationRecord } from './protocols/envelope.js';
-export { messageSync, messageAwareness, messageAuth, messageQueryAwareness, messageSaved, messageChunk, messageComments, MAX_FRAME_BYTES, chunkFrame, createChunkReader, ChunkLimitError, type ChunkReader, CLOSE } from './providers/room.js';
+export { messageSync, messageAwareness, messageAuth, messageQueryAwareness, messageSaved, messageChunk, messageComments, MAX_FRAME_BYTES, chunkFrame, createChunkReader, ChunkError, type ChunkReader, CLOSE } from './providers/room.js';
 export { messageYjsSyncStep1, messageYjsSyncStep2, messageYjsUpdate, type SyncProtocol } from './protocols/sync.js';
 export { messagePermissionDenied, messageReadOnly, writePermissionDenied, writeReadOnly } from './protocols/auth.js';
 export { commentsSubscribe, commentsSnapshot, commentsChange, writeCommentsSubscribe, writeCommentsSnapshot, writeCommentsChange, readCommentsMessage, type CommentChange, type CommentMessage, type CommentSnapshot, type CommentThread, type ThreadComment } from './protocols/comments.js';
 export { applyAwarenessUpdate, encodeAwarenessUpdate, readAwarenessEntries, writeAwarenessEntries, type AwarenessEntry } from './protocols/awareness.js';
 export { createDecoder, readVarUint, readVarUint8Array, type Decoder } from 'lib0-v14/decoding';
 export { writeVarUint8Array, type Encoder } from 'lib0-v14/encoding';
-export { assertAdmission, assertSchema, assertUsableDoc, checkSchema, inspectAdmission, isInitialized, registryEmpty, schemaVersion, SchemaMismatchError, UndecodableUpdateError, UnsupportedDocError, type AdmissionResult, type AdmissionVerdict, type SchemaProblem } from './admission.js';
+export { assertAdmission, assertSchema, checkSchema, inspectAdmission, isInitialized, registryEmpty, schemaVersion, SchemaMismatchError, UndecodableUpdateError, type AdmissionResult, type AdmissionVerdict, type SchemaProblem } from './admission.js';
 import type { ProviderStack } from './providers/index.js';
 export declare const IndexeddbPersistence: ProviderStack['IndexeddbPersistence'];
 export declare const WebsocketProvider: ProviderStack['WebsocketProvider'];

package/dist/crdt/protocol.js

@@ -30,7 +30,7 @@ export { bindCrdt } from './index.js';
 export { SCHEMA_VERSION, META_KEY } from './edytor-doc.js';
 export { GENERATION, generationWord, frame, PROTOCOL_VERSION, GENERATION_RECORD, GenerationMismatchError, readProtocolVersion } from './protocols/envelope.js';
 // ── Message types, acknowledgements and chunks ─────────────────────────
-export { messageSync, messageAwareness, messageAuth, messageQueryAwareness, messageSaved, messageChunk, messageComments, MAX_FRAME_BYTES, chunkFrame, createChunkReader, ChunkLimitError, CLOSE } from './providers/room.js';
+export { messageSync, messageAwareness, messageAuth, messageQueryAwareness, messageSaved, messageChunk, messageComments, MAX_FRAME_BYTES, chunkFrame, createChunkReader, ChunkError, CLOSE } from './providers/room.js';
 export { messageYjsSyncStep1, messageYjsSyncStep2, messageYjsUpdate } from './protocols/sync.js';
 export { messagePermissionDenied, messageReadOnly, writePermissionDenied, writeReadOnly } from './protocols/auth.js';
 export { commentsSubscribe, commentsSnapshot, commentsChange, writeCommentsSubscribe, writeCommentsSnapshot, writeCommentsChange, readCommentsMessage } from './protocols/comments.js';
@@ -46,7 +46,7 @@ export { writeVarUint8Array } from 'lib0-v14/encoding';
 // the matrix and the refusal-preserves-data contract). The errors they
 // throw are also exported from `edytor` and `edytor/crdt/edytor`, where a
 // `loadDocument` caller catches them.
-export { assertAdmission, assertSchema, assertUsableDoc, checkSchema, inspectAdmission, isInitialized, registryEmpty, schemaVersion, SchemaMismatchError, UndecodableUpdateError, UnsupportedDocError } from './admission.js';
+export { assertAdmission, assertSchema, checkSchema, inspectAdmission, isInitialized, registryEmpty, schemaVersion, SchemaMismatchError, UndecodableUpdateError } from './admission.js';
 // ── Raw providers ──────────────────────────────────────────────────────
 //
 // The classes `createIndexeddbSync`/`createWebsocketSync` construct, bound

package/dist/crdt/providers/index.d.ts

@@ -280,7 +280,7 @@ export declare const bindProviders: (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: 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;

package/dist/crdt/providers/room.d.ts

@@ -69,14 +69,15 @@ export declare const MAX_FRAME_BYTES: number;
  * receiver applies the reassembled frame only once `end` arrives.
  */
 export declare const chunkFrame: (whole: Uint8Array, maxFrameBytes?: number) => Uint8Array[];
-/** A chunk sequence announces a frame larger than its reader takes ({@link createChunkReader}). */
-export declare class ChunkLimitError extends Error {
-    readonly total: number;
-    readonly limit: number;
-    constructor(total: number, limit: number);
-}
-/** A chunk part or end with no sequence started (one lost, or never sent). */
-export declare class ChunkSequenceError extends Error {
+/**
+ * A chunk sequence its reader refuses ({@link createChunkReader}): one
+ * announcing a frame larger than the reader takes (`total` over `limit`),
+ * or a part or end with no sequence started (one lost, or never sent).
+ */
+export declare class ChunkError extends Error {
+    readonly total?: number | undefined;
+    readonly limit?: number | undefined;
+    constructor(total?: number | undefined, limit?: number | undefined);
 }
 /** A chunk reader ({@link createChunkReader}): feed it chunk bodies; `buffered` is what it holds. */
 export type ChunkReader = {
@@ -89,7 +90,7 @@ export type ChunkReader = {
  * each chunk frame's body (after the message type); it returns the whole
  * frame on `end`, `null` before. An out-of-order or oversized sequence
  * throws and resets; a sequence announcing more than `maxBytes` throws
- * {@link ChunkLimitError} at its start, before anything is buffered. A
+ * {@link ChunkError} at its start, before anything is buffered. A
  * sequence is assembled into ONE buffer of its announced size, allocated
  * at its start (`buffered`), never into parts copied at its end.
  * `admit(total)` is asked at each start, before that allocation: it may

package/dist/crdt/providers/room.js

@@ -92,26 +92,29 @@ export const chunkFrame = (whole, maxFrameBytes = MAX_FRAME_BYTES) => {
     frames.push(frame(messageChunk, (e) => encoding.writeVarUint(e, chunkEnd)));
     return frames;
 };
-/** A chunk sequence announces a frame larger than its reader takes ({@link createChunkReader}). */
-export class ChunkLimitError extends Error {
+/**
+ * A chunk sequence its reader refuses ({@link createChunkReader}): one
+ * announcing a frame larger than the reader takes (`total` over `limit`),
+ * or a part or end with no sequence started (one lost, or never sent).
+ */
+export class ChunkError extends Error {
     total;
     limit;
     constructor(total, limit) {
-        super(`chunked frame of ${total} bytes exceeds ${limit}`);
+        super(limit === undefined
+            ? 'chunk without a start'
+            : `chunked frame of ${total} bytes exceeds ${limit}`);
         this.total = total;
         this.limit = limit;
-        this.name = 'ChunkLimitError';
+        this.name = 'ChunkError';
     }
 }
-/** A chunk part or end with no sequence started (one lost, or never sent). */
-export class ChunkSequenceError extends Error {
-}
 /**
  * The receiving half of {@link chunkFrame}, one per connection: feed it
  * each chunk frame's body (after the message type); it returns the whole
  * frame on `end`, `null` before. An out-of-order or oversized sequence
  * throws and resets; a sequence announcing more than `maxBytes` throws
- * {@link ChunkLimitError} at its start, before anything is buffered. A
+ * {@link ChunkError} at its start, before anything is buffered. A
  * sequence is assembled into ONE buffer of its announced size, allocated
  * at its start (`buffered`), never into parts copied at its end.
  * `admit(total)` is asked at each start, before that allocation: it may
@@ -136,14 +139,14 @@ export const createChunkReader = (maxBytes = Infinity, admit = () => true) => {
                 reset();
                 const announced = decoding.readVarUint(decoder);
                 if (announced > maxBytes)
-                    throw new ChunkLimitError(announced, maxBytes);
+                    throw new ChunkError(announced, maxBytes);
                 whole = admit(announced) ? new Uint8Array(announced) : null;
                 total = announced;
                 open = true;
                 return null;
             }
             if (!open)
-                throw new ChunkSequenceError(`chunk ${kind} without a start`);
+                throw new ChunkError();
             if (kind === chunkPart) {
                 const bytes = decoding.readVarUint8Array(decoder);
                 if (received + bytes.length > total)

package/dist/crdt/providers/websocket.d.ts

@@ -228,5 +228,5 @@ export declare const bindWebsocketProvider: (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: WebsocketProviderEvents[NAME]): void;
         };
     };
-    watchComments: (server: string, roomName: string, listener: (message: CommentMessage) => void) => (() => void);
+    watchComments: (server: string | null, roomName: string, listener: (message: CommentMessage) => void) => (() => void);
 };