@lensmcp/protocol-types 1.0.0

package/lib/attributes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"attributes.d.ts","sourceRoot":"","sources":["../../src/lib/attributes.ts"],"names":[],"mappings":"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"}

package/lib/attributes.js

@@ -0,0 +1,203 @@
+import { z } from 'zod';
+// ---------- render ----------
+export const RenderPhaseSchema = z.enum(['mount', 'update']);
+export const RenderWhySchema = z.discriminatedUnion('type', [
+    z.object({ type: z.literal('props'), changedKeys: z.array(z.string()) }),
+    z.object({ type: z.literal('react-state'), hookIndex: z.number().int() }),
+    z.object({ type: z.literal('context'), contextName: z.string() }),
+    z.object({
+        type: z.literal('valtio-path'),
+        path: z.string(),
+        changedKeys: z.array(z.string()),
+    }),
+    z.object({
+        type: z.literal('parent-render'),
+        parentRenderId: z.string(),
+    }),
+    z.object({
+        type: z.literal('hook-dep-changed'),
+        hookInstanceId: z.string(),
+        depsHashBefore: z.string(),
+        depsHashAfter: z.string(),
+    }),
+    z.object({ type: z.literal('force'), reason: z.string() }),
+]);
+export const RenderAttrsSchema = z.object({
+    phase: RenderPhaseSchema,
+    actualDurationMs: z.number().nonnegative(),
+    baseDurationMs: z.number().nonnegative(),
+    startTime: z.number().nonnegative(),
+    commitTime: z.number().nonnegative(),
+    why: z.array(RenderWhySchema),
+});
+// ---------- effect-run ----------
+export const EffectRunAttrsSchema = z.object({
+    hookInstanceId: z.string(),
+    depsHash: z.string(),
+    prevDepsHash: z.string().optional(),
+    durationMs: z.number().nonnegative(),
+    cleanupRan: z.boolean().optional(),
+});
+// ---------- valtio update (state-update kind) ----------
+export const ValtioUpdateAttrsSchema = z.object({
+    storeId: z.string(),
+    path: z.string(),
+    changedKeys: z.array(z.string()),
+    beforeHash: z.string(),
+    afterHash: z.string(),
+    preview: z.unknown().optional(),
+});
+// ---------- server-request ----------
+export const ServerRequestAttrsSchema = z.object({
+    method: z.string(),
+    route: z.string(),
+    status: z.number().int().optional(),
+    durationMs: z.number().nonnegative().optional(),
+    traceparent: z.string().optional(),
+});
+// ---------- loop ----------
+export const LoopPatternSchema = z.enum([
+    'N+1',
+    'sequential-await',
+    'growing-allocation',
+]);
+export const LoopAttrsSchema = z.object({
+    iterations: z.number().int().nonnegative(),
+    durationMs: z.number().nonnegative(),
+    dbCallsInsideLoop: z.number().int().nonnegative(),
+    redisCallsInsideLoop: z.number().int().nonnegative(),
+    awaitedOperationsInsideLoop: z.number().int().nonnegative(),
+    slowestIterations: z
+        .array(z.object({
+        index: z.number().int().nonnegative(),
+        durationMs: z.number().nonnegative(),
+        childNodeIds: z.array(z.string()),
+    }))
+        .optional(),
+    patterns: z.array(LoopPatternSchema).optional(),
+});
+// ---------- memory ----------
+export const MemoryContainerKindSchema = z.enum([
+    'Map',
+    'Set',
+    'Array',
+    'EventEmitter',
+    'Queue',
+    'RxSubject',
+    'Timer',
+    'Interval',
+    'Custom',
+]);
+export const MemoryOwnerAttrsSchema = z.object({
+    ownerInstanceId: z.string(),
+    containerKind: MemoryContainerKindSchema,
+    fieldName: z.string(),
+    itemCount: z.number().int().nonnegative(),
+    estimatedBytes: z.number().nonnegative(),
+    retainedBytes: z.number().nonnegative().optional(),
+    growthSinceStart: z.number(),
+});
+export const MemoryMutationOperationSchema = z.enum([
+    'set',
+    'push',
+    'add',
+    'delete',
+    'clear',
+    'subscribe',
+    'listen',
+    'schedule',
+]);
+export const MemoryMutationAttrsSchema = z.object({
+    ownerNodeId: z.string(),
+    operation: MemoryMutationOperationSchema,
+    beforeCount: z.number().int().nonnegative(),
+    afterCount: z.number().int().nonnegative(),
+    estimatedDeltaBytes: z.number(),
+    keyPreview: z.string().optional(),
+    valueType: z.string().optional(),
+});
+// ---------- visual ----------
+export const RectSchema = z.object({
+    x: z.number(),
+    y: z.number(),
+    width: z.number().nonnegative(),
+    height: z.number().nonnegative(),
+});
+export const VisualFrameCauseSchema = z.enum([
+    'page-load',
+    'route-change',
+    'user-action',
+    'react-commit',
+    'state-update',
+    'api-response',
+    'hmr-update',
+    'animation-tick',
+]);
+export const VisualChangeKindSchema = z.enum([
+    'computed-style',
+    'layout',
+    'paint-order',
+]);
+export const VisualFrameAttrsSchema = z.object({
+    causedBy: VisualFrameCauseSchema,
+    viewport: RectSchema,
+    layoutSnapshotId: z.string(),
+    styleSnapshotId: z.string(),
+    screenshotId: z.string().optional(),
+    changedNodes: z.array(z.object({
+        uid: z.string(),
+        component: z.string().optional(),
+        change: VisualChangeKindSchema,
+        property: z.string().optional(),
+        before: z.unknown().optional(),
+        after: z.unknown().optional(),
+    })),
+});
+export const VisualRuleTypeSchema = z.enum([
+    'grid-spacing',
+    'alignment',
+    'overflow',
+    'text-clipping',
+    'color-contrast',
+    'token-usage',
+    'z-index',
+    'responsive',
+    'custom',
+]);
+export const VisualRuleTimingSchema = z.enum([
+    'always',
+    'after-animation',
+    'stable-only',
+    'during-animation',
+]);
+export const VisualViolationSeveritySchema = z.enum([
+    'info',
+    'warning',
+    'error',
+]);
+export const VisualViolationAttrsSchema = z.object({
+    ruleId: z.string(),
+    ruleType: VisualRuleTypeSchema,
+    severity: VisualViolationSeveritySchema,
+    timing: VisualRuleTimingSchema,
+    element: z.object({
+        uid: z.string(),
+        component: z.string().optional(),
+        rect: RectSchema,
+    }),
+    expected: z.record(z.string(), z.unknown()),
+    actual: z.record(z.string(), z.unknown()),
+    evidence: z.object({
+        computedStyle: z.string().optional(),
+        screenshotCrop: z.string().optional(),
+        trace: z.string().optional(),
+        cssCause: z
+            .object({
+            selector: z.string(),
+            file: z.string().optional(),
+            line: z.number().int().optional(),
+            declaration: z.string().optional(),
+        })
+            .optional(),
+    }),
+});

package/lib/context.d.ts

@@ -0,0 +1,66 @@
+import { z } from 'zod';
+export declare const FlowOriginTypeSchema: z.ZodEnum<{
+    "user-click": "user-click";
+    "user-input": "user-input";
+    keyboard: "keyboard";
+    "route-load": "route-load";
+    effect: "effect";
+    "memo-recompute": "memo-recompute";
+    timer: "timer";
+    raf: "raf";
+    "idle-callback": "idle-callback";
+    "websocket-message": "websocket-message";
+    "broadcast-channel": "broadcast-channel";
+    "post-message": "post-message";
+    "storage-event": "storage-event";
+    "service-worker-message": "service-worker-message";
+    "media-query-change": "media-query-change";
+    "visibility-change": "visibility-change";
+    resize: "resize";
+    "intersection-observer": "intersection-observer";
+    "mutation-observer": "mutation-observer";
+    "backend-response": "backend-response";
+    "hmr-update": "hmr-update";
+}>;
+export type FlowOriginType = z.infer<typeof FlowOriginTypeSchema>;
+export declare const TraceContextSchema: z.ZodObject<{
+    sessionId: z.ZodString;
+    browserContextId: z.ZodOptional<z.ZodString>;
+    tabId: z.ZodOptional<z.ZodString>;
+    frameId: z.ZodOptional<z.ZodString>;
+    route: z.ZodOptional<z.ZodString>;
+    url: z.ZodOptional<z.ZodString>;
+    flowId: z.ZodOptional<z.ZodString>;
+    originType: z.ZodOptional<z.ZodEnum<{
+        "user-click": "user-click";
+        "user-input": "user-input";
+        keyboard: "keyboard";
+        "route-load": "route-load";
+        effect: "effect";
+        "memo-recompute": "memo-recompute";
+        timer: "timer";
+        raf: "raf";
+        "idle-callback": "idle-callback";
+        "websocket-message": "websocket-message";
+        "broadcast-channel": "broadcast-channel";
+        "post-message": "post-message";
+        "storage-event": "storage-event";
+        "service-worker-message": "service-worker-message";
+        "media-query-change": "media-query-change";
+        "visibility-change": "visibility-change";
+        resize: "resize";
+        "intersection-observer": "intersection-observer";
+        "mutation-observer": "mutation-observer";
+        "backend-response": "backend-response";
+        "hmr-update": "hmr-update";
+    }>>;
+    originNodeId: z.ZodOptional<z.ZodString>;
+    causedByNodeId: z.ZodOptional<z.ZodString>;
+    requestId: z.ZodOptional<z.ZodString>;
+    traceparent: z.ZodOptional<z.ZodString>;
+    userActionId: z.ZodOptional<z.ZodString>;
+    userIdHash: z.ZodOptional<z.ZodString>;
+    tenantIdHash: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type TraceContext = z.infer<typeof TraceContextSchema>;
+//# sourceMappingURL=context.d.ts.map

package/lib/context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.d.ts","sourceRoot":"","sources":["../../src/lib/context.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;EAsB/B,CAAC;AAEH,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAElE,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAoB7B,CAAC;AAEH,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC"}

package/lib/context.js

@@ -0,0 +1,41 @@
+import { z } from 'zod';
+export const FlowOriginTypeSchema = z.enum([
+    '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',
+]);
+export const TraceContextSchema = z.object({
+    sessionId: z.string(),
+    browserContextId: z.string().optional(),
+    tabId: z.string().optional(),
+    frameId: z.string().optional(),
+    route: z.string().optional(),
+    url: z.string().optional(),
+    flowId: z.string().optional(),
+    originType: FlowOriginTypeSchema.optional(),
+    originNodeId: z.string().optional(),
+    causedByNodeId: z.string().optional(),
+    requestId: z.string().optional(),
+    traceparent: z.string().optional(),
+    userActionId: z.string().optional(),
+    userIdHash: z.string().optional(),
+    tenantIdHash: z.string().optional(),
+});

package/lib/edge.d.ts

@@ -0,0 +1,42 @@
+import { z } from 'zod';
+export declare const EdgeAxisSchema: z.ZodEnum<{
+    db: "db";
+    memory: "memory";
+    visual: "visual";
+    render: "render";
+    state: "state";
+    network: "network";
+    backend: "backend";
+    performance: "performance";
+    lifecycle: "lifecycle";
+    ownership: "ownership";
+    caused: "caused";
+    async: "async";
+    data: "data";
+}>;
+export type EdgeAxis = z.infer<typeof EdgeAxisSchema>;
+export declare const TraceEdgeSchema: z.ZodObject<{
+    id: z.ZodString;
+    from: z.ZodString;
+    to: z.ZodString;
+    axis: z.ZodEnum<{
+        db: "db";
+        memory: "memory";
+        visual: "visual";
+        render: "render";
+        state: "state";
+        network: "network";
+        backend: "backend";
+        performance: "performance";
+        lifecycle: "lifecycle";
+        ownership: "ownership";
+        caused: "caused";
+        async: "async";
+        data: "data";
+    }>;
+    type: z.ZodString;
+    timestamp: z.ZodNumber;
+    attributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+export type TraceEdge = z.infer<typeof TraceEdgeSchema>;
+//# sourceMappingURL=edge.d.ts.map

package/lib/edge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"edge.d.ts","sourceRoot":"","sources":["../../src/lib/edge.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,cAAc;;;;;;;;;;;;;;EAczB,CAAC;AACH,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AAEtD,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;iBAQ1B,CAAC;AACH,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC"}

package/lib/edge.js

@@ -0,0 +1,25 @@
+import { z } from 'zod';
+export const EdgeAxisSchema = z.enum([
+    'ownership',
+    'caused',
+    'async',
+    'data',
+    'render',
+    'state',
+    'network',
+    'backend',
+    'db',
+    'visual',
+    'performance',
+    'memory',
+    'lifecycle',
+]);
+export const TraceEdgeSchema = z.object({
+    id: z.string(),
+    from: z.string(),
+    to: z.string(),
+    axis: EdgeAxisSchema,
+    type: z.string(),
+    timestamp: z.number().int().nonnegative(),
+    attributes: z.record(z.string(), z.unknown()).optional(),
+});

package/lib/event.d.ts

@@ -0,0 +1,160 @@
+import { z } from 'zod';
+export declare const EventSourceSchema: z.ZodEnum<{
+    nx: "nx";
+    vite: "vite";
+    typescript: "typescript";
+    eslint: "eslint";
+    rollup: "rollup";
+    "client-runtime": "client-runtime";
+    chrome: "chrome";
+    react: "react";
+    valtio: "valtio";
+    nestjs: "nestjs";
+    nextjs: "nextjs";
+    db: "db";
+    redis: "redis";
+    queue: "queue";
+    memory: "memory";
+    visual: "visual";
+    perf: "perf";
+    security: "security";
+    gateway: "gateway";
+    external: "external";
+}>;
+export type EventSource = z.infer<typeof EventSourceSchema>;
+export declare const EventCategorySchema: z.ZodEnum<{
+    db: "db";
+    memory: "memory";
+    visual: "visual";
+    security: "security";
+    build: "build";
+    lint: "lint";
+    typecheck: "typecheck";
+    test: "test";
+    runtime: "runtime";
+    render: "render";
+    trace: "trace";
+    state: "state";
+    network: "network";
+    backend: "backend";
+    performance: "performance";
+    deps: "deps";
+    cluster: "cluster";
+}>;
+export type EventCategory = z.infer<typeof EventCategorySchema>;
+export declare const SeveritySchema: z.ZodEnum<{
+    error: "error";
+    debug: "debug";
+    info: "info";
+    warning: "warning";
+    fatal: "fatal";
+}>;
+export type Severity = z.infer<typeof SeveritySchema>;
+export declare const BaseEventSchema: z.ZodObject<{
+    id: z.ZodString;
+    sessionId: z.ZodString;
+    timestamp: z.ZodNumber;
+    source: z.ZodEnum<{
+        nx: "nx";
+        vite: "vite";
+        typescript: "typescript";
+        eslint: "eslint";
+        rollup: "rollup";
+        "client-runtime": "client-runtime";
+        chrome: "chrome";
+        react: "react";
+        valtio: "valtio";
+        nestjs: "nestjs";
+        nextjs: "nextjs";
+        db: "db";
+        redis: "redis";
+        queue: "queue";
+        memory: "memory";
+        visual: "visual";
+        perf: "perf";
+        security: "security";
+        gateway: "gateway";
+        external: "external";
+    }>;
+    category: z.ZodEnum<{
+        db: "db";
+        memory: "memory";
+        visual: "visual";
+        security: "security";
+        build: "build";
+        lint: "lint";
+        typecheck: "typecheck";
+        test: "test";
+        runtime: "runtime";
+        render: "render";
+        trace: "trace";
+        state: "state";
+        network: "network";
+        backend: "backend";
+        performance: "performance";
+        deps: "deps";
+        cluster: "cluster";
+    }>;
+    severity: z.ZodEnum<{
+        error: "error";
+        debug: "debug";
+        info: "info";
+        warning: "warning";
+        fatal: "fatal";
+    }>;
+    context: z.ZodObject<{
+        sessionId: z.ZodString;
+        browserContextId: z.ZodOptional<z.ZodString>;
+        tabId: z.ZodOptional<z.ZodString>;
+        frameId: z.ZodOptional<z.ZodString>;
+        route: z.ZodOptional<z.ZodString>;
+        url: z.ZodOptional<z.ZodString>;
+        flowId: z.ZodOptional<z.ZodString>;
+        originType: z.ZodOptional<z.ZodEnum<{
+            "user-click": "user-click";
+            "user-input": "user-input";
+            keyboard: "keyboard";
+            "route-load": "route-load";
+            effect: "effect";
+            "memo-recompute": "memo-recompute";
+            timer: "timer";
+            raf: "raf";
+            "idle-callback": "idle-callback";
+            "websocket-message": "websocket-message";
+            "broadcast-channel": "broadcast-channel";
+            "post-message": "post-message";
+            "storage-event": "storage-event";
+            "service-worker-message": "service-worker-message";
+            "media-query-change": "media-query-change";
+            "visibility-change": "visibility-change";
+            resize: "resize";
+            "intersection-observer": "intersection-observer";
+            "mutation-observer": "mutation-observer";
+            "backend-response": "backend-response";
+            "hmr-update": "hmr-update";
+        }>>;
+        originNodeId: z.ZodOptional<z.ZodString>;
+        causedByNodeId: z.ZodOptional<z.ZodString>;
+        requestId: z.ZodOptional<z.ZodString>;
+        traceparent: z.ZodOptional<z.ZodString>;
+        userActionId: z.ZodOptional<z.ZodString>;
+        userIdHash: z.ZodOptional<z.ZodString>;
+        tenantIdHash: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    fingerprint: z.ZodString;
+    title: z.ZodString;
+    message: z.ZodOptional<z.ZodString>;
+    location: z.ZodOptional<z.ZodObject<{
+        file: z.ZodString;
+        line: z.ZodOptional<z.ZodNumber>;
+        column: z.ZodOptional<z.ZodNumber>;
+        symbol: z.ZodOptional<z.ZodString>;
+        componentName: z.ZodOptional<z.ZodString>;
+        hookName: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    relatedFiles: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    relatedUrls: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    raw: z.ZodOptional<z.ZodUnknown>;
+}, z.core.$strip>;
+export type BaseEvent = z.infer<typeof BaseEventSchema>;
+//# sourceMappingURL=event.d.ts.map

package/lib/event.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"event.d.ts","sourceRoot":"","sources":["../../src/lib/event.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;EAqB5B,CAAC;AACH,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAE5D,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;EAkB9B,CAAC;AACH,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAEhE,eAAO,MAAM,cAAc;;;;;;EAMzB,CAAC;AACH,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AAEtD,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAe1B,CAAC;AAEH,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC"}

package/lib/event.js

@@ -0,0 +1,67 @@
+import { z } from 'zod';
+import { SourceLocationSchema } from './source-location.js';
+import { TraceContextSchema } from './context.js';
+export const EventSourceSchema = z.enum([
+    'nx',
+    'vite',
+    'typescript',
+    'eslint',
+    'rollup',
+    'client-runtime',
+    'chrome',
+    'react',
+    'valtio',
+    'nestjs',
+    'nextjs',
+    'db',
+    'redis',
+    'queue',
+    'memory',
+    'visual',
+    'perf',
+    'security',
+    'gateway',
+    'external',
+]);
+export const EventCategorySchema = z.enum([
+    'build',
+    'lint',
+    'typecheck',
+    'test',
+    'runtime',
+    'render',
+    'visual',
+    'trace',
+    'state',
+    'network',
+    'backend',
+    'db',
+    'memory',
+    'performance',
+    'security',
+    'deps',
+    'cluster',
+]);
+export const SeveritySchema = z.enum([
+    'debug',
+    'info',
+    'warning',
+    'error',
+    'fatal',
+]);
+export const BaseEventSchema = z.object({
+    id: z.string(),
+    sessionId: z.string(),
+    timestamp: z.number().int().nonnegative(),
+    source: EventSourceSchema,
+    category: EventCategorySchema,
+    severity: SeveritySchema,
+    context: TraceContextSchema,
+    fingerprint: z.string(),
+    title: z.string(),
+    message: z.string().optional(),
+    location: SourceLocationSchema.optional(),
+    relatedFiles: z.array(z.string()).optional(),
+    relatedUrls: z.array(z.string()).optional(),
+    raw: z.unknown().optional(),
+});