@pm-cm/yjs 0.0.1

package/README.md

@@ -0,0 +1,164 @@
+# @pm-cm/yjs
+
+Collaborative split-editor sync between ProseMirror and CodeMirror over Yjs.
+
+Extends `@pm-cm/core` with real-time collaboration: synchronizes a ProseMirror `XmlFragment` and a CodeMirror-friendly `Y.Text` through a single Yjs `Doc`, with collaborative cursor support. The serialization format is pluggable — you provide `serialize` and `parse` functions.
+
+## Install
+
+```
+npm install @pm-cm/yjs @pm-cm/core yjs y-prosemirror y-protocols prosemirror-model prosemirror-state prosemirror-view
+```
+
+## Usage
+
+### 1. Document sync (Bridge)
+
+Keeps `Y.Text` (CodeMirror) and `Y.XmlFragment` (ProseMirror) in sync within a single Yjs doc.
+
+```ts
+import { Doc } from 'yjs'
+import { createYjsBridge } from '@pm-cm/yjs'
+
+const doc = new Doc()
+
+const bridge = createYjsBridge({
+  doc,
+  sharedText: doc.getText('text'),
+  sharedProseMirror: doc.getXmlFragment('prosemirror'),
+  schema,      // ProseMirror Schema
+  serialize,   // (doc: Node) => string
+  parse,       // (text: string, schema: Schema) => Node
+})
+
+// bootstrapResult tells you how the bridge initialized
+console.log(bridge.bootstrapResult.source) // 'text' | 'prosemirror' | 'both-match' | 'empty' | 'initial'
+
+// After a ProseMirror edit, push to the CodeMirror side:
+bridge.syncToSharedText(editorView.state.doc)
+
+// CodeMirror → ProseMirror direction is automatic (Y.Text observer).
+
+bridge.dispose() // cleanup
+```
+
+### 2. Collaborative editing with cursor sync
+
+`createCollabPlugins` returns ProseMirror plugins for Yjs sync, remote cursors, and undo. Pass `serialize` and `cursorSync: true` to additionally enable PM ↔ CM cursor synchronization.
+
+```ts
+import { EditorState } from 'prosemirror-state'
+import { EditorView } from 'prosemirror-view'
+import { Awareness } from 'y-protocols/awareness'
+import { Doc } from 'yjs'
+import { createYjsBridge, createCollabPlugins, syncCmCursor } from '@pm-cm/yjs'
+
+const doc = new Doc()
+const awareness = new Awareness(doc)
+const xmlFragment = doc.getXmlFragment('prosemirror')
+
+const bridge = createYjsBridge({
+  doc,
+  sharedText: doc.getText('text'),
+  sharedProseMirror: xmlFragment,
+  schema,
+  serialize,
+  parse,
+})
+
+// Setup ProseMirror with collab + cursor sync plugins
+const { plugins, doc: pmDoc } = createCollabPlugins(schema, {
+  sharedProseMirror: xmlFragment,
+  awareness,
+  serialize,
+  cursorSync: true, // opt-in (default false)
+  bridge,           // auto-wires PM doc changes → Y.Text
+})
+
+const view = new EditorView(element, {
+  state: EditorState.create({ schema, doc: pmDoc, plugins }),
+})
+
+// PM cursor → awareness is automatic (plugin handles it).
+
+// CM cursor → awareness: one line.
+syncCmCursor(view, cmOffset)
+```
+
+## API
+
+### Bridge
+
+| Export | Description |
+|---|---|
+| `createYjsBridge(config, options?)` | Create a bridge that keeps `Y.Text` (CM) and `Y.XmlFragment` (PM) in sync. Throws if shared types are detached or belong to a different `Y.Doc` |
+| `replaceSharedText(sharedText, next, origin, normalize?)` | Minimal-diff replace of `Y.Text` content. Returns `ReplaceTextResult` |
+| `replaceSharedProseMirror(doc, fragment, text, origin, config)` | Replace `Y.XmlFragment` from serialized text. Returns `ReplaceProseMirrorResult` |
+
+### Bridge Sync Plugin
+
+| Export | Description |
+|---|---|
+| `createBridgeSyncPlugin(bridge, options?)` | ProseMirror plugin that auto-wires PM doc changes → `bridge.syncToSharedText()` |
+| `bridgeSyncPluginKey` | `PluginKey` for the bridge sync plugin |
+
+### Collab Plugins
+
+| Export | Description |
+|---|---|
+| `createCollabPlugins(schema, options)` | Returns `{ plugins, doc, mapping }`. Bundles `ySyncPlugin`, `yCursorPlugin`, `yUndoPlugin`, and optionally cursor sync. `cursorSync` defaults to `false`. **Throws** if `cursorSync: true` but `serialize` is not provided |
+| `createAwarenessProxy(awareness, cursorFieldName?)` | Proxy that suppresses y-prosemirror's auto cursor management |
+
+### Cursor Sync
+
+| Export | Description |
+|---|---|
+| `createCursorSyncPlugin(options)` | ProseMirror plugin: PM selection → awareness (auto), CM offset → awareness (via meta) |
+| `syncCmCursor(view, anchor, head?, onWarning?)` | Dispatch a CM cursor offset (or range) to the cursor sync plugin. Input values are floored to non-negative integers |
+| `cursorSyncPluginKey` | `PluginKey<CursorSyncState>` for reading plugin state |
+
+### Cursor Mapping (re-exported from @pm-cm/core)
+
+| Export | Description |
+|---|---|
+| `buildCursorMap(doc, serialize, locate?)` | Build a PM position ↔ CM offset mapping |
+| `cursorMapLookup(map, pmPos)` | PM position → CM offset |
+| `reverseCursorMapLookup(map, cmOffset)` | CM offset → PM position |
+
+### Constants
+
+| Export | Value |
+|---|---|
+| `ORIGIN_TEXT_TO_PM` | `'bridge:text-to-prosemirror'` |
+| `ORIGIN_PM_TO_TEXT` | `'bridge:prosemirror-to-text'` |
+| `ORIGIN_INIT` | `'bridge:init'` |
+
+### Types
+
+| Type | Description |
+|---|---|
+| `YjsBridgeConfig` | Config for `createYjsBridge` — uses `sharedProseMirror` (capital M) |
+| `YjsBridgeHandle` | Handle returned by `createYjsBridge` — includes `bootstrapResult` |
+| `YjsBridgeOptions` | Options for `createYjsBridge` (`initialText?`, `prefer?`) |
+| `BootstrapResult` | `{ source: 'text' \| 'prosemirror' \| 'both-match' \| 'empty' \| 'initial', parseError?: boolean }` |
+| `CollabPluginsOptions` | Options for `createCollabPlugins` — uses `sharedProseMirror` (capital M) |
+| `CursorSyncPluginOptions` | Options for `createCursorSyncPlugin` |
+| `CursorSyncState` | Plugin state: `{ pendingCm, mappedTextOffset }` |
+| `ReplaceResult` | Union: `ReplaceTextResult \| ReplaceProseMirrorResult` |
+| `ReplaceTextResult` | `{ ok: true } \| { ok: false; reason: 'unchanged' \| 'detached' }` |
+| `ReplaceProseMirrorResult` | `{ ok: true } \| { ok: false; reason: 'parse-error' \| 'detached' }` |
+| `YCursorPluginOpts` | Typed options for `yCursorPlugin` (`awarenessStateFilter`, `cursorBuilder`, `selectionBuilder`, `getSelection`) |
+| `YUndoPluginOpts` | Typed options for `yUndoPlugin` (`protectedNodes`, `trackedOrigins`, `undoManager`) |
+| `ProseMirrorMapping` | `Map<AbstractType<unknown>, Node \| Node[]>` — Yjs ↔ PM node mapping |
+| `ErrorCode` | `'parse-error' \| 'serialize-error'` — re-exported from `@pm-cm/core` |
+| `ErrorEvent` | `{ code: ErrorCode, message: string, cause: unknown }` — structured error event |
+| `OnError` | `(event: ErrorEvent) => void` — re-exported from `@pm-cm/core` |
+| `WarningCode` | `'bridge-already-wired' \| 'sync-failed' \| 'ysync-plugin-missing' \| 'cursor-sync-not-installed'` |
+| `WarningEvent` | `{ code: WarningCode, message: string }` — structured warning event |
+| `OnWarning` | `(event: WarningEvent) => void` — warning handler callback |
+| `Serialize`, `Parse`, `Normalize` | Re-exported from `@pm-cm/core` |
+| `TextSegment`, `CursorMap`, `LocateText` | Re-exported from `@pm-cm/core` |
+
+### Compatibility
+
+This package depends on internal state shapes of `y-prosemirror` (specifically `ySyncPluginKey` state and transaction meta). These internals are accessed via runtime type guards that degrade gracefully (returning `null` / logging a warning) when the expected shape is absent. The tested and supported version is `y-prosemirror@^1.3.7`.

package/dist/index.cjs

@@ -0,0 +1,515 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  ORIGIN_INIT: () => ORIGIN_INIT,
+  ORIGIN_PM_TO_TEXT: () => ORIGIN_PM_TO_TEXT,
+  ORIGIN_TEXT_TO_PM: () => ORIGIN_TEXT_TO_PM,
+  bridgeSyncPluginKey: () => bridgeSyncPluginKey,
+  buildCursorMap: () => import_core2.buildCursorMap,
+  createAwarenessProxy: () => createAwarenessProxy,
+  createBridgeSyncPlugin: () => createBridgeSyncPlugin,
+  createCollabPlugins: () => createCollabPlugins,
+  createCursorSyncPlugin: () => createCursorSyncPlugin,
+  createYjsBridge: () => createYjsBridge,
+  cursorMapLookup: () => import_core2.cursorMapLookup,
+  cursorSyncPluginKey: () => cursorSyncPluginKey,
+  replaceSharedProseMirror: () => replaceSharedProseMirror,
+  replaceSharedText: () => replaceSharedText,
+  reverseCursorMapLookup: () => import_core2.reverseCursorMapLookup,
+  syncCmCursor: () => syncCmCursor
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/bridge.ts
+var import_y_prosemirror = require("y-prosemirror");
+
+// src/types.ts
+var ORIGIN_TEXT_TO_PM = "bridge:text-to-prosemirror";
+var ORIGIN_PM_TO_TEXT = "bridge:prosemirror-to-text";
+var ORIGIN_INIT = "bridge:init";
+
+// src/bridge.ts
+var defaultNormalize = (s) => s.replace(/\r\n?/g, "\n");
+var defaultOnError = (event) => console.error(`[bridge] ${event.code}: ${event.message}`, event.cause);
+function replaceSharedText(sharedText, next, origin, normalize = defaultNormalize) {
+  if (!sharedText.doc) {
+    return { ok: false, reason: "detached" };
+  }
+  const normalized = normalize(next);
+  const current = sharedText.toString();
+  if (current === normalized) {
+    return { ok: false, reason: "unchanged" };
+  }
+  let start = 0;
+  const minLen = Math.min(current.length, normalized.length);
+  while (start < minLen && current.charCodeAt(start) === normalized.charCodeAt(start)) {
+    start++;
+  }
+  let endCurrent = current.length;
+  let endNext = normalized.length;
+  while (endCurrent > start && endNext > start && current.charCodeAt(endCurrent - 1) === normalized.charCodeAt(endNext - 1)) {
+    endCurrent--;
+    endNext--;
+  }
+  sharedText.doc.transact(() => {
+    const deleteCount = endCurrent - start;
+    if (deleteCount > 0) {
+      sharedText.delete(start, deleteCount);
+    }
+    const insertStr = normalized.slice(start, endNext);
+    if (insertStr.length > 0) {
+      sharedText.insert(start, insertStr);
+    }
+  }, origin);
+  return { ok: true };
+}
+function replaceSharedProseMirror(doc, fragment, text, origin, config) {
+  if (!fragment.doc) {
+    return { ok: false, reason: "detached" };
+  }
+  if (fragment.doc !== doc) {
+    throw new Error("fragment belongs to a different Y.Doc than the provided doc");
+  }
+  const normalize = config.normalize ?? defaultNormalize;
+  const onError = config.onError ?? defaultOnError;
+  let nextDoc;
+  try {
+    nextDoc = config.parse(normalize(text), config.schema);
+  } catch (error) {
+    onError({ code: "parse-error", message: "failed to parse text into ProseMirror document", cause: error });
+    return { ok: false, reason: "parse-error" };
+  }
+  doc.transact(() => {
+    (0, import_y_prosemirror.prosemirrorToYXmlFragment)(nextDoc, fragment);
+  }, origin);
+  return { ok: true };
+}
+function createYjsBridge(config, options) {
+  const {
+    doc,
+    sharedText,
+    sharedProseMirror,
+    schema,
+    serialize,
+    parse
+  } = config;
+  const normalize = config.normalize ?? defaultNormalize;
+  const onError = config.onError ?? defaultOnError;
+  if (!sharedText.doc) {
+    throw new Error("sharedText is not attached to any Y.Doc");
+  }
+  if (sharedText.doc !== doc) {
+    throw new Error("sharedText belongs to a different Y.Doc than the provided doc");
+  }
+  if (!sharedProseMirror.doc) {
+    throw new Error("sharedProseMirror is not attached to any Y.Doc");
+  }
+  if (sharedProseMirror.doc !== doc) {
+    throw new Error("sharedProseMirror belongs to a different Y.Doc than the provided doc");
+  }
+  let lastBridgedText = null;
+  const syncTextToProsemirror = (origin) => {
+    const text = normalize(sharedText.toString());
+    if (lastBridgedText === text) {
+      return true;
+    }
+    const result = replaceSharedProseMirror(doc, sharedProseMirror, text, origin, {
+      schema,
+      parse,
+      normalize,
+      onError
+    });
+    if (result.ok) {
+      lastBridgedText = text;
+    }
+    return result.ok;
+  };
+  const sharedProseMirrorToText = (fragment) => {
+    try {
+      const pmDoc = (0, import_y_prosemirror.yXmlFragmentToProseMirrorRootNode)(fragment, schema);
+      return normalize(serialize(pmDoc));
+    } catch (error) {
+      onError({ code: "serialize-error", message: "failed to convert ProseMirror fragment to text", cause: error });
+      return null;
+    }
+  };
+  const bootstrap = () => {
+    const text = normalize(sharedText.toString());
+    const hasText = text.length > 0;
+    const hasProsemirror = sharedProseMirror.length > 0;
+    if (!hasText && !hasProsemirror) {
+      const initial = options?.initialText ?? "";
+      if (initial.length > 0) {
+        const initResult = replaceSharedProseMirror(doc, sharedProseMirror, initial, ORIGIN_INIT, {
+          schema,
+          parse,
+          normalize,
+          onError
+        });
+        if (!initResult.ok) {
+          return { source: "initial", parseError: true };
+        }
+        const pmDoc = (0, import_y_prosemirror.yXmlFragmentToProseMirrorRootNode)(sharedProseMirror, schema);
+        const canonicalText = serialize(pmDoc);
+        replaceSharedText(sharedText, canonicalText, ORIGIN_INIT, normalize);
+        lastBridgedText = normalize(canonicalText);
+        return { source: "initial" };
+      }
+      return { source: "empty" };
+    }
+    if (hasText && !hasProsemirror) {
+      const ok = syncTextToProsemirror(ORIGIN_INIT);
+      return { source: "text", ...!ok && { parseError: true } };
+    }
+    if (!hasText && hasProsemirror) {
+      const textFromProsemirror = sharedProseMirrorToText(sharedProseMirror);
+      if (textFromProsemirror !== null) {
+        replaceSharedText(sharedText, textFromProsemirror, ORIGIN_INIT, normalize);
+        lastBridgedText = normalize(textFromProsemirror);
+        return { source: "prosemirror" };
+      }
+      return { source: "prosemirror", parseError: true };
+    }
+    const prosemirrorText = sharedProseMirrorToText(sharedProseMirror);
+    if (prosemirrorText === null) {
+      const fallbackText = hasText ? text : options?.initialText ?? "";
+      let parseError = false;
+      if (fallbackText.length > 0) {
+        replaceSharedText(sharedText, fallbackText, ORIGIN_INIT, normalize);
+        const fallbackResult = replaceSharedProseMirror(doc, sharedProseMirror, fallbackText, ORIGIN_INIT, {
+          schema,
+          parse,
+          normalize,
+          onError
+        });
+        if (!fallbackResult.ok) parseError = true;
+      }
+      return { source: "text", ...parseError && { parseError: true } };
+    }
+    if (prosemirrorText !== text) {
+      const prefer = options?.prefer ?? "text";
+      if (prefer === "prosemirror") {
+        replaceSharedText(sharedText, prosemirrorText, ORIGIN_INIT, normalize);
+        lastBridgedText = normalize(prosemirrorText);
+        return { source: "prosemirror" };
+      } else {
+        const ok = syncTextToProsemirror(ORIGIN_INIT);
+        return { source: "text", ...!ok && { parseError: true } };
+      }
+    } else {
+      lastBridgedText = text;
+      return { source: "both-match" };
+    }
+  };
+  const textObserver = (_, transaction) => {
+    if (transaction.origin === ORIGIN_PM_TO_TEXT || transaction.origin === ORIGIN_INIT) {
+      return;
+    }
+    syncTextToProsemirror(ORIGIN_TEXT_TO_PM);
+  };
+  const bootstrapResult = bootstrap();
+  sharedText.observe(textObserver);
+  return {
+    bootstrapResult,
+    syncToSharedText(doc2) {
+      const text = serialize(doc2);
+      const result = replaceSharedText(sharedText, text, ORIGIN_PM_TO_TEXT, normalize);
+      if (result.ok || result.reason === "unchanged") {
+        lastBridgedText = normalize(text);
+      }
+      return result;
+    },
+    isYjsSyncChange(tr) {
+      const meta = tr.getMeta(import_y_prosemirror.ySyncPluginKey);
+      return typeof meta === "object" && meta !== null && "isChangeOrigin" in meta && meta.isChangeOrigin === true;
+    },
+    dispose() {
+      sharedText.unobserve(textObserver);
+    }
+  };
+}
+
+// src/awareness-proxy.ts
+function createAwarenessProxy(awareness, cursorField = "pmCursor") {
+  return new Proxy(awareness, {
+    get(target, prop, receiver) {
+      if (prop === "getLocalState") {
+        return () => {
+          const state = target.getLocalState();
+          return state ? { ...state, [cursorField]: null } : state;
+        };
+      }
+      if (prop === "setLocalStateField") {
+        return (field, value2) => {
+          if (field === cursorField) return;
+          target.setLocalStateField(field, value2);
+        };
+      }
+      const value = Reflect.get(target, prop, receiver);
+      return typeof value === "function" ? value.bind(target) : value;
+    }
+  });
+}
+
+// src/collab-plugins.ts
+var import_y_prosemirror3 = require("y-prosemirror");
+
+// src/bridge-sync-plugin.ts
+var import_prosemirror_state = require("prosemirror-state");
+var bridgeSyncPluginKey = new import_prosemirror_state.PluginKey("pm-cm-bridge-sync");
+var wiredBridges = /* @__PURE__ */ new WeakSet();
+var defaultOnWarning = (event) => console.warn(`[pm-cm] ${event.code}: ${event.message}`);
+function createBridgeSyncPlugin(bridge, options = {}) {
+  const warn = options.onWarning ?? defaultOnWarning;
+  if (wiredBridges.has(bridge)) {
+    warn({ code: "bridge-already-wired", message: "this bridge is already wired to another plugin instance" });
+  }
+  wiredBridges.add(bridge);
+  return new import_prosemirror_state.Plugin({
+    key: bridgeSyncPluginKey,
+    state: {
+      init() {
+        return { needsSync: false };
+      },
+      apply(tr, _prev) {
+        if (!tr.docChanged) return { needsSync: false };
+        if (bridge.isYjsSyncChange(tr)) return { needsSync: false };
+        return { needsSync: true };
+      }
+    },
+    view() {
+      return {
+        update(view) {
+          const state = bridgeSyncPluginKey.getState(view.state);
+          if (state?.needsSync) {
+            const result = bridge.syncToSharedText(view.state.doc);
+            if (!result.ok) {
+              if (result.reason === "detached") {
+                options.onSyncFailure?.(result, view);
+                warn({ code: "sync-failed", message: `bridge sync failed: ${result.reason}` });
+              }
+            }
+          }
+        },
+        destroy() {
+          wiredBridges.delete(bridge);
+        }
+      };
+    }
+  });
+}
+
+// src/cursor-sync-plugin.ts
+var import_prosemirror_state2 = require("prosemirror-state");
+var import_y_prosemirror2 = require("y-prosemirror");
+var import_yjs = require("yjs");
+var import_core = require("@pm-cm/core");
+var cursorSyncPluginKey = new import_prosemirror_state2.PluginKey("pm-cm-cursor-sync");
+function getYSyncState(view) {
+  const raw = import_y_prosemirror2.ySyncPluginKey.getState(view.state);
+  if (!raw) return null;
+  if (typeof raw === "object" && "type" in raw && raw.type && "binding" in raw && raw.binding && typeof raw.binding === "object" && "mapping" in raw.binding && raw.binding.mapping instanceof Map) {
+    return raw;
+  }
+  return null;
+}
+function toRelativePosition(view, pmPos) {
+  const ySyncState = getYSyncState(view);
+  if (!ySyncState) return null;
+  return (0, import_y_prosemirror2.absolutePositionToRelativePosition)(
+    pmPos,
+    ySyncState.type,
+    ySyncState.binding.mapping
+    // eslint-disable-line @typescript-eslint/no-explicit-any -- y-prosemirror internal mapping type
+  );
+}
+function broadcastPmCursor(awareness, cursorFieldName, view, pmAnchor, pmHead) {
+  const relAnchor = toRelativePosition(view, pmAnchor);
+  const relHead = toRelativePosition(view, pmHead);
+  if (relAnchor === null || relHead === null) return false;
+  awareness.setLocalStateField(cursorFieldName, { anchor: relAnchor, head: relHead });
+  return true;
+}
+function broadcastTextCursor(awareness, cmCursorFieldName, sharedText, textAnchor, textHead) {
+  const len = sharedText.length;
+  const clamp = (v) => Math.max(0, Math.min(v, len));
+  const relAnchor = (0, import_yjs.createRelativePositionFromTypeIndex)(sharedText, clamp(textAnchor));
+  const relHead = (0, import_yjs.createRelativePositionFromTypeIndex)(sharedText, clamp(textHead));
+  awareness.setLocalStateField(cmCursorFieldName, { anchor: relAnchor, head: relHead });
+}
+var defaultOnWarning2 = (event) => console.warn(`[pm-cm] ${event.code}: ${event.message}`);
+function createCursorSyncPlugin(options) {
+  const { awareness, serialize, locate, sharedText } = options;
+  const warn = options.onWarning ?? defaultOnWarning2;
+  const cursorFieldName = options.cursorFieldName ?? "pmCursor";
+  const cmCursorFieldName = options.cmCursorFieldName ?? "cursor";
+  let warnedSyncPluginMissing = false;
+  let cachedMap = null;
+  let cachedMapDoc = null;
+  function getOrBuildMap(doc) {
+    if (cachedMapDoc !== doc || !cachedMap) {
+      cachedMap = (0, import_core.buildCursorMap)(doc, serialize, locate);
+      cachedMapDoc = doc;
+    }
+    return cachedMap;
+  }
+  return new import_prosemirror_state2.Plugin({
+    key: cursorSyncPluginKey,
+    state: {
+      init() {
+        return { pendingCm: null, mappedTextOffset: null };
+      },
+      apply(tr, prev, _oldState, newState) {
+        const cmMeta = tr.getMeta(cursorSyncPluginKey);
+        if (cmMeta) {
+          return { pendingCm: cmMeta, mappedTextOffset: prev.mappedTextOffset };
+        }
+        let mappedTextOffset = prev.mappedTextOffset;
+        if (tr.selectionSet || tr.docChanged) {
+          const map = getOrBuildMap(newState.doc);
+          mappedTextOffset = (0, import_core.cursorMapLookup)(map, newState.selection.anchor);
+        }
+        return {
+          pendingCm: prev.pendingCm !== null ? null : prev.pendingCm,
+          mappedTextOffset
+        };
+      }
+    },
+    view() {
+      return {
+        update(view, prevState) {
+          const pluginState = cursorSyncPluginKey.getState(view.state);
+          const prevPluginState = cursorSyncPluginKey.getState(prevState);
+          if (pluginState?.pendingCm != null && pluginState.pendingCm !== prevPluginState?.pendingCm) {
+            const map = getOrBuildMap(view.state.doc);
+            const pmAnchor = (0, import_core.reverseCursorMapLookup)(map, pluginState.pendingCm.anchor);
+            const pmHead = (0, import_core.reverseCursorMapLookup)(map, pluginState.pendingCm.head);
+            if (pmAnchor !== null && pmHead !== null) {
+              const ok = broadcastPmCursor(awareness, cursorFieldName, view, pmAnchor, pmHead);
+              if (!ok && !warnedSyncPluginMissing) {
+                warnedSyncPluginMissing = true;
+                warn({ code: "ysync-plugin-missing", message: "ySyncPlugin state not available \u2014 cursor broadcast skipped" });
+              }
+            }
+            if (sharedText) {
+              broadcastTextCursor(
+                awareness,
+                cmCursorFieldName,
+                sharedText,
+                pluginState.pendingCm.anchor,
+                pluginState.pendingCm.head
+              );
+            }
+            return;
+          }
+          if (view.hasFocus() && (view.state.selection !== prevState.selection || view.state.doc !== prevState.doc)) {
+            const { anchor, head } = view.state.selection;
+            const ok = broadcastPmCursor(awareness, cursorFieldName, view, anchor, head);
+            if (!ok && !warnedSyncPluginMissing) {
+              warnedSyncPluginMissing = true;
+              warn({ code: "ysync-plugin-missing", message: "ySyncPlugin state not available \u2014 cursor broadcast skipped" });
+            }
+            if (sharedText) {
+              const map = getOrBuildMap(view.state.doc);
+              const textAnchor = (0, import_core.cursorMapLookup)(map, anchor);
+              const textHead = (0, import_core.cursorMapLookup)(map, head);
+              if (textAnchor !== null && textHead !== null) {
+                broadcastTextCursor(awareness, cmCursorFieldName, sharedText, textAnchor, textHead);
+              }
+            }
+          }
+        }
+      };
+    }
+  });
+}
+function syncCmCursor(view, anchor, head, onWarning) {
+  if (!cursorSyncPluginKey.getState(view.state)) {
+    (onWarning ?? defaultOnWarning2)({ code: "cursor-sync-not-installed", message: "cursor sync plugin is not installed on this EditorView" });
+    return;
+  }
+  const sanitize = (v) => Math.max(0, Math.floor(v));
+  view.dispatch(
+    view.state.tr.setMeta(cursorSyncPluginKey, {
+      anchor: sanitize(anchor),
+      head: sanitize(head ?? anchor)
+    })
+  );
+}
+
+// src/collab-plugins.ts
+function createCollabPlugins(schema, options) {
+  const cursorFieldName = options.cursorFieldName ?? "pmCursor";
+  const enableCursorSync = options.cursorSync ?? false;
+  const { sharedProseMirror } = options;
+  if (enableCursorSync && !options.serialize) {
+    throw new Error("createCollabPlugins: cursorSync requires serialize to be provided");
+  }
+  const { doc, mapping: rawMapping } = (0, import_y_prosemirror3.initProseMirrorDoc)(sharedProseMirror, schema);
+  const mapping = rawMapping;
+  const pmAwareness = enableCursorSync ? createAwarenessProxy(options.awareness, cursorFieldName) : options.awareness;
+  const plugins = [
+    (0, import_y_prosemirror3.ySyncPlugin)(sharedProseMirror, { mapping: rawMapping }),
+    (0, import_y_prosemirror3.yCursorPlugin)(pmAwareness, options.yCursorPluginOpts ?? {}, cursorFieldName),
+    (0, import_y_prosemirror3.yUndoPlugin)(options.yUndoPluginOpts)
+  ];
+  if (options.bridge) {
+    plugins.push(createBridgeSyncPlugin(options.bridge, { onWarning: options.onWarning }));
+  }
+  if (enableCursorSync && options.serialize) {
+    plugins.push(
+      createCursorSyncPlugin({
+        awareness: options.awareness,
+        serialize: options.serialize,
+        cursorFieldName,
+        cmCursorFieldName: options.cmCursorFieldName,
+        locate: options.locate,
+        sharedText: options.sharedText,
+        onWarning: options.onWarning
+      })
+    );
+  }
+  return { plugins, doc, mapping };
+}
+
+// src/index.ts
+var import_core2 = require("@pm-cm/core");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ORIGIN_INIT,
+  ORIGIN_PM_TO_TEXT,
+  ORIGIN_TEXT_TO_PM,
+  bridgeSyncPluginKey,
+  buildCursorMap,
+  createAwarenessProxy,
+  createBridgeSyncPlugin,
+  createCollabPlugins,
+  createCursorSyncPlugin,
+  createYjsBridge,
+  cursorMapLookup,
+  cursorSyncPluginKey,
+  replaceSharedProseMirror,
+  replaceSharedText,
+  reverseCursorMapLookup,
+  syncCmCursor
+});
+//# sourceMappingURL=index.cjs.map