@lensmcp/protocol-types 1.0.0

package/lib/node.d.ts

@@ -0,0 +1,204 @@
+import { z } from 'zod';
+export declare const TraceNodeTypeSchema: z.ZodEnum<{
+    effect: "effect";
+    timer: "timer";
+    "hmr-update": "hmr-update";
+    route: "route";
+    render: "render";
+    promise: "promise";
+    session: "session";
+    "browser-context": "browser-context";
+    tab: "tab";
+    renderer: "renderer";
+    router: "router";
+    page: "page";
+    component: "component";
+    element: "element";
+    slot: "slot";
+    "react-mount": "react-mount";
+    "react-unmount": "react-unmount";
+    hook: "hook";
+    "effect-run": "effect-run";
+    memo: "memo";
+    "memo-compute": "memo-compute";
+    "ui-event": "ui-event";
+    handler: "handler";
+    animation: "animation";
+    "animation-frame": "animation-frame";
+    transition: "transition";
+    "api-client-call": "api-client-call";
+    "http-request": "http-request";
+    "http-response": "http-response";
+    "server-process": "server-process";
+    "nest-app": "nest-app";
+    "nest-module": "nest-module";
+    "nest-provider": "nest-provider";
+    "singleton-instance": "singleton-instance";
+    "server-request": "server-request";
+    guard: "guard";
+    controller: "controller";
+    "service-method": "service-method";
+    loop: "loop";
+    "loop-iteration": "loop-iteration";
+    "queue-job": "queue-job";
+    "db-query": "db-query";
+    "redis-op": "redis-op";
+    "promise-continuation": "promise-continuation";
+    "state-store": "state-store";
+    "state-update": "state-update";
+    selector: "selector";
+    "selector-update": "selector-update";
+    "visual-frame": "visual-frame";
+    "visual-violation": "visual-violation";
+    "style-change": "style-change";
+    "layout-change": "layout-change";
+    "memory-owner": "memory-owner";
+    "memory-mutation": "memory-mutation";
+    "memory-retention": "memory-retention";
+    "heap-snapshot": "heap-snapshot";
+    "build-event": "build-event";
+    "lint-event": "lint-event";
+    "typecheck-event": "typecheck-event";
+    "test-event": "test-event";
+    "bundle-report": "bundle-report";
+}>;
+export type TraceNodeType = z.infer<typeof TraceNodeTypeSchema>;
+export declare const LifecycleSchema: z.ZodEnum<{
+    created: "created";
+    active: "active";
+    completed: "completed";
+    disposed: "disposed";
+    errored: "errored";
+}>;
+export type Lifecycle = z.infer<typeof LifecycleSchema>;
+export declare const TraceNodeSchema: z.ZodObject<{
+    id: z.ZodString;
+    parentTraceNodeId: z.ZodOptional<z.ZodString>;
+    type: z.ZodEnum<{
+        effect: "effect";
+        timer: "timer";
+        "hmr-update": "hmr-update";
+        route: "route";
+        render: "render";
+        promise: "promise";
+        session: "session";
+        "browser-context": "browser-context";
+        tab: "tab";
+        renderer: "renderer";
+        router: "router";
+        page: "page";
+        component: "component";
+        element: "element";
+        slot: "slot";
+        "react-mount": "react-mount";
+        "react-unmount": "react-unmount";
+        hook: "hook";
+        "effect-run": "effect-run";
+        memo: "memo";
+        "memo-compute": "memo-compute";
+        "ui-event": "ui-event";
+        handler: "handler";
+        animation: "animation";
+        "animation-frame": "animation-frame";
+        transition: "transition";
+        "api-client-call": "api-client-call";
+        "http-request": "http-request";
+        "http-response": "http-response";
+        "server-process": "server-process";
+        "nest-app": "nest-app";
+        "nest-module": "nest-module";
+        "nest-provider": "nest-provider";
+        "singleton-instance": "singleton-instance";
+        "server-request": "server-request";
+        guard: "guard";
+        controller: "controller";
+        "service-method": "service-method";
+        loop: "loop";
+        "loop-iteration": "loop-iteration";
+        "queue-job": "queue-job";
+        "db-query": "db-query";
+        "redis-op": "redis-op";
+        "promise-continuation": "promise-continuation";
+        "state-store": "state-store";
+        "state-update": "state-update";
+        selector: "selector";
+        "selector-update": "selector-update";
+        "visual-frame": "visual-frame";
+        "visual-violation": "visual-violation";
+        "style-change": "style-change";
+        "layout-change": "layout-change";
+        "memory-owner": "memory-owner";
+        "memory-mutation": "memory-mutation";
+        "memory-retention": "memory-retention";
+        "heap-snapshot": "heap-snapshot";
+        "build-event": "build-event";
+        "lint-event": "lint-event";
+        "typecheck-event": "typecheck-event";
+        "test-event": "test-event";
+        "bundle-report": "bundle-report";
+    }>;
+    logicalId: z.ZodOptional<z.ZodString>;
+    instanceId: z.ZodOptional<z.ZodString>;
+    generation: z.ZodOptional<z.ZodNumber>;
+    lifecycle: z.ZodEnum<{
+        created: "created";
+        active: "active";
+        completed: "completed";
+        disposed: "disposed";
+        errored: "errored";
+    }>;
+    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>;
+    name: z.ZodString;
+    startTime: z.ZodNumber;
+    endTime: z.ZodOptional<z.ZodNumber>;
+    durationMs: z.ZodOptional<z.ZodNumber>;
+    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>>;
+    attributes: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, z.core.$strip>;
+export type TraceNode = z.infer<typeof TraceNodeSchema>;
+//# sourceMappingURL=node.d.ts.map

package/lib/node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"node.d.ts","sourceRoot":"","sources":["../../src/lib/node.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAuE9B,CAAC;AACH,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAEhE,eAAO,MAAM,eAAe;;;;;;EAM1B,CAAC;AACH,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AAExD,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAmB1B,CAAC;AAEH,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC"}

package/lib/node.js

@@ -0,0 +1,98 @@
+import { z } from 'zod';
+import { SourceLocationSchema } from './source-location.js';
+import { TraceContextSchema } from './context.js';
+export const TraceNodeTypeSchema = z.enum([
+    // Browser process tree
+    'session',
+    'browser-context',
+    'tab',
+    'renderer',
+    'router',
+    'route',
+    'page',
+    // React UI
+    'component',
+    'element',
+    'slot',
+    'render',
+    'react-mount',
+    'react-unmount',
+    'hook',
+    'effect',
+    'effect-run',
+    'memo',
+    'memo-compute',
+    // User interaction
+    'ui-event',
+    'handler',
+    'animation',
+    'animation-frame',
+    'transition',
+    'timer',
+    // Network / API
+    'api-client-call',
+    'http-request',
+    'http-response',
+    // Backend
+    'server-process',
+    'nest-app',
+    'nest-module',
+    'nest-provider',
+    'singleton-instance',
+    'server-request',
+    'guard',
+    'controller',
+    'service-method',
+    'loop',
+    'loop-iteration',
+    'queue-job',
+    'db-query',
+    'redis-op',
+    'promise',
+    'promise-continuation',
+    // State
+    'state-store',
+    'state-update',
+    'selector',
+    'selector-update',
+    // Visual
+    'visual-frame',
+    'visual-violation',
+    'style-change',
+    'layout-change',
+    // Memory
+    'memory-owner',
+    'memory-mutation',
+    'memory-retention',
+    'heap-snapshot',
+    // Build / dev
+    'build-event',
+    'lint-event',
+    'typecheck-event',
+    'test-event',
+    'bundle-report',
+    'hmr-update',
+]);
+export const LifecycleSchema = z.enum([
+    'created',
+    'active',
+    'completed',
+    'disposed',
+    'errored',
+]);
+export const TraceNodeSchema = z.object({
+    id: z.string(),
+    parentTraceNodeId: z.string().optional(),
+    type: TraceNodeTypeSchema,
+    logicalId: z.string().optional(),
+    instanceId: z.string().optional(),
+    generation: z.number().int().nonnegative().optional(),
+    lifecycle: LifecycleSchema,
+    context: TraceContextSchema,
+    name: z.string(),
+    startTime: z.number().int().nonnegative(),
+    endTime: z.number().int().nonnegative().optional(),
+    durationMs: z.number().nonnegative().optional(),
+    location: SourceLocationSchema.optional(),
+    attributes: z.record(z.string(), z.unknown()),
+});

package/lib/resources.d.ts

@@ -0,0 +1,205 @@
+import { z } from 'zod';
+/**
+ * Well-known URI schemes used by LensMCP. See `planning/03-mcp-surface.md`.
+ * Each scheme maps 1:1 to a FrontMCP @App package.
+ */
+export declare const URI_SCHEMES: readonly ["agent", "events", "build", "lint", "typecheck", "test", "runtime", "render", "visual", "flow", "story", "trace", "graph", "bundle", "security", "perf", "deps", "memory", "browser", "react", "valtio", "nest", "next", "process"];
+export type UriScheme = (typeof URI_SCHEMES)[number];
+export declare const ResourceEnvelopeSchema: z.ZodObject<{
+    $schema: z.ZodOptional<z.ZodString>;
+    schemaVersion: z.ZodLiteral<1>;
+    revision: z.ZodNumber;
+    updatedAt: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type ResourceEnvelope = z.infer<typeof ResourceEnvelopeSchema>;
+export declare const AgentStatusKindSchema: z.ZodEnum<{
+    warning: "warning";
+    starting: "starting";
+    clean: "clean";
+    failing: "failing";
+}>;
+export type AgentStatusKind = z.infer<typeof AgentStatusKindSchema>;
+export declare const AgentBlockingItemSchema: z.ZodObject<{
+    source: z.ZodString;
+    severity: z.ZodEnum<{
+        error: "error";
+        debug: "debug";
+        info: "info";
+        warning: "warning";
+        fatal: "fatal";
+    }>;
+    title: z.ZodString;
+    fingerprint: z.ZodString;
+    resource: z.ZodString;
+    pageId: z.ZodOptional<z.ZodString>;
+    flowId: 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>>;
+}, z.core.$strip>;
+export type AgentBlockingItem = z.infer<typeof AgentBlockingItemSchema>;
+export declare const AgentChecksSchema: z.ZodObject<{
+    typecheck: z.ZodOptional<z.ZodEnum<{
+        unknown: "unknown";
+        passed: "passed";
+        failed: "failed";
+    }>>;
+    lint: z.ZodOptional<z.ZodEnum<{
+        unknown: "unknown";
+        passed: "passed";
+        failed: "failed";
+    }>>;
+    build: z.ZodOptional<z.ZodEnum<{
+        unknown: "unknown";
+        passed: "passed";
+        failed: "failed";
+    }>>;
+    runtime: z.ZodOptional<z.ZodEnum<{
+        warning: "warning";
+        unknown: "unknown";
+        passed: "passed";
+        failed: "failed";
+    }>>;
+    visual: z.ZodOptional<z.ZodEnum<{
+        warning: "warning";
+        unknown: "unknown";
+        passed: "passed";
+        failed: "failed";
+    }>>;
+    memory: z.ZodOptional<z.ZodEnum<{
+        warning: "warning";
+        unknown: "unknown";
+        passed: "passed";
+        failed: "failed";
+    }>>;
+}, z.core.$strip>;
+export declare const AgentCurrentStatusSchema: z.ZodObject<{
+    $schema: z.ZodOptional<z.ZodString>;
+    schemaVersion: z.ZodLiteral<1>;
+    revision: z.ZodNumber;
+    updatedAt: z.ZodOptional<z.ZodString>;
+    sessionId: z.ZodString;
+    status: z.ZodEnum<{
+        warning: "warning";
+        starting: "starting";
+        clean: "clean";
+        failing: "failing";
+    }>;
+    activeTab: z.ZodOptional<z.ZodString>;
+    tabsWithIssues: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    blocking: z.ZodArray<z.ZodObject<{
+        source: z.ZodString;
+        severity: z.ZodEnum<{
+            error: "error";
+            debug: "debug";
+            info: "info";
+            warning: "warning";
+            fatal: "fatal";
+        }>;
+        title: z.ZodString;
+        fingerprint: z.ZodString;
+        resource: z.ZodString;
+        pageId: z.ZodOptional<z.ZodString>;
+        flowId: 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>>;
+    }, z.core.$strip>>;
+    warnings: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        source: z.ZodString;
+        severity: z.ZodEnum<{
+            error: "error";
+            debug: "debug";
+            info: "info";
+            warning: "warning";
+            fatal: "fatal";
+        }>;
+        title: z.ZodString;
+        fingerprint: z.ZodString;
+        resource: z.ZodString;
+        pageId: z.ZodOptional<z.ZodString>;
+        flowId: 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>>;
+    }, z.core.$strip>>>;
+    suggestedReads: z.ZodArray<z.ZodString>;
+    checks: z.ZodOptional<z.ZodObject<{
+        typecheck: z.ZodOptional<z.ZodEnum<{
+            unknown: "unknown";
+            passed: "passed";
+            failed: "failed";
+        }>>;
+        lint: z.ZodOptional<z.ZodEnum<{
+            unknown: "unknown";
+            passed: "passed";
+            failed: "failed";
+        }>>;
+        build: z.ZodOptional<z.ZodEnum<{
+            unknown: "unknown";
+            passed: "passed";
+            failed: "failed";
+        }>>;
+        runtime: z.ZodOptional<z.ZodEnum<{
+            warning: "warning";
+            unknown: "unknown";
+            passed: "passed";
+            failed: "failed";
+        }>>;
+        visual: z.ZodOptional<z.ZodEnum<{
+            warning: "warning";
+            unknown: "unknown";
+            passed: "passed";
+            failed: "failed";
+        }>>;
+        memory: z.ZodOptional<z.ZodEnum<{
+            warning: "warning";
+            unknown: "unknown";
+            passed: "passed";
+            failed: "failed";
+        }>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type AgentCurrentStatus = z.infer<typeof AgentCurrentStatusSchema>;
+export declare const AgentSessionSchema: z.ZodObject<{
+    $schema: z.ZodOptional<z.ZodString>;
+    schemaVersion: z.ZodLiteral<1>;
+    revision: z.ZodNumber;
+    updatedAt: z.ZodOptional<z.ZodString>;
+    sessionId: z.ZodString;
+    supportedResources: z.ZodArray<z.ZodString>;
+    supportedTools: z.ZodArray<z.ZodString>;
+    supportedJobs: z.ZodArray<z.ZodString>;
+    supportedChannels: z.ZodArray<z.ZodString>;
+    subscribedByDefault: z.ZodArray<z.ZodString>;
+    transports: z.ZodArray<z.ZodEnum<{
+        stdio: "stdio";
+        http: "http";
+        socket: "socket";
+    }>>;
+    host: z.ZodObject<{
+        platform: z.ZodString;
+        node: z.ZodString;
+    }, z.core.$strip>;
+    project: z.ZodObject<{
+        name: z.ZodString;
+        nxVersion: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type AgentSession = z.infer<typeof AgentSessionSchema>;
+//# sourceMappingURL=resources.d.ts.map

package/lib/resources.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resources.d.ts","sourceRoot":"","sources":["../../src/lib/resources.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB;;;GAGG;AACH,eAAO,MAAM,WAAW,+OAyBd,CAAC;AACX,MAAM,MAAM,SAAS,GAAG,CAAC,OAAO,WAAW,CAAC,CAAC,MAAM,CAAC,CAAC;AAIrD,eAAO,MAAM,sBAAsB;;;;;iBAKjC,CAAC;AACH,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAItE,eAAO,MAAM,qBAAqB;;;;;EAKhC,CAAC;AACH,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAEpE,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;iBASlC,CAAC;AACH,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAExE,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAO5B,CAAC;AAEH,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBASnC,CAAC;AACH,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAI1E,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;iBAgB7B,CAAC;AACH,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC"}

package/lib/resources.js

@@ -0,0 +1,94 @@
+import { z } from 'zod';
+import { SCHEMA_VERSION } from './schema-version.js';
+import { SourceLocationSchema } from './source-location.js';
+import { SeveritySchema } from './event.js';
+/**
+ * Well-known URI schemes used by LensMCP. See `planning/03-mcp-surface.md`.
+ * Each scheme maps 1:1 to a FrontMCP @App package.
+ */
+export const URI_SCHEMES = [
+    'agent',
+    'events',
+    'build',
+    'lint',
+    'typecheck',
+    'test',
+    'runtime',
+    'render',
+    'visual',
+    'flow',
+    'story',
+    'trace',
+    'graph',
+    'bundle',
+    'security',
+    'perf',
+    'deps',
+    'memory',
+    'browser',
+    'react',
+    'valtio',
+    'nest',
+    'next',
+    'process',
+];
+// -------- shared header on every resource JSON --------
+export const ResourceEnvelopeSchema = z.object({
+    $schema: z.string().optional(),
+    schemaVersion: z.literal(SCHEMA_VERSION),
+    revision: z.number().int().nonnegative(),
+    updatedAt: z.string().datetime().optional(),
+});
+// -------- agent://current-status --------
+export const AgentStatusKindSchema = z.enum([
+    'starting',
+    'clean',
+    'warning',
+    'failing',
+]);
+export const AgentBlockingItemSchema = z.object({
+    source: z.string(),
+    severity: SeveritySchema,
+    title: z.string(),
+    fingerprint: z.string(),
+    resource: z.string(),
+    pageId: z.string().optional(),
+    flowId: z.string().optional(),
+    location: SourceLocationSchema.optional(),
+});
+export const AgentChecksSchema = z.object({
+    typecheck: z.enum(['passed', 'failed', 'unknown']).optional(),
+    lint: z.enum(['passed', 'failed', 'unknown']).optional(),
+    build: z.enum(['passed', 'failed', 'unknown']).optional(),
+    runtime: z.enum(['passed', 'failed', 'warning', 'unknown']).optional(),
+    visual: z.enum(['passed', 'failed', 'warning', 'unknown']).optional(),
+    memory: z.enum(['passed', 'failed', 'warning', 'unknown']).optional(),
+});
+export const AgentCurrentStatusSchema = ResourceEnvelopeSchema.extend({
+    sessionId: z.string(),
+    status: AgentStatusKindSchema,
+    activeTab: z.string().optional(),
+    tabsWithIssues: z.array(z.string()).optional(),
+    blocking: z.array(AgentBlockingItemSchema),
+    warnings: z.array(AgentBlockingItemSchema).default([]),
+    suggestedReads: z.array(z.string()),
+    checks: AgentChecksSchema.optional(),
+});
+// -------- agent://session --------
+export const AgentSessionSchema = ResourceEnvelopeSchema.extend({
+    sessionId: z.string(),
+    supportedResources: z.array(z.string()),
+    supportedTools: z.array(z.string()),
+    supportedJobs: z.array(z.string()),
+    supportedChannels: z.array(z.string()),
+    subscribedByDefault: z.array(z.string()),
+    transports: z.array(z.enum(['stdio', 'http', 'socket'])),
+    host: z.object({
+        platform: z.string(),
+        node: z.string(),
+    }),
+    project: z.object({
+        name: z.string(),
+        nxVersion: z.string().optional(),
+    }),
+});

package/lib/schema-version.d.ts

@@ -0,0 +1,3 @@
+export declare const SCHEMA_VERSION: 1;
+export type SchemaVersion = typeof SCHEMA_VERSION;
+//# sourceMappingURL=schema-version.d.ts.map

package/lib/schema-version.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema-version.d.ts","sourceRoot":"","sources":["../../src/lib/schema-version.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,cAAc,EAAG,CAAU,CAAC;AACzC,MAAM,MAAM,aAAa,GAAG,OAAO,cAAc,CAAC"}

package/lib/schema-version.js

@@ -0,0 +1 @@
+export const SCHEMA_VERSION = 1;

package/lib/source-location.d.ts

@@ -0,0 +1,11 @@
+import { z } from 'zod';
+export declare const SourceLocationSchema: 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>;
+export type SourceLocation = z.infer<typeof SourceLocationSchema>;
+//# sourceMappingURL=source-location.d.ts.map

package/lib/source-location.d.ts.map

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

package/lib/source-location.js

@@ -0,0 +1,9 @@
+import { z } from 'zod';
+export const SourceLocationSchema = z.object({
+    file: z.string(),
+    line: z.number().int().nonnegative().optional(),
+    column: z.number().int().nonnegative().optional(),
+    symbol: z.string().optional(),
+    componentName: z.string().optional(),
+    hookName: z.string().optional(),
+});

package/lib/tokens.d.ts

@@ -0,0 +1,14 @@
+/**
+ * DI tokens for FrontMCP `@Provider` registrations. Each token is paired
+ * with a TypeScript interface declared by the package that owns it, so
+ * consumers can type the `this.get(Token)` call by importing the
+ * companion type. We keep the *interfaces* abstract in this package and
+ * let `@lensmcp/core` etc. ship their concrete classes.
+ */
+export declare const SessionToken: unique symbol;
+export declare const EventBusToken: unique symbol;
+export declare const GraphStoreToken: unique symbol;
+export declare const ResourceStoreToken: unique symbol;
+export declare const StorageToken: unique symbol;
+export type LensmcpToken = typeof SessionToken | typeof EventBusToken | typeof GraphStoreToken | typeof ResourceStoreToken | typeof StorageToken;
+//# sourceMappingURL=tokens.d.ts.map

package/lib/tokens.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tokens.d.ts","sourceRoot":"","sources":["../../src/lib/tokens.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,eAAO,MAAM,YAAY,eAAyC,CAAC;AACnE,eAAO,MAAM,aAAa,eAAuC,CAAC;AAClE,eAAO,MAAM,eAAe,eAAyC,CAAC;AACtE,eAAO,MAAM,kBAAkB,eAA4C,CAAC;AAC5E,eAAO,MAAM,YAAY,eAAyC,CAAC;AAEnE,MAAM,MAAM,YAAY,GACpB,OAAO,YAAY,GACnB,OAAO,aAAa,GACpB,OAAO,eAAe,GACtB,OAAO,kBAAkB,GACzB,OAAO,YAAY,CAAC"}

package/lib/tokens.js

@@ -0,0 +1,12 @@
+/**
+ * DI tokens for FrontMCP `@Provider` registrations. Each token is paired
+ * with a TypeScript interface declared by the package that owns it, so
+ * consumers can type the `this.get(Token)` call by importing the
+ * companion type. We keep the *interfaces* abstract in this package and
+ * let `@lensmcp/core` etc. ship their concrete classes.
+ */
+export const SessionToken = Symbol.for('@lensmcp/session/Session');
+export const EventBusToken = Symbol.for('@lensmcp/core/EventBus');
+export const GraphStoreToken = Symbol.for('@lensmcp/core/GraphStore');
+export const ResourceStoreToken = Symbol.for('@lensmcp/core/ResourceStore');
+export const StorageToken = Symbol.for('@lensmcp/storage/Storage');