Live survey304 models · 14 providers · 23,592 auditsAudited implement · SAFE →What changedHow we verifyllms.txt

MCP server · Org-owned · Audited from source

Memlab MCP server

by meta/memlabMIT licenceAudited 13 Nov 2026 · source d8f1c4ee2a62

npm memlab-website 1.0.1stdio★ 5,091
✕BLOCKGrade F · 53/100 · 13 Nov 2026 · d8f1c4e

Is it safe? No — BLOCK, grade F (53/100). It exposes 174 tools: 149 read, 25 write and 0 destructive. The audit recorded 39 findings (0 critical, 4 high, 5 medium, 26 low). Maintainer's description: A framework for finding JavaScript memory leaks and analyzing heap snapshots

Ask an AI about this pageGChatGPTCClaudePPerplexityGeGeminiXGrok
More
Cite

Cite this page

ModelsAtlas. “Memlab MCP server (meta/memlab)”. Retrieved 13 Nov 2026. https://modelsatlas.com/mcp/meta/memlab

Why this is BLOCK. The audit found 0 critical and 4 high findings; the most severe is Code injection at packages/mcp-server/scripts/sync-tool-catalog.mjs:43. Each finding is listed below with its file and line.

Why this page is still public. People search for this server by name. Hiding it would leave them with the README's word alone; here they see what the code does. We list it so you can decide, and we do not show connect commands for BLOCK servers.

2 MCP servers are called Memlab. You are viewing meta/memlab. Compare all 2 →

  • meta/memlab Org-owned★ 5,091✕BLOCK
  • facebook/memlab Org-owned★ 5,067✕BLOCK

Trust audit

Audit 0.4.1 · full source read 13 Nov 2026

Trust score53/100✕BLOCK F
0 critical4 high5 medium26 low4 info

39 findings, listed below with the file and line each was found on. Grade A needs a sandboxed behavioural run too; this audit read the source only.

What the source does

  • FilesystemDeclared2 observations
  • NetworkDeclared7 observations
  • ShellDeclared6 observations
  • DependenciesNot pinnedSome ranges float
  • SecretsFoundSee the findings

Findings (39)

Sorted by severity · the 25 most severe of 39 are listed

HIGHCode injectioncode.eval_exec · packages/mcp-server/scripts/sync-tool-catalog.mjs:43
F-02 Code injectionCWE-78 · CWE-94 · CWE-95Layer L1
return new Function(`return [${body}];`)();
Why
evaluates text as code
Fix
remove; use a parser or a dispatch table
HIGHCode injectioncode.eval_exec · packages/mcp-server/src/fix-status.ts:105
F-02 Code injectionCWE-78 · CWE-94 · CWE-95Layer L1
exec(
Why
evaluates text as code
Fix
remove; use a parser or a dispatch table
HIGHCode injectioncode.eval_exec · packages/mcp-server/src/tools/check-health.ts:605
F-02 Code injectionCWE-78 · CWE-94 · CWE-95Layer L1
(val.includes('function(') && val.includes('module'))
Why
evaluates text as code
Fix
remove; use a parser or a dispatch table
HIGHCode injectioncode.eval_exec · packages/mcp-server/src/tools/eval.ts:5704
F-02 Code injectionCWE-78 · CWE-94 · CWE-95Layer L1
'- ⚠ `node.retainedSize` / `node.retained_size` THROW inside eval (they read back ~0 on some loads). Use `helpers.retainedSize(id)` / `helpers.retainedSizes([ids])` / `helpers.aggregateRetained([ids])
Why
evaluates text as code
Fix
remove; use a parser or a dispatch table
MEDIUMHard-coded secretsinv.env_committed · website/.env
F-03 Hard-coded secretsCWE-798 · CWE-321Layer L0
.env
Why
a real .env in the package
Fix
ship .env.example with placeholders only
MEDIUMNetwork egressnet.raw_ip · packages/mcp-server/src/cdp-capture.ts:208
F-04 Network egressCWE-200 · CWE-319Layer L1
const endpoint = `http://127.0.0.1:${port}/json`;
Why
No further detail recorded for this rule.
Fix
—
MEDIUMNetwork egressnet.raw_ip · packages/mcp-server/src/cdp-capture.ts:237
F-04 Network egressCWE-200 · CWE-319Layer L1
const endpoint = `http://127.0.0.1:${port}/json`;
Why
No further detail recorded for this rule.
Fix
—
MEDIUMHard-coded secretssecret.generic · website/docusaurus.config.js:235
F-03 Hard-coded secretsCWE-798 · CWE-321Layer L1

Excerpt withheld: it is a secret, and we never print one.

Why
No further detail recorded for this rule.
Fix
—
LOWInventory / provenanceinv.hidden_file · .watchmanconfig
F-13 Inventory / provenanceCWE-1104Layer L0
.watchmanconfig
Why
hidden member outside the usual dotfiles
Fix
review its purpose
LOWInventory / provenanceinv.hidden_file · packages/mcp-server/bin/.eslintrc.js
F-13 Inventory / provenanceCWE-1104Layer L0
.eslintrc.js
Why
hidden member outside the usual dotfiles
Fix
review its purpose
LOWInventory / provenanceinv.hidden_file · website/.env
F-13 Inventory / provenanceCWE-1104Layer L0
.env
Why
hidden member outside the usual dotfiles
Fix
review its purpose
LOWInventory / provenanceinv.hidden_file · website/.prettierignore
F-13 Inventory / provenanceCWE-1104Layer L0
.prettierignore
Why
hidden member outside the usual dotfiles
Fix
review its purpose
LOWInventory / provenanceinv.hidden_file · website/static/.nojekyll
F-13 Inventory / provenanceCWE-1104Layer L0
.nojekyll
Why
hidden member outside the usual dotfiles
Fix
review its purpose
LOWCode injectioncode.eval_exec · packages/e2e/src/E2EInteractionManager.ts:159
F-02 Code injectionCWE-78 · CWE-94 · CWE-95Layer L1
eval(script);
Why
evaluates text as code
Fix
remove; use a parser or a dispatch table
LOWInsecure cryptocrypto.weak_hash · packages/mcp-server/src/guardrail.ts:369
F-09 Insecure cryptoCWE-327 · CWE-338Layer L1
const key = `para:${crypto.createHash('sha1').update(t).digest('hex')}`;
Why
No further detail recorded for this rule.
Fix
—
LOWInsecure cryptocrypto.weak_hash · packages/mcp-server/src/tools/finding-index.ts:490
F-09 Insecure cryptoCWE-327 · CWE-338Layer L1
return crypto.createHash('sha1').update(material).digest('hex').slice(0, 12);
Why
No further detail recorded for this rule.
Fix
—
LOWInsecure cryptocrypto.weak_hash · packages/mcp-server/src/tools/finding-index.ts:1147
F-09 Insecure cryptoCWE-327 · CWE-338Layer L1
.createHash('sha1')
Why
No further detail recorded for this rule.
Fix
—
LOWFilesystem / pathfs.traversal · packages/api/src/__tests__/API/E2EBasicAnalysis.test.ts:13
F-05 Filesystem / pathCWE-22 · CWE-59Layer L1
import {run} from '../../index';
Why
No further detail recorded for this rule.
Fix
—
LOWFilesystem / pathfs.traversal · packages/api/src/__tests__/API/E2EDetachedDOMAnalysis.test.ts:14
F-05 Filesystem / pathCWE-22 · CWE-59Layer L1
import {DetachedDOMElementAnalysis, warmupAndTakeSnapshots} from '../../index';
Why
No further detail recorded for this rule.
Fix
—
LOWFilesystem / pathfs.traversal · packages/api/src/__tests__/API/E2EDuplicateObjectAnalysis.test.ts:10
F-05 Filesystem / pathCWE-22 · CWE-59Layer L1
import type {BrowserInteractionResultReader} from '../../index';
Why
No further detail recorded for this rule.
Fix
—
LOWFilesystem / pathfs.traversal · packages/api/src/__tests__/API/E2EDuplicateObjectAnalysis.test.ts:14
F-05 Filesystem / pathCWE-22 · CWE-59Layer L1
import {ObjectShallowAnalysis, warmupAndTakeSnapshots} from '../../index';
Why
No further detail recorded for this rule.
Fix
—
LOWFilesystem / pathfs.traversal · packages/api/src/__tests__/API/E2EFindLeaks.example.ts:15
F-05 Filesystem / pathCWE-22 · CWE-59Layer L1
import {run} from '../../index';
Why
No further detail recorded for this rule.
Fix
—
LOWObfuscation / stealthobf.decode_call · packages/e2e/src/NetworkManager.ts:121
F-07 Obfuscation / stealthCWE-506 · CWE-94Layer L1
? atob(response.body)
Why
No further detail recorded for this rule.
Fix
—
LOWSupply chainsupply.unpinned · package.json
F-08 Supply chainCWE-829 · CWE-1357Layer L1
ansi, babar, blessed, chalk, fs-extra, minimist, string-width, util.promisify
Why
23 dependency range(s) float
Fix
pin exact versions or ship a lockfile

Tools it exposes

174 declared in source · 0 destructive

149 read25 write0 destructive
ToolWhat it doesRisk
memlab_analysis_batteryRun a roundwrite
memlab_analyze_runPoint at a leak huntwrite
memlab_array_group_byIterate through array (or Map/Set) elements, extract a named property from each, andwrite
memlab_batchRun several memlab tools against ONE snapshot load, in order, and return all their outputs together.write
memlab_cache_inventoryInventory of MODULE-LEVEL collections (Map / Set / WeakMap / Array) — held directly by a modulewrite
memlab_cache_sole_retainerModule-level caches (Map / Set / Array held by a module scope or by an exported function, such as a memoizerwrite
memlab_check_healthRun all heuristic health checks in one call and return a prioritized list of findings. This is the recommended first step after loading a snapshot — it replaces calling 4-5 individual tools to triage.write
memlab_evalExecute arbitrary JavaScript code against the loaded heap snapshot.write
memlab_eval_acrossRun ONEwrite
memlab_find_by_shapeFind all objects that have a specific set of property names (multi-property intersection search). Unlike find_by_property which searches for a single property, this finds objects matching awrite
memlab_ladder_probeRun ONE numeric probe across an ORDERED ladder of snapshots and report the series, the per-cycle rate and a linear fit.write
memlab_map_entriesEnumerate the entries of ONE Map or Set (node_id is REQUIRED — this is not a global scan). The companion to memlab_weakmap_entries for strongly-held collections. The KEYS are usually the whole diagnosis of an unbounded cache: a Store/singleton Map keyed bywrite
memlab_probesSave named probes for an app once, and have the ladder tools run them by themselves. A probe iswrite
memlab_prune_runReclaim the disk a roundwrite
memlab_rate_modelIs this population UNBOUNDED, or is it a working set whose size is just a function of how fast the harness drove?\n\nwrite
memlab_react_update_queuesThe React eager-bailout leak family as one report. Awrite
memlab_reportsRun curated memory analysis reports — like Chrome DevTools Memory panel views. Usewrite
memlab_shape_census_diffPer-SHAPE growth across a LADDER: group objects by their property set at every rung and report the series, the per-cycle rate and the fit — the shape-level equivalent ofwrite
memlab_stale_collectionsFind Map, Set, and Array collections holding stale references. Detects: (1) detached DOM /write
memlab_start_jobStart ANY memlab tool as a background job and return a job id at once; collect the result withwrite
memlab_switch_matrixProve the judges can go red: run every invariant judge (aswrite
memlab_timersPending timers and scheduled tasks, grouped by the function they will run and what that function CAPTURES. Finds React Scheduler task records by shape (write
memlab_validate_findingCheck a finding write-up against the evidence its claim needs, BEFORE it is filed. The finding is JSON:write
memlab_what_ifIf this set of objects were freed, how many bytes would actually come back? Reports the dominator-deduped retained size of a population — the bytes that go away when it does, with nothing double-counted and nothing counted that is also reachable another way.\n\nwrite
stale_collectionsFind Map/Set/Array collections holding references to detached or unmounted nodeswrite
class_histogramShow instance count and total self size per class/constructor nameread
detached_domFind detached DOM elements still retained in memory — common source of leaksread
duplicated_stringsFind duplicated string instances ranked by total size — common source of wasteread
global_variablesFind non-built-in global variables on Window, sorted by retained sizeread
largest_objectsFind the top objects by retained size in the heapread
memlab_ab_compareJudge an A/B round (read
memlab_aggregateAggregate heap nodes by type, name, or name prefix. Returns grouped statistics (count, total self size, aggregate retained size) sorted by retained size. Retained size uses dominator-aware aggregation (no double-counting).read
memlab_allocation_sitesWHO ALLOCATED these objects: group live objects by the JavaScript stack that allocated them, from a capture recorded with allocation tracking (a .heaptimeline, or a snapshot taken while tracking was on).read
memlab_anonymize_snapshotNo description in the sourceread
memlab_app_configRead the feature flags and config values the app was actually running with, out of the snapshot itself.\n\nread
memlab_app_heapReport APP-ATTRIBUTABLE heap: total self size minus bundle/code memory, minus dev-build artifacts, minus measurement-harness content — the part of the heap that is actually the application.read
memlab_artifact_budgetONE number forread
memlab_async_censusCensus PENDING ASYNC WORK: React-scheduler task queues (with a live-vs-cancelled split), timer callback closures, and unsettled Promises with their owner shapes.read
memlab_auto_investigateNo description in the sourceread
memlab_battery_statusReport on a battery started withread
memlab_blink_native_censusNative (Blink) classes that grow across a ladder —read
memlab_bound_functionsBound functions (read
memlab_build_pair_compareLine up a DEV-build round and a PRODUCTION-build round of the same interaction and say, per population, whether its growth is dev-only, production-real or production-only.read
memlab_build_provenanceAssert that the build a snapshot came from actually contains the change you are measuring, BEFORE reading any before/after number. Scans the heap for marker strings from the new revision (read
memlab_cache_analysisNo description in the sourceread
memlab_calibrate_judgesNo description in the sourceread
memlab_captureTake fresh heap snapshots of a LIVE page and/or its dedicated WORKERS over the Chrome DevTools Protocol, without a harness script.read
memlab_censusCount several named POPULATIONS across every rung of a ladder in ONE pass per snapshot, and report each oneread
memlab_census_diffTake the detached-DOM and listener-record census at TWO rungs and diff them per class / per callback in one call.read
memlab_chain_walkWalk a repeated linked structure from a starting node and report how deep it goes and what it holds — for closure chains (read
memlab_class_histogramShow per-constructor/class instance count and total self size. Useful for identifying which types of objects dominate memory.read
memlab_closure_inspectionInspect a closure (function) OR a suspended generator/async frame to show its captured/live variables.read
memlab_co_holdersFind collections that hold the SAME objects or are keyed by the same keys: Maps, Sets and WeakMaps (Arrays withread
memlab_collection_diffFind WHICH collections grew across a snapshot ladder, WITHOUT being told their names. Censuses every Map/Set/WeakMap/WeakSet/Array on every rung, keys each by a per-capture-STABLEread
memlab_collection_trendTrack named collections ACROSS a snapshot ladder: entry counts per rung, with per-cycle growth. memlab_cache_analysis, memlab_stale_collections and memlab_growth_signals all answerread
memlab_compare_roundsCompare N rounds of a sweep and surface the patterns no single round shows.\n\nread
memlab_console_retentionReport what an attached DevTools console is keeping alive, and answer whether a specific object depends on it. DevTools holds a global handle on every object passed toread
memlab_count_populationCount one population by SEVERAL independent methods and report when they disagree.\n\nread
memlab_dead_context_variablesFind captured variables that no live code can read, heap-wide. Closures created in one scope share one Context, so a variable read only by a callback that is gone stays alive as long as ANY sibling closure does.read
memlab_detached_domNo description in the sourceread
memlab_dev_artifactsNo description in the sourceread
memlab_dev_subtracted_deltaPer-class growth fromread
memlab_diff_snapshotsCompare two heap snapshots: classes that grew, shrunk, appeared or disappeared betweenread
memlab_dom_auditBudget the ATTACHED DOM and rank the surfaces worth virtualizing. This is an OPTIMIZATION tool, not a leak tool — the elements it reports are all live and correctly retained; the point is that there are too many of them.\n\nread
memlab_dominator_attributionGiven several candidate retainers, measure how much of a population each one actually DOMINATES — i.e. what would really be freed by releasing it. Answersread
memlab_dominator_chainNo description in the sourceread
memlab_dominator_subtreeShow the direct children in the dominator tree for a given node — i.e., objects whose retained size is exclusively attributed to this node. These are the objects that would be freed if this node were garbage collected. Useful for understanding what composes a large retained size.read
memlab_drill_to_heavy_leafFollow the retained size DOWN from one node to the object actually holding it, in a single call.\n\nread
memlab_duplicate_objectsNo description in the sourceread
memlab_duplicated_stringsFind duplicated string instances in the heap. Shows strings that appear multiple times, ranked by total retained size — a common source of memory waste. Use after memlab_class_histogram shows high string counts.read
memlab_element_censusRetained React elements and fibers by component type. Fibers are split into mounted (reached by the committed tree from a root), alternate (a mounted fiberread
memlab_error_callsitesWhere retained Error objects were created, read from the stack frames V8 captured on each Error (a private symbol holding each frameread
memlab_event_listener_leaksDetect EventEmitter-style listener accumulation — the #1 cause of memory leaks inread
memlab_event_registryDetector for per-model event registries (Backbone/Marionette/observer style): objects mapping event names to arrays of {callback, context} listeners, e.g.read
memlab_explain_deltaExplain WHERE a heap grew between two loaded snapshots, attributed by dominator (who owns the new bytes) rather than by class (what the new bytes are).read
memlab_external_stringsAttributeread
memlab_field_release_impactIf a fix nulls this property, how many bytes actually come back — and is the property the ONLY reference?\n\nread
memlab_find_by_propertyFind all objects that have a specific property name (outgoing edge). Useful for identifyingread
memlab_find_nodes_by_classNo description in the sourceread
memlab_finding_indexFingerprint a leak finding by its retainer path and check it against findings from previous rounds, so a hunt does not spend itself re-discovering a known or already-fixed leak.read
memlab_fix_knowledge_checkBefore writing a leak fix, answer true/false questions on the beliefs that most often send a fix the wrong way: a WeakMap hop read as the cause, a field nulled on a copy React keeps, a cache filling up read as a leak, a dev-only chain, a cleanup removed with a different function.read
memlab_for_eachStructured map/filter/reduce over all heap nodes.read
memlab_framework_buffersSize the framework buffers that recur in every hunt on the same stack, in ONE call, minification-safe. Generic probes: in-memoryread
memlab_gate_fingerprintDecide which EXPERIMENT ARM the loaded capture is in by comparing it against a capture of the other arm, for gatesread
memlab_get_nodeLook up a heap node by its numeric ID. Returns full details including size, type, detachedness (attached / detached / unknown), distance from the root in hops, dominator, location, and string value if applicable.read
memlab_get_propertyLook up a specific property (outgoing edge) of a heap node by name and return the target node with full details. Useful for traversing the object graph step by step (e.g., get the __proto__, stateNode, or memoizedState of a node).read
memlab_get_referencesGet outgoing edges (references) from a heap node, sorted by target retained size (orread
memlab_get_referrersGet incoming edges (referrers) to a heap node, sorted by source retained size (orread
memlab_get_stringResolve any V8 string node to its full text value. Handles all V8 string encodings:read
memlab_get_valueDecode the actual numeric value of a V8 SMI (Small Integer) or heap number node.read
memlab_global_variablesFind non-built-in global variables on the Window object (browser) or global object (Node.js), sorted by retained size. These are application-specific globals that may indicate memory issues.read
memlab_growth_cohortGroup the NEWEST instances of a population by who holds them — top referrer edges, top shapes, top root-path heads, and their dominator-deduped retained size.\n\nread
memlab_growth_signalsNo description in the sourceread
memlab_hunt_reportRender a leak huntread
memlab_hypothesisTest one hypothesis against EVERY rung of a snapshot ladder in a single call: supply a JavaScript predicate over heap nodes and get its match count, total self size, and trend per rung.read
memlab_id_space_auditNo description in the sourceread
memlab_identifyName a minified structure from its property shape. In a production bundle nearly every class isread
memlab_identity_diffSame objects, or just the same number of objects? Matches a population across two snapshots by CONTENT rather than by node id. Use it across isolates (a reload, another session); between captures of ONE isolate, memlab_diff_snapshots matches by V8 object id, which is exact.\n\nread
memlab_intern_opportunitiesNo description in the sourceread
memlab_island_doorsList EVERY production-reachable reference into an island, not just the shortest one.read
memlab_job_statusReport on a job started withread
memlab_judgesJudge a leak-hunt round against its stated INVARIANTS — plain-words claims about what must hold once the app is at rest — instead of readingread
memlab_ladderName a snapshot ladder once and reference it asread
memlab_largest_objectsFind the top N objects by retained size in the loaded heap snapshot. Filters out internal/meta objects. Use node_type to filter to a specific type (e.g.,read
memlab_leak_reportNo description in the sourceread
memlab_live_evalEvaluate one JavaScript expression in a LIVE page over the Chrome DevTools Protocol and return its JSON value, to check a snapshot hypothesis against the running app (is a global defined, how long is a queue now, which keys does a debug object have) without a harness script.read
memlab_load_snapshotNo description in the sourceread
memlab_match_objectFind the object in ANOTHER loaded snapshot that corresponds to a given object in the current one.read
memlab_memory_partitionAnswerread
memlab_metricRecord a measurement under a name and keep it across sessions, so a number measured today can be compared with one measured next week.\n\nread
memlab_model_censusPer MODEL TYPE in Backbone-style collections (objects carryingread
memlab_model_duplicatesModel instances that share an identity value (e.g. a message id atread
memlab_module_attributionAttribute heap bytes to the MODULE that owns them, by walking the dominator tree up to the nearest module-registry export or module SCOPE (the top-level closure context a Hasteread
memlab_module_presentPre-flight: does a class/constructor appear in this heap AT ALL? Answersread
memlab_module_sourceThe SERVED source of one module, read from the snapshot: itsread
memlab_native_contextsSplit ONE snapshot by JavaScript realm: the page, each iframe, extension isolated worlds, detached windows, Noderead
memlab_next_measurementWhat can the snapshots currently loaded actually support — and which capture would change that?\n\nread
memlab_object_cost_breakdownNo description in the sourceread
memlab_object_shapeShow the shape/structure of one or more heap objects: all named properties with target node types and sizes. Filters out internal/hidden edges to show only user-visible properties. Supports batch inspection via node_ids to compare multiple objects side-by-side in a single call.read
memlab_object_urlsUnrevokedread
memlab_overlap_matrixDo these classes retain the SAME bytes? Reports pairwise overlap in dominator-deduped retained size, plus theread
memlab_path_treeShow WHERE the memory sits as a tree: the shortest-retainer-path tree (each object hangs under the object on its shortest path from a GC root) with the app bytes of every subtree, expanded wherever a branch holds at leastread
memlab_pending_promisesUnsettled Promises ranked by REACTION-CHAIN length, with retained size, the native (Blink task-attribution / soft-navigation) memory their reactions keep alive, and the production owner path. One promise that never settles keeps everyread
memlab_persistent_structuresDetect persistent / structurally-shared data structures (Immutable.js Maps, Lists and trie nodes; Immer drafts; RxJS-style Subscriptions) and report how many VERSIONS are retained, with dominator-deduped bytes. Use it whenever a leak report shows growth in short minified classes (read
memlab_pinch_pointsFindread
memlab_population_diffCompare the COMPOSITION of a population between two loaded snapshots, not just its size. Equal totals are not identity: a round that strands N objects and frees N others reports the same count at both ends, and reading that asread
memlab_population_vs_ownersDecide whether a population is STRUCTURAL (about one record per live owner) or ACCUMULATING (owners are collecting records), by counting both and reporting the ratio.read
memlab_positive_controlsMeasure the round\read
memlab_property_distributionNo description in the sourceread
memlab_property_namesIndex the heapread
memlab_query_objectsQuery heap objects by any combination of filters in ONE call, instead of chaining class search, node search and property inspection: class or node name (regex), node type, an outgoing property or edge name (regex), detached or not, the owning realm (read
memlab_quick_diagnosisNo description in the sourceread
memlab_rate_tableBuild the per-surface, per-cycle rate table for ONE metric across several rounds — the artifact that says which surface to fix first.\n\nread
memlab_react_ownersName the React COMPONENT behind a population of plainread
memlab_realm_duplicationFind what is loaded TWICE across realms: given a page snapshot and its worker snapshots (memlab_capture writes them), list every module present in more than one realm with its state bytes in each realm, and the bytes that would go away if only the largest copy remained.read
memlab_realm_summaryCompare the heaps of several REALMS captured at the same moment — a page plus its dedicated workers (memlab_capture writes them) — as one table: per realm, app memory, bundle text, loaded code and dev-only bytes, plus the WebAssembly modules and SharedArrayBuffers it holds.read
memlab_referrer_summaryGroup all incoming references (referrers) of a node by edge name and source class.read
memlab_replicateAsk whether a measured effect REPRODUCES across two or more independently-driven runs, and refuse to call it real until it does.read
memlab_retained_byHow much of the heap is retained ONLY through each kind of retainer: closure contexts, detached DOM nodes, the DevTools console, and event handler functions.read
memlab_retainer_diffA population grew between two snapshots — did it grow along the SAME retention path, or did a new one appear?\n\nread
memlab_retainer_layersCounterfactual retainer analysis: answerread
memlab_retainer_summaryNo description in the sourceread
memlab_retainer_traceNo description in the sourceread
memlab_retention_windowsList the retention windows this app has — timeouts, TTLs, cleanup intervals, eviction ages — before calling any growth unbounded.\n\nread
memlab_round_auditRead a leak huntread
memlab_round_digestThe verdict table for a finished leak-hunt round, and nothing else.read
memlab_scope_chainsChains of contexts that share one ScopeInfo — each call of a function pinning the previous callread
memlab_script_censusCensus the retained JS SOURCE TEXT in the heap, and flag the same bundle being retained more than once.read
memlab_search_nodesGeneral-purpose search for heap nodes by combining filters: name pattern (regex), node type, minimum retained/self size, and detachment status. Results sorted by retained size. Supports count-only and ids-only modes for large result sets.read
memlab_search_stringsSearch the content (stringValue) of all string nodes in the heap snapshot.read
memlab_sequence_analysisTrend analysis across an ORDERED sequence of >=2 heap snapshots (the canonicalread
memlab_server_statusCheap liveness/health check: returns instantly with the server VERSION, process RSS, uptime, and the resident snapshots. The version answersread
memlab_settle_checkSeparate RETENTION from in-flight BACKLOG by comparing a busy snapshot against one captured after the app settled (idle + forced GC).read
memlab_shape_histogramGroup objects by their property structure (shape/hidden class). Objects with the same set of property names are grouped together, revealing distinct record types. Much more useful than class_histogram when most objects are genericread
memlab_sliced_stringsNo description in the sourceread
memlab_snapshot_budget_plannerWhich rungs of this ladder can you actually hold in memory at once, and which should be probed transiently?\n\nread
memlab_snapshot_headerPeek a .heapsnapshotread
memlab_snapshot_summaryGet an overview of the loaded heap snapshot: total nodes, edges, size, and per-node-type breakdown with count and self size.read
memlab_snapshotsNo description in the sourceread
memlab_source_for_findingA findingread
memlab_source_for_nodeWhich MODULE\read
memlab_sparse_elementsFind integer-keyed objects and arrays whose ELEMENTS BACKING STORE is mostly holes — memory V8 has allocated and the application never uses. This is the waste a class histogram cannot see: the store is aread
memlab_stale_refsReact refs (read
memlab_string_patternsGroup strings by common prefix and show aggregate counts and sizes. Instead of seeing 20 individual histogram entries for CSV strings that all start with the same header, see them grouped:read
memlab_string_prefix_censusCount strings by PREFIX on every rung of a ladder —read
memlab_sweep_digestNo description in the sourceread
memlab_synthetic_controlsRead a sizing roundread
memlab_toolsIndex of every memlab tool, grouped by the QUESTION it answers (read
memlab_trace_allRetainer-trace an ENTIRE population and cluster the paths server-side, instead of sampling a handful and hoping they are representative.\n\nread
memlab_trace_dominatorsNo description in the sourceread
memlab_unit_costHow much memory does ONE of these actually cost? Reports dominator-deduped retained bytes per instance for a class or an object shape,read
memlab_verify_fixDecide whether a fix actually worked, by comparing the per-cycle growth RATE of one metric between a before ladder and an after ladder. hunt_runner --ab drives both arms but nothing analyses them, which is why fix write-ups stall atread
memlab_weakmap_entriesNo description in the sourceread
memlab_weakref_censusCensus every WeakRef in the heap, split LIVE vs EMPTY (referent already collected), and group by the shape of the object holding them.read

Audit history

  1. ✕BLOCK F 53 / 100

    First audit · d8f1c4ee2a62

README badge

Badges show the current verdict, BLOCK included

ModelsAtlas: BLOCK FMODELSATLASBLOCK · F

A badge cannot be hidden by the maintainer while the verdict is BLOCK. Fix the findings, push, and the re-audit updates it.

Questions about Memlab MCP server

What is the Memlab MCP server?
A framework for finding JavaScript memory leaks and analyzing heap snapshots
What tools does Memlab expose?
174 in total: 149 read-only, 25 that write, and 0 that can delete or overwrite. Every one is listed on this page with its risk.
Is Memlab safe to connect to an agent?
No — not without reading the findings first. The audit graded it F (53/100) and found 4 critical or high issues in the source. Each one is listed on this page with the file and line it is on.
What credentials does Memlab need?
No credential environment variables were found in its source, so it appears to need none.
How does Memlab run?
It speaks stdio, so it runs as a local process your client starts. It is published on npm as memlab-website at 1.0.1.
How current is this page?
The grade is for one exact copy of the source (d8f1c4ee2a62), read on 2026-11-13. The repository is watched and re-audited when it changes.
Which Memlab MCP server is the right one?
2 unrelated servers share the name “Memlab”; compare them side by side before you install.
I already installed Memlab. What should I do?
Remove it from your client's MCP configuration, then rotate any API keys and tokens that were in your environment while it ran.
Can the verdict change?
Yes. The repository is watched and re-audited when its source changes. If the findings are removed the verdict updates, and the history on this page shows it.

Sources

  • meta/memlab on GitHub — the source we read, its licence, stars and activityObserved · 13 Nov 2026
  • ModelsAtlas trust audit — BLOCK verdict for commit d8f1c4ee2a62Observed · 13 Nov 2026

Spotted something wrong? Report a correction · Methodology

Keep going in your AI

Opens with this page as the source. We add nothing else to the prompt.