@lensmcp/cluster 1.17.1 → 1.17.2

package/index.d.ts

@@ -1,4 +1,5 @@
 export { type NodeExternalsConfig, type ScopePatterns, buildScopePatterns } from './build-scope-patterns';
 export { createDevWebpackConfig, type DevWebpackOptions } from './create-webpack-dev';
 export { createProdWebpackConfig, type ProdWebpackOptions } from './create-webpack-prod';
+export { appendTypecheckEvents, buildTypecheckRunEvents, parseTscDiagnosticLine, parseTscOutput, publishTypecheckRun, resolveEventFile, type TscDiagnostic, type TypecheckBusEvent, } from './typecheck-bus';
 //# sourceMappingURL=index.d.ts.map

package/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../libs/cluster/src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,mBAAmB,EAAE,KAAK,aAAa,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AAC1G,OAAO,EAAE,sBAAsB,EAAE,KAAK,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AACtF,OAAO,EAAE,uBAAuB,EAAE,KAAK,kBAAkB,EAAE,MAAM,uBAAuB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../libs/cluster/src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,mBAAmB,EAAE,KAAK,aAAa,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AAC1G,OAAO,EAAE,sBAAsB,EAAE,KAAK,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AACtF,OAAO,EAAE,uBAAuB,EAAE,KAAK,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AACzF,OAAO,EACL,qBAAqB,EACrB,uBAAuB,EACvB,sBAAsB,EACtB,cAAc,EACd,mBAAmB,EACnB,gBAAgB,EAChB,KAAK,aAAa,EAClB,KAAK,iBAAiB,GACvB,MAAM,iBAAiB,CAAC"}

package/index.js

@@ -1,9 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createProdWebpackConfig = exports.createDevWebpackConfig = exports.buildScopePatterns = void 0;
+exports.resolveEventFile = exports.publishTypecheckRun = exports.parseTscOutput = exports.parseTscDiagnosticLine = exports.buildTypecheckRunEvents = exports.appendTypecheckEvents = exports.createProdWebpackConfig = exports.createDevWebpackConfig = exports.buildScopePatterns = void 0;
 var build_scope_patterns_1 = require("./build-scope-patterns");
 Object.defineProperty(exports, "buildScopePatterns", { enumerable: true, get: function () { return build_scope_patterns_1.buildScopePatterns; } });
 var create_webpack_dev_1 = require("./create-webpack-dev");
 Object.defineProperty(exports, "createDevWebpackConfig", { enumerable: true, get: function () { return create_webpack_dev_1.createDevWebpackConfig; } });
 var create_webpack_prod_1 = require("./create-webpack-prod");
 Object.defineProperty(exports, "createProdWebpackConfig", { enumerable: true, get: function () { return create_webpack_prod_1.createProdWebpackConfig; } });
+var typecheck_bus_1 = require("./typecheck-bus");
+Object.defineProperty(exports, "appendTypecheckEvents", { enumerable: true, get: function () { return typecheck_bus_1.appendTypecheckEvents; } });
+Object.defineProperty(exports, "buildTypecheckRunEvents", { enumerable: true, get: function () { return typecheck_bus_1.buildTypecheckRunEvents; } });
+Object.defineProperty(exports, "parseTscDiagnosticLine", { enumerable: true, get: function () { return typecheck_bus_1.parseTscDiagnosticLine; } });
+Object.defineProperty(exports, "parseTscOutput", { enumerable: true, get: function () { return typecheck_bus_1.parseTscOutput; } });
+Object.defineProperty(exports, "publishTypecheckRun", { enumerable: true, get: function () { return typecheck_bus_1.publishTypecheckRun; } });
+Object.defineProperty(exports, "resolveEventFile", { enumerable: true, get: function () { return typecheck_bus_1.resolveEventFile; } });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lensmcp/cluster",
-  "version": "1.17.1",
+  "version": "1.17.2",
   "description": "Run your Nx workspace as a local production cluster: pods on unix sockets with true HMR, one https gateway with per-project domains, scale-from-zero, autoscale, idle-kill, local-CA TLS — observed by the LensMCP lens.",
   "main": "./index.js",
   "types": "./index.d.ts",
@@ -65,8 +65,8 @@
     }
   },
   "dependencies": {
-    "@lensmcp/node-instrumentation": "1.17.1",
-    "@lensmcp/nx-plugin": "1.17.1",
+    "@lensmcp/node-instrumentation": "1.17.2",
+    "@lensmcp/nx-plugin": "1.17.2",
     "fork-ts-checker-webpack-plugin": "^9.0.0",
     "glob": "^11.0.0",
     "http-proxy": "^1.18.0",

package/tsgo-check-plugin.d.ts

@@ -35,6 +35,14 @@ export interface TsgoCheckPluginOptions {
     binPath?: string;
     /** Injectable for tests. */
     spawnImpl?: typeof spawn;
+    /**
+     * Override the lens bus file. Defaults to `LENSMCP_EVENT_FILE` (which the
+     * gateway already injects into this process) or
+     * `<workspaceRoot>/.lensmcp/events.jsonl`. Injectable for tests.
+     */
+    eventFile?: string;
+    /** Set false to skip publishing to the lens bus (console output is unchanged). */
+    publishEvents?: boolean;
 }
 /** The workspace's tsgo binary, or null when not installed (caller falls back to fork-ts-checker). */
 export declare function resolveTsgoBin(workspaceRoot: string, override?: string): string | null;
@@ -56,6 +64,12 @@ export declare class TsgoCheckPlugin {
     apply(compiler: any): void;
     /** Debounced: rapid successive rebuilds collapse into one check; an in-flight check is superseded. */
     schedule(): void;
+    /**
+     * Publish one completed check onto the lens bus so `typecheck://*` reflects
+     * it. Strictly passive + fully swallowed: the console output above is the
+     * contract webpack/the gateway rely on, this is pure observation on top.
+     */
+    private publish;
     private run;
 }
 //# sourceMappingURL=tsgo-check-plugin.d.ts.map

package/tsgo-check-plugin.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tsgo-check-plugin.d.ts","sourceRoot":"","sources":["../../../libs/cluster/src/tsgo-check-plugin.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,OAAO,EAAE,KAAK,EAAqB,MAAM,oBAAoB,CAAC;AAI9D,MAAM,WAAW,sBAAsB;IACrC,OAAO,EAAE,MAAM,CAAC;IAChB,0DAA0D;IAC1D,QAAQ,EAAE,MAAM,CAAC;IACjB,aAAa,EAAE,MAAM,CAAC;IACtB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,2FAA2F;IAC3F,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,4BAA4B;IAC5B,SAAS,CAAC,EAAE,OAAO,KAAK,CAAC;CAC1B;AAED,sGAAsG;AACtG,wBAAgB,cAAc,CAAC,aAAa,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAGtF;AAED;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,GAAG,MAAM,CA0BlG;AAED,qBAAa,eAAe;IAC1B,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAyB;IAC9C,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAe;IACzC,OAAO,CAAC,KAAK,CAA8C;IAC3D,OAAO,CAAC,QAAQ,CAA6B;IAC7C,OAAO,CAAC,QAAQ,CAAuB;IACvC,OAAO,CAAC,QAAQ,CAAS;gBAEb,IAAI,EAAE,sBAAsB;IAMxC,KAAK,CAAC,QAAQ,EAAE,GAAG,GAAG,IAAI;IAO1B,sGAAsG;IACtG,QAAQ,IAAI,IAAI;IAOhB,OAAO,CAAC,GAAG;CA0CZ"}
+{"version":3,"file":"tsgo-check-plugin.d.ts","sourceRoot":"","sources":["../../../libs/cluster/src/tsgo-check-plugin.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,OAAO,EAAE,KAAK,EAAqB,MAAM,oBAAoB,CAAC;AAK9D,MAAM,WAAW,sBAAsB;IACrC,OAAO,EAAE,MAAM,CAAC;IAChB,0DAA0D;IAC1D,QAAQ,EAAE,MAAM,CAAC;IACjB,aAAa,EAAE,MAAM,CAAC;IACtB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,2FAA2F;IAC3F,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,4BAA4B;IAC5B,SAAS,CAAC,EAAE,OAAO,KAAK,CAAC;IACzB;;;;OAIG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,kFAAkF;IAClF,aAAa,CAAC,EAAE,OAAO,CAAC;CACzB;AAED,sGAAsG;AACtG,wBAAgB,cAAc,CAAC,aAAa,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAGtF;AAED;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,GAAG,MAAM,CA0BlG;AAED,qBAAa,eAAe;IAC1B,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAyB;IAC9C,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAe;IACzC,OAAO,CAAC,KAAK,CAA8C;IAC3D,OAAO,CAAC,QAAQ,CAA6B;IAC7C,OAAO,CAAC,QAAQ,CAAuB;IACvC,OAAO,CAAC,QAAQ,CAAS;gBAEb,IAAI,EAAE,sBAAsB;IAMxC,KAAK,CAAC,QAAQ,EAAE,GAAG,GAAG,IAAI;IAO1B,sGAAsG;IACtG,QAAQ,IAAI,IAAI;IAOhB;;;;OAIG;IACH,OAAO,CAAC,OAAO;IAkBf,OAAO,CAAC,GAAG;CA4DZ"}

package/tsgo-check-plugin.js

@@ -33,6 +33,7 @@ const tslib_1 = require("tslib");
 const node_child_process_1 = require("node:child_process");
 const fs = tslib_1.__importStar(require("node:fs"));
 const path = tslib_1.__importStar(require("node:path"));
+const typecheck_bus_1 = require("./typecheck-bus");
 /** The workspace's tsgo binary, or null when not installed (caller falls back to fork-ts-checker). */
 function resolveTsgoBin(workspaceRoot, override) {
     const candidate = override || path.join(workspaceRoot, 'node_modules', '.bin', 'tsgo');
@@ -90,12 +91,41 @@ class TsgoCheckPlugin {
         this.timer = setTimeout(() => this.run(), this.opts.debounceMs ?? 500);
         this.timer.unref?.();
     }
+    /**
+     * Publish one completed check onto the lens bus so `typecheck://*` reflects
+     * it. Strictly passive + fully swallowed: the console output above is the
+     * contract webpack/the gateway rely on, this is pure observation on top.
+     */
+    publish(args) {
+        if (this.opts.publishEvents === false)
+            return;
+        try {
+            (0, typecheck_bus_1.publishTypecheckRun)({
+                workspaceRoot: this.opts.workspaceRoot,
+                project: this.opts.appName,
+                tool: 'tsgo',
+                tsConfig: this.opts.tsConfig,
+                output: args.output,
+                durationMs: args.durationMs,
+                ...(args.toolError ? { toolError: args.toolError } : {}),
+                ...(this.opts.eventFile ? { eventFile: this.opts.eventFile } : {}),
+            });
+        }
+        catch {
+            /* never let instrumentation disturb a build */
+        }
+    }
     run() {
         const bin = resolveTsgoBin(this.opts.workspaceRoot, this.opts.binPath);
         if (!bin) {
             // The binary vanished after config time (e.g. a reinstall mid-serve) — warn once, go quiet.
             this.disabled = true;
             console.warn(`[tsgo] ${this.opts.appName}: tsgo binary not found — type checking disabled for this session`);
+            // A checker that stopped checking must SAY so: without this the resource
+            // would keep serving the last (possibly clean) verdict forever, which is
+            // exactly the "looks healthy, nobody is watching" state this work exists
+            // to make impossible.
+            this.publish({ output: '', durationMs: 0, toolError: `tsgo binary not found — type checking disabled` });
             return;
         }
         if (this.inflight) {
@@ -117,15 +147,20 @@ class TsgoCheckPlugin {
             if (this.inflight === child)
                 this.inflight = null;
             console.warn(`[tsgo] ${this.opts.appName}: failed to spawn ${bin}`);
+            // A spawn failure is NOT a clean check — report it as a tool error so the
+            // resource says "the checker died", never "your types are fine".
+            this.publish({ output: '', durationMs: Date.now() - startedAt, toolError: `failed to spawn ${bin}` });
         });
         child.on('close', (code, signal) => {
             if (this.inflight === child)
                 this.inflight = null;
             if (signal)
                 return; // superseded — a newer check owns the verdict
-            const secs = ((Date.now() - startedAt) / 1000).toFixed(1);
+            const durationMs = Date.now() - startedAt;
+            const secs = (durationMs / 1000).toFixed(1);
             if (code === 0) {
                 console.log(`[tsgo] ${this.opts.appName}: types clean (${secs}s)`);
+                this.publish({ output: '', durationMs });
                 return;
             }
             // Print the raw `file.ts(1,2): error TSxxxx:` lines — the gateway's `error TS\d+` sniff
@@ -134,7 +169,18 @@ class TsgoCheckPlugin {
                 process.stdout.write(out.endsWith('\n') ? out : `${out}\n`);
             const count = (out.match(/error TS\d+/g) ?? []).length;
             console.log(`[tsgo] ${this.opts.appName}: ${count} type error${count === 1 ? '' : 's'} (${secs}s)`);
+            // A non-zero exit with NO parseable diagnostic is the checker itself
+            // failing (bad shim tsconfig, OOM) — `publishTypecheckRun` would
+            // otherwise read "0 errors" and report CLEAN on a failed run.
+            this.publish({
+                output: out,
+                durationMs,
+                ...(count === 0 ? { toolError: `tsgo exited ${code} with no diagnostics: ${firstLine(out)}` } : {}),
+            });
         });
     }
 }
 exports.TsgoCheckPlugin = TsgoCheckPlugin;
+function firstLine(s) {
+    return s.trim().split('\n')[0]?.slice(0, 300) ?? '';
+}

package/typecheck-bus.d.ts

@@ -0,0 +1,82 @@
+/** One parsed compiler diagnostic. MIRROR of session's `TscDiagnostic`. */
+export interface TscDiagnostic {
+    file: string;
+    line: number;
+    column: number;
+    severity: 'error' | 'warning';
+    code: string;
+    message: string;
+}
+export declare function stripAnsi(s: string): string;
+/** MIRROR of session's `parseTscDiagnosticLine`. */
+export declare function parseTscDiagnosticLine(raw: string): TscDiagnostic | null;
+/** MIRROR of session's `parseTscOutput`. */
+export declare function parseTscOutput(output: string): TscDiagnostic[];
+/** MIRROR of session's cap — a broken tsconfig can cascade into thousands. */
+export declare const MAX_DIAGNOSTICS_PER_RUN = 200;
+/** Loose BaseEvent shape — cluster does not depend on `@lensmcp/protocol-types`. */
+export interface TypecheckBusEvent {
+    id: string;
+    sessionId: string;
+    timestamp: number;
+    source: 'typescript';
+    category: 'typecheck';
+    severity: 'info' | 'warning' | 'error';
+    context: {
+        sessionId: string;
+        projectName?: string;
+    };
+    fingerprint: string;
+    title: string;
+    message?: string;
+    location?: {
+        file: string;
+        line: number;
+        column: number;
+    };
+    raw?: Record<string, unknown>;
+}
+/**
+ * Build the ordered event list for one completed check.
+ * MIRROR of session's `buildTypecheckRunEvents` — see it for the protocol
+ * (START carries the legacy `tsc clear` prefix an older reducer resets on;
+ * END deliberately does not, or it would wipe what was just published).
+ */
+export declare function buildTypecheckRunEvents(args: {
+    project: string;
+    tool: string;
+    tsConfig?: string;
+    diagnostics: readonly TscDiagnostic[];
+    durationMs: number;
+    toolError?: string;
+    now?: () => number;
+    idImpl?: () => string;
+}): TypecheckBusEvent[];
+/**
+ * Where the bus lives for this process. Same resolution order the serve
+ * executor uses for the pod env, so the checker and the pods it type-checks
+ * always land on ONE file.
+ */
+export declare function resolveEventFile(workspaceRoot: string): string;
+/**
+ * Append events as NDJSON, honouring the shared rotation contract
+ * (`maybeRotateEventFile` is exported from node-instrumentation precisely so
+ * every OTHER writer to the bus enforces the same caps — the gateway once was
+ * the one writer without it, and the bus outgrew every consumer).
+ *
+ * Never throws: a lens that cannot write must not break a build.
+ */
+export declare function appendTypecheckEvents(eventFile: string, events: readonly TypecheckBusEvent[]): void;
+/** Parse a raw tsgo/tsc run and publish it. Returns the events written (for tests). */
+export declare function publishTypecheckRun(args: {
+    workspaceRoot: string;
+    project: string;
+    tool: string;
+    tsConfig?: string;
+    /** Raw combined stdout+stderr of the check. */
+    output: string;
+    durationMs: number;
+    toolError?: string;
+    eventFile?: string;
+}): TypecheckBusEvent[];
+//# sourceMappingURL=typecheck-bus.d.ts.map

package/typecheck-bus.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"typecheck-bus.d.ts","sourceRoot":"","sources":["../../../libs/cluster/src/typecheck-bus.ts"],"names":[],"mappings":"AAwDA,2EAA2E;AAC3E,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,OAAO,GAAG,SAAS,CAAC;IAC9B,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;CACjB;AASD,wBAAgB,SAAS,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAE3C;AAED,oDAAoD;AACpD,wBAAgB,sBAAsB,CAAC,GAAG,EAAE,MAAM,GAAG,aAAa,GAAG,IAAI,CAexE;AAED,4CAA4C;AAC5C,wBAAgB,cAAc,CAAC,MAAM,EAAE,MAAM,GAAG,aAAa,EAAE,CAO9D;AAED,8EAA8E;AAC9E,eAAO,MAAM,uBAAuB,MAAM,CAAC;AAE3C,oFAAoF;AACpF,MAAM,WAAW,iBAAiB;IAChC,EAAE,EAAE,MAAM,CAAC;IACX,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,YAAY,CAAC;IACrB,QAAQ,EAAE,WAAW,CAAC;IACtB,QAAQ,EAAE,MAAM,GAAG,SAAS,GAAG,OAAO,CAAC;IACvC,OAAO,EAAE;QAAE,SAAS,EAAE,MAAM,CAAC;QAAC,WAAW,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IACrD,WAAW,EAAE,MAAM,CAAC;IACpB,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,QAAQ,CAAC,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC;IAC1D,GAAG,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAC/B;AAQD;;;;;GAKG;AACH,wBAAgB,uBAAuB,CAAC,IAAI,EAAE;IAC5C,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,SAAS,aAAa,EAAE,CAAC;IACtC,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,GAAG,CAAC,EAAE,MAAM,MAAM,CAAC;IACnB,MAAM,CAAC,EAAE,MAAM,MAAM,CAAC;CACvB,GAAG,iBAAiB,EAAE,CA8EtB;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,aAAa,EAAE,MAAM,GAAG,MAAM,CAE9D;AAqBD;;;;;;;GAOG;AACH,wBAAgB,qBAAqB,CAAC,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,SAAS,iBAAiB,EAAE,GAAG,IAAI,CAsBnG;AAED,uFAAuF;AACvF,wBAAgB,mBAAmB,CAAC,IAAI,EAAE;IACxC,aAAa,EAAE,MAAM,CAAC;IACtB,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,+CAA+C;IAC/C,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB,GAAG,iBAAiB,EAAE,CAWtB"}

package/typecheck-bus.js

@@ -0,0 +1,256 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MAX_DIAGNOSTICS_PER_RUN = void 0;
+exports.stripAnsi = stripAnsi;
+exports.parseTscDiagnosticLine = parseTscDiagnosticLine;
+exports.parseTscOutput = parseTscOutput;
+exports.buildTypecheckRunEvents = buildTypecheckRunEvents;
+exports.resolveEventFile = resolveEventFile;
+exports.appendTypecheckEvents = appendTypecheckEvents;
+exports.publishTypecheckRun = publishTypecheckRun;
+const tslib_1 = require("tslib");
+/**
+ * The tsgo checker's bus writer — turns a completed type check into the
+ * `typescript`/`typecheck` events `installTypecheckReducer` materialises into
+ * `typecheck://*`.
+ *
+ * ── The failure this fixes ──────────────────────────────────────────────────
+ * `typecheck://current` answered `{"status":"unknown","errorCount":0,
+ * "revision":0}` on a workspace whose dev cluster was type-checking on every
+ * single rebuild. `revision: 0` means no event had EVER arrived: the reducer
+ * had no producer at all. The checks were running — `[tsgo] engine: types
+ * clean (2.6s)`, and on failure real diagnostics like
+ * `…/hazard-analyst.agent.ts(52,12): error TS2416: …` — but that output went
+ * to the executor's stdout and nowhere else.
+ *
+ * The gateway's console sniff (`runtime/lifecycle.ts`, `/error TS\d+/`) does
+ * see those lines, but it emits `source:'gateway' / category:'cluster'` with
+ * the whole line stuffed verbatim into `raw.line` — no file, no position, no
+ * code, no per-project status, throttled to one line per 5s, and filtered out
+ * by all three check reducers. It is a crash-banner, not a typecheck feed.
+ *
+ * So the checker publishes directly. `TsgoCheckPlugin` runs INSIDE the nx
+ * serve executor process, which the gateway already spawns with
+ * `LENSMCP_EVENT_FILE` and `LENSMCP_PROJECT` in its env
+ * (`executors/gateway/runtime/lifecycle.ts`) — the same JSONL rendezvous the
+ * MCP server tails at 50 ms. No new transport, no new wiring.
+ *
+ * ── Why this file MIRRORS `@lensmcp/session` ────────────────────────────────
+ * The canonical parser + event builder is
+ * `libs/session/src/lib/collectors/typecheck-events.ts`. `@lensmcp/cluster` is
+ * PUBLISHED and `@lensmcp/session` is private/bundled-into-the-CLI, so cluster
+ * cannot depend on it. This is the same deliberate mirror
+ * `libs/bridge/src/lib/env-sink.ts` makes of node-instrumentation's emit
+ * contract. Drift is pinned by `TSC_PARITY_FIXTURE`, asserted byte-for-byte in
+ * BOTH projects' specs — change one parser without the other and a test fails.
+ *
+ * Strictly passive: every write is best-effort inside try/catch, the host
+ * build is never blocked, delayed, or failed by it.
+ */
+const fs = tslib_1.__importStar(require("node:fs"));
+const path = tslib_1.__importStar(require("node:path"));
+const busHygiene = (() => {
+    try {
+        // eslint-disable-next-line @typescript-eslint/no-require-imports
+        return require('@lensmcp/node-instrumentation');
+    }
+    catch {
+        return undefined;
+    }
+})();
+/** MIRROR of session's regex — `path(line,col): error TS1234: message`. */
+const DIAG_LINE_REGEX = /^(.+?)\((\d+),(\d+)\):\s+(error|warning)\s+(TS\d+):\s+(.+)$/;
+// CSI/ANSI escape, built from String.fromCharCode so the literal control char
+// never appears in source (no-control-regex).
+const ANSI_CSI = new RegExp(`${String.fromCharCode(27)}\\[[0-9;]*[A-Za-z]`, 'g');
+function stripAnsi(s) {
+    return s.replace(ANSI_CSI, '');
+}
+/** MIRROR of session's `parseTscDiagnosticLine`. */
+function parseTscDiagnosticLine(raw) {
+    const line = stripAnsi(raw).trim();
+    if (!line)
+        return null;
+    const m = DIAG_LINE_REGEX.exec(line);
+    if (!m)
+        return null;
+    const [, file, lineStr, colStr, severity, code, message] = m;
+    if (!file || !lineStr || !colStr || !severity || !code || !message)
+        return null;
+    return {
+        file,
+        line: Number(lineStr),
+        column: Number(colStr),
+        severity: severity === 'warning' ? 'warning' : 'error',
+        code,
+        message,
+    };
+}
+/** MIRROR of session's `parseTscOutput`. */
+function parseTscOutput(output) {
+    const out = [];
+    for (const line of output.split('\n')) {
+        const d = parseTscDiagnosticLine(line);
+        if (d)
+            out.push(d);
+    }
+    return out;
+}
+/** MIRROR of session's cap — a broken tsconfig can cascade into thousands. */
+exports.MAX_DIAGNOSTICS_PER_RUN = 200;
+let idCounter = 0;
+function makeId() {
+    idCounter = (idCounter + 1) % 0xffff;
+    return `${Date.now().toString(36)}${idCounter.toString(36)}${Math.random().toString(36).slice(2, 8)}`;
+}
+/**
+ * Build the ordered event list for one completed check.
+ * MIRROR of session's `buildTypecheckRunEvents` — see it for the protocol
+ * (START carries the legacy `tsc clear` prefix an older reducer resets on;
+ * END deliberately does not, or it would wipe what was just published).
+ */
+function buildTypecheckRunEvents(args) {
+    const at = (args.now ?? Date.now)();
+    const id = args.idImpl ?? makeId;
+    const sessionId = 'pending'; // stamped by the ingesting session, as every file-bus producer does
+    const base = {
+        sessionId,
+        source: 'typescript',
+        category: 'typecheck',
+        context: { sessionId, projectName: args.project },
+    };
+    const rawBase = {
+        project: args.project,
+        tool: args.tool,
+        ...(args.tsConfig ? { tsConfig: args.tsConfig } : {}),
+    };
+    const errors = args.diagnostics.filter((d) => d.severity === 'error');
+    const forwarded = args.diagnostics.slice(0, exports.MAX_DIAGNOSTICS_PER_RUN);
+    const events = [];
+    // A run that produced NO verdict emits NO clear: wiping the previous state
+    // and replacing it with zero diagnostics would read as a clean check.
+    if (!args.toolError) {
+        events.push({
+            ...base,
+            id: id(),
+            timestamp: at,
+            severity: 'info',
+            title: `tsc clear: ${args.project}`,
+            message: `typecheck run starting for ${args.project}`,
+            fingerprint: `tsc:${args.project}:run-start`,
+            raw: { ...rawBase, kind: 'typecheck-run', phase: 'start' },
+        });
+        for (const d of forwarded) {
+            events.push({
+                ...base,
+                id: id(),
+                timestamp: at,
+                severity: d.severity,
+                title: `${d.code}: ${d.message}`,
+                message: d.message,
+                location: { file: d.file, line: d.line, column: d.column },
+                // MIRROR of session's `diagnosticFingerprint` — position included so N
+                // hits of one code in one file stay N, not 1.
+                fingerprint: `tsc:${args.project}:${d.file}:${d.line}:${d.column}:${d.code}`,
+                raw: { ...rawBase, kind: 'typecheck-diagnostic', code: d.code },
+            });
+        }
+    }
+    const status = args.toolError ? 'error' : errors.length > 0 ? 'failing' : 'clean';
+    events.push({
+        ...base,
+        id: id(),
+        timestamp: at,
+        severity: 'info',
+        title: `typecheck run: ${args.project} — ${args.toolError ? 'tool error' : `${errors.length} error${errors.length === 1 ? '' : 's'}`} (${args.durationMs}ms)`,
+        ...(args.toolError ? { message: args.toolError } : {}),
+        fingerprint: `tsc:${args.project}:run-end`,
+        raw: {
+            ...rawBase,
+            kind: 'typecheck-run',
+            phase: 'end',
+            status,
+            durationMs: args.durationMs,
+            errorCount: errors.length,
+            warningCount: args.diagnostics.length - errors.length,
+            ...(args.diagnostics.length > forwarded.length
+                ? { truncatedDiagnostics: args.diagnostics.length - forwarded.length }
+                : {}),
+            ...(args.toolError ? { error: args.toolError } : {}),
+        },
+    });
+    return events;
+}
+/**
+ * Where the bus lives for this process. Same resolution order the serve
+ * executor uses for the pod env, so the checker and the pods it type-checks
+ * always land on ONE file.
+ */
+function resolveEventFile(workspaceRoot) {
+    return process.env['LENSMCP_EVENT_FILE'] || path.join(workspaceRoot, '.lensmcp', 'events.jsonl');
+}
+/**
+ * Last directory we successfully created, so the common case costs no syscall.
+ *
+ * Deliberately NOT a boolean: a `dirReady` flag latches TRUE for the life of
+ * the process, so if `.lensmcp/` is later removed (a clean, a `rm -rf tmp`, a
+ * different bus path) every subsequent append fails ENOENT and the producer
+ * goes silent FOREVER — reporting nothing, which is the precise failure mode
+ * this whole file exists to make impossible. Keyed by path + re-ensured on
+ * ENOENT instead.
+ */
+let ensuredDir = null;
+function ensureDir(eventFile) {
+    const dir = path.dirname(eventFile);
+    if (ensuredDir === dir)
+        return;
+    fs.mkdirSync(dir, { recursive: true });
+    ensuredDir = dir;
+}
+/**
+ * Append events as NDJSON, honouring the shared rotation contract
+ * (`maybeRotateEventFile` is exported from node-instrumentation precisely so
+ * every OTHER writer to the bus enforces the same caps — the gateway once was
+ * the one writer without it, and the bus outgrew every consumer).
+ *
+ * Never throws: a lens that cannot write must not break a build.
+ */
+function appendTypecheckEvents(eventFile, events) {
+    if (events.length === 0)
+        return;
+    const payload = events.map((e) => JSON.stringify(e)).join('\n') + '\n';
+    try {
+        ensureDir(eventFile);
+        busHygiene?.maybeRotateEventFile(eventFile, payload.length);
+        fs.appendFileSync(eventFile, payload);
+    }
+    catch (err) {
+        // The directory vanished under us (clean / rotate race). Re-create it once
+        // and retry — self-healing beats going permanently quiet.
+        if (err?.code === 'ENOENT') {
+            try {
+                ensuredDir = null;
+                ensureDir(eventFile);
+                fs.appendFileSync(eventFile, payload);
+            }
+            catch {
+                /* lens offline — never break the host build */
+            }
+            return;
+        }
+        /* lens offline — never break the host build */
+    }
+}
+/** Parse a raw tsgo/tsc run and publish it. Returns the events written (for tests). */
+function publishTypecheckRun(args) {
+    const events = buildTypecheckRunEvents({
+        project: args.project,
+        tool: args.tool,
+        ...(args.tsConfig ? { tsConfig: args.tsConfig } : {}),
+        diagnostics: args.toolError ? [] : parseTscOutput(args.output),
+        durationMs: args.durationMs,
+        ...(args.toolError ? { toolError: args.toolError } : {}),
+    });
+    appendTypecheckEvents(args.eventFile ?? resolveEventFile(args.workspaceRoot), events);
+    return events;
+}