@lensmcp/memory-tracker 1.0.0

package/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/README.md

@@ -0,0 +1,92 @@
+# @lensmcp/memory-tracker
+
+Track memory growth in long-lived JavaScript containers, attribute it to the flow that caused it, and surface suspected leaks as LensMCP events.
+
+`@lensmcp/memory-tracker` instruments the mutating methods of `Map`, `Set`, and `Array` instances in place. Every mutation updates a per-container "owner" record (item count plus a rough byte estimate) and is attributed to the active request/flow. When a flow grows a container past a threshold and the items do not shrink back, the tracker emits a `memory-retention` ("memory leak suspected") event. It also reports stale generations of disposed singletons that still retain bytes. The result is a deterministic, attributable memory signal in the LensMCP lens — instead of a flat heap graph, you see *which owner grew, by how much, and under which flow*.
+
+It is designed to run in "light mode" inside the LensMCP node/NestJS instrumentation: zero sampling timers in the hot path, bounded per-mutation work, and a pluggable event sink so the host process forwards events to the LensMCP bus.
+
+## Install
+
+```bash
+yarn add @lensmcp/memory-tracker
+```
+
+Most users do not install this directly. It is normally enabled through the `memory` option of `@lensmcp/nest-instrumentation` (or the node instrumentation), which calls `configureMemoryTracker` and wires the flow brackets for you. Reach for the direct API only when instrumenting a runtime that LensMCP does not auto-wire.
+
+## Usage
+
+Configure the tracker once at startup, track the containers you care about, then bracket each unit of work so growth can be attributed and leaks detected.
+
+```ts
+import {
+  configureMemoryTracker,
+  trackContainer,
+  onFlowStart,
+  onFlowSettled,
+} from '@lensmcp/memory-tracker';
+
+// 1. Configure once. `sink` receives every memory BaseEvent; the host
+//    forwards it to the LensMCP bus. `contextGetter` lets each mutation
+//    attribute itself to the active flow (e.g. an AsyncLocalStorage store).
+configureMemoryTracker({
+  sessionId: 'session-123',
+  sink: (event) => bus.publish(event),
+  leakItemThreshold: 50,                       // items of growth that flips a suspected leak (default 50)
+  staleGenerationBytesThreshold: 1024 * 1024,  // bytes a disposed singleton may retain (default 1 MB)
+  settleMs: 1000,                              // grace period after a flow ends (default 1000)
+  contextGetter: () => currentLensmcpContext(), // optional: returns { sessionId, flowId?, requestId?, originNodeId? }
+});
+
+// 2. Track a container. Patching is in-place, non-destructive, and
+//    idempotent (re-tracking the same instance is a no-op).
+class SessionCache {
+  private readonly entries = new Map<string, Session>();
+
+  constructor(instanceId: string) {
+    trackContainer({
+      ownerInstanceId: instanceId, // identifies the owning instance
+      fieldName: 'entries',        // the field being tracked
+      container: this.entries,     // the Map / Set / Array to instrument
+    });
+  }
+}
+
+// 3. Bracket a flow. Mutations between start and settle are attributed to
+//    this flow; owners that grew past the threshold and stayed resident are
+//    flagged and emitted as `memory-retention` events.
+onFlowStart('req-42');
+// ... handle request: cache.entries.set(...) etc.
+const flaggedOwnerIds = onFlowSettled('req-42'); // string[] of suspected-leak owners
+```
+
+`trackContainer` only patches `Map`, `Set`, and `Array` instances — anything else is ignored. Tracked mutations are: `set` / `delete` / `clear` (Map), `add` / `delete` / `clear` (Set), and `push` / `splice` (Array).
+
+## API
+
+- **`configureMemoryTracker(opts)`** — Set the active session id, the event `sink`, the optional `contextGetter`, and detector thresholds (`leakItemThreshold`, `staleGenerationBytesThreshold`, `settleMs`). Returns the resolved options. Must be called before events are emitted.
+- **`trackContainer({ ownerInstanceId, fieldName, container })`** — Instrument a `Map`/`Set`/`Array` in place so each mutation updates its owner record and emits a `memory-mutation` event. Idempotent and non-destructive.
+- **`onFlowStart(flowId)`** — Snapshot every owner's item count at the start of a flow.
+- **`onFlowSettled(flowId)`** — Compare each owner's attributed growth against `leakItemThreshold`; emit `memory-retention` for owners that grew and stayed resident. Returns the flagged owner ids.
+- **`checkStaleGeneration({ logicalId, instanceId, generation, retainedBytes })`** — On singleton disposal, emit `singleton-stale-generation` when retained bytes exceed `staleGenerationBytesThreshold`. Returns whether it flagged.
+- **`allOwners()` / `getOwner(ownerId)` / `ownerKey(ownerInstanceId, fieldName)`** — Inspect the owner registry: list owner snapshots, fetch one record, or compute an owner key (`<ownerInstanceId>::<fieldName>`).
+- **`emitMutation` / `emitRetention` / `emitStaleGeneration`** — Low-level emit helpers that build each memory `BaseEvent` and push it to the sink (used internally; exported for advanced hosts).
+- **`activeMemoryOptions()` / `currentMemoryContext()` / `resetMemoryTracker()`** — Read the resolved options, read the current flow context, or reset tracker state (test hook).
+- **`markFlowStart` / `recordFlowDelta` / `flowGrowth` / `ensureOwner` / `resetOwners`** — Lower-level owner/flow primitives behind the detectors.
+- **Types** — `MemoryEventSink`, `MemoryContext`, `ResolvedMemoryOptions`, `MemoryOwnerSnapshot`, `MemoryContainerKind`, `MemoryMutationOperation`, and the `TrackContainerArgs` input.
+
+## How it fits
+
+`@lensmcp/memory-tracker` is enabled by `@lensmcp/nest-instrumentation` via its `memory` option (the node instrumentation does the same). The host supplies the `sessionId`, the event `sink`, and a `contextGetter` bound to its own request context, and brackets each request with `onFlowStart` / `onFlowSettled`.
+
+Every event is a `@lensmcp/protocol-types` `BaseEvent` with `source` and `category` of `memory`, carrying one of three payload kinds:
+
+- `memory-mutation` — `debug` severity; per-mutation before/after counts and an estimated byte delta.
+- `memory-retention` — `warning` severity; the "memory leak suspected" signal (owner id, flow, growth) surfaced in the lens.
+- `singleton-stale-generation` — `warning` severity; a disposed singleton generation still retaining bytes.
+
+These events flow through the host's sink to the LensMCP bus, where the lens renders them in the **"memory leak suspected"** channel.
+
+---
+
+Part of [LensMCP](https://github.com/kiwiapps-ltd/lensmcp). Apache-2.0.

package/index.d.ts

@@ -0,0 +1,7 @@
+export { configureMemoryTracker, activeMemoryOptions, currentMemoryContext, resetMemoryTracker, } from './lib/context.js';
+export { trackContainer, type TrackContainerArgs } from './lib/track-container.js';
+export { ensureOwner, allOwners, getOwner, ownerKey, resetOwners, markFlowStart, recordFlowDelta, flowGrowth, } from './lib/owners.js';
+export { emitMutation, emitRetention, emitStaleGeneration } from './lib/emit.js';
+export { onFlowStart, onFlowSettled, checkStaleGeneration, } from './lib/detectors.js';
+export type { MemoryEventSink, MemoryContext, ResolvedMemoryOptions, MemoryOwnerSnapshot, MemoryContainerKind, MemoryMutationOperation, } from './lib/types.js';
+//# sourceMappingURL=index.d.ts.map

package/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,sBAAsB,EACtB,mBAAmB,EACnB,oBAAoB,EACpB,kBAAkB,GACnB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EAAE,cAAc,EAAE,KAAK,kBAAkB,EAAE,MAAM,0BAA0B,CAAC;AACnF,OAAO,EACL,WAAW,EACX,SAAS,EACT,QAAQ,EACR,QAAQ,EACR,WAAW,EACX,aAAa,EACb,eAAe,EACf,UAAU,GACX,MAAM,iBAAiB,CAAC;AACzB,OAAO,EAAE,YAAY,EAAE,aAAa,EAAE,mBAAmB,EAAE,MAAM,eAAe,CAAC;AACjF,OAAO,EACL,WAAW,EACX,aAAa,EACb,oBAAoB,GACrB,MAAM,oBAAoB,CAAC;AAC5B,YAAY,EACV,eAAe,EACf,aAAa,EACb,qBAAqB,EACrB,mBAAmB,EACnB,mBAAmB,EACnB,uBAAuB,GACxB,MAAM,gBAAgB,CAAC"}

package/index.js

@@ -0,0 +1,5 @@
+export { configureMemoryTracker, activeMemoryOptions, currentMemoryContext, resetMemoryTracker, } from './lib/context.js';
+export { trackContainer } from './lib/track-container.js';
+export { ensureOwner, allOwners, getOwner, ownerKey, resetOwners, markFlowStart, recordFlowDelta, flowGrowth, } from './lib/owners.js';
+export { emitMutation, emitRetention, emitStaleGeneration } from './lib/emit.js';
+export { onFlowStart, onFlowSettled, checkStaleGeneration, } from './lib/detectors.js';

package/lib/context.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Memory tracker state. The container wrappers consult a module-level
+ * "current context" getter so each mutation can attribute itself to the
+ * active flow/request. The host wires this getter to its own
+ * AsyncLocalStorage (e.g. nest-instrumentation's
+ * `currentLensmcpContext`).
+ */
+import type { MemoryContext, ResolvedMemoryOptions, MemoryEventSink } from './types.js';
+type ContextGetter = () => MemoryContext | undefined;
+export declare function configureMemoryTracker(opts: {
+    sessionId: string;
+    sink: MemoryEventSink;
+    leakItemThreshold?: number;
+    staleGenerationBytesThreshold?: number;
+    settleMs?: number;
+    contextGetter?: ContextGetter;
+}): ResolvedMemoryOptions;
+export declare function activeMemoryOptions(): ResolvedMemoryOptions | undefined;
+export declare function currentMemoryContext(): MemoryContext | undefined;
+/** Test hook. */
+export declare function resetMemoryTracker(): void;
+export {};
+//# sourceMappingURL=context.d.ts.map

package/lib/context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.d.ts","sourceRoot":"","sources":["../../src/lib/context.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,OAAO,KAAK,EAAE,aAAa,EAAE,qBAAqB,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAExF,KAAK,aAAa,GAAG,MAAM,aAAa,GAAG,SAAS,CAAC;AAWrD,wBAAgB,sBAAsB,CAAC,IAAI,EAAE;IAC3C,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,eAAe,CAAC;IACtB,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,6BAA6B,CAAC,EAAE,MAAM,CAAC;IACvC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,aAAa,CAAC,EAAE,aAAa,CAAC;CAC/B,GAAG,qBAAqB,CAWxB;AAED,wBAAgB,mBAAmB,IAAI,qBAAqB,GAAG,SAAS,CAEvE;AAED,wBAAgB,oBAAoB,IAAI,aAAa,GAAG,SAAS,CAEhE;AAED,iBAAiB;AACjB,wBAAgB,kBAAkB,IAAI,IAAI,CAGzC"}

package/lib/context.js

@@ -0,0 +1,30 @@
+let contextGetter = () => undefined;
+let options;
+const DEFAULTS = {
+    leakItemThreshold: 50,
+    staleGenerationBytesThreshold: 1024 * 1024,
+    settleMs: 1000,
+};
+export function configureMemoryTracker(opts) {
+    options = {
+        sessionId: opts.sessionId,
+        sink: opts.sink,
+        leakItemThreshold: opts.leakItemThreshold ?? DEFAULTS.leakItemThreshold,
+        staleGenerationBytesThreshold: opts.staleGenerationBytesThreshold ?? DEFAULTS.staleGenerationBytesThreshold,
+        settleMs: opts.settleMs ?? DEFAULTS.settleMs,
+    };
+    if (opts.contextGetter)
+        contextGetter = opts.contextGetter;
+    return options;
+}
+export function activeMemoryOptions() {
+    return options;
+}
+export function currentMemoryContext() {
+    return contextGetter();
+}
+/** Test hook. */
+export function resetMemoryTracker() {
+    options = undefined;
+    contextGetter = () => undefined;
+}

package/lib/detectors.d.ts

@@ -0,0 +1,14 @@
+export declare function onFlowStart(flowId: string): void;
+/**
+ * Compare each owner's count at flow-start vs now. Owners that grew by
+ * more than `leakItemThreshold` and didn't shrink are flagged. Returns
+ * the list of flagged owner ids (also useful for tests).
+ */
+export declare function onFlowSettled(flowId: string): string[];
+export declare function checkStaleGeneration(args: {
+    logicalId: string;
+    instanceId: string;
+    generation: number;
+    retainedBytes: number;
+}): boolean;
+//# sourceMappingURL=detectors.d.ts.map

package/lib/detectors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"detectors.d.ts","sourceRoot":"","sources":["../../src/lib/detectors.ts"],"names":[],"mappings":"AAoBA,wBAAgB,WAAW,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAEhD;AAED;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,CAqBtD;AAED,wBAAgB,oBAAoB,CAAC,IAAI,EAAE;IACzC,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;IACnB,aAAa,EAAE,MAAM,CAAC;CACvB,GAAG,OAAO,CAcV"}

package/lib/detectors.js

@@ -0,0 +1,62 @@
+/**
+ * Suspect-leak + stale-generation detectors.
+ *
+ * `onFlowStart` / `onFlowSettled` bracket a flow: at start we snapshot
+ * every owner's count; after the flow settles we compare. If an owner
+ * grew past the threshold and didn't shrink back, we emit a
+ * `memory-retention` event.
+ *
+ * `checkStaleGeneration` is called when a singleton instance is
+ * disposed; if its sampled retained bytes exceed the threshold we emit
+ * a `singleton-stale-generation` event.
+ */
+import { activeMemoryOptions } from './context.js';
+import { clearFlowStart, flowGrowth, markFlowStart, } from './owners.js';
+import { emitRetention, emitStaleGeneration } from './emit.js';
+export function onFlowStart(flowId) {
+    markFlowStart(flowId);
+}
+/**
+ * Compare each owner's count at flow-start vs now. Owners that grew by
+ * more than `leakItemThreshold` and didn't shrink are flagged. Returns
+ * the list of flagged owner ids (also useful for tests).
+ */
+export function onFlowSettled(flowId) {
+    const opts = activeMemoryOptions();
+    if (!opts)
+        return [];
+    const flagged = [];
+    for (const g of flowGrowth(flowId)) {
+        // Flag when THIS flow's attributed growth crosses the threshold AND
+        // the items are still resident (the container didn't shrink back).
+        if (g.growth >= opts.leakItemThreshold && g.endCount >= g.growth) {
+            emitRetention({
+                options: opts,
+                ownerId: g.owner.ownerId,
+                flowId,
+                startCount: g.startCount,
+                endCount: g.endCount,
+                growth: g.growth,
+            });
+            flagged.push(g.owner.ownerId);
+        }
+    }
+    clearFlowStart(flowId);
+    return flagged;
+}
+export function checkStaleGeneration(args) {
+    const opts = activeMemoryOptions();
+    if (!opts)
+        return false;
+    if (args.retainedBytes > opts.staleGenerationBytesThreshold) {
+        emitStaleGeneration({
+            options: opts,
+            logicalId: args.logicalId,
+            instanceId: args.instanceId,
+            generation: args.generation,
+            retainedBytes: args.retainedBytes,
+        });
+        return true;
+    }
+    return false;
+}

package/lib/emit.d.ts

@@ -0,0 +1,31 @@
+import type { MemoryContext, MemoryMutationOperation, ResolvedMemoryOptions } from './types.js';
+export declare function emitMutation(args: {
+    options: ResolvedMemoryOptions;
+    ownerId: string;
+    operation: MemoryMutationOperation;
+    beforeCount: number;
+    afterCount: number;
+    estimatedDeltaBytes: number;
+    keyPreview?: string;
+    context?: MemoryContext;
+    timestamp?: number;
+}): void;
+export declare function emitRetention(args: {
+    options: ResolvedMemoryOptions;
+    ownerId: string;
+    flowId: string;
+    startCount: number;
+    endCount: number;
+    growth: number;
+    context?: MemoryContext;
+    timestamp?: number;
+}): void;
+export declare function emitStaleGeneration(args: {
+    options: ResolvedMemoryOptions;
+    logicalId: string;
+    instanceId: string;
+    generation: number;
+    retainedBytes: number;
+    timestamp?: number;
+}): void;
+//# sourceMappingURL=emit.d.ts.map

package/lib/emit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"emit.d.ts","sourceRoot":"","sources":["../../src/lib/emit.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EACV,aAAa,EACb,uBAAuB,EACvB,qBAAqB,EACtB,MAAM,YAAY,CAAC;AAiBpB,wBAAgB,YAAY,CAAC,IAAI,EAAE;IACjC,OAAO,EAAE,qBAAqB,CAAC;IAC/B,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,uBAAuB,CAAC;IACnC,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC;IACnB,mBAAmB,EAAE,MAAM,CAAC;IAC5B,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,OAAO,CAAC,EAAE,aAAa,CAAC;IACxB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB,GAAG,IAAI,CAyBP;AAED,wBAAgB,aAAa,CAAC,IAAI,EAAE;IAClC,OAAO,EAAE,qBAAqB,CAAC;IAC/B,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,CAAC,EAAE,aAAa,CAAC;IACxB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB,GAAG,IAAI,CAwBP;AAED,wBAAgB,mBAAmB,CAAC,IAAI,EAAE;IACxC,OAAO,EAAE,qBAAqB,CAAC;IAC/B,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;IACnB,aAAa,EAAE,MAAM,CAAC;IACtB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB,GAAG,IAAI,CAuBP"}

package/lib/emit.js

@@ -0,0 +1,93 @@
+let seq = 0;
+function memId(prefix) {
+    seq = (seq + 1) % 0xffffff;
+    return `${prefix}-${seq.toString(36)}`;
+}
+function baseContext(options, ctx) {
+    return {
+        sessionId: ctx?.sessionId ?? options.sessionId,
+        ...(ctx?.flowId ? { flowId: ctx.flowId } : {}),
+        ...(ctx?.requestId ? { requestId: ctx.requestId } : {}),
+        ...(ctx?.originNodeId ? { originNodeId: ctx.originNodeId } : {}),
+    };
+}
+export function emitMutation(args) {
+    const { options } = args;
+    const event = {
+        id: memId('memmut'),
+        sessionId: args.context?.sessionId ?? options.sessionId,
+        timestamp: args.timestamp ?? nowMs(),
+        source: 'memory',
+        category: 'memory',
+        severity: 'debug',
+        context: baseContext(options, args.context),
+        fingerprint: `memory-mutation:${args.ownerId}:${args.operation}`,
+        title: `${args.operation} ${args.ownerId}`,
+        raw: {
+            kind: 'memory-mutation',
+            mutation: {
+                ownerNodeId: args.ownerId,
+                operation: args.operation,
+                beforeCount: args.beforeCount,
+                afterCount: args.afterCount,
+                estimatedDeltaBytes: args.estimatedDeltaBytes,
+                keyPreview: args.keyPreview,
+            },
+        },
+    };
+    options.sink(event);
+}
+export function emitRetention(args) {
+    const { options } = args;
+    const event = {
+        id: memId('memret'),
+        sessionId: args.context?.sessionId ?? options.sessionId,
+        timestamp: args.timestamp ?? nowMs(),
+        source: 'memory',
+        category: 'memory',
+        severity: 'warning',
+        context: { ...baseContext(options, args.context), flowId: args.flowId },
+        fingerprint: `memory-retention:${args.ownerId}`,
+        title: `Suspected leak: ${args.ownerId} grew by ${args.growth} and did not shrink`,
+        raw: {
+            kind: 'memory-retention',
+            retention: {
+                ownerId: args.ownerId,
+                flowId: args.flowId,
+                startCount: args.startCount,
+                endCount: args.endCount,
+                growth: args.growth,
+            },
+        },
+    };
+    options.sink(event);
+}
+export function emitStaleGeneration(args) {
+    const { options } = args;
+    const event = {
+        id: memId('memstale'),
+        sessionId: options.sessionId,
+        timestamp: args.timestamp ?? nowMs(),
+        source: 'memory',
+        category: 'memory',
+        severity: 'warning',
+        context: { sessionId: options.sessionId },
+        fingerprint: `memory-stale-generation:${args.logicalId}`,
+        title: `Stale generation retained: ${args.logicalId} gen ${args.generation} holds ${args.retainedBytes} bytes`,
+        raw: {
+            kind: 'singleton-stale-generation',
+            staleGeneration: {
+                logicalId: args.logicalId,
+                instanceId: args.instanceId,
+                generation: args.generation,
+                retainedBytes: args.retainedBytes,
+            },
+        },
+    };
+    options.sink(event);
+}
+function nowMs() {
+    // `Date.now` is fine in library runtime code; the workflow-script ban
+    // doesn't apply here.
+    return Date.now();
+}

package/lib/owners.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Owner registry. Each tracked container is an "owner" — keyed by
+ * `<ownerInstanceId>::<fieldName>`. We hold the current item count +
+ * a rough byte estimate, and the count at the start of each in-flight
+ * flow so the leak detector can compute per-flow growth.
+ */
+import type { MemoryContainerKind, MemoryOwnerSnapshot } from './types.js';
+interface OwnerRecord {
+    ownerId: string;
+    ownerInstanceId: string;
+    containerKind: MemoryContainerKind;
+    fieldName: string;
+    itemCount: number;
+    estimatedBytes: number;
+    startCount: number;
+    /** itemCount captured at the start of each active flow, keyed by flowId. */
+    flowStartCounts: Map<string, number>;
+    /**
+     * Net items added by each flow's mutations, keyed by flowId. This is
+     * the *attributed* growth — only flows whose own mutations grew the
+     * container are blamed, not every flow that happened to be in flight
+     * while another flow grew it.
+     */
+    flowDeltas: Map<string, number>;
+}
+export declare function ownerKey(ownerInstanceId: string, fieldName: string): string;
+export declare function ensureOwner(args: {
+    ownerInstanceId: string;
+    fieldName: string;
+    containerKind: MemoryContainerKind;
+}): OwnerRecord;
+export declare function recordCount(rec: OwnerRecord, itemCount: number, estimatedBytes: number): void;
+export declare function markFlowStart(flowId: string): void;
+/** Attribute a net item delta to the flow whose mutation caused it. */
+export declare function recordFlowDelta(rec: OwnerRecord, flowId: string, delta: number): void;
+export declare function flowGrowth(flowId: string): Array<{
+    owner: OwnerRecord;
+    startCount: number;
+    endCount: number;
+    growth: number;
+}>;
+export declare function clearFlowStart(flowId: string): void;
+export declare function allOwners(): MemoryOwnerSnapshot[];
+export declare function getOwner(ownerId: string): OwnerRecord | undefined;
+export declare function resetOwners(): void;
+export {};
+//# sourceMappingURL=owners.d.ts.map

package/lib/owners.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"owners.d.ts","sourceRoot":"","sources":["../../src/lib/owners.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,KAAK,EAAE,mBAAmB,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAC;AAE3E,UAAU,WAAW;IACnB,OAAO,EAAE,MAAM,CAAC;IAChB,eAAe,EAAE,MAAM,CAAC;IACxB,aAAa,EAAE,mBAAmB,CAAC;IACnC,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,cAAc,EAAE,MAAM,CAAC;IACvB,UAAU,EAAE,MAAM,CAAC;IACnB,4EAA4E;IAC5E,eAAe,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACrC;;;;;OAKG;IACH,UAAU,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACjC;AAID,wBAAgB,QAAQ,CAAC,eAAe,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,CAE3E;AAED,wBAAgB,WAAW,CAAC,IAAI,EAAE;IAChC,eAAe,EAAE,MAAM,CAAC;IACxB,SAAS,EAAE,MAAM,CAAC;IAClB,aAAa,EAAE,mBAAmB,CAAC;CACpC,GAAG,WAAW,CAkBd;AAED,wBAAgB,WAAW,CACzB,GAAG,EAAE,WAAW,EAChB,SAAS,EAAE,MAAM,EACjB,cAAc,EAAE,MAAM,GACrB,IAAI,CAGN;AAED,wBAAgB,aAAa,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAMlD;AAED,uEAAuE;AACvE,wBAAgB,eAAe,CAC7B,GAAG,EAAE,WAAW,EAChB,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,MAAM,GACZ,IAAI,CAEN;AAED,wBAAgB,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,KAAK,CAAC;IAChD,KAAK,EAAE,WAAW,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC,CAeD;AAED,wBAAgB,cAAc,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAKnD;AAED,wBAAgB,SAAS,IAAI,mBAAmB,EAAE,CAUjD;AAED,wBAAgB,QAAQ,CAAC,OAAO,EAAE,MAAM,GAAG,WAAW,GAAG,SAAS,CAEjE;AAED,wBAAgB,WAAW,IAAI,IAAI,CAElC"}

package/lib/owners.js

@@ -0,0 +1,78 @@
+const owners = new Map();
+export function ownerKey(ownerInstanceId, fieldName) {
+    return `${ownerInstanceId}::${fieldName}`;
+}
+export function ensureOwner(args) {
+    const id = ownerKey(args.ownerInstanceId, args.fieldName);
+    let rec = owners.get(id);
+    if (!rec) {
+        rec = {
+            ownerId: id,
+            ownerInstanceId: args.ownerInstanceId,
+            containerKind: args.containerKind,
+            fieldName: args.fieldName,
+            itemCount: 0,
+            estimatedBytes: 0,
+            startCount: 0,
+            flowStartCounts: new Map(),
+            flowDeltas: new Map(),
+        };
+        owners.set(id, rec);
+    }
+    return rec;
+}
+export function recordCount(rec, itemCount, estimatedBytes) {
+    rec.itemCount = itemCount;
+    rec.estimatedBytes = estimatedBytes;
+}
+export function markFlowStart(flowId) {
+    for (const rec of owners.values()) {
+        if (!rec.flowStartCounts.has(flowId)) {
+            rec.flowStartCounts.set(flowId, rec.itemCount);
+        }
+    }
+}
+/** Attribute a net item delta to the flow whose mutation caused it. */
+export function recordFlowDelta(rec, flowId, delta) {
+    rec.flowDeltas.set(flowId, (rec.flowDeltas.get(flowId) ?? 0) + delta);
+}
+export function flowGrowth(flowId) {
+    const out = [];
+    for (const rec of owners.values()) {
+        // Only owners this flow actually mutated. `growth` is the flow's own
+        // attributed net add, not the global item-count delta.
+        const delta = rec.flowDeltas.get(flowId);
+        if (delta === undefined)
+            continue;
+        out.push({
+            owner: rec,
+            startCount: rec.flowStartCounts.get(flowId) ?? 0,
+            endCount: rec.itemCount,
+            growth: delta,
+        });
+    }
+    return out;
+}
+export function clearFlowStart(flowId) {
+    for (const rec of owners.values()) {
+        rec.flowStartCounts.delete(flowId);
+        rec.flowDeltas.delete(flowId);
+    }
+}
+export function allOwners() {
+    return [...owners.values()].map((rec) => ({
+        ownerId: rec.ownerId,
+        ownerInstanceId: rec.ownerInstanceId,
+        containerKind: rec.containerKind,
+        fieldName: rec.fieldName,
+        itemCount: rec.itemCount,
+        estimatedBytes: rec.estimatedBytes,
+        growthSinceStart: rec.itemCount - rec.startCount,
+    }));
+}
+export function getOwner(ownerId) {
+    return owners.get(ownerId);
+}
+export function resetOwners() {
+    owners.clear();
+}

package/lib/track-container.d.ts

@@ -0,0 +1,7 @@
+export interface TrackContainerArgs {
+    ownerInstanceId: string;
+    fieldName: string;
+    container: unknown;
+}
+export declare function trackContainer(args: TrackContainerArgs): void;
+//# sourceMappingURL=track-container.d.ts.map

package/lib/track-container.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"track-container.d.ts","sourceRoot":"","sources":["../../src/lib/track-container.ts"],"names":[],"mappings":"AAiBA,MAAM,WAAW,kBAAkB;IACjC,eAAe,EAAE,MAAM,CAAC;IACxB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,OAAO,CAAC;CACpB;AAKD,wBAAgB,cAAc,CAAC,IAAI,EAAE,kBAAkB,GAAG,IAAI,CA6B7D"}

package/lib/track-container.js

@@ -0,0 +1,155 @@
+/**
+ * Container tracking. Wraps the mutating methods of a Map / Set / Array
+ * so each mutation:
+ *   1. updates the owner's item count + byte estimate,
+ *   2. emits a `memory-mutation` event attributed to the active flow.
+ *
+ * The wrapping is in-place (we patch the instance's own methods) and
+ * non-destructive: original behaviour always runs, return values pass
+ * through, and patching is idempotent (guarded by a Symbol flag).
+ */
+import { activeMemoryOptions, currentMemoryContext } from './context.js';
+import { ensureOwner, recordCount, recordFlowDelta } from './owners.js';
+import { emitMutation } from './emit.js';
+const PATCHED = Symbol.for('@lensmcp/memory-tracker/patched');
+/** Rough per-item byte estimate; good enough for growth-trend detection. */
+const BYTES_PER_ITEM = 64;
+export function trackContainer(args) {
+    const { container } = args;
+    if (!container || typeof container !== 'object')
+        return;
+    if (container[PATCHED])
+        return;
+    let kind;
+    if (container instanceof Map) {
+        kind = 'Map';
+        patchMap(args, container);
+    }
+    else if (container instanceof Set) {
+        kind = 'Set';
+        patchSet(args, container);
+    }
+    else if (Array.isArray(container)) {
+        kind = 'Array';
+        patchArray(args, container);
+    }
+    else {
+        return;
+    }
+    container[PATCHED] = true;
+    // Register the owner eagerly (at its current size) so a subsequent
+    // `markFlowStart` snapshots a baseline even before the first mutation.
+    const initial = sizeOf(container);
+    const owner = ensureOwner({
+        ownerInstanceId: args.ownerInstanceId,
+        fieldName: args.fieldName,
+        containerKind: kind,
+    });
+    recordCount(owner, initial, initial * BYTES_PER_ITEM);
+}
+function sizeOf(container) {
+    if (container instanceof Map || container instanceof Set)
+        return container.size;
+    if (Array.isArray(container))
+        return container.length;
+    return 0;
+}
+function afterMutation(args, kind, operation, before, keyPreview) {
+    const opts = activeMemoryOptions();
+    if (!opts)
+        return;
+    const after = sizeOf(args.container);
+    const owner = ensureOwner({
+        ownerInstanceId: args.ownerInstanceId,
+        fieldName: args.fieldName,
+        containerKind: kind,
+    });
+    recordCount(owner, after, after * BYTES_PER_ITEM);
+    const ctx = currentMemoryContext();
+    // Attribute this mutation's net delta to the active flow so the leak
+    // detector blames the flow that actually grew the container. Keyed by
+    // requestId (preferred — the interceptor brackets onFlowStart/Settled
+    // by requestId) with flowId as the fallback for non-request flows.
+    const flowKey = ctx?.requestId ?? ctx?.flowId;
+    if (flowKey)
+        recordFlowDelta(owner, flowKey, after - before);
+    emitMutation({
+        options: opts,
+        ownerId: owner.ownerId,
+        operation,
+        beforeCount: before,
+        afterCount: after,
+        estimatedDeltaBytes: (after - before) * BYTES_PER_ITEM,
+        keyPreview,
+        context: ctx,
+    });
+}
+function patchMap(args, map) {
+    const origSet = map.set.bind(map);
+    const origDelete = map.delete.bind(map);
+    const origClear = map.clear.bind(map);
+    map.set = (k, v) => {
+        const before = map.size;
+        const r = origSet(k, v);
+        afterMutation(args, 'Map', 'set', before, previewKey(k));
+        return r;
+    };
+    map.delete = (k) => {
+        const before = map.size;
+        const r = origDelete(k);
+        afterMutation(args, 'Map', 'delete', before, previewKey(k));
+        return r;
+    };
+    map.clear = () => {
+        const before = map.size;
+        origClear();
+        afterMutation(args, 'Map', 'clear', before);
+    };
+}
+function patchSet(args, set) {
+    const origAdd = set.add.bind(set);
+    const origDelete = set.delete.bind(set);
+    const origClear = set.clear.bind(set);
+    set.add = (v) => {
+        const before = set.size;
+        const r = origAdd(v);
+        afterMutation(args, 'Set', 'add', before, previewKey(v));
+        return r;
+    };
+    set.delete = (v) => {
+        const before = set.size;
+        const r = origDelete(v);
+        afterMutation(args, 'Set', 'delete', before, previewKey(v));
+        return r;
+    };
+    set.clear = () => {
+        const before = set.size;
+        origClear();
+        afterMutation(args, 'Set', 'clear', before);
+    };
+}
+function patchArray(args, arr) {
+    const origPush = arr.push.bind(arr);
+    const origSplice = arr.splice.bind(arr);
+    arr.push = (...items) => {
+        const before = arr.length;
+        const r = origPush(...items);
+        afterMutation(args, 'Array', 'push', before);
+        return r;
+    };
+    arr.splice = ((start, deleteCount, ...items) => {
+        const before = arr.length;
+        const r = deleteCount === undefined
+            ? origSplice(start)
+            : origSplice(start, deleteCount, ...items);
+        afterMutation(args, 'Array', items.length > 0 ? 'push' : 'delete', before);
+        return r;
+    });
+}
+function previewKey(k) {
+    if (typeof k === 'string')
+        return k.slice(0, 40);
+    if (typeof k === 'number' || typeof k === 'boolean')
+        return String(k);
+    return undefined;
+}

package/lib/types.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Public types for `@lensmcp/memory-tracker`. The tracker emits
+ * `BaseEvent`s through a pluggable sink (same shape as
+ * `@lensmcp/nest-instrumentation`'s EventSink) so the host process can
+ * forward them to the LensMCP bus.
+ */
+import type { BaseEvent, MemoryContainerKind, MemoryMutationOperation } from '@lensmcp/protocol-types';
+export type { MemoryContainerKind, MemoryMutationOperation };
+export type MemoryEventSink = (event: BaseEvent) => void;
+export interface MemoryContext {
+    sessionId: string;
+    flowId?: string;
+    requestId?: string;
+    originNodeId?: string;
+}
+/** Resolved options after defaults are applied. */
+export interface ResolvedMemoryOptions {
+    sessionId: string;
+    sink: MemoryEventSink;
+    /** Owner growth (in items) within a flow that flips a suspected leak. Default 50. */
+    leakItemThreshold: number;
+    /** Bytes retained by a disposed singleton that flags stale-generation. Default 1MB. */
+    staleGenerationBytesThreshold: number;
+    /** ms to wait after flow end before checking owner shrinkage. Default 1000. */
+    settleMs: number;
+}
+export interface MemoryOwnerSnapshot {
+    ownerId: string;
+    ownerInstanceId: string;
+    containerKind: MemoryContainerKind;
+    fieldName: string;
+    itemCount: number;
+    estimatedBytes: number;
+    growthSinceStart: number;
+}
+//# sourceMappingURL=types.d.ts.map

package/lib/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/lib/types.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,KAAK,EAAE,SAAS,EAAE,mBAAmB,EAAE,uBAAuB,EAAE,MAAM,yBAAyB,CAAC;AAEvG,YAAY,EAAE,mBAAmB,EAAE,uBAAuB,EAAE,CAAC;AAE7D,MAAM,MAAM,eAAe,GAAG,CAAC,KAAK,EAAE,SAAS,KAAK,IAAI,CAAC;AAEzD,MAAM,WAAW,aAAa;IAC5B,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAED,mDAAmD;AACnD,MAAM,WAAW,qBAAqB;IACpC,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,eAAe,CAAC;IACtB,qFAAqF;IACrF,iBAAiB,EAAE,MAAM,CAAC;IAC1B,uFAAuF;IACvF,6BAA6B,EAAE,MAAM,CAAC;IACtC,+EAA+E;IAC/E,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,mBAAmB;IAClC,OAAO,EAAE,MAAM,CAAC;IAChB,eAAe,EAAE,MAAM,CAAC;IACxB,aAAa,EAAE,mBAAmB,CAAC;IACnC,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,cAAc,EAAE,MAAM,CAAC;IACvB,gBAAgB,EAAE,MAAM,CAAC;CAC1B"}

package/lib/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@lensmcp/memory-tracker",
+  "version": "1.0.0",
+  "type": "module",
+  "main": "./index.js",
+  "module": "./index.js",
+  "types": "./index.d.ts",
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "types": "./index.d.ts",
+      "import": "./index.js",
+      "default": "./index.js"
+    }
+  },
+  "dependencies": {
+    "@lensmcp/protocol-types": "1.0.0",
+    "tslib": "^2.3.0"
+  },
+  "license": "Apache-2.0",
+  "homepage": "https://github.com/kiwiapps-ltd/lensmcp#readme",
+  "bugs": {
+    "url": "https://github.com/kiwiapps-ltd/lensmcp/issues"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "description": "LensMCP container/memory mutation tracking (Map/Set/Array instrumentation).",
+  "keywords": [
+    "lensmcp",
+    "mcp",
+    "observability",
+    "ai-agents",
+    "claude",
+    "memory",
+    "leak-detection"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/kiwiapps-ltd/lensmcp.git",
+    "directory": "libs/memory-tracker"
+  }
+}