@coldsmirk/inkstone-monaco 0.8.2

package/README.md

@@ -0,0 +1,37 @@
+# @coldsmirk/inkstone-monaco
+
+Framework-agnostic [Monaco](https://microsoft.github.io/monaco-editor/) assembly: a lazy **offline host** (bundled workers, no CDN loader), opt-in Simplified-Chinese UI via the official NLS catalog, embedded-friendly geometry fixes, and a streaming controller for AI-typed content.
+
+Part of [inkstone](https://github.com/coldsmirk/inkstone). For a drop-in React component use [`@coldsmirk/inkstone-react`](https://www.npmjs.com/package/@coldsmirk/inkstone-react)'s `<MonacoEditor>`, which is built on this package; reach for this layer to wire the host into your own components (any framework), or to gate raw `@monaco-editor/react` components (e.g. `<DiffEditor>`) on the same offline module.
+
+## What you get
+
+- **`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.
+- **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.
+
+## Install
+
+```bash
+pnpm add @coldsmirk/inkstone-monaco monaco-editor
+```
+
+`monaco-editor` is a **peer dependency** — your app owns the version. Node.js >= 22 for build / SSR hosts; workers are bundled by your bundler from `new Worker(new URL(...))`, which any Vite / Rollup / webpack 5 setup handles natively.
+
+## Quick start
+
+```ts
+import { ensureMonacoHost } from "@coldsmirk/inkstone-monaco";
+
+const monaco = await ensureMonacoHost({ locale: "zh-cn" });
+const editor = monaco.editor.create(container, { value: "const x = 1;\n", language: "javascript" });
+```
+
+## The one Monaco rule
+
+The host evaluates the requested locale catalog **before** the monaco module, because Monaco resolves its UI strings at module-evaluation time. A static `import "monaco-editor"` anywhere in your app would evaluate first and lock the UI to English — so never import it statically; take the instance from `ensureMonacoHost()`. **Type-only imports are fine** (`import type { editor } from "monaco-editor"` erases at compile time).
+
+## License
+
+UNLICENSED — proprietary. All rights reserved; no use, copying, or redistribution without the author's permission.

package/dist/index.cjs

@@ -0,0 +1,135 @@
+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

@@ -0,0 +1,113 @@
+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 };

package/dist/index.d.ts

@@ -0,0 +1,113 @@
+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 };

package/dist/index.js

@@ -0,0 +1,133 @@
+//#region src/host.ts
+let hostPromise = null;
+function editorWorker() {
+	return new Worker(new URL("workers/editor.worker.js", import.meta.url), { type: "module" });
+}
+const WORKER_BY_LABEL = {
+	typescript: () => new Worker(new URL("workers/ts.worker.js", import.meta.url), { type: "module" }),
+	json: () => new Worker(new URL("workers/json.worker.js", import.meta.url), { type: "module" }),
+	css: () => new Worker(new URL("workers/css.worker.js", import.meta.url), { type: "module" }),
+	html: () => new Worker(new URL("workers/html.worker.js", import.meta.url), { 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
+export { StreamingEditorController, ensureMonacoHost };

package/dist/workers/css.worker.js

@@ -0,0 +1,3 @@
+// Worker entry: the CSS language worker (also serves scss/less). See editor.worker.js for
+// why this indirection exists.
+import "monaco-editor/esm/vs/language/css/css.worker.js";

package/dist/workers/editor.worker.js

@@ -0,0 +1,5 @@
+// Worker entry: re-exports monaco's base editor worker through a file that lives inside
+// this package, so the host can reference it with `new URL("./workers/…", import.meta.url)`
+// — the only worker form bundlers resolve inside a published dependency (Vite's `?worker`
+// suffix fails to load from node_modules).
+import "monaco-editor/esm/vs/editor/editor.worker.js";

package/dist/workers/html.worker.js

@@ -0,0 +1,3 @@
+// Worker entry: the HTML language worker (also serves handlebars/razor). See editor.worker.js
+// for why this indirection exists.
+import "monaco-editor/esm/vs/language/html/html.worker.js";

package/dist/workers/json.worker.js

@@ -0,0 +1,2 @@
+// Worker entry: the JSON language worker. See editor.worker.js for why this indirection exists.
+import "monaco-editor/esm/vs/language/json/json.worker.js";

package/dist/workers/ts.worker.js

@@ -0,0 +1,3 @@
+// Worker entry: the TypeScript worker, which also serves JavaScript IntelliSense.
+// See editor.worker.js for why this indirection exists.
+import "monaco-editor/esm/vs/language/typescript/ts.worker.js";

package/package.json

@@ -0,0 +1,62 @@
+{
+  "name": "@coldsmirk/inkstone-monaco",
+  "version": "0.8.2",
+  "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",
+    "monaco-editor",
+    "editor",
+    "nls",
+    "zh-cn",
+    "worker"
+  ],
+  "homepage": "https://github.com/coldsmirk/inkstone/tree/main/packages/monaco#readme",
+  "bugs": "https://github.com/coldsmirk/inkstone/issues",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/coldsmirk/inkstone.git",
+    "directory": "packages/monaco"
+  },
+  "license": "UNLICENSED",
+  "author": {
+    "name": "Venus"
+  },
+  "sideEffects": false,
+  "type": "module",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      }
+    },
+    "./package.json": "./package.json"
+  },
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "devDependencies": {
+    "monaco-editor": "^0.55.1"
+  },
+  "peerDependencies": {
+    "monaco-editor": "^0.55.1"
+  },
+  "engines": {
+    "node": ">=22"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "clean": "rimraf dist",
+    "typecheck": "tsc --noEmit"
+  }
+}