edytor 1.0.0 → 3.0.0

package/dist/cloudflare/routeDocumentSocket.js

@@ -28,6 +28,50 @@ import { CLOSE, validRoomId } from '../crdt/providers/room.js';
 import { COMMENTS_HEADER, HISTORY_HEADER, HISTORY_KEY_HEADER, IDENTITY_HEADERS, PROBE_HEADER, closedSocket } from './room/shared.js';
 import { parseReplica } from './room/access.js';
 import { MAX_COMMENT_REQUEST_BYTES } from './room/comments.js';
+/** The CORS headers `options.cors` gives an answer to `request` (none: `null`). */
+const corsHeaders = (request, options) => {
+    const cors = options?.cors;
+    const origin = request.headers.get('Origin');
+    if (!cors || origin === null || !originAllowed(request, options))
+        return null;
+    const headers = new Headers();
+    if (options?.allowedOrigins === undefined) {
+        headers.set('Access-Control-Allow-Origin', '*');
+        return headers;
+    }
+    headers.set('Access-Control-Allow-Origin', origin);
+    headers.set('Vary', 'Origin');
+    if (typeof cors === 'object' && cors.credentials === true)
+        headers.set('Access-Control-Allow-Credentials', 'true');
+    return headers;
+};
+/**
+ * One HTTP route with `options.cors`: a preflight answered here, every other
+ * answer given its CORS headers (a `101` upgrade passes as it is).
+ */
+const withCors = async (request, options, route) => {
+    const cors = options?.cors;
+    if (cors && request.method === 'OPTIONS' && request.headers.has('Origin')) {
+        const headers = corsHeaders(request, options);
+        if (headers === null)
+            return new Response('origin not allowed', { status: 403 });
+        headers.set('Access-Control-Allow-Methods', 'GET, POST');
+        headers.set('Access-Control-Allow-Headers', request.headers.get('Access-Control-Request-Headers') ?? 'Content-Type');
+        headers.set('Access-Control-Max-Age', String((typeof cors === 'object' ? cors.maxAge : undefined) ?? 600));
+        return new Response(null, { status: 204, headers });
+    }
+    const response = await route();
+    const headers = corsHeaders(request, options);
+    if (headers === null || response.status === 101)
+        return response;
+    const merged = new Headers(response.headers);
+    headers.forEach((value, name) => merged.set(name, value));
+    return new Response(response.body, {
+        status: response.status,
+        statusText: response.statusText,
+        headers: merged
+    });
+};
 /** Is `request`'s `Origin` one `options` allows (no `Origin`, or no list: yes)? */
 const originAllowed = (request, options) => {
     const allowed = options?.allowedOrigins;
@@ -109,6 +153,9 @@ const identityHeaders = (identity) => {
  * `404` (the room keeps no history), `405` (another method).
  */
 export async function routeDocumentHistory(request, rooms, documentId, authorize, options) {
+    return withCors(request, options, () => routeHistory(request, rooms, documentId, authorize, options));
+}
+async function routeHistory(request, rooms, documentId, authorize, options) {
     const query = new URL(request.url).searchParams;
     const op = request.method === 'GET'
         ? query.has('key')
@@ -191,6 +238,9 @@ const bodyWithin = async (request, max) => {
  * comment bytes full), `429` (the user past the room's comment rate).
  */
 export async function routeDocumentComments(request, rooms, documentId, authorize, options) {
+    return withCors(request, options, () => routeComments(request, rooms, documentId, authorize, options));
+}
+async function routeComments(request, rooms, documentId, authorize, options) {
     const op = request.method === 'GET' ? 'list' : request.method === 'POST' ? 'post' : null;
     if (op === null)
         return new Response('method not allowed', { status: 405 });
@@ -215,6 +265,9 @@ export async function routeDocumentComments(request, rooms, documentId, authoriz
         .fetch(new Request(request.url, { method: op === 'post' ? 'POST' : 'GET', headers, body }));
 }
 export async function routeDocumentSocket(request, rooms, documentId, authorize, options) {
+    return withCors(request, options, () => routeSocket(request, rooms, documentId, authorize, options));
+}
+async function routeSocket(request, rooms, documentId, authorize, options) {
     // The probes: a plain GET, authorized like a dial, answered with JSON or
     // an HTTP status — `lastUpdated` and `snapshot` (the document).
     const query = new URL(request.url).searchParams;

package/dist/collaboration/awarenessSelection.d.ts

@@ -56,6 +56,20 @@ export type AwarenessLike = {
     getLocalState: () => Record<string, unknown> | null;
     setLocalState: (state: Record<string, unknown> | null) => void;
 };
+/**
+ * The awareness a view's presence writer reads and writes: its own state,
+ * every client's state, and the `change` event (the real `Awareness`).
+ */
+export type PresenceSource = AwarenessLike & {
+    clientID: number;
+    getStates: () => Map<number, Record<string, unknown>>;
+    on: (name: 'change', listener: () => void) => void;
+    off: (name: 'change', listener: () => void) => void;
+};
+/** Another person online: their client id and the fields of their `user` state (`name`, `color`, …), the document's actor name and colour when `user` has none. */
+export type PresencePeer = EdytorAwarenessUser & Record<string, unknown> & {
+    clientId: number;
+};
 /** A client-local presence key, minted once by the view that owns the entry. */
 export declare const mintPresenceKey: () => string;
 /**
@@ -90,9 +104,16 @@ export declare class PresenceWriter {
     private readonly awareness;
     private readonly key;
     throttle: number;
-    constructor(awareness: AwarenessLike, key: string, { share, throttle }?: PresenceOptions);
+    constructor(awareness: PresenceSource, key: string, { share, throttle }?: PresenceOptions);
     get share(): PresenceShare;
     set share(share: PresenceShare);
+    /**
+     * The other people online: every client but this one, by client id,
+     * each `{ clientId, name?, color?, …user }`. Reactive: read in markup or
+     * an effect, it updates when someone joins, leaves or changes their
+     * state; the awareness listener exists only while something reads it.
+     */
+    get peers(): PresencePeer[];
     /** Publish `payload` (the full selection; `focus`: the block holding its focus) as this view shares it, within the throttle. */
     write(payload: PresenceSelection | null, focus?: string | null): void;
     /** Remove this view's entry and drop a held write (the view's teardown). */

package/dist/collaboration/awarenessSelection.js

@@ -1,4 +1,19 @@
 import { isRecord, jsonEquals } from '../utils/json.js';
+import { createSubscriber } from 'svelte/reactivity';
+/** Every client but this one, by client id. */
+const readPeers = (awareness) => [...awareness.getStates()]
+    .filter(([clientId]) => clientId !== awareness.clientID)
+    .sort(([a], [b]) => a - b)
+    .map(([clientId, state]) => {
+    const actor = isRecord(state.actor) ? state.actor : {};
+    const user = isRecord(state.user) ? state.user : {};
+    const peer = { ...user, clientId };
+    if (peer.name === undefined && typeof actor.name === 'string')
+        peer.name = actor.name;
+    if (peer.color === undefined && typeof actor.color === 'string')
+        peer.color = actor.color;
+    return peer;
+});
 let presenceKeys = 0;
 /** A client-local presence key, minted once by the view that owns the entry. */
 export const mintPresenceKey = () => `view-${++presenceKeys}`;
@@ -50,6 +65,21 @@ export class PresenceWriter {
     #held;
     /** The last payload and focused block handed in, kept so a share change republishes at once. */
     #latest = [null, null];
+    /** The peers while someone reads them reactively (`undefined`: recompute). */
+    #peers;
+    #watched = false;
+    #subscribe = createSubscriber((update) => {
+        const changed = () => {
+            this.#peers = undefined;
+            update();
+        };
+        this.#watched = true;
+        this.awareness.on('change', changed);
+        return () => {
+            this.awareness.off('change', changed);
+            [this.#watched, this.#peers] = [false, undefined];
+        };
+    });
     constructor(awareness, key, { share = 'caret', throttle = DEFAULT_PRESENCE_THROTTLE } = {}) {
         this.awareness = awareness;
         this.key = key;
@@ -65,6 +95,18 @@ export class PresenceWriter {
         this.#share = share;
         this.write(...this.#latest);
     }
+    /**
+     * The other people online: every client but this one, by client id,
+     * each `{ clientId, name?, color?, …user }`. Reactive: read in markup or
+     * an effect, it updates when someone joins, leaves or changes their
+     * state; the awareness listener exists only while something reads it.
+     */
+    get peers() {
+        this.#subscribe();
+        if (!this.#watched)
+            return readPeers(this.awareness);
+        return (this.#peers ??= readPeers(this.awareness));
+    }
     /** Publish `payload` (the full selection; `focus`: the block holding its focus) as this view shares it, within the throttle. */
     write(payload, focus = null) {
         this.#latest = [payload, focus];

package/dist/collaboration/comments/client.d.ts

@@ -48,7 +48,7 @@ export type CommentsClientOptions = {
     /**
      * The websocket sync's server URL (the `server` of `<Edytor>` or
      * `createWebsocketSync`), whose socket hears the room's changes. Default:
-     * `server` read as `ws:`/`wss:`.
+     * every websocket sync of the same room on the page, whatever its URL.
      */
     socket?: string;
     /** Query parameters sent with each request (a token): an object, or a function read at every request. */

package/dist/collaboration/comments/client.js

@@ -34,7 +34,7 @@ export const createCommentsClient = (options) => {
     assertRoomId(options.room);
     const server = options.server.replace(/\/+$/, '');
     const base = `${server.replace(/^ws/, 'http')}/${encodeURIComponent(options.room)}`;
-    const socket = (options.socket ?? server.replace(/^http/, 'ws')).replace(/\/+$/, '');
+    const socket = options.socket?.replace(/\/+$/, '') ?? null;
     const request = async (method, body) => {
         const url = new URL(base);
         const params = typeof options.params === 'function' ? options.params() : options.params;

package/dist/collaboration/remoteSelection.js

@@ -42,8 +42,8 @@ const getCaretRect = (point, origin, editor) => {
     const range = (point.node.ownerDocument ?? editor.ownerDocument).createRange();
     range.setStart(point.node, point.offset);
     range.collapse(true);
-    const rect = typeof range.getBoundingClientRect === 'function' ? range.getBoundingClientRect() : null;
-    if (rect && (rect.width || rect.height)) {
+    const rect = range.getBoundingClientRect();
+    if (rect.width || rect.height) {
         return toRemoteRect(rect, origin);
     }
     return getFallbackRect(point, origin, editor);
@@ -71,7 +71,7 @@ const getSelectionRects = (start, end, origin, editor) => {
         (end.text.node && renderSkipped(end.text.node))) {
         return [getFallbackRect(start, origin, editor)];
     }
-    const clientRects = typeof range.getClientRects === 'function' ? Array.from(range.getClientRects()) : [];
+    const clientRects = Array.from(range.getClientRects());
     const seen = new Set();
     const rects = clientRects
         .filter((rect) => rect.width || rect.height)

package/dist/components/Block.svelte

@@ -35,7 +35,9 @@
 	const previewViewOf = (cell: PreviewCell): BlockView => ({
 		id: cell.id,
 		type: cell.type,
-		data: cell.data ?? {},
+		get data() {
+			return structuredClone(cell.data ?? {});
+		},
 		selected: false,
 		focused: false,
 		handle: undefined,

package/dist/components/Edytor.svelte

@@ -5,11 +5,9 @@
 	import { Edytor as EdytorClass, useEdytor } from '../edytor.svelte.js';
 	import {
 		SyncRefusedError,
-		type Awareness,
 		type DocChange,
 		type DocumentActor,
-		type EdytorDocument,
-		type YDoc
+		type EdytorDocument
 	} from '../crdt/index.js';
 	import { CLOSE, validRoomId } from '../crdt/providers/room.js';
 	import type { EdytorSync, WebsocketSyncOptions } from '../collaboration/index.js';
@@ -23,21 +21,15 @@
 	import { brandOf } from '../plugins/brand.js';
 	import type { PartialLabels } from '../labels.js';
 	import { createRichTextPlugin } from '../plugins/richtext/RichTextPlugin.svelte';
-	import { createArrowMovePlugin } from '../plugins/arrowMove/arrowMove.js';
-	import { createImagePlugin } from '../plugins/image/ImagePlugin.svelte';
 	import { createSuggestionsPlugin } from '../plugins/suggestions/suggestionsPlugin.js';
 
 	/**
 	 * The plugins every view has unless it lists one of their kind (or sets
 	 * `defaultPlugins={false}`), after the app's so its kinds and keys win:
-	 * block moves, the suggestion UI, the image kind, then rich text.
+	 * the suggestion UI, then rich text (an app lists `createArrowMovePlugin()`
+	 * for block moves and `createImagePlugin({ upload })` for images itself).
 	 */
-	const DEFAULTS = [
-		createArrowMovePlugin(),
-		createSuggestionsPlugin(),
-		createImagePlugin(),
-		createRichTextPlugin()
-	];
+	const DEFAULTS = [createSuggestionsPlugin(), createRichTextPlugin()];
 	const withDefaults = (plugins: Plugin[] = []): Plugin[] => {
 		const listed = new Set(plugins.map(brandOf));
 		return [...plugins, ...DEFAULTS.filter((plugin) => !listed.has(brandOf(plugin)))];
@@ -67,7 +59,7 @@
 
 	export type EdytorProps = {
 		plugins?: Plugin[];
-		/** Add rich text, arrow moves, the suggestion UI and images unless `plugins` lists them (default `true`). */
+		/** Add rich text and the suggestion UI unless `plugins` lists them (default `true`). */
 		defaultPlugins?: boolean;
 		class?: string;
 		/** The root textbox's accessible name (or name it with `aria-labelledby`). */
@@ -81,8 +73,6 @@
 		edytor?: EdytorClass;
 		/** The assembled document this view renders (see `crdt/document.ts`). */
 		document?: EdytorDocument;
-		doc?: YDoc;
-		awareness?: Awareness;
 		/** The local author (id, name, color) of the document this view owns: attribution and presence. */
 		actor?: DocumentActor;
 		/**
@@ -96,6 +86,13 @@
 		 * the connection.
 		 */
 		readonly?: boolean;
+		/**
+		 * Let users nest blocks (default `false`): Tab and Shift+Tab nest and
+		 * unnest, drops and handle keys may place a block inside another. Off,
+		 * Tab is left to the browser and no gesture nests; containers keep their
+		 * bodies. Read once.
+		 */
+		allowNesting?: boolean;
 		/** Chords (`mod+s`, `shift+alt+enter`) the view binds before plugins and built-ins. Read once. */
 		hotkeys?: Partial<Record<HotKeyCombination, HotKey>>;
 		/** After every commit that changed the visible document: a `JSONDoc`, the type `value` takes. */
@@ -186,8 +183,8 @@
 		edytor = $bindable(),
 		// Aliased so the DOM `document` global keeps working in this scope.
 		document: edytorDocument,
-		doc,
 		readonly = false,
+		allowNesting = false,
 		value = defaultValue,
 		hotkeys,
 		sync,
@@ -198,7 +195,6 @@
 		onSyncRefused,
 		requireHydration,
 		snapshot,
-		awareness,
 		actor,
 		presence,
 		onChange,
@@ -216,10 +212,9 @@
 
 	const initialEdytorOptions = untrack(() => ({
 		readonly,
+		allowNesting,
 		plugins: defaultPlugins ? withDefaults(userPlugins) : userPlugins,
 		document: edytorDocument,
-		doc,
-		awareness,
 		actor,
 		requireHydration,
 		hotkeys,
@@ -291,7 +286,7 @@
 		}
 	});
 
-	// The component owns the Edytor — release its doc/awareness/facade/
+	// The component owns the Edytor — release its facade/
 	// undo-manager listeners so a shared doc doesn't retain dead mounts.
 	// `onDestroy` also runs after a server render: a view-owned document
 	// (and its awareness timer) must not outlive the request.
@@ -408,6 +403,29 @@
 {/if}
 
 <style>
+	/* Where a drag lands, a block handle's or files' from outside (`DropIndicator`):
+	 * the bar (4px) and the nest backdrop, placed in the overlay and shown
+	 * (`data-shown`) by the drag; their look is a theme's (`edytor/themes/notion.css`). */
+	:global([data-edytor-drop-indicator]),
+	:global([data-edytor-drop-backdrop]) {
+		position: absolute;
+		pointer-events: none;
+	}
+
+	:global([data-edytor-drop-indicator]) {
+		z-index: 100;
+		box-sizing: border-box;
+		height: 4px;
+	}
+
+	:global([data-edytor-drop-backdrop]) {
+		z-index: 99;
+	}
+
+	:global([data-edytor-drop-backdrop]:not([data-shown='true'])) {
+		visibility: hidden;
+	}
+
 	/*
 	 * Room below the last block, where a press puts the caret in a trailing
 	 * paragraph (`nav.trailing.press`): `--edytor-trailing-space`. No

package/dist/components/Edytor.svelte.d.ts

@@ -1,5 +1,5 @@
 import { Edytor as EdytorClass, useEdytor } from '../edytor.svelte.js';
-import { SyncRefusedError, type Awareness, type DocChange, type DocumentActor, type EdytorDocument, type YDoc } from '../crdt/index.js';
+import { SyncRefusedError, type DocChange, type DocumentActor, type EdytorDocument } from '../crdt/index.js';
 import type { EdytorSync, WebsocketSyncOptions } from '../collaboration/index.js';
 import { type PresenceOptions } from '../collaboration/awarenessSelection.js';
 export { EdytorClass as EdytorContext, useEdytor };
@@ -7,7 +7,7 @@ import type { Plugin } from '../plugins.js';
 import type { PartialLabels } from '../labels.js';
 export type EdytorProps = {
     plugins?: Plugin[];
-    /** Add rich text, arrow moves, the suggestion UI and images unless `plugins` lists them (default `true`). */
+    /** Add rich text and the suggestion UI unless `plugins` lists them (default `true`). */
     defaultPlugins?: boolean;
     class?: string;
     /** The root textbox's accessible name (or name it with `aria-labelledby`). */
@@ -21,8 +21,6 @@ export type EdytorProps = {
     edytor?: EdytorClass;
     /** The assembled document this view renders (see `crdt/document.ts`). */
     document?: EdytorDocument;
-    doc?: YDoc;
-    awareness?: Awareness;
     /** The local author (id, name, color) of the document this view owns: attribution and presence. */
     actor?: DocumentActor;
     /**
@@ -36,6 +34,13 @@ export type EdytorProps = {
      * the connection.
      */
     readonly?: boolean;
+    /**
+     * Let users nest blocks (default `false`): Tab and Shift+Tab nest and
+     * unnest, drops and handle keys may place a block inside another. Off,
+     * Tab is left to the browser and no gesture nests; containers keep their
+     * bodies. Read once.
+     */
+    allowNesting?: boolean;
     /** Chords (`mod+s`, `shift+alt+enter`) the view binds before plugins and built-ins. Read once. */
     hotkeys?: Partial<Record<HotKeyCombination, HotKey>>;
     /** After every commit that changed the visible document: a `JSONDoc`, the type `value` takes. */

package/dist/components/InlineBlock.svelte

@@ -28,7 +28,7 @@
 			return part.type;
 		},
 		get data() {
-			return block ? block.data : (part.data ?? {});
+			return block ? block.data : structuredClone(part.data ?? {});
 		},
 		get selected() {
 			return block?.selected ?? false;

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/data.d.ts

@@ -73,6 +73,16 @@ export declare const readData: (node: EngineNode) => JsonObj | undefined;
  * in `node`'s data, in order; `[]` where no array is.
  */
 export declare const itemIds: (node: EngineNode, path: readonly string[]) => string[];
+/**
+ * `node`'s data as it reads once `patches` are applied (nothing written),
+ * with the ids of the array items at a path (`itemIds`): an item a patch
+ * makes has no id yet (`''`), so a later patch names it by index.
+ * `null` when a patch fits no value.
+ */
+export declare const previewData: (node: EngineNode | undefined, patches: readonly DataPatch[]) => {
+    data: JsonObj;
+    ids: (path: readonly string[]) => string[];
+} | null;
 /** `data` with `patches` applied in order, as a fresh value (a root patch replaces it); `null` when one fits no value. */
 export declare const applyPatch: (data: JsonObj, patches: readonly DataPatch[]) => JsonObj | null;
 /**

package/dist/crdt/data.js

@@ -354,8 +354,9 @@ export const readData = (node) => valueOf(treeOf(leavesOf(node)));
  * The ids of the items of the array at `path` (keys, item indexes or ids)
  * in `node`'s data, in order; `[]` where no array is.
  */
-export const itemIds = (node, path) => {
-    let t = treeOf(leavesOf(node));
+export const itemIds = (node, path) => idsAt(treeOf(leavesOf(node)), path);
+const idsAt = (root, path) => {
+    let t = root;
     for (const k of path)
         if (t && isArr(open(t))) {
             const item = itemAt(itemsOf(t), k);
@@ -365,6 +366,23 @@ export const itemIds = (node, path) => {
             t = itemish(k) ? undefined : t?.k.get(enc(segmentKey(k)));
     return t ? itemsOf(open(t)).map(({ id }) => id) : [];
 };
+/**
+ * `node`'s data as it reads once `patches` are applied (nothing written),
+ * with the ids of the array items at a path (`itemIds`): an item a patch
+ * makes has no id yet (`''`), so a later patch names it by index.
+ * `null` when a patch fits no value.
+ */
+export const previewData = (node, patches) => {
+    const base = node ? leavesOf(node) : new Map();
+    const root = treeOf(base);
+    if (!patches.every((p) => edits().apply(root, p)))
+        return null;
+    const known = new Set([...base.keys()].flatMap((key) => key.split('/')));
+    return {
+        data: valueOf(root) ?? {},
+        ids: (path) => idsAt(root, path).map((id) => (known.has(`${id}#`) ? id : ''))
+    };
+};
 /** `data` with `patches` applied in order, as a fresh value (a root patch replaces it); `null` when one fits no value. */
 export const applyPatch = (data, patches) => {
     const root = treeOf(dataLeaves(data));

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();