@coldsmirk/inkstone-monaco 0.16.0 → 0.17.0

package/README.md

@@ -11,6 +11,7 @@ Part of [inkstone](https://github.com/coldsmirk/inkstone). For a drop-in React c
 - **`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.
+- **`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/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("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: null
+			};
+		}
+	};
+}
+//#endregion
+export { dropMonacoWorkerFallbacks };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@coldsmirk/inkstone-monaco",
-  "version": "0.16.0",
+  "version": "0.17.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, 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.0"
   },
   "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"