@coldsmirk/inkstone-monaco 0.8.2 → 0.9.0

package/README.md

@@ -8,8 +8,10 @@ Part of [inkstone](https://github.com/coldsmirk/inkstone). For a drop-in React c
 
 - **`ensureMonacoHost(options?)`** — the process-wide host: resolves the local `monaco-editor` module (never the CDN), routes **all** built-in language workers (base editor, TypeScript/JavaScript, JSON, CSS/scss/less, HTML/handlebars/razor) as bundler-emitted chunks so everything works offline, and applies `locale: "zh-cn"` via Monaco's official NLS catalog when asked. Idempotent — every caller gets the same module; a load failure is not cached, so a fresh call retries.
 - **`getWorker` extension point** — plug third-party language workers (e.g. monaco-yaml) into the routing; return `undefined` to fall back to the built-in routes.
+- **`monacoLanguages`** — the sorted catalog of every built-in language id the installed Monaco registers (with the `MonacoBuiltInLanguage` union type behind it), held to the installed `monaco-editor` by an upgrade-tripwire test. These are *ids*, not display names (`proto`, `sol`, `aes`); an unknown id silently falls back to `plaintext`.
+- **`disabledKeybindings` / `installDisabledKeybindings`** — swallow the find/replace chords and the command palette's F1 for editors that opt in. Monaco's standalone keybinding service is page-global and its rules are permanent, so the install registers each chord once per monaco module's service (duplicate copies of this package share the ledger; independent monaco bundles register their own) and scopes it with a per-capability context key created on the opted-in editor; the chord table is held to the installed `monaco-editor` by an upgrade-tripwire test.
 - **Embedded-editor fix** — works around [microsoft/monaco-editor#5177](https://github.com/microsoft/monaco-editor/issues/5177) (find-widget button tooltips landing on top of the buttons they describe) with a `width: max-content` hover-layer style tagged `data-inkstone="monaco-hover-geometry"`; deleted the moment upstream fixes it. The tooltip layer positions against the editor's container — give that container `position: relative`.
-- **`StreamingEditorController`** — stream generated text into an editor without routing every token through app state: `begin()` / `append(chunk)` / `end()` / `discard()`, `attach(editor)` / `detach(editor)` with buffered replay for late-mounting editors, `isStreaming()` for the onChange guard, and `replace(old, new, all)` for exact edits that preserve undo/cursor/folds.
+- **`StreamingEditorController`** — stream generated text into an editor without routing every token through app state: `begin()` / `append(chunk)` / `end()` / `discard()`, `attach(editor)` / `detach(editor)` with buffered replay for late-mounting editors (and for a model swapped onto the attached editor mid-stream, including after the final chunk), `isStreaming()` for the onChange guard, and `replace(old, new, all)` for exact edits that preserve undo/cursor/folds. The stream locks every editor it touches read-only and `end()` / `discard()` restore each one's own setting — by handle, so an editor detached mid-stream is restored too; `discard()` puts every displaced document back into the model it came from, and `end()` does the same for every model except the one keeping the streamed text. Full-buffer writes and restorations preserve each model's UTF-8 BOM. Editors and models the app disposed mid-stream are skipped, never touched — teardown can race the stream without wedging it.
 
 ## Install
 

package/dist/index.d.ts

@@ -33,14 +33,71 @@ interface MonacoHostOptions {
 type MonacoModule = typeof monacoEditor;
 declare function ensureMonacoHost(options?: MonacoHostOptions): Promise<MonacoModule>;
 //#endregion
+//#region src/keybindings.d.ts
+/**
+ * A set of keybindings to swallow, plus the context key that scopes them to the editors that
+ * opted in.
+ */
+interface SwallowedKeybindings {
+  readonly contextKey: string;
+  readonly keybindings: readonly number[];
+}
+/**
+ * The keybindings `disableFind` / `disableCommandPalette` swallow: the find/replace widget's
+ * entries (Ctrl/Cmd+F to find; Ctrl+H and Cmd+Alt+F, the per-platform replace bindings) and
+ * the command palette's F1 — Monaco never binds Ctrl+Shift+P (a VS Code binding). Sourced
+ * from monaco-editor 0.55.1 (`findController.js`, `standaloneCommandsQuickAccess.js`).
+ *
+ * Both replace chords are swallowed on every platform rather than branching: `CtrlCmd` already
+ * resolves per platform, and the off-platform chord (Ctrl+Alt+F on Windows, Cmd+H on macOS, where
+ * the OS takes the key before the page sees it) is one Monaco never bound.
+ */
+declare function disabledKeybindings(monaco: MonacoModule, disableFind: boolean, disableCommandPalette: boolean): SwallowedKeybindings[];
+/**
+ * The slice of a standalone editor the install touches — a structural type, so the install is
+ * testable without evaluating the monaco module (which jsdom cannot do).
+ */
+interface KeybindingTargetEditor {
+  createContextKey: (key: string, defaultValue: boolean) => unknown;
+  addCommand: (keybinding: number, handler: () => void, context?: string) => string | null;
+}
+/**
+ * Opt `editorInstance` into swallowing `groups` on `monaco`'s keybinding service: it always
+ * creates its own context keys (that is what scopes the rules to it), but each chord goes onto
+ * the page-global service only the first time any editor of that monaco module asks for it —
+ * monaco offers no way to unregister one.
+ */
+declare function installDisabledKeybindings(monaco: MonacoModule, editorInstance: KeybindingTargetEditor, groups: readonly SwallowedKeybindings[]): void;
+//#endregion
 //#region src/languages.d.ts
 /**
- * Monaco's built-in language ids — the set Monaco ships tokenizers for out of the box, used
- * to type `<MonacoEditor language>`. Monaco also accepts any custom-registered id (e.g. a
+ * Monaco's built-in language ids: every id the editor registers out of the box, sourced from the
+ * installed monaco-editor and held to it by `languages.test.ts` — a bump that adds, renames, or
+ * drops a language fails the suite until this list is updated.
+ *
+ * These are *ids*, not display names, and the two diverge more than they look: protobuf registers
+ * as `proto`, Solidity as `sol`, Sophia as `aes`. Monaco silently falls back to `plaintext` for an
+ * unknown id, so an id that reads right but is not one of these buys no tokenizer at all.
+ *
+ * Three ids come from outside `basic-languages`: `json` (the JSON language service),
+ * `typescript` / `javascript` (also served by the TypeScript worker), and `plaintext` (the editor
+ * core's fallback language).
+ */
+declare const BUILT_IN_LANGUAGES: readonly ["abap", "aes", "apex", "azcli", "bat", "bicep", "c", "cameligo", "clojure", "coffeescript", "cpp", "csharp", "csp", "css", "cypher", "dart", "dockerfile", "ecl", "elixir", "flow9", "freemarker2", "freemarker2.tag-angle.interpolation-bracket", "freemarker2.tag-angle.interpolation-dollar", "freemarker2.tag-auto.interpolation-bracket", "freemarker2.tag-auto.interpolation-dollar", "freemarker2.tag-bracket.interpolation-bracket", "freemarker2.tag-bracket.interpolation-dollar", "fsharp", "go", "graphql", "handlebars", "hcl", "html", "ini", "java", "javascript", "json", "julia", "kotlin", "less", "lexon", "liquid", "lua", "m3", "markdown", "mdx", "mips", "msdax", "mysql", "objective-c", "pascal", "pascaligo", "perl", "pgsql", "php", "pla", "plaintext", "postiats", "powerquery", "powershell", "proto", "pug", "python", "qsharp", "r", "razor", "redis", "redshift", "restructuredtext", "ruby", "rust", "sb", "scala", "scheme", "scss", "shell", "sol", "sparql", "sql", "st", "swift", "systemverilog", "tcl", "twig", "typescript", "typespec", "vb", "verilog", "wgsl", "xml", "yaml"];
+/**
+ * A language id Monaco registers out of the box.
+ */
+type MonacoBuiltInLanguage = (typeof BUILT_IN_LANGUAGES)[number];
+/**
+ * Every built-in Monaco language id, sorted.
+ */
+declare const monacoLanguages: readonly MonacoBuiltInLanguage[];
+/**
+ * The `<MonacoEditor language>` type. Monaco also accepts any custom-registered id (e.g. a
  * language wired through `getWorker` such as monaco-yaml), so the type stays open: the union
  * drives editor autocomplete while `string & Record<never, never>` still admits any string.
  */
-type MonacoLanguage = "abap" | "apex" | "azcli" | "bat" | "bicep" | "cameligo" | "clojure" | "coffeescript" | "cpp" | "csharp" | "csp" | "css" | "cypher" | "dart" | "dockerfile" | "ecl" | "elixir" | "flow9" | "freemarker2" | "fsharp" | "go" | "graphql" | "handlebars" | "hcl" | "html" | "ini" | "java" | "javascript" | "json" | "julia" | "kotlin" | "less" | "lexon" | "liquid" | "lua" | "m3" | "markdown" | "mdx" | "mips" | "msdax" | "mysql" | "objective-c" | "pascal" | "pascaligo" | "perl" | "pgsql" | "php" | "pla" | "postiats" | "powerquery" | "powershell" | "protobuf" | "pug" | "python" | "qsharp" | "r" | "razor" | "redis" | "redshift" | "restructuredtext" | "ruby" | "rust" | "sb" | "scala" | "scheme" | "scss" | "shell" | "solidity" | "sophia" | "sparql" | "sql" | "st" | "swift" | "systemverilog" | "tcl" | "twig" | "typescript" | "typespec" | "vb" | "wgsl" | "xml" | "yaml" | "plaintext" | (string & Record<never, never>);
+type MonacoLanguage = MonacoBuiltInLanguage | (string & Record<never, never>);
 //#endregion
 //#region src/streaming.d.ts
 /**
@@ -67,13 +124,68 @@ declare class StreamingEditorController {
   private editor;
   private writing;
   private buffer;
+  /**
+   * Every editor instance the stream locked, each with its OWN pre-lock `readOnly` setting
+   * (the stream forces `readOnly: true`, so restoring a hardcoded `false` would silently
+   * unlock an editor the app declared read-only). Keyed by the instance handle so the
+   * restore reaches detached editors too — a keep-alive host that never remounts must not
+   * stay locked forever. The watcher evicts the entry the moment the instance is disposed
+   * (an unmount tears the editor down for good): a dead editor needs no restore, and
+   * `ICodeEditor` has no `isDisposed()` to check at restore time.
+   */
+  private readonly locked;
+  /**
+   * Every model whose content the stream overwrote, with the document it displaced. Keyed by
+   * the model handle so {@link discard} (every model) and {@link end} (every model except the
+   * one keeping the streamed text) put each document back into the model it came from — not
+   * into whichever model happens to be attached at teardown (the app may have switched
+   * documents or swapped in a replacement editor mid-stream).
+   */
+  private readonly displaced;
+  /**
+   * The model currently holding the streamed text. {@link append} extends it chunk by chunk;
+   * any other model reaching the write path (the app swapped documents on the attached editor
+   * mid-stream) is first brought up to date with a full buffer replay — an incremental append
+   * would silently drop every chunk streamed before the swap.
+   */
+  private synced;
+  /**
+   * Lock the editor for the stream: record its own pre-lock `readOnly` first (once per
+   * instance, so a re-lock after a remount cannot overwrite the snapshot with the stream's
+   * `readOnly: true`), then lock it.
+   */
+  private takeOver;
+  /**
+   * Snapshot what the stream is about to overwrite in this model — once per model, just
+   * before the first stream write into it. Every model write path must claim first ({@link
+   * begin}'s clear, {@link attach}'s buffer replay, {@link append}'s edit): any of them can
+   * be the first to touch a model the stream has not seen, since the app may swap models or
+   * editors mid-stream.
+   */
+  private claim;
+  /**
+   * The streamed buffer as stored in this model, preserving its displaced document's BOM.
+   */
+  private valueFor;
+  /**
+   * Claim a model and bring it up to the complete buffered stream in one handle-stable write.
+   */
+  private replay;
+  /**
+   * Hand every locked editor back with its own `readOnly` setting, via the handle recorded
+   * at lock time — a detached instance is restored too, not just the currently attached one.
+   * Drops both stream snapshots; the next stream starts fresh.
+   */
+  private releaseAll;
   /**
    * Bind the mounted editor. If a stream is in progress, the buffered content is synced
    * into the model immediately and the editor is set read-only.
    */
   attach(instance: StreamTargetEditor): void;
   /**
-   * Release the editor (unmount). A stream in progress keeps accumulating in the buffer.
+   * Release the editor (unmount). A stream in progress keeps accumulating in the buffer, and
+   * the lock / displaced-document snapshots keep their handles — {@link end} and
+   * {@link discard} restore this instance and its model even while it stays detached.
    */
   detach(instance: StreamTargetEditor): void;
   /**
@@ -82,7 +194,8 @@ declare class StreamingEditorController {
    */
   isStreaming(): boolean;
   /**
-   * Start a stream: clears the buffer and the editor, and sets it read-only.
+   * Start a stream: clears the buffer and the editor (snapshotting the document the clear
+   * displaces), and sets it read-only.
    */
   begin(): void;
   /**
@@ -92,22 +205,28 @@ declare class StreamingEditorController {
   append(text: string): void;
   /**
    * End the stream and return the full streamed text — the caller reconciles it into app
-   * state (one write, replacing the per-token churn).
+   * state (one write, replacing the per-token churn). The streamed document stays on screen
+   * in the model that currently holds it; every OTHER model the stream wrote in passing (the
+   * app switched documents away and back mid-stream) gets its own displaced document back,
+   * instead of being stranded with an intermediate slice of the stream. Every editor the
+   * stream locked gets its own `readOnly` setting back, attached or not.
    */
   end(): string;
   /**
-   * Abort mid-stream WITHOUT yielding the buffer: clears the writing/read-only state and
-   * drops the partial text. For teardown paths (document switch / reset) where flushing
-   * the partial stream into the now-current document would corrupt it.
+   * Abort mid-stream WITHOUT yielding the buffer: drops the partial text, puts every
+   * displaced document back into the model it came from (even a detached one), and restores
+   * every locked editor's `readOnly` setting. For teardown paths (document switch / reset)
+   * where flushing the partial stream into the now-current document would corrupt it.
    */
   discard(): void;
   /**
    * Exact find-and-replace on the attached editor, located by character offset and applied
    * via `executeEdits` — preserving the undo stack, cursor, and fold state. Returns whether
-   * it was applied (`false` = no editor / empty search / no match; the caller falls back to
-   * a state write).
+   * it was applied (`false` = no editor / empty search / no match, or an editor that refused
+   * the edit because it is read-only — a stream in progress; the caller falls back to a state
+   * write).
    */
   replace(search: string, replaceWith: string, all: boolean): boolean;
 }
 //#endregion
-export { type MonacoHostOptions, type MonacoLanguage, type MonacoModule, type MonacoUiLocale, type StreamTargetEditor, StreamingEditorController, ensureMonacoHost };
+export { type KeybindingTargetEditor, type MonacoBuiltInLanguage, type MonacoHostOptions, type MonacoLanguage, type MonacoModule, type MonacoUiLocale, type StreamTargetEditor, StreamingEditorController, type SwallowedKeybindings, disabledKeybindings, ensureMonacoHost, installDisabledKeybindings, monacoLanguages };

package/dist/index.js

@@ -43,17 +43,186 @@ function ensureMonacoHost(options = {}) {
 	return hostPromise;
 }
 //#endregion
+//#region src/keybindings.ts
+const FIND_CONTEXT_KEY = "inkstoneFindDisabled";
+const COMMAND_PALETTE_CONTEXT_KEY = "inkstoneCommandPaletteDisabled";
+const REGISTRY_KEY = Symbol.for("coldsmirk.inkstone.monaco.keybindingRegistry");
+function landedChords(monaco) {
+	const holder = globalThis;
+	let registries = holder[REGISTRY_KEY];
+	if (!registries) {
+		registries = /* @__PURE__ */ new WeakMap();
+		holder[REGISTRY_KEY] = registries;
+	}
+	const existing = registries.get(monaco);
+	if (existing) return existing;
+	const created = /* @__PURE__ */ new Map();
+	registries.set(monaco, created);
+	return created;
+}
+function disabledKeybindings(monaco, disableFind, disableCommandPalette) {
+	const { KeyCode, KeyMod } = monaco;
+	return [...disableFind ? [{
+		contextKey: FIND_CONTEXT_KEY,
+		keybindings: [
+			KeyMod.CtrlCmd | KeyCode.KeyF,
+			KeyMod.CtrlCmd | KeyCode.KeyH,
+			KeyMod.CtrlCmd | KeyMod.Alt | KeyCode.KeyF
+		]
+	}] : [], ...disableCommandPalette ? [{
+		contextKey: COMMAND_PALETTE_CONTEXT_KEY,
+		keybindings: [KeyCode.F1]
+	}] : []];
+}
+function installDisabledKeybindings(monaco, editorInstance, groups) {
+	const registered = landedChords(monaco);
+	for (const { contextKey, keybindings } of groups) {
+		editorInstance.createContextKey(contextKey, true);
+		let landed = registered.get(contextKey);
+		if (!landed) {
+			landed = /* @__PURE__ */ new Set();
+			registered.set(contextKey, landed);
+		}
+		for (const keybinding of keybindings) if (!landed.has(keybinding) && editorInstance.addCommand(keybinding, () => void 0, contextKey) !== null) landed.add(keybinding);
+	}
+}
+const monacoLanguages = [
+	"abap",
+	"aes",
+	"apex",
+	"azcli",
+	"bat",
+	"bicep",
+	"c",
+	"cameligo",
+	"clojure",
+	"coffeescript",
+	"cpp",
+	"csharp",
+	"csp",
+	"css",
+	"cypher",
+	"dart",
+	"dockerfile",
+	"ecl",
+	"elixir",
+	"flow9",
+	"freemarker2",
+	"freemarker2.tag-angle.interpolation-bracket",
+	"freemarker2.tag-angle.interpolation-dollar",
+	"freemarker2.tag-auto.interpolation-bracket",
+	"freemarker2.tag-auto.interpolation-dollar",
+	"freemarker2.tag-bracket.interpolation-bracket",
+	"freemarker2.tag-bracket.interpolation-dollar",
+	"fsharp",
+	"go",
+	"graphql",
+	"handlebars",
+	"hcl",
+	"html",
+	"ini",
+	"java",
+	"javascript",
+	"json",
+	"julia",
+	"kotlin",
+	"less",
+	"lexon",
+	"liquid",
+	"lua",
+	"m3",
+	"markdown",
+	"mdx",
+	"mips",
+	"msdax",
+	"mysql",
+	"objective-c",
+	"pascal",
+	"pascaligo",
+	"perl",
+	"pgsql",
+	"php",
+	"pla",
+	"plaintext",
+	"postiats",
+	"powerquery",
+	"powershell",
+	"proto",
+	"pug",
+	"python",
+	"qsharp",
+	"r",
+	"razor",
+	"redis",
+	"redshift",
+	"restructuredtext",
+	"ruby",
+	"rust",
+	"sb",
+	"scala",
+	"scheme",
+	"scss",
+	"shell",
+	"sol",
+	"sparql",
+	"sql",
+	"st",
+	"swift",
+	"systemverilog",
+	"tcl",
+	"twig",
+	"typescript",
+	"typespec",
+	"vb",
+	"verilog",
+	"wgsl",
+	"xml",
+	"yaml"
+].toSorted();
+//#endregion
 //#region src/streaming.ts
+const UTF8_BOM = "";
 var StreamingEditorController = class {
 	editor = null;
 	writing = false;
 	buffer = "";
+	locked = /* @__PURE__ */ new Map();
+	displaced = /* @__PURE__ */ new Map();
+	synced = null;
+	takeOver(instance) {
+		if (!this.locked.has(instance)) this.locked.set(instance, {
+			readOnly: instance.getRawOptions().readOnly ?? false,
+			watcher: instance.onDidDispose(() => this.locked.delete(instance))
+		});
+		instance.updateOptions({ readOnly: true });
+	}
+	claim(model) {
+		if (!this.displaced.has(model)) this.displaced.set(model, model.getValue(void 0, true));
+	}
+	valueFor(model) {
+		return this.displaced.get(model)?.startsWith(UTF8_BOM) ? UTF8_BOM + this.buffer : this.buffer;
+	}
+	replay(instance, model) {
+		this.claim(model);
+		this.synced = model;
+		model.setValue(this.valueFor(model));
+		if (!model.isDisposed() && instance.getModel() === model) instance.revealLine(model.getLineCount());
+	}
+	releaseAll() {
+		for (const [instance, lock] of this.locked) {
+			lock.watcher.dispose();
+			instance.updateOptions({ readOnly: lock.readOnly });
+		}
+		this.locked.clear();
+		this.displaced.clear();
+		this.synced = null;
+	}
 	attach(instance) {
 		this.editor = instance;
 		if (this.writing) {
-			instance.updateOptions({ readOnly: true });
-			instance.setValue(this.buffer);
-			instance.revealLine(instance.getModel()?.getLineCount() ?? 1);
+			this.takeOver(instance);
+			const model = instance.getModel();
+			if (model) this.replay(instance, model);
 		}
 	}
 	detach(instance) {
@@ -65,9 +234,11 @@ var StreamingEditorController = class {
 	begin() {
 		this.writing = true;
 		this.buffer = "";
+		this.synced = null;
 		if (this.editor) {
-			this.editor.updateOptions({ readOnly: true });
-			this.editor.setValue("");
+			this.takeOver(this.editor);
+			const model = this.editor.getModel();
+			if (model) this.replay(this.editor, model);
 		}
 	}
 	append(text) {
@@ -75,6 +246,11 @@ var StreamingEditorController = class {
 		this.buffer += text;
 		const model = this.editor?.getModel();
 		if (!this.editor || !model) return;
+		if (model !== this.synced) {
+			this.replay(this.editor, model);
+			return;
+		}
+		this.claim(model);
 		const line = model.getLineCount();
 		const column = model.getLineMaxColumn(line);
 		model.applyEdits([{
@@ -86,17 +262,28 @@ var StreamingEditorController = class {
 			},
 			text
 		}]);
-		this.editor.revealLine(model.getLineCount());
+		if (!model.isDisposed()) this.editor.revealLine(model.getLineCount());
 	}
 	end() {
-		this.writing = false;
-		this.editor?.updateOptions({ readOnly: false });
+		try {
+			const instance = this.editor;
+			const current = instance?.getModel();
+			if (instance && current && current !== this.synced && !current.isDisposed()) this.replay(instance, current);
+			for (const [model, doc] of this.displaced) if (model !== this.synced && !model.isDisposed()) model.setValue(doc);
+		} finally {
+			this.writing = false;
+			this.releaseAll();
+		}
 		return this.buffer;
 	}
 	discard() {
-		this.writing = false;
-		this.buffer = "";
-		this.editor?.updateOptions({ readOnly: false });
+		try {
+			for (const [model, doc] of this.displaced) if (!model.isDisposed()) model.setValue(doc);
+		} finally {
+			this.writing = false;
+			this.buffer = "";
+			this.releaseAll();
+		}
 	}
 	replace(search, replaceWith, all) {
 		const model = this.editor?.getModel();
@@ -125,9 +312,8 @@ var StreamingEditorController = class {
 				text: replaceWith
 			};
 		});
-		this.editor.executeEdits("inkstone-stream-replace", edits);
-		return true;
+		return this.editor.executeEdits("inkstone-stream-replace", edits);
 	}
 };
 //#endregion
-export { StreamingEditorController, ensureMonacoHost };
+export { StreamingEditorController, disabledKeybindings, ensureMonacoHost, installDisabledKeybindings, monacoLanguages };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@coldsmirk/inkstone-monaco",
-  "version": "0.8.2",
+  "version": "0.9.0",
   "description": "Framework-agnostic Monaco assembly: lazy offline host (all language workers bundled, no CDN), opt-in Simplified-Chinese UI via monaco's official NLS catalog, and a streaming editor controller for AI-typed content.",
   "keywords": [
     "monaco",
@@ -25,19 +25,11 @@
   "type": "module",
   "exports": {
     ".": {
-      "import": {
-        "types": "./dist/index.d.ts",
-        "default": "./dist/index.js"
-      },
-      "require": {
-        "types": "./dist/index.d.cts",
-        "default": "./dist/index.cjs"
-      }
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
     },
     "./package.json": "./package.json"
   },
-  "main": "./dist/index.cjs",
-  "module": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "files": [
     "dist"
@@ -49,7 +41,7 @@
     "monaco-editor": "^0.55.1"
   },
   "engines": {
-    "node": ">=22"
+    "node": ">=24"
   },
   "publishConfig": {
     "access": "public"

package/dist/index.cjs

@@ -1,135 +0,0 @@
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-//#region src/host.ts
-let hostPromise = null;
-function editorWorker() {
-	return new Worker(new URL("workers/editor.worker.js", require("url").pathToFileURL(__filename).href), { type: "module" });
-}
-const WORKER_BY_LABEL = {
-	typescript: () => new Worker(new URL("workers/ts.worker.js", require("url").pathToFileURL(__filename).href), { type: "module" }),
-	json: () => new Worker(new URL("workers/json.worker.js", require("url").pathToFileURL(__filename).href), { type: "module" }),
-	css: () => new Worker(new URL("workers/css.worker.js", require("url").pathToFileURL(__filename).href), { type: "module" }),
-	html: () => new Worker(new URL("workers/html.worker.js", require("url").pathToFileURL(__filename).href), { type: "module" })
-};
-const WORKER_ALIASES = {
-	javascript: "typescript",
-	scss: "css",
-	less: "css",
-	handlebars: "html",
-	razor: "html"
-};
-function builtinGetWorker(label) {
-	const factory = WORKER_BY_LABEL[WORKER_ALIASES[label] ?? label];
-	return factory ? factory() : editorWorker();
-}
-const HOVER_GEOMETRY_STYLE_SELECTOR = "style[data-inkstone=\"monaco-hover-geometry\"]";
-function installHoverGeometryFix() {
-	if (document.querySelector(HOVER_GEOMETRY_STYLE_SELECTOR)) return;
-	const style = document.createElement("style");
-	style.dataset.inkstone = "monaco-hover-geometry";
-	style.textContent = ".context-view:has(> .workbench-hover-container) { width: max-content !important; }";
-	document.head.append(style);
-}
-function ensureMonacoHost(options = {}) {
-	hostPromise ??= (async () => {
-		const { locale = "en", getWorker } = options;
-		if (locale === "zh-cn") await import("monaco-editor/esm/nls.messages.zh-cn.js");
-		const monaco = await import("monaco-editor");
-		globalThis.MonacoEnvironment = { getWorker: (workerId, label) => getWorker?.(workerId, label) ?? builtinGetWorker(label) };
-		installHoverGeometryFix();
-		return monaco;
-	})().catch((error) => {
-		hostPromise = null;
-		throw error;
-	});
-	return hostPromise;
-}
-//#endregion
-//#region src/streaming.ts
-var StreamingEditorController = class {
-	editor = null;
-	writing = false;
-	buffer = "";
-	attach(instance) {
-		this.editor = instance;
-		if (this.writing) {
-			instance.updateOptions({ readOnly: true });
-			instance.setValue(this.buffer);
-			instance.revealLine(instance.getModel()?.getLineCount() ?? 1);
-		}
-	}
-	detach(instance) {
-		if (this.editor === instance) this.editor = null;
-	}
-	isStreaming() {
-		return this.writing;
-	}
-	begin() {
-		this.writing = true;
-		this.buffer = "";
-		if (this.editor) {
-			this.editor.updateOptions({ readOnly: true });
-			this.editor.setValue("");
-		}
-	}
-	append(text) {
-		if (!this.writing) return;
-		this.buffer += text;
-		const model = this.editor?.getModel();
-		if (!this.editor || !model) return;
-		const line = model.getLineCount();
-		const column = model.getLineMaxColumn(line);
-		model.applyEdits([{
-			range: {
-				startLineNumber: line,
-				startColumn: column,
-				endLineNumber: line,
-				endColumn: column
-			},
-			text
-		}]);
-		this.editor.revealLine(model.getLineCount());
-	}
-	end() {
-		this.writing = false;
-		this.editor?.updateOptions({ readOnly: false });
-		return this.buffer;
-	}
-	discard() {
-		this.writing = false;
-		this.buffer = "";
-		this.editor?.updateOptions({ readOnly: false });
-	}
-	replace(search, replaceWith, all) {
-		const model = this.editor?.getModel();
-		if (search === "" || !this.editor || !model) return false;
-		const source = model.getValue();
-		const offsets = [];
-		let from = 0;
-		for (;;) {
-			const index = source.indexOf(search, from);
-			if (index === -1) break;
-			offsets.push(index);
-			if (!all) break;
-			from = index + search.length;
-		}
-		if (offsets.length === 0) return false;
-		const edits = offsets.map((offset) => {
-			const start = model.getPositionAt(offset);
-			const end = model.getPositionAt(offset + search.length);
-			return {
-				range: {
-					startLineNumber: start.lineNumber,
-					startColumn: start.column,
-					endLineNumber: end.lineNumber,
-					endColumn: end.column
-				},
-				text: replaceWith
-			};
-		});
-		this.editor.executeEdits("inkstone-stream-replace", edits);
-		return true;
-	}
-};
-//#endregion
-exports.StreamingEditorController = StreamingEditorController;
-exports.ensureMonacoHost = ensureMonacoHost;

package/dist/index.d.cts

@@ -1,113 +0,0 @@
-import * as monacoEditor from "monaco-editor";
-import { editor } from "monaco-editor";
-
-//#region src/host.d.ts
-/**
- * Supported UI locales for Monaco's built-in chrome (context menu, find widget, command
- * palette …). `"en"` is Monaco's built-in default; `"zh-cn"` loads the official
- * Simplified-Chinese catalog that monaco-editor ships in its ESM distribution.
- */
-type MonacoUiLocale = "en" | "zh-cn";
-interface MonacoHostOptions {
-  /**
-   * UI locale for Monaco's built-in chrome. A non-`"en"` locale is applied by evaluating the
-   * official locale catalog before the monaco module itself — which is why the host owns the
-   * monaco import: a static `import "monaco-editor"` elsewhere would evaluate first and lock
-   * the UI to English.
-   *
-   * @default "en"
-   */
-  locale?: MonacoUiLocale;
-  /**
-   * Custom worker routing, tried first; return `undefined` to fall back to the built-in
-   * routing. Monaco's built-in languages are fully covered without this — it exists for
-   * workers this package does not ship (a third-party language server, e.g. monaco-yaml):
-   * key on `label` and return `new Worker(new URL(...))` for the ones you handle, `undefined`
-   * otherwise. See the README's "Language workers" section for a full example.
-   */
-  getWorker?: (workerId: string, label: string) => Worker | undefined;
-}
-/**
- * The monaco module namespace, as resolved by {@link ensureMonacoHost}.
- */
-type MonacoModule = typeof monacoEditor;
-declare function ensureMonacoHost(options?: MonacoHostOptions): Promise<MonacoModule>;
-//#endregion
-//#region src/languages.d.ts
-/**
- * Monaco's built-in language ids — the set Monaco ships tokenizers for out of the box, used
- * to type `<MonacoEditor language>`. Monaco also accepts any custom-registered id (e.g. a
- * language wired through `getWorker` such as monaco-yaml), so the type stays open: the union
- * drives editor autocomplete while `string & Record<never, never>` still admits any string.
- */
-type MonacoLanguage = "abap" | "apex" | "azcli" | "bat" | "bicep" | "cameligo" | "clojure" | "coffeescript" | "cpp" | "csharp" | "csp" | "css" | "cypher" | "dart" | "dockerfile" | "ecl" | "elixir" | "flow9" | "freemarker2" | "fsharp" | "go" | "graphql" | "handlebars" | "hcl" | "html" | "ini" | "java" | "javascript" | "json" | "julia" | "kotlin" | "less" | "lexon" | "liquid" | "lua" | "m3" | "markdown" | "mdx" | "mips" | "msdax" | "mysql" | "objective-c" | "pascal" | "pascaligo" | "perl" | "pgsql" | "php" | "pla" | "postiats" | "powerquery" | "powershell" | "protobuf" | "pug" | "python" | "qsharp" | "r" | "razor" | "redis" | "redshift" | "restructuredtext" | "ruby" | "rust" | "sb" | "scala" | "scheme" | "scss" | "shell" | "solidity" | "sophia" | "sparql" | "sql" | "st" | "swift" | "systemverilog" | "tcl" | "twig" | "typescript" | "typespec" | "vb" | "wgsl" | "xml" | "yaml" | "plaintext" | (string & Record<never, never>);
-//#endregion
-//#region src/streaming.d.ts
-/**
- * The editor surface the controller drives — satisfied by any Monaco code editor
- * (type-only import, so this package never evaluates the monaco module itself).
- */
-type StreamTargetEditor = editor.ICodeEditor;
-/**
- * Streams generated text (an AI response, a log tail) into a Monaco editor chunk by chunk,
- * decoupled from the editor's controlled-value cycle.
- *
- * Why not just write the store on every chunk: the editor is typically a controlled
- * component, so routing every token through app state re-renders the tree per token — and
- * the controlled value would clobber the half-written document. Instead the controller
- * mutates the Monaco model directly (append-at-EOF via `applyEdits`, scrolled into view),
- * the editor's `onChange` short-circuits on {@link isStreaming}, and the caller reconciles
- * app state once from {@link end}'s return value.
- *
- * The target editor may mount late or unmount mid-stream (keep-alive tab hosts): chunks
- * accumulate in a buffer that is replayed on {@link attach}, so the final document is
- * complete even if the editor never mounts.
- */
-declare class StreamingEditorController {
-  private editor;
-  private writing;
-  private buffer;
-  /**
-   * Bind the mounted editor. If a stream is in progress, the buffered content is synced
-   * into the model immediately and the editor is set read-only.
-   */
-  attach(instance: StreamTargetEditor): void;
-  /**
-   * Release the editor (unmount). A stream in progress keeps accumulating in the buffer.
-   */
-  detach(instance: StreamTargetEditor): void;
-  /**
-   * Whether a stream is in progress — the editor's `onChange` must not write back to app
-   * state while this is true.
-   */
-  isStreaming(): boolean;
-  /**
-   * Start a stream: clears the buffer and the editor, and sets it read-only.
-   */
-  begin(): void;
-  /**
-   * Append a chunk: buffered always, and applied at end-of-document when an editor is
-   * attached (a minimal edit, scrolled into view).
-   */
-  append(text: string): void;
-  /**
-   * End the stream and return the full streamed text — the caller reconciles it into app
-   * state (one write, replacing the per-token churn).
-   */
-  end(): string;
-  /**
-   * Abort mid-stream WITHOUT yielding the buffer: clears the writing/read-only state and
-   * drops the partial text. For teardown paths (document switch / reset) where flushing
-   * the partial stream into the now-current document would corrupt it.
-   */
-  discard(): void;
-  /**
-   * Exact find-and-replace on the attached editor, located by character offset and applied
-   * via `executeEdits` — preserving the undo stack, cursor, and fold state. Returns whether
-   * it was applied (`false` = no editor / empty search / no match; the caller falls back to
-   * a state write).
-   */
-  replace(search: string, replaceWith: string, all: boolean): boolean;
-}
-//#endregion
-export { type MonacoHostOptions, type MonacoLanguage, type MonacoModule, type MonacoUiLocale, type StreamTargetEditor, StreamingEditorController, ensureMonacoHost };