@kedataindo/docflow-core 0.0.71 → 0.0.73

package/dist/Collaboration-CGv9OZlB.d.cts

@@ -0,0 +1,109 @@
+import { AnyExtension } from '@tiptap/core';
+import { Awareness } from 'y-protocols/awareness';
+import { IndexeddbPersistence } from 'y-indexeddb';
+import { WebrtcProvider } from 'y-webrtc';
+import { WebsocketProvider } from 'y-websocket';
+import * as Y from 'yjs';
+
+interface AwarenessState {
+    clientId: number;
+    user: {
+        name: string;
+        color: string;
+    };
+    cursor?: {
+        from: number;
+        to: number;
+    } | null;
+    /**
+     * Phase 9 PR2 — *present* flag. False when the local user has navigated
+     * away from the editor route (the Yjs provider is still alive but the
+     * host has gated cursor emission off, per the §6 *\"TOC sidebar orphan
+     * wiring\"* / REST-heartbeat scope notes). Peers see this instantly
+     * via the awareness `change` event — far faster than the 15s REST
+     * heartbeat fallback. Defaults to true when the user is in the editor.
+     */
+    present: boolean;
+}
+interface CollaborationOptions {
+    room: string;
+    provider?: 'webrtc' | 'websocket';
+    websocketUrl?: string;
+    signaling?: string[];
+    user: {
+        name: string;
+        color: string;
+    };
+    onAwarenessChange?: (states: AwarenessState[]) => void;
+    initialStorageState?: Uint8Array;
+    /**
+     * Phase 9 PR2 — when false, the local user is treated as
+     * out-of-editor: their cursor field is nulled and `present` is false.
+     * Default is true (in editor). Toggle at runtime via
+     * `setLocalCursorEnabled()` returned from `createCollaboration`.
+     */
+    emitCursor?: boolean;
+    /**
+     * Phase 9 OF1 — when true, mirror the room's Y.Doc into IndexedDB
+     * (`docflow-<room>`) via y-indexeddb so edits survive offline and reload.
+     * Reconcile-on-reconnect is plain Yjs merge — no conflict resolution
+     * needed. The IndexedDB mirror is NEVER a seed source: the server (or the
+     * legacy-JSON seed path) still owns initial state; the mirror only
+     * contributes local offline edits via the normal Yjs update exchange.
+     */
+    offline?: boolean;
+}
+interface CollaborationSetup {
+    ydoc: Y.Doc;
+    provider: WebrtcProvider | WebsocketProvider | null;
+    awareness: Awareness;
+    /**
+     * Phase 9 OF1 — y-indexeddb persistence instance, present only when
+     * `options.offline` is true. Exposed so hosts/tests can `await
+     * persistence.whenSynced` before asserting the mirror contents. Do not
+     * use it as a seed source.
+     */
+    persistence?: IndexeddbPersistence;
+    /**
+     * Issue #117 — resolves after BOTH the offline mirror (if `offline`) AND
+     * the provider's first sync (if `websocket`) have completed. Hosts MUST
+     * `await setup.whenReady` before binding the editor, otherwise the
+     * TipTap view can render against the IndexedDB cache before the
+     * authoritative server state arrives, briefly showing — and on a
+     * disconnected peer potentially re-broadcasting — nodes the server has
+     * since deleted. Resolves immediately when neither side applies.
+     */
+    whenReady: Promise<void>;
+    destroy: () => void;
+    /**
+     * Phase 9 PR2 — toggle the local cursor emission + present flag.
+     * Pass `false` when the editor route unmounts, `true` when it remounts.
+     * Triggers an awareness `change` event so peers see the leave/rejoin
+     * instantly (no REST-heartbeat lag).
+     */
+    setLocalCursorEnabled: (enabled: boolean) => void;
+}
+/**
+ * Build the collaboration runtime for a room.
+ *
+ * Async by design (issue fe-aktifai#230): the network sync providers are
+ * imported lazily — `y-webrtc` only when `provider: 'webrtc'`, `y-websocket`
+ * only when `provider: 'websocket'`, `y-indexeddb` only when `offline` is
+ * set. The main docflow barrel therefore never pulls the collab stack into
+ * bundles where collaboration is disabled; hosts that opt in simply
+ * `await createCollaboration(...)` and pass the resulting `CollaborationSetup`
+ * to `createEditor` / `<DocsEditor>`.
+ */
+declare function createCollaboration(options: CollaborationOptions): Promise<CollaborationSetup>;
+/**
+ * Build the TipTap extensions that bind an editor to a collaboration room.
+ *
+ * Takes a prebuilt `CollaborationSetup` only (issue fe-aktifai#230): the
+ * raw-options convenience path was removed because it required a
+ * *synchronous* provider construction, which is impossible now that
+ * `createCollaboration` lazy-imports `y-webrtc`/`y-websocket` and is async.
+ * Hosts must `await createCollaboration(...)` first and pass the result.
+ */
+declare function collaborationExtensions(setup: CollaborationSetup): AnyExtension[];
+
+export { type AwarenessState as A, type CollaborationOptions as C, type CollaborationSetup as a, createCollaboration as b, collaborationExtensions as c };

package/dist/Collaboration-CGv9OZlB.d.ts

@@ -0,0 +1,109 @@
+import { AnyExtension } from '@tiptap/core';
+import { Awareness } from 'y-protocols/awareness';
+import { IndexeddbPersistence } from 'y-indexeddb';
+import { WebrtcProvider } from 'y-webrtc';
+import { WebsocketProvider } from 'y-websocket';
+import * as Y from 'yjs';
+
+interface AwarenessState {
+    clientId: number;
+    user: {
+        name: string;
+        color: string;
+    };
+    cursor?: {
+        from: number;
+        to: number;
+    } | null;
+    /**
+     * Phase 9 PR2 — *present* flag. False when the local user has navigated
+     * away from the editor route (the Yjs provider is still alive but the
+     * host has gated cursor emission off, per the §6 *\"TOC sidebar orphan
+     * wiring\"* / REST-heartbeat scope notes). Peers see this instantly
+     * via the awareness `change` event — far faster than the 15s REST
+     * heartbeat fallback. Defaults to true when the user is in the editor.
+     */
+    present: boolean;
+}
+interface CollaborationOptions {
+    room: string;
+    provider?: 'webrtc' | 'websocket';
+    websocketUrl?: string;
+    signaling?: string[];
+    user: {
+        name: string;
+        color: string;
+    };
+    onAwarenessChange?: (states: AwarenessState[]) => void;
+    initialStorageState?: Uint8Array;
+    /**
+     * Phase 9 PR2 — when false, the local user is treated as
+     * out-of-editor: their cursor field is nulled and `present` is false.
+     * Default is true (in editor). Toggle at runtime via
+     * `setLocalCursorEnabled()` returned from `createCollaboration`.
+     */
+    emitCursor?: boolean;
+    /**
+     * Phase 9 OF1 — when true, mirror the room's Y.Doc into IndexedDB
+     * (`docflow-<room>`) via y-indexeddb so edits survive offline and reload.
+     * Reconcile-on-reconnect is plain Yjs merge — no conflict resolution
+     * needed. The IndexedDB mirror is NEVER a seed source: the server (or the
+     * legacy-JSON seed path) still owns initial state; the mirror only
+     * contributes local offline edits via the normal Yjs update exchange.
+     */
+    offline?: boolean;
+}
+interface CollaborationSetup {
+    ydoc: Y.Doc;
+    provider: WebrtcProvider | WebsocketProvider | null;
+    awareness: Awareness;
+    /**
+     * Phase 9 OF1 — y-indexeddb persistence instance, present only when
+     * `options.offline` is true. Exposed so hosts/tests can `await
+     * persistence.whenSynced` before asserting the mirror contents. Do not
+     * use it as a seed source.
+     */
+    persistence?: IndexeddbPersistence;
+    /**
+     * Issue #117 — resolves after BOTH the offline mirror (if `offline`) AND
+     * the provider's first sync (if `websocket`) have completed. Hosts MUST
+     * `await setup.whenReady` before binding the editor, otherwise the
+     * TipTap view can render against the IndexedDB cache before the
+     * authoritative server state arrives, briefly showing — and on a
+     * disconnected peer potentially re-broadcasting — nodes the server has
+     * since deleted. Resolves immediately when neither side applies.
+     */
+    whenReady: Promise<void>;
+    destroy: () => void;
+    /**
+     * Phase 9 PR2 — toggle the local cursor emission + present flag.
+     * Pass `false` when the editor route unmounts, `true` when it remounts.
+     * Triggers an awareness `change` event so peers see the leave/rejoin
+     * instantly (no REST-heartbeat lag).
+     */
+    setLocalCursorEnabled: (enabled: boolean) => void;
+}
+/**
+ * Build the collaboration runtime for a room.
+ *
+ * Async by design (issue fe-aktifai#230): the network sync providers are
+ * imported lazily — `y-webrtc` only when `provider: 'webrtc'`, `y-websocket`
+ * only when `provider: 'websocket'`, `y-indexeddb` only when `offline` is
+ * set. The main docflow barrel therefore never pulls the collab stack into
+ * bundles where collaboration is disabled; hosts that opt in simply
+ * `await createCollaboration(...)` and pass the resulting `CollaborationSetup`
+ * to `createEditor` / `<DocsEditor>`.
+ */
+declare function createCollaboration(options: CollaborationOptions): Promise<CollaborationSetup>;
+/**
+ * Build the TipTap extensions that bind an editor to a collaboration room.
+ *
+ * Takes a prebuilt `CollaborationSetup` only (issue fe-aktifai#230): the
+ * raw-options convenience path was removed because it required a
+ * *synchronous* provider construction, which is impossible now that
+ * `createCollaboration` lazy-imports `y-webrtc`/`y-websocket` and is async.
+ * Hosts must `await createCollaboration(...)` first and pass the result.
+ */
+declare function collaborationExtensions(setup: CollaborationSetup): AnyExtension[];
+
+export { type AwarenessState as A, type CollaborationOptions as C, type CollaborationSetup as a, createCollaboration as b, collaborationExtensions as c };

package/dist/chunk-XJG72F7M.js

@@ -0,0 +1,140 @@
+// src/Collaboration.ts
+import { Collaboration } from "@tiptap/extension-collaboration";
+import { CollaborationCursor } from "@tiptap/extension-collaboration-cursor";
+import { Awareness } from "y-protocols/awareness";
+import * as Y from "yjs";
+var LOCAL_SIGNALING = ["ws://localhost:4444"];
+var warnedLocalSignaling = false;
+function resolveSignalingUrls(signaling) {
+  if (signaling && signaling.length > 0) return signaling;
+  if (!warnedLocalSignaling) {
+    warnedLocalSignaling = true;
+    console.warn(
+      '[docflow] webrtc provider has no `signaling` configured \u2014 falling back to localhost-only sync (ws://localhost:4444 + same-browser tabs). For production self-host, run your own signaling server and pass `signaling`, or use `provider: "websocket"` with your own websocketUrl.'
+    );
+  }
+  return LOCAL_SIGNALING;
+}
+var LOCAL_PRESENT_DEFAULT = true;
+function createAwarenessStates(awareness) {
+  const states = [];
+  awareness.getStates().forEach((state, clientId) => {
+    const raw = state;
+    states.push({
+      clientId,
+      user: raw.user ?? { name: "", color: "" },
+      cursor: raw.cursor ?? null,
+      // `present` defaults to true for backwards compat (legacy states
+      // don't set it) and for the local user (always considered present
+      // until PR2 toggles it off).
+      present: raw.present ?? LOCAL_PRESENT_DEFAULT
+    });
+  });
+  return states;
+}
+async function createCollaboration(options) {
+  const ydoc = new Y.Doc();
+  if (options.initialStorageState) {
+    Y.applyUpdate(ydoc, options.initialStorageState);
+  }
+  let persistence;
+  if (options.offline) {
+    const { IndexeddbPersistence } = await import("y-indexeddb");
+    persistence = new IndexeddbPersistence(`docflow-${options.room}`, ydoc);
+  }
+  let provider = null;
+  if (options.provider === "webrtc") {
+    const { WebrtcProvider } = await import("y-webrtc");
+    provider = new WebrtcProvider(options.room, ydoc, {
+      signaling: resolveSignalingUrls(options.signaling)
+    });
+  } else if (options.provider === "websocket") {
+    if (!options.websocketUrl) {
+      throw new Error('[Collaboration] websocketUrl is required when provider is "websocket"');
+    }
+    const { WebsocketProvider } = await import("y-websocket");
+    provider = new WebsocketProvider(options.websocketUrl, options.room, ydoc);
+  }
+  const awareness = provider?.awareness ?? new Awareness(ydoc);
+  awareness.setLocalStateField("user", options.user);
+  let emitCursor = options.emitCursor ?? true;
+  const setLocalCursorEnabled = (enabled) => {
+    if (emitCursor === enabled) return;
+    emitCursor = enabled;
+    if (!enabled) {
+      awareness.setLocalStateField("cursor", null);
+    }
+    awareness.setLocalStateField("emitCursor", enabled);
+  };
+  awareness.setLocalStateField("present", true);
+  awareness.setLocalStateField("emitCursor", emitCursor);
+  let awarenessHandler;
+  if (options.onAwarenessChange) {
+    const notify = () => {
+      options.onAwarenessChange?.(createAwarenessStates(awareness));
+    };
+    awarenessHandler = notify;
+    awareness.on("change", notify);
+    notify();
+  }
+  const readyParts = [];
+  if (persistence) {
+    readyParts.push(
+      persistence.whenSynced.then(
+        () => void 0,
+        () => void 0
+      )
+    );
+  }
+  if (provider && options.provider === "websocket") {
+    const ws = provider;
+    readyParts.push(
+      new Promise((resolve) => {
+        let settled = false;
+        const done = () => {
+          if (settled) return;
+          settled = true;
+          resolve();
+        };
+        if (ws.synced) {
+          done();
+          return;
+        }
+        ws.once("sync", done);
+        ws.once("synced", done);
+        setTimeout(done, 5e3);
+      })
+    );
+  }
+  const whenReady = readyParts.length === 0 ? Promise.resolve() : Promise.all(readyParts).then(() => void 0);
+  const destroy = () => {
+    if (awarenessHandler) {
+      awareness.off("change", awarenessHandler);
+    }
+    awareness.setLocalState(null);
+    provider?.destroy?.();
+    awareness.destroy?.();
+    void persistence?.destroy();
+    ydoc.destroy();
+  };
+  return { ydoc, provider, awareness, persistence, whenReady, destroy, setLocalCursorEnabled };
+}
+function collaborationExtensions(setup) {
+  const extensions = [
+    Collaboration.configure({ document: setup.ydoc })
+  ];
+  if (setup.provider) {
+    extensions.push(
+      CollaborationCursor.configure({
+        provider: setup.provider,
+        user: setup.awareness.getLocalState()?.user ?? { name: "", color: "" }
+      })
+    );
+  }
+  return extensions;
+}
+
+export {
+  createCollaboration,
+  collaborationExtensions
+};

package/dist/collab/index.cjs

@@ -0,0 +1,286 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/collab/index.ts
+var collab_exports = {};
+__export(collab_exports, {
+  SubdocumentProvider: () => SubdocumentProvider,
+  collaborationExtensions: () => collaborationExtensions,
+  createCollaboration: () => createCollaboration
+});
+module.exports = __toCommonJS(collab_exports);
+
+// src/SubdocumentProvider.ts
+var import_awareness = require("y-protocols/awareness");
+var import_y_websocket = require("y-websocket");
+var Y = __toESM(require("yjs"), 1);
+var SubdocumentProvider = class {
+  parentDoc;
+  subdocs;
+  awareness;
+  options;
+  states = /* @__PURE__ */ new Map();
+  activeQueue = [];
+  parentProvider = null;
+  constructor(options) {
+    this.options = {
+      maxActive: options.maxActive ?? 5,
+      onStateChange: options.onStateChange ?? (() => {
+      }),
+      ...options
+    };
+    this.parentDoc = new Y.Doc();
+    this.subdocs = this.parentDoc.getMap("subdocs");
+    this.awareness = new import_awareness.Awareness(this.parentDoc);
+    this.awareness.setLocalStateField("user", this.options.user);
+    this.parentProvider = new import_y_websocket.WebsocketProvider(
+      this.options.websocketUrl,
+      `${this.options.roomPrefix}/_parent`,
+      this.parentDoc
+    );
+  }
+  /** Create a new subdocument. Does NOT activate it. */
+  createSubdoc(id, initialState) {
+    if (this.states.has(id)) return this.states.get(id).doc;
+    const doc = new Y.Doc();
+    if (initialState) Y.applyUpdate(doc, initialState);
+    doc.getXmlFragment("default");
+    this.subdocs.set(id, doc);
+    this.states.set(id, {
+      id,
+      doc,
+      provider: null,
+      active: false
+    });
+    this.options.onStateChange(this.getAllStates());
+    return doc;
+  }
+  /** Activate a subdocument — connects it to the network for live sync. */
+  activate(id) {
+    const state = this.states.get(id);
+    if (!state || state.active) return;
+    if (this.activeQueue.length >= this.options.maxActive) {
+      const oldest = this.activeQueue.shift();
+      if (oldest) this.deactivate(oldest);
+    }
+    const doc = state.doc;
+    const roomName = `${this.options.roomPrefix}/${id}`;
+    const provider = new import_y_websocket.WebsocketProvider(
+      this.options.websocketUrl,
+      roomName,
+      doc
+    );
+    provider.awareness.setLocalStateField("user", this.options.user);
+    state.provider = provider;
+    state.active = true;
+    this.activeQueue.push(id);
+    this.options.onStateChange(this.getAllStates());
+  }
+  /** Deactivate a subdocument — disconnects it from the network. */
+  deactivate(id) {
+    const state = this.states.get(id);
+    if (!state || !state.active) return;
+    state.provider?.destroy();
+    state.provider = null;
+    state.active = false;
+    const idx = this.activeQueue.indexOf(id);
+    if (idx >= 0) this.activeQueue.splice(idx, 1);
+    this.options.onStateChange(this.getAllStates());
+  }
+  /** Get the Y.XmlFragment for a subdocument. */
+  getFragment(id) {
+    const doc = this.states.get(id)?.doc ?? this.subdocs.get(id);
+    if (!doc) return null;
+    return doc.getXmlFragment("default");
+  }
+  /** Check if a subdocument is currently active (syncing). */
+  isActive(id) {
+    return this.states.get(id)?.active ?? false;
+  }
+  /** Get all subdocument states. */
+  getAllStates() {
+    return Array.from(this.states.values());
+  }
+  /** Get IDs of all active subdocuments. */
+  getActiveIds() {
+    return [...this.activeQueue];
+  }
+  /** Destroy all subdocuments and providers. */
+  destroy() {
+    for (const [id] of this.states) {
+      this.deactivate(id);
+    }
+    this.parentProvider?.destroy();
+    this.parentDoc.destroy();
+    this.states.clear();
+    this.activeQueue.length = 0;
+  }
+};
+
+// src/Collaboration.ts
+var import_extension_collaboration = require("@tiptap/extension-collaboration");
+var import_extension_collaboration_cursor = require("@tiptap/extension-collaboration-cursor");
+var import_awareness2 = require("y-protocols/awareness");
+var Y2 = __toESM(require("yjs"), 1);
+var LOCAL_SIGNALING = ["ws://localhost:4444"];
+var warnedLocalSignaling = false;
+function resolveSignalingUrls(signaling) {
+  if (signaling && signaling.length > 0) return signaling;
+  if (!warnedLocalSignaling) {
+    warnedLocalSignaling = true;
+    console.warn(
+      '[docflow] webrtc provider has no `signaling` configured \u2014 falling back to localhost-only sync (ws://localhost:4444 + same-browser tabs). For production self-host, run your own signaling server and pass `signaling`, or use `provider: "websocket"` with your own websocketUrl.'
+    );
+  }
+  return LOCAL_SIGNALING;
+}
+var LOCAL_PRESENT_DEFAULT = true;
+function createAwarenessStates(awareness) {
+  const states = [];
+  awareness.getStates().forEach((state, clientId) => {
+    const raw = state;
+    states.push({
+      clientId,
+      user: raw.user ?? { name: "", color: "" },
+      cursor: raw.cursor ?? null,
+      // `present` defaults to true for backwards compat (legacy states
+      // don't set it) and for the local user (always considered present
+      // until PR2 toggles it off).
+      present: raw.present ?? LOCAL_PRESENT_DEFAULT
+    });
+  });
+  return states;
+}
+async function createCollaboration(options) {
+  const ydoc = new Y2.Doc();
+  if (options.initialStorageState) {
+    Y2.applyUpdate(ydoc, options.initialStorageState);
+  }
+  let persistence;
+  if (options.offline) {
+    const { IndexeddbPersistence } = await import("y-indexeddb");
+    persistence = new IndexeddbPersistence(`docflow-${options.room}`, ydoc);
+  }
+  let provider = null;
+  if (options.provider === "webrtc") {
+    const { WebrtcProvider } = await import("y-webrtc");
+    provider = new WebrtcProvider(options.room, ydoc, {
+      signaling: resolveSignalingUrls(options.signaling)
+    });
+  } else if (options.provider === "websocket") {
+    if (!options.websocketUrl) {
+      throw new Error('[Collaboration] websocketUrl is required when provider is "websocket"');
+    }
+    const { WebsocketProvider: WebsocketProvider2 } = await import("y-websocket");
+    provider = new WebsocketProvider2(options.websocketUrl, options.room, ydoc);
+  }
+  const awareness = provider?.awareness ?? new import_awareness2.Awareness(ydoc);
+  awareness.setLocalStateField("user", options.user);
+  let emitCursor = options.emitCursor ?? true;
+  const setLocalCursorEnabled = (enabled) => {
+    if (emitCursor === enabled) return;
+    emitCursor = enabled;
+    if (!enabled) {
+      awareness.setLocalStateField("cursor", null);
+    }
+    awareness.setLocalStateField("emitCursor", enabled);
+  };
+  awareness.setLocalStateField("present", true);
+  awareness.setLocalStateField("emitCursor", emitCursor);
+  let awarenessHandler;
+  if (options.onAwarenessChange) {
+    const notify = () => {
+      options.onAwarenessChange?.(createAwarenessStates(awareness));
+    };
+    awarenessHandler = notify;
+    awareness.on("change", notify);
+    notify();
+  }
+  const readyParts = [];
+  if (persistence) {
+    readyParts.push(
+      persistence.whenSynced.then(
+        () => void 0,
+        () => void 0
+      )
+    );
+  }
+  if (provider && options.provider === "websocket") {
+    const ws = provider;
+    readyParts.push(
+      new Promise((resolve) => {
+        let settled = false;
+        const done = () => {
+          if (settled) return;
+          settled = true;
+          resolve();
+        };
+        if (ws.synced) {
+          done();
+          return;
+        }
+        ws.once("sync", done);
+        ws.once("synced", done);
+        setTimeout(done, 5e3);
+      })
+    );
+  }
+  const whenReady = readyParts.length === 0 ? Promise.resolve() : Promise.all(readyParts).then(() => void 0);
+  const destroy = () => {
+    if (awarenessHandler) {
+      awareness.off("change", awarenessHandler);
+    }
+    awareness.setLocalState(null);
+    provider?.destroy?.();
+    awareness.destroy?.();
+    void persistence?.destroy();
+    ydoc.destroy();
+  };
+  return { ydoc, provider, awareness, persistence, whenReady, destroy, setLocalCursorEnabled };
+}
+function collaborationExtensions(setup) {
+  const extensions = [
+    import_extension_collaboration.Collaboration.configure({ document: setup.ydoc })
+  ];
+  if (setup.provider) {
+    extensions.push(
+      import_extension_collaboration_cursor.CollaborationCursor.configure({
+        provider: setup.provider,
+        user: setup.awareness.getLocalState()?.user ?? { name: "", color: "" }
+      })
+    );
+  }
+  return extensions;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SubdocumentProvider,
+  collaborationExtensions,
+  createCollaboration
+});