@nocturnium/svelte-ide 1.2.1 → 1.4.0

package/README.md

@@ -8,9 +8,10 @@ framework.
 [![license](https://img.shields.io/badge/license-MIT-blue.svg)](./LICENSE)
 [![svelte](https://img.shields.io/badge/Svelte-5-ff3e00.svg)](https://svelte.dev)
 
-Built from scratch with Svelte 5 runes and zero runtime UI dependencies. Use a
-single `<CustomEditor>` for a textarea-grade upgrade, or compose the editor,
-LSP, collaboration, AI, and plugin pieces into a full IDE experience.
+Built from scratch with Svelte 5 runes and **zero required runtime dependencies
+beyond the Svelte 5 peer**. Use a single `<CustomEditor>` for a textarea-grade
+upgrade, or compose the editor, LSP, collaboration, AI, and plugin pieces into a
+full IDE experience.
 
 ---
 
@@ -26,7 +27,9 @@ LSP, collaboration, AI, and plugin pieces into a full IDE experience.
 - **AI panel & agent presence** layers for assistant UI and presence patterns.
 - **Plugin system** with a proposal-based lifecycle (bring your own backend).
 - **Themeable** — every color/size is a CSS custom property you can override.
-- **Zero external UI dependencies**; collaboration deps are optional peers.
+- **Minimal footprint** — no required runtime dependencies beyond the Svelte 5
+  peer; styling is plain CSS variables (no CSS framework). The Yjs collaboration
+  stack is the only other runtime dependency, and it's an optional peer.
 
 ## Install
 
@@ -43,6 +46,25 @@ Collaboration is optional and tree-shakeable — install these only if you use t
 npm install yjs y-websocket y-protocols
 ```
 
+## Dependencies
+
+The published package carries **no top-level `dependencies`** — it ships with
+zero required runtime dependencies beyond the Svelte 5 peer.
+
+- **`svelte` `^5.0.0`** — the one required peer. Your app already has it.
+- **`yjs`, `y-protocols`, `y-websocket`** — _optional_ peers, marked
+  `optional: true`. They are imported only by the realtime-collaboration code
+  (`<CollaborativeEditor>` and the `./crdt` entry), so they're pulled in only if
+  you actually use collaboration. The rest of the library never touches them.
+- **No CSS framework at runtime.** Styling is plain CSS custom properties
+  shipped in `@nocturnium/svelte-ide/theme.css` — no Tailwind, no `@apply`, no
+  utility-class runtime. (Tailwind is used only to build this repo's demo site.)
+
+Everything else in `package.json` — Vite, ESLint, TypeScript, Vitest,
+Playwright, semantic-release, Tailwind, Prettier, and the rest — is a
+`devDependency` used to build, test, and lint the library. None of it is
+published: only the `dist/` folder ships (`"files": ["dist"]`).
+
 ## Quick start
 
 Import the component **and** the theme stylesheet (components are unstyled

package/dist/components/editor/CustomEditor.svelte

@@ -7,7 +7,13 @@
 		createKeyboardHandler,
 		createDefaultKeybindings,
 		createFoldManager,
+		extractFunctionAt,
+		extractVariableAt,
+		organizeImportsAt,
 		type EditorState,
+		type ExtractFunctionResult,
+		type ExtractVariableResult,
+		type OrganizeImportsResult,
 		type Selection,
 		type SearchMatch,
 		type FoldManager,
@@ -590,6 +596,51 @@
 		hiddenInput?.focus();
 	}
 
+	/**
+	 * Extract the current selection into a new function (Track H). Analyzes the
+	 * current content fresh (not the debounced complexityMetrics, which can lag a
+	 * recent edit) so the enclosing region is always correct, regardless of the
+	 * complexityHighlighting prop. The edit is applied as a single undo step; on
+	 * refusal the editor is untouched. Returns the result so callers can surface
+	 * the reason.
+	 */
+	export function extractFunction(): ExtractFunctionResult {
+		const metrics = complexityAnalyzer.analyze(editorState.lines, language);
+		const result = extractFunctionAt(editorState, metrics);
+		announce(result.ok ? 'Extracted function' : result.reason);
+		return result;
+	}
+
+	/**
+	 * Extract the current selection into a hoisted `const` (Track H). Single undo
+	 * step; on refusal the editor is untouched and the reason is returned.
+	 */
+	export function extractVariable(): ExtractVariableResult {
+		const result = extractVariableAt(editorState);
+		announce(result.ok ? 'Extracted variable' : result.reason);
+		return result;
+	}
+
+	/**
+	 * Sort, de-duplicate, and tidy the leading import block (Track H). Single undo
+	 * step; on refusal the editor is untouched and the reason is returned.
+	 */
+	export function organizeImports(): OrganizeImportsResult {
+		const result = organizeImportsAt(editorState);
+		announce(result.ok ? 'Organized imports' : result.reason);
+		return result;
+	}
+
+	/** Current primary selection (anchor/head), for callers driving code actions. */
+	export function getSelection(): Selection {
+		return editorState.selection;
+	}
+
+	/** Text covered by the current primary selection ('' when collapsed). */
+	export function getSelectedText(): string {
+		return editorState.getSelectedText();
+	}
+
 	function handleFoldIndicatorClick(lineNumber: number, e: MouseEvent) {
 		e.preventDefault();
 		e.stopPropagation();

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

@@ -1,5 +1,5 @@
 import type { EditorPreferences } from '../../types';
-import { type Cursor } from './core';
+import { type ExtractFunctionResult, type ExtractVariableResult, type OrganizeImportsResult, type Selection, type Cursor } from './core';
 import { type ComplexityMetrics, type ComplexityRegion } from './core/complexity-analyzer';
 import { type FoldPreset } from './core/semantic-analyzer';
 import type { AIAwareness } from './core/ai-awareness';
@@ -38,6 +38,11 @@ declare const CustomEditor: import("svelte").Component<Props, {
     unfoldAll: () => void;
     flashComplexityRegion: (region: ComplexityRegion) => void;
     scrollToLine: (line: number, region?: ComplexityRegion) => Promise<void>;
+    extractFunction: () => ExtractFunctionResult;
+    extractVariable: () => ExtractVariableResult;
+    organizeImports: () => OrganizeImportsResult;
+    getSelection: () => Selection;
+    getSelectedText: () => string;
 }, "content">;
 type CustomEditor = ReturnType<typeof CustomEditor>;
 export default CustomEditor;

package/dist/components/editor/core/apply-extract-plan.d.ts

@@ -0,0 +1,26 @@
+import type { EditorState } from './state';
+import { type ExtractPlan, type ExtractRefusal } from './extract-function';
+import type { ComplexityMetrics, ComplexityRegion } from './complexity-analyzer';
+export type ExtractFunctionResult = {
+    ok: true;
+} | ExtractRefusal;
+/**
+ * Find the innermost enclosing region whose [startLine, endLine] (0-based,
+ * inclusive) contains the block. Prefers `function` regions; ties are broken by
+ * the smallest span. Returns undefined when no region encloses the block.
+ */
+export declare function findEnclosingFunctionRegion(metrics: ComplexityMetrics | null, blockStart: number, blockEnd: number): ComplexityRegion | undefined;
+/**
+ * Apply a successful ExtractPlan to a live editor as a SINGLE undo step. Edits
+ * are issued bottom-up: the new function is inserted AFTER the enclosing
+ * function first (it sits below the block, so the block's line numbers stay
+ * valid), then the block is replaced by the call at its original indentation.
+ */
+export declare function applyExtractPlan(editor: EditorState, plan: ExtractPlan, blockStart: number, blockEnd: number): void;
+/**
+ * Extract the editor's current line selection into a new function. Finds the
+ * enclosing function from the complexity metrics, runs the (pure) planner, and
+ * either applies the plan or returns the planner's refusal so the caller can
+ * surface the reason to the user.
+ */
+export declare function extractFunctionAt(editor: EditorState, metrics: ComplexityMetrics | null): ExtractFunctionResult;

package/dist/components/editor/core/apply-extract-plan.js

@@ -0,0 +1,151 @@
+import { planExtractFunction } from './extract-function';
+import { tokenize } from '../tokenizer';
+// Tokens after which a `{` opens an object literal (a value position) rather than
+// a statement block.
+const OBJECT_LITERAL_PRECEDERS = new Set([
+    '=',
+    '(',
+    '[',
+    ',',
+    ':',
+    'return',
+    '=>',
+    '?',
+    '&&',
+    '||',
+    '??',
+    '!'
+]);
+/**
+ * Would the new function — inserted as a sibling after `insertAfterLine` — land
+ * inside a container where a `function` declaration is NOT valid (a class body,
+ * or an object/array literal)? The applier writes a bare `function extracted()`
+ * there, which is a SyntaxError, so the orchestration refuses these. Scans the
+ * brace nesting through the insertion line, classifying each `{` as a class
+ * body, object literal, or statement block.
+ */
+function insertionInNonFunctionContainer(lines, language, insertAfterLine) {
+    const source = lines
+        .slice(0, insertAfterLine + 1)
+        .map((line) => line.text)
+        .join('\n');
+    const tokens = tokenize(source, language)
+        .flatMap((line) => line.tokens)
+        .filter((t) => {
+        if (t.type === 'text')
+            return t.text.trim().length > 0;
+        if (t.type === 'comment' || t.type.startsWith('comment.'))
+            return false;
+        if (t.type === 'string' || t.type.startsWith('string.'))
+            return false;
+        return true;
+    });
+    const stack = [];
+    let prev = '';
+    let pendingClass = false;
+    for (const t of tokens) {
+        const text = t.text;
+        if (text === 'class' && t.type.startsWith('keyword')) {
+            pendingClass = true;
+        }
+        else if (text === '{') {
+            stack.push(pendingClass ? 'class' : OBJECT_LITERAL_PRECEDERS.has(prev) ? 'object' : 'block');
+            pendingClass = false;
+        }
+        else if (text === '}') {
+            stack.pop();
+        }
+        else if (text === '[') {
+            stack.push('object'); // array/computed literal is not a statement container
+        }
+        else if (text === ']') {
+            stack.pop();
+        }
+        prev = text;
+    }
+    const top = stack[stack.length - 1];
+    return top === 'object' || top === 'class';
+}
+/**
+ * Find the innermost enclosing region whose [startLine, endLine] (0-based,
+ * inclusive) contains the block. Prefers `function` regions; ties are broken by
+ * the smallest span. Returns undefined when no region encloses the block.
+ */
+export function findEnclosingFunctionRegion(metrics, blockStart, blockEnd) {
+    if (!metrics)
+        return undefined;
+    const containing = metrics.regions.filter((r) => r.startLine <= blockStart && blockEnd <= r.endLine);
+    if (containing.length === 0)
+        return undefined;
+    const functions = containing.filter((r) => r.type === 'function');
+    const pool = functions.length > 0 ? functions : containing;
+    return pool.reduce((best, r) => r.endLine - r.startLine < best.endLine - best.startLine ? r : best);
+}
+/**
+ * Apply a successful ExtractPlan to a live editor as a SINGLE undo step. Edits
+ * are issued bottom-up: the new function is inserted AFTER the enclosing
+ * function first (it sits below the block, so the block's line numbers stay
+ * valid), then the block is replaced by the call at its original indentation.
+ */
+export function applyExtractPlan(editor, plan, blockStart, blockEnd) {
+    // Geometry captured from the pre-edit document.
+    const indent = editor.getLine(blockStart)?.text.match(/^[ \t]*/)?.[0] ?? '';
+    const insertLine = plan.insertAfterLine;
+    const insertCol = editor.getLine(insertLine)?.text.length ?? 0;
+    const blockEndCol = editor.getLine(blockEnd)?.text.length ?? 0;
+    const callText = indent + plan.callText;
+    editor.transact((tx) => {
+        // 1. New function after the enclosing function's last line.
+        tx.insert({ line: insertLine, column: insertCol }, `\n${plan.functionText}`);
+        // 2. Remove the block's text — the lines collapse to one empty line at blockStart.
+        tx.delete({ line: blockStart, column: 0 }, { line: blockEnd, column: blockEndCol });
+        // 3. Drop in the call at the block's original indent.
+        tx.insert({ line: blockStart, column: 0 }, callText);
+    });
+    // Caret at the end of the new call.
+    editor.setCursor({ line: blockStart, column: callText.length });
+}
+/**
+ * Extract the editor's current line selection into a new function. Finds the
+ * enclosing function from the complexity metrics, runs the (pure) planner, and
+ * either applies the plan or returns the planner's refusal so the caller can
+ * surface the reason to the user.
+ */
+export function extractFunctionAt(editor, metrics) {
+    if (!editor.hasSelection) {
+        return { ok: false, reason: 'Select a block of statements to extract.' };
+    }
+    const { start, end } = editor.normalizedSelection;
+    const blockStart = start.line;
+    // A selection ending at column 0 of a later line covers the full lines above it.
+    const blockEnd = end.column === 0 && end.line > start.line ? end.line - 1 : end.line;
+    const region = findEnclosingFunctionRegion(metrics, blockStart, blockEnd);
+    if (!region) {
+        return { ok: false, reason: 'Place the selection inside a function to extract from.' };
+    }
+    // The applier inserts the new function as a sibling after the enclosing
+    // function's last line. The analyzer types class/object methods as `function`
+    // too, so that insertion can land inside a class body or object/array literal,
+    // where a bare `function extracted()` is a SyntaxError. Refuse rather than
+    // miswrite until method extraction is supported. (The region-based class check
+    // is kept as defense-in-depth alongside the brace-context scan.)
+    const inClassRegion = metrics?.regions.some((r) => r !== region &&
+        r.type === 'class' &&
+        r.startLine <= region.startLine &&
+        region.endLine <= r.endLine);
+    if (inClassRegion ||
+        insertionInNonFunctionContainer(editor.lines, editor.language, region.endLine)) {
+        return { ok: false, reason: 'Extracting from a class or object method is not supported yet.' };
+    }
+    const plan = planExtractFunction({
+        lines: editor.lines.map((line) => ({ text: line.text })),
+        language: editor.language,
+        region: { startLine: region.startLine, endLine: region.endLine, type: region.type },
+        blockStart,
+        blockEnd
+    });
+    if (!plan.ok)
+        return plan;
+    applyExtractPlan(editor, plan, blockStart, blockEnd);
+    return { ok: true };
+}

package/dist/components/editor/core/extract-function.js

@@ -123,7 +123,16 @@ function planExtractFunctionUnsafe(input) {
         return { ok: false, reason: 'Could not safely determine the block inputs and outputs.' };
     }
     for (const decl of insideDeclarations) {
-        if (usedAfterB.has(decl.name) && decl.depth > 0) {
+        // A name declared at depth > 0 inside the block and used after it is only
+        // conditionally defined — extracting it would drop the after-use's binding.
+        // The ONE safe exception is a nested arrow/catch/function PARAM that merely
+        // shadows an outer var (params are excluded from outputs, and the after-use
+        // resolves to the always-defined outer binding). A real lexical
+        // let/const/for-of declaration that shadows an outer name is NOT safe: it
+        // becomes a declared return and the call site emits a duplicate `const`.
+        if (usedAfterB.has(decl.name) &&
+            decl.depth > 0 &&
+            !(decl.kind === 'param' && declaredBeforeB.has(decl.name))) {
             return {
                 ok: false,
                 reason: 'A variable used after the block is only conditionally defined inside it.'
@@ -142,6 +151,18 @@ function planExtractFunctionUnsafe(input) {
     const returnNames = returns.map((item) => item.name);
     const declaredReturnNames = new Set(returnNames.filter((name) => declaredInsideB.has(name)));
     const outerReturnNames = returnNames.filter((name) => !declaredInsideB.has(name));
+    // A `const`-emitted return (a name declared inside the block) that ALSO has an
+    // outer binding before the block would write a duplicate `const <name>` at the
+    // call site (SyntaxError). This is depth-independent, so it covers the
+    // for-/while-header lexical declarations the brace-depth guard above cannot see
+    // (a `for (const v of …)` binding sits before the loop body brace).
+    const duplicateConstReturn = [...declaredReturnNames].find((name) => declaredBeforeB.has(name));
+    if (duplicateConstReturn) {
+        return {
+            ok: false,
+            reason: 'A variable declared in the block shadows an outer variable used after it.'
+        };
+    }
     if (returnNames.length > 1 && outerReturnNames.length > 0) {
         return {
             ok: false,
@@ -633,7 +654,13 @@ function isIdentifierUse(tokens, index) {
     return true;
 }
 function getAssignments(tokens, declarations) {
-    const assigned = declarations.map((decl) => ({
+    // Seed with the block's own let/const/var/function declarations (a declared
+    // value used after the block is a return). Nested fn/arrow/catch params are
+    // NOT outputs — they're bindings scoped to their construct; a real assignment
+    // to one is still picked up by the operator scan below.
+    const assigned = declarations
+        .filter((decl) => decl.kind !== 'param')
+        .map((decl) => ({
         name: decl.name,
         line: decl.line,
         col: decl.col,
@@ -677,6 +704,12 @@ function identifierInIncrement(tokens, index) {
     if (!areAdjacent(first, second))
         return undefined;
     const previous = tokens[index - 1];
+    // A run of 3+ identical operators (e.g. `a+++b` is `a++ + b`) yields overlapping
+    // pairs; only the run's leading pair is a real increment. Skip a pair whose
+    // previous token is the same operator adjacent to it, so the trailing operand
+    // (`b`) is never spuriously modeled as a mutation target.
+    if (previous && previous.text === first.text && areAdjacent(previous, first))
+        return undefined;
     const next = tokens[index + 2];
     const target = isIdentifierToken(previous)
         ? previous

package/dist/components/editor/core/extract-variable.d.ts

@@ -0,0 +1,48 @@
+import type { EditorState, Position } from './state';
+export type ExtractVariablePlan = {
+    ok: true;
+    /** Name of the hoisted constant (always `extracted` in this build). */
+    varName: string;
+    /** Full text of the new `const` line, including the statement's indentation. */
+    declarationLine: string;
+    /** 0-based line the declaration is inserted ABOVE (the selection's line). */
+    insertLine: number;
+    /** The trimmed selection range to overwrite with {@link varName}. */
+    replaceRange: {
+        start: Position;
+        end: Position;
+    };
+};
+export type ExtractVariableRefusal = {
+    ok: false;
+    reason: string;
+};
+export type ExtractVariableResult = {
+    ok: true;
+} | ExtractVariableRefusal;
+type PlanInput = {
+    lines: readonly {
+        text: string;
+    }[];
+    language: string;
+    selection: {
+        start: Position;
+        end: Position;
+    };
+};
+/**
+ * Plan the extraction of a selected expression into a hoisted `const`. PURE: no
+ * editor mutation. Returns a refusal (with a human reason) whenever the selection
+ * is anything other than a single, complete, single-line value expression — the
+ * safe-or-refuse contract. The token heuristics here are the runtime gate; the
+ * unit suite additionally parses every accepted result with acorn to prove the
+ * rewrite is valid JS (the parser oracle is test-only, never shipped).
+ */
+export declare function planExtractVariable(input: PlanInput): ExtractVariablePlan | ExtractVariableRefusal;
+/**
+ * Extract the editor's current selection into a hoisted `const` as a SINGLE undo
+ * step. On refusal the editor is untouched and the reason is returned so the
+ * caller can surface it.
+ */
+export declare function extractVariableAt(editor: EditorState): ExtractVariableResult;
+export {};

package/dist/components/editor/core/extract-variable.js

@@ -0,0 +1,457 @@
+import { resolveLanguage, tokenize } from '../tokenizer';
+const SUPPORTED_LANGUAGES = new Set(['javascript', 'typescript', 'jsx', 'tsx']);
+const VAR_NAME = 'extracted';
+const IDENTIFIER_TYPES = new Set(['variable', 'function.call', 'type.class']);
+// Keywords whose presence (at the selection's top nesting level) means the
+// selection is a statement, not a value expression. `new`/`typeof`/`instanceof`/
+// `in`/`of`/`void`/`delete`/`as` are deliberately ABSENT — they are valid inside
+// an expression. `function`/`class` ARE refused: a function/class expression is
+// valid JS but introduces a body we don't want to hoist blindly in this build.
+const STATEMENT_KEYWORDS = new Set([
+    'const',
+    'let',
+    'var',
+    'function',
+    'class',
+    'return',
+    'if',
+    'else',
+    'for',
+    'while',
+    'do',
+    'switch',
+    'case',
+    'default',
+    'break',
+    'continue',
+    'throw',
+    'try',
+    'catch',
+    'finally',
+    'import',
+    'export',
+    'with',
+    'debugger'
+]);
+const ASSIGNMENT_OPERATORS = new Set([
+    '=',
+    '+=',
+    '-=',
+    '*=',
+    '/=',
+    '%=',
+    '**=',
+    '&=',
+    '|=',
+    '^=',
+    '&&=',
+    '||=',
+    '??=',
+    '<<=',
+    '>>=',
+    '>>>='
+]);
+/**
+ * Plan the extraction of a selected expression into a hoisted `const`. PURE: no
+ * editor mutation. Returns a refusal (with a human reason) whenever the selection
+ * is anything other than a single, complete, single-line value expression — the
+ * safe-or-refuse contract. The token heuristics here are the runtime gate; the
+ * unit suite additionally parses every accepted result with acorn to prove the
+ * rewrite is valid JS (the parser oracle is test-only, never shipped).
+ */
+export function planExtractVariable(input) {
+    try {
+        return planExtractVariableUnsafe(input);
+    }
+    catch {
+        return { ok: false, reason: 'Could not safely analyze the selected expression.' };
+    }
+}
+function planExtractVariableUnsafe(input) {
+    const language = resolveLanguage(input.language);
+    if (!SUPPORTED_LANGUAGES.has(language)) {
+        return { ok: false, reason: 'Extract variable supports JavaScript/TypeScript only.' };
+    }
+    const { start, end } = input.selection;
+    if (start.line !== end.line) {
+        return { ok: false, reason: 'Select a single-line expression to extract.' };
+    }
+    const lineText = input.lines[start.line]?.text;
+    if (lineText === undefined) {
+        return { ok: false, reason: 'Select an expression to extract.' };
+    }
+    const rawStart = Math.max(0, Math.min(start.column, lineText.length));
+    const rawEnd = Math.max(rawStart, Math.min(end.column, lineText.length));
+    const raw = lineText.slice(rawStart, rawEnd);
+    const exprText = raw.trim();
+    if (exprText.length === 0) {
+        return { ok: false, reason: 'Select an expression to extract.' };
+    }
+    // Tighten the replace range to the trimmed span so surrounding whitespace is
+    // preserved exactly (a leading space before the selection stays put).
+    const leadWs = raw.length - raw.trimStart().length;
+    const trailWs = raw.length - raw.trimEnd().length;
+    const adjStart = { line: start.line, column: rawStart + leadWs };
+    const adjEnd = { line: start.line, column: rawEnd - trailWs };
+    const lineTokens = tokenize(lineText, language)[0]?.tokens ?? [];
+    // Boundary integrity: refuse when either edge of the selection falls STRICTLY
+    // inside a string, template, or comment token. Such a boundary slices a
+    // lexical token in half — the half-token is dropped by the column filter
+    // below (hiding it from every later gate) while the RAW text still carries the
+    // broken fragment (an unterminated string, or a `/*` that swallows the next
+    // line and silently deletes a binding). This single check closes that class.
+    if (splitsLexicalToken(lineTokens, adjStart.column) ||
+        splitsLexicalToken(lineTokens, adjEnd.column)) {
+        return { ok: false, reason: 'Selection splits a string, template, or comment.' };
+    }
+    const inRange = lineTokens.filter((token) => token.start >= adjStart.column && token.end <= adjEnd.column);
+    if (inRange.some(isCommentToken)) {
+        return { ok: false, reason: 'Selection contains a comment, not a pure expression.' };
+    }
+    const codeTokens = inRange.filter(isCodeToken);
+    // A string/number literal selection has no "code" tokens but is a fine
+    // expression. Only refuse when there is genuinely nothing of substance.
+    const meaningful = inRange.filter((token) => !isWhitespaceText(token) && !isCommentToken(token));
+    if (meaningful.length === 0) {
+        return { ok: false, reason: 'Select an expression to extract.' };
+    }
+    // Refuse trivially-simple selections (a lone identifier/number) — extracting
+    // `foo` to `const extracted = foo` is noise, not a refactor.
+    if (meaningful.length === 1 &&
+        (IDENTIFIER_TYPES.has(meaningful[0].type) ||
+            meaningful[0].type.startsWith('number') ||
+            meaningful[0].type.startsWith('constant'))) {
+        return { ok: false, reason: 'Selection is already a simple value; nothing to extract.' };
+    }
+    // Balance runs over `meaningful` (templates kept) so a template interpolation
+    // `${ … }` balances — its `${` is a string.template token while the closing
+    // `}` is a real code brace; counting only the brace would falsely reject every
+    // interpolated template.
+    const balanceRefusal = checkDelimiterBalance(meaningful);
+    if (balanceRefusal)
+        return balanceRefusal;
+    const statementRefusal = checkStatementShape(codeTokens);
+    if (statementRefusal)
+        return statementRefusal;
+    // Completeness runs over `meaningful` (literals kept) — not `codeTokens` —
+    // so a leading/trailing string or number literal reads as an operand, not as
+    // a missing one (e.g. `'Total: ' + total` must not look like a leading `+`).
+    const completenessRefusal = checkExpressionCompleteness(meaningful);
+    if (completenessRefusal)
+        return completenessRefusal;
+    // A side-effecting expression is only safe to hoist when the selection is the
+    // WHOLE value of its statement (`x = <sel>;` / `return <sel>;`). Pulling one
+    // out of a short-circuit (`a && f()`), a ternary branch, or a sibling-operand
+    // position (`g() + f()`) would change whether/when it runs — valid JS, wrong
+    // behavior. `meaningful` (templates kept) is passed so tagged templates count.
+    const callRefusal = checkCallContext(lineTokens.filter(isCodeToken), meaningful, adjStart, adjEnd);
+    if (callRefusal)
+        return callRefusal;
+    if (hasIdentifierNamed(allCodeTokens(input.lines, language), VAR_NAME)) {
+        return { ok: false, reason: `A variable named ${VAR_NAME} already exists.` };
+    }
+    const indent = lineText.match(/^[\t ]*/)?.[0] ?? '';
+    const declarationLine = `${indent}const ${VAR_NAME} = ${exprText};`;
+    return {
+        ok: true,
+        varName: VAR_NAME,
+        declarationLine,
+        insertLine: start.line,
+        replaceRange: { start: adjStart, end: adjEnd }
+    };
+}
+/**
+ * Extract the editor's current selection into a hoisted `const` as a SINGLE undo
+ * step. On refusal the editor is untouched and the reason is returned so the
+ * caller can surface it.
+ */
+export function extractVariableAt(editor) {
+    if (!editor.hasSelection) {
+        return { ok: false, reason: 'Select an expression to extract.' };
+    }
+    const { start, end } = editor.normalizedSelection;
+    const plan = planExtractVariable({
+        lines: editor.lines.map((line) => ({ text: line.text })),
+        language: editor.language,
+        selection: { start, end }
+    });
+    if (!plan.ok)
+        return plan;
+    applyExtractVariablePlan(editor, plan);
+    return { ok: true };
+}
+/**
+ * Apply a successful plan. Order matters: the in-line edits (remove the
+ * expression, drop in the name) run first against the original line, then the
+ * declaration is prepended at column 0 of that same line — a position the
+ * earlier edits never touched — so it lands as a new line directly above.
+ */
+function applyExtractVariablePlan(editor, plan) {
+    editor.transact((tx) => {
+        tx.delete(plan.replaceRange.start, plan.replaceRange.end);
+        tx.insert(plan.replaceRange.start, plan.varName);
+        tx.insert({ line: plan.insertLine, column: 0 }, `${plan.declarationLine}\n`);
+    });
+    // Caret on the new declaration so the user sees what was hoisted.
+    editor.setCursor({ line: plan.insertLine, column: plan.declarationLine.length });
+}
+function isCommentToken(token) {
+    return token.type === 'comment' || token.type.startsWith('comment.');
+}
+function isStringToken(token) {
+    return token.type === 'string' || token.type.startsWith('string.');
+}
+function isWhitespaceText(token) {
+    return token.type === 'text' && token.text.trim().length === 0;
+}
+function isCodeToken(token) {
+    return !isCommentToken(token) && !isStringToken(token) && !isWhitespaceText(token);
+}
+// Operates over `meaningful` tokens (code + strings/templates, no whitespace or
+// comments). Strings and regexes are opaque — their inner brackets/backticks
+// don't count. Template interpolation is handled symmetrically: a `${` template
+// token opens a brace that the interpolation's closing code `}` balances, and
+// the literal's backtick delimiters must pair up (an odd count = a cut template).
+function checkDelimiterBalance(tokens) {
+    const incomplete = {
+        ok: false,
+        reason: 'Selection is not a complete expression.'
+    };
+    let paren = 0;
+    let bracket = 0;
+    let brace = 0;
+    let backticks = 0;
+    for (const token of tokens) {
+        if (isTemplateToken(token)) {
+            backticks += (token.text.match(/`/g) ?? []).length;
+            if (token.text.endsWith('${'))
+                brace++; // interpolation open → matched by the code `}`
+            continue;
+        }
+        if (!isCodeToken(token))
+            continue; // ordinary strings / regexes are opaque
+        if (token.text === '(')
+            paren++;
+        else if (token.text === ')')
+            paren--;
+        else if (token.text === '[')
+            bracket++;
+        else if (token.text === ']')
+            bracket--;
+        else if (token.text === '{')
+            brace++;
+        else if (token.text === '}')
+            brace--;
+        if (paren < 0 || bracket < 0 || brace < 0)
+            return incomplete;
+    }
+    if (paren !== 0 || bracket !== 0 || brace !== 0)
+        return incomplete;
+    if (backticks % 2 === 1)
+        return incomplete; // a template literal cut mid-string
+    return undefined;
+}
+function isTemplateToken(token) {
+    return token.type === 'string.template';
+}
+/**
+ * Reject anything that isn't a single value expression: statement keywords,
+ * assignments, `await`/`yield`, statement terminators, or a top-level comma
+ * (a sequence that would change meaning when hoisted). Nesting is tracked so a
+ * comma INSIDE a call/array (depth &gt; 0) stays allowed.
+ */
+function checkStatementShape(tokens) {
+    let depth = 0;
+    for (let i = 0; i < tokens.length; i++) {
+        const token = tokens[i];
+        const text = token.text;
+        if (text === '(' || text === '[' || text === '{')
+            depth++;
+        else if (text === ')' || text === ']' || text === '}')
+            depth--;
+        if (text === ';') {
+            return { ok: false, reason: 'Selection must be a single expression, not a statement.' };
+        }
+        if (text === 'await' || text === 'yield') {
+            return { ok: false, reason: 'Selection uses await/yield and cannot be safely extracted.' };
+        }
+        if (depth === 0 && text === ',') {
+            return { ok: false, reason: 'Selection spans multiple expressions.' };
+        }
+        if (depth === 0 && text === '...') {
+            return { ok: false, reason: 'Selection is not a complete expression.' };
+        }
+        // Assignments and ++/-- are MUTATIONS — refuse at ANY nesting depth, since a
+        // parenthesized `(x = next())` or `(o.n += 1)` would otherwise slip past a
+        // depth-0-only check and get hoisted out of the position it mutates from.
+        if (isAssignmentOperator(token)) {
+            return { ok: false, reason: 'Selection contains an assignment, not a pure expression.' };
+        }
+        if (isIncrementHere(tokens, i)) {
+            return { ok: false, reason: 'Selection mutates a variable; not a pure value.' };
+        }
+        if (depth === 0 && STATEMENT_KEYWORDS.has(text) && token.type.startsWith('keyword')) {
+            return { ok: false, reason: 'Selection must be an expression, not a statement.' };
+        }
+    }
+    return undefined;
+}
+// `++`/`--` may arrive as one token or as two adjacent `+`/`-` tokens depending
+// on the tokenizer path — detect both. A mutation is never a pure value.
+function isIncrementHere(tokens, i) {
+    const t = tokens[i];
+    if (t.text === '++' || t.text === '--')
+        return true;
+    const next = tokens[i + 1];
+    return (t.text === '+' || t.text === '-') && next?.text === t.text && t.end === next.start;
+}
+function isAssignmentOperator(token) {
+    return token.type === 'operator' && ASSIGNMENT_OPERATORS.has(token.text);
+}
+// Operators valid as the FIRST token of an expression (prefix/unary). Anything
+// else leading (a binary `*`, `&&`, a stray `.`) means the selection starts
+// mid-expression.
+const VALID_LEADING_OPERATORS = new Set(['!', '~', '+', '-', '++', '--']);
+const POSTFIX_OPERATORS = new Set(['++', '--']);
+// Keyword operators the tokenizer types as `keyword` (or, for `satisfies`, as a
+// bare identifier) rather than `operator`, so the operator-typed first/last
+// checks miss them. INFIX need a LEFT operand (can't lead); NEEDS_RIGHT need a
+// RIGHT operand (can't trail). Matched by TEXT to cover the misclassification.
+const INFIX_KEYWORDS = new Set(['in', 'instanceof', 'as', 'satisfies']);
+const NEEDS_RIGHT_KEYWORDS = new Set([
+    'typeof',
+    'void',
+    'delete',
+    'new',
+    'keyof',
+    'in',
+    'instanceof',
+    'as',
+    'satisfies'
+]);
+/**
+ * Reject selections that start or end mid-expression — a dangling binary/member
+ * operator, a keyword operator missing an operand, or a mis-nested ternary —
+ * which the delimiter/statement gates miss but which would produce a SyntaxError
+ * like `const extracted = in registry;`. Conservative: a false refusal is safe,
+ * a false accept is not.
+ */
+function checkExpressionCompleteness(tokens) {
+    if (tokens.length === 0)
+        return undefined; // a bare string/number literal
+    const incomplete = {
+        ok: false,
+        reason: 'Selection is not a complete expression.'
+    };
+    const first = tokens[0];
+    if (first.text === '.')
+        return incomplete;
+    if (first.type === 'operator' && !VALID_LEADING_OPERATORS.has(first.text))
+        return incomplete;
+    if (INFIX_KEYWORDS.has(first.text))
+        return incomplete; // leading `in`/`as`/… has no left operand
+    const last = tokens[tokens.length - 1];
+    if (last.text === '.' || last.text === '?' || last.text === ':')
+        return incomplete;
+    if (last.type === 'operator' && !POSTFIX_OPERATORS.has(last.text))
+        return incomplete;
+    if (NEEDS_RIGHT_KEYWORDS.has(last.text))
+        return incomplete; // trailing `typeof`/`as`/… has no right operand
+    // Ternary balance at the selection's top level — a STACK, not a count, so a
+    // mis-ordered `b : c ? d` (colon before its `?`) is rejected. A `?` is a
+    // ternary head only when it is NOT optional chaining (`?.`) and NOT half of a
+    // nullish `??` (the tokenizer emits `??` and `?.` as two adjacent operators).
+    let depth = 0;
+    let openTernaries = 0;
+    for (let i = 0; i < tokens.length; i++) {
+        const token = tokens[i];
+        const text = token.text;
+        if (text === '(' || text === '[' || text === '{')
+            depth++;
+        else if (text === ')' || text === ']' || text === '}')
+            depth--;
+        else if (depth === 0 &&
+            text === '?' &&
+            !isPartOfPair(tokens, i, '?') &&
+            tokens[i + 1]?.text !== '.') {
+            openTernaries++;
+        }
+        else if (depth === 0 && text === ':') {
+            openTernaries--;
+            if (openTernaries < 0)
+                return incomplete; // a `:` with no preceding `?`
+        }
+    }
+    if (openTernaries !== 0)
+        return incomplete;
+    return undefined;
+}
+/** Strictly-inside test for the boundary-integrity gate. */
+function splitsLexicalToken(tokens, column) {
+    return tokens.some((t) => (isStringToken(t) || isCommentToken(t)) && t.start < column && column < t.end);
+}
+/**
+ * Half of an adjacent identical-operator pair, e.g. either `?` in `??` (which the
+ * tokenizer emits as two separate `?` operators). Used so a nullish `??` is not
+ * mistaken for a ternary head.
+ */
+function isPartOfPair(tokens, i, char) {
+    const t = tokens[i];
+    const prev = tokens[i - 1];
+    const next = tokens[i + 1];
+    return ((next?.text === char && t.end === next.start) || (prev?.text === char && prev.end === t.start));
+}
+/**
+ * Could the selection have a side effect when evaluated? Detecting every call
+ * FORM precisely (paren calls, optional calls `fn?.()`, keyword-named property
+ * calls `arr.in()`, tagged templates `` tag`x` ``, JSX with embedded calls) is a
+ * losing game against the tokenizer, so in the dangerous operand position we are
+ * deliberately conservative: ANY paren, `new`, or tagged template counts. A pure
+ * value (identifiers, member access, literals, operators) does not.
+ */
+function hasImpureConstruct(tokens) {
+    for (let i = 0; i < tokens.length; i++) {
+        const t = tokens[i];
+        if (t.text === '(')
+            return true; // a call, or a grouped paren — refuse either, conservatively
+        if (t.text === 'new' && t.type.startsWith('keyword'))
+            return true;
+        if (t.text === 'delete')
+            return true; // a `delete` expression mutates its target
+        if (isTemplateToken(t) && i > 0) {
+            const prev = tokens[i - 1];
+            // A template preceded by a value-producing token is a TAGGED template — a call.
+            if (IDENTIFIER_TYPES.has(prev.type) || prev.text === ')' || prev.text === ']')
+                return true;
+        }
+    }
+    return false;
+}
+/**
+ * When the selection is the COMPLETE right-hand value of its statement
+ * (`x = <sel>;` / `return <sel>;`), hoisting is always safe — the value is
+ * computed in the same place, one line up. When it is a strict sub-expression
+ * operand, refuse anything that could carry a side effect.
+ */
+function checkCallContext(lineCodeTokens, selTokens, adjStart, adjEnd) {
+    const prev = lineCodeTokens.filter((t) => t.end <= adjStart.column).at(-1);
+    const next = lineCodeTokens.find((t) => t.start >= adjEnd.column);
+    const isCompleteRhs = (!prev || prev.text === '=' || prev.text === 'return') && (!next || next.text === ';');
+    if (isCompleteRhs)
+        return undefined;
+    if (!hasImpureConstruct(selTokens))
+        return undefined;
+    return {
+        ok: false,
+        reason: 'Extracting a call or side-effecting expression from inside a larger expression could change when it runs.'
+    };
+}
+function allCodeTokens(lines, language) {
+    const source = lines.map((line) => line.text).join('\n');
+    return tokenize(source, language)
+        .flatMap((line) => line.tokens)
+        .filter(isCodeToken);
+}
+function hasIdentifierNamed(tokens, name) {
+    return tokens.some((token) => token.text === name && IDENTIFIER_TYPES.has(token.type));
+}

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

@@ -18,5 +18,8 @@ export * from './quick-actions';
 export * from './diagnostics';
 export * from './breakpoints';
 export * from './extract-function';
+export * from './apply-extract-plan';
+export * from './extract-variable';
+export * from './organize-imports';
 export type { Position } from './state';
 export type { Diagnostic, Range } from './quick-actions';

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

@@ -22,3 +22,6 @@ export * from './quick-actions';
 export * from './diagnostics';
 export * from './breakpoints';
 export * from './extract-function';
+export * from './apply-extract-plan';
+export * from './extract-variable';
+export * from './organize-imports';

package/dist/components/editor/core/organize-imports.d.ts

@@ -0,0 +1,38 @@
+import type { EditorState } from './state';
+export type OrganizeImportsPlan = {
+    ok: true;
+    /** 0-based first line of the import block being replaced. */
+    startLine: number;
+    /** 0-based last line of the import block being replaced (inclusive). */
+    endLine: number;
+    /** The reorganized import block (no trailing newline). */
+    newText: string;
+};
+export type OrganizeImportsRefusal = {
+    ok: false;
+    reason: string;
+};
+export type OrganizeImportsResult = {
+    ok: true;
+} | OrganizeImportsRefusal;
+/**
+ * Plan an "organize imports" rewrite of the leading import block: sort the
+ * statements by module path, sort the named specifiers within each, and drop
+ * exact-duplicate statements. PURE — no editor mutation.
+ *
+ * Safe-or-refuse: this build only touches a contiguous run of single-line
+ * `import … from '…'` statements at the top of the file. It refuses (rather than
+ * risk changing behavior) on side-effect imports, multi-line imports, comments
+ * interleaved in the block, or any statement it cannot fully parse.
+ */
+export declare function planOrganizeImports(input: {
+    lines: readonly {
+        text: string;
+    }[];
+    language: string;
+}): OrganizeImportsPlan | OrganizeImportsRefusal;
+/**
+ * Organize the editor's leading import block as a SINGLE undo step. On refusal
+ * the editor is untouched and the reason is returned.
+ */
+export declare function organizeImportsAt(editor: EditorState): OrganizeImportsResult;

package/dist/components/editor/core/organize-imports.js

@@ -0,0 +1,249 @@
+import { resolveLanguage } from '../tokenizer';
+const SUPPORTED_LANGUAGES = new Set(['javascript', 'typescript', 'jsx', 'tsx']);
+const IDENT = '[A-Za-z_$][\\w$]*';
+/**
+ * Plan an "organize imports" rewrite of the leading import block: sort the
+ * statements by module path, sort the named specifiers within each, and drop
+ * exact-duplicate statements. PURE — no editor mutation.
+ *
+ * Safe-or-refuse: this build only touches a contiguous run of single-line
+ * `import … from '…'` statements at the top of the file. It refuses (rather than
+ * risk changing behavior) on side-effect imports, multi-line imports, comments
+ * interleaved in the block, or any statement it cannot fully parse.
+ */
+export function planOrganizeImports(input) {
+    try {
+        return planOrganizeImportsUnsafe(input);
+    }
+    catch {
+        return { ok: false, reason: 'Could not safely parse the imports; leaving them untouched.' };
+    }
+}
+function planOrganizeImportsUnsafe(input) {
+    const language = resolveLanguage(input.language);
+    if (!SUPPORTED_LANGUAGES.has(language)) {
+        return { ok: false, reason: 'Organize imports supports JavaScript/TypeScript only.' };
+    }
+    const lines = input.lines.map((line) => line.text);
+    // Find the first import statement; everything above it (license headers,
+    // blank lines, leading comments) is left untouched.
+    const firstImport = lines.findIndex((text) => /^\s*import\b/.test(text));
+    if (firstImport === -1) {
+        return { ok: false, reason: 'No imports to organize.' };
+    }
+    // Walk the contiguous leading run: import lines and blank lines. A comment
+    // ENDS the run unless another import follows it — only a comment BETWEEN two
+    // imports is the unsupported "interleaved" case. A trailing body comment (a
+    // section header, the first JSDoc) is just the end of the block and must not
+    // make organize refuse.
+    let lastImport = firstImport;
+    const importLineIndices = [];
+    let sawCommentInRun = false;
+    let commentBetweenImports = false;
+    for (let i = firstImport; i < lines.length; i++) {
+        const text = lines[i];
+        if (text.trim().length === 0)
+            continue; // blank lines tolerated inside the run
+        if (isCommentLine(text)) {
+            sawCommentInRun = true;
+            continue;
+        }
+        if (!/^\s*import\b/.test(text))
+            break; // a code line ends the run
+        if (sawCommentInRun)
+            commentBetweenImports = true; // a comment preceded THIS import
+        importLineIndices.push(i);
+        lastImport = i;
+    }
+    if (commentBetweenImports) {
+        return { ok: false, reason: 'Comments between imports are not supported yet.' };
+    }
+    const indent = lines[firstImport].match(/^[\t ]*/)?.[0] ?? '';
+    const parsed = [];
+    for (const i of importLineIndices) {
+        const text = lines[i];
+        if (!hasBalancedBraces(text)) {
+            return { ok: false, reason: 'Multi-line imports are not supported yet.' };
+        }
+        if (isSideEffectImport(text)) {
+            return {
+                ok: false,
+                reason: 'Side-effect imports present; not reordering to preserve evaluation order.'
+            };
+        }
+        const imp = parseImport(text);
+        if (!imp) {
+            return { ok: false, reason: 'Could not safely parse the imports; leaving them untouched.' };
+        }
+        parsed.push(imp);
+    }
+    const emitted = parsed.map((imp) => `${indent}${emitImport(imp)}`);
+    const deduped = dedupe([...emitted.keys()]
+        .sort((a, b) => compareImport(parsed[a], parsed[b], emitted[a], emitted[b]))
+        .map((index) => emitted[index]));
+    const newText = deduped.join('\n');
+    const originalText = lines.slice(firstImport, lastImport + 1).join('\n');
+    if (newText === originalText) {
+        return { ok: false, reason: 'Imports are already organized.' };
+    }
+    return { ok: true, startLine: firstImport, endLine: lastImport, newText };
+}
+/**
+ * Organize the editor's leading import block as a SINGLE undo step. On refusal
+ * the editor is untouched and the reason is returned.
+ */
+export function organizeImportsAt(editor) {
+    const plan = planOrganizeImports({
+        lines: editor.lines.map((line) => ({ text: line.text })),
+        language: editor.language
+    });
+    if (!plan.ok)
+        return plan;
+    const endCol = editor.getLine(plan.endLine)?.text.length ?? 0;
+    editor.transact((tx) => {
+        tx.delete({ line: plan.startLine, column: 0 }, { line: plan.endLine, column: endCol });
+        tx.insert({ line: plan.startLine, column: 0 }, plan.newText);
+    });
+    const lastLineLength = plan.newText.split('\n').at(-1)?.length ?? 0;
+    const lastLine = plan.startLine + plan.newText.split('\n').length - 1;
+    editor.setCursor({ line: lastLine, column: lastLineLength });
+    return { ok: true };
+}
+function isCommentLine(text) {
+    const t = text.trim();
+    return t.startsWith('//') || t.startsWith('/*') || t.startsWith('*');
+}
+function hasBalancedBraces(text) {
+    let brace = 0;
+    for (const ch of text) {
+        if (ch === '{')
+            brace++;
+        else if (ch === '}')
+            brace--;
+        if (brace < 0)
+            return false;
+    }
+    return brace === 0;
+}
+function isSideEffectImport(text) {
+    return new RegExp(`^\\s*import\\s*(['"])[^'"]+\\1\\s*;?\\s*$`).test(text);
+}
+function parseImport(text) {
+    const trimmed = text.trim().replace(/;\s*$/, '');
+    const sourceMatch = trimmed.match(/\bfrom\s*(['"])([^'"]+)\1$/);
+    if (!sourceMatch)
+        return null;
+    const quote = sourceMatch[1];
+    const source = sourceMatch[2];
+    let clause = trimmed.slice('import'.length, trimmed.length - sourceMatch[0].length).trim();
+    if (clause.length === 0)
+        return null; // `import from 'x'` is invalid
+    // `import type { … }` / `import type Foo from …` / `import type * as ns` is
+    // type-only. But `import type from 'x'` and `import type, { a }` are DEFAULT
+    // imports named `type`, so only treat it as type-only when `type` is followed
+    // by a real clause start (`{`, `*`, or an identifier) — NOT a comma.
+    let typeOnly = false;
+    if (/^type\s+[{*A-Za-z_$]/.test(clause)) {
+        typeOnly = true;
+        clause = clause.replace(/^type\s+/, '').trim();
+    }
+    let named;
+    const braceMatch = clause.match(/\{([^}]*)\}/);
+    if (braceMatch) {
+        const parsedNamed = parseNamed(braceMatch[1]);
+        if (!parsedNamed)
+            return null;
+        named = parsedNamed;
+        const at = braceMatch.index ?? 0;
+        clause = (clause.slice(0, at) + clause.slice(at + braceMatch[0].length)).trim();
+        clause = clause.replace(/^,|,$/g, '').trim();
+    }
+    let defaultImport;
+    let namespace;
+    const remainders = clause
+        .split(',')
+        .map((part) => part.trim())
+        .filter(Boolean);
+    for (const part of remainders) {
+        const nsMatch = part.match(new RegExp(`^\\*\\s+as\\s+(${IDENT})$`));
+        if (nsMatch) {
+            if (namespace)
+                return null; // two namespace clauses is invalid
+            namespace = nsMatch[1];
+            continue;
+        }
+        if (new RegExp(`^${IDENT}$`).test(part)) {
+            if (defaultImport)
+                return null; // `import A, B from …` is invalid JS
+            defaultImport = part;
+            continue;
+        }
+        return null; // unrecognized clause fragment
+    }
+    if (!defaultImport && !namespace && !named)
+        return null;
+    // A namespace import cannot be combined with a named clause (`* as ns, { a }`
+    // and `d, * as ns, { a }` are SyntaxErrors). Refuse rather than re-emit them.
+    if (namespace && named)
+        return null;
+    return { source, quote, typeOnly, defaultImport, namespace, named };
+}
+function parseNamed(inner) {
+    const specs = [];
+    for (const raw of inner.split(',')) {
+        const spec = raw.trim();
+        if (spec.length === 0)
+            continue;
+        let body = spec;
+        let typeOnly = false;
+        const typeMatch = body.match(new RegExp(`^type\\s+(.*)$`));
+        if (typeMatch) {
+            typeOnly = true;
+            body = typeMatch[1].trim();
+        }
+        const aliasMatch = body.match(new RegExp(`^(${IDENT})\\s+as\\s+(${IDENT})$`));
+        if (aliasMatch) {
+            specs.push({ name: aliasMatch[1], alias: aliasMatch[2], typeOnly });
+            continue;
+        }
+        if (new RegExp(`^${IDENT}$`).test(body)) {
+            specs.push({ name: body, typeOnly });
+            continue;
+        }
+        return null;
+    }
+    return specs;
+}
+function emitImport(imp) {
+    const parts = [];
+    if (imp.defaultImport)
+        parts.push(imp.defaultImport);
+    if (imp.namespace)
+        parts.push(`* as ${imp.namespace}`);
+    if (imp.named) {
+        const specs = [...imp.named]
+            .sort((a, b) => compareName(a.name, b.name))
+            .map((n) => `${n.typeOnly ? 'type ' : ''}${n.name}${n.alias ? ` as ${n.alias}` : ''}`);
+        // An import with ONLY an empty `{}` is preserved as `{}` (valid, rare).
+        parts.push(`{ ${specs.join(', ')} }`);
+    }
+    const clause = parts.join(', ');
+    return `import ${imp.typeOnly ? 'type ' : ''}${clause} from ${imp.quote}${imp.source}${imp.quote};`;
+}
+function compareName(a, b) {
+    return a.toLowerCase().localeCompare(b.toLowerCase()) || a.localeCompare(b);
+}
+function compareImport(a, b, aLine, bLine) {
+    return compareName(a.source, b.source) || aLine.localeCompare(bLine);
+}
+function dedupe(sortedLines) {
+    const seen = new Set();
+    const out = [];
+    for (const line of sortedLines) {
+        if (seen.has(line))
+            continue;
+        seen.add(line);
+        out.push(line);
+    }
+    return out;
+}

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

@@ -25,6 +25,16 @@ export interface Selection {
     /** End of selection (head/cursor position) */
     head: Position;
 }
+/**
+ * Primitive edits available inside {@link EditorState.transact}. Every insert
+ * and delete is folded into a single undo step.
+ */
+export interface EditorTransaction {
+    /** Insert text at a position; returns the position after the inserted text. */
+    insert(position: Position, text: string): Position;
+    /** Delete the range [from, to) (end exclusive). */
+    delete(from: Position, to: Position): void;
+}
 /**
  * A single line in the document
  */
@@ -271,6 +281,15 @@ export declare class EditorState {
      * Insert text at all cursor positions
      */
     insert(text: string): void;
+    /**
+     * Run several primitive edits as ONE undoable transaction. Inserts/deletes
+     * performed via the provided `tx` are folded into a single history entry, so
+     * one undo reverts the whole change and one redo reapplies it. Used by
+     * multi-edit refactors such as extract-function. Emits a single content +
+     * selection + cursor change after the body so subscribers (and `bind:content`)
+     * update once.
+     */
+    transact(fn: (tx: EditorTransaction) => void): void;
     /**
      * Insert text at a specific position (internal, doesn't update cursor)
      * @returns New position after insert

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

@@ -376,6 +376,30 @@ export class EditorState {
         this.emitCursorChange();
         this.commitHistory(history, 'insert');
     }
+    /**
+     * Run several primitive edits as ONE undoable transaction. Inserts/deletes
+     * performed via the provided `tx` are folded into a single history entry, so
+     * one undo reverts the whole change and one redo reapplies it. Used by
+     * multi-edit refactors such as extract-function. Emits a single content +
+     * selection + cursor change after the body so subscribers (and `bind:content`)
+     * update once.
+     */
+    transact(fn) {
+        // Force a fresh, isolated history entry: don't merge into prior typing, and
+        // (after commit) don't let the next keystroke merge into this one.
+        this.lastHistoryType = null;
+        const history = this.beginHistory('insert');
+        fn({
+            insert: (position, text) => this.insertAtInternal(position, text, history.entry.changes),
+            delete: (from, to) => this.deleteRangeInternal(from, to, history.entry.changes)
+        });
+        // The internal primitives don't move cursors; clamp the primary so it stays
+        // valid against the new content (callers may set a more precise position).
+        this.setCursor(this.clampPosition(this.selection.head));
+        this.emitChange({ type: 'replace', from: { line: 0, column: 0 } });
+        this.commitHistory(history, 'insert');
+        this.lastHistoryType = null;
+    }
     /**
      * Insert text at a specific position (internal, doesn't update cursor)
      * @returns New position after insert

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@nocturnium/svelte-ide",
-	"version": "1.2.1",
+	"version": "1.4.0",
 	"description": "Svelte 5 code editor and IDE building blocks — custom editor, syntax highlighting, code folding, multi-cursor, LSP client, and optional realtime collaboration.",
 	"author": "Nocturnium & Jordan Dziat <hello@nocturnium.ai> (https://nocturnium.ai)",
 	"license": "MIT",
@@ -142,6 +142,7 @@
 		"@sveltejs/vite-plugin-svelte": "^5.1.0",
 		"@tailwindcss/vite": "^4.1.0",
 		"@types/node": "^22.15.0",
+		"acorn": "^8.16.0",
 		"eslint": "^9.39.0",
 		"eslint-plugin-svelte": "^3.9.0",
 		"globals": "^16.2.0",