@veltdev/ace-crdt 1.0.0

package/cjs/index.js

@@ -0,0 +1,1610 @@
+'use strict';
+
+var crdt = require('@veltdev/crdt');
+var Y = require('yjs');
+
+function _interopNamespaceDefault(e) {
+    var n = Object.create(null);
+    if (e) {
+        Object.keys(e).forEach(function (k) {
+            if (k !== 'default') {
+                var d = Object.getOwnPropertyDescriptor(e, k);
+                Object.defineProperty(n, k, d.get ? d : {
+                    enumerable: true,
+                    get: function () { return e[k]; }
+                });
+            }
+        });
+    }
+    n.default = e;
+    return Object.freeze(n);
+}
+
+var Y__namespace = /*#__PURE__*/_interopNamespaceDefault(Y);
+
+// POLICY: Every function/method in this file MUST be wrapped in try/catch.
+// The package must NEVER throw an exception to the consumer's code.
+const LOG_PREFIX = '[VeltAceCRDT]';
+/**
+ * Log an error/warning — only visible when debug mode is enabled
+ * via sessionStorage.setItem('forceCrdtDebugMode', 'true').
+ */
+function logError(message, error) {
+    try {
+        if (typeof sessionStorage !== 'undefined' &&
+            sessionStorage.getItem('forceCrdtDebugMode')) {
+            console.warn(`${LOG_PREFIX} ${message}`, error !== undefined ? error : '');
+        }
+    }
+    catch {
+        // sessionStorage may not be available (SSR / iframe restrictions)
+    }
+}
+
+// POLICY: Every function/method in this file MUST be wrapped in try/catch.
+// The package must NEVER throw an exception to the consumer's code.
+const CONFIG_MAP_KEY = 'veltConfig';
+const INITIALIZED_FLAG = '__docInitialized';
+const LEGACY_FLAG = 'hasContentSet';
+function normalizeText(value) {
+    try {
+        if (typeof value !== 'string')
+            return '';
+        return value.replace(/\r\n/g, '\n').replace(/\r/g, '\n');
+    }
+    catch (error) {
+        logError('Failed to normalize text', error);
+        return '';
+    }
+}
+function applyInitialContent(doc, ytext, initialContent, force) {
+    try {
+        const configMap = doc.getMap(CONFIG_MAP_KEY);
+        const text = normalizeText(initialContent);
+        if (!force) {
+            if (configMap.get(INITIALIZED_FLAG) || configMap.get(LEGACY_FLAG)) {
+                return false;
+            }
+            if (ytext.length > 0) {
+                configMap.set(INITIALIZED_FLAG, true);
+                return false;
+            }
+        }
+        doc.transact(() => {
+            if (ytext.length > 0)
+                ytext.delete(0, ytext.length);
+            if (text.length > 0)
+                ytext.insert(0, text);
+            configMap.set(INITIALIZED_FLAG, true);
+        }, 'velt-ace-initial-content');
+        return true;
+    }
+    catch (error) {
+        logError('Failed to apply initial content', error);
+        return false;
+    }
+}
+function replaceYText(doc, ytext, value, origin) {
+    try {
+        const text = normalizeText(value);
+        doc.transact(() => {
+            try {
+                if (ytext.length > 0)
+                    ytext.delete(0, ytext.length);
+                if (text.length > 0)
+                    ytext.insert(0, text);
+            }
+            catch (error) {
+                logError('Failed inside Y.Text replace transaction', error);
+            }
+        }, origin);
+    }
+    catch (error) {
+        logError('Failed to replace Y.Text', error);
+    }
+}
+function positionToIndex(text, position) {
+    try {
+        const normalized = normalizeText(text);
+        const lines = normalized.split('\n');
+        const row = Math.max(0, Math.min(Number(position.row) || 0, Math.max(0, lines.length - 1)));
+        const column = Math.max(0, Math.min(Number(position.column) || 0, lines[row]?.length ?? 0));
+        let index = 0;
+        for (let i = 0; i < row; i += 1) {
+            index += (lines[i]?.length ?? 0) + 1;
+        }
+        return Math.max(0, Math.min(index + column, normalized.length));
+    }
+    catch (error) {
+        logError('Failed to convert Ace position to index', error);
+        return 0;
+    }
+}
+function indexToPosition(text, index) {
+    try {
+        const normalized = normalizeText(text);
+        const bounded = Math.max(0, Math.min(Number(index) || 0, normalized.length));
+        const before = normalized.slice(0, bounded);
+        const lines = before.split('\n');
+        return {
+            row: Math.max(0, lines.length - 1),
+            column: lines[lines.length - 1]?.length ?? 0,
+        };
+    }
+    catch (error) {
+        logError('Failed to convert text index to Ace position', error);
+        return { row: 0, column: 0 };
+    }
+}
+function rangeToOffsets(text, range) {
+    try {
+        const anchor = positionToIndex(text, range.start);
+        const head = positionToIndex(text, range.end);
+        return { anchor, head };
+    }
+    catch (error) {
+        logError('Failed to convert Ace range to offsets', error);
+        return { anchor: 0, head: 0 };
+    }
+}
+function offsetsToRange(text, anchor, head) {
+    try {
+        return {
+            start: indexToPosition(text, Math.min(anchor, head)),
+            end: indexToPosition(text, Math.max(anchor, head)),
+            isBackwards: head < anchor,
+        };
+    }
+    catch (error) {
+        logError('Failed to convert offsets to Ace range', error);
+        return {
+            start: { row: 0, column: 0 },
+            end: { row: 0, column: 0 },
+        };
+    }
+}
+
+// POLICY: Every function/method in this file MUST be wrapped in try/catch.
+// The package must NEVER throw an exception to the consumer's code.
+const CONTENT_KEY = 'content';
+const DEFAULT_EDITOR_ID = 'velt-ace-crdt-document';
+const DEFAULT_CURSOR_COLOR = '#2563eb';
+const REMOTE_MARKER_PREFIX = 'velt-ace-remote-marker';
+const REMOTE_STYLE_ID = 'velt-ace-crdt-remote-marker-styles';
+const LABEL_BELOW_CLASS = 'velt-ace-remote-marker-label-below';
+class CollaborationManager {
+    constructor(config) {
+        this.store = null;
+        this.provider = null;
+        this.undoManager = null;
+        this.editor = null;
+        this.session = null;
+        this.rangeFactory = null;
+        this.userId = 'anonymous';
+        this._initialized = false;
+        this._synced = false;
+        this._status = 'connecting';
+        this._initialContentApplied = false;
+        this._lastFlushReason = null;
+        this.statusListeners = new Set();
+        this.syncedListeners = new Set();
+        this.awarenessListeners = new Set();
+        this.cleanupFns = [];
+        this.editorCleanupFns = [];
+        this.remoteMarkerIds = [];
+        this.remoteMarkerClasses = new Set();
+        this.selectionPublishTimer = null;
+        this.localSelectionSignature = null;
+        this.remoteRenderTimer = null;
+        this.isApplyingRemote = false;
+        this.isApplyingLocal = false;
+        try {
+            this.config = this.normalizeConfig(config);
+            this.editor = this.config.editor ?? null;
+            this.rangeFactory = this.config.rangeFactory ?? null;
+        }
+        catch (error) {
+            logError('Failed to construct CollaborationManager', error);
+            this.config = this.normalizeConfig({});
+        }
+    }
+    async initialize() {
+        try {
+            if (this._initialized)
+                return;
+            this.userId = this.readUserId();
+            this.store = this.createStore();
+            this.setupAwareness();
+            this.setupStoreTextObserver();
+            this.setupAwarenessListeners();
+            if (this.config.editor) {
+                this.attachEditor(this.config.editor, { destroyExisting: false, rangeFactory: this.config.rangeFactory });
+            }
+            try {
+                await this.store.initialize();
+            }
+            catch (error) {
+                if (this.isCorruptionError(error)) {
+                    await this.tryRecoverFromCorruption();
+                }
+                else {
+                    this.reportError('Store initialization failed', error);
+                }
+            }
+            this.provider = this.store.getProvider();
+            this.setupProviderListeners();
+            this.setupUndoManager();
+            this._initialized = true;
+            this.tryApplyInitialContent();
+            this.syncTextToEditor('initialize');
+        }
+        catch (error) {
+            this.reportError('Initialization failed unexpectedly', error);
+        }
+    }
+    destroy() {
+        try {
+            this.detachEditor();
+            for (const fn of this.cleanupFns.splice(0)) {
+                try {
+                    fn();
+                }
+                catch { /* ignore cleanup */ }
+            }
+            try {
+                this.undoManager?.destroy();
+            }
+            catch { /* ignore */ }
+            this.undoManager = null;
+            try {
+                this.getAwareness()?.setLocalState(null);
+            }
+            catch { /* ignore */ }
+            try {
+                this.store?.destroy();
+            }
+            catch { /* ignore */ }
+            this.store = null;
+            this.provider = null;
+            this.statusListeners.clear();
+            this.syncedListeners.clear();
+            this.awarenessListeners.clear();
+            this._initialized = false;
+            this._synced = false;
+            this._status = 'disconnected';
+        }
+        catch (error) {
+            logError('Error during destroy', error);
+        }
+    }
+    attachEditor(editor, options = {}) {
+        try {
+            if (!editor)
+                return false;
+            if (options.destroyExisting !== false)
+                this.detachEditor();
+            this.editor = editor;
+            this.session = this.resolveSession(editor);
+            this.rangeFactory = options.rangeFactory ?? this.rangeFactory ?? this.config.rangeFactory ?? null;
+            this.bindEditorEvents();
+            this.syncTextToEditor('attach-editor');
+            this.publishCurrentSelection();
+            return true;
+        }
+        catch (error) {
+            this.reportError('Failed to attach Ace editor', error);
+            return false;
+        }
+    }
+    detachEditor() {
+        try {
+            this.clearSelectionPublishTimer();
+            this.clearRemoteRenderTimer();
+            this.clearRemoteMarkers();
+            for (const fn of this.editorCleanupFns.splice(0)) {
+                try {
+                    fn();
+                }
+                catch { /* ignore cleanup */ }
+            }
+            this.editor = null;
+            this.session = null;
+        }
+        catch (error) {
+            logError('Failed to detach Ace editor', error);
+        }
+    }
+    get initialized() {
+        try {
+            return this._initialized;
+        }
+        catch {
+            return false;
+        }
+    }
+    get synced() {
+        try {
+            return this._synced;
+        }
+        catch {
+            return false;
+        }
+    }
+    get status() {
+        try {
+            return this._status;
+        }
+        catch {
+            return 'disconnected';
+        }
+    }
+    get editorAttached() {
+        try {
+            return !!this.editor;
+        }
+        catch {
+            return false;
+        }
+    }
+    getCollaborationPrimitives() {
+        try {
+            return {
+                ytext: this.getText(),
+                awareness: this.getAwareness(),
+                undoManager: this.undoManager,
+                doc: this.getDoc(),
+                provider: this.getProvider(),
+            };
+        }
+        catch (error) {
+            logError('Failed to get collaboration primitives', error);
+            return { ytext: null, awareness: null, undoManager: null, doc: null, provider: null };
+        }
+    }
+    getValue() {
+        try {
+            return this.getText()?.toString() ?? normalizeText(this.readEditorValue());
+        }
+        catch (error) {
+            logError('Failed to get value', error);
+            return '';
+        }
+    }
+    setValue(value, reason = 'set-value') {
+        try {
+            const ytext = this.getText();
+            const doc = this.getDoc();
+            if (!ytext || !doc)
+                return false;
+            replaceYText(doc, ytext, value, this);
+            this._lastFlushReason = reason;
+            this.syncTextToEditor(reason);
+            return true;
+        }
+        catch (error) {
+            this.reportError('Failed to set value', error);
+            return false;
+        }
+    }
+    insertText(value, index) {
+        try {
+            const ytext = this.getText();
+            const doc = this.getDoc();
+            if (!ytext || !doc)
+                return false;
+            const text = normalizeText(value);
+            const insertAt = Number.isFinite(Number(index))
+                ? Math.max(0, Math.min(Number(index), ytext.length))
+                : positionToIndex(ytext.toString(), this.readCursorPosition());
+            doc.transact(() => {
+                try {
+                    if (text.length > 0)
+                        ytext.insert(insertAt, text);
+                }
+                catch (error) {
+                    logError('Failed inside insert transaction', error);
+                }
+            }, this);
+            this._lastFlushReason = 'insert-text';
+            this.syncTextToEditor('insert-text');
+            return true;
+        }
+        catch (error) {
+            this.reportError('Failed to insert text', error);
+            return false;
+        }
+    }
+    flushEditorToStore(reason = 'manual') {
+        try {
+            const ytext = this.getText();
+            const doc = this.getDoc();
+            if (!ytext || !doc)
+                return false;
+            const value = normalizeText(this.readEditorValue());
+            if (value !== ytext.toString()) {
+                replaceYText(doc, ytext, value, this);
+            }
+            this._lastFlushReason = reason;
+            return true;
+        }
+        catch (error) {
+            this.reportError('Failed to flush Ace editor to Store', error);
+            return false;
+        }
+    }
+    async forceReset(initialContent) {
+        try {
+            const ytext = this.getText();
+            const doc = this.getDoc();
+            if (!ytext || !doc)
+                return false;
+            const next = initialContent ?? this.config.initialContent ?? '';
+            replaceYText(doc, ytext, next, this);
+            this._lastFlushReason = 'force-reset';
+            this._initialContentApplied = true;
+            this.syncTextToEditor('force-reset');
+            return true;
+        }
+        catch (error) {
+            this.reportError('Failed to force reset Ace content', error);
+            return false;
+        }
+    }
+    onStatusChange(cb) {
+        try {
+            this.statusListeners.add(cb);
+        }
+        catch (error) {
+            logError('Failed to add status listener', error);
+        }
+        return () => {
+            try {
+                this.statusListeners.delete(cb);
+            }
+            catch { /* ignore */ }
+        };
+    }
+    onSynced(cb) {
+        try {
+            this.syncedListeners.add(cb);
+        }
+        catch (error) {
+            logError('Failed to add synced listener', error);
+        }
+        return () => {
+            try {
+                this.syncedListeners.delete(cb);
+            }
+            catch { /* ignore */ }
+        };
+    }
+    onRemoteSelectionsChange(cb) {
+        try {
+            this.awarenessListeners.add(cb);
+            cb(this.getRemoteSelections());
+        }
+        catch (error) {
+            logError('Failed to add remote selection listener', error);
+        }
+        return () => {
+            try {
+                this.awarenessListeners.delete(cb);
+            }
+            catch { /* ignore */ }
+        };
+    }
+    getDoc() {
+        try {
+            return this.store?.getDoc() ?? null;
+        }
+        catch (error) {
+            logError('Failed to get Y.Doc', error);
+            return null;
+        }
+    }
+    getText() {
+        try {
+            return this.store?.getText() ?? null;
+        }
+        catch (error) {
+            logError('Failed to get Y.Text', error);
+            return null;
+        }
+    }
+    getYText() {
+        try {
+            return this.getText();
+        }
+        catch (error) {
+            logError('Failed to get Y.Text alias', error);
+            return null;
+        }
+    }
+    getProvider() {
+        try {
+            return this.provider ?? this.store?.getProvider() ?? null;
+        }
+        catch (error) {
+            logError('Failed to get SyncProvider', error);
+            return null;
+        }
+    }
+    getAwareness() {
+        try {
+            return this.store?.getAwareness() ?? null;
+        }
+        catch (error) {
+            logError('Failed to get Awareness', error);
+            return null;
+        }
+    }
+    getUndoManager() {
+        try {
+            return this.undoManager;
+        }
+        catch (error) {
+            logError('Failed to get UndoManager', error);
+            return null;
+        }
+    }
+    getEditor() {
+        try {
+            return this.editor;
+        }
+        catch (error) {
+            logError('Failed to get Ace editor', error);
+            return null;
+        }
+    }
+    getStore() {
+        try {
+            return this.store;
+        }
+        catch (error) {
+            logError('Failed to get Store', error);
+            return null;
+        }
+    }
+    getStats() {
+        try {
+            return {
+                initialized: this.initialized,
+                synced: this.synced,
+                status: this.status,
+                hasEditor: !!this.editor,
+                hasStore: !!this.store,
+                remoteSelectionCount: this.getRemoteSelections().length,
+                textLength: this.getValue().length,
+                lastFlushReason: this._lastFlushReason,
+            };
+        }
+        catch {
+            return {
+                initialized: false,
+                synced: false,
+                status: 'disconnected',
+                hasEditor: false,
+                hasStore: false,
+                remoteSelectionCount: 0,
+                textLength: 0,
+                lastFlushReason: null,
+            };
+        }
+    }
+    async saveVersion(name) {
+        try {
+            this.flushEditorToStore('save-version');
+            return (await this.store?.saveVersion(name)) ?? '';
+        }
+        catch (error) {
+            logError('Failed to save version', error);
+            return '';
+        }
+    }
+    async getVersions() {
+        try {
+            return (await this.store?.getVersions()) ?? [];
+        }
+        catch (error) {
+            logError('Failed to get versions', error);
+            return [];
+        }
+    }
+    async getVersionById(versionId) {
+        try {
+            return (await this.store?.getVersionById(versionId)) ?? null;
+        }
+        catch (error) {
+            logError('Failed to get version by id', error);
+            return null;
+        }
+    }
+    async restoreVersion(versionId) {
+        try {
+            const versions = (await this.store?.getVersions()) ?? [];
+            const hasVersion = versions.some((version) => version?.versionId === versionId || version?.id === versionId);
+            if (!hasVersion)
+                return false;
+            const restored = (await this.store?.restoreVersion(versionId)) ?? false;
+            if (restored) {
+                this._lastFlushReason = 'restore-version';
+                this.syncTextToEditor('restore-version');
+            }
+            return restored;
+        }
+        catch (error) {
+            logError('Failed to restore version', error);
+            return false;
+        }
+    }
+    async setStateFromVersion(version) {
+        try {
+            await this.store?.setStateFromVersion(version);
+            this._lastFlushReason = 'set-state-from-version';
+            this.syncTextToEditor('set-state-from-version');
+        }
+        catch (error) {
+            logError('Failed to set state from version', error);
+        }
+    }
+    setLocalSelection(selection) {
+        try {
+            if (!this.store)
+                return false;
+            if (!selection) {
+                if (this.localSelectionSignature === null)
+                    return true;
+                this.localSelectionSignature = null;
+                this.store.updateAwareness?.({ selection: null });
+                this.notifyAwarenessListeners();
+                return true;
+            }
+            const normalized = this.createAwarenessSelection(selection);
+            if (!normalized)
+                return false;
+            const signature = this.createSelectionSignature(normalized);
+            if (signature === this.localSelectionSignature)
+                return true;
+            this.localSelectionSignature = signature;
+            this.store.updateAwareness?.({ selection: normalized });
+            this.notifyAwarenessListeners();
+            return true;
+        }
+        catch (error) {
+            this.reportError('Failed to set local selection', error);
+            return false;
+        }
+    }
+    publishCurrentSelection(kind = 'cursor') {
+        try {
+            const range = this.readSelectionRange();
+            if (!range)
+                return false;
+            const collapsed = this.isCollapsed(range);
+            const effectiveKind = kind !== 'highlight' && collapsed
+                ? 'cursor'
+                : kind === 'cursor' && !collapsed ? 'selection' : kind;
+            return this.setLocalSelection({ ...range, kind: effectiveKind, text: this.readSelectedText() });
+        }
+        catch (error) {
+            this.reportError('Failed to publish current selection', error);
+            return false;
+        }
+    }
+    addHighlight(range, color) {
+        try {
+            const current = range?.start && range?.end ? range : this.readSelectionRange();
+            if (!current)
+                return false;
+            const highlightRange = this.expandCollapsedHighlightRange(current);
+            return this.setLocalSelection({
+                ...highlightRange,
+                kind: 'highlight',
+                color: color ?? this.resolveCursorData().color,
+                colorLight: this.withAlpha(color ?? this.resolveCursorData().color, '33'),
+                text: this.readSelectedText(),
+            });
+        }
+        catch (error) {
+            this.reportError('Failed to add highlight marker', error);
+            return false;
+        }
+    }
+    getRemoteSelections() {
+        try {
+            const awareness = this.getAwareness();
+            const doc = this.getDoc();
+            if (!awareness)
+                return [];
+            const localAwarenessClientId = Number(awareness.clientID);
+            const localDocClientId = doc?.clientID;
+            const selections = [];
+            awareness.getStates().forEach((state, clientId) => {
+                try {
+                    if (clientId === localDocClientId || clientId === localAwarenessClientId)
+                        return;
+                    const selection = state?.selection;
+                    if (!selection?.start || !selection?.end)
+                        return;
+                    selections.push({
+                        ...selection,
+                        userId: selection.userId ?? state.user?.userId,
+                        name: selection.name ?? state.user?.name,
+                        email: selection.email ?? state.user?.email,
+                        color: selection.color ?? state.user?.color,
+                        colorLight: selection.colorLight ?? state.user?.colorLight,
+                        clientId,
+                    });
+                }
+                catch {
+                    // Ignore one malformed remote awareness state.
+                }
+            });
+            return selections;
+        }
+        catch (error) {
+            logError('Failed to get remote selections', error);
+            return [];
+        }
+    }
+    renderRemoteSelections() {
+        try {
+            const session = this.session;
+            if (!session?.addMarker)
+                return 0;
+            this.clearRemoteMarkers();
+            this.ensureRemoteMarkerStyles(this.getRemoteSelections());
+            let rendered = 0;
+            for (const selection of this.getRemoteSelections()) {
+                try {
+                    const range = this.createAceRange(selection.start, selection.end);
+                    const className = this.createMarkerClassName(selection);
+                    // The name label renders above the marker line; on the first row it
+                    // would be clipped by the scroller, so flip it below the line there.
+                    const labelModifier = this.normalizePosition(selection.start).row === 0
+                        ? ` ${LABEL_BELOW_CLASS}`
+                        : '';
+                    // inFront=true — Ace paints back markers BEHIND the text layer, which
+                    // hides the caret border and the ::after name label under the glyphs.
+                    const markerId = session.addMarker(range, className + labelModifier, 'text', true);
+                    this.remoteMarkerIds.push(markerId);
+                    rendered += 1;
+                }
+                catch {
+                    // Ignore one bad remote marker.
+                }
+            }
+            return rendered;
+        }
+        catch (error) {
+            logError('Failed to render remote selections', error);
+            return 0;
+        }
+    }
+    clearRemoteMarkers() {
+        try {
+            const session = this.session;
+            if (!session?.removeMarker) {
+                this.remoteMarkerIds = [];
+                return;
+            }
+            for (const markerId of this.remoteMarkerIds.splice(0)) {
+                try {
+                    session.removeMarker(markerId);
+                }
+                catch { /* ignore one marker */ }
+            }
+        }
+        catch (error) {
+            logError('Failed to clear remote markers', error);
+        }
+    }
+    normalizeConfig(config) {
+        try {
+            const input = (config ?? {});
+            return {
+                editorId: input.editorId || DEFAULT_EDITOR_ID,
+                veltClient: input.veltClient,
+                editor: input.editor ?? null,
+                initialContent: typeof input.initialContent === 'string' ? input.initialContent : undefined,
+                cursorData: input.cursorData,
+                rangeFactory: input.rangeFactory,
+                debounceMs: input.debounceMs,
+                onError: input.onError,
+                forceResetInitialContent: Boolean(input.forceResetInitialContent),
+            };
+        }
+        catch (error) {
+            logError('Failed to normalize config', error);
+            return {
+                editorId: DEFAULT_EDITOR_ID,
+                veltClient: undefined,
+            };
+        }
+    }
+    createStore() {
+        try {
+            return new crdt.Store({
+                id: this.config.editorId,
+                userId: this.userId,
+                type: 'text',
+                contentKey: CONTENT_KEY,
+                source: 'ace',
+                debounceMs: this.config.debounceMs,
+                veltClient: this.config.veltClient,
+                forceResetInitialContent: this.config.forceResetInitialContent,
+                initialValue: this.config.forceResetInitialContent ? '' : undefined,
+            });
+        }
+        catch (error) {
+            logError('Failed to create Store', error);
+            throw error;
+        }
+    }
+    setupStoreTextObserver() {
+        try {
+            const ytext = this.store?.getText();
+            if (!ytext)
+                return;
+            const observer = (event) => {
+                try {
+                    if (event.transaction.origin === this || this.isApplyingLocal)
+                        return;
+                    this.syncTextToEditor('remote', event);
+                }
+                catch (error) {
+                    logError('Y.Text observer failed', error);
+                }
+            };
+            ytext.observe(observer);
+            this.cleanupFns.push(() => {
+                try {
+                    ytext.unobserve(observer);
+                }
+                catch { /* ignore */ }
+            });
+        }
+        catch (error) {
+            logError('Failed to setup Y.Text observer', error);
+        }
+    }
+    setupUndoManager() {
+        try {
+            const ytext = this.getText();
+            if (!ytext || this.undoManager)
+                return;
+            this.undoManager = new Y__namespace.UndoManager(ytext, {
+                trackedOrigins: new Set([this, null]),
+            });
+        }
+        catch (error) {
+            logError('Failed to setup UndoManager', error);
+        }
+    }
+    setupAwareness() {
+        try {
+            const cursorData = this.resolveCursorData();
+            this.store?.updateAwareness?.({
+                selection: undefined,
+                user: {
+                    userId: this.userId,
+                    name: cursorData.name || 'Anonymous',
+                    email: cursorData.email || '',
+                    color: cursorData.color || DEFAULT_CURSOR_COLOR,
+                    colorLight: cursorData.colorLight || this.withAlpha(cursorData.color || DEFAULT_CURSOR_COLOR, '33'),
+                },
+            });
+        }
+        catch (error) {
+            logError('Failed to setup awareness', error);
+        }
+    }
+    setupProviderListeners() {
+        try {
+            if (!this.provider)
+                return;
+            const onSynced = (event) => {
+                try {
+                    const synced = typeof event === 'boolean' ? event : Boolean(event?.synced);
+                    this._synced = synced;
+                    this.syncedListeners.forEach((cb) => {
+                        try {
+                            cb(synced);
+                        }
+                        catch { /* ignore listener errors */ }
+                    });
+                    if (synced) {
+                        this.tryApplyInitialContent();
+                        this.syncTextToEditor('synced');
+                    }
+                }
+                catch (error) {
+                    logError('Error in synced handler', error);
+                }
+            };
+            const onStatus = (event) => {
+                try {
+                    const status = typeof event === 'string' ? event : event?.status;
+                    if (!status)
+                        return;
+                    this._status = status;
+                    this.statusListeners.forEach((cb) => {
+                        try {
+                            cb(status);
+                        }
+                        catch { /* ignore listener errors */ }
+                    });
+                }
+                catch (error) {
+                    logError('Error in status handler', error);
+                }
+            };
+            this.provider.on('synced', onSynced);
+            this.provider.on('sync', onSynced);
+            this.provider.on('status', onStatus);
+            this.cleanupFns.push(() => {
+                try {
+                    this.provider?.off?.('synced', onSynced);
+                }
+                catch { /* ignore */ }
+                try {
+                    this.provider?.off?.('sync', onSynced);
+                }
+                catch { /* ignore */ }
+                try {
+                    this.provider?.off?.('status', onStatus);
+                }
+                catch { /* ignore */ }
+            });
+            const providerAny = this.provider;
+            if (typeof providerAny.synced === 'boolean')
+                this._synced = providerAny.synced;
+            if (providerAny.status)
+                this._status = providerAny.status;
+        }
+        catch (error) {
+            logError('Failed to setup provider listeners', error);
+        }
+    }
+    setupAwarenessListeners() {
+        try {
+            const awareness = this.store?.getAwareness();
+            if (!awareness?.on)
+                return;
+            const handler = () => {
+                try {
+                    this.notifyAwarenessListeners();
+                    this.scheduleRemoteSelectionRender();
+                }
+                catch (error) {
+                    logError('Awareness handler failed', error);
+                }
+            };
+            awareness.on('change', handler);
+            awareness.on('update', handler);
+            this.cleanupFns.push(() => {
+                try {
+                    awareness.off?.('change', handler);
+                }
+                catch { /* ignore */ }
+                try {
+                    awareness.off?.('update', handler);
+                }
+                catch { /* ignore */ }
+            });
+        }
+        catch (error) {
+            logError('Failed to setup awareness listeners', error);
+        }
+    }
+    bindEditorEvents() {
+        try {
+            const session = this.session;
+            if (!session?.on)
+                return;
+            const onChange = (delta) => {
+                try {
+                    this.applyAceDelta(delta);
+                }
+                catch (error) {
+                    logError('Ace change handler failed', error);
+                }
+            };
+            session.on('change', onChange);
+            this.editorCleanupFns.push(() => {
+                try {
+                    session.off?.('change', onChange);
+                }
+                catch { /* ignore */ }
+            });
+            const selection = session.selection ?? this.editor?.selection;
+            const onSelection = () => {
+                try {
+                    this.scheduleSelectionPublish('selection', 90);
+                }
+                catch (error) {
+                    logError('Ace selection handler failed', error);
+                }
+            };
+            const onCursor = () => {
+                try {
+                    this.scheduleSelectionPublish('cursor', 160);
+                }
+                catch (error) {
+                    logError('Ace cursor handler failed', error);
+                }
+            };
+            selection?.on?.('changeSelection', onSelection);
+            selection?.on?.('changeCursor', onCursor);
+            this.editorCleanupFns.push(() => {
+                try {
+                    selection?.off?.('changeSelection', onSelection);
+                }
+                catch { /* ignore */ }
+                try {
+                    selection?.off?.('changeCursor', onCursor);
+                }
+                catch { /* ignore */ }
+            });
+        }
+        catch (error) {
+            logError('Failed to bind Ace editor events', error);
+        }
+    }
+    tryApplyInitialContent() {
+        try {
+            if (this._initialContentApplied)
+                return;
+            if (!this.store || this.config.initialContent === undefined)
+                return;
+            if (!this._synced && !this.config.forceResetInitialContent)
+                return;
+            const ytext = this.store.getText();
+            if (!ytext)
+                return;
+            this._initialContentApplied = applyInitialContent(this.store.getDoc(), ytext, this.config.initialContent, this.config.forceResetInitialContent);
+            if (this._initialContentApplied)
+                this.syncTextToEditor('initial-content');
+        }
+        catch (error) {
+            logError('Failed to apply initial content', error);
+        }
+    }
+    applyAceDelta(delta) {
+        try {
+            if (this.isApplyingRemote || !delta?.action)
+                return;
+            const ytext = this.getText();
+            const doc = this.getDoc();
+            if (!ytext || !doc)
+                return;
+            const current = ytext.toString();
+            const start = positionToIndex(current, delta.start ?? { row: 0, column: 0 });
+            const end = positionToIndex(current, delta.end ?? delta.start ?? { row: 0, column: 0 });
+            const payload = Array.isArray(delta.lines) ? delta.lines.join('\n') : normalizeText(delta.text ?? '');
+            this.isApplyingLocal = true;
+            doc.transact(() => {
+                try {
+                    if (delta.action === 'insert') {
+                        if (payload.length > 0)
+                            ytext.insert(start, payload);
+                    }
+                    else if (delta.action === 'remove') {
+                        const length = Math.max(0, end - start);
+                        if (length > 0)
+                            ytext.delete(start, length);
+                    }
+                    else {
+                        replaceYText(doc, ytext, this.readEditorValue(), this);
+                    }
+                }
+                catch (error) {
+                    logError('Failed inside Ace delta transaction', error);
+                }
+            }, this);
+            this._lastFlushReason = 'local-edit';
+        }
+        catch (error) {
+            this.reportError('Failed to apply Ace delta', error);
+        }
+        finally {
+            this.isApplyingLocal = false;
+        }
+    }
+    syncTextToEditor(reason, event) {
+        try {
+            const ytext = this.getText();
+            const editor = this.editor;
+            const session = this.session ?? this.resolveSession(editor);
+            if (!ytext || !editor || !session)
+                return;
+            const next = ytext.toString();
+            const current = normalizeText(this.readEditorValue());
+            if (current === next)
+                return;
+            this.isApplyingRemote = true;
+            try {
+                const appliedIncrementally = event ? this.applyRemoteDeltaToSession(session, event) : false;
+                if (!appliedIncrementally || normalizeText(this.readEditorValue()) !== next) {
+                    this.replaceEditorValuePreservingSelection(editor, session, next);
+                }
+                this._lastFlushReason = reason;
+            }
+            finally {
+                this.isApplyingRemote = false;
+            }
+        }
+        catch (error) {
+            this.isApplyingRemote = false;
+            this.reportError('Failed to sync Y.Text to Ace editor', error);
+        }
+    }
+    // Applies a remote Y.Text delta as incremental session edits so Ace keeps
+    // the local user's cursor/selection anchors instead of resetting them on a
+    // whole-document setValue (which Ace treats as replace-all).
+    applyRemoteDeltaToSession(session, event) {
+        try {
+            if (!session.insert || !session.remove)
+                return false;
+            const delta = event?.delta;
+            if (!Array.isArray(delta) || delta.length === 0)
+                return false;
+            // Y.Text with plain strings only ever emits retain/insert/delete string ops;
+            // bail out to full replacement on anything else (e.g. embeds).
+            if (!delta.every((op) => typeof op.retain === 'number'
+                || typeof op.insert === 'string'
+                || typeof op.delete === 'number')) {
+                return false;
+            }
+            let index = 0;
+            for (const op of delta) {
+                const currentText = normalizeText(session.getValue?.() ?? this.readEditorValue());
+                if (typeof op.retain === 'number') {
+                    index += op.retain;
+                }
+                else if (typeof op.insert === 'string') {
+                    session.insert(indexToPosition(currentText, index), op.insert);
+                    index += op.insert.length;
+                }
+                else if (typeof op.delete === 'number') {
+                    const start = indexToPosition(currentText, index);
+                    const end = indexToPosition(currentText, index + op.delete);
+                    session.remove(this.createAceRange(start, end));
+                }
+            }
+            return true;
+        }
+        catch (error) {
+            logError('Failed to apply remote delta incrementally', error);
+            return false;
+        }
+    }
+    replaceEditorValuePreservingSelection(editor, session, next) {
+        try {
+            const currentText = normalizeText(this.readEditorValue());
+            const selectionRange = this.readSelectionRange();
+            const offsets = selectionRange ? rangeToOffsets(currentText, selectionRange) : null;
+            if (session.setValue) {
+                session.setValue(next);
+            }
+            else {
+                editor.setValue?.(next, -1);
+            }
+            if (!offsets)
+                return;
+            const anchor = Math.min(offsets.anchor, next.length);
+            const head = Math.min(offsets.head, next.length);
+            const restored = offsetsToRange(next, anchor, head);
+            const selectionApi = session.selection ?? editor.selection;
+            if (anchor === head) {
+                selectionApi?.moveToPosition?.(restored.end);
+            }
+            else {
+                selectionApi?.setSelectionRange?.(this.createAceRange(restored.start, restored.end), restored.isBackwards);
+            }
+        }
+        catch (error) {
+            logError('Failed to replace Ace editor value', error);
+        }
+    }
+    readEditorValue() {
+        try {
+            return normalizeText(this.editor?.getValue?.() ?? this.session?.getValue?.() ?? '');
+        }
+        catch (error) {
+            logError('Failed to read Ace editor value', error);
+            return '';
+        }
+    }
+    readCursorPosition() {
+        try {
+            return this.session?.selection?.getCursor?.()
+                ?? this.editor?.selection?.getCursor?.()
+                ?? { row: 0, column: 0 };
+        }
+        catch {
+            return { row: 0, column: 0 };
+        }
+    }
+    readSelectionRange() {
+        try {
+            return this.editor?.getSelectionRange?.()
+                ?? this.session?.selection?.getRange?.()
+                ?? this.editor?.selection?.getRange?.()
+                ?? null;
+        }
+        catch (error) {
+            logError('Failed to read Ace selection range', error);
+            return null;
+        }
+    }
+    readSelectedText() {
+        try {
+            const range = this.readSelectionRange();
+            if (this.editor?.getSelectedText)
+                return normalizeText(this.editor.getSelectedText());
+            if (range && this.session?.getTextRange)
+                return normalizeText(this.session.getTextRange(range));
+            return '';
+        }
+        catch {
+            return '';
+        }
+    }
+    resolveSession(editor) {
+        try {
+            return editor?.getSession?.() ?? editor?.session ?? null;
+        }
+        catch (error) {
+            logError('Failed to resolve Ace session', error);
+            return null;
+        }
+    }
+    createAwarenessSelection(selection) {
+        try {
+            if (!selection.start || !selection.end)
+                return null;
+            const cursorData = this.resolveCursorData();
+            return {
+                start: this.normalizePosition(selection.start),
+                end: this.normalizePosition(selection.end),
+                isBackwards: Boolean(selection.isBackwards),
+                userId: selection.userId ?? this.userId,
+                name: selection.name ?? cursorData.name,
+                email: selection.email ?? cursorData.email,
+                color: selection.color ?? cursorData.color,
+                colorLight: selection.colorLight ?? cursorData.colorLight,
+                text: selection.text,
+                kind: selection.kind ?? (this.isCollapsed(selection) ? 'cursor' : 'selection'),
+                updatedAt: Date.now(),
+            };
+        }
+        catch (error) {
+            logError('Failed to create awareness selection', error);
+            return null;
+        }
+    }
+    notifyAwarenessListeners() {
+        try {
+            const selections = this.getRemoteSelections();
+            for (const cb of this.awarenessListeners) {
+                try {
+                    cb(selections);
+                }
+                catch { /* ignore listener errors */ }
+            }
+        }
+        catch (error) {
+            logError('Failed to notify awareness listeners', error);
+        }
+    }
+    scheduleSelectionPublish(kind = 'cursor', delayMs = 120) {
+        try {
+            this.clearSelectionPublishTimer();
+            const safeDelay = Math.max(0, Number(delayMs) || 0);
+            this.selectionPublishTimer = setTimeout(() => {
+                try {
+                    this.selectionPublishTimer = null;
+                    this.publishCurrentSelection(kind);
+                }
+                catch (error) {
+                    logError('Scheduled selection publish failed', error);
+                }
+            }, safeDelay);
+        }
+        catch (error) {
+            logError('Failed to schedule selection publish', error);
+        }
+    }
+    clearSelectionPublishTimer() {
+        try {
+            if (this.selectionPublishTimer)
+                clearTimeout(this.selectionPublishTimer);
+            this.selectionPublishTimer = null;
+        }
+        catch (error) {
+            logError('Failed to clear selection publish timer', error);
+        }
+    }
+    scheduleRemoteSelectionRender() {
+        try {
+            if (this.remoteRenderTimer)
+                return;
+            this.remoteRenderTimer = setTimeout(() => {
+                try {
+                    this.remoteRenderTimer = null;
+                    this.renderRemoteSelections();
+                }
+                catch (error) {
+                    logError('Scheduled remote selection render failed', error);
+                }
+            }, 16);
+        }
+        catch (error) {
+            logError('Failed to schedule remote selection render', error);
+        }
+    }
+    clearRemoteRenderTimer() {
+        try {
+            if (this.remoteRenderTimer)
+                clearTimeout(this.remoteRenderTimer);
+            this.remoteRenderTimer = null;
+        }
+        catch (error) {
+            logError('Failed to clear remote render timer', error);
+        }
+    }
+    createAceRange(start, end) {
+        try {
+            const safeStart = this.normalizePosition(start);
+            const safeEnd = this.normalizePosition(end);
+            if (this.rangeFactory)
+                return this.rangeFactory(safeStart, safeEnd);
+            const globalAce = globalThis.ace;
+            const Range = globalAce?.require?.('ace/range')?.Range;
+            if (Range)
+                return new Range(safeStart.row, safeStart.column, safeEnd.row, safeEnd.column);
+            return { start: safeStart, end: safeEnd };
+        }
+        catch (error) {
+            logError('Failed to create Ace range', error);
+            return { start, end };
+        }
+    }
+    ensureRemoteMarkerStyles(selections) {
+        try {
+            if (typeof document === 'undefined')
+                return;
+            let style = document.getElementById(REMOTE_STYLE_ID);
+            if (!style) {
+                style = document.createElement('style');
+                style.id = REMOTE_STYLE_ID;
+                // [class] bumps specificity above the per-client ::after rules below.
+                style.appendChild(document.createTextNode(`.${LABEL_BELOW_CLASS}[class]::after{top:100%;bottom:auto;}`));
+                document.head.appendChild(style);
+            }
+            const rules = [];
+            for (const selection of selections) {
+                try {
+                    const className = this.createMarkerClassName(selection);
+                    if (this.remoteMarkerClasses.has(className))
+                        continue;
+                    this.remoteMarkerClasses.add(className);
+                    const color = this.escapeCssColor(selection.color ?? DEFAULT_CURSOR_COLOR);
+                    const light = this.escapeCssColor(selection.colorLight ?? this.withAlpha(color, '33'));
+                    const label = this.escapeCssString(selection.name ?? selection.email ?? 'Remote');
+                    const kind = selection.kind ?? 'selection';
+                    const border = kind === 'cursor' ? `border-left:2px solid ${color};` : `border:1px solid ${color};border-left:2px solid ${color};`;
+                    const zIndex = kind === 'cursor' ? 9 : 8;
+                    rules.push(`.${className}{position:absolute;background:${kind === 'cursor' ? 'transparent' : light};${border}box-sizing:border-box;z-index:${zIndex};pointer-events:none;}`);
+                    rules.push(`.${className}::after{content:'${label}';position:absolute;top:-18px;left:0;background:${color};color:#fff;font:600 11px system-ui,sans-serif;padding:1px 5px;border-radius:3px;white-space:nowrap;}`);
+                }
+                catch {
+                    // Ignore one style rule.
+                }
+            }
+            if (rules.length > 0)
+                style.appendChild(document.createTextNode(rules.join('\n')));
+        }
+        catch (error) {
+            logError('Failed to ensure remote marker styles', error);
+        }
+    }
+    createMarkerClassName(selection) {
+        try {
+            const kind = String(selection.kind ?? 'selection').replace(/[^a-zA-Z0-9_-]/g, '');
+            const clientId = String(selection.clientId).replace(/[^a-zA-Z0-9_-]/g, '');
+            return `${REMOTE_MARKER_PREFIX}-${kind}-${clientId}`;
+        }
+        catch {
+            return `${REMOTE_MARKER_PREFIX}-unknown`;
+        }
+    }
+    createSelectionSignature(selection) {
+        try {
+            return [
+                selection.kind ?? '',
+                selection.start.row,
+                selection.start.column,
+                selection.end.row,
+                selection.end.column,
+                selection.isBackwards ? '1' : '0',
+                selection.text ?? '',
+                selection.color ?? '',
+                selection.colorLight ?? '',
+            ].join('|');
+        }
+        catch {
+            return '';
+        }
+    }
+    expandCollapsedHighlightRange(range) {
+        try {
+            if (!this.isCollapsed(range))
+                return range;
+            const row = this.normalizePosition(range.start).row;
+            const line = this.readLine(row);
+            const fallbackEnd = Math.max(range.end.column + 1, line.length);
+            return {
+                start: { row, column: 0 },
+                end: { row, column: Math.max(1, fallbackEnd) },
+                isBackwards: false,
+            };
+        }
+        catch (error) {
+            logError('Failed to expand collapsed highlight range', error);
+            return range;
+        }
+    }
+    readLine(row) {
+        try {
+            const safeRow = Math.max(0, Number(row) || 0);
+            const session = this.session;
+            const line = session?.getLine?.(safeRow);
+            if (typeof line === 'string')
+                return line;
+            return this.readEditorValue().split('\n')[safeRow] ?? '';
+        }
+        catch {
+            return '';
+        }
+    }
+    normalizePosition(position) {
+        try {
+            return {
+                row: Math.max(0, Number(position.row) || 0),
+                column: Math.max(0, Number(position.column) || 0),
+            };
+        }
+        catch {
+            return { row: 0, column: 0 };
+        }
+    }
+    isCollapsed(selection) {
+        try {
+            return selection.start?.row === selection.end?.row && selection.start?.column === selection.end?.column;
+        }
+        catch {
+            return false;
+        }
+    }
+    resolveCursorData() {
+        try {
+            const configured = this.config.cursorData ?? {};
+            const user = this.readVeltUser();
+            const color = configured.color || user?.color || DEFAULT_CURSOR_COLOR;
+            return {
+                name: configured.name || user?.name || user?.email || this.userId || 'Anonymous',
+                email: configured.email || user?.email || '',
+                color,
+                colorLight: configured.colorLight || this.withAlpha(color, '33'),
+            };
+        }
+        catch (error) {
+            logError('Failed to resolve cursor data', error);
+            return {
+                name: 'Anonymous',
+                email: '',
+                color: DEFAULT_CURSOR_COLOR,
+                colorLight: this.withAlpha(DEFAULT_CURSOR_COLOR, '33'),
+            };
+        }
+    }
+    readUserId() {
+        try {
+            return this.readVeltUser()?.userId || this.readVeltUser()?.id || 'anonymous';
+        }
+        catch {
+            return 'anonymous';
+        }
+    }
+    readVeltUser() {
+        try {
+            return this.config.veltClient?.getUser?.() ?? null;
+        }
+        catch {
+            return null;
+        }
+    }
+    withAlpha(color, alpha) {
+        try {
+            if (/^#[0-9a-fA-F]{6}$/.test(color))
+                return `${color}${alpha}`;
+            return `${DEFAULT_CURSOR_COLOR}${alpha}`;
+        }
+        catch {
+            return `${DEFAULT_CURSOR_COLOR}${alpha}`;
+        }
+    }
+    escapeCssColor(color) {
+        try {
+            return /^#[0-9a-fA-F]{6}([0-9a-fA-F]{2})?$/.test(color) ? color : DEFAULT_CURSOR_COLOR;
+        }
+        catch {
+            return DEFAULT_CURSOR_COLOR;
+        }
+    }
+    escapeCssString(value) {
+        try {
+            return String(value).replace(/\\/g, '\\\\').replace(/'/g, "\\'");
+        }
+        catch {
+            return 'Remote';
+        }
+    }
+    isCorruptionError(error) {
+        try {
+            const message = error instanceof Error ? error.message : String(error ?? '');
+            return /invalid|corrupt|decode|unexpected end|malformed|contentRefs/i.test(message);
+        }
+        catch {
+            return false;
+        }
+    }
+    async tryRecoverFromCorruption() {
+        try {
+            logError('Detected corrupted CRDT state; attempting recovery');
+            try {
+                this.store?.destroy();
+            }
+            catch { /* ignore */ }
+            this.store = this.createStore();
+            this.setupAwareness();
+            this.setupStoreTextObserver();
+            this.setupAwarenessListeners();
+            await this.store.initialize();
+        }
+        catch (error) {
+            this.reportError('Failed to recover from corrupted CRDT state', error);
+        }
+    }
+    reportError(message, error) {
+        try {
+            logError(message, error);
+            this.config.onError?.(error instanceof Error ? error : new Error(message));
+        }
+        catch {
+            // Never let error reporting throw.
+        }
+    }
+}
+async function createCollaboration(config) {
+    try {
+        const manager = new CollaborationManager(config);
+        await manager.initialize();
+        return manager;
+    }
+    catch (error) {
+        logError('Failed to create collaboration', error);
+        return new CollaborationManager(config);
+    }
+}
+
+exports.CollaborationManager = CollaborationManager;
+exports.createCollaboration = createCollaboration;
+exports.indexToPosition = indexToPosition;
+exports.normalizeText = normalizeText;
+exports.offsetsToRange = offsetsToRange;
+exports.positionToIndex = positionToIndex;
+exports.rangeToOffsets = rangeToOffsets;
+//# sourceMappingURL=index.js.map