@lensmcp/protocol-types 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,128 @@
+# @lensmcp/protocol-types
+
+> The shared event protocol for LensMCP — Zod schemas and inferred TypeScript types for the events, trace nodes, edges, and resources that flow between producers and consumers.
+
+LensMCP is an observability lens for coding agents. This package is the **wire contract** that keeps every part of the system in sync: a single set of [Zod](https://zod.dev) schemas (and the TypeScript types inferred from them) describing the events emitted by instrumentation, the trace graph (nodes + edges) those events build up, the per-domain attribute shapes, and the MCP resources consumers read.
+
+Because the schemas and types are derived from the same definitions, producers (browser/React, Node/Nest taps, the gateway) and consumers (`@lensmcp/core`, the MCP server, the dashboard) share one source of truth — emit-side validation and read-side typing never drift apart.
+
+## Install
+
+```bash
+yarn add @lensmcp/protocol-types
+```
+
+Requires Node `>=18`. `zod` is a runtime dependency.
+
+## Usage
+
+Validate an event on the producer side, and type it on the consumer side, from the same schema:
+
+```ts
+import {
+  BaseEventSchema,
+  type BaseEvent,
+  type EventSource,
+} from '@lensmcp/protocol-types';
+
+// Producer: parse/validate before emitting (throws on bad shape).
+const event = BaseEventSchema.parse({
+  id: 'evt_01',
+  sessionId: 'sess_abc',
+  timestamp: Date.now(),
+  source: 'react',
+  category: 'render',
+  severity: 'warning',
+  context: { sessionId: 'sess_abc', route: '/dashboard' },
+  fingerprint: 'render:Slow:/dashboard',
+  title: 'Slow render',
+});
+
+// Consumer: the inferred type is the contract.
+function handle(e: BaseEvent) {
+  const from: EventSource = e.source;
+  console.log(from, e.category, e.severity);
+}
+```
+
+Use `.safeParse()` when you want to branch on validity instead of throwing:
+
+```ts
+const result = BaseEventSchema.safeParse(input);
+if (!result.success) {
+  // result.error is a ZodError
+}
+```
+
+Every schema follows the `XxxSchema` (value) + `Xxx` (inferred type) naming convention, so you can import whichever you need.
+
+## What's in here
+
+### Event (`event.ts`)
+
+- **`BaseEventSchema` / `BaseEvent`** — the common envelope on every emitted event: `id`, `sessionId`, `timestamp`, `source`, `category`, `severity`, `context`, `fingerprint`, `title`, plus optional `message`, `location`, `relatedFiles`, `relatedUrls`, and `raw`.
+- **`EventSourceSchema` / `EventSource`** — where the event came from:
+  `nx`, `vite`, `typescript`, `eslint`, `rollup`, `client-runtime`, `chrome`, `react`, `valtio`, `nestjs`, `nextjs`, `db`, `redis`, `queue`, `memory`, `visual`, `perf`, `security`, `gateway`, `external`.
+- **`EventCategorySchema` / `EventCategory`** — what kind of signal it is:
+  `build`, `lint`, `typecheck`, `test`, `runtime`, `render`, `visual`, `trace`, `state`, `network`, `backend`, `db`, `memory`, `performance`, `security`, `deps`, `cluster`.
+- **`SeveritySchema` / `Severity`** — `debug`, `info`, `warning`, `error`, `fatal`.
+
+### Trace context (`context.ts`)
+
+- **`TraceContextSchema` / `TraceContext`** — the correlation envelope carried on events and nodes: `sessionId` plus optional browser identifiers (`browserContextId`, `tabId`, `frameId`, `route`, `url`), flow identifiers (`flowId`, `originType`, `originNodeId`, `causedByNodeId`), request identifiers (`requestId`, `traceparent`), and hashed actor identifiers (`userActionId`, `userIdHash`, `tenantIdHash`).
+- **`FlowOriginTypeSchema` / `FlowOriginType`** — what kicked off a flow (e.g. `user-click`, `user-input`, `keyboard`, `route-load`, `effect`, `memo-recompute`, `timer`, `raf`, `idle-callback`, `websocket-message`, `broadcast-channel`, `post-message`, `storage-event`, `service-worker-message`, `media-query-change`, `visibility-change`, `resize`, `intersection-observer`, `mutation-observer`, `backend-response`, `hmr-update`).
+
+### Trace graph — nodes & edges (`node.ts`, `edge.ts`)
+
+- **`TraceNodeSchema` / `TraceNode`** — a node in the trace graph: identity (`id`, `parentTraceNodeId`, `logicalId`, `instanceId`, `generation`), `type`, `lifecycle`, `context`, timing (`startTime`, `endTime`, `durationMs`), optional `location`, and an open `attributes` record.
+- **`TraceNodeTypeSchema` / `TraceNodeType`** — the node taxonomy spanning the browser process tree, React UI, user interaction, network/API, backend (Nest app/module/provider, requests, DB/Redis ops, queue jobs, loops, promises), state, visual, memory, and build/dev events.
+- **`LifecycleSchema` / `Lifecycle`** — `created`, `active`, `completed`, `disposed`, `errored`.
+- **`TraceEdgeSchema` / `TraceEdge`** — a directed relationship between nodes: `from`, `to`, `axis`, `type`, `timestamp`, optional `attributes`.
+- **`EdgeAxisSchema` / `EdgeAxis`** — the relationship dimension: `ownership`, `caused`, `async`, `data`, `render`, `state`, `network`, `backend`, `db`, `visual`, `performance`, `memory`, `lifecycle`.
+
+### Domain attributes (`attributes.ts`)
+
+Typed `attributes` payloads for specific node types, each with its `XxxSchema` + `Xxx` pair:
+
+- **Render** — `RenderAttrs`, `RenderPhase` (`mount` | `update`), and the discriminated `RenderWhy` (props / react-state / context / valtio-path / parent-render / hook-dep-changed / force).
+- **Effects & state** — `EffectRunAttrs`, `ValtioUpdateAttrs`.
+- **Backend** — `ServerRequestAttrs`, plus `LoopAttrs` / `LoopPattern` (`N+1`, `sequential-await`, `growing-allocation`).
+- **Memory** — `MemoryOwnerAttrs`, `MemoryMutationAttrs`, with `MemoryContainerKind` and `MemoryMutationOperation` enums.
+- **Visual** — `VisualFrameAttrs` and `VisualViolationAttrs`, plus `Rect`, `VisualFrameCause`, `VisualChangeKind`, `VisualRuleType`, `VisualRuleTiming`, and `VisualViolationSeverity`.
+
+### Source location (`source-location.ts`)
+
+- **`SourceLocationSchema` / `SourceLocation`** — `file` plus optional `line`, `column`, `symbol`, `componentName`, `hookName`. Reused across events, nodes, and resources to point back at code.
+
+### Resources (`resources.ts`)
+
+The MCP-facing read models, all built on a shared envelope:
+
+- **`ResourceEnvelopeSchema` / `ResourceEnvelope`** — the header on every resource JSON (`schemaVersion`, `revision`, optional `$schema` and `updatedAt`).
+- **`URI_SCHEMES` / `UriScheme`** — the well-known LensMCP resource URI schemes (each maps 1:1 to a FrontMCP `@App` package): `agent`, `events`, `build`, `lint`, `typecheck`, `test`, `runtime`, `render`, `visual`, `flow`, `story`, `trace`, `graph`, `bundle`, `security`, `perf`, `deps`, `memory`, `browser`, `react`, `valtio`, `nest`, `next`, `process`.
+- **`AgentCurrentStatusSchema` / `AgentCurrentStatus`** (`agent://current-status`) — rollup status (`AgentStatusKind`: `starting` | `clean` | `warning` | `failing`), `blocking` / `warnings` items (`AgentBlockingItem`), `suggestedReads`, and per-domain `checks` (`AgentChecks`).
+- **`AgentSessionSchema` / `AgentSession`** (`agent://session`) — session capabilities: supported resources/tools/jobs/channels, default subscriptions, transports, host info, and project info.
+
+### DI tokens (`tokens.ts`)
+
+`Symbol`-based dependency-injection tokens for FrontMCP `@Provider` registrations — `SessionToken`, `EventBusToken`, `GraphStoreToken`, `ResourceStoreToken`, `StorageToken` (union type `LensmcpToken`). The interfaces stay abstract here; packages like `@lensmcp/core` ship the concrete implementations.
+
+### Schema version (`schema-version.ts`)
+
+- **`SCHEMA_VERSION`** (currently `1`) and the **`SchemaVersion`** literal type — stamped into `ResourceEnvelope` so consumers can detect protocol drift.
+
+## How it fits
+
+```
+producers                         @lensmcp/protocol-types                    consumers
+─────────                         ──────────────────────                    ─────────
+browser / React tap        ─┐                                          ┌─►  @lensmcp/core
+node / NestJS taps         ─┼──►  Zod schemas + inferred types   ──────┼─►  MCP server
+gateway                    ─┘     (the wire contract)                  └─►  dashboard
+```
+
+Every `@lensmcp` instrumentation library and the gateway validate and emit events against these schemas; `@lensmcp/core` and the MCP server consume them with the matching inferred types. One definition, validated on the way out and typed on the way in — so the protocol can't silently drift between producer and consumer.
+
+---
+
+Part of [LensMCP](https://github.com/kiwiapps-ltd/lensmcp). Apache-2.0.

package/index.d.ts

@@ -0,0 +1,10 @@
+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/resources.js';
+export * from './lib/tokens.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,cAAc,yBAAyB,CAAC;AACxC,cAAc,0BAA0B,CAAC;AACzC,cAAc,kBAAkB,CAAC;AACjC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,eAAe,CAAC;AAC9B,cAAc,eAAe,CAAC;AAC9B,cAAc,qBAAqB,CAAC;AACpC,cAAc,oBAAoB,CAAC;AACnC,cAAc,iBAAiB,CAAC"}

package/index.js

@@ -0,0 +1,9 @@
+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/resources.js';
+export * from './lib/tokens.js';

package/lib/attributes.d.ts

@@ -0,0 +1,312 @@
+import { z } from 'zod';
+export declare const RenderPhaseSchema: z.ZodEnum<{
+    mount: "mount";
+    update: "update";
+}>;
+export type RenderPhase = z.infer<typeof RenderPhaseSchema>;
+export declare const RenderWhySchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"props">;
+    changedKeys: z.ZodArray<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"react-state">;
+    hookIndex: z.ZodNumber;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"context">;
+    contextName: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"valtio-path">;
+    path: z.ZodString;
+    changedKeys: z.ZodArray<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"parent-render">;
+    parentRenderId: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"hook-dep-changed">;
+    hookInstanceId: z.ZodString;
+    depsHashBefore: z.ZodString;
+    depsHashAfter: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"force">;
+    reason: z.ZodString;
+}, z.core.$strip>], "type">;
+export type RenderWhy = z.infer<typeof RenderWhySchema>;
+export declare const RenderAttrsSchema: z.ZodObject<{
+    phase: z.ZodEnum<{
+        mount: "mount";
+        update: "update";
+    }>;
+    actualDurationMs: z.ZodNumber;
+    baseDurationMs: z.ZodNumber;
+    startTime: z.ZodNumber;
+    commitTime: z.ZodNumber;
+    why: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"props">;
+        changedKeys: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"react-state">;
+        hookIndex: z.ZodNumber;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"context">;
+        contextName: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"valtio-path">;
+        path: z.ZodString;
+        changedKeys: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"parent-render">;
+        parentRenderId: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"hook-dep-changed">;
+        hookInstanceId: z.ZodString;
+        depsHashBefore: z.ZodString;
+        depsHashAfter: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"force">;
+        reason: z.ZodString;
+    }, z.core.$strip>], "type">>;
+}, z.core.$strip>;
+export type RenderAttrs = z.infer<typeof RenderAttrsSchema>;
+export declare const EffectRunAttrsSchema: z.ZodObject<{
+    hookInstanceId: z.ZodString;
+    depsHash: z.ZodString;
+    prevDepsHash: z.ZodOptional<z.ZodString>;
+    durationMs: z.ZodNumber;
+    cleanupRan: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export type EffectRunAttrs = z.infer<typeof EffectRunAttrsSchema>;
+export declare const ValtioUpdateAttrsSchema: z.ZodObject<{
+    storeId: z.ZodString;
+    path: z.ZodString;
+    changedKeys: z.ZodArray<z.ZodString>;
+    beforeHash: z.ZodString;
+    afterHash: z.ZodString;
+    preview: z.ZodOptional<z.ZodUnknown>;
+}, z.core.$strip>;
+export type ValtioUpdateAttrs = z.infer<typeof ValtioUpdateAttrsSchema>;
+export declare const ServerRequestAttrsSchema: z.ZodObject<{
+    method: z.ZodString;
+    route: z.ZodString;
+    status: z.ZodOptional<z.ZodNumber>;
+    durationMs: z.ZodOptional<z.ZodNumber>;
+    traceparent: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type ServerRequestAttrs = z.infer<typeof ServerRequestAttrsSchema>;
+export declare const LoopPatternSchema: z.ZodEnum<{
+    "N+1": "N+1";
+    "sequential-await": "sequential-await";
+    "growing-allocation": "growing-allocation";
+}>;
+export type LoopPattern = z.infer<typeof LoopPatternSchema>;
+export declare const LoopAttrsSchema: z.ZodObject<{
+    iterations: z.ZodNumber;
+    durationMs: z.ZodNumber;
+    dbCallsInsideLoop: z.ZodNumber;
+    redisCallsInsideLoop: z.ZodNumber;
+    awaitedOperationsInsideLoop: z.ZodNumber;
+    slowestIterations: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        index: z.ZodNumber;
+        durationMs: z.ZodNumber;
+        childNodeIds: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>>>;
+    patterns: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        "N+1": "N+1";
+        "sequential-await": "sequential-await";
+        "growing-allocation": "growing-allocation";
+    }>>>;
+}, z.core.$strip>;
+export type LoopAttrs = z.infer<typeof LoopAttrsSchema>;
+export declare const MemoryContainerKindSchema: z.ZodEnum<{
+    Map: "Map";
+    Set: "Set";
+    Array: "Array";
+    EventEmitter: "EventEmitter";
+    Queue: "Queue";
+    RxSubject: "RxSubject";
+    Timer: "Timer";
+    Interval: "Interval";
+    Custom: "Custom";
+}>;
+export type MemoryContainerKind = z.infer<typeof MemoryContainerKindSchema>;
+export declare const MemoryOwnerAttrsSchema: z.ZodObject<{
+    ownerInstanceId: z.ZodString;
+    containerKind: z.ZodEnum<{
+        Map: "Map";
+        Set: "Set";
+        Array: "Array";
+        EventEmitter: "EventEmitter";
+        Queue: "Queue";
+        RxSubject: "RxSubject";
+        Timer: "Timer";
+        Interval: "Interval";
+        Custom: "Custom";
+    }>;
+    fieldName: z.ZodString;
+    itemCount: z.ZodNumber;
+    estimatedBytes: z.ZodNumber;
+    retainedBytes: z.ZodOptional<z.ZodNumber>;
+    growthSinceStart: z.ZodNumber;
+}, z.core.$strip>;
+export type MemoryOwnerAttrs = z.infer<typeof MemoryOwnerAttrsSchema>;
+export declare const MemoryMutationOperationSchema: z.ZodEnum<{
+    set: "set";
+    push: "push";
+    add: "add";
+    delete: "delete";
+    clear: "clear";
+    subscribe: "subscribe";
+    listen: "listen";
+    schedule: "schedule";
+}>;
+export type MemoryMutationOperation = z.infer<typeof MemoryMutationOperationSchema>;
+export declare const MemoryMutationAttrsSchema: z.ZodObject<{
+    ownerNodeId: z.ZodString;
+    operation: z.ZodEnum<{
+        set: "set";
+        push: "push";
+        add: "add";
+        delete: "delete";
+        clear: "clear";
+        subscribe: "subscribe";
+        listen: "listen";
+        schedule: "schedule";
+    }>;
+    beforeCount: z.ZodNumber;
+    afterCount: z.ZodNumber;
+    estimatedDeltaBytes: z.ZodNumber;
+    keyPreview: z.ZodOptional<z.ZodString>;
+    valueType: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type MemoryMutationAttrs = z.infer<typeof MemoryMutationAttrsSchema>;
+export declare const RectSchema: z.ZodObject<{
+    x: z.ZodNumber;
+    y: z.ZodNumber;
+    width: z.ZodNumber;
+    height: z.ZodNumber;
+}, z.core.$strip>;
+export type Rect = z.infer<typeof RectSchema>;
+export declare const VisualFrameCauseSchema: z.ZodEnum<{
+    "hmr-update": "hmr-update";
+    "state-update": "state-update";
+    "page-load": "page-load";
+    "route-change": "route-change";
+    "user-action": "user-action";
+    "react-commit": "react-commit";
+    "api-response": "api-response";
+    "animation-tick": "animation-tick";
+}>;
+export type VisualFrameCause = z.infer<typeof VisualFrameCauseSchema>;
+export declare const VisualChangeKindSchema: z.ZodEnum<{
+    "computed-style": "computed-style";
+    layout: "layout";
+    "paint-order": "paint-order";
+}>;
+export type VisualChangeKind = z.infer<typeof VisualChangeKindSchema>;
+export declare const VisualFrameAttrsSchema: z.ZodObject<{
+    causedBy: z.ZodEnum<{
+        "hmr-update": "hmr-update";
+        "state-update": "state-update";
+        "page-load": "page-load";
+        "route-change": "route-change";
+        "user-action": "user-action";
+        "react-commit": "react-commit";
+        "api-response": "api-response";
+        "animation-tick": "animation-tick";
+    }>;
+    viewport: z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+        width: z.ZodNumber;
+        height: z.ZodNumber;
+    }, z.core.$strip>;
+    layoutSnapshotId: z.ZodString;
+    styleSnapshotId: z.ZodString;
+    screenshotId: z.ZodOptional<z.ZodString>;
+    changedNodes: z.ZodArray<z.ZodObject<{
+        uid: z.ZodString;
+        component: z.ZodOptional<z.ZodString>;
+        change: z.ZodEnum<{
+            "computed-style": "computed-style";
+            layout: "layout";
+            "paint-order": "paint-order";
+        }>;
+        property: z.ZodOptional<z.ZodString>;
+        before: z.ZodOptional<z.ZodUnknown>;
+        after: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type VisualFrameAttrs = z.infer<typeof VisualFrameAttrsSchema>;
+export declare const VisualRuleTypeSchema: z.ZodEnum<{
+    custom: "custom";
+    "grid-spacing": "grid-spacing";
+    alignment: "alignment";
+    overflow: "overflow";
+    "text-clipping": "text-clipping";
+    "color-contrast": "color-contrast";
+    "token-usage": "token-usage";
+    "z-index": "z-index";
+    responsive: "responsive";
+}>;
+export type VisualRuleType = z.infer<typeof VisualRuleTypeSchema>;
+export declare const VisualRuleTimingSchema: z.ZodEnum<{
+    always: "always";
+    "after-animation": "after-animation";
+    "stable-only": "stable-only";
+    "during-animation": "during-animation";
+}>;
+export type VisualRuleTiming = z.infer<typeof VisualRuleTimingSchema>;
+export declare const VisualViolationSeveritySchema: z.ZodEnum<{
+    error: "error";
+    info: "info";
+    warning: "warning";
+}>;
+export type VisualViolationSeverity = z.infer<typeof VisualViolationSeveritySchema>;
+export declare const VisualViolationAttrsSchema: z.ZodObject<{
+    ruleId: z.ZodString;
+    ruleType: z.ZodEnum<{
+        custom: "custom";
+        "grid-spacing": "grid-spacing";
+        alignment: "alignment";
+        overflow: "overflow";
+        "text-clipping": "text-clipping";
+        "color-contrast": "color-contrast";
+        "token-usage": "token-usage";
+        "z-index": "z-index";
+        responsive: "responsive";
+    }>;
+    severity: z.ZodEnum<{
+        error: "error";
+        info: "info";
+        warning: "warning";
+    }>;
+    timing: z.ZodEnum<{
+        always: "always";
+        "after-animation": "after-animation";
+        "stable-only": "stable-only";
+        "during-animation": "during-animation";
+    }>;
+    element: z.ZodObject<{
+        uid: z.ZodString;
+        component: z.ZodOptional<z.ZodString>;
+        rect: z.ZodObject<{
+            x: z.ZodNumber;
+            y: z.ZodNumber;
+            width: z.ZodNumber;
+            height: z.ZodNumber;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+    expected: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    actual: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    evidence: z.ZodObject<{
+        computedStyle: z.ZodOptional<z.ZodString>;
+        screenshotCrop: z.ZodOptional<z.ZodString>;
+        trace: z.ZodOptional<z.ZodString>;
+        cssCause: z.ZodOptional<z.ZodObject<{
+            selector: z.ZodString;
+            file: z.ZodOptional<z.ZodString>;
+            line: z.ZodOptional<z.ZodNumber>;
+            declaration: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type VisualViolationAttrs = z.infer<typeof VisualViolationAttrsSchema>;
+//# sourceMappingURL=attributes.d.ts.map