@lensmcp/memory-tracker 1.18.4 → 1.18.6

package/index.js

@@ -1,5 +1 @@
-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';
+"use strict";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.js

@@ -1,30 +1 @@
-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;
-}
+"use strict";var a=Object.defineProperty;var t=(e,n)=>a(e,"name",{value:n,configurable:!0});var c=Object.defineProperty,r=t((e,n)=>c(e,"name",{value:n,configurable:!0}),"t");let s=r(()=>{},"contextGetter"),o;const l={leakItemThreshold:50,staleGenerationBytesThreshold:1024*1024,settleMs:1e3};export function configureMemoryTracker(e){return o={sessionId:e.sessionId,sink:e.sink,leakItemThreshold:e.leakItemThreshold??l.leakItemThreshold,staleGenerationBytesThreshold:e.staleGenerationBytesThreshold??l.staleGenerationBytesThreshold,settleMs:e.settleMs??l.settleMs},e.contextGetter&&(s=e.contextGetter),o}t(configureMemoryTracker,"configureMemoryTracker"),r(configureMemoryTracker,"configureMemoryTracker");export function activeMemoryOptions(){return o}t(activeMemoryOptions,"activeMemoryOptions"),r(activeMemoryOptions,"activeMemoryOptions");export function currentMemoryContext(){return s()}t(currentMemoryContext,"currentMemoryContext"),r(currentMemoryContext,"currentMemoryContext");export function resetMemoryTracker(){o=void 0,s=r(()=>{},"contextGetter")}t(resetMemoryTracker,"resetMemoryTracker"),r(resetMemoryTracker,"resetMemoryTracker");

package/lib/detectors.js

@@ -1,62 +1 @@
-/**
- * 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;
-}
+"use strict";var s=Object.defineProperty;var n=(e,t)=>s(e,"name",{value:t,configurable:!0});var l=Object.defineProperty,r=n((e,t)=>l(e,"name",{value:t,configurable:!0}),"n");import{activeMemoryOptions as i}from"./context.js";import{clearFlowStart as c,flowGrowth as d,markFlowStart as w}from"./owners.js";import{emitRetention as u,emitStaleGeneration as f}from"./emit.js";export function onFlowStart(e){w(e)}n(onFlowStart,"onFlowStart"),r(onFlowStart,"onFlowStart");export function onFlowSettled(e){const t=i();if(!t)return[];const a=[];for(const o of d(e))o.growth>=t.leakItemThreshold&&o.endCount>=o.growth&&(u({options:t,ownerId:o.owner.ownerId,flowId:e,startCount:o.startCount,endCount:o.endCount,growth:o.growth}),a.push(o.owner.ownerId));return c(e),a}n(onFlowSettled,"onFlowSettled"),r(onFlowSettled,"onFlowSettled");export function checkStaleGeneration(e){const t=i();return t&&e.retainedBytes>t.staleGenerationBytesThreshold?(f({options:t,logicalId:e.logicalId,instanceId:e.instanceId,generation:e.generation,retainedBytes:e.retainedBytes}),!0):!1}n(checkStaleGeneration,"checkStaleGeneration"),r(checkStaleGeneration,"checkStaleGeneration");

package/lib/emit.js

@@ -1,93 +1 @@
-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();
-}
+"use strict";var m=Object.defineProperty;var n=(t,e)=>m(t,"name",{value:e,configurable:!0});var I=Object.defineProperty,o=n((t,e)=>I(t,"name",{value:e,configurable:!0}),"n");let d=0;function r(t){return d=(d+1)%16777215,`${t}-${d.toString(36)}`}n(r,"d"),o(r,"memId");function a(t,e){return{sessionId:e?.sessionId??t.sessionId,...e?.flowId?{flowId:e.flowId}:{},...e?.requestId?{requestId:e.requestId}:{},...e?.originNodeId?{originNodeId:e.originNodeId}:{}}}n(a,"r"),o(a,"baseContext");export function emitMutation(t){const{options:e}=t,i={id:r("memmut"),sessionId:t.context?.sessionId??e.sessionId,timestamp:t.timestamp??s(),source:"memory",category:"memory",severity:"debug",context:a(e,t.context),fingerprint:`memory-mutation:${t.ownerId}:${t.operation}`,title:`${t.operation} ${t.ownerId}`,raw:{kind:"memory-mutation",mutation:{ownerNodeId:t.ownerId,operation:t.operation,beforeCount:t.beforeCount,afterCount:t.afterCount,estimatedDeltaBytes:t.estimatedDeltaBytes,keyPreview:t.keyPreview}}};e.sink(i)}n(emitMutation,"emitMutation"),o(emitMutation,"emitMutation");export function emitRetention(t){const{options:e}=t,i={id:r("memret"),sessionId:t.context?.sessionId??e.sessionId,timestamp:t.timestamp??s(),source:"memory",category:"memory",severity:"warning",context:{...a(e,t.context),flowId:t.flowId},fingerprint:`memory-retention:${t.ownerId}`,title:`Suspected leak: ${t.ownerId} grew by ${t.growth} and did not shrink`,raw:{kind:"memory-retention",retention:{ownerId:t.ownerId,flowId:t.flowId,startCount:t.startCount,endCount:t.endCount,growth:t.growth}}};e.sink(i)}n(emitRetention,"emitRetention"),o(emitRetention,"emitRetention");export function emitStaleGeneration(t){const{options:e}=t,i={id:r("memstale"),sessionId:e.sessionId,timestamp:t.timestamp??s(),source:"memory",category:"memory",severity:"warning",context:{sessionId:e.sessionId},fingerprint:`memory-stale-generation:${t.logicalId}`,title:`Stale generation retained: ${t.logicalId} gen ${t.generation} holds ${t.retainedBytes} bytes`,raw:{kind:"singleton-stale-generation",staleGeneration:{logicalId:t.logicalId,instanceId:t.instanceId,generation:t.generation,retainedBytes:t.retainedBytes}}};e.sink(i)}n(emitStaleGeneration,"emitStaleGeneration"),o(emitStaleGeneration,"emitStaleGeneration");function s(){return Date.now()}n(s,"s"),o(s,"nowMs");

package/lib/owners.js

@@ -1,78 +1 @@
-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();
-}
+"use strict";var l=Object.defineProperty;var o=(e,t)=>l(e,"name",{value:t,configurable:!0});var w=Object.defineProperty,r=o((e,t)=>w(e,"name",{value:t,configurable:!0}),"o");const a=new Map;export function ownerKey(e,t){return`${e}::${t}`}o(ownerKey,"ownerKey"),r(ownerKey,"ownerKey");export function ensureOwner(e){const t=ownerKey(e.ownerInstanceId,e.fieldName);let n=a.get(t);return n||(n={ownerId:t,ownerInstanceId:e.ownerInstanceId,containerKind:e.containerKind,fieldName:e.fieldName,itemCount:0,estimatedBytes:0,startCount:0,flowStartCounts:new Map,flowDeltas:new Map},a.set(t,n)),n}o(ensureOwner,"ensureOwner"),r(ensureOwner,"ensureOwner");export function recordCount(e,t,n){e.itemCount=t,e.estimatedBytes=n}o(recordCount,"recordCount"),r(recordCount,"recordCount");export function markFlowStart(e){for(const t of a.values())t.flowStartCounts.has(e)||t.flowStartCounts.set(e,t.itemCount)}o(markFlowStart,"markFlowStart"),r(markFlowStart,"markFlowStart");export function recordFlowDelta(e,t,n){e.flowDeltas.set(t,(e.flowDeltas.get(t)??0)+n)}o(recordFlowDelta,"recordFlowDelta"),r(recordFlowDelta,"recordFlowDelta");export function flowGrowth(e){const t=[];for(const n of a.values()){const s=n.flowDeltas.get(e);s!==void 0&&t.push({owner:n,startCount:n.flowStartCounts.get(e)??0,endCount:n.itemCount,growth:s})}return t}o(flowGrowth,"flowGrowth"),r(flowGrowth,"flowGrowth");export function clearFlowStart(e){for(const t of a.values())t.flowStartCounts.delete(e),t.flowDeltas.delete(e)}o(clearFlowStart,"clearFlowStart"),r(clearFlowStart,"clearFlowStart");export function allOwners(){return[...a.values()].map(e=>({ownerId:e.ownerId,ownerInstanceId:e.ownerInstanceId,containerKind:e.containerKind,fieldName:e.fieldName,itemCount:e.itemCount,estimatedBytes:e.estimatedBytes,growthSinceStart:e.itemCount-e.startCount}))}o(allOwners,"allOwners"),r(allOwners,"allOwners");export function getOwner(e){return a.get(e)}o(getOwner,"getOwner"),r(getOwner,"getOwner");export function resetOwners(){a.clear()}o(resetOwners,"resetOwners"),r(resetOwners,"resetOwners");

package/lib/track-container.js

@@ -1,155 +1 @@
-/**
- * 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;
-}
+"use strict";var z=Object.defineProperty;var s=(t,e)=>z(t,"name",{value:e,configurable:!0});var A=Object.defineProperty,f=s((t,e)=>A(t,"name",{value:e,configurable:!0}),"s");import{activeMemoryOptions as g,currentMemoryContext as v}from"./context.js";import{ensureOwner as b,recordCount as h,recordFlowDelta as C}from"./owners.js";import{emitMutation as k}from"./emit.js";const I=Symbol.for("@lensmcp/memory-tracker/patched"),p=64;export function trackContainer(t){const{container:e}=t;if(!e||typeof e!="object"||e[I])return;let a;if(e instanceof Map)a="Map",w(t,e);else if(e instanceof Set)a="Set",M(t,e);else if(Array.isArray(e))a="Array",S(t,e);else return;e[I]=!0;const o=m(e),c=b({ownerInstanceId:t.ownerInstanceId,fieldName:t.fieldName,containerKind:a});h(c,o,o*p)}s(trackContainer,"trackContainer"),f(trackContainer,"trackContainer");function m(t){return t instanceof Map||t instanceof Set?t.size:Array.isArray(t)?t.length:0}s(m,"w"),f(m,"sizeOf");function d(t,e,a,o,c){const r=g();if(!r)return;const n=m(t.container),i=b({ownerInstanceId:t.ownerInstanceId,fieldName:t.fieldName,containerKind:e});h(i,n,n*p);const l=v(),y=l?.requestId??l?.flowId;y&&C(i,y,n-o),k({options:r,ownerId:i.ownerId,operation:a,beforeCount:o,afterCount:n,estimatedDeltaBytes:(n-o)*p,keyPreview:c,context:l})}s(d,"d"),f(d,"afterMutation");function w(t,e){const a=e.set.bind(e),o=e.delete.bind(e),c=e.clear.bind(e);e.set=(r,n)=>{const i=e.size,l=a(r,n);return d(t,"Map","set",i,u(r)),l},e.delete=r=>{const n=e.size,i=o(r);return d(t,"Map","delete",n,u(r)),i},e.clear=()=>{const r=e.size;c(),d(t,"Map","clear",r)}}s(w,"m"),f(w,"patchMap");function M(t,e){const a=e.add.bind(e),o=e.delete.bind(e),c=e.clear.bind(e);e.add=r=>{const n=e.size,i=a(r);return d(t,"Set","add",n,u(r)),i},e.delete=r=>{const n=e.size,i=o(r);return d(t,"Set","delete",n,u(r)),i},e.clear=()=>{const r=e.size;c(),d(t,"Set","clear",r)}}s(M,"C"),f(M,"patchSet");function S(t,e){const a=e.push.bind(e),o=e.splice.bind(e);e.push=(...c)=>{const r=e.length,n=a(...c);return d(t,"Array","push",r),n},e.splice=((c,r,...n)=>{const i=e.length,l=r===void 0?o(c):o(c,r,...n);return d(t,"Array",n.length>0?"push":"delete",i),l})}s(S,"D"),f(S,"patchArray");function u(t){if(typeof t=="string")return t.slice(0,40);if(typeof t=="number"||typeof t=="boolean")return String(t)}s(u,"u"),f(u,"previewKey");

package/lib/types.js

@@ -1 +1 @@
-export {};
+"use strict";export{};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lensmcp/memory-tracker",
-  "version": "1.18.4",
+  "version": "1.18.6",
   "type": "module",
   "main": "./index.js",
   "module": "./index.js",
@@ -14,7 +14,7 @@
     }
   },
   "dependencies": {
-    "@lensmcp/protocol-types": "1.18.4",
+    "@lensmcp/protocol-types": "1.18.6",
     "tslib": "^2.3.0"
   },
   "license": "Apache-2.0",