@coldsmirk/inkstone-monaco 0.17.0 → 0.18.0

package/README.md

@@ -10,7 +10,7 @@ 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.

package/dist/index.d.ts

@@ -51,6 +51,47 @@ type MonacoModule = typeof monacoEditor;
  */
 declare function ensureMonacoHost(options?: MonacoHostOptions): Promise<MonacoModule>;
 //#endregion
+//#region src/auto-imports.d.ts
+/**
+ * Options for {@link installAutoImportCompletions}.
+ */
+interface AutoImportCompletionOptions {
+  /**
+   * The module specifiers admitted as auto-import sources for this model, or undefined /
+   * empty to offer none. Consulted on every completion request, so the answer may follow the
+   * app's active editing surface.
+   */
+  admittedSources: (model: monacoEditor.editor.ITextModel) => readonly string[] | undefined;
+}
+/**
+ * Registers the auto-import completion provider on `monaco`'s `typescript` language id (the
+ * id also carries `.tsx` models — the model path decides JSX-ness). Additive beside the
+ * stock provider: entries are only unimported module exports from sources the app admits,
+ * labeled with their module, sorted after in-scope symbols by the language service's own
+ * `sortText`, and resolving one computes the import statement (merging into an existing
+ * import from the same module) as `additionalTextEdits`. A routed worker without the bundled
+ * 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;
+//#endregion
+//#region src/hover-dead-band.d.ts
+/**
+ * The slice of a standalone editor the install touches — structural, so the install is
+ * testable without evaluating the monaco module (which jsdom cannot do).
+ */
+interface HoverDeadBandTargetEditor {
+  getContribution: (id: string) => unknown;
+}
+/**
+ * Keeps `editorInstance`'s content hover reachable by a slowly moving pointer: overrides the
+ * controller's on-the-widget test so the widget's pointer-active frame counts as the widget
+ * (see the file comment for the dead band this compensates). Installed by `<MonacoEditor>`
+ * 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;
+//#endregion
 //#region src/jsx-tag-closing.d.ts
 /**
  * The slice of a text model the install reads — a structural type, so the install is testable
@@ -63,22 +104,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
@@ -310,4 +366,4 @@ declare class StreamingEditorController {
   discard(): void;
 }
 //#endregion
-export { DEFAULT_MONACO_OPTIONS, type JsxTagClosingTargetEditor, type JsxTagClosingTargetModel, type KeybindingTargetEditor, type MonacoBuiltInLanguage, type MonacoHostOptions, type MonacoLanguage, type MonacoModule, type MonacoUiLocale, type StreamTargetEditor, StreamingEditorController, type SwallowedKeybindings, disabledKeybindings, ensureMonacoHost, installDisabledKeybindings, installJsxTagClosing, modelValueMatches, monacoLanguages, reconcileModelValue, registerShikiHighlighting, replaceInEditor };
+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, installDisabledKeybindings, installHoverDeadBandFix, installJsxTagClosing, modelValueMatches, monacoLanguages, reconcileModelValue, registerShikiHighlighting, replaceInEditor };

package/dist/index.js

@@ -1,5 +1,128 @@
 import { CODE_FONT_FAMILY } from "@coldsmirk/inkstone-core";
 import { shikiToMonaco } from "@shikijs/monaco";
+//#region src/auto-imports.ts
+const MISSING_LOOKUP_REJECTION$1 = "Missing requestHandler or method: getAutoImportCompletionsAtPosition";
+const MODE_BOOTING_REJECTIONS$1 = /* @__PURE__ */ new Set(["TypeScript not registered!", "JavaScript not registered!"]);
+const ENTRY_KINDS = {
+	function: "Function",
+	method: "Function",
+	class: "Class",
+	interface: "Interface",
+	module: "Module",
+	type: "Variable",
+	alias: "Variable"
+};
+function itemKind(monaco, kind) {
+	return monaco.languages.CompletionItemKind[ENTRY_KINDS[kind] ?? "Variable"];
+}
+function partsText(parts) {
+	return (parts ?? []).map((part) => part.text).join("");
+}
+const LEDGER_KEY = Symbol.for("coldsmirk.inkstone.autoImportCompletions");
+function ledgerOf() {
+	const holder = globalThis;
+	let ledger = holder[LEDGER_KEY];
+	if (!ledger) {
+		ledger = /* @__PURE__ */ new WeakMap();
+		holder[LEDGER_KEY] = ledger;
+	}
+	return ledger;
+}
+function classify(error) {
+	const message = error instanceof Error ? error.message : typeof error === "string" ? error : "";
+	if (message === MISSING_LOOKUP_REJECTION$1) return "disarm";
+	return MODE_BOOTING_REJECTIONS$1.has(message) ? "booting" : "failure";
+}
+function installAutoImportCompletions(monaco, options) {
+	const ledger = ledgerOf();
+	const installed = ledger.get(monaco);
+	if (installed) return installed;
+	let lookupUnsupported = false;
+	const disposable = monaco.languages.registerCompletionItemProvider("typescript", {
+		async provideCompletionItems(model, position) {
+			const sources = options.admittedSources(model);
+			if (lookupUnsupported || !sources || sources.length === 0) return { suggestions: [] };
+			const wordInfo = model.getWordUntilPosition(position);
+			const offset = model.getOffsetAt(position);
+			try {
+				const workerFor = await monaco.typescript.getTypeScriptWorker();
+				if (model.isDisposed()) return { suggestions: [] };
+				const info = await (await workerFor(model.uri)).getAutoImportCompletionsAtPosition(model.uri.toString(), offset, sources);
+				if (!info || model.isDisposed()) return { suggestions: [] };
+				const range = {
+					startLineNumber: position.lineNumber,
+					startColumn: wordInfo.startColumn,
+					endLineNumber: position.lineNumber,
+					endColumn: wordInfo.endColumn
+				};
+				return {
+					suggestions: info.entries.map((entry) => {
+						return {
+							label: {
+								label: entry.name,
+								description: entry.source
+							},
+							kind: itemKind(monaco, entry.kind),
+							insertText: entry.insertText ?? entry.name,
+							filterText: entry.name,
+							sortText: entry.sortText,
+							range,
+							uri: model.uri,
+							offset,
+							entry
+						};
+					}),
+					incomplete: info.isIncomplete
+				};
+			} catch (error) {
+				const verdict = classify(error);
+				if (verdict === "disarm") lookupUnsupported = true;
+				else if (verdict === "failure") console.error("inkstone: auto-import completion lookup failed", error);
+				return { suggestions: [] };
+			}
+		},
+		async resolveCompletionItem(item) {
+			const myItem = item;
+			if (!myItem.entry) return item;
+			try {
+				const details = await (await (await monaco.typescript.getTypeScriptWorker())(myItem.uri)).getAutoImportCompletionEntryDetails(myItem.uri.toString(), myItem.offset, myItem.entry.name, myItem.entry.source, myItem.entry.data);
+				const model = monaco.editor.getModel(myItem.uri);
+				if (!details || !model || model.isDisposed()) return item;
+				const fileName = myItem.uri.toString();
+				const additionalTextEdits = (details.codeActions ?? []).flatMap((action) => action.changes).filter((change) => change.fileName === fileName).flatMap((change) => change.textChanges).map((textChange) => {
+					const start = model.getPositionAt(textChange.span.start);
+					const end = model.getPositionAt(textChange.span.start + textChange.span.length);
+					return {
+						range: {
+							startLineNumber: start.lineNumber,
+							startColumn: start.column,
+							endLineNumber: end.lineNumber,
+							endColumn: end.column
+						},
+						text: textChange.newText
+					};
+				});
+				const documentation = partsText(details.documentation);
+				return {
+					...myItem,
+					additionalTextEdits,
+					detail: details.codeActions?.[0]?.description ?? partsText(details.displayParts),
+					...documentation && { documentation: { value: documentation } }
+				};
+			} catch (error) {
+				if (classify(error) === "failure") console.error("inkstone: auto-import details lookup failed", error);
+				return item;
+			}
+		}
+	});
+	const install = { dispose: () => {
+		ledger.delete(monaco);
+		disposable.dispose();
+	} };
+	ledger.set(monaco, install);
+	return install;
+}
+//#endregion
 //#region src/geometry-fixes.ts
 const HOVER_GEOMETRY_STYLE_SELECTOR = "style[data-inkstone=\"monaco-hover-geometry\"]";
 function installHoverGeometryFix() {
@@ -101,13 +224,40 @@ function ensureMonacoHost(options = {}) {
 	return attempt;
 }
 //#endregion
+//#region src/hover-dead-band.ts
+const CONTENT_HOVER_CONTRIBUTION = "editor.contrib.contentHover";
+const TOLERANCE = 4;
+function isContentHoverController(candidate) {
+	return typeof candidate === "object" && candidate !== null && typeof candidate._isMouseOnContentHoverWidget === "function";
+}
+function installHoverDeadBandFix(editorInstance) {
+	const controller = editorInstance.getContribution(CONTENT_HOVER_CONTRIBUTION);
+	if (!isContentHoverController(controller) || Object.hasOwn(controller, "_isMouseOnContentHoverWidget")) return { dispose: () => {} };
+	controller._isMouseOnContentHoverWidget = (mouseEvent) => {
+		const dom = controller._contentWidget?.getDomNode();
+		if (!dom) return false;
+		const rect = dom.getBoundingClientRect();
+		const view = dom.ownerDocument.defaultView;
+		const x = mouseEvent.event.posx - (view?.scrollX ?? 0);
+		const y = mouseEvent.event.posy - (view?.scrollY ?? 0);
+		return rect.width > 0 && rect.height > 0 && x >= rect.left - TOLERANCE && x <= rect.right + TOLERANCE && y >= rect.top - TOLERANCE && y <= rect.bottom + TOLERANCE;
+	};
+	return { dispose: () => {
+		delete controller._isMouseOnContentHoverWidget;
+	} };
+}
+//#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 +266,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);
 			}
 		})();
@@ -506,4 +666,4 @@ var StreamingEditorController = class {
 	}
 };
 //#endregion
-export { DEFAULT_MONACO_OPTIONS, StreamingEditorController, disabledKeybindings, ensureMonacoHost, installDisabledKeybindings, installJsxTagClosing, modelValueMatches, monacoLanguages, reconcileModelValue, registerShikiHighlighting, replaceInEditor };
+export { DEFAULT_MONACO_OPTIONS, StreamingEditorController, disabledKeybindings, ensureMonacoHost, installAutoImportCompletions, installDisabledKeybindings, installHoverDeadBandFix, installJsxTagClosing, modelValueMatches, monacoLanguages, reconcileModelValue, registerShikiHighlighting, replaceInEditor };

package/dist/vite.js

@@ -4,7 +4,7 @@ function dropMonacoWorkerFallbacks() {
 	return {
 		name: "inkstone:drop-monaco-worker-fallbacks",
 		transform(code, id) {
-			if (!id.includes("monaco-editor") || !id.endsWith("workerManager.js")) return;
+			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;
@@ -16,7 +16,7 @@ function dropMonacoWorkerFallbacks() {
 			}
 			return {
 				code: transformed,
-				map: null
+				map: { mappings: "" }
 			};
 		}
 	};

package/dist/workers/ts.worker.js

@@ -2,16 +2,65 @@
 // See editor.worker.js for why this indirection exists.
 //
 // Unlike its siblings this entry is not a bare re-export: it subclasses the stock worker to
-// expose `getJsxClosingTagAtPosition` — the language-service call behind auto-closing JSX
-// tags (`installJsxTagClosing` is the editor-side half) — which monaco's own worker never
-// proxied. The host's worker proxy forwards any method name, so the subclass only has to
-// exist here; nothing on the main thread changes.
+// expose language-service calls monaco's own worker never proxied — the host's worker proxy
+// forwards any method name, so the subclass only has to exist here; nothing on the main
+// thread changes for it to be callable:
+//  - `getJsxClosingTagAtPosition`, behind auto-closing JSX tags (`installJsxTagClosing` is
+//    the editor-side half);
+//  - the auto-import completion pair, behind `installAutoImportCompletions`: the stock worker
+//    calls `getCompletionsAtPosition` without preferences, so the service never surfaces
+//    unimported module exports, and its details call drops `source`/`data`, so the import
+//    text edit (`codeActions`) can never be requested. These two pass the module-export
+//    preferences through and return the entries verbatim.
 import { initialize, TypeScriptWorker } from "monaco-editor/language/typescript/ts.worker.js";
 
+// The preferences that make the language service surface unimported module exports and, on
+// the details call, compute their import edits. `allowIncompleteCompletions` lets it bound a
+// broad enumeration by the typed prefix and say so (`isIncomplete` → monaco re-queries).
+const AUTO_IMPORT_PREFERENCES = {
+  includeCompletionsForModuleExports: true,
+  includeCompletionsWithInsertText: true,
+  allowIncompleteCompletions: true
+};
+
 class JsxTypeScriptWorker extends TypeScriptWorker {
   getJsxClosingTagAtPosition(fileName, position) {
     return this.getLanguageService().getJsxClosingTagAtPosition(fileName, position);
   }
+
+  getAutoImportCompletionsAtPosition(fileName, position, admittedSources) {
+    const info = this.getLanguageService().getCompletionsAtPosition(fileName, position, AUTO_IMPORT_PREFERENCES);
+
+    if (!info) {
+      return;
+    }
+
+    // Only entries importable from an admitted specifier: the language service also offers
+    // every other module in the program (deep package paths included), which the editor-side
+    // policy has ruled out — filtering here keeps them off the wire entirely.
+    const admitted = new Set(admittedSources);
+
+    return {
+      isIncomplete: info.isIncomplete === true,
+      entries: info.entries.filter(entry => entry.source !== undefined && admitted.has(entry.source))
+    };
+  }
+
+  getAutoImportCompletionEntryDetails(fileName, position, entryName, source, data) {
+    // `data` must round-trip from the completion entry: without it the service cannot compute
+    // the import edit for a node_modules package (an ambient module happens to survive, but
+    // the contract is the pair). `semicolons: "insert"` makes the generated statement end in
+    // one, matching the house style of every template the editors seed.
+    return this.getLanguageService().getCompletionEntryDetails(
+      fileName,
+      position,
+      entryName,
+      { semicolons: "insert" },
+      source,
+      AUTO_IMPORT_PREFERENCES,
+      data
+    );
+  }
 }
 
 // Monaco's worker handshake is two-staged (`internal/common/initialize.js`, 0.56): a first

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@coldsmirk/inkstone-monaco",
-  "version": "0.17.0",
+  "version": "0.18.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,7 +40,7 @@
   ],
   "dependencies": {
     "@shikijs/monaco": "^4.4.3",
-    "@coldsmirk/inkstone-core": "^0.17.0"
+    "@coldsmirk/inkstone-core": "^0.18.0"
   },
   "devDependencies": {
     "monaco-editor": "^0.56.0",