@lensmcp/cluster 1.17.1 → 1.17.3

package/create-webpack-dev.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"create-webpack-dev.d.ts","sourceRoot":"","sources":["../../../libs/cluster/src/create-webpack-dev.ts"],"names":[],"mappings":"AAIA,OAAO,EAAsB,KAAK,mBAAmB,EAAE,MAAM,wBAAwB,CAAC;AAQtF,YAAY,EAAE,mBAAmB,EAAE,CAAC;AAEpC,MAAM,WAAW,iBAAiB;IAChC,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,aAAa,EAAE,MAAM,CAAC;IACtB,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;IAClB,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,mBAAmB,CAAC,EAAE,OAAO,CAAC;IAC9B,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC;IACrB,cAAc,CAAC,EAAE,MAAM,EAAE,CAAC;IAC1B,mBAAmB,CAAC,EAAE,mBAAmB,CAAC;IAC1C,qBAAqB,CAAC,EAAE,KAAK,CAAC;QAAE,SAAS,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IACxE,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,kFAAkF;IAClF,WAAW,CAAC,EAAE,OAAO,CAAC;CACvB;AA2CD,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,iBAAiB,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAgKtF"}
+{"version":3,"file":"create-webpack-dev.d.ts","sourceRoot":"","sources":["../../../libs/cluster/src/create-webpack-dev.ts"],"names":[],"mappings":"AAIA,OAAO,EAAsB,KAAK,mBAAmB,EAAE,MAAM,wBAAwB,CAAC;AAatF,YAAY,EAAE,mBAAmB,EAAE,CAAC;AAEpC,MAAM,WAAW,iBAAiB;IAChC,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,aAAa,EAAE,MAAM,CAAC;IACtB,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;IAClB,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,mBAAmB,CAAC,EAAE,OAAO,CAAC;IAC9B,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC;IACrB,cAAc,CAAC,EAAE,MAAM,EAAE,CAAC;IAC1B,mBAAmB,CAAC,EAAE,mBAAmB,CAAC;IAC1C,qBAAqB,CAAC,EAAE,KAAK,CAAC;QAAE,SAAS,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IACxE,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,kFAAkF;IAClF,WAAW,CAAC,EAAE,OAAO,CAAC;CACvB;AA2CD,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,iBAAiB,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAyKtF"}

package/create-webpack-dev.js

@@ -49,12 +49,22 @@ function createDevWebpackConfig(options) {
     // Type-checking mode (LENSMCP_TYPECHECK): default = the resident fork-ts-checker pair (async,
     // feeds the lens `error TS` service-error signal); 'off' = none (fastest, quietest — the signal
     // is traded away); 'tsgo' = zero-resident cold re-checks via @typescript/native-preview (same
-    // signal, no idle memory — see tsgo-check-plugin.ts). tsgo falls back to fork-ts-checker when
-    // the binary isn't installed in the workspace, so the flag can ship ahead of the devDep.
+    // signal, no idle memory — see tsgo-check-plugin.ts).
+    //
+    // tsgo still falls back to fork-ts-checker when no binary resolves — degrading gracefully beats
+    // failing a dev server — but that fallback is now an ANOMALY, not the expected "the flag shipped
+    // ahead of the devDep" state: @lensmcp/cluster DEPENDS on the compiler. So it also reports itself
+    // onto the lens bus. fork-ts-checker publishes to the CONSOLE only, so without this the
+    // `typecheck://` resources would sit at `producer: 'none'` with nothing naming the reason —
+    // the precise "looks healthy because nobody is watching" state this producer exists to end.
     const typecheckMode = process.env.LENSMCP_TYPECHECK;
     const tsgoBin = typecheckMode === 'tsgo' ? (0, tsgo_check_plugin_1.resolveTsgoBin)(workspaceRoot, process.env.LENSMCP_TSGO_BIN) : null;
     if (typecheckMode === 'tsgo' && !tsgoBin) {
-        console.warn(`[serve] ${options.appName}: LENSMCP_TYPECHECK=tsgo but no tsgo binary (yarn add -D @typescript/native-preview) — falling back to fork-ts-checker`);
+        // No trailing period: `summariseProducers` renders this INSIDE a sentence it terminates itself.
+        const detail = `${tsgo_check_plugin_1.TSGO_MISSING_CAUSE}. Fell back to fork-ts-checker, which reports to the console only — ` +
+            `so typecheck:// has no producer for this project until it is fixed`;
+        console.warn(`[serve] ${options.appName}: LENSMCP_TYPECHECK=tsgo but ${detail}.`);
+        (0, tsgo_check_plugin_1.reportTsgoUnavailable)({ appName: options.appName, tsConfig, workspaceRoot, detail });
     }
     const useTsgo = !!tsgoBin;
     // Build combined allowlist: orgScopes + bundlePackages + user-provided

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.3",
   "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,9 @@
     }
   },
   "dependencies": {
-    "@lensmcp/node-instrumentation": "1.17.1",
-    "@lensmcp/nx-plugin": "1.17.1",
+    "@lensmcp/node-instrumentation": "1.17.3",
+    "@lensmcp/nx-plugin": "1.17.3",
+    "@typescript/native-preview": "^7.0.0-dev.20260707.2",
     "fork-ts-checker-webpack-plugin": "^9.0.0",
     "glob": "^11.0.0",
     "http-proxy": "^1.18.0",

package/tsgo-check-plugin.d.ts

@@ -21,8 +21,15 @@
  * `module: preserve` + `emitDecoratorMetadata` otherwise flags TS1272 on decorated signatures —
  * an emit-safety rule that doesn't apply here (this checker never emits; webpack owns emit).
  * Parity was verified per adopting workspace (0-error parity with tsc on all spot-checked apps);
- * tsgo is a PREVIEW compiler, which is why this mode is opt-in and falls back to fork-ts-checker
- * when the binary is absent.
+ * tsgo is a PREVIEW compiler, which is why this MODE is opt-in.
+ *
+ * OWNERSHIP: `@lensmcp/cluster` DEPENDS on `@typescript/native-preview` — this is our feature, so we
+ * ship the compiler that powers it rather than asking every consumer to remember a devDep. That was
+ * the old contract, and it made the feature (and, once this plugin became the `typecheck://`
+ * producer, the whole typecheck health signal) die quietly in any workspace that forgot. Resolution
+ * still PREFERS a workspace's own copy (a workspace pinning a tsgo version keeps winning), and a
+ * missing binary is now an ANOMALY: it degrades gracefully — never crashing the dev server — but it
+ * reports itself onto the lens bus instead of only warning into a log nobody reads.
  */
 import { spawn } from 'node:child_process';
 export interface TsgoCheckPluginOptions {
@@ -31,13 +38,83 @@ export interface TsgoCheckPluginOptions {
     tsConfig: string;
     workspaceRoot: string;
     debounceMs?: number;
-    /** Binary override (LENSMCP_TSGO_BIN); default: <workspaceRoot>/node_modules/.bin/tsgo. */
+    /** Binary override (LENSMCP_TSGO_BIN); otherwise resolved by {@link resolveTsgoBin}. */
     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 npm package that ships the tsgo compiler — a real `dependency` of `@lensmcp/cluster`. */
+export declare const TSGO_PACKAGE = "@typescript/native-preview";
+/** Seams for {@link resolveTsgoBin}, so every branch of the precedence is testable without an install. */
+export interface TsgoResolutionDeps {
+    /** Locate OUR `@typescript/native-preview`. Default: {@link resolveTsgoPackageDir}. */
+    ownPackageDir?: () => string | null;
+    /** Probe a candidate. Default: exists && is a file && is executable. */
+    isExecutable?: (candidate: string) => boolean;
+    /** Default: `process.platform`. */
+    platform?: NodeJS.Platform;
 }
-/** 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;
+/**
+ * Where OUR copy of {@link TSGO_PACKAGE} lives, or null when it isn't installed.
+ *
+ * `require.resolve` walks up from THIS module, so it finds the copy installed for
+ * `@lensmcp/cluster` whether the consumer's installer HOISTED it
+ * (`<root>/node_modules/@typescript/native-preview`) or NESTED it
+ * (`<root>/node_modules/@lensmcp/cluster/node_modules/@typescript/native-preview`, the shape you
+ * get on a version conflict) or used pnpm's virtual store. A hand-written `../../node_modules/…`
+ * relative guess gets exactly one of those right.
+ */
+export declare function resolveTsgoPackageDir(): string | null;
+/**
+ * The tsgo binary to run, or null when none is usable.
+ *
+ * Precedence — first usable wins:
+ *  1. `override` (LENSMCP_TSGO_BIN). Deliberately NOT a fallthrough: an override pointing at a
+ *     missing/non-executable file is an operator mistake to SURFACE, not to paper over by silently
+ *     running a different compiler than the one that was asked for.
+ *  2. The consuming workspace's `node_modules/.bin/tsgo` — a workspace that pins its own tsgo
+ *     version still beats the one we ship.
+ *  3. OURS, via {@link resolveTsgoPackageDir}. `@lensmcp/cluster` depends on {@link TSGO_PACKAGE},
+ *     so this is the branch that normally answers, and the reason the feature no longer depends on
+ *     every consumer independently remembering a devDep.
+ */
+export declare function resolveTsgoBin(workspaceRoot: string, override?: string, deps?: TsgoResolutionDeps): string | null;
+/**
+ * Why tsgo could not run, and what to do — the CAUSE half, shared by both sites that can hit it.
+ *
+ * Phrased for the new ownership: `@lensmcp/cluster` DEPENDS on the compiler, so "not installed" is
+ * no longer an expected opt-out state, it is a broken install (or an unsupported platform, or a bad
+ * override). Callers append the CONSEQUENCE, which differs by site.
+ */
+export declare const TSGO_MISSING_CAUSE: string;
+/**
+ * Report — onto the LENS BUS, not just the console — that tsgo cannot run.
+ *
+ * A `console.warn` is invisible to anything reading `typecheck://current`, which is precisely the
+ * failure this whole area exists to eliminate: a resource that looks healthy because nobody is
+ * watching. Published as a `toolError` run, so the reducer records the producer as reporting with
+ * `lastRunStatus: 'error'` — `status` degrades to `unknown` (never a false `clean`) and `detail`
+ * names the cause and the fix.
+ *
+ * Strictly passive: fully swallowed, never blocks or fails the host build.
+ */
+export declare function reportTsgoUnavailable(args: {
+    appName: string;
+    tsConfig: string;
+    workspaceRoot: string;
+    /** Full sentence: {@link TSGO_MISSING_CAUSE} plus this site's consequence. */
+    detail: string;
+    /** Override the lens bus file. Injectable for tests. */
+    eventFile?: string;
+}): void;
 /**
  * Write the shim tsconfig (absolute `extends`; see the header) and return its path. It lives under
  * the WORKSPACE's git-ignored `tmp/` — NOT os.tmpdir(): `types: ['node']` (and every other @types
@@ -56,6 +133,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;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,wFAAwF;IACxF,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,gGAAgG;AAChG,eAAO,MAAM,YAAY,+BAA+B,CAAC;AAEzD,0GAA0G;AAC1G,MAAM,WAAW,kBAAkB;IACjC,uFAAuF;IACvF,aAAa,CAAC,EAAE,MAAM,MAAM,GAAG,IAAI,CAAC;IACpC,wEAAwE;IACxE,YAAY,CAAC,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,OAAO,CAAC;IAC9C,mCAAmC;IACnC,QAAQ,CAAC,EAAE,MAAM,CAAC,QAAQ,CAAC;CAC5B;AAmCD;;;;;;;;;GASG;AACH,wBAAgB,qBAAqB,IAAI,MAAM,GAAG,IAAI,CA6BrD;AA6BD;;;;;;;;;;;;GAYG;AACH,wBAAgB,cAAc,CAC5B,aAAa,EAAE,MAAM,EACrB,QAAQ,CAAC,EAAE,MAAM,EACjB,IAAI,GAAE,kBAAuB,GAC5B,MAAM,GAAG,IAAI,CAcf;AAED;;;;;;GAMG;AACH,eAAO,MAAM,kBAAkB,QAG2C,CAAC;AAE3E;;;;;;;;;;GAUG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE;IAC1C,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;IACjB,aAAa,EAAE,MAAM,CAAC;IACtB,8EAA8E;IAC9E,MAAM,EAAE,MAAM,CAAC;IACf,wDAAwD;IACxD,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB,GAAG,IAAI,CAeP;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;CA8DZ"}

package/tsgo-check-plugin.js

@@ -1,7 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TsgoCheckPlugin = void 0;
+exports.TsgoCheckPlugin = exports.TSGO_MISSING_CAUSE = exports.TSGO_PACKAGE = void 0;
+exports.resolveTsgoPackageDir = resolveTsgoPackageDir;
 exports.resolveTsgoBin = resolveTsgoBin;
+exports.reportTsgoUnavailable = reportTsgoUnavailable;
 exports.writeShimTsconfig = writeShimTsconfig;
 const tslib_1 = require("tslib");
 /**
@@ -27,16 +29,191 @@ const tslib_1 = require("tslib");
  * `module: preserve` + `emitDecoratorMetadata` otherwise flags TS1272 on decorated signatures —
  * an emit-safety rule that doesn't apply here (this checker never emits; webpack owns emit).
  * Parity was verified per adopting workspace (0-error parity with tsc on all spot-checked apps);
- * tsgo is a PREVIEW compiler, which is why this mode is opt-in and falls back to fork-ts-checker
- * when the binary is absent.
+ * tsgo is a PREVIEW compiler, which is why this MODE is opt-in.
+ *
+ * OWNERSHIP: `@lensmcp/cluster` DEPENDS on `@typescript/native-preview` — this is our feature, so we
+ * ship the compiler that powers it rather than asking every consumer to remember a devDep. That was
+ * the old contract, and it made the feature (and, once this plugin became the `typecheck://`
+ * producer, the whole typecheck health signal) die quietly in any workspace that forgot. Resolution
+ * still PREFERS a workspace's own copy (a workspace pinning a tsgo version keeps winning), and a
+ * missing binary is now an ANOMALY: it degrades gracefully — never crashing the dev server — but it
+ * reports itself onto the lens bus instead of only warning into a log nobody reads.
  */
 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"));
-/** 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');
-    return fs.existsSync(candidate) ? candidate : null;
+const typecheck_bus_1 = require("./typecheck-bus");
+/** The npm package that ships the tsgo compiler — a real `dependency` of `@lensmcp/cluster`. */
+exports.TSGO_PACKAGE = '@typescript/native-preview';
+/**
+ * The spawnable shim names inside a `node_modules/.bin`.
+ *
+ * On win32 the only shims `child_process.spawn` can execute directly are `tsgo.cmd` / `tsgo.exe`;
+ * the EXTENSIONLESS `tsgo` npm writes beside them is a POSIX shell script for git-bash, and
+ * spawning it without a shell fails. So win32 never considers the bare name.
+ */
+function shimNames(platform) {
+    return platform === 'win32' ? ['tsgo.cmd', 'tsgo.exe'] : ['tsgo'];
+}
+/**
+ * Existence is not enough — a directory, a dangling symlink, or a non-`+x` file all "exist" and
+ * then fail at spawn time as an opaque EACCES/ENOENT mid-serve. Probe once, here.
+ * `statSync` follows symlinks on purpose (`.bin/tsgo` IS one).
+ */
+function isExecutableFile(candidate, platform) {
+    try {
+        if (!fs.statSync(candidate).isFile())
+            return false;
+    }
+    catch {
+        return false; // missing, or a dangling symlink
+    }
+    // X_OK is meaningless on win32 (it reports every readable file executable), so the extension
+    // check in `shimNames` is the real gate there.
+    if (platform === 'win32')
+        return true;
+    try {
+        fs.accessSync(candidate, fs.constants.X_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Where OUR copy of {@link TSGO_PACKAGE} lives, or null when it isn't installed.
+ *
+ * `require.resolve` walks up from THIS module, so it finds the copy installed for
+ * `@lensmcp/cluster` whether the consumer's installer HOISTED it
+ * (`<root>/node_modules/@typescript/native-preview`) or NESTED it
+ * (`<root>/node_modules/@lensmcp/cluster/node_modules/@typescript/native-preview`, the shape you
+ * get on a version conflict) or used pnpm's virtual store. A hand-written `../../node_modules/…`
+ * relative guess gets exactly one of those right.
+ */
+function resolveTsgoPackageDir() {
+    try {
+        // The package maps `"./package.json"` in its `exports`, which is the cheap, exact answer.
+        return path.dirname(require.resolve(`${exports.TSGO_PACKAGE}/package.json`));
+    }
+    catch {
+        /* an `exports` map without ./package.json — fall through to the entry-point walk */
+    }
+    try {
+        let dir = path.dirname(require.resolve(exports.TSGO_PACKAGE));
+        // The entry may sit a few levels below the package root (`<pkg>/lib/version.cjs`), so walk up
+        // to the manifest that actually NAMES the package rather than assuming a depth.
+        for (let i = 0; i < 6; i++) {
+            const manifest = path.join(dir, 'package.json');
+            if (fs.existsSync(manifest)) {
+                try {
+                    const { name } = JSON.parse(fs.readFileSync(manifest, 'utf8'));
+                    if (name === exports.TSGO_PACKAGE)
+                        return dir;
+                }
+                catch {
+                    /* unreadable manifest — keep walking */
+                }
+            }
+            const parent = path.dirname(dir);
+            if (parent === dir)
+                break;
+            dir = parent;
+        }
+    }
+    catch {
+        /* not installed */
+    }
+    return null;
+}
+/** `bin.tsgo` (or a string `bin`) from a package dir, as an absolute path. */
+function packageDeclaredBin(pkgDir) {
+    try {
+        const { bin } = JSON.parse(fs.readFileSync(path.join(pkgDir, 'package.json'), 'utf8'));
+        const rel = typeof bin === 'string' ? bin : bin?.['tsgo'];
+        return rel ? path.join(pkgDir, rel) : null;
+    }
+    catch {
+        return null;
+    }
+}
+/** Candidate binaries for an installed {@link TSGO_PACKAGE}, best first. */
+function ownBinCandidates(pkgDir, platform) {
+    // `<…>/node_modules/@typescript/native-preview` ⇒ `<…>/node_modules/.bin` — two levels up holds
+    // for a hoisted install, a nested one, and pnpm's store alike (a scoped package is always
+    // `<node_modules>/<scope>/<name>`).
+    const binDir = path.resolve(pkgDir, '..', '..', '.bin');
+    const shims = shimNames(platform).map((n) => path.join(binDir, n));
+    // The package's OWN `bin/tsgo` is present whenever the package is, regardless of whether the
+    // installer wrote shims — but it is a `#!/usr/bin/env node` script, so it is directly spawnable
+    // on POSIX only. On win32 the `.cmd`/`.exe` shims are the only usable entry.
+    const declared = platform === 'win32' ? null : packageDeclaredBin(pkgDir);
+    return declared ? [declared, ...shims] : shims;
+}
+/**
+ * The tsgo binary to run, or null when none is usable.
+ *
+ * Precedence — first usable wins:
+ *  1. `override` (LENSMCP_TSGO_BIN). Deliberately NOT a fallthrough: an override pointing at a
+ *     missing/non-executable file is an operator mistake to SURFACE, not to paper over by silently
+ *     running a different compiler than the one that was asked for.
+ *  2. The consuming workspace's `node_modules/.bin/tsgo` — a workspace that pins its own tsgo
+ *     version still beats the one we ship.
+ *  3. OURS, via {@link resolveTsgoPackageDir}. `@lensmcp/cluster` depends on {@link TSGO_PACKAGE},
+ *     so this is the branch that normally answers, and the reason the feature no longer depends on
+ *     every consumer independently remembering a devDep.
+ */
+function resolveTsgoBin(workspaceRoot, override, deps = {}) {
+    const platform = deps.platform ?? process.platform;
+    const isExecutable = deps.isExecutable ?? ((c) => isExecutableFile(c, platform));
+    if (override)
+        return isExecutable(override) ? override : null;
+    for (const name of shimNames(platform)) {
+        const candidate = path.join(workspaceRoot, 'node_modules', '.bin', name);
+        if (isExecutable(candidate))
+            return candidate;
+    }
+    const pkgDir = (deps.ownPackageDir ?? resolveTsgoPackageDir)();
+    if (!pkgDir)
+        return null;
+    return ownBinCandidates(pkgDir, platform).find(isExecutable) ?? null;
+}
+/**
+ * Why tsgo could not run, and what to do — the CAUSE half, shared by both sites that can hit it.
+ *
+ * Phrased for the new ownership: `@lensmcp/cluster` DEPENDS on the compiler, so "not installed" is
+ * no longer an expected opt-out state, it is a broken install (or an unsupported platform, or a bad
+ * override). Callers append the CONSEQUENCE, which differs by site.
+ */
+exports.TSGO_MISSING_CAUSE = `tsgo binary not found — @lensmcp/cluster depends on ${exports.TSGO_PACKAGE}, so an absent binary means an ` +
+    `incomplete install (reinstall node_modules), a platform with no ${exports.TSGO_PACKAGE} build, or a ` +
+    `LENSMCP_TSGO_BIN override pointing at a missing or non-executable file`;
+/**
+ * Report — onto the LENS BUS, not just the console — that tsgo cannot run.
+ *
+ * A `console.warn` is invisible to anything reading `typecheck://current`, which is precisely the
+ * failure this whole area exists to eliminate: a resource that looks healthy because nobody is
+ * watching. Published as a `toolError` run, so the reducer records the producer as reporting with
+ * `lastRunStatus: 'error'` — `status` degrades to `unknown` (never a false `clean`) and `detail`
+ * names the cause and the fix.
+ *
+ * Strictly passive: fully swallowed, never blocks or fails the host build.
+ */
+function reportTsgoUnavailable(args) {
+    try {
+        (0, typecheck_bus_1.publishTypecheckRun)({
+            workspaceRoot: args.workspaceRoot,
+            project: args.appName,
+            tool: 'tsgo',
+            tsConfig: args.tsConfig,
+            output: '',
+            durationMs: 0,
+            toolError: args.detail,
+            ...(args.eventFile ? { eventFile: args.eventFile } : {}),
+        });
+    }
+    catch {
+        /* never let instrumentation disturb a build */
+    }
 }
 /**
  * Write the shim tsconfig (absolute `extends`; see the header) and return its path. It lives under
@@ -90,12 +267,43 @@ 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`);
+            // No trailing period: `summariseProducers` renders this INSIDE a sentence it terminates itself.
+            const detail = `${exports.TSGO_MISSING_CAUSE}. Type checking is disabled for the rest of this session`;
+            console.warn(`[tsgo] ${this.opts.appName}: ${detail}.`);
+            // 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: detail });
             return;
         }
         if (this.inflight) {
@@ -117,15 +325,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 +347,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;
+}