@treenity/mods 3.0.2 → 3.0.3

package/mcp/mcp-server.ts

@@ -0,0 +1,393 @@
+// Treenity MCP Server — exposes tree store as MCP tools
+// StreamableHTTP transport, stateless, token auth via ?token= or Authorization header
+
+import { requestApproval } from '#agent/guardian';
+import { matchesAny } from '@treenity/core/glob';
+import { AiPolicy } from '#agent/types';
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
+import { createNode, getComponent } from '@treenity/core';
+import { verifyViewSource } from '@treenity/core/mods/uix/verify';
+import { TypeCatalog } from '@treenity/core/schema/catalog';
+import { executeAction } from '@treenity/core/server/actions';
+import { buildClaims, resolveToken, type Session, withAcl } from '@treenity/core/server/auth';
+import { deployPrefab } from '@treenity/core/server/prefab';
+import type { Tree } from '@treenity/core/tree';
+import { existsSync, readFileSync } from 'node:fs';
+import { createServer, type Server } from 'node:http';
+import { createServer as createHttpsServer } from 'node:https';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { z } from 'zod/v3';
+
+function loadDevCerts(): { key: Buffer; cert: Buffer } | null {
+  const home = homedir();
+  const keyPath = join(home, 'localhost+2-key.pem');
+  const certPath = join(home, 'localhost+2.pem');
+  if (!existsSync(keyPath) || !existsSync(certPath)) return null;
+  return { key: readFileSync(keyPath), cert: readFileSync(certPath) };
+}
+
+// Guardian policy check for MCP write operations
+// Reads global policy from /agents/guardian, checks deny → escalate → allow
+export type McpGuardianResult = { allowed: true } | { allowed: false; reason: string };
+
+
+export async function checkMcpGuardian(store: Tree, toolName: string, input?: string): Promise<McpGuardianResult> {
+  try {
+    const guardianNode = await store.get('/agents/guardian');
+    if (!guardianNode) return { allowed: false, reason: 'no Guardian configured at /agents/guardian — all writes denied' };
+
+    const policy = getComponent(guardianNode, AiPolicy);
+    if (!policy || policy.$type !== 'ai.policy') return { allowed: false, reason: 'invalid Guardian policy type — writes denied' };
+
+    const allow = (policy.allow as string[]) ?? [];
+    const deny = (policy.deny as string[]) ?? [];
+    const escalate = (policy.escalate as string[]) ?? [];
+
+    if (matchesAny(deny, toolName)) return { allowed: false, reason: `denied by Guardian: ${toolName}` };
+
+    if (matchesAny(escalate, toolName)) {
+      const approved = await requestApproval(store, {
+        agentPath: '/agents/mcp',
+        role: 'mcp',
+        tool: toolName,
+        input: input?.slice(0, 500) ?? '',
+        reason: 'MCP tool requires approval',
+      });
+      return approved
+        ? { allowed: true }
+        : { allowed: false, reason: 'denied by human' };
+    }
+
+    if (matchesAny(allow, toolName)) return { allowed: true };
+
+    // Unknown tool via MCP → deny by default (safer than escalate for external callers)
+    return { allowed: false, reason: `not in Guardian allow list: ${toolName}. Use Treenity Agent Office for write operations.` };
+  } catch (err) {
+    console.error('[mcp-guardian] failed to check policy:', err);
+    return { allowed: false, reason: 'Guardian check failed — writes denied for safety' };
+  }
+}
+
+/** Compact YAML-like serializer — readable for LLMs, much less noisy than JSON */
+function yaml(val: unknown, depth = 0, maxStr = 300): string {
+  const pad = '  '.repeat(depth);
+  if (val == null) return 'null';
+  if (typeof val === 'boolean' || typeof val === 'number') return String(val);
+  if (typeof val === 'string') {
+    if (maxStr < Infinity && val.length > maxStr) return JSON.stringify(val.slice(0, maxStr) + '…');
+    return /[\n\r:#\[\]{}",]/.test(val) || val === '' ? JSON.stringify(val) : val;
+  }
+  if (Array.isArray(val)) {
+    if (!val.length) return '[]';
+    if (val.every(v => typeof v !== 'object' || v == null)) {
+      const inline = `[${val.map(v => yaml(v, 0, maxStr)).join(', ')}]`;
+      if (inline.length < 80) return inline;
+    }
+    return val.map(item => {
+      if (typeof item !== 'object' || item == null) return `${pad}- ${yaml(item, 0, maxStr)}`;
+      const inner = yaml(item, depth + 1, maxStr);
+      const lines = inner.split('\n');
+      return lines.length === 1
+        ? `${pad}- ${lines[0].trimStart()}`
+        : `${pad}- ${lines[0].trimStart()}\n${lines.slice(1).map(l => `${pad}  ${l.trimStart()}`).join('\n')}`;
+    }).join('\n');
+  }
+  if (typeof val === 'object') {
+    const entries = Object.entries(val as Record<string, unknown>);
+    if (!entries.length) return '{}';
+    return entries.map(([k, v]) => {
+      if (v != null && typeof v === 'object') {
+        const inner = yaml(v, depth + 1, maxStr);
+        if (!inner.includes('\n') && inner.length < 60) return `${pad}${k}: ${inner.trimStart()}`;
+        return `${pad}${k}:\n${inner}`;
+      }
+      return `${pad}${k}: ${yaml(v, 0, maxStr)}`;
+    }).join('\n');
+  }
+  return String(val);
+}
+
+const text = (s: string) => ({ content: [{ type: 'text' as const, text: s }] });
+const catalog = new TypeCatalog();
+
+function dataKeys(node: Record<string, unknown>) {
+  return Object.keys(node).filter(k => !k.startsWith('$'));
+}
+
+export async function buildMcpServer(store: Tree, session: Session, claims?: string[]) {
+  claims ??= await buildClaims(store, session.userId);
+  const aclStore = withAcl(store, session.userId, claims);
+
+  const mcp = new McpServer({ name: 'treenity', version: '1.0.0' });
+
+  mcp.registerTool(
+    'get_node',
+    {
+      description: 'Read a node by path. Returns full untruncated values.',
+      inputSchema: { path: z.string() },
+    },
+    async ({ path }) => {
+      const node = await aclStore.get(path);
+      return text(node ? yaml(node, 0, Infinity) : `not found: ${path}`);
+    },
+  );
+
+  mcp.registerTool(
+    'list_children',
+    {
+      description: 'List children of a node. Long string values may be truncated — use get_node for full data.',
+      inputSchema: {
+        path: z.string(),
+        depth: z.number().optional(),
+        detail: z.boolean().optional().describe('Show first-level fields and component types'),
+        full: z.boolean().optional().describe('Return complete YAML of each node'),
+      },
+    },
+    async ({ path, depth, detail, full }) => {
+      const ctx = { queryContextPath: path, userId: session.userId };
+      const result = await aclStore.getChildren(path, { depth }, ctx);
+      const { items, total, truncated } = result;
+      const truncNote = truncated ? '\n⚠️ Results truncated — ACL scan limit reached. Use query mounts for large collections.' : '';
+
+      if (full) return text(yaml({ total, truncated, items }));
+
+      if (detail) {
+        const lines = items.map(n => {
+          const name = n.$path.split('/').at(-1);
+          const keys = dataKeys(n);
+          const header = n.$type === 'dir' ? `${name}/` : `${name}: ${n.$type}  [${keys.length}]`;
+          const fields = keys.map(k => {
+            const v = (n as Record<string, unknown>)[k];
+            if (v && typeof v === 'object' && '$type' in (v as object))
+              return `  ${k}: ${(v as Record<string, unknown>).$type}`;
+            if (Array.isArray(v)) return `  ${k}: [${v.length}]`;
+            const s = String(v);
+            return `  ${k}: ${s.length > 60 ? s.slice(0, 60) + '…' : s}`;
+          });
+          return header + (fields.length ? '\n' + fields.join('\n') : '');
+        });
+        return text(lines.join('\n') + `\n(${total} total)` + truncNote);
+      }
+
+      const lines = items.map(n => {
+        const name = n.$path.split('/').at(-1);
+        if (n.$type === 'dir') return `${name}/`;
+        return `${name}  ${n.$type}  [${dataKeys(n).length}]`;
+      });
+      return text(lines.join('\n') + (total > items.length ? `\n(${total} total)` : '') + truncNote);
+    },
+  );
+
+  mcp.registerTool(
+    'set_node',
+    {
+      description: 'Create or update a node. May require Guardian approval.',
+      inputSchema: {
+        path: z.string(),
+        type: z.string(),
+        components: z.record(z.unknown()).optional(),
+        acl: z.array(z.object({ g: z.string(), p: z.number() })).optional(),
+        owner: z.string().optional(),
+      },
+    },
+    async ({ path, type, components, acl, owner }) => {
+      const guard = await checkMcpGuardian(store, 'mcp__treenity__set_node', JSON.stringify({ path, type }));
+      if (!guard.allowed) return text(`🛑 Guardian: ${guard.reason}`);
+      const existing = await aclStore.get(path);
+      const node = existing ?? createNode(path, type);
+      if (!existing) node.$type = type;
+      if (components) {
+        for (const [k, v] of Object.entries(components)) {
+          if (k === '__proto__' || k === 'constructor' || k === 'prototype') continue;
+          const comp = v as Record<string, unknown> | null;
+          if (comp && typeof comp === 'object' && comp.$type === type) {
+            for (const [fk, fv] of Object.entries(comp)) {
+              if (fk !== '$type') node[fk] = fv;
+            }
+            continue;
+          }
+          node[k] = v;
+        }
+      }
+      if (acl) node.$acl = acl;
+      if (owner) node.$owner = owner;
+      await aclStore.set(node);
+      return text(yaml(node));
+    },
+  );
+
+  mcp.registerTool(
+    'execute',
+    {
+      description: 'Execute an action on a node or component. Actions are methods registered on types. May require Guardian approval.',
+      inputSchema: {
+        path: z.string(),
+        action: z.string(),
+        type: z.string().optional(),
+        key: z.string().optional(),
+        data: z.record(z.unknown()).optional(),
+      },
+    },
+    async ({ path, action, type, key, data }) => {
+      const guard = await checkMcpGuardian(store, 'mcp__treenity__execute', JSON.stringify({ path, action }));
+      if (!guard.allowed) return text(`🛑 Guardian: ${guard.reason}`);
+      // Action-level Guardian check — allows operators to deny/escalate specific actions
+      // e.g. deny "mcp__treenity__execute:run" to block flow execution
+      const actionGuard = await checkMcpGuardian(store, `mcp__treenity__execute:${action}`, JSON.stringify({ path }));
+      if (!actionGuard.allowed) return text(`🛑 Guardian: ${actionGuard.reason}`);
+      const result = await executeAction(aclStore, path, type, key, action, data);
+      return text(yaml(result ?? { ok: true }));
+    },
+  );
+
+  mcp.registerTool(
+    'deploy_prefab',
+    {
+      description: 'Deploy a module prefab (node tree template) to a target path. Idempotent: skips existing nodes. Browse available prefabs via list_children /sys/mods.',
+      inputSchema: {
+        source: z.string().describe('Prefab path: /sys/mods/{mod}/prefabs/{name}'),
+        target: z.string().describe('Target path where nodes will be created'),
+        allowAbsolute: z.boolean().optional().describe('Allow prefab to write outside target (e.g. /sys/autostart refs). Default: false'),
+      },
+    },
+    async ({ source, target, allowAbsolute }) => {
+      const guard = await checkMcpGuardian(store, 'mcp__treenity__deploy_prefab', JSON.stringify({ source, target }));
+      if (!guard.allowed) return text(`🛑 Guardian: ${guard.reason}`);
+      const result = await deployPrefab(aclStore, source, target, { allowAbsolute });
+      return text(yaml(result));
+    },
+  );
+
+  mcp.registerTool(
+    'compile_view',
+    {
+      description: 'Verify that a UIX view source compiles correctly. Pass path to check an existing type node, or source to verify before writing.',
+      inputSchema: {
+        path: z.string().optional().describe('Path to type node (e.g. /sys/types/cosmos/system) — reads view.source'),
+        source: z.string().optional().describe('Raw JSX/TSX source to verify directly'),
+      },
+    },
+    async ({ path, source }) => {
+      let code = source;
+      if (!code) {
+        if (!path) return text('error: provide path or source');
+        const node = await aclStore.get(path);
+        if (!node) return text(`not found: ${path}`);
+        code = (node as any)?.view?.source;
+        if (!code || typeof code !== 'string') return text(`no view.source on ${path}`);
+      }
+      const result = verifyViewSource(code);
+      return text(yaml(result));
+    },
+  );
+
+  mcp.registerTool(
+    'remove_node',
+    {
+      description: 'Remove a node by path. May be denied by Guardian.',
+      inputSchema: { path: z.string() },
+    },
+    async ({ path }) => {
+      const guard = await checkMcpGuardian(store, 'mcp__treenity__remove_node', path);
+      if (!guard.allowed) return text(`🛑 Guardian: ${guard.reason}`);
+      const ok = await aclStore.remove(path);
+      return text(ok ? `removed: ${path}` : `not found: ${path}`);
+    },
+  );
+
+  // ── Discovery tools — powered by TypeCatalog ──
+
+  mcp.registerTool(
+    'catalog',
+    {
+      description: 'List all registered types with title, properties, and action names. Use this first to discover what types exist.',
+      inputSchema: {},
+    },
+    async () => text(yaml(catalog.list())),
+  );
+
+  mcp.registerTool(
+    'describe_type',
+    {
+      description: 'Get full schema of a type: properties, actions with argument types, and cross-references to other types. Use after catalog to understand a specific type deeply.',
+      inputSchema: { type: z.string().describe('Type name, e.g. "cafe.contact" or "board.task"') },
+    },
+    async ({ type: typeName }) => {
+      const desc = catalog.describe(typeName);
+      return text(desc ? yaml(desc) : `type not found: ${typeName}`);
+    },
+  );
+
+  mcp.registerTool(
+    'search_types',
+    {
+      description: 'Search types by keyword across names, titles, property names, and action names. Use to find types relevant to a task.',
+      inputSchema: { query: z.string().describe('Search keyword, e.g. "order", "mail", "contact"') },
+    },
+    async ({ query }) => text(yaml(catalog.search(query))),
+  );
+
+  return mcp;
+}
+
+export function extractToken(req: import('node:http').IncomingMessage): string | null {
+  const auth = req.headers.authorization;
+  if (typeof auth === 'string' && auth.startsWith('Bearer ')) return auth.slice(7);
+
+  const qs = (req.url ?? '').split('?')[1];
+  if (qs) {
+    const match = qs.match(/(?:^|&)token=([^&]+)/);
+    if (match) return decodeURIComponent(match[1]);
+  }
+  return null;
+}
+
+/** Create MCP HTTP server. Returns server handle for lifecycle management. */
+export function createMcpHttpServer(store: Tree, port: number): Server {
+  const tls = loadDevCerts();
+
+  const handler = async (req: import('node:http').IncomingMessage, res: import('node:http').ServerResponse) => {
+    res.setHeader('Access-Control-Allow-Origin', '*');
+    res.setHeader('Access-Control-Allow-Methods', 'GET, POST, DELETE, OPTIONS');
+    res.setHeader('Access-Control-Allow-Headers', 'Content-Type, Authorization, mcp-session-id');
+    if (req.method === 'OPTIONS') {
+      res.writeHead(204);
+      res.end();
+      return;
+    }
+
+    const url = (req.url ?? '/').split('?')[0];
+    if (url !== '/mcp') {
+      res.writeHead(404);
+      res.end('not found');
+      return;
+    }
+
+    const token = extractToken(req);
+    let session: Session | null = null;
+    let devClaims: string[] | undefined;
+    if (token) {
+      session = await resolveToken(store, token);
+    } else if (!process.env.TENANT) {
+      console.warn('[mcp] ⚠️  DEV MODE: no TENANT set — all MCP requests have ADMIN access. Set TENANT env for production.');
+      session = { userId: 'mcp-dev' } as Session;
+      devClaims = ['u:mcp-dev', 'authenticated', 'admins'];
+    }
+    if (!session) {
+      res.writeHead(401, { 'Content-Type': 'text/plain' });
+      res.end('token required (?token= or Authorization: Bearer)');
+      return;
+    }
+
+    const transport = new StreamableHTTPServerTransport({ sessionIdGenerator: undefined });
+    const mcp = await buildMcpServer(store, session, devClaims);
+    await mcp.connect(transport);
+    await transport.handleRequest(req, res);
+  };
+
+  const server = tls ? createHttpsServer(tls, handler) : createServer(handler);
+  server.listen(port, '127.0.0.1', () => console.log(`treenity mcp ${tls ? 'https' : 'http'}://localhost:${port}/mcp`));
+  return server;
+}

package/mcp/server.ts

@@ -0,0 +1,2 @@
+import './types';
+import './service';

package/mcp/service.ts

@@ -0,0 +1,18 @@
+// MCP autostart service — starts/stops the MCP HTTP server via tree lifecycle
+
+import { getComponent, register } from '@treenity/core';
+import { createMcpHttpServer } from './mcp-server';
+import { McpConfig } from './types';
+
+register('mcp.server', 'service', async (node, ctx) => {
+  const config = getComponent(node, McpConfig);
+  const port = config?.port ?? (Number(process.env.MCP_PORT) || 3212);
+  const server = createMcpHttpServer(ctx.tree, port);
+
+  return {
+    stop: async () => {
+      server.close();
+      console.log(`[mcp] stopped :${port}`);
+    },
+  };
+});

package/mcp/types.ts

@@ -0,0 +1,6 @@
+import { registerType } from '@treenity/core/comp';
+
+export class McpConfig {
+  port = 3212;
+}
+registerType('mcp.server', McpConfig);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@treenity/mods",
-  "version": "3.0.2",
+  "version": "3.0.3",
   "description": "Official Treenity modules — board, sim, cafe, doc, mindmap, and more.",
   "type": "module",
   "publishConfig": {
@@ -38,12 +38,14 @@
   },
   "files": [
     "dist",
+    "agent",
     "board",
     "brahman",
     "cafe",
     "canary",
     "doc",
     "launcher",
+    "mcp",
     "mindmap",
     "sensor-demo",
     "sensor-generator",
@@ -73,7 +75,8 @@
     }
   },
   "dependencies": {
-    "@grammyjs/runner": "^2.0.3"
+    "@grammyjs/runner": "^2.0.3",
+    "@modelcontextprotocol/sdk": "^1.27.1"
   },
   "optionalDependencies": {
     "@huggingface/transformers": "^3.8.1",

package/dist/mindmap/radial-tree.d.ts

@@ -1,14 +0,0 @@
-import 'd3-transition';
-import type { TreeItem } from './use-tree-data';
-type Props = {
-    data: TreeItem;
-    selectedPath: string | null;
-    onSelect: (path: string) => void;
-    onToggle: (path: string) => void;
-    branchColors: Map<string, string>;
-    width: number;
-    height: number;
-};
-export declare function MindMapTree({ data, selectedPath, onSelect, onToggle, branchColors, width, height }: Props): import("react/jsx-runtime").JSX.Element;
-export {};
-//# sourceMappingURL=radial-tree.d.ts.map

package/dist/mindmap/radial-tree.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"radial-tree.d.ts","sourceRoot":"","sources":["../../mindmap/radial-tree.tsx"],"names":[],"mappings":"AAKA,OAAO,eAAe,CAAC;AAGvB,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAEhD,KAAK,KAAK,GAAG;IACX,IAAI,EAAE,QAAQ,CAAC;IACf,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B,QAAQ,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IACjC,QAAQ,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IACjC,YAAY,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAClC,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAkGF,wBAAgB,WAAW,CAAC,EAAE,IAAI,EAAE,YAAY,EAAE,QAAQ,EAAE,QAAQ,EAAE,YAAY,EAAE,KAAK,EAAE,MAAM,EAAE,EAAE,KAAK,2CA6QzG"}

package/dist/mindmap/radial-tree.js

@@ -1,184 +0,0 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-// Miro-style mind map — horizontal balanced tree with organic bezier curves
-// Pure SVG: text labels + colored branches, no foreignObject
-import { hierarchy, tree as d3tree } from 'd3-hierarchy';
-import { select } from 'd3-selection';
-import 'd3-transition';
-import { zoom as d3zoom, zoomIdentity } from 'd3-zoom';
-import { useCallback, useEffect, useMemo, useRef } from 'react';
-// Type → icon mapping (simple SVG paths)
-const TYPE_ICONS = {
-    dir: 'M2 4h5l2 2h9v12H2V4z',
-    ref: 'M10 2a8 8 0 100 16 8 8 0 000-16zm1 4v4l3.5 2.1-.8 1.3L9 11V6h2z',
-    user: 'M12 4a4 4 0 110 8 4 4 0 010-8zM12 14c-4.42 0-8 1.79-8 4v2h16v-2c0-2.21-3.58-4-8-4z',
-    root: 'M10 20v-6h4v6h5v-8h3L12 3 2 12h3v8z',
-};
-function getIcon(type) {
-    if (TYPE_ICONS[type])
-        return TYPE_ICONS[type];
-    const base = type.split('.')[0];
-    return TYPE_ICONS[base] ?? null;
-}
-// Measure text width roughly (8px per char at 13px font, 6.5px at 11px)
-function textWidth(str, fontSize) {
-    return str.length * fontSize * 0.62;
-}
-function splitTree(root) {
-    const left = [];
-    const right = [];
-    root.children.forEach((child, i) => {
-        const tagged = { ...child, _side: (i % 2 === 0 ? 'right' : 'left') };
-        if (i % 2 === 0)
-            right.push(tagged);
-        else
-            left.push(tagged);
-    });
-    return { ...root, children: [...right, ...left] };
-}
-function tagSide(item, side) {
-    return {
-        ...item,
-        _side: item._side ?? side,
-        children: item.children.map(c => tagSide(c, side)),
-    };
-}
-function buildSide(root, children, side) {
-    return {
-        ...root,
-        _side: undefined,
-        children: children.map(c => tagSide(c, side)),
-    };
-}
-// Organic cubic bezier — Miro-style smooth S-curve
-function linkPath(sx, sy, tx, ty) {
-    const dx = tx - sx;
-    const cp = Math.abs(dx) * 0.5;
-    return `M${sx},${sy} C${sx + (dx > 0 ? cp : -cp)},${sy} ${tx - (dx > 0 ? cp : -cp)},${ty} ${tx},${ty}`;
-}
-function layoutHalf(root, children, side, height) {
-    if (children.length === 0)
-        return null;
-    const subtree = buildSide(root, children, side);
-    const h = hierarchy(subtree, d => d.children);
-    const nodeCount = h.descendants().length;
-    const treeHeight = Math.max(height * 0.8, nodeCount * 32);
-    const layout = d3tree()
-        .size([treeHeight, 220 * Math.max(1, h.height)])
-        .separation((a, b) => (a.parent === b.parent ? 1 : 1.5));
-    layout(h);
-    // Convert: d3tree gives vertical layout (x=vertical, y=horizontal)
-    // We flip and mirror for left side
-    for (const node of h.descendants()) {
-        const lNode = node;
-        if (side === 'left') {
-            lNode._rx = -lNode.y;
-            lNode._ry = lNode.x - treeHeight / 2;
-        }
-        else {
-            lNode._rx = lNode.y;
-            lNode._ry = lNode.x - treeHeight / 2;
-        }
-    }
-    return h;
-}
-export function MindMapTree({ data, selectedPath, onSelect, onToggle, branchColors, width, height }) {
-    const svgRef = useRef(null);
-    const gRef = useRef(null);
-    const zoomRef = useRef(null);
-    // Split into left/right halves
-    const { leftNodes, rightNodes } = useMemo(() => {
-        const split = splitTree(data);
-        const leftChildren = [];
-        const rightChildren = [];
-        for (const c of split.children) {
-            if (c._side === 'left')
-                leftChildren.push(c);
-            else
-                rightChildren.push(c);
-        }
-        const left = layoutHalf(data, leftChildren, 'left', height);
-        const right = layoutHalf(data, rightChildren, 'right', height);
-        return {
-            leftNodes: left ? left.descendants().slice(1) : [],
-            rightNodes: right ? right.descendants().slice(1) : [],
-        };
-    }, [data, height]);
-    const allNodes = useMemo(() => [...leftNodes, ...rightNodes], [leftNodes, rightNodes]);
-    // Build links from parent→child coords
-    const links = useMemo(() => {
-        const result = [];
-        for (const node of allNodes) {
-            const parent = node.parent;
-            if (!parent)
-                continue;
-            const sx = parent.depth === 0 ? 0 : parent._rx;
-            const sy = parent.depth === 0 ? 0 : parent._ry;
-            const tx = node._rx;
-            const ty = node._ry;
-            const color = branchColors.get(node.data.path) ?? 'var(--text-3)';
-            const strokeWidth = Math.max(1.5, 3.5 - node.depth * 0.6);
-            result.push({
-                key: `${parent.data.path}->${node.data.path}`,
-                path: linkPath(sx, sy, tx, ty),
-                color,
-                width: strokeWidth,
-                source: parent,
-                target: node,
-            });
-        }
-        return result;
-    }, [allNodes, branchColors]);
-    // Zoom
-    useEffect(() => {
-        if (!svgRef.current || !gRef.current)
-            return;
-        const svg = select(svgRef.current);
-        const g = select(gRef.current);
-        const zoomBehavior = d3zoom()
-            .scaleExtent([0.1, 4])
-            .on('zoom', event => {
-            g.attr('transform', event.transform.toString());
-        });
-        svg.call(zoomBehavior);
-        const initialTransform = zoomIdentity.translate(width / 2, height / 2).scale(0.85);
-        svg.call(zoomBehavior.transform, initialTransform);
-        zoomRef.current = zoomBehavior;
-        return () => { svg.on('.zoom', null); };
-    }, [width, height]);
-    // Fit view
-    const fitView = useCallback(() => {
-        if (!svgRef.current || !zoomRef.current || !gRef.current)
-            return;
-        const svg = select(svgRef.current);
-        const bounds = gRef.current.getBBox();
-        if (!bounds.width || !bounds.height)
-            return;
-        const pad = 60;
-        const scale = Math.min((width - pad * 2) / bounds.width, (height - pad * 2) / bounds.height, 1.5);
-        const tx = width / 2 - (bounds.x + bounds.width / 2) * scale;
-        const ty = height / 2 - (bounds.y + bounds.height / 2) * scale;
-        svg.transition().duration(400).call(zoomRef.current.transform, zoomIdentity.translate(tx, ty).scale(scale));
-    }, [width, height]);
-    // Auto-fit on data change
-    useEffect(() => {
-        const t = setTimeout(fitView, 80);
-        return () => clearTimeout(t);
-    }, [data, fitView]);
-    const rootName = data.name === '/' ? '/' : data.name;
-    const rootColor = branchColors.get(data.path) ?? 'var(--text)';
-    return (_jsxs("div", { className: "mm-tree-wrap", children: [_jsx("div", { className: "mm-toolbar", children: _jsx("button", { className: "mm-btn", onClick: fitView, title: "Fit view", children: _jsx("svg", { width: "16", height: "16", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", children: _jsx("path", { d: "M15 3h6v6M9 21H3v-6M21 3l-7 7M3 21l7-7" }) }) }) }), _jsx("svg", { ref: svgRef, width: width, height: height, className: "mm-svg", children: _jsxs("g", { ref: gRef, children: [links.map(l => (_jsx("path", { d: l.path, fill: "none", stroke: l.color, strokeWidth: l.width, strokeOpacity: 0.7, strokeLinecap: "round", className: "mm-link" }, l.key))), _jsxs("g", { className: `mm-node mm-root${selectedPath === data.path ? ' mm-node-selected' : ''}`, onClick: () => onSelect(data.path), onDoubleClick: () => onToggle(data.path), children: [_jsx("rect", { x: -textWidth(rootName, 16) / 2 - 24, y: -20, width: textWidth(rootName, 16) + 48, height: 40, rx: 20, className: "mm-root-bg" }), _jsx("text", { textAnchor: "middle", dominantBaseline: "central", className: "mm-root-label", children: rootName })] }), allNodes.map(node => {
-                            const d = node.data;
-                            const x = node._rx;
-                            const y = node._ry;
-                            const color = branchColors.get(d.path) ?? 'var(--text-2)';
-                            const isLeft = d._side === 'left';
-                            const isSelected = selectedPath === d.path;
-                            const icon = getIcon(d.type);
-                            const hasChildren = d.childCount > 0;
-                            const label = d.name;
-                            // Type badge (short)
-                            const shortType = d.type.includes('.') ? d.type.split('.').pop() : '';
-                            return (_jsxs("g", { transform: `translate(${x},${y})`, className: `mm-node${isSelected ? ' mm-node-selected' : ''}`, onClick: () => onSelect(d.path), onDoubleClick: () => onToggle(d.path), children: [_jsx("rect", { x: isLeft ? -textWidth(label, 13) - 30 : -10, y: -14, width: textWidth(label, 13) + 50, height: 28, fill: "transparent", className: "mm-hit" }), isSelected && (_jsx("rect", { x: isLeft ? -textWidth(label, 13) - 26 : -6, y: -12, width: textWidth(label, 13) + 42, height: 24, rx: 12, className: "mm-select-bg", fill: color, fillOpacity: 0.1 })), _jsx("circle", { cx: 0, cy: 0, r: hasChildren && !d.expanded ? 4 : 3, fill: color, className: "mm-dot" }), icon && (_jsx("g", { transform: `translate(${isLeft ? -22 : 8}, -8) scale(0.7)`, children: _jsx("path", { d: icon, fill: color, fillOpacity: 0.6 }) })), _jsx("text", { x: isLeft ? -12 : (icon ? 24 : 12), textAnchor: isLeft ? 'end' : 'start', dominantBaseline: "central", className: "mm-label", fill: color, children: label }), shortType && node.depth <= 2 && (_jsx("text", { x: isLeft ? -12 - textWidth(label, 13) - 8 : (icon ? 24 : 12) + textWidth(label, 13) + 8, textAnchor: isLeft ? 'end' : 'start', dominantBaseline: "central", className: "mm-type-tag", fill: color, children: shortType })), hasChildren && !d.expanded && (_jsxs("g", { transform: `translate(${isLeft ? 8 : -8 + (icon ? 24 : 12) + textWidth(label, 13) + (shortType && node.depth <= 2 ? textWidth(shortType, 10) + 16 : 8)}, 0)`, className: "mm-count-badge", onClick: e => { e.stopPropagation(); onToggle(d.path); }, children: [_jsx("circle", { r: 8, fill: color, fillOpacity: 0.15 }), _jsx("text", { textAnchor: "middle", dominantBaseline: "central", fill: color, fontSize: "9", fontWeight: "600", children: d.childCount })] }))] }, d.path));
-                        })] }) })] }));
-}
-//# sourceMappingURL=radial-tree.js.map