@checkstack/ui 1.11.0 → 1.13.0

package/src/components/CodeEditor/monacoGuard.ts

@@ -0,0 +1,76 @@
+/// <reference types="vite/client" />
+// Guarded accessor for the monaco-vscode editor API. ALL runtime monaco access
+// in this package goes through here; direct value imports of
+// `@codingame/monaco-vscode-editor-api` elsewhere are banned by lint
+// (`no-restricted-imports`) so the guard cannot be bypassed.
+//
+// Why: `monaco.editor.*` / `monaco.languages.*` functions resolve services via
+// `StandaloneServices.get()`, which AUTO-INITIALIZES the monaco-vscode services
+// on first use (CodinGame `standaloneServices.js` — `get()` calls `initialize`
+// when not yet initialized). `@typefox/monaco-editor-react` tracks its OWN,
+// independent init flags; if any `monaco.*` call runs BEFORE the wrapper's init,
+// it trips CodinGame's `servicesInitialized` flag and the wrapper's later
+// `initialize()` throws "Services are already initialized" — the editor then
+// never renders. This is dev-only (production's single mount masked it once),
+// and it is exactly the bug this guard prevents from regressing.
+//
+// In dev, calling any `monaco.editor.*` / `monaco.languages.*` FUNCTION before
+// `areVscodeServicesReady()` throws immediately, at the exact call site, with a
+// clear message. In production the raw API is returned (zero overhead).
+
+import * as monacoApi from "@codingame/monaco-vscode-editor-api";
+import { areVscodeServicesReady } from "./vscodeServicesSignal";
+
+// The namespaces whose functions auto-initialize the services on first use.
+const GUARDED_NAMESPACES = new Set(["editor", "languages"]);
+
+// Wrap a namespace so calling any of its functions before services are ready
+// throws. Non-function members (enums like `MarkerSeverity`, classes) pass
+// through untouched. Returns the same type `T` (the Proxy is invisible to types,
+// so call sites still type-check against the real monaco signatures).
+const guardNamespace = <T extends object>(ns: T, nsName: string): T =>
+  new Proxy(ns, {
+    get(target, prop, receiver): unknown {
+      const value: unknown = Reflect.get(target, prop, receiver);
+      if (typeof value !== "function" || typeof prop !== "string") {
+        return value;
+      }
+      const fn = value;
+      return (...args: unknown[]): unknown => {
+        if (!areVscodeServicesReady()) {
+          throw new Error(
+            `monaco.${nsName}.${prop}() was called before the monaco-vscode ` +
+              `services were initialized. That call auto-initializes the ` +
+              `services and breaks the editor's @typefox init ("Services are ` +
+              `already initialized"), so the editor never renders. Gate it ` +
+              `behind \`apiReady\` (the editor's onEditorStartDone) or ` +
+              `\`areVscodeServicesReady()\`. See ` +
+              `core/ui/src/components/CodeEditor/monacoGuard.ts.`,
+          );
+        }
+        return Reflect.apply(fn, ns, args);
+      };
+    },
+  });
+
+const guardedMonaco: typeof monacoApi = import.meta.env.DEV
+  ? new Proxy(monacoApi, {
+      get(target, prop, receiver): unknown {
+        const value: unknown = Reflect.get(target, prop, receiver);
+        if (
+          typeof prop === "string" &&
+          GUARDED_NAMESPACES.has(prop) &&
+          typeof value === "object" &&
+          value !== null
+        ) {
+          return guardNamespace(value, prop);
+        }
+        return value;
+      },
+    })
+  : monacoApi;
+
+// The guarded runtime value. Consumers import this for runtime monaco access
+// and import the TYPE namespace separately, type-only, from
+// `@codingame/monaco-vscode-editor-api` (which the lint rule allows).
+export { guardedMonaco as monaco };

package/src/components/CodeEditor/monacoTsService.ts

@@ -0,0 +1,185 @@
+// Shared standalone TypeScript / JavaScript language-service setup.
+//
+// Extracted from `TypefoxEditor` so it can be imported by BOTH the editor and
+// the headless `validateScripts` validator. Both need the same singletons
+// configured (compiler options, ambient stdlib types, the TS worker), and the
+// validator must work even when NO editor is mounted (every script action card
+// collapsed) - so the setup cannot live inside the editor component module's
+// render path.
+//
+// The TS/JS language-service `defaults` are singletons, so the configuration
+// here runs ONCE at module load. The worker factory is registered lazily (and
+// idempotently) via `ensureStandaloneWorkerFactory()` because the editor also
+// registers it during its own init - the guard makes a double-call a no-op.
+
+// Side-effect import: registers the standalone language grammars. Imported here
+// too (not only in TypefoxEditor) so the validator gets a fully-registered TS
+// language environment regardless of import order.
+import "@codingame/monaco-vscode-standalone-languages";
+// The named imports below ALSO trigger this package's side-effect registration
+// of the standalone TypeScript language features (defaults + ts.worker).
+import {
+  typescriptDefaults,
+  javascriptDefaults,
+  ScriptTarget,
+  ModuleKind,
+  ModuleResolutionKind,
+} from "@codingame/monaco-vscode-standalone-typescript-language-features";
+// Worker entry URLs, bundled and resolved by Vite via the `?worker&url` suffix.
+// Imported as URL STRINGS (not Worker constructors) because
+// monaco-languageclient's worker factory consumes `loader().url.toString()`.
+import editorWorkerUrl from "@codingame/monaco-vscode-editor-api/esm/vs/editor/editor.worker.js?worker&url";
+import tsWorkerUrl from "@codingame/monaco-vscode-standalone-typescript-language-features/worker?worker&url";
+import jsonWorkerUrl from "@codingame/monaco-vscode-standalone-json-language-features/worker?worker&url";
+import {
+  // `useWorkerFactory` is a plain library registration function, not a React
+  // hook. We alias away the `use` prefix so the `react-hooks/rules-of-hooks`
+  // lint rule (which keys purely off the identifier name) does not misfire.
+  useWorkerFactory as registerWorkerFactory,
+  Worker,
+  type WorkerFactoryConfig,
+  type WorkerLoader,
+} from "monaco-languageclient/workerFactory";
+
+// Re-exported so consumers keep a single import surface for the TS services.
+export {
+  typescriptDefaults,
+  javascriptDefaults,
+  ScriptTarget,
+  ModuleKind,
+  ModuleResolutionKind,
+} from "@codingame/monaco-vscode-standalone-typescript-language-features";
+
+// The logger type originates from `@codingame/monaco-vscode-log-service-override`,
+// which is not a direct dependency of this package. We derive it from the
+// `WorkerFactoryConfig` we already import so we never reach for a transitive
+// specifier (and never need an `any`).
+type WorkerFactoryLogger = WorkerFactoryConfig["logger"];
+
+const editorWorkerLoader: WorkerLoader = () =>
+  new Worker(editorWorkerUrl, { type: "module" });
+
+const tsWorkerLoader: WorkerLoader = () =>
+  new Worker(tsWorkerUrl, { type: "module" });
+
+const jsonWorkerLoader: WorkerLoader = () =>
+  new Worker(jsonWorkerUrl, { type: "module" });
+
+// The "monaco-vscode services ready" signal (`markVscodeServicesReady` /
+// `areVscodeServicesReady` / `onVscodeServicesReady`) lives in the Monaco-free
+// `vscodeServicesSignal` module so the barrel and the automation editor can
+// observe readiness without importing this Monaco-heavy module. See that file
+// for the full rationale.
+
+let workerFactoryRegistered = false;
+
+/**
+ * Register the worker loaders for the standalone (classic) Monaco setup. We
+ * only need the generic editor worker plus the TypeScript worker (which also
+ * serves JavaScript) and the JSON worker. Mirrors the upstream
+ * `defineClassicWorkers` helper.
+ *
+ * Idempotent: the first caller registers, subsequent calls no-op. Both the
+ * editor (via its `monacoWorkerFactory` app-config hook) AND the headless
+ * validator call this, so the guard prevents a double registration. The
+ * editor's call may pass a `logger`; the first registration wins, so when the
+ * validator registers first the editor simply reuses it (logging is optional).
+ */
+export const ensureStandaloneWorkerFactory = (
+  logger?: WorkerFactoryLogger,
+): void => {
+  if (workerFactoryRegistered) {
+    return;
+  }
+  workerFactoryRegistered = true;
+  registerWorkerFactory({
+    workerLoaders: {
+      editorWorkerService: editorWorkerLoader,
+      // Both must be defined or the worker factory errors (see upstream
+      // helper-classic.ts).
+      javascript: tsWorkerLoader,
+      typescript: tsWorkerLoader,
+      json: jsonWorkerLoader,
+    },
+    logger,
+  });
+};
+
+// Base compiler options for the standalone TS + JS services. `types` (node +
+// bun-types) is added only once the stdlib bundle has loaded (see
+// ensureStandaloneStdlib), so the service doesn't transiently error on a
+// missing `node` type while the ~3 MB bundle is still fetching.
+//
+// `baseUrl: "file:///"` anchors NodeJs bare-import resolution at the virtual
+// root so an `import "lodash"` walks `file:///node_modules/...` - the same
+// virtual layout the stdlib bundle AND the lazy-ATA extra-libs are registered
+// under. `typeRoots` lists BOTH the `@types` root (so a package with no own
+// types, e.g. lodash, falls back to `@types/lodash`) and the bare
+// `node_modules` root (so the bundled `bun-types`, which is NOT under
+// `@types`, still resolves as an ambient `types` entry).
+export const BASE_COMPILER_OPTIONS = {
+  target: ScriptTarget.ESNext,
+  module: ModuleKind.ESNext,
+  moduleResolution: ModuleResolutionKind.NodeJs,
+  lib: ["esnext"],
+  allowNonTsExtensions: false,
+  noEmit: true,
+  strict: true,
+  esModuleInterop: true,
+  baseUrl: "file:///",
+  typeRoots: ["file:///node_modules/@types", "file:///node_modules"],
+};
+
+/**
+ * Configure the standalone TS + JS language services ONCE at module load.
+ * `typescriptDefaults` / `javascriptDefaults` are singletons, so doing this at
+ * module scope (not per-mount) guarantees the first editor to mount cannot
+ * start the service with stale defaults - the timing race the legacy monaco
+ * editor hit.
+ */
+const configureTypeScriptDefaults = (): void => {
+  for (const defaults of [typescriptDefaults, javascriptDefaults]) {
+    defaults.setCompilerOptions({ ...BASE_COMPILER_OPTIONS });
+    // 1108: a top-level `return` is valid because the runtime wraps scripts in
+    // an async IIFE (same suppression as the legacy editor).
+    defaults.setDiagnosticsOptions({ diagnosticCodesToIgnore: [1108] });
+    // Push models to the worker eagerly so diagnostics/completions are ready on
+    // the first keystroke.
+    defaults.setEagerModelSync(true);
+  }
+};
+
+configureTypeScriptDefaults();
+
+/**
+ * Lazy-load the bundled `@types/node` + `bun-types` declarations into the
+ * standalone TS service so script editors have `console`, `fetch`, `process`,
+ * `Bun`, etc. typed. The ~3 MB bundle is code-split into its own chunk and
+ * fetched once. Runs at module load; this file is browser-only so the dynamic
+ * import is safe here. Returns the in-flight promise so callers (the headless
+ * validator) can await stdlib readiness before requesting diagnostics.
+ */
+let stdlibLoad: Promise<void> | undefined;
+export const ensureStandaloneStdlib = (): Promise<void> => {
+  if (stdlibLoad) {
+    return stdlibLoad;
+  }
+  stdlibLoad = (async () => {
+    const stdlibModule = await import("./generated/stdlib-types.json");
+    const bundle = stdlibModule.default;
+    for (const defaults of [typescriptDefaults, javascriptDefaults]) {
+      for (const [path, content] of Object.entries(bundle)) {
+        defaults.addExtraLib(content, `file:///${path}`);
+      }
+      // The @types/node + bun-types declarations now exist at their node_modules
+      // virtual paths, so include them ambiently.
+      defaults.setCompilerOptions({
+        ...BASE_COMPILER_OPTIONS,
+        types: ["node", "bun-types"],
+      });
+    }
+  })();
+  return stdlibLoad;
+};
+
+void ensureStandaloneStdlib();

package/src/components/CodeEditor/popoutTitle.test.ts

@@ -0,0 +1,37 @@
+import { describe, expect, it } from "bun:test";
+import { popoutTitle } from "./popoutTitle";
+import type { CodeEditorLanguage } from "./types";
+
+describe("popoutTitle", () => {
+  it("derives a script title for TypeScript", () => {
+    expect(popoutTitle({ language: "typescript" })).toBe(
+      "Edit script - TypeScript",
+    );
+  });
+
+  it("derives a script title for JavaScript", () => {
+    expect(popoutTitle({ language: "javascript" })).toBe(
+      "Edit script - JavaScript",
+    );
+  });
+
+  it("derives a script title for Shell", () => {
+    expect(popoutTitle({ language: "shell" })).toBe("Edit script - Shell");
+  });
+
+  it("falls back to a generic title for markup/text languages", () => {
+    const markupLanguages: CodeEditorLanguage[] = [
+      "json",
+      "yaml",
+      "xml",
+      "markdown",
+    ];
+    for (const language of markupLanguages) {
+      expect(popoutTitle({ language })).toBe("Edit");
+    }
+  });
+
+  it("uses a normal hyphen, never an em-dash", () => {
+    expect(popoutTitle({ language: "typescript" })).not.toContain("—");
+  });
+});

package/src/components/CodeEditor/popoutTitle.ts

@@ -0,0 +1,31 @@
+// Pure helper deriving the popout-dialog title from the editor language.
+// Kept separate (and unit-tested) so the title logic isn't buried in UI glue.
+import type { CodeEditorLanguage } from "./types";
+
+// Human-readable display name for the languages that get a script-flavoured
+// title. Markup/text languages fall through to the generic "Edit" title since
+// "script" wouldn't read correctly for them.
+const SCRIPT_LANGUAGE_LABELS: Partial<Record<CodeEditorLanguage, string>> = {
+  typescript: "TypeScript",
+  javascript: "JavaScript",
+  shell: "Shell",
+};
+
+/**
+ * Derive the overlay dialog title from the editor language.
+ *
+ * - Script languages (`typescript` / `javascript` / `shell`) read as
+ *   `Edit script - <Language>`.
+ * - Everything else (markup/text: json / yaml / xml / markdown) falls back to
+ *   the generic `Edit`.
+ *
+ * Uses a normal hyphen (not an em-dash) per the project content style.
+ */
+export const popoutTitle = ({
+  language,
+}: {
+  language: CodeEditorLanguage;
+}): string => {
+  const scriptLabel = SCRIPT_LANGUAGE_LABELS[language];
+  return scriptLabel ? `Edit script - ${scriptLabel}` : "Edit";
+};

package/src/components/CodeEditor/scriptContext.test.ts

@@ -7,13 +7,17 @@ import {
 import type { JsonSchemaProperty } from "../DynamicForm/types";
 
 describe("healthcheckScriptContext", () => {
-  it("emits both the global and module-export declarations of defineHealthCheck", () => {
+  it("emits the global helper + context types, but NOT a bare-name module block", () => {
     const ctx = healthcheckScriptContext({});
-    // Module declaration is what `import { defineHealthCheck } from
-    // "@checkstack/healthcheck"` resolves to.
-    expect(ctx.typeDefinitions).toContain('declare module "@checkstack/healthcheck"');
+    // The bare-name `@checkstack/healthcheck` module block is REMOVED (plan
+    // §6.2 / §6.4): the subpath module `@checkstack/sdk/healthcheck` is now
+    // resolved from the injected @checkstack/sdk editor bundle, not from
+    // scriptContext. scriptContext must NOT declare ANY package module block.
+    expect(ctx.typeDefinitions).not.toContain('declare module "@checkstack/healthcheck"');
+    expect(ctx.typeDefinitions).not.toContain('declare module "@checkstack/sdk/healthcheck"');
+    expect(ctx.typeDefinitions).not.toContain("declare module");
     expect(ctx.typeDefinitions).toContain("HealthCheckScriptResult");
-    // Global declaration is what makes Monaco autocomplete `defineHea…`
+    // The global declaration stays — it makes Monaco autocomplete `defineHea…`
     // _without_ requiring the user to type the import first (Monaco 0.55
     // doesn't expose `includeCompletionsForModuleExports`).
     expect(ctx.typeDefinitions).toMatch(/declare function defineHealthCheck/);
@@ -143,9 +147,13 @@ describe("healthcheckScriptContext", () => {
 });
 
 describe("integrationScriptContext", () => {
-  it("emits both the global and module-export declarations of defineIntegration", () => {
+  it("emits the global helper + context types, but NOT a bare-name module block", () => {
     const ctx = integrationScriptContext({});
-    expect(ctx.typeDefinitions).toContain('declare module "@checkstack/integration"');
+    // Bare-name `@checkstack/integration` block removed (§6.2/§6.4); the
+    // subpath module resolves from the injected @checkstack/sdk editor bundle.
+    expect(ctx.typeDefinitions).not.toContain('declare module "@checkstack/integration"');
+    expect(ctx.typeDefinitions).not.toContain('declare module "@checkstack/sdk/integration"');
+    expect(ctx.typeDefinitions).not.toContain("declare module");
     expect(ctx.typeDefinitions).toContain("IntegrationScriptResult");
     // Global form — analogous to defineHealthCheck.
     expect(ctx.typeDefinitions).toMatch(/declare function defineIntegration/);

package/src/components/CodeEditor/scriptContext.ts

@@ -8,8 +8,9 @@ import { jsonSchemaToTypeScript } from "./generateTypeDefinitions";
  *
  *  - `healthcheckInlineContext` — inline TS/JS health checks.
  *    `context.config` is typed from the collector's own config schema.
- *    A virtual `@checkstack/healthcheck` module exposes the required
- *    return shape so users get a type _error_ when the shape is wrong.
+ *    The `@checkstack/sdk/healthcheck` module (resolved from the injected
+ *    @checkstack/sdk editor bundle) exposes the required return shape so
+ *    users get a type _error_ when the shape is wrong.
  *
  *  - `healthcheckShellContext` — shell health checks. No platform-injected
  *    env vars today (the user supplies `env` themselves), so we surface
@@ -18,7 +19,8 @@ import { jsonSchemaToTypeScript } from "./generateTypeDefinitions";
  *
  *  - `integrationInlineContext` — TS/JS integration scripts.
  *    `context.event.payload` is typed from the event's payload schema.
- *    A virtual `@checkstack/integration` module exposes the result shape.
+ *    The `@checkstack/sdk/integration` module (resolved from the injected
+ *    @checkstack/sdk editor bundle) exposes the result shape.
  *
  *  - `integrationShellContext` — shell integration scripts. The platform
  *    injects `EVENT_ID`, `DELIVERY_ID`, `SUBSCRIPTION_ID`,
@@ -119,9 +121,10 @@ interface HealthCheckScriptContext {
  * to be so mistakes are caught before the script ever runs.
  *
  * Available both as a global (this declaration) and as a named export
- * from \`@checkstack/healthcheck\` (below). The global form means the
- * editor can autocomplete it without the user typing the import first;
- * the module form is for explicit, IDE-style imports.
+ * from \`@checkstack/sdk/healthcheck\`. The global form means the editor
+ * can autocomplete it without the user typing the import first; the
+ * named-export form (resolved from the injected @checkstack/sdk editor
+ * bundle, not declared here) is for explicit, IDE-style imports.
  */
 declare function defineHealthCheck<
   T extends
@@ -132,11 +135,6 @@ declare function defineHealthCheck<
 >(value: T): T;
 
 declare const context: HealthCheckScriptContext;
-
-declare module "@checkstack/healthcheck" {
-  export type { HealthCheckScriptResult, HealthCheckScriptContext };
-  export { defineHealthCheck };
-}
 `;
 }
 
@@ -187,7 +185,8 @@ interface IntegrationScriptContext {
  * Helper that asserts the return shape of an integration script at the
  * type level. See \`defineHealthCheck\` for the analogous health-check
  * helper. Available both as a global and as a named export from
- * \`@checkstack/integration\`.
+ * \`@checkstack/sdk/integration\` (resolved from the injected
+ * @checkstack/sdk editor bundle, not declared here).
  */
 declare function defineIntegration<
   T extends
@@ -200,11 +199,6 @@ declare function defineIntegration<
 >(value: T): T;
 
 declare const context: IntegrationScriptContext;
-
-declare module "@checkstack/integration" {
-  export type { IntegrationScriptResult, IntegrationScriptContext };
-  export { defineIntegration };
-}
 `;
 }
 
@@ -221,7 +215,7 @@ declare module "@checkstack/integration" {
  * `defineHealthCheck` is available without an import (declared as an
  * ambient global in the editor's type defs and injected onto
  * `globalThis` by the runner). The named-import form
- * `import { defineHealthCheck } from "@checkstack/healthcheck"` also
+ * `import { defineHealthCheck } from "@checkstack/sdk/healthcheck"` also
  * works if users prefer it.
  */
 const HEALTHCHECK_INLINE_TS_STARTER = `import { loadavg } from "node:os";

package/src/components/CodeEditor/scriptDiagnostics.test.ts

@@ -0,0 +1,135 @@
+import { describe, expect, it } from "bun:test";
+import {
+  buildValidationSource,
+  flattenDiagnosticMessage,
+  mapWorkerDiagnostics,
+  offsetToPosition,
+  type RawTsDiagnostic,
+} from "./scriptDiagnostics";
+
+describe("offsetToPosition", () => {
+  it("returns 1-based line/column", () => {
+    const text = "ab\ncde\nf";
+    expect(offsetToPosition(text, 0)).toEqual({ line: 1, column: 1 });
+    expect(offsetToPosition(text, 1)).toEqual({ line: 1, column: 2 });
+    // offset 3 is the 'c' (first char after the first newline)
+    expect(offsetToPosition(text, 3)).toEqual({ line: 2, column: 1 });
+    expect(offsetToPosition(text, 7)).toEqual({ line: 3, column: 1 });
+  });
+
+  it("clamps an out-of-range offset to the text length", () => {
+    expect(offsetToPosition("ab", 999)).toEqual({ line: 1, column: 3 });
+  });
+});
+
+describe("flattenDiagnosticMessage", () => {
+  it("passes through a plain string", () => {
+    expect(flattenDiagnosticMessage("boom")).toBe("boom");
+  });
+
+  it("flattens a nested chain depth-first", () => {
+    expect(
+      flattenDiagnosticMessage({
+        messageText: "top",
+        next: [
+          { messageText: "child-a" },
+          { messageText: "child-b", next: [{ messageText: "grandchild" }] },
+        ],
+      }),
+    ).toBe("top child-a child-b grandchild");
+  });
+});
+
+describe("buildValidationSource", () => {
+  it("prepends the type defs and reports the prefix line count", () => {
+    const { text, prependedLineCount } = buildValidationSource({
+      typeDefinitions: "declare const context: { x: number };", // 1 line
+      source: "context.x;",
+    });
+    expect(prependedLineCount).toBe(1);
+    expect(text).toBe("declare const context: { x: number };\ncontext.x;");
+  });
+
+  it("counts multi-line type defs", () => {
+    const { prependedLineCount } = buildValidationSource({
+      typeDefinitions: "line1\nline2\nline3",
+      source: "x",
+    });
+    expect(prependedLineCount).toBe(3);
+  });
+});
+
+describe("mapWorkerDiagnostics", () => {
+  // 2 lines of type defs prepended; user source starts at combined line 3.
+  const { text, prependedLineCount } = buildValidationSource({
+    typeDefinitions: "declare const context: {\n  readonly a: number;\n};",
+    source: "const z = context.b;\n", // `b` doesn't exist -> error on user line 1
+  });
+
+  const errorOffset = text.indexOf("context.b") + "context.".length; // points at `b`
+
+  it("shifts a real type error back onto the user's source line", () => {
+    const diagnostics: RawTsDiagnostic[] = [
+      {
+        start: errorOffset,
+        length: 1,
+        category: 1, // Error
+        code: 2339,
+        messageText: "Property 'b' does not exist on type",
+      },
+    ];
+    const mapped = mapWorkerDiagnostics({
+      diagnostics,
+      validationText: text,
+      prependedLineCount,
+    });
+    expect(mapped).toHaveLength(1);
+    expect(mapped[0]).toMatchObject({
+      severity: "error",
+      line: 1,
+      message: "Property 'b' does not exist on type",
+    });
+  });
+
+  it("drops ignored codes (lazy-ATA module resolution, top-level return)", () => {
+    const diagnostics: RawTsDiagnostic[] = [
+      { start: errorOffset, category: 1, code: 2307, messageText: "Cannot find module 'lodash'" },
+      { start: errorOffset, category: 1, code: 1108, messageText: "A 'return' statement" },
+    ];
+    expect(
+      mapWorkerDiagnostics({ diagnostics, validationText: text, prependedLineCount }),
+    ).toEqual([]);
+  });
+
+  it("drops diagnostics that land inside the prepended type-def prefix", () => {
+    const diagnostics: RawTsDiagnostic[] = [
+      { start: 0, category: 1, code: 2300, messageText: "noise in generated types" },
+    ];
+    expect(
+      mapWorkerDiagnostics({ diagnostics, validationText: text, prependedLineCount }),
+    ).toEqual([]);
+  });
+
+  it("drops non-error/-warning categories and unpositioned diagnostics", () => {
+    const diagnostics: RawTsDiagnostic[] = [
+      { start: errorOffset, category: 2, code: 9999, messageText: "suggestion" },
+      { category: 1, code: 2339, messageText: "global, no position" },
+    ];
+    expect(
+      mapWorkerDiagnostics({ diagnostics, validationText: text, prependedLineCount }),
+    ).toEqual([]);
+  });
+
+  it("keeps warnings", () => {
+    const diagnostics: RawTsDiagnostic[] = [
+      { start: errorOffset, category: 0, code: 6133, messageText: "'z' is declared but never read" },
+    ];
+    const mapped = mapWorkerDiagnostics({
+      diagnostics,
+      validationText: text,
+      prependedLineCount,
+    });
+    expect(mapped).toHaveLength(1);
+    expect(mapped[0]?.severity).toBe("warning");
+  });
+});