@nocturnium/svelte-ide 1.0.1 → 1.0.3

package/dist/components/editor/EditorPane.svelte

@@ -2,6 +2,7 @@
 	import Editor from './Editor.svelte';
 	import EditorTabs from './EditorTabs.svelte';
 	import type { EditorPreferences } from '../../types';
+	import type { AIAwareness } from './core/ai-awareness';
 	import {
 		getTabs,
 		getActiveTab,
@@ -15,11 +16,23 @@
 
 	interface Props {
 		preferences?: Partial<EditorPreferences>;
+		folding?: boolean;
+		multiCursor?: boolean;
+		maxCursors?: number;
+		aiAgents?: AIAwareness[];
 		onSave?: (path: string, content: string) => Promise<void>;
 		class?: string;
 	}
 
-	let { preferences = {}, onSave, class: className = '' }: Props = $props();
+	let {
+		preferences = {},
+		folding = true,
+		multiCursor = true,
+		maxCursors = 100,
+		aiAgents = [],
+		onSave,
+		class: className = ''
+	}: Props = $props();
 
 	// Use getter functions for reactive access
 	let tabs = $derived(getTabs());
@@ -70,6 +83,10 @@
 					language={activeTab.language}
 					readonly={activeTab.aiEditing}
 					{preferences}
+					{folding}
+					{multiCursor}
+					{maxCursors}
+					{aiAgents}
 					onChange={handleChange}
 					onCursorChange={handleCursorChange}
 					onSave={handleSave}

package/dist/components/editor/EditorPane.svelte.d.ts

@@ -1,6 +1,11 @@
 import type { EditorPreferences } from '../../types';
+import type { AIAwareness } from './core/ai-awareness';
 interface Props {
     preferences?: Partial<EditorPreferences>;
+    folding?: boolean;
+    multiCursor?: boolean;
+    maxCursors?: number;
+    aiAgents?: AIAwareness[];
     onSave?: (path: string, content: string) => Promise<void>;
     class?: string;
 }

package/dist/components/editor/EditorSelections.svelte

@@ -26,6 +26,7 @@
 		viewportHeight: number;
 		getLine: (n: number) => { text: string } | undefined;
 		lineCount: number;
+		lineToVisualRow?: (line: number) => number;
 	}
 
 	let {
@@ -39,7 +40,8 @@
 		scrollTop,
 		viewportHeight,
 		getLine,
-		lineCount
+		lineCount,
+		lineToVisualRow = (line) => line
 	}: Props = $props();
 
 	// Selection rects memoization
@@ -70,17 +72,17 @@
 
 		// Calculate visible line range (with 1-line buffer for smooth scrolling)
 		const vh = viewportHeight || FALLBACK_VIEWPORT_HEIGHT;
-		const firstVisibleLine = Math.max(0, Math.floor(scrollTop / lineHeight) - 1);
-		const lastVisibleLine = Math.min(lineCount - 1, Math.ceil((scrollTop + vh) / lineHeight) + 1);
+		const firstVisibleRow = Math.max(0, Math.floor(scrollTop / lineHeight) - 1);
+		const lastVisibleRow = Math.max(0, Math.ceil((scrollTop + vh) / lineHeight) + 1);
 
 		// Create cache key from all cursors, scroll position, and measurement values
 		const cursorKeys = cursors
 			.map(
 				(c) =>
-					`${c.id}:${c.selection.anchor.line}:${c.selection.anchor.column}-${c.selection.head.line}:${c.selection.head.column}`
+					`${c.id}:${c.selection.anchor.line}/${lineToVisualRow(c.selection.anchor.line)}:${c.selection.anchor.column}-${c.selection.head.line}/${lineToVisualRow(c.selection.head.line)}:${c.selection.head.column}`
 			)
 			.join('|');
-		const key = `${cursorKeys}@${firstVisibleLine}-${lastVisibleLine}:${charWidth}:${lineHeight}:${gutterWidth}`;
+		const key = `${cursorKeys}@${firstVisibleRow}-${lastVisibleRow}:${charWidth}:${lineHeight}:${gutterWidth}`;
 		if (key === cachedSelectionKey) {
 			return cachedSelectionRects;
 		}
@@ -100,13 +102,14 @@
 			const start = getSelectionStart(cursor.selection);
 			const end = getSelectionEnd(cursor.selection);
 
-			// Only iterate over lines that are both selected AND visible
-			const renderStart = Math.max(start.line, firstVisibleLine);
-			const renderEnd = Math.min(end.line, lastVisibleLine);
+			const renderStart = Math.max(start.line, 0);
+			const renderEnd = Math.min(end.line, lineCount - 1);
 
 			for (let line = renderStart; line <= renderEnd; line++) {
 				const lineContent = getLine(line);
 				if (!lineContent) continue;
+				const visualRow = lineToVisualRow(line);
+				if (visualRow < firstVisibleRow || visualRow > lastVisibleRow) continue;
 
 				let startCol = 0;
 				let endCol = lineContent.text.length;
@@ -122,7 +125,7 @@
 				const width = Math.max((endCol - startCol) * charWidth, 4);
 
 				rects.push({
-					top: line * lineHeight,
+					top: visualRow * lineHeight,
 					left: gutterWidth + contentPadding + startCol * charWidth,
 					width,
 					height: lineHeight,
@@ -139,7 +142,7 @@
 	// Get cursor style for a specific cursor position
 	function getCursorStyleForPosition(pos: Position): string {
 		const left = gutterWidth + contentPadding + pos.column * charWidth;
-		const top = pos.line * lineHeight;
+		const top = lineToVisualRow(pos.line) * lineHeight;
 		return `left: ${left}px; top: ${top}px; height: ${lineHeight}px;`;
 	}
 </script>
@@ -156,11 +159,12 @@
 </div>
 
 <!-- Cursors (all cursors rendered with primary/secondary distinction) -->
-{#if cursorVisible && !isReadonly}
+{#if !isReadonly}
 	{#each cursors as cursor (cursor.id)}
 		<div
 			class="custom-editor__cursor"
 			class:custom-editor__cursor--secondary={!cursor.isPrimary}
+			class:custom-editor__cursor--hidden={!cursorVisible}
 			style={getCursorStyleForPosition(cursor.selection.head)}
 		></div>
 	{/each}
@@ -193,6 +197,7 @@
 		background: var(--color-nocturnium-aurora-blue);
 		z-index: 10;
 		pointer-events: none;
+		opacity: 1;
 		transition: opacity 80ms;
 	}
 
@@ -201,4 +206,15 @@
 		background: var(--ide-interactive-muted);
 		opacity: 0.85;
 	}
+
+	.custom-editor__cursor--hidden {
+		opacity: 0;
+	}
+
+	@media (prefers-reduced-motion: reduce) {
+		.custom-editor__cursor {
+			opacity: 1;
+			transition: none;
+		}
+	}
 </style>

package/dist/components/editor/EditorSelections.svelte.d.ts

@@ -19,6 +19,7 @@ interface Props {
         text: string;
     } | undefined;
     lineCount: number;
+    lineToVisualRow?: (line: number) => number;
 }
 declare const EditorSelections: import("svelte").Component<Props, {}, "">;
 type EditorSelections = ReturnType<typeof EditorSelections>;

package/dist/components/editor/core/folding.d.ts

@@ -109,6 +109,17 @@ export declare class FoldManager {
      * Get visible lines (line numbers that should be rendered)
      */
     getVisibleLines(totalLines: number): number[];
+    /**
+     * Map a raw document line to its compacted visual row.
+     *
+     * Visible lines map to their exact row in getVisibleLines(totalLines). Hidden
+     * lines map to the row of the nearest visible fold header at or above them.
+     */
+    lineToVisualRow(line: number, totalLines: number): number;
+    /**
+     * Map a compacted visual row back to the raw document line rendered there.
+     */
+    visualRowToLine(visualRow: number, totalLines: number): number;
     /**
      * Get the number of hidden lines after a fold start
      */

package/dist/components/editor/core/folding.js

@@ -641,6 +641,47 @@ export class FoldManager {
         }
         return visible;
     }
+    /**
+     * Map a raw document line to its compacted visual row.
+     *
+     * Visible lines map to their exact row in getVisibleLines(totalLines). Hidden
+     * lines map to the row of the nearest visible fold header at or above them.
+     */
+    lineToVisualRow(line, totalLines) {
+        if (totalLines <= 0)
+            return 0;
+        const clampedLine = Math.max(0, Math.min(Math.floor(line), totalLines - 1));
+        const visible = this.getVisibleLines(totalLines);
+        if (visible.length === 0)
+            return 0;
+        let low = 0;
+        let high = visible.length;
+        while (low < high) {
+            const mid = Math.floor((low + high) / 2);
+            if (visible[mid] < clampedLine) {
+                low = mid + 1;
+            }
+            else {
+                high = mid;
+            }
+        }
+        if (visible[low] === clampedLine) {
+            return low;
+        }
+        return Math.max(0, low - 1);
+    }
+    /**
+     * Map a compacted visual row back to the raw document line rendered there.
+     */
+    visualRowToLine(visualRow, totalLines) {
+        if (totalLines <= 0)
+            return 0;
+        const visible = this.getVisibleLines(totalLines);
+        if (visible.length === 0)
+            return 0;
+        const clampedRow = Math.max(0, Math.min(Math.floor(visualRow), visible.length - 1));
+        return visible[clampedRow];
+    }
     /**
      * Get the number of hidden lines after a fold start
      */

package/dist/components/editor/core/index.d.ts

@@ -4,18 +4,13 @@
 export * from './state';
 export * from './navigation';
 export * from './keybindings';
-export * from './crdt-binding';
 export * from './search';
 export * from './folding';
 export * from './multi-cursor';
 export * from './complexity-analyzer';
 export * from './ai-awareness';
-export * from './ghost-pair';
 export * from './semantic-analyzer';
 export * from './commands';
-export * from './timeline';
-export * from './conflict-predictor';
-export * from './echo-cursor';
 export * from './bracket-healer';
 export * from './git-blame';
 export * from './snippet-manager';

package/dist/components/editor/core/index.js

@@ -4,18 +4,17 @@
 export * from './state';
 export * from './navigation';
 export * from './keybindings';
-export * from './crdt-binding';
+// NOTE: './crdt-binding' is intentionally NOT re-exported here. It imports yjs
+// (an optional peer dependency), so leaking it through this barrel would force
+// yjs onto every consumer of the non-collaborative editor. The CRDT binding is
+// available through the dedicated `@nocturnium/svelte-ide/crdt` entry instead.
 export * from './search';
 export * from './folding';
 export * from './multi-cursor';
 export * from './complexity-analyzer';
 export * from './ai-awareness';
-export * from './ghost-pair';
 export * from './semantic-analyzer';
 export * from './commands';
-export * from './timeline';
-export * from './conflict-predictor';
-export * from './echo-cursor';
 export * from './bracket-healer';
 export * from './git-blame';
 export * from './snippet-manager';

package/dist/components/editor/core/state.d.ts

@@ -305,6 +305,10 @@ export declare class EditorState {
      * Deep copy a selection to prevent reference issues in history
      */
     private deepCopySelection;
+    private transformCursorUpdatesForInsert;
+    private transformPositionForInsert;
+    private transformCursorUpdatesForDelete;
+    private transformPositionForDelete;
     /**
      * Check if undo is available
      */
@@ -317,6 +321,7 @@ export declare class EditorState {
      * Compare two tokenizer states for equality
      */
     private tokenizerStatesEqual;
+    private tokenizerStateValuesEqual;
     /**
      * Re-tokenize a range of lines with early-exit optimization
      */

package/dist/components/editor/core/state.js

@@ -7,7 +7,7 @@
  */
 import { getTokenizer } from '../tokenizer';
 import { HISTORY_GROUP_TIMEOUT_MS, MAX_HISTORY_SIZE } from '../constants';
-import { CursorManager, createCursorManager, getSelectionStart, getSelectionEnd, isSelectionEmpty } from './multi-cursor';
+import { CursorManager, createCursorManager, comparePositions, getSelectionStart, getSelectionEnd, isSelectionEmpty } from './multi-cursor';
 /**
  * Core editor state class
  */
@@ -361,10 +361,12 @@ export class EditorState {
                 const start = getSelectionStart(cursor.selection);
                 const end = getSelectionEnd(cursor.selection);
                 this.deleteRangeInternal(start, end);
+                this.transformCursorUpdatesForDelete(updates, start, end);
                 currentPos = start;
             }
             // Insert text
             const newPos = this.insertAtInternal(currentPos, text);
+            this.transformCursorUpdatesForInsert(updates, currentPos, text);
             updates.push({ id: cursor.id, position: newPos });
         }
         // Apply all cursor updates using batch update to avoid multiple merge/emit calls
@@ -453,6 +455,7 @@ export class EditorState {
                 const start = getSelectionStart(cursor.selection);
                 const end = getSelectionEnd(cursor.selection);
                 this.deleteRangeInternal(start, end);
+                this.transformCursorUpdatesForDelete(updates, start, end);
                 updates.push({ id: cursor.id, position: start });
             }
         }
@@ -519,25 +522,32 @@ export class EditorState {
         for (const cursor of cursors) {
             const { line, column } = cursor.selection.head;
             if (column > 0) {
+                const from = { line, column: column - 1 };
+                const to = { line, column };
                 // Delete within line
                 const currentLine = this._lines[line];
-                currentLine.text = currentLine.text.slice(0, column - 1) + currentLine.text.slice(column);
+                currentLine.text =
+                    currentLine.text.slice(0, from.column) + currentLine.text.slice(to.column);
                 // Re-tokenize to end of document so deleting a multi-line construct
                 // delimiter re-propagates state to lines below.
                 this.retokenize(line, this._lines.length);
-                updates.push({ id: cursor.id, position: { line, column: column - 1 } });
+                this.transformCursorUpdatesForDelete(updates, from, to);
+                updates.push({ id: cursor.id, position: from });
             }
             else if (line > 0) {
                 // Join with previous line
                 const prevLine = this._lines[line - 1];
                 const currentLine = this._lines[line];
                 const newColumn = prevLine.text.length;
+                const from = { line: line - 1, column: newColumn };
+                const to = { line, column: 0 };
                 prevLine.text += currentLine.text;
                 this._lines.splice(line, 1);
                 this._tokenizerStates.splice(line, 1);
                 this.renumberLines(line);
                 this.retokenize(line - 1, this._lines.length);
-                updates.push({ id: cursor.id, position: { line: line - 1, column: newColumn } });
+                this.transformCursorUpdatesForDelete(updates, from, to);
+                updates.push({ id: cursor.id, position: from });
             }
         }
         // Apply all cursor updates using batch update
@@ -564,28 +574,41 @@ export class EditorState {
             return;
         }
         this.saveHistory('delete');
+        const updates = [];
         for (const cursor of cursors) {
             const { line, column } = cursor.selection.head;
             const currentLine = this._lines[line];
             if (column < currentLine.text.length) {
+                const from = { line, column };
+                const to = { line, column: column + 1 };
                 // Delete within line
-                currentLine.text = currentLine.text.slice(0, column) + currentLine.text.slice(column + 1);
+                currentLine.text =
+                    currentLine.text.slice(0, from.column) + currentLine.text.slice(to.column);
                 // Re-tokenize to end of document so deleting a multi-line construct
                 // delimiter re-propagates state to lines below.
                 this.retokenize(line, this._lines.length);
+                this.transformCursorUpdatesForDelete(updates, from, to);
+                updates.push({ id: cursor.id, position: from });
             }
             else if (line < this._lines.length - 1) {
                 // Join with next line
                 const nextLine = this._lines[line + 1];
+                const from = { line, column };
+                const to = { line: line + 1, column: 0 };
                 currentLine.text += nextLine.text;
                 this._lines.splice(line + 1, 1);
                 this._tokenizerStates.splice(line + 1, 1);
                 this.renumberLines(line + 1);
                 this.retokenize(line, this._lines.length);
+                this.transformCursorUpdatesForDelete(updates, from, to);
+                updates.push({ id: cursor.id, position: from });
             }
         }
+        // Apply all cursor updates using batch update
+        this._cursorManager.batchUpdateCursors(updates);
         this.emitChange({ type: 'delete', from: this.cursor, to: this.cursor });
         this.emitSelectionChange();
+        this.emitCursorChange();
     }
     /**
      * Insert a new line (enter key)
@@ -624,8 +647,8 @@ export class EditorState {
             timestamp: now
         };
         if (shouldMerge) {
-            // Update the last entry instead of creating a new one
-            this._undoStack[this._undoStack.length - 1] = entry;
+            // Keep the original restore snapshot; only extend the group's recency.
+            this._undoStack[this._undoStack.length - 1].timestamp = now;
         }
         else {
             this._undoStack.push(entry);
@@ -715,6 +738,57 @@ export class EditorState {
             head: { line: sel.head.line, column: sel.head.column }
         };
     }
+    transformCursorUpdatesForInsert(updates, at, text) {
+        for (const update of updates) {
+            update.position = this.transformPositionForInsert(update.position, at, text);
+        }
+    }
+    transformPositionForInsert(position, at, text) {
+        if (comparePositions(position, at) < 0) {
+            return position;
+        }
+        const textLines = text.split('\n');
+        const insertedLineCount = textLines.length - 1;
+        if (insertedLineCount === 0) {
+            if (position.line !== at.line) {
+                return position;
+            }
+            return { line: position.line, column: position.column + text.length };
+        }
+        if (position.line === at.line) {
+            return {
+                line: position.line + insertedLineCount,
+                column: textLines[textLines.length - 1].length + position.column - at.column
+            };
+        }
+        return { line: position.line + insertedLineCount, column: position.column };
+    }
+    transformCursorUpdatesForDelete(updates, from, to) {
+        for (const update of updates) {
+            update.position = this.transformPositionForDelete(update.position, from, to);
+        }
+    }
+    transformPositionForDelete(position, from, to) {
+        if (comparePositions(position, from) <= 0) {
+            return position;
+        }
+        if (comparePositions(position, to) <= 0) {
+            return from;
+        }
+        if (from.line === to.line) {
+            if (position.line !== from.line) {
+                return position;
+            }
+            return { line: position.line, column: position.column - (to.column - from.column) };
+        }
+        if (position.line === to.line) {
+            return {
+                line: from.line,
+                column: from.column + position.column - to.column
+            };
+        }
+        return { line: position.line - (to.line - from.line), column: position.column };
+    }
     /**
      * Check if undo is available
      */
@@ -738,11 +812,56 @@ export class EditorState {
             return true;
         if (!a || !b)
             return a === b;
-        return (a.inBlockComment === b.inBlockComment &&
-            a.inTemplateLiteral === b.inTemplateLiteral &&
-            a.inMultilineString === b.inMultilineString &&
-            a.stringDelimiter === b.stringDelimiter &&
-            a.templateDepth === b.templateDepth);
+        const aKeys = Object.keys(a)
+            .filter((key) => a[key] !== undefined)
+            .sort();
+        const bKeys = Object.keys(b)
+            .filter((key) => b[key] !== undefined)
+            .sort();
+        if (aKeys.length !== bKeys.length)
+            return false;
+        for (let i = 0; i < aKeys.length; i++) {
+            const key = aKeys[i];
+            if (key !== bKeys[i])
+                return false;
+            if (!this.tokenizerStateValuesEqual(a[key], b[key])) {
+                return false;
+            }
+        }
+        return true;
+    }
+    tokenizerStateValuesEqual(a, b) {
+        if (a === b)
+            return true;
+        if (typeof a !== typeof b)
+            return false;
+        if (a === null || b === null)
+            return a === b;
+        if (typeof a !== 'object' || typeof b !== 'object')
+            return false;
+        if (Array.isArray(a) || Array.isArray(b)) {
+            if (!Array.isArray(a) || !Array.isArray(b) || a.length !== b.length)
+                return false;
+            return a.every((value, index) => this.tokenizerStateValuesEqual(value, b[index]));
+        }
+        const aRecord = a;
+        const bRecord = b;
+        const aKeys = Object.keys(aRecord)
+            .filter((key) => aRecord[key] !== undefined)
+            .sort();
+        const bKeys = Object.keys(bRecord)
+            .filter((key) => bRecord[key] !== undefined)
+            .sort();
+        if (aKeys.length !== bKeys.length)
+            return false;
+        for (let i = 0; i < aKeys.length; i++) {
+            const key = aKeys[i];
+            if (key !== bKeys[i])
+                return false;
+            if (!this.tokenizerStateValuesEqual(aRecord[key], bRecord[key]))
+                return false;
+        }
+        return true;
     }
     /**
      * Re-tokenize a range of lines with early-exit optimization

package/dist/components/editor/editor-find.d.ts

@@ -17,6 +17,7 @@ export interface EditorFindDeps {
     scrollCursorIntoView: () => void;
     focusEditor: () => void;
     isReadonly: () => boolean;
+    lineToVisualRow?: (line: number) => number;
 }
 export interface MatchRect {
     top: number;

package/dist/components/editor/editor-find.js

@@ -92,19 +92,20 @@ export function createEditorFind(deps) {
             return [];
         const { scrollTop, viewportHeight } = viewport;
         const { lineHeight, charWidth, gutterWidth, contentPadding } = measurements;
-        const firstVisibleLine = Math.max(0, Math.floor(scrollTop / lineHeight) - 1);
-        const lineCount = deps.getLineCount();
-        const lastVisibleLine = Math.min(lineCount - 1, Math.ceil((scrollTop + viewportHeight) / lineHeight) + 1);
+        const lineToVisualRow = deps.lineToVisualRow ?? ((line) => line);
+        const firstVisibleRow = Math.max(0, Math.floor(scrollTop / lineHeight) - 1);
+        const lastVisibleRow = Math.max(0, Math.ceil((scrollTop + viewportHeight) / lineHeight) + 1);
         const rects = [];
         for (let i = 0; i < matches.length; i++) {
             const match = matches[i];
-            if (match.line < firstVisibleLine || match.line > lastVisibleLine)
+            const visualRow = lineToVisualRow(match.line);
+            if (visualRow < firstVisibleRow || visualRow > lastVisibleRow)
                 continue;
             const width = (match.endColumn - match.startColumn) * charWidth;
             if (width <= 0)
                 continue;
             rects.push({
-                top: match.line * lineHeight,
+                top: visualRow * lineHeight,
                 left: gutterWidth + contentPadding + match.startColumn * charWidth,
                 width,
                 height: lineHeight,

package/dist/components/editor/editor-input.d.ts

@@ -30,6 +30,7 @@ export interface EditorInputDeps {
         lineHeight: number;
         gutterWidth: number;
     };
+    visualRowToLine?: (visualRow: number) => number;
     /**
      * Editor tab size (columns per tab stop). Optional for backwards
      * compatibility; when omitted, DEFAULT_TAB_SIZE is used. Needed so that

package/dist/components/editor/editor-input.js

@@ -82,7 +82,10 @@ export function createEditorInput(deps) {
         const x = e.clientX - rect.left - gutterWidth - CONTENT_PADDING;
         const y = e.clientY - rect.top;
         const editorState = deps.getEditorState();
-        const line = Math.max(0, Math.min(Math.floor((y + scrollTop) / lineHeight), editorState.lineCount - 1));
+        const visualRow = Math.max(0, Math.min(Math.floor((y + scrollTop) / lineHeight), editorState.lineCount - 1));
+        const line = deps.visualRowToLine
+            ? deps.visualRowToLine(visualRow)
+            : Math.max(0, Math.min(visualRow, editorState.lineCount - 1));
         const lineContent = editorState.getLine(line);
         const lineText = lineContent?.text ?? '';
         const tabSize = deps.getTabSize?.() ?? DEFAULT_TAB_SIZE;

package/dist/components/editor/editor-scroll.d.ts

@@ -2,6 +2,7 @@ import type { Selection } from './core';
 export interface ScrollConfig {
     getEditorContent: () => HTMLDivElement | null;
     getSelection: () => Selection;
+    lineToVisualRow?: (line: number) => number;
     getMeasurements: () => {
         lineHeight: number;
         charWidth: number;

package/dist/components/editor/editor-scroll.js

@@ -8,7 +8,8 @@ export function createEditorScroll(config) {
             return;
         const selection = config.getSelection();
         const { lineHeight, charWidth, gutterWidth } = config.getMeasurements();
-        const cursorTop = selection.head.line * lineHeight;
+        const lineToVisualRow = config.lineToVisualRow ?? ((line) => line);
+        const cursorTop = lineToVisualRow(selection.head.line) * lineHeight;
         const cursorLeft = gutterWidth + CONTENT_PADDING + selection.head.column * charWidth;
         const viewportHeight = editorContent.clientHeight;
         const viewportWidth = editorContent.clientWidth;

package/dist/components/editor/index.d.ts

@@ -3,13 +3,29 @@
  */
 export { default as Editor } from './Editor.svelte';
 export { default as CustomEditor } from './CustomEditor.svelte';
-export { default as CollaborativeEditor } from './CollaborativeEditor.svelte';
 export { default as EditorTabs } from './EditorTabs.svelte';
 export { default as EditorPane } from './EditorPane.svelte';
 export { default as FileIcon } from './FileIcon.svelte';
 export { default as FileExplorer } from './FileExplorer.svelte';
-export * from './core';
+export * from './core/state';
+export * from './core/navigation';
+export * from './core/keybindings';
+export * from './core/search';
+export * from './core/folding';
+export * from './core/multi-cursor';
+export * from './core/complexity-analyzer';
+export * from './core/ai-awareness';
+export * from './core/semantic-analyzer';
+export * from './core/commands';
+export * from './core/bracket-healer';
+export * from './core/git-blame';
+export * from './core/snippet-manager';
+export * from './core/quick-actions';
+export * from './core/diagnostics';
+export * from './core/breakpoints';
+export type { Position } from './core/state';
+export type { Diagnostic, Range } from './core/quick-actions';
 export * from './theme';
 export { getLanguageExtension, getLanguageConfig, getLanguageFromExtension, getLanguageFromFilename, getLanguageFromMimeType, getAllLanguageConfigs, resolveLanguage, type LanguageConfig } from './languages';
 export { getSupportedLanguages, isLanguageSupported } from './languages';
-export { getTokenizer, tokenize, getTokenClass, tokensToHTML, PlaintextTokenizer, SimpleTokenizer, GrammarTokenizer, createToken, type Token, type TokenizedLine, type TokenizerState, type TokenType, type LanguageTokenizer, type TokenRule, type LanguageGrammar } from './tokenizer';
+export { getTokenizer, tokenize, getTokenClass, tokensToHTML, PlaintextTokenizer, createToken, type Token, type TokenizedLine, type TokenizerState, type TokenType, type LanguageTokenizer } from './tokenizer';