@coldsmirk/inkstone-monaco 0.30.0 → 0.31.0

package/README.md

@@ -12,15 +12,15 @@ Part of [inkstone](https://github.com/coldsmirk/inkstone). For a drop-in React c
 - **`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. 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 fixes** — 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`. The command palette's row tooltips have the same trouble inside the palette: 0.56 positions them against the palette's list, which sets no position of its own, so they landed above the row they describe (by the height of the filter box); a `position: relative` style on the list, tagged `data-inkstone="monaco-quick-input-geometry"`, puts them on their row until upstream does.
+- **Embedded-editor fixes** — 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. And 0.57 draws an editor's context menu under `fixedOverflowWidgets` (inkstone's default) in a shadow root hosted in the node the editor was created in, which no theme color reaches — a transparent menu, its items over the code ([microsoft/monaco-editor#5511](https://github.com/microsoft/monaco-editor/issues/5511)); the host makes that node a `.monaco-component`, the class Monaco writes its theme's colors on, so the menu inherits them, and `<MonacoEditor>` keeps the class in the `className` it renders.
 - **`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.
 - **`registerShikiHighlighting(monaco, highlighter)`** — wire `@coldsmirk/inkstone-core`'s shared Shiki highlighter onto a monaco module (one from `ensureMonacoHost`), once per distinct module: defines the highlighter's themes as Monaco themes, registers each loaded grammar's canonical name as a Monaco language where Monaco has none and its Shiki tokenization in Monaco's registry — over Monaco's own, JSON's included (its mode's tokenizer is turned off through its configuration, its other features left on) — and patches `setTheme` so the Shiki theme ids route through the highlighter while non-Shiki ids (vs/vs-dark, caller-defined) keep Monaco's original path. Called again on a bridged module, it registers the grammars loaded since. A failed registration is restored and retried on the next call.
 - **Tokenization off the page's thread** — VS Code's design, through the same door in Monaco: each model an editor shows is tokenized whole in a worker of its own, built from what the shared highlighter was built from (`highlighterSources`), the tokens and the state each line ends in sent back as they are made and moved past the edits the worker has not yet seen. The page's thread tokenizes only what Monaco still asks of it before the worker reaches it — a model's first lines in view, the lines an edit touches — and of those only a line it can afford: one of 1,000 characters or more, or one the grammar does not finish in 50 ms, is drawn in the default color until the worker's tokens arrive, the line after it read from the state before it (a minified line costs the grammar about 10 ms per 1,000 characters, 370 over 10,000, and one in view would hold the page that long). The worker bounds a line as VS Code does, at 20,000 characters and 500 ms. Where the page passes a line over in the lines it paints first, its own states for the lines after it stand — Monaco keeps a state it computed over one sent later — so an edit there is drawn from them until the worker's tokens arrive. A highlighter inkstone did not build, or a host that routes no worker for `textmate`, leaves every model to Monaco's own pass on the page's thread, under the same bound.
 - **Which regex engine** — the worker builds the engine kind the shared highlighter was configured with: Oniguruma wherever an engine was configured, the strict JavaScript engine where none was, so the page and the worker tokenize alike. The JavaScript engine translates each grammar's patterns at the first tokenization — in the worker for a model, and on the page for the lines it tokenizes itself (a TypeScript file's first sixty lines: about 170 ms) — so an app that opens files in Monaco should configure `onigurumaEngine` from `@coldsmirk/inkstone-core` (`configureHighlighter({ engine: onigurumaEngine })`, before the first `getHighlighter()`): its WASM is inlined into your bundle and compiles the same lines in about 20 ms.
 - **`registerShikiLanguage(monaco, highlighter, language)`** — the lazy path: an app that loads grammars as files are opened calls this after each `highlighter.loadLanguage(...)` and before a model names the language. Registers the language where Monaco lacks it (`toml`, `shellscript`), its tokenization once under the grammar's canonical name (an alias like `ts` collapses), the models of a grammar shiki has built again since (a language it embeds lazily arrived) tokenized again under the new one, and leaves the theme the editor shows alone — the one thing re-running `@shikijs/monaco`'s `shikiToMonaco` cannot promise, which is why the bridge is inkstone's own. Throws for a grammar the highlighter has not loaded.
-- **`installDesignTokens()`** — defines the VS Code design tokens monaco-editor 0.56's chrome reads and the standalone editor never does ([microsoft/monaco-editor#5408](https://github.com/microsoft/monaco-editor/issues/5408)): `--vscode-cornerRadius-{small,medium,large,xLarge}` and `--vscode-shadow-{md,lg,xl}`, on `.monaco-editor` (the context menu's shadow root and a host's `overflowWidgetsDomNode` inherit them). Without them the context menu, completion, hover, and find widgets ship square and shadowless. Each resolves through the host's `--inkstone-radius-*` / `--inkstone-shadow-*` token first (see `@coldsmirk/inkstone-core`), then a fallback scale in the spirit of 0.55's look. It also keeps an input box's focus ring single: the standalone editor outlines both the `.monaco-inputbox` container (its `synthetic-focus` ring, which follows the box's radius) and the inner `<input>` (square, 1px inside), and the inner ring's corners poke out as soon as the box has corners — the container's ring is the one ring. `ensureMonacoHost` installs it; idempotent.
-- **`DEFAULT_MONACO_OPTIONS`** — the inkstone construction-option baseline (no minimap, 14px/1.6 type on the shared `--inkstone-font-family-code` token, embedded-friendly find widget, tuned completion, thin scrollbars). Spread it to extend: `{ ...DEFAULT_MONACO_OPTIONS, wordWrap: "on" }`.
+- **`installDesignTokens()`** — defines the VS Code design tokens monaco-editor's chrome has read since 0.56 and the standalone editor still never does ([microsoft/monaco-editor#5408](https://github.com/microsoft/monaco-editor/issues/5408)): `--vscode-cornerRadius-{small,medium,large,xLarge,circle}` and `--vscode-shadow-{md,lg,xl}`, on `.monaco-editor` (a host's `overflowWidgetsDomNode` carries the class) and on `.monaco-component` — every context view, the class Monaco writes its own theme colors on: an element's tooltip and, since 0.57 under `fixedOverflowWidgets`, the editor's context menu stand in the node the editor was created in, outside `.monaco-editor`. Without them the context menu, completion, hover, and find widgets ship square and shadowless. 0.57 also took the completion list off `--vscode-shadow-lg` for a literal `0 2px 8px` shadow; it is put back on the token, so it wears the host's shadow as the hover and the context menu do. Each resolves through the host's `--inkstone-radius-*` / `--inkstone-shadow-*` token first (see `@coldsmirk/inkstone-core`), then a fallback scale in the spirit of 0.55's look. It also keeps an input box's focus ring single: the standalone editor outlines both the `.monaco-inputbox` container (its `synthetic-focus` ring, which follows the box's radius) and the inner `<input>` (square, 1px inside), and the inner ring's corners poke out as soon as the box has corners — the container's ring is the one ring. `ensureMonacoHost` installs it; idempotent.
+- **`DEFAULT_MONACO_OPTIONS`** — the inkstone construction-option baseline (no minimap, 14px/1.6 type on the shared `--inkstone-font-family-code` token, embedded-friendly find widget, tuned completion, thin scrollbars). Spread it to extend: `{ ...DEFAULT_MONACO_OPTIONS, wordWrap: "on" }`. Left out on purpose: `fullwidthCharacterWidth: "twoCells"`, which centers each full-width character — CJK text among it — in exactly two cells of a monospace font, so it lines up with the grid the way a terminal draws it. It draws every such character as a span of its own, which costs on text dense with them (a Chinese JSON body, a document of prose), so it is a host's to turn on where the alignment matters more.
 - **`reconcileModelValue` / `modelValueMatches`** — the controlled-value reconcile: diff an external value against a live model (normalized to the model's EOL) and apply one minimal `applyEdits` replace that never lands on the undo stack or moves a caret outside the changed region.
 
 ## Install

package/dist/index.d.ts

@@ -51,7 +51,7 @@ type MonacoModule = typeof monacoEditor;
  * (both are idempotent), instead of replaying one transient failure — a chunk 404 after a
  * redeploy, a flaky network — for the rest of the session.
  */
-declare function ensureMonacoHost(options?: MonacoHostOptions): Promise<MonacoModule>;
+export declare function ensureMonacoHost(options?: MonacoHostOptions): Promise<MonacoModule>;
 //#endregion
 //#region src/auto-imports.d.ts
 /**
@@ -75,18 +75,19 @@ interface AutoImportCompletionOptions {
  * subclass (a `getWorker` override) is detected on the first answer and the install disarms
  * silently. Install once per app; repeated calls return the first install's disposable.
  */
-declare function installAutoImportCompletions(monaco: MonacoModule, options: AutoImportCompletionOptions): monacoEditor.IDisposable;
+export declare function installAutoImportCompletions(monaco: MonacoModule, options: AutoImportCompletionOptions): monacoEditor.IDisposable;
 //#endregion
 //#region src/design-tokens.d.ts
 /**
  * Define the VS Code design tokens Monaco's chrome reads but the standalone editor lacks —
- * corner radii and widget shadows — on `.monaco-editor`, resolved through the host's
- * `--inkstone-radius-*` / `--inkstone-shadow-*` tokens with inkstone's fallbacks, and keep an
- * input box's focus ring single now that the box has corners (see `INPUTBOX_FOCUS_RULE`).
+ * corner radii and widget shadows — where Monaco writes its theme's colors, resolved
+ * through the host's `--inkstone-radius-*` / `--inkstone-shadow-*` tokens with inkstone's
+ * fallbacks; keep an input box's focus ring single now that the box has corners (see
+ * `INPUTBOX_FOCUS_RULE`), and the completion list on the shadow token (`SUGGEST_SHADOW_RULE`).
  * Installed by `ensureMonacoHost`; idempotent, so a host that brings monaco up on its own can
  * call it too.
  */
-declare function installDesignTokens(): void;
+export declare function installDesignTokens(): void;
 //#endregion
 //#region src/hover-dead-band.d.ts
 /**
@@ -103,7 +104,7 @@ interface HoverDeadBandTargetEditor {
  * on every editor; a monaco whose hover controller no longer matches the pinned shape is
  * left untouched. Dispose to restore the stock test.
  */
-declare function installHoverDeadBandFix(editorInstance: HoverDeadBandTargetEditor): monacoEditor.IDisposable;
+export declare function installHoverDeadBandFix(editorInstance: HoverDeadBandTargetEditor): monacoEditor.IDisposable;
 //#endregion
 //#region src/jsx-tag-closing.d.ts
 /**
@@ -149,7 +150,7 @@ interface JsxTagClosingTargetEditor {
  * 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;
+export declare function installJsxTagClosing(monaco: MonacoModule, editorInstance: JsxTagClosingTargetEditor): monacoEditor.IDisposable;
 //#endregion
 //#region src/keybindings.d.ts
 /**
@@ -164,13 +165,13 @@ interface SwallowedKeybindings {
  * 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.56.0 (`findController.js`, `standaloneCommandsQuickAccess.js`).
+ * from monaco-editor 0.57.0 (`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[];
+export 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).
@@ -185,7 +186,7 @@ interface KeybindingTargetEditor {
  * 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;
+export declare function installDisabledKeybindings(monaco: MonacoModule, editorInstance: KeybindingTargetEditor, groups: readonly SwallowedKeybindings[]): void;
 //#endregion
 //#region src/languages.d.ts
 /**
@@ -209,7 +210,7 @@ type MonacoBuiltInLanguage = (typeof BUILT_IN_LANGUAGES)[number];
 /**
  * Every built-in Monaco language id, sorted.
  */
-declare const monacoLanguages: readonly MonacoBuiltInLanguage[];
+export 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
@@ -224,7 +225,7 @@ type MonacoLanguage = MonacoBuiltInLanguage | (string & Record<never, never>);
  * tuned for API-assisted editing, thin scrollbars, and an embedded-friendly find widget.
  * Spread these to extend rather than replace: `options={{ ...DEFAULT_MONACO_OPTIONS, wordWrap: "on" }}`.
  */
-declare const DEFAULT_MONACO_OPTIONS: editor.IStandaloneEditorConstructionOptions;
+export declare const DEFAULT_MONACO_OPTIONS: editor.IStandaloneEditorConstructionOptions;
 //#endregion
 //#region src/reconcile.d.ts
 /**
@@ -232,11 +233,11 @@ declare const DEFAULT_MONACO_OPTIONS: editor.IStandaloneEditorConstructionOption
  * documents already match. Fires the model's content-change event synchronously when it
  * edits — callers that must not re-enter their change callback silence it around this call.
  */
-declare function reconcileModelValue(model: editor.ITextModel, externalValue: string): void;
+export declare function reconcileModelValue(model: editor.ITextModel, externalValue: string): void;
 /**
  * Whether an external value already matches the model after applying its EOL convention.
  */
-declare function modelValueMatches(model: editor.ITextModel, externalValue: string): boolean;
+export declare function modelValueMatches(model: editor.ITextModel, externalValue: string): boolean;
 //#endregion
 //#region src/replace.d.ts
 /**
@@ -246,7 +247,7 @@ declare function modelValueMatches(model: editor.ITextModel, externalValue: stri
  * because it is read-only — e.g. locked by a stream in progress; the caller falls back to a
  * state write).
  */
-declare function replaceInEditor(target: editor.ICodeEditor | null, search: string, replaceWith: string, all: boolean): boolean;
+export declare function replaceInEditor(target: editor.ICodeEditor | null, search: string, replaceWith: string, all: boolean): boolean;
 //#endregion
 //#region src/shiki-bridge.d.ts
 /**
@@ -275,7 +276,7 @@ declare function replaceInEditor(target: editor.ICodeEditor | null, search: stri
  * A grammar loaded into the highlighter *after* this call is not tokenized until it is
  * registered — pass it to {@link registerShikiLanguage} (or call this again).
  */
-declare function registerShikiHighlighting(monaco: MonacoModule, highlighter: HighlighterCore): void;
+export declare function registerShikiHighlighting(monaco: MonacoModule, highlighter: HighlighterCore): void;
 /**
  * Register the tokenization of one grammar the highlighter has loaded since the module was
  * bridged — the lazy path: an app that loads grammars as files are opened registers each here,
@@ -285,7 +286,7 @@ declare function registerShikiHighlighting(monaco: MonacoModule, highlighter: Hi
  * a language it embeds lazily arrived, has its models tokenized again under the new one. Throws
  * when the highlighter has not loaded the grammar: there is nothing to tokenize with.
  */
-declare function registerShikiLanguage(monaco: MonacoModule, highlighter: HighlighterCore, language: string): void;
+export declare function registerShikiLanguage(monaco: MonacoModule, highlighter: HighlighterCore, language: string): void;
 //#endregion
 //#region src/streaming.d.ts
 /**
@@ -308,7 +309,7 @@ type StreamTargetEditor = editor.ICodeEditor;
  * 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 {
+export declare class StreamingEditorController {
   private editor;
   private writing;
   private buffer;
@@ -409,4 +410,4 @@ declare class StreamingEditorController {
   discard(): void;
 }
 //#endregion
-export { type AutoImportCompletionOptions, DEFAULT_MONACO_OPTIONS, type HoverDeadBandTargetEditor, type JsxTagClosingTargetEditor, type JsxTagClosingTargetModel, type KeybindingTargetEditor, type MonacoBuiltInLanguage, type MonacoHostOptions, type MonacoLanguage, type MonacoModule, type MonacoUiLocale, type StreamTargetEditor, StreamingEditorController, type SwallowedKeybindings, disabledKeybindings, ensureMonacoHost, installAutoImportCompletions, installDesignTokens, installDisabledKeybindings, installHoverDeadBandFix, installJsxTagClosing, modelValueMatches, monacoLanguages, reconcileModelValue, registerShikiHighlighting, registerShikiLanguage, replaceInEditor };
+export type { AutoImportCompletionOptions, HoverDeadBandTargetEditor, JsxTagClosingTargetEditor, JsxTagClosingTargetModel, KeybindingTargetEditor, MonacoBuiltInLanguage, MonacoHostOptions, MonacoLanguage, MonacoModule, MonacoUiLocale, StreamTargetEditor, SwallowedKeybindings };

package/dist/index.js

@@ -131,16 +131,18 @@ const DESIGN_TOKENS = [
 	`--vscode-cornerRadius-medium: ${inkstoneRadius("medium", "4px")}`,
 	`--vscode-cornerRadius-large: ${inkstoneRadius("large", "6px")}`,
 	`--vscode-cornerRadius-xLarge: ${inkstoneRadius("xlarge", "8px")}`,
+	"--vscode-cornerRadius-circle: 9999px",
 	`--vscode-shadow-md: ${inkstoneShadow("medium", "0 1px 4px var(--vscode-widget-shadow)")}`,
 	`--vscode-shadow-lg: ${inkstoneShadow("large", "0 2px 8px var(--vscode-widget-shadow)")}`,
 	`--vscode-shadow-xl: ${inkstoneShadow("xlarge", "0 4px 16px var(--vscode-widget-shadow)")}`
 ];
 const INPUTBOX_FOCUS_RULE = ".monaco-editor .monaco-inputbox > .ibwrapper > .input:focus { outline: none; }";
+const SUGGEST_SHADOW_RULE = ".monaco-editor:not(.hc-black):not(.hc-light) .suggest-widget { box-shadow: var(--vscode-shadow-lg); }";
 function installDesignTokens() {
 	if (document.querySelector(DESIGN_TOKENS_STYLE_SELECTOR)) return;
 	const style = document.createElement("style");
 	style.dataset.inkstone = "monaco-design-tokens";
-	style.textContent = `.monaco-editor { ${DESIGN_TOKENS.join("; ")}; }\n${INPUTBOX_FOCUS_RULE}`;
+	style.textContent = `.monaco-editor, .monaco-diff-editor, .monaco-component { ${DESIGN_TOKENS.join("; ")}; }\n${INPUTBOX_FOCUS_RULE}\n${SUGGEST_SHADOW_RULE}`;
 	document.head.append(style);
 }
 //#endregion
@@ -181,6 +183,14 @@ function localizeActionDescriptions(editorInstance) {
 	}
 }
 //#endregion
+//#region src/context-menu-fix.ts
+const COMPONENT_CLASS = "monaco-component";
+function installContextMenuThemeFix(monaco) {
+	monaco.editor.onDidCreateEditor((editorInstance) => {
+		editorInstance.getContainerDomNode().classList.add(COMPONENT_CLASS);
+	});
+}
+//#endregion
 //#region src/geometry-fixes.ts
 const HOVER_GEOMETRY_STYLE_SELECTOR = "style[data-inkstone=\"monaco-hover-geometry\"]";
 function installHoverGeometryFix() {
@@ -198,14 +208,6 @@ function installSuggestGeometryFix() {
 	style.textContent = ".monaco-editor .suggest-widget .monaco-list .monaco-list-row > .contents > .main > .right > span.readMore.codicon.codicon-suggest-more-info::before { position: absolute; top: 50%; left: 50%; transform: translate(-50%, -50%); }";
 	document.head.append(style);
 }
-const QUICK_INPUT_GEOMETRY_STYLE_SELECTOR = "style[data-inkstone=\"monaco-quick-input-geometry\"]";
-function installQuickInputGeometryFix() {
-	if (document.querySelector(QUICK_INPUT_GEOMETRY_STYLE_SELECTOR)) return;
-	const style = document.createElement("style");
-	style.dataset.inkstone = "monaco-quick-input-geometry";
-	style.textContent = ".monaco-editor .quick-input-list { position: relative; }";
-	document.head.append(style);
-}
 const HOVER_FOCUS_STYLE_SELECTOR = "style[data-inkstone=\"monaco-hover-focus\"]";
 function installHoverFocusFix() {
 	if (document.querySelector(HOVER_FOCUS_STYLE_SELECTOR)) return;
@@ -313,11 +315,11 @@ function ensureMonacoHost(options = {}) {
 			installDesignTokens();
 			installHoverGeometryFix();
 			installSuggestGeometryFix();
-			installQuickInputGeometryFix();
 			installHoverFocusFix();
 			const monaco = await import("monaco-editor");
 			rememberInternals(monaco, await loadMonacoInternals());
 			globalThis.MonacoEnvironment = { getWorker: (workerId, label) => getWorker?.(workerId, label) ?? builtinGetWorker(label) };
+			installContextMenuThemeFix(monaco);
 			if (locale === "zh-cn") monaco.editor.onDidCreateEditor(localizeActionDescriptions);
 			return monaco;
 		} catch (error) {

package/dist/vite.d.ts

@@ -17,6 +17,5 @@ import { Plugin } from "vite";
  * 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 };
+export declare function dropMonacoWorkerFallbacks(): Plugin;
+//#endregion

package/dist/workers/ts.worker.js

@@ -63,7 +63,7 @@ class JsxTypeScriptWorker extends TypeScriptWorker {
   }
 }
 
-// Monaco's worker handshake is two-staged (`internal/common/initialize.js`, 0.56): a first
+// Monaco's worker handshake is two-staged (`internal/common/initialize.js`, 0.57): a first
 // message merely triggers `initialize`, whose own handler then reads the *second* message as
 // createData. The stock entry import above installed the stage-one handler for its own
 // factory; this assignment must *replace* it with one building the subclass — calling

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@coldsmirk/inkstone-monaco",
-  "version": "0.30.0",
+  "version": "0.31.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",
@@ -40,15 +40,15 @@
   ],
   "dependencies": {
     "@shikijs/vscode-textmate": "^10.0.2",
-    "shiki": "^4.4.3",
-    "@coldsmirk/inkstone-core": "^0.30.0"
+    "shiki": "^4.5.0",
+    "@coldsmirk/inkstone-core": "^0.31.0"
   },
   "devDependencies": {
-    "monaco-editor": "^0.56.0",
-    "vite": "^8.2.2"
+    "monaco-editor": "^0.57.0",
+    "vite": "^8.3.4"
   },
   "peerDependencies": {
-    "monaco-editor": "^0.56.0",
+    "monaco-editor": "^0.57.0",
     "vite": ">=6"
   },
   "peerDependenciesMeta": {