@lensmcp/cluster 1.23.13 → 1.24.0

package/swap-recycle.d.ts

@@ -38,6 +38,9 @@ export interface SwapRecyclePolicy {
     /** How long the pod must have been quiet — no swap running, no previous app closing — before its heap
      *  is compared with what it booted with. `0` = compare at once, whatever is going on. */
     settleMs: number;
+    /** Replace the pod once a CLOSED generation has stayed in memory this long, through at least two full GCs
+     *  (pod-memory.ts proves it). `0` = off. */
+    retainedMs: number;
 }
 export interface SwapRecycleState {
     /** Live heap right after the first app was built, in bytes. Unknown until measured. */
@@ -51,6 +54,18 @@ export interface SwapRecycleState {
     stuckCloses?: number;
     /** `false` while a swap is running or a previous app is still closing, and for `settleMs` after. */
     settled?: boolean;
+    /** The oldest generation that was closed and is PROVEN still in memory (alive after ≥2 full GCs since its
+     *  close) — what `pod-memory.ts`'s tracker knows. Absent when every closed generation was collected. */
+    retained?: RetainedGenerationState;
+}
+/** A closed generation the pod has proven is still in memory. */
+export interface RetainedGenerationState {
+    /** The app generation in this pod (1 = the one it booted with). */
+    generation: number;
+    /** Since its app was closed. */
+    ageMs: number;
+    /** Full GCs it has survived since then. */
+    gcs: number;
 }
 /**
  * - `LENSMCP_SWAP_RECYCLE` — `0`/`false`/`off`/`no` disables the guard.
@@ -68,6 +83,12 @@ export interface SwapRecycleState {
  *   the engine at 3.2× its boot heap, knowledge at 4.1× and audit at 3.5× — three pods replaced in the same
  *   half minute, each replacement one more cold boot on top of the burst that caused it. The share-of-limit
  *   rule is NOT held back: running into V8's limit is a crash whenever it happens.
+ * - `LENSMCP_SWAP_RECYCLE_RETAINED_MS` — default `600000` (10 min). A generation whose app was closed and that
+ *   is still in memory this long after, through at least two full GCs, is not garbage waiting for a collector:
+ *   something points into it, and nothing in the process is going to let go (issues/closed/pod-memory-02). Ten minutes is
+ *   past every timer a closed app was measured to leave behind (BullMQ's blocking-client and lock-renewal
+ *   timeouts, app intervals: 15 s – ~2.5 min on foodguard) with a wide margin, and it fires whatever the heap
+ *   says — a leak that costs 32 MB a swap (registry, 2026-10-09) takes forty swaps to reach 3×.
  */
 export declare function swapRecyclePolicy(env?: NodeJS.ProcessEnv): SwapRecyclePolicy;
 /**

package/swap-recycle.js

@@ -1 +1 @@
-"use strict";var r=Object.defineProperty;var i=(e,s)=>r(e,"name",{value:s,configurable:!0});var o=Object.defineProperty,t=i((e,s)=>o(e,"name",{value:s,configurable:!0}),"t");Object.defineProperty(exports,"__esModule",{value:!0}),exports.swapRecyclePolicy=swapRecyclePolicy,exports.recycleReason=recycleReason;const MB=1024*1024,numberFrom=t((e,s,a)=>{if(e===void 0||e.trim()==="")return s;const n=Number(e);return Number.isFinite(n)&&n>=a?n:s},"numberFrom");function swapRecyclePolicy(e=process.env){return{enabled:!["0","false","no","off"].includes((e.LENSMCP_SWAP_RECYCLE??"").trim().toLowerCase()),heapFactor:numberFrom(e.LENSMCP_SWAP_RECYCLE_HEAP_FACTOR,3,0),minHeapBytes:numberFrom(e.LENSMCP_SWAP_RECYCLE_MIN_MB,512,0)*MB,heapRatio:Math.min(1,numberFrom(e.LENSMCP_SWAP_RECYCLE_HEAP_RATIO,.7,0)),maxSwaps:Math.floor(numberFrom(e.LENSMCP_SWAP_RECYCLE_AFTER,0,0)),stuckCloseMs:Math.floor(numberFrom(e.LENSMCP_SWAP_RECYCLE_STUCK_CLOSE_MS,6e4,0)),settleMs:Math.floor(numberFrom(e.LENSMCP_SWAP_RECYCLE_SETTLE_MS,5e3,0))}}i(swapRecyclePolicy,"swapRecyclePolicy"),t(swapRecyclePolicy,"swapRecyclePolicy");const mb=t(e=>(e/MB).toFixed(0),"mb");function recycleReason(e,s){if(!(!e.enabled||s.swaps<1)){if(e.maxSwaps>0&&s.swaps>=e.maxSwaps)return`${s.swaps} hot swaps in this process (LENSMCP_SWAP_RECYCLE_AFTER=${e.maxSwaps})`;if(e.stuckCloseMs>0&&(s.stuckCloses??0)>0){const a=s.stuckCloses;return`${a} previous app${a===1?" has":"s have"} not finished closing after ${Math.round(e.stuckCloseMs/1e3)}s \u2014 a shutdown hook that never returns keeps the whole app, its connections included, in memory`}if(e.heapRatio>0&&s.limitBytes>0&&s.usedBytes>=e.heapRatio*s.limitBytes){const a=Math.round(s.usedBytes/s.limitBytes*100);return`its heap is ${mb(s.usedBytes)} MB after a full GC, ${a}% of V8's ${mb(s.limitBytes)} MB limit`}if(e.heapFactor>0&&s.settled!==!1&&s.baselineBytes!==void 0&&s.baselineBytes>0&&s.usedBytes>=e.minHeapBytes&&s.usedBytes>=e.heapFactor*s.baselineBytes){const a=(s.usedBytes/s.baselineBytes).toFixed(1);return`its heap is ${mb(s.usedBytes)} MB after a full GC, ${a}\xD7 the ${mb(s.baselineBytes)} MB it booted with \u2014 earlier generations of the bundle are still in memory`}}}i(recycleReason,"recycleReason"),t(recycleReason,"recycleReason");
+"use strict";var o=Object.defineProperty;var n=(s,e)=>o(s,"name",{value:e,configurable:!0});var t=Object.defineProperty,r=n((s,e)=>t(s,"name",{value:e,configurable:!0}),"r");Object.defineProperty(exports,"__esModule",{value:!0}),exports.swapRecyclePolicy=swapRecyclePolicy,exports.recycleReason=recycleReason;const MB=1024*1024,numberFrom=r((s,e,a)=>{if(s===void 0||s.trim()==="")return e;const i=Number(s);return Number.isFinite(i)&&i>=a?i:e},"numberFrom");function swapRecyclePolicy(s=process.env){return{enabled:!["0","false","no","off"].includes((s.LENSMCP_SWAP_RECYCLE??"").trim().toLowerCase()),heapFactor:numberFrom(s.LENSMCP_SWAP_RECYCLE_HEAP_FACTOR,3,0),minHeapBytes:numberFrom(s.LENSMCP_SWAP_RECYCLE_MIN_MB,512,0)*MB,heapRatio:Math.min(1,numberFrom(s.LENSMCP_SWAP_RECYCLE_HEAP_RATIO,.7,0)),maxSwaps:Math.floor(numberFrom(s.LENSMCP_SWAP_RECYCLE_AFTER,0,0)),stuckCloseMs:Math.floor(numberFrom(s.LENSMCP_SWAP_RECYCLE_STUCK_CLOSE_MS,6e4,0)),settleMs:Math.floor(numberFrom(s.LENSMCP_SWAP_RECYCLE_SETTLE_MS,5e3,0)),retainedMs:Math.floor(numberFrom(s.LENSMCP_SWAP_RECYCLE_RETAINED_MS,10*6e4,0))}}n(swapRecyclePolicy,"swapRecyclePolicy"),r(swapRecyclePolicy,"swapRecyclePolicy");const mb=r(s=>(s/MB).toFixed(0),"mb");function recycleReason(s,e){if(!(!s.enabled||e.swaps<1)){if(s.maxSwaps>0&&e.swaps>=s.maxSwaps)return`${e.swaps} hot swaps in this process (LENSMCP_SWAP_RECYCLE_AFTER=${s.maxSwaps})`;if(s.stuckCloseMs>0&&(e.stuckCloses??0)>0){const a=e.stuckCloses;return`${a} previous app${a===1?" has":"s have"} not finished closing after ${Math.round(s.stuckCloseMs/1e3)}s \u2014 a shutdown hook that never returns keeps the whole app, its connections included, in memory`}if(s.retainedMs>0&&e.retained&&e.retained.gcs>=2&&e.retained.ageMs>=s.retainedMs){const a=e.retained,i=a.ageMs<9e4?`${Math.round(a.ageMs/1e3)}s`:`${Math.round(a.ageMs/6e4)} min`;return`generation ${a.generation} is still in memory ${i} after its app was closed, through ${a.gcs} full GCs \u2014 something still points into it, and only a fresh process gives it back`}if(s.heapRatio>0&&e.limitBytes>0&&e.usedBytes>=s.heapRatio*e.limitBytes){const a=Math.round(e.usedBytes/e.limitBytes*100);return`its heap is ${mb(e.usedBytes)} MB after a full GC, ${a}% of V8's ${mb(e.limitBytes)} MB limit`}if(s.heapFactor>0&&e.settled!==!1&&e.baselineBytes!==void 0&&e.baselineBytes>0&&e.usedBytes>=s.minHeapBytes&&e.usedBytes>=s.heapFactor*e.baselineBytes){const a=(e.usedBytes/e.baselineBytes).toFixed(1);return`its heap is ${mb(e.usedBytes)} MB after a full GC, ${a}\xD7 the ${mb(e.baselineBytes)} MB it booted with \u2014 earlier generations of the bundle are still in memory`}}}n(recycleReason,"recycleReason"),r(recycleReason,"recycleReason");

package/tsgo-check-plugin.d.ts

@@ -7,7 +7,7 @@
  * services cold in ~1-3s, so instead of holding a program we re-check COLD after each successful
  * rebuild (debounced): idle cost is exactly zero.
  *
- * ONE AT A TIME (issues/foodguard/34). "Zero resident" is not "small": a cold check of a real service
+ * ONE AT A TIME (issues/closed/foodguard-34). "Zero resident" is not "small": a cold check of a real service
  * peaks at 1.4-3.4GB. Every service's plugin used to start its own the moment its build finished, so
  * one edit to a shared file started one per service at the same instant; and a newer build was meant
  * to REPLACE the running check with SIGTERM, which this checker ignores — it runs to the end and

package/workspace-paths.d.ts

@@ -0,0 +1,76 @@
+/** A `paths` key with one `*`, parsed as TypeScript parses it. */
+export interface PathPattern {
+    /** The key as written. */
+    key: string;
+    /** The text before the `*`. */
+    prefix: string;
+    /** The text after it. */
+    suffix: string;
+    /** Its substitutions, as written. */
+    targets: string[];
+}
+/** A tsconfig's `paths`, as TypeScript reads them. */
+export interface WorkspacePaths {
+    /** The tsconfig read, then every file it extends: a change to any of them can change the mapping. */
+    configFiles: string[];
+    /** What the substitutions resolve against: the effective `baseUrl`, else the directory of the tsconfig that defines `paths`. */
+    baseDir: string;
+    /** The effective `baseUrl`, when the tsconfig sets one: a bare specifier is also tried under it. */
+    baseUrl?: string;
+    /** The keys without a `*`. */
+    exact: Map<string, string[]>;
+    /** The keys with one `*`, in the order written. A key with more than one is ignored, as TypeScript ignores it. */
+    patterns: PathPattern[];
+}
+/** A file a bare specifier may resolve to, and what mapped it there. */
+export interface PathCandidate {
+    file: string;
+    /** The `paths` key, or `baseUrl`. */
+    via: string;
+}
+/**
+ * `tsConfig`'s `paths` as TypeScript reads them (`extends` followed, comments allowed) — `null` when the file does
+ * not exist or cannot be parsed. `exact` and `patterns` are both empty when it maps nothing.
+ */
+export declare function readWorkspacePaths(tsConfig: string, workspaceRoot: string): WorkspacePaths | null;
+/** Whether `paths` maps anything. */
+export declare function hasPathMappings(paths: WorkspacePaths | null): paths is WorkspacePaths;
+/**
+ * The files a bare specifier resolves to under `paths`, in the order TypeScript tries them (module resolution's
+ * `tryLoadModuleUsingPaths`, then `tryLoadModuleUsingBaseUrl`): the targets of the key that matches it best — an
+ * exact key, else the wildcard with the longest prefix — then the specifier under `baseUrl`. Empty when nothing
+ * applies.
+ */
+export declare function workspacePathCandidates(paths: WorkspacePaths, specifier: string): PathCandidate[];
+/** The part of enhanced-resolve's request this reads and passes on. */
+interface ResolveRequest {
+    request?: string;
+    [key: string]: unknown;
+}
+type ResolveCallback = (err?: Error | null, result?: unknown) => void;
+type ResolveStep = (request: ResolveRequest, resolveContext: unknown, callback: ResolveCallback) => void;
+/** The part of an enhanced-resolve hook this taps. */
+interface ResolveHook {
+    tapAsync(name: string, step: ResolveStep): void;
+}
+/** The part of enhanced-resolve's `Resolver` this uses. */
+interface PathsResolver {
+    ensureHook(name: string): unknown;
+    getHook(name: string): ResolveHook;
+    doResolve(hook: unknown, request: ResolveRequest, message: string, resolveContext: unknown, callback: ResolveCallback): void;
+}
+/**
+ * A resolver plugin (`resolve.plugins`) resolving a bare specifier through {@link WorkspacePaths}.
+ *
+ * It taps `normal-resolve`: after `resolve.alias` (on `raw-resolve`), so an alias a `webpackConfigPath` override
+ * sets still wins, and before the lookup in node_modules, so a mapped specifier beats an installed package of the
+ * same name, as in `tsc`. Each candidate re-enters resolution the way an alias does — extensions, `index` files and
+ * the watcher's missing-file tracking all apply — and the first that resolves is the answer; when none does, the
+ * request goes on to node_modules.
+ */
+export declare class WorkspacePathsResolverPlugin {
+    readonly paths: WorkspacePaths;
+    constructor(paths: WorkspacePaths);
+    apply(resolver: PathsResolver): void;
+}
+export {};

package/workspace-paths.js

@@ -0,0 +1 @@
+"use strict";var x=Object.defineProperty;var f=(s,e)=>x(s,"name",{value:e,configurable:!0});var h=Object.defineProperty,u=f((s,e)=>h(s,"name",{value:e,configurable:!0}),"u");Object.defineProperty(exports,"__esModule",{value:!0}),exports.WorkspacePathsResolverPlugin=void 0,exports.readWorkspacePaths=readWorkspacePaths,exports.hasPathMappings=hasPathMappings,exports.workspacePathCandidates=workspacePathCandidates;const tslib_1=require("tslib"),fs=tslib_1.__importStar(require("node:fs")),node_module_1=require("node:module"),path=tslib_1.__importStar(require("node:path"));function loadTypeScript(s){try{return(0,node_module_1.createRequire)(path.join(s,"package.json"))("typescript")}catch{return require("typescript")}}f(loadTypeScript,"loadTypeScript"),u(loadTypeScript,"loadTypeScript");function readWorkspacePaths(s,e){const i=path.resolve(e,s);if(!fs.existsSync(i))return null;try{const n=loadTypeScript(e),r=n.readJsonConfigFile(i,o=>n.sys.readFile(o)),a={...n.sys,readDirectory:u(()=>[],"readDirectory")},{options:t}=n.parseJsonSourceFileConfigFileContent(r,a,path.dirname(i),void 0,i),l=new Map,d=[];for(const[o,c]of Object.entries(t.paths??{})){if(!Array.isArray(c))continue;const p=o.indexOf("*");p===-1?l.set(o,c):o.indexOf("*",p+1)===-1&&d.push({key:o,prefix:o.slice(0,p),suffix:o.slice(p+1),targets:c})}return{configFiles:[i,...(r.extendedSourceFiles??[]).map(o=>path.resolve(o))],baseDir:t.baseUrl??t.pathsBasePath??path.dirname(i),...t.baseUrl?{baseUrl:t.baseUrl}:{},exact:l,patterns:d}}catch{return null}}f(readWorkspacePaths,"readWorkspacePaths"),u(readWorkspacePaths,"readWorkspacePaths");function hasPathMappings(s){return!!s&&(s.exact.size>0||s.patterns.length>0)}f(hasPathMappings,"hasPathMappings"),u(hasPathMappings,"hasPathMappings");function workspacePathCandidates(s,e){const i=[],n=s.exact.get(e);if(n)for(const r of n)i.push({file:path.resolve(s.baseDir,r),via:e});else{let r;for(const a of s.patterns)e.length<a.prefix.length+a.suffix.length||!e.startsWith(a.prefix)||!e.endsWith(a.suffix)||(!r||a.prefix.length>r.prefix.length)&&(r=a);if(r){const a=e.slice(r.prefix.length,e.length-r.suffix.length);for(const t of r.targets){const l=t.indexOf("*"),d=l===-1?t:t.slice(0,l)+a+t.slice(l+1);i.push({file:path.resolve(s.baseDir,d),via:r.key})}}}return s.baseUrl&&i.push({file:path.resolve(s.baseUrl,e),via:"baseUrl"}),i}f(workspacePathCandidates,"workspacePathCandidates"),u(workspacePathCandidates,"workspacePathCandidates");class WorkspacePathsResolverPlugin{static{f(this,"WorkspacePathsResolverPlugin")}static{u(this,"WorkspacePathsResolverPlugin")}constructor(e){this.paths=e}apply(e){const i=e.ensureHook("internal-resolve");e.getHook("normal-resolve").tapAsync("WorkspacePathsResolverPlugin",(n,r,a)=>{const t=n.request;if(!t||t.startsWith(".")||path.isAbsolute(t))return a();const l=workspacePathCandidates(this.paths,t);let d=0;const o=u(()=>{const c=l[d++];if(!c)return a();e.doResolve(i,{...n,request:c.file,fullySpecified:!1},`aliased with mapping '${c.via}' (tsconfig paths): '${t}' to '${c.file}'`,r,(p,g)=>{if(p)return a(p);if(g)return a(null,g);o()})},"attempt");o()})}}exports.WorkspacePathsResolverPlugin=WorkspacePathsResolverPlugin;