@vibesdotdev/mcp 0.0.0-stage → 1.0.0-rc.1

package/dist/docs/server.docs.descriptor.js

@@ -0,0 +1,383 @@
+const descriptor = {
+    kind: 'docs/topic',
+    id: 'mcp.server',
+    title: 'MCP Server',
+    summary: 'Model Context Protocol server setup, transport, and lifecycle',
+    body: {
+        type: 'markdown',
+        sourceType: 'raw',
+        source: `---
+title: MCP Server
+summary: Model Context Protocol server setup and lifecycle management
+tags: [mcp, server, transport, lifecycle, protocol]
+parent: mcp
+order: 1
+surfaces: [cli, web, in-app]
+hardware: [consumer, cloud]
+man:
+  name: "mcp.server — MCP server setup and lifecycle"
+  section: 1
+  synopsis: "vibes man mcp.server"
+  seeAlso: ["mcp.tools", "dev.mcp.start", "dev.mcp.serve"]
+---
+
+The **Model Context Protocol (MCP)** server enables AI agents to discover and invoke tools, access resources, and use prompts from the runtime.
+
+## Server architecture
+
+MCP server exposes runtime capabilities via standard protocol:
+
+\`\`\`
+┌─────────────────┐
+│   MCP Client    │  ←→  MCP Protocol (JSON-RPC)
+│  (Claude, etc.) │
+└─────────────────┘
+         ↓
+┌─────────────────┐
+│  MCP Server     │  ←→  Runtime (tools/resources/prompts)
+│  (@vibesdotdev/mcp)
+└─────────────────┘
+\`\`\`
+
+## Transport modes
+
+### Stdio transport (default)
+
+Communicate via standard streams:
+
+\`\`\`ts
+import { createMcpAdapter } from '@vibesdotdev/mcp/adapters/mcp';
+
+const adapter = createMcpAdapter(runtime, { mode: 'stdio', preset: 'full' }, logger);
+await adapter.start();
+// On host shutdown:
+await adapter.shutdown();
+\`\`\`
+
+**Use when:** Local MCP clients (Claude Desktop, IDE plugins).
+
+### HTTP transport (Web Standard streamable HTTP)
+
+Bun-native HTTP server using Web Standard APIs (not SSE):
+
+\`\`\`ts
+import { createBunMcpServer } from '@vibesdotdev/mcp/adapters';
+import { createMcpAuthenticator } from '@vibesdotdev/mcp';
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { getRuntimeHttpListener } from '@vibesdotdev/kernel';
+
+const server = createBunMcpServer({
+  listener: getRuntimeHttpListener(runtime),
+  port: 3001,
+  hostname: '0.0.0.0',
+  buildServer: () => new McpServer({ name: 'my-server', version: '1.0.0' }),
+  logger: myLogger,
+  lifecycle: runtime.lifecycle,
+  authenticate: createMcpAuthenticator({ remote: true, scope: 'mcp' })
+});
+
+await server.start();
+\`\`\`
+
+\`lifecycle\` is the serving runtime's: idle sessions expire per request on every
+host, and a persistent host also sweeps them on its runtime-owned interval (a
+finite host has no background sweep). Disposing the runtime clears it.
+
+**Use when:** Remote MCP clients, cloud deployments, Workers (use \`createMcpFetchHandler\` instead of \`createBunMcpServer\` in a Workers environment).
+
+**Note:** This transport uses Web Standard streamable HTTP (MCP Streamable HTTP transport; the SDK negotiates protocol version, defaulting to 2025-03-26 and supporting up to 2025-11-25). There are no \`/mcp/sse\` or \`/mcp/message\` endpoints — the server handles all MCP traffic through a single fetch handler.
+
+## Server lifecycle
+
+### Starting MCP server
+
+\`\`\`bash
+vibes dev mcp start
+\`\`\`
+
+Starts MCP server in background with stdio transport.
+
+### Serving HTTP endpoint
+
+\`\`\`bash
+vibes dev mcp serve --port 3001
+\`\`\`
+
+Starts HTTP server using Web Standard streamable HTTP transport (not SSE).
+
+### Stopping server
+
+\`\`\`bash
+vibes dev mcp stop
+\`\`\`
+
+Gracefully shuts down server.
+
+### Restarting server
+
+\`\`\`bash
+vibes dev mcp restart
+\`\`\`
+
+Stops and restarts server (picks up config changes).
+
+## Server configuration
+
+### MCP adapter options
+
+\`\`\`ts
+import type { McpAdapterOptions } from '@vibesdotdev/mcp';
+import { createMcpAdapter } from '@vibesdotdev/mcp/adapters/mcp';
+import { createMcpAuthenticator } from '@vibesdotdev/mcp';
+
+// \`runtime\` is the VibesRuntime handed to your host entry. The token is a credential.
+const token = await runtime.resolveCredential({ source: 'secret', key: 'MCP_TOKEN' });
+if (!token.ok) throw token.error;
+
+const options: McpAdapterOptions = {
+  mode: 'http',                         // 'stdio' | 'http'
+  mcpClientId: 'claude-desktop',        // Client identifier (optional)
+  logLevel: 'info',                     // LogLevel (optional)
+  toolExecutionTimeoutMs: 30_000,       // Per-tool timeout (optional)
+  port: 3001,                           // http mode only
+  authenticate: createMcpAuthenticator({
+    apiKeys: [token.value],
+    scope: 'mcp'
+  })                                    // optional; omit for unauthenticated
+};
+
+const server = createMcpAdapter(runtime, options, logger);
+\`\`\`
+
+### Capability negotiation
+
+Server advertises capabilities during handshake:
+
+\`\`\`ts
+capabilities: {
+  tools: { listChanged: true },      // Tool discovery
+  resources: { listChanged: true },  // Resource access
+  prompts: { listChanged: true }     // Prompt templates
+}
+\`\`\`
+
+Clients can request specific capabilities.
+
+## Tool registration
+
+Tools are auto-discovered from runtime:
+
+\`\`\`ts
+const descriptors = runtime.query('tools/tool').descriptors();
+for (const descriptor of descriptors) {
+  server.registerTool(
+    descriptor.id,
+    {
+      title: descriptor.name,
+      description: descriptor.description,
+      inputSchema: descriptor.schemas.input,
+      outputSchema: descriptor.schemas.output
+    },
+    async (args) => {
+      return invokeTool({ runtime, toolId: descriptor.id, input: args });
+    }
+  );
+}
+\`\`\`
+
+## Resource registration
+
+Resources provide read-only data access:
+
+\`\`\`ts
+server.registerResource(
+  'workspace-files',
+  'file://workspace/**',
+  {
+    description: 'Workspace file contents',
+    mimeType: 'text/plain'
+  },
+  async (uri) => {
+    const content = await fs.read(uri.pathname);
+    return {
+      contents: [{
+        uri: uri.href,
+        mimeType: 'text/plain',
+        text: content
+      }]
+    };
+  }
+);
+\`\`\`
+
+## Prompt registration
+
+Prompts provide templated messages:
+
+\`\`\`ts
+server.registerPrompt(
+  'code-review',
+  {
+    description: 'Review code for best practices',
+    argsSchema: {
+      filePath: z.string().describe('File to review')
+    }
+  },
+  async (args) => {
+    const code = await fs.read(args.filePath);
+    return {
+      messages: [{
+        role: 'user',
+        content: {
+          type: 'text',
+          text: \`Review this code:\\n\\n\${code}\`
+        }
+      }]
+    };
+  }
+);
+\`\`\`
+
+## Authentication
+
+### Bearer token auth (local allowlist)
+
+Pass allowed API keys directly. The returned function is passed as \`authenticate\` to the transport or adapter options.
+
+\`\`\`ts
+import { createMcpAuthenticator } from '@vibesdotdev/mcp';
+
+const token = await runtime.resolveCredential({ source: 'secret', key: 'MCP_TOKEN' });
+if (!token.ok) throw token.error;
+
+const authenticate = createMcpAuthenticator({
+  apiKeys: [token.value],
+  scope: 'mcp'
+});
+
+// Pass to createBunMcpServer:
+const server = createBunMcpServer({ ..., authenticate });
+
+// Or pass to createMcpAdapter:
+const adapter = createMcpAdapter(runtime, { ..., authenticate }, logger);
+\`\`\`
+
+### Remote validation (cloud mode)
+
+For cloud deployments, configure the host-owned authentication API endpoint:
+
+\`\`\`ts
+const authenticate = createMcpAuthenticator({
+  remote: true,
+  scope: 'mcp',
+  authApiBaseUrl: 'https://auth.example.test' // supplied by host composition
+});
+\`\`\`
+
+## Logging
+
+MCP server emits structured logs on the logger of the runtime it was handed (never a module-level logger, which has no runtime):
+
+\`\`\`ts
+import { getLogger } from '@vibesdotdev/logging';
+
+const logger = getLogger('mcp', runtime);
+logger.info('MCP server started', {
+  transport: 'stdio',
+  capabilities: ['tools', 'resources']
+});
+\`\`\`
+
+**Log levels:**
+- \`debug\` — Protocol messages
+- \`info\` — Lifecycle events
+- \`warn\` — Non-critical errors
+- \`error\` — Critical failures
+
+## WRONG: Manual protocol handling
+
+\`\`\`ts
+// ❌ NEVER — use createMcpAdapter instead
+const server = new McpServer({ name: 'custom', version: '1.0' });
+// Manual tool registration...
+\`\`\`
+
+## RIGHT: Runtime-integrated server
+
+\`\`\`ts
+// ✅ Auto-discovers tools/resources/prompts
+const server = createMcpAdapter(runtime, options, logger);
+\`\`\`
+
+## MCP client configuration
+
+### Claude Desktop
+
+\`\`\`json
+{
+  "mcpServers": {
+    "vibes": {
+      "command": "vibes",
+      "args": ["dev", "mcp", "start"]
+    }
+  }
+}
+\`\`\`
+
+### Cursor IDE (and any stdio-capable client)
+
+\`\`\`json
+{
+  "mcpServers": {
+    "vibes": {
+      "type": "stdio",
+      "command": "vibes",
+      "args": ["dev", "mcp", "serve", "--mode", "stdio", "--client", "claude"]
+    }
+  }
+}
+\`\`\`
+
+The stdio relay attaches to the shared runtime host, so there is no fixed URL
+to configure. The HTTP transport's port is derived per workspace (there is no
+fixed \`3001\`) — run \`vibes dev mcp status\` to see the port the current
+workspace is serving on before pointing an HTTP client at it. \`--client\` is
+the legacy catalog/harness selector; \`vibes dev mcp serve --help\` lists the
+newer \`--preset\` / \`--harness\` / \`--agent\` knobs.
+
+## Monitoring
+
+Adapters expose start() and shutdown(). They do not expose an event emitter.
+Pass the runtime logger to observe protocol and listener failures. For tool-call
+instrumentation, supply prepareToolCallContext on the tool-aware adapter; it
+receives the canonical tool id, validated input and prepared context before
+invocation. Return the context to preserve the serving authority.
+
+Use the projection doctor and live tool audit to compare the observed wire
+catalog with authored descriptors. They report measured bytes, schema loss and
+description drift; policy audit findings and high-severity wire findings retain
+their distinct verdicts.
+
+:::card{title="See also"}
+- [\`mcp.tools\`](mcp.tools) — MCP tool exposure
+- [\`mcp.resources\`](mcp.resources) — MCP resources
+- [\`mcp.prompts\`](mcp.prompts) — MCP prompts
+- \`dev.mcp.start\` — Start command reference
+:::
+`
+    },
+    parent: 'mcp',
+    order: 1,
+    tags: ['mcp', 'server', 'transport', 'lifecycle', 'protocol'],
+    surfaces: ['cli', 'web', 'in-app'],
+    hardware: ['consumer', 'cloud'],
+    man: {
+        name: 'mcp.server — MCP server setup and lifecycle',
+        section: 1,
+        synopsis: 'vibes man mcp.server',
+        seeAlso: ['mcp.tools', 'dev.mcp.start', 'dev.mcp.serve']
+    },
+    enabled: true
+};
+export default descriptor;
+//# sourceMappingURL=server.docs.descriptor.js.map

package/dist/docs/server.docs.descriptor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"server.docs.descriptor.js","sourceRoot":"","sources":["../../src/docs/server.docs.descriptor.ts"],"names":[],"mappings":"AAEA,MAAM,UAAU,GAAwB;IACtC,IAAI,EAAE,YAAY;IAClB,EAAE,EAAE,YAAY;IAChB,KAAK,EAAE,YAAY;IACnB,OAAO,EAAE,+DAA+D;IACxE,IAAI,EAAE;QACJ,IAAI,EAAE,UAAU;QAChB,UAAU,EAAE,KAAK;QACjB,MAAM,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAsWX;KACE;IACD,MAAM,EAAE,KAAK;IACb,KAAK,EAAE,CAAC;IACR,IAAI,EAAE,CAAC,KAAK,EAAE,QAAQ,EAAE,WAAW,EAAE,WAAW,EAAE,UAAU,CAAC;IAC7D,QAAQ,EAAE,CAAC,KAAK,EAAE,KAAK,EAAE,QAAQ,CAAC;IAClC,QAAQ,EAAE,CAAC,UAAU,EAAE,OAAO,CAAC;IAC/B,GAAG,EAAE;QACH,IAAI,EAAE,6CAA6C;QACnD,OAAO,EAAE,CAAC;QACV,QAAQ,EAAE,sBAAsB;QAChC,OAAO,EAAE,CAAC,WAAW,EAAE,eAAe,EAAE,eAAe,CAAC;KACzD;IACD,OAAO,EAAE,IAAI;CACd,CAAC;AAEF,eAAe,UAAU,CAAC"}

package/dist/docs/tools.docs.descriptor.d.ts

@@ -0,0 +1,4 @@
+import type { DocsTopicDescriptor } from '@vibesdotdev/docs-contracts';
+declare const descriptor: DocsTopicDescriptor;
+export default descriptor;
+//# sourceMappingURL=tools.docs.descriptor.d.ts.map

package/dist/docs/tools.docs.descriptor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tools.docs.descriptor.d.ts","sourceRoot":"","sources":["../../src/docs/tools.docs.descriptor.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,6BAA6B,CAAC;AAEvE,QAAA,MAAM,UAAU,EAAE,mBAyTjB,CAAC;AAEF,eAAe,UAAU,CAAC"}

package/dist/docs/tools.docs.descriptor.js

@@ -0,0 +1,316 @@
+const descriptor = {
+    kind: 'docs/topic',
+    id: 'mcp.tools',
+    title: 'MCP Tools',
+    summary: 'Tool exposure, discovery, and invocation via MCP protocol',
+    body: {
+        type: 'markdown',
+        sourceType: 'raw',
+        source: `---
+title: MCP Tools
+summary: Expose and invoke runtime tools via Model Context Protocol
+tags: [mcp, tools, discovery, invocation, adapters]
+parent: mcp
+order: 2
+surfaces: [cli, web, in-app]
+hardware: [consumer, cloud]
+---
+
+MCP **tools** are callable functions exposed to AI clients. The MCP server auto-discovers \`tools/tool\` descriptors from the runtime and exposes them via the protocol.
+
+MCP owns one orientation tool: \`vibes-context\`. It returns a read-only snapshot of workspace path, project id, atlas index, workspace file index, and the bound work session. Chat surfaces render that payload with a designed Kit \`ToolCard\` registered as \`tools/ui\` by \`@vibesdotdev/mcp/svelte/plugin\` — not a JSON dump and not a host-local card table.
+
+## Tool discovery
+
+MCP server queries runtime for available tools:
+
+\`\`\`ts
+const descriptors = runtime.query('tools/tool').descriptors();
+const enabled = runtime.query('tools/tool').enabled().descriptors();
+\`\`\`
+
+Tools are filtered based on:
+1. **Enabled status** — Disabled tools not exposed
+2. **MCP client ID** — Some tools client-specific
+3. **Safety category** — High-risk tools may require approval
+
+## Tool exposure
+
+Each tool registers with MCP server:
+
+\`\`\`ts
+server.registerTool(
+  descriptor.id,
+  {
+    title: descriptor.name ?? descriptor.id,
+    description: resolveMcpDescription(descriptor),
+    inputSchema: flattenDiscriminatedUnion(descriptor.schemas.input),
+    outputSchema: descriptor.schemas.output,
+    annotations: deriveMcpAnnotations(descriptor.safety)
+  },
+  async (args, extra) => {
+    // Invoke through runtime
+    const result = await invokeTool({
+      runtime,
+      toolId: descriptor.id,
+      input: args,
+      ctx: {
+        callId: \`mcp_\${Date.now()}_\${crypto.randomUUID()}\`,
+        signal: extra.signal,
+        sendProgress: extra.sendProgress
+      }
+    });
+    
+    return formatMcpResponse(result);
+  }
+);
+\`\`\`
+
+## Schema conversion
+
+A tool's \`schemas.input\` zod schema is converted to MCP JSON Schema by the MCP
+adapter when it serves \`tools/list\` (Zod's JSON Schema generation, then pattern and
+union-branch tightening). Tool authors write the zod schema; there is no conversion
+call to make:
+
+\`\`\`ts
+schemas: {
+  input: z.object({
+    path: z.string().describe('File path to read'),
+    encoding: z.enum(['utf8', 'binary']).optional()
+  })
+}
+\`\`\`
+
+**Supported Zod features:**
+- ✅ \`z.string()\`, \`z.number()\`, \`z.boolean()\`
+- ✅ \`z.object()\` with nested properties
+- ✅ \`z.enum()\` for fixed options
+- ✅ \`z.array()\` for lists
+- ✅ \`z.optional()\` for optional fields
+- ✅ \`z.describe()\` for field descriptions
+
+**Discriminated unions:** Flattened to merged object schema:
+
+\`\`\`ts
+// Zod discriminated union
+const schema = z.discriminatedUnion('action', [
+  z.object({ action: z.literal('read'), path: z.string() }),
+  z.object({ action: z.literal('write'), path: z.string(), content: z.string() })
+]);
+
+// MCP schema (flattened)
+{
+  type: 'object',
+  properties: {
+    action: { type: 'string', enum: ['read', 'write'] },
+    path: { type: 'string' },
+    content: { type: 'string', optional: true }
+  }
+}
+\`\`\`
+
+## Tool annotations
+
+MCP annotations provide hints to clients:
+
+\`\`\`ts
+annotations: {
+  readOnlyHint: true,      // Tool doesn't modify state
+  destructiveHint: false,  // Tool doesn't delete/destroy
+  idempotentHint: true,    // Multiple calls = same result
+  openWorldHint: false     // Tool operates in closed system
+}
+\`\`\`
+
+Derived from tool safety category:
+- \`read\` → readOnlyHint: true
+- \`write\` → destructiveHint: true
+- \`execute\` → openWorldHint: true
+
+## Tool invocation flow
+
+\`\`\`
+1. MCP client calls tools/list
+   ↓
+2. Server returns available tools
+   ↓
+3. Client calls tools/call with tool ID + args
+   ↓
+4. Server invokes tool via runtime.invokeTool()
+   ↓
+5. Tool executes (may call other tools, access resources)
+   ↓
+6. Result formatted as MCP response
+   ↓
+7. Client receives result
+\`\`\`
+
+## Response formatting
+
+Tool results formatted per MCP spec:
+
+\`\`\`ts
+// String result
+{
+  content: [{ type: 'text', text: 'Operation successful' }]
+}
+
+// Object result
+{
+  content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+  structuredContent: result  // Typed data for clients
+}
+
+// MCP content (from tool)
+{
+  content: [
+    { type: 'text', text: 'Processing...' },
+    { type: 'resource_link', name: 'file.txt', uri: 'file://file.txt' }
+  ]
+}
+
+// Error result
+{
+  content: [{ type: 'text', text: 'Error: Permission denied' }],
+  isError: true,
+  _meta: {
+    errorCode: 'PERMISSION_DENIED',
+    recoveryHint: 'Grant workspace access first',
+    suggestedToolCall: {
+      toolId: 'workspace-grant',
+      input: { path: '/workspace' }
+    }
+  }
+}
+\`\`\`
+
+## Trust tags
+
+Tool outputs wrapped with trust tags for prompt injection protection:
+
+\`\`\`ts
+// Trust tier derived from safety category
+const trustTier = deriveTrustTier(descriptor);  // 'low' | 'medium' | 'high'
+
+// Wrap output with nonce-tagged boundary
+const wrapped = wrapToolOutputText({
+  toolId: descriptor.id,
+  tier: trustTier,
+  text: result,
+  nonce: callNonce  // Unique per tool call
+});
+\`\`\`
+
+Prevents injected instructions in tool output from impersonating system content.
+
+## Progress reporting
+
+Tools can report progress during execution:
+
+\`\`\`ts
+async (args, extra) => {
+  extra.sendProgress?.({
+    progress: 0.5,  // 50% complete
+    total: 100,
+    message: 'Processing files...'
+  });
+  
+  const result = await invokeTool({ ... });
+  return formatMcpResponse(result);
+}
+\`\`\`
+
+## Cancellation
+
+Tools support cancellation via AbortSignal:
+
+\`\`\`ts
+async (args, extra) => {
+  if (extra.signal?.aborted) {
+    throw new Error('Tool call cancelled');
+  }
+  
+  return invokeTool({
+    ...,
+    ctx: { signal: extra.signal }
+  });
+}
+\`\`\`
+
+## Tool selection presets
+
+MCP clients can request tool subsets:
+
+\`\`\`ts
+import { selectMcpTools } from '@vibesdotdev/mcp/adapters/mcp';
+
+const selected = selectMcpTools(descriptors, {
+  mcpClientId: 'claude-desktop',
+  preset: 'minimal'  // or 'full', 'safe-only'
+});
+\`\`\`
+
+**Presets:**
+- \`minimal\` — Read-only tools (workspace-fs, workspace-fs)
+- \`safe\` — Read + write with confirmation
+- \`full\` — All tools including execute
+
+## WRONG: Manual tool registration
+
+\`\`\`ts
+// ❌ NEVER — bypasses auto-discovery
+server.registerTool('my-tool', {...}, handler);
+\`\`\`
+
+## RIGHT: Runtime auto-discovery
+
+\`\`\`ts
+// ✅ Server auto-discovers all tools/tool descriptors
+const server = buildServer(runtime, options, logger);
+\`\`\`
+
+## Tool debugging
+
+Enable debug logging:
+
+\`\`\`bash
+vibes dev mcp start --log-level debug
+\`\`\`
+
+Logs show:
+- Tool discovery results
+- Schema conversion warnings
+- Invocation timing
+- Error details
+
+## Monitoring
+
+Track tool usage:
+
+\`\`\`ts
+runtime.on('tools/invocation', (event) => {
+  metrics.histogram('tools.duration', event.duration);
+  metrics.increment(\`tools.\${event.toolId}.calls\`);
+  
+  if (event.error) {
+    metrics.increment(\`tools.\${event.toolId}.errors\`);
+  }
+});
+\`\`\`
+
+:::card{title="See also"}
+- [\`mcp.server\`](mcp.server) — MCP server setup
+- [\`tools.invoke\`](tools.invoke) — invokeTool API
+:::
+`
+    },
+    parent: 'mcp',
+    order: 2,
+    tags: ['mcp', 'tools', 'discovery', 'invocation', 'adapters'],
+    surfaces: ['cli', 'web', 'in-app'],
+    hardware: ['consumer', 'cloud'],
+    enabled: true
+};
+export default descriptor;
+//# sourceMappingURL=tools.docs.descriptor.js.map

package/dist/docs/tools.docs.descriptor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tools.docs.descriptor.js","sourceRoot":"","sources":["../../src/docs/tools.docs.descriptor.ts"],"names":[],"mappings":"AAEA,MAAM,UAAU,GAAwB;IACtC,IAAI,EAAE,YAAY;IAClB,EAAE,EAAE,WAAW;IACf,KAAK,EAAE,WAAW;IAClB,OAAO,EAAE,2DAA2D;IACpE,IAAI,EAAE;QACJ,IAAI,EAAE,UAAU;QAChB,UAAU,EAAE,KAAK;QACjB,MAAM,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAySX;KACE;IACD,MAAM,EAAE,KAAK;IACb,KAAK,EAAE,CAAC;IACR,IAAI,EAAE,CAAC,KAAK,EAAE,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,UAAU,CAAC;IAC7D,QAAQ,EAAE,CAAC,KAAK,EAAE,KAAK,EAAE,QAAQ,CAAC;IAClC,QAAQ,EAAE,CAAC,UAAU,EAAE,OAAO,CAAC;IAC/B,OAAO,EAAE,IAAI;CACd,CAAC;AAEF,eAAe,UAAU,CAAC"}