@coldsmirk/inkstone-monaco 0.16.0 → 0.17.1

package/README.md

@@ -10,7 +10,8 @@ Part of [inkstone](https://github.com/coldsmirk/inkstone). For a drop-in React c
 - **`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.
-- **`installJsxTagClosing`** — VS Code's auto-closing JSX tags: a typed `>` that completes an opening tag inserts the matching closing tag and keeps the caret between the pair. Parser-backed: the bundled TS worker subclasses monaco's stock worker to expose `getJsxClosingTagAtPosition` — a language-service call monaco never proxied (VS Code ships the feature in its TypeScript extension, outside the editor core) — so generics, comparisons, arrow functions, and already-closed elements never trigger. The keystroke handler gates itself to TypeScript/JavaScript models whose path ends in `.tsx` / `.jsx`; a `getWorker` override that routes the `typescript` label to a worker without the subclass downgrades the feature to a no-op. `<MonacoEditor>` installs it automatically.
+- **`installJsxTagClosing`** — VS Code's auto-closing JSX tags: a typed `>` that completes an opening tag inserts the matching closing tag and keeps the caret between the pair. Parser-backed: the bundled TS worker subclasses monaco's stock worker to expose `getJsxClosingTagAtPosition` — a language-service call monaco never proxied (VS Code ships the feature in its TypeScript extension, outside the editor core) — so generics, comparisons, arrow functions, and already-closed elements never trigger. Only a *typed* `>` triggers: the gates require one bare single-character insertion into a **writable** TypeScript/JavaScript model whose path ends in `.tsx` / `.jsx`, and the reply lands only while the caret still sits right after that `>` — so `replaceInEditor` replacements, `StreamingEditorController` appends (the stream holds the editor read-only), and other programmatic writes never earn a closing tag, and the insert arrives as its own undo step (one undo removes just the closing tag). A `getWorker` override that routes the `typescript` label to a worker without the subclass is detected on its first lookup and the install disarms silently. Multi-cursor typing and the diff editor's panes are deliberately out of scope. `<MonacoEditor>` installs it automatically.
+- **`dropMonacoWorkerFallbacks()`** (from **`@coldsmirk/inkstone-monaco/vite`**) — a Vite plugin that removes monaco's built-in worker fallbacks at build time. Monaco's language workerManagers statically reference their workers as `new Worker(new URL(...))` fallbacks that never run under `ensureMonacoHost` (the environment check prefers `getWorker`), yet bundlers emit a chunk per reference — including a ~7MB TypeScript worker duplicate that is never fetched. The plugin rewrites the fallbacks into located throws so the duplicates are never emitted; if a monaco bump reshapes the pattern it warns and leaves the file untouched (the dead chunk returns, nothing breaks).
 - **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 (and for a model swapped onto the attached editor mid-stream, including after the final chunk), and `isStreaming()` for the onChange guard. 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.
 - **`replaceInEditor(editor, old, new, all)`** — exact find-and-replace on an editor handle via `executeEdits`, preserving undo/cursor/folds; returns whether the edit landed (`false` = no editor / empty search / no match / a read-only editor refused it — e.g. one locked by a stream in progress), so a tool-call handler knows to fall back to a state write.

package/dist/index.d.ts

@@ -63,22 +63,37 @@ interface JsxTagClosingTargetModel {
   isDisposed: () => boolean;
   getPositionAt: (offset: number) => monacoEditor.IPosition;
 }
+/**
+ * The caret shape the reply-time guard reads — the four corners of a (possibly collapsed)
+ * selection, as monaco's `Selection` carries them.
+ */
+interface JsxTagClosingCursor {
+  readonly selectionStartLineNumber: number;
+  readonly selectionStartColumn: number;
+  readonly positionLineNumber: number;
+  readonly positionColumn: number;
+}
 /**
  * The slice of a standalone editor the install touches — structural, same rationale as
  * {@link JsxTagClosingTargetModel}.
  */
 interface JsxTagClosingTargetEditor {
   getModel: () => JsxTagClosingTargetModel | null;
+  getOption: (id: monacoEditor.editor.EditorOption) => unknown;
+  getSelection: () => JsxTagClosingCursor | null;
+  pushUndoStop: () => boolean;
   onDidChangeModelContent: (listener: (event: monacoEditor.editor.IModelContentChangedEvent) => void) => monacoEditor.IDisposable;
   executeEdits: (source: string, edits: monacoEditor.editor.IIdentifiedSingleEditOperation[], endCursorState: monacoEditor.Selection[]) => boolean;
 }
 /**
  * Watch `editorInstance` for tag-completing `">"` keystrokes and insert the matching JSX
- * closing tag, keeping the cursor between the pair. Installed by `<MonacoEditor>` on every
- * editor; the keystroke handler gates itself, so only TypeScript / JavaScript models whose
- * path ends in `.tsx` / `.jsx` — the extensions that make the language service parse JSX —
- * ever reach the worker. Listener lifetime follows the editor; dispose the returned
- * subscription to detach earlier.
+ * closing tag as its own undo step, keeping the cursor between the pair. Installed by
+ * `<MonacoEditor>` on every editor; the keystroke handler gates itself, so only a bare ">"
+ * typed into a writable TypeScript / JavaScript model whose path ends in `.tsx` / `.jsx` —
+ * the extensions that make the language service parse JSX — ever reaches the worker. A
+ * routed worker without the lookup (a `getWorker` override bypassing the bundled entry) is
+ * detected on its first answer and the install disarms silently. Listener lifetime follows
+ * the editor; dispose the returned subscription to detach earlier.
  */
 declare function installJsxTagClosing(monaco: MonacoModule, editorInstance: JsxTagClosingTargetEditor): monacoEditor.IDisposable;
 //#endregion

package/dist/index.js

@@ -102,12 +102,16 @@ function ensureMonacoHost(options = {}) {
 }
 //#endregion
 //#region src/jsx-tag-closing.ts
+const MISSING_LOOKUP_REJECTION = "Missing requestHandler or method: getJsxClosingTagAtPosition";
+const MODE_BOOTING_REJECTIONS = /* @__PURE__ */ new Set(["TypeScript not registered!", "JavaScript not registered!"]);
 function installJsxTagClosing(monaco, editorInstance) {
+	let lookupUnsupported = false;
 	return editorInstance.onDidChangeModelContent((event) => {
-		if (event.isFlush || event.isUndoing || event.isRedoing || event.changes.length !== 1) return;
+		if (lookupUnsupported || event.isFlush || event.isUndoing || event.isRedoing || event.changes.length !== 1) return;
 		const change = event.changes[0];
 		const model = editorInstance.getModel();
-		if (change?.text !== ">" || !model) return;
+		if (change?.text !== ">" || change.rangeLength !== 0 || !model) return;
+		if (editorInstance.getOption(monaco.editor.EditorOption.readOnly) === true) return;
 		const { path } = model.uri;
 		if (!path.endsWith(".tsx") && !path.endsWith(".jsx")) return;
 		const language = model.getLanguageId();
@@ -116,16 +120,26 @@ function installJsxTagClosing(monaco, editorInstance) {
 		const version = model.getVersionId();
 		(async () => {
 			try {
-				const closing = await (await (language === "typescript" ? await monaco.typescript.getTypeScriptWorker() : await monaco.typescript.getJavaScriptWorker())(model.uri)).getJsxClosingTagAtPosition?.(model.uri.toString(), offset);
+				const closing = await (await (language === "typescript" ? await monaco.typescript.getTypeScriptWorker() : await monaco.typescript.getJavaScriptWorker())(model.uri)).getJsxClosingTagAtPosition(model.uri.toString(), offset);
 				if (!closing || model.isDisposed() || model.getVersionId() !== version || editorInstance.getModel() !== model) return;
 				const position = model.getPositionAt(offset);
+				const selection = editorInstance.getSelection();
+				if (!selection || selection.selectionStartLineNumber !== position.lineNumber || selection.selectionStartColumn !== position.column || selection.positionLineNumber !== position.lineNumber || selection.positionColumn !== position.column) return;
 				const cursor = new monaco.Selection(position.lineNumber, position.column, position.lineNumber, position.column);
+				editorInstance.pushUndoStop();
 				editorInstance.executeEdits("jsx-tag-closing", [{
 					range: new monaco.Range(position.lineNumber, position.column, position.lineNumber, position.column),
 					text: closing.newText,
 					forceMoveMarkers: false
 				}], [cursor]);
+				editorInstance.pushUndoStop();
 			} catch (error) {
+				const message = error instanceof Error ? error.message : typeof error === "string" ? error : "";
+				if (message === MISSING_LOOKUP_REJECTION) {
+					lookupUnsupported = true;
+					return;
+				}
+				if (MODE_BOOTING_REJECTIONS.has(message)) return;
 				console.error("inkstone: jsx closing-tag lookup failed", error);
 			}
 		})();

package/dist/vite.d.ts

@@ -0,0 +1,22 @@
+import { Plugin } from "vite";
+//#region src/vite.d.ts
+/**
+ * A Vite plugin that drops monaco's built-in worker fallbacks so no duplicate worker chunks
+ * are emitted: the statically-referenced fallback expressions become located throws, which
+ * never run while `ensureMonacoHost` owns `MonacoEnvironment` — and fail honestly, naming the
+ * worker, if some path reaches a fallback anyway. Apply it in any app whose workers ride this
+ * package's routing:
+ *
+ * ```ts
+ * import { dropMonacoWorkerFallbacks } from "@coldsmirk/inkstone-monaco/vite";
+ *
+ * export default defineConfig({ plugins: [dropMonacoWorkerFallbacks(), …] });
+ * ```
+ *
+ * If a monaco-editor bump reshapes the fallback so nothing matches, the plugin warns at build
+ * time and leaves the file untouched — the duplicate chunk returns (dead weight, nothing
+ * breaks) until the pattern catches up.
+ */
+declare function dropMonacoWorkerFallbacks(): Plugin;
+//#endregion
+export { dropMonacoWorkerFallbacks };

package/dist/vite.js

@@ -0,0 +1,25 @@
+//#region src/vite.ts
+const WORKER_FALLBACK = /new Worker\(new URL\('(?<worker>[\w.]+\.worker\.js)', import\.meta\.url\), \{ type: "module" \}\)/g;
+function dropMonacoWorkerFallbacks() {
+	return {
+		name: "inkstone:drop-monaco-worker-fallbacks",
+		transform(code, id) {
+			if (!id.includes("/node_modules/monaco-editor/") || !id.endsWith("workerManager.js")) return;
+			let matched = false;
+			const transformed = code.replaceAll(WORKER_FALLBACK, (_expression, file) => {
+				matched = true;
+				return `(() => { throw new Error("inkstone: monaco's '${file}' fallback was dropped at build; MonacoEnvironment.getWorker must route it"); })()`;
+			});
+			if (!matched) {
+				this.warn("no monaco worker fallback matched — a monaco-editor bump likely reshaped it, and the duplicate worker chunk is back until this plugin catches up");
+				return;
+			}
+			return {
+				code: transformed,
+				map: { mappings: "" }
+			};
+		}
+	};
+}
+//#endregion
+export { dropMonacoWorkerFallbacks };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@coldsmirk/inkstone-monaco",
-  "version": "0.16.0",
+  "version": "0.17.1",
   "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, a streaming editor controller for AI-typed content, and the shared Shiki highlighting bridge.",
   "keywords": [
     "monaco",
@@ -28,6 +28,10 @@
       "types": "./dist/index.d.ts",
       "default": "./dist/index.js"
     },
+    "./vite": {
+      "types": "./dist/vite.d.ts",
+      "default": "./dist/vite.js"
+    },
     "./package.json": "./package.json"
   },
   "types": "./dist/index.d.ts",
@@ -36,13 +40,20 @@
   ],
   "dependencies": {
     "@shikijs/monaco": "^4.4.3",
-    "@coldsmirk/inkstone-core": "^0.16.0"
+    "@coldsmirk/inkstone-core": "^0.17.1"
   },
   "devDependencies": {
-    "monaco-editor": "^0.56.0"
+    "monaco-editor": "^0.56.0",
+    "vite": "^8.2.2"
   },
   "peerDependencies": {
-    "monaco-editor": "^0.56.0"
+    "monaco-editor": "^0.56.0",
+    "vite": ">=6"
+  },
+  "peerDependenciesMeta": {
+    "vite": {
+      "optional": true
+    }
   },
   "engines": {
     "node": ">=24"