@lensmcp/protocol-types 1.21.5 → 1.22.0

package/index.d.ts

@@ -9,3 +9,6 @@ export * from './lib/producer-health.js';
 export * from './lib/resources.js';
 export * from './lib/tokens.js';
 export * from './lib/capture-demand.js';
+export * from './lib/bounded-clone.js';
+export * from './lib/bounded-map.js';
+export * from './lib/flood-guard.js';

package/index.js

@@ -1 +1 @@
-"use strict";export*from"./lib/schema-version.js";export*from"./lib/source-location.js";export*from"./lib/context.js";export*from"./lib/event.js";export*from"./lib/node.js";export*from"./lib/edge.js";export*from"./lib/attributes.js";export*from"./lib/producer-health.js";export*from"./lib/resources.js";export*from"./lib/tokens.js";export*from"./lib/capture-demand.js";
+"use strict";export*from"./lib/schema-version.js";export*from"./lib/source-location.js";export*from"./lib/context.js";export*from"./lib/event.js";export*from"./lib/node.js";export*from"./lib/edge.js";export*from"./lib/attributes.js";export*from"./lib/producer-health.js";export*from"./lib/resources.js";export*from"./lib/tokens.js";export*from"./lib/capture-demand.js";export*from"./lib/bounded-clone.js";export*from"./lib/bounded-map.js";export*from"./lib/flood-guard.js";

package/lib/bounded-clone.d.ts

@@ -0,0 +1,153 @@
+/**
+ * Budgeted structural clone — the ONE bounded-copy implementation, shared by
+ * every producer and consumer that must not let an unbounded payload through.
+ *
+ * WHY IT LIVES HERE: this walk was written for the CONSUMER side (`@lensmcp/storage`
+ * clamps `raw` at ingest so the ring buffer, flow index and 20 reducers cannot all
+ * hold the same multi-megabyte object). But the expensive half of that payload is
+ * paid long before a consumer sees it — the producer serializes it, ships it over
+ * the wire and appends it to the bus file. Bounding it at the PRODUCER needs the
+ * same walk, and a second copy of these rules would drift from the first. Both
+ * sides already depend on `@lensmcp/protocol-types`, so it is the only home that
+ * adds no dependency edge, and it is deliberately free of runtime imports so a
+ * browser bundle can carry it.
+ *
+ * THE PROPERTY THAT MATTERS: nothing here ever serializes the whole value to
+ * measure or copy it. `JSON.parse(JSON.stringify(v))` — the idiom this replaces —
+ * allocates the entire payload twice just to find out it was 4 MB. The walk sums
+ * as it descends and stops at the budget, so a bounded clone of a huge object
+ * costs a handful of property reads rather than the object.
+ *
+ * CORRECTNESS: consumers branch on discriminators that live inside the payload
+ * (`raw.kind`, `update.storeId`, `render.componentInstanceId`), so the clamp NEVER
+ * drops a key and never swaps a container for a scalar: it keeps every cheap entry
+ * unconditionally, preserves object/array shape, and shrinks only the large leaves.
+ * Past the budget it degrades to a SKELETON (scalars kept, arrays emptied,
+ * containers still containers). The only wholesale replacement is at the recursion
+ * ceiling, and it is a marker OBJECT — so a read off it yields `undefined`, never
+ * a TypeError.
+ */
+/**
+ * Per-event `raw` budget. Sits above the measured p99.9 (15.8 KiB) so no
+ * normal diagnostic payload is ever touched, and far below the pathological
+ * ones (87 KiB visual frames, an 8.27 MB valtio preview).
+ */
+export declare const DEFAULT_RAW_BYTE_LIMIT: number;
+/** Longest single string leaf kept intact (stack traces, base64 crops). */
+export declare const DEFAULT_MAX_STRING_BYTES: number;
+/**
+ * Longest array kept intact. Bounds the unbounded ones — `raw.report.chunks[].modules[]`,
+ * `raw.frame.changedNodes[]`, `raw.render.why[]` — while leaving every array
+ * observed in practice (≤ 64 entries) whole.
+ */
+export declare const DEFAULT_MAX_ARRAY_ITEMS = 64;
+/**
+ * Recursion ceiling. Doubles as the cycle guard: events arriving over the
+ * file/UDS/UDP transports are `JSON.parse` output (acyclic), but an
+ * in-process producer could hand us a cyclic object, and a `Set`-based guard
+ * would allocate on every event. A depth cap is total and allocation-free.
+ */
+export declare const DEFAULT_MAX_DEPTH = 12;
+/**
+ * An entry estimated at or below this is "cheap" and kept unconditionally.
+ * This is the correctness lever: `kind`, `storeId`, `path`, `componentName`,
+ * `durationMs`, `floodSuppressed` and every other discriminator/identifier
+ * are all far below it, so they survive regardless of how the budget runs out.
+ */
+export declare const CHEAP_ENTRY_BYTES = 512;
+/** Cost charged when ACCOUNTING stops at the depth ceiling. */
+export declare const NOMINAL_DEEP_BYTES = 32;
+/** Depth allowed when reporting a stubbed value's true size (slow path only). */
+export declare const DEEP_REPORT_DEPTH = 64;
+/** String prefix kept once the budget is spent (skeleton mode). */
+export declare const SKELETON_STRING_BYTES = 256;
+/** How many truncated paths the marker lists, so the marker stays small. */
+export declare const MAX_RECORDED_PATHS = 20;
+/** Key added to a truncated `raw` root describing what was cut. */
+export declare const TRUNCATION_MARKER_KEY = "__lensmcpTruncation";
+/** Key identifying a value that was replaced wholesale by a marker stub. */
+export declare const TRUNCATED_VALUE_KEY = "__lensmcpTruncated";
+/** Shape of the `raw[TRUNCATION_MARKER_KEY]` marker. */
+export interface TruncationMarker {
+    truncated: true;
+    /** Approximate serialized size of the ORIGINAL payload. */
+    originalBytes: number;
+    /** Approximate serialized size of what was kept. */
+    keptBytes: number;
+    /** Paths that were shrunk, capped at {@link MAX_RECORDED_PATHS}. */
+    paths: string[];
+}
+export interface ClampEventOptions {
+    /** Per-event `raw` budget in bytes. Default {@link DEFAULT_RAW_BYTE_LIMIT}. */
+    rawByteLimit?: number;
+    /** Longest string leaf kept intact. Default 4 KiB. */
+    maxStringBytes?: number;
+    /** Longest array kept intact. Default 64. */
+    maxArrayItems?: number;
+    /** Recursion ceiling / cycle guard. Default 12. */
+    maxDepth?: number;
+}
+/**
+ * Approximate the serialized JSON size of a value WITHOUT serializing it.
+ *
+ * `JSON.stringify(x).length` allocates the entire string just to measure it —
+ * an allocation storm when it runs per event at hundreds of events/second,
+ * and pathological on the very payloads we are trying to bound (stringifying
+ * an 8 MB preview to discover it is 8 MB). This walks the structure and sums
+ * instead, and stops early once `budget` is exceeded, so the common case
+ * costs a handful of property reads.
+ *
+ * @param budget Stop as soon as the running total exceeds this. The return
+ *   value is then a LOWER BOUND, which is all a threshold test needs. Pass
+ *   `Number.POSITIVE_INFINITY` when the exact figure is wanted (reporting).
+ */
+export declare function estimateJsonBytes(value: unknown, budget?: number, maxDepth?: number): number;
+/**
+ * Is `value` bigger than `budget` — treating "too deep to measure" as YES?
+ *
+ * WHY this exists separately from {@link estimateJsonBytes}: the depth ceiling
+ * makes a deeply nested payload look SMALL, and a size estimate that
+ * under-reports defeats the guard that reads it. Measured while building this:
+ * an 80 KB string nested 30 levels deep estimated at 1 300 B, so the clamp
+ * never fired and the payload was retained whole — a hole big enough to
+ * reintroduce the leak through one deeply nested `preview`. For an admission
+ * DECISION the honest answer to "I can't see the bottom" is "assume it is too
+ * big"; the clamp then descends and stubs at the ceiling. Accounting keeps the
+ * bounded estimate, and is only ever applied to already-clamped events.
+ */
+export declare function exceedsJsonByteBudget(value: unknown, budget: number, maxDepth?: number): boolean;
+export interface ClampContext {
+    budget: number;
+    maxStringBytes: number;
+    maxArrayItems: number;
+    paths: string[];
+    truncatedAnything: boolean;
+}
+export declare function clampValue(value: unknown, ctx: ClampContext, depthLeft: number, path: string): unknown;
+/** What {@link boundedClone} produced, and what it cost. */
+export interface BoundedCloneResult<T = unknown> {
+    /** The bounded copy. A plain JSON-safe structure — never the input by reference. */
+    value: T;
+    /** Did anything get shrunk? */
+    truncated: boolean;
+    /** Approximate serialized bytes of the ORIGINAL (a full walk, slow path only). */
+    originalBytes: number;
+    /** Approximate serialized bytes of what was kept. */
+    keptBytes: number;
+    /** Paths that were shrunk, capped at {@link MAX_RECORDED_PATHS}. */
+    paths: string[];
+}
+/**
+ * Clone `value` into a plain structure that fits a byte budget.
+ *
+ * This is the producer-side entry point. Use it wherever the old idiom was
+ * `JSON.parse(JSON.stringify(v))` on a value whose size you do not control —
+ * that idiom is unbounded in BOTH directions (it allocates the full string and
+ * then the full clone), which is how a single state update became a 4.2 MB
+ * event on the bus.
+ *
+ * Returns `{ value: undefined, truncated: false }` for a budget of `0`, so a
+ * caller can disable previews entirely with one config value rather than a
+ * branch at every call site.
+ */
+export declare function boundedClone<T = unknown>(value: unknown, opts?: ClampEventOptions): BoundedCloneResult<T | undefined>;

package/lib/bounded-clone.js

@@ -0,0 +1 @@
+"use strict";var T=Object.defineProperty;var i=(e,t)=>T(e,"name",{value:t,configurable:!0});var h=Object.defineProperty,l=i((e,t)=>h(e,"name",{value:t,configurable:!0}),"_");export const DEFAULT_RAW_BYTE_LIMIT=32768,DEFAULT_MAX_STRING_BYTES=4096,DEFAULT_MAX_ARRAY_ITEMS=64,DEFAULT_MAX_DEPTH=12,CHEAP_ENTRY_BYTES=512,NOMINAL_DEEP_BYTES=32,DEEP_REPORT_DEPTH=64,SKELETON_STRING_BYTES=256,MAX_RECORDED_PATHS=20,TRUNCATION_MARKER_KEY="__lensmcpTruncation",TRUNCATED_VALUE_KEY="__lensmcpTruncated";export function estimateJsonBytes(e,t=Number.POSITIVE_INFINITY,r=12){return y(e,t,r,32)}i(estimateJsonBytes,"estimateJsonBytes"),l(estimateJsonBytes,"estimateJsonBytes");export function exceedsJsonByteBudget(e,t,r=12){return y(e,t,r,Number.POSITIVE_INFINITY)>t}i(exceedsJsonByteBudget,"exceedsJsonByteBudget"),l(exceedsJsonByteBudget,"exceedsJsonByteBudget");function y(e,t,r,a){switch(typeof e){case"undefined":case"function":case"symbol":return 0;case"boolean":return 5;case"number":return Number.isFinite(e)?8:4;case"bigint":return 20;case"string":return e.length+2;default:break}if(e===null)return 4;if(r<=0)return a;if(e instanceof Date)return 26;if(Array.isArray(e)){let n=2;for(let s=0;s<e.length;s++)if(n+=y(e[s],t-n,r-1,a)+1,n>t)return n;return n}let u=2;const o=e;for(const n in o){if(!Object.prototype.hasOwnProperty.call(o,n))continue;const s=y(o[n],t-u,r-1,a);if(s!==0&&(u+=n.length+4+s,u>t))return u}return u}i(y,"T"),l(y,"walk");function g(e,t){e.truncatedAnything=!0,e.paths.length<20&&e.paths.push(t||"<root>")}i(g,"A"),l(g,"record");function f(e,t,r){return g(e,r),{[TRUNCATED_VALUE_KEY]:!0,originalBytes:estimateJsonBytes(t,Number.POSITIVE_INFINITY,64)}}i(f,"I"),l(f,"stub");function p(e){if(e===null)return!0;const t=typeof e;return t==="number"||t==="boolean"||t==="string"||t==="bigint"}i(p,"y"),l(p,"isScalar");export function clampValue(e,t,r,a){if(typeof e=="string"){const u=t.budget<=0?256:t.maxStringBytes;if(e.length+2<=u)return t.budget-=e.length+2,e;const o=Math.max(0,u-64);return g(t,a),t.budget-=o,`${e.slice(0,o)}\u2026[lensmcp truncated: ${e.length-o} more chars]`}return e===null||typeof e!="object"?(t.budget-=y(e,Number.POSITIVE_INFINITY,1,32),e):r<=0?f(t,e,a):e instanceof Date?(t.budget-=26,e):Array.isArray(e)?m(e,t,r,a):b(e,t,r,a)}i(clampValue,"clampValue"),l(clampValue,"clampValue");function m(e,t,r,a){const u=[],o=Math.min(e.length,t.maxArrayItems);for(let n=0;n<o&&!(t.budget<=0);n++)u.push(clampValue(e[n],t,r-1,`${a}[${n}]`));return u.length<e.length&&g(t,`${a}[] (+${e.length-u.length} items dropped)`),u}i(m,"f"),l(m,"clampArray");function b(e,t,r,a){const u={};let o;const n=t.budget<=0;for(const s in e){if(!Object.prototype.hasOwnProperty.call(e,s))continue;const c=e[s],I=y(c,512,r-1,Number.POSITIVE_INFINITY);if(I<=512&&(!n||p(c))){u[s]=c,t.budget-=s.length+4+I;continue}(o??=[]).push({key:s,bytes:I})}if(!o)return u;o.sort((s,c)=>s.bytes===c.bytes?0:s.bytes<c.bytes?-1:1);for(const{key:s}of o){const c=a?`${a}.${s}`:s;u[s]=clampValue(e[s],t,r-1,c)}return u}i(b,"m"),l(b,"clampObject");export function boundedClone(e,t={}){const r=t.rawByteLimit??32768,a=t.maxDepth??12;if(r<=0)return{value:void 0,truncated:!1,originalBytes:0,keptBytes:0,paths:[]};if(e==null)return{value:e,truncated:!1,originalBytes:0,keptBytes:0,paths:[]};if(!exceedsJsonByteBudget(e,r,a)){const c=estimateJsonBytes(e,r,a),I={budget:r,maxStringBytes:t.maxStringBytes??4096,maxArrayItems:t.maxArrayItems??64,paths:[],truncatedAnything:!1};return{value:clampValue(e,I,a,""),truncated:!1,originalBytes:c,keptBytes:c,paths:[]}}const u=estimateJsonBytes(e,Number.POSITIVE_INFINITY,64),o={budget:r,maxStringBytes:t.maxStringBytes??4096,maxArrayItems:t.maxArrayItems??64,paths:[],truncatedAnything:!1},n=clampValue(e,o,a,""),s=estimateJsonBytes(n,Number.POSITIVE_INFINITY,a);if(o.truncatedAnything&&n!==null&&typeof n=="object"&&!Array.isArray(n)){const c={truncated:!0,originalBytes:u,keptBytes:s,paths:o.paths};n[TRUNCATION_MARKER_KEY]=c}return{value:n,truncated:o.truncatedAnything,originalBytes:u,keptBytes:s,paths:o.paths}}i(boundedClone,"boundedClone"),l(boundedClone,"boundedClone");

package/lib/bounded-map.d.ts

@@ -0,0 +1,32 @@
+/**
+ * A cap for a `Map` keyed on something a producer chooses.
+ *
+ * Several reducers kept a session-lifetime `Map` keyed on a value taken straight off an event —
+ * `raw.project`, `raw.tool`, a rule id — with no cap and no eviction. Because the bridge accepts a
+ * `publish` envelope with an arbitrary `raw` and no origin check, a page the developer visited could
+ * grow those maps one entry per message: `db.analyzeRuns` (issues/codex-security/19), the
+ * `producers` registries in typecheck/lint/build (21), `visual.rules` (64), and the memory
+ * reducer's `ownerNodeId` map (41).
+ *
+ * The existing bounds did not cover it. The `raw` clamp bounds ONE payload, not the number of
+ * distinct keys, and the flood guard is per-fingerprint — so unique fingerprints, which the same
+ * envelope chooses, step around it. That is the mechanism this repo already wrote down as
+ * *"fingerprint is the flood bucket"*.
+ *
+ * Eviction is insertion-order: JS `Map` iterates in insertion order, so the first key is the oldest.
+ * That matches the cap `db.reducer.ts` already applied to its query shapes, and it is the right
+ * policy for these collections — the newest producer is the one a developer is looking at.
+ */
+/**
+ * Trim `map` to at most `max` entries, dropping the oldest first.
+ *
+ * Returns the number of entries evicted, so a caller can report pressure rather than hiding it.
+ */
+export declare function capMap(map: Map<string, unknown>, max: number): number;
+/**
+ * Default ceiling for a producer-keyed registry.
+ *
+ * Far above what a real workspace produces — a large monorepo has tens of projects and a handful of
+ * tools — and low enough that a forged stream cannot exhaust the process before the cap bites.
+ */
+export declare const MAX_PRODUCER_KEYS = 256;

package/lib/bounded-map.js

@@ -0,0 +1 @@
+"use strict";var c=Object.defineProperty;var t=(e,r)=>c(e,"name",{value:r,configurable:!0});var i=Object.defineProperty,s=t((e,r)=>i(e,"name",{value:r,configurable:!0}),"o");export function capMap(e,r){if(e.size<=r)return 0;let n=0;const o=e.keys();for(;e.size>r;){const a=o.next();if(a.done)break;e.delete(a.value)&&(n+=1)}return n}t(capMap,"capMap"),s(capMap,"capMap");export const MAX_PRODUCER_KEYS=256;

package/lib/bounded-writer.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Per-generation cap. Override with `LENSMCP_EVENT_MAX_BYTES` (default 50 MB); 0/invalid ⇒ default.
+ */
+export declare function eventMaxBytes(env?: NodeJS.ProcessEnv): number;
+/**
+ * Rotated generations kept as history (`.1` … `.N`, newest → oldest). With the live file that bounds
+ * a workspace to (N+1) × the cap — ~300 MB at defaults. Override with `LENSMCP_EVENT_MAX_FILES`.
+ */
+export declare function eventMaxFiles(env?: NodeJS.ProcessEnv): number;
+/**
+ * Rotate `file` if it has outgrown the per-generation cap.
+ *
+ * Drops the oldest generation, shifts `.1` → `.2` → … → `.N`, and renames the live file to `.1`;
+ * the next append recreates it. Best-effort throughout — many processes append to one path, and the
+ * final `renameSync` is atomic, so a writer that loses the race throws ENOENT and no-ops. A racing
+ * shift can at worst mis-order HISTORY generations; it can never touch the live file.
+ *
+ * `caps` exists for tests, and passing it also bypasses the throttle so a test need not append a
+ * megabyte to observe a rotation.
+ */
+export declare function maybeRotateEventFile(file: string, addedBytes: number, caps?: {
+    maxBytes?: number;
+    maxFiles?: number;
+}): void;
+/** Test seam: forget the throttle state for a path (or all paths). */
+export declare function resetRotationThrottle(file?: string): void;

package/lib/bounded-writer.js

@@ -0,0 +1 @@
+"use strict";var y=Object.defineProperty;var r=(e,t)=>y(e,"name",{value:t,configurable:!0});var v=Object.defineProperty,o=r((e,t)=>v(e,"name",{value:t,configurable:!0}),"c");import{renameSync as l,statSync as f,unlinkSync as x}from"node:fs";export function eventMaxBytes(e=process.env){const t=Number(e.LENSMCP_EVENT_MAX_BYTES);return Number.isFinite(t)&&t>0?t:50*1024*1024}r(eventMaxBytes,"eventMaxBytes"),o(eventMaxBytes,"eventMaxBytes");export function eventMaxFiles(e=process.env){const t=Number(e.LENSMCP_EVENT_MAX_FILES);return Number.isFinite(t)&&t>=1&&t<=20?Math.floor(t):5}r(eventMaxFiles,"eventMaxFiles"),o(eventMaxFiles,"eventMaxFiles");const E=1024*1024,a=new Map;export function maybeRotateEventFile(e,t,i){const s=(a.get(e)??0)+t,c=i?.maxBytes??eventMaxBytes(),u=i?.maxFiles??eventMaxFiles(),m=Math.min(E,c);if(s<m){a.set(e,s);return}try{const n=f(e).size;if(a.set(e,0),n<=c)return}catch{a.set(e,s);return}try{x(`${e}.${u}`)}catch{}for(let n=u-1;n>=1;n--)try{l(`${e}.${n}`,`${e}.${n+1}`)}catch{}try{l(e,`${e}.1`)}catch{}}r(maybeRotateEventFile,"maybeRotateEventFile"),o(maybeRotateEventFile,"maybeRotateEventFile");export function resetRotationThrottle(e){e===void 0?a.clear():a.delete(e)}r(resetRotationThrottle,"resetRotationThrottle"),o(resetRotationThrottle,"resetRotationThrottle");

package/lib/flood-guard.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Per-fingerprint event flood guard
+ *
+ * Lives in `protocol-types` because EVERY producer needs it — node taps, the Nest
+ * sink, the gateway, the bridge, and (since the admission decision must happen
+ * BEFORE a payload is built) the browser runtime. It is pure logic with no Node
+ * APIs, so a browser bundle can carry it. — a token bucket per fingerprint, shared by
+ * every bus WRITER (lensEmit, the cluster gateway's observability emit, the
+ * bridge env sink mirrors it). One hot fingerprint (an app retrying a fetch in
+ * a loop, a valtio store churning per frame) must not be able to write hundreds
+ * of lines/sec into events.jsonl: the 2026-07-28 incident sustained ~680 ev/s,
+ * grew the bus file to 254 MB in two hours, and OOM-crash-looped every consumer
+ * that ingests it. The guard keeps the SIGNAL (the first burst, then a trickle
+ * with a `floodSuppressed` count) while dropping the redundant repetition.
+ */
+export interface FloodAdmit {
+    ok: boolean;
+    /** Events dropped for this fingerprint since the last admitted one (0 normally). */
+    suppressed: number;
+}
+export interface FloodGuard {
+    admit(fingerprint: string): FloodAdmit;
+}
+export interface FloodGuardOptions {
+    /** Instantaneous burst allowance per fingerprint (bucket capacity). Default 30. */
+    burst?: number;
+    /** Sustained events/sec per fingerprint (bucket refill). Default 5. */
+    perSec?: number;
+    /** Max distinct fingerprints tracked before stale buckets are evicted. Default 2048. */
+    maxKeys?: number;
+}
+export declare function createEventFloodGuard(opts?: FloodGuardOptions): FloodGuard;

package/lib/flood-guard.js

@@ -0,0 +1 @@
+"use strict";var m=Object.defineProperty;var i=(t,n)=>m(t,"name",{value:n,configurable:!0});var v=Object.defineProperty,u=i((t,n)=>v(t,"name",{value:n,configurable:!0}),"o");function p(){const t=typeof process<"u"?process.env?.LENSMCP_EVENT_MAX_EPS:void 0;if(t===void 0||t==="")return;if(t==="off")return"off";const n=Number(t);if(Number.isFinite(n))return n<=0?"off":n}i(p,"S"),u(p,"envPerSec");export function createEventFloodGuard(t){const n=p();if(n==="off")return{admit:u(()=>({ok:!0,suppressed:0}),"admit")};const l=n??t?.perSec??5,f=Math.max(1,t?.burst??Math.max(30,l*4)),c=t?.maxKeys??2048,r=new Map,d=u(o=>{for(const[s,e]of r)o-e.lastSeenAt>6e4&&r.delete(s);if(r.size>c){const s=[...r.entries()].sort((e,a)=>e[1].lastSeenAt-a[1].lastSeenAt);for(let e=0;e<s.length>>1;e++)r.delete(s[e][0])}},"evictStale");return{admit(o){const s=Date.now();let e=r.get(o);e||(r.size>=c&&d(s),e={tokens:f,lastRefillAt:s,suppressed:0,lastSeenAt:s},r.set(o,e)),e.lastSeenAt=s;const a=s-e.lastRefillAt;if(a>0&&(e.tokens=Math.min(f,e.tokens+a/1e3*l),e.lastRefillAt=s),e.tokens>=1){e.tokens-=1;const S=e.suppressed;return e.suppressed=0,{ok:!0,suppressed:S}}return e.suppressed+=1,{ok:!1,suppressed:0}}}}i(createEventFloodGuard,"createEventFloodGuard"),u(createEventFloodGuard,"createEventFloodGuard");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lensmcp/protocol-types",
-  "version": "1.21.5",
+  "version": "1.22.0",
   "type": "module",
   "main": "./index.js",
   "module": "./index.js",
@@ -11,6 +11,11 @@
       "types": "./index.d.ts",
       "import": "./index.js",
       "default": "./index.js"
+    },
+    "./bounded-writer": {
+      "types": "./lib/bounded-writer.d.ts",
+      "import": "./lib/bounded-writer.js",
+      "default": "./lib/bounded-writer.js"
     }
   },
   "dependencies": {