@mdxui/do 2.1.1 → 4.0.0

package/dist/chunk-OVLO7UOH.js

@@ -0,0 +1,1071 @@
+import { retryWithBackoff } from './chunk-Y52IEYVM.js';
+import { newWebSocketRpcSession } from 'capnweb';
+import { useState, useRef, useCallback, useEffect } from 'react';
+
+function createCapnwebClient(baseUrl, options = {}) {
+  const httpUrl = `${baseUrl.replace(/\/$/, "").replace(/\/rpc$/, "")}/rpc`;
+  const wsUrl = httpUrl.replace(/^http/, "ws");
+  const rpcUrl = options.authToken ? `${wsUrl}?token=${encodeURIComponent(options.authToken)}` : wsUrl;
+  const session = newWebSocketRpcSession(rpcUrl);
+  const rpc = session;
+  return {
+    /**
+     * Namespace operations
+     */
+    Namespace: {
+      async list(_params) {
+        return [{ id: "default", name: "default" }];
+      }
+    },
+    /**
+     * Schema operations
+     */
+    Schema: {
+      async discover(_params) {
+        try {
+          const schemas = await rpc.getSchemas();
+          return {
+            namespaces: ["default"],
+            types: schemas ?? [],
+            schemas: schemas ?? []
+          };
+        } catch (error) {
+          console.error("[@mdxui/do] Failed to get schemas:", error);
+          return { namespaces: ["default"], types: [], schemas: [] };
+        }
+      },
+      async get(params) {
+        try {
+          const result = await rpc.getSchema(params.type);
+          return result;
+        } catch {
+          return null;
+        }
+      }
+    },
+    /**
+     * Thing operations
+     */
+    Thing: {
+      async types(params) {
+        try {
+          const schemas = await rpc.getSchemas();
+          return (schemas ?? []).map((name) => ({
+            name,
+            ns: params.ns || "default"
+          }));
+        } catch (error) {
+          console.error("[@mdxui/do] Failed to get types:", error);
+          return [];
+        }
+      },
+      async list(params) {
+        try {
+          const options2 = {};
+          if (params.type) options2.type = params.type;
+          if (params.limit !== void 0) options2.limit = params.limit;
+          if (params.offset !== void 0) options2.offset = params.offset;
+          const result = await rpc.list(options2);
+          if (Array.isArray(result)) {
+            return { data: result, total: result.length };
+          }
+          if (result) {
+            const items = result.data || result.items || result.result || [];
+            return { data: items, total: result.count ?? items.length };
+          }
+          return { data: [], total: 0 };
+        } catch (error) {
+          console.error("[@mdxui/do] Failed to list things:", error);
+          return { data: [], total: 0 };
+        }
+      },
+      async get(params) {
+        try {
+          const result = await rpc.get({ type: params.type, id: params.id });
+          return result;
+        } catch {
+          return null;
+        }
+      },
+      async create(params) {
+        const result = await rpc.create({ type: params.type, data: params.data });
+        return result;
+      },
+      async update(params) {
+        const result = await rpc.update({ type: params.type, id: params.id, data: params.data });
+        return result;
+      },
+      async delete(params) {
+        await rpc.delete({ type: params.type, id: params.id });
+        return { success: true };
+      },
+      async versions(_params) {
+        return [];
+      },
+      async stats(_params) {
+        try {
+          const options2 = {};
+          if (_params.type) options2.type = _params.type;
+          const result = await rpc.getStats(options2);
+          return {
+            total: result?.total ?? 0,
+            byType: result?.byType ?? {}
+          };
+        } catch (error) {
+          console.error("[@mdxui/do] Failed to get stats:", error);
+          return { total: 0, byType: {} };
+        }
+      }
+    },
+    /**
+     * SQL operations (not supported by capnweb servers)
+     */
+    SQL: {
+      async execute(_params) {
+        throw new Error("SQL execution is not supported by this server");
+      }
+    },
+    // Required for interface compatibility
+    dup: () => createCapnwebClient(baseUrl, options),
+    onRpcBroken: (callback) => {
+      if ("onRpcBroken" in session && typeof session.onRpcBroken === "function") {
+        session.onRpcBroken(callback);
+      }
+    },
+    [Symbol.dispose]: () => {
+      if (Symbol.dispose in session) {
+        session[Symbol.dispose]();
+      }
+    }
+  };
+}
+function $CapnwebContext(url, options) {
+  return createCapnwebClient(url, options);
+}
+
+// src/lib/json-rpc-client.ts
+var endpointCache = /* @__PURE__ */ new Map();
+function createJsonRpcClient(baseUrl, options = {}) {
+  const rpcUrl = baseUrl.replace(/\/$/, "").replace(/\/rpc$/, "");
+  function getAuthHeaders() {
+    if (options.authToken) {
+      return { Authorization: `Bearer ${options.authToken}` };
+    }
+    return {};
+  }
+  async function rpcCall(method, args = []) {
+    const response = await fetch(`${rpcUrl}/rpc`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        ...getAuthHeaders()
+      },
+      body: JSON.stringify({ method, args })
+    });
+    if (!response.ok) {
+      throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+    }
+    const data = await response.json();
+    if (data.error) {
+      throw new Error(data.error.message || data.error.code);
+    }
+    return data.result;
+  }
+  async function restCall(path, init) {
+    const response = await fetch(`${rpcUrl}${path}`, {
+      ...init,
+      headers: {
+        "Content-Type": "application/json",
+        ...getAuthHeaders(),
+        ...init?.headers
+      }
+    });
+    if (!response.ok) {
+      const method = init?.method?.toUpperCase() ?? "GET";
+      if (response.status === 404 && method === "GET") {
+        return { data: [], count: 0 };
+      }
+      throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+    }
+    return response.json();
+  }
+  return {
+    /**
+     * Namespace operations
+     */
+    Namespace: {
+      async list(_params) {
+        return [{ id: "default", name: "default" }];
+      }
+    },
+    /**
+     * Schema operations
+     */
+    Schema: {
+      async discover(_params) {
+        const schemas = await rpcCall("schemas.list", []);
+        return {
+          namespaces: ["default"],
+          types: schemas,
+          schemas
+        };
+      },
+      async get(params) {
+        const result = await rpcCall("schemas.get", [params.type]);
+        return result;
+      }
+    },
+    /**
+     * Thing operations (maps to REST endpoints)
+     */
+    Thing: {
+      async types(params) {
+        try {
+          const schemas = await rpcCall("schemas.list", []);
+          let validEndpoints = endpointCache.get(rpcUrl);
+          if (!validEndpoints) {
+            validEndpoints = /* @__PURE__ */ new Set();
+            const probeResults = await Promise.all(
+              schemas.map(async (type) => {
+                const endpoint = getEndpointForType(type);
+                try {
+                  const response = await fetch(`${rpcUrl}${endpoint}`, { method: "HEAD" });
+                  return { type, exists: response.ok };
+                } catch {
+                  try {
+                    const response = await fetch(`${rpcUrl}${endpoint}?limit=0`);
+                    return { type, exists: response.ok };
+                  } catch {
+                    return { type, exists: false };
+                  }
+                }
+              })
+            );
+            for (const { type, exists } of probeResults) {
+              if (exists) {
+                validEndpoints.add(type);
+              }
+            }
+            endpointCache.set(rpcUrl, validEndpoints);
+          }
+          return Array.from(validEndpoints).map((name) => ({
+            name,
+            ns: params.ns || "default"
+          }));
+        } catch {
+          return ["Noun", "Verb", "Action", "Function"].map((name) => ({
+            name,
+            ns: params.ns || "default"
+          }));
+        }
+      },
+      async list(params) {
+        const endpoint = getEndpointForType(params.type || "Thing");
+        const response = await restCall(endpoint);
+        const items = response.data || response.items || response.result || [];
+        return {
+          data: items,
+          total: response.count ?? items.length
+        };
+      },
+      async get(params) {
+        const endpoint = getEndpointForType(params.type);
+        const response = await restCall(`${endpoint}/${params.id}`);
+        return response.data;
+      },
+      async create(params) {
+        const endpoint = getEndpointForType(params.type);
+        const response = await restCall(endpoint, {
+          method: "POST",
+          body: JSON.stringify(params.data)
+        });
+        return response.data;
+      },
+      async update(params) {
+        const endpoint = getEndpointForType(params.type);
+        const response = await restCall(`${endpoint}/${params.id}`, {
+          method: "PUT",
+          body: JSON.stringify(params.data)
+        });
+        return response.data;
+      },
+      async delete(params) {
+        const endpoint = getEndpointForType(params.type);
+        await restCall(`${endpoint}/${params.id}`, { method: "DELETE" });
+        return { success: true };
+      },
+      async versions(_params) {
+        return [];
+      },
+      async stats(_params) {
+        let validEndpoints = endpointCache.get(rpcUrl);
+        if (!validEndpoints) {
+          await this.types({ ns: _params.ns });
+          validEndpoints = endpointCache.get(rpcUrl) || /* @__PURE__ */ new Set();
+        }
+        const types = Array.from(validEndpoints);
+        const results = await Promise.all(
+          types.map(async (type) => {
+            const endpoint = getEndpointForType(type);
+            const response = await restCall(endpoint).catch(() => ({ count: 0 }));
+            return { type, count: response.count || 0 };
+          })
+        );
+        const byType = {};
+        let total = 0;
+        for (const { type, count } of results) {
+          byType[type] = count;
+          total += count;
+        }
+        return { total, byType };
+      }
+    },
+    /**
+     * SQL operations
+     */
+    SQL: {
+      async execute(params) {
+        const startTime = Date.now();
+        try {
+          const result = await rpcCall("sql.execute", [params.query, params.params || []]);
+          return {
+            rows: result.rows ?? [],
+            columns: result.columns ?? [],
+            rowsAffected: result.rowsAffected,
+            executionTimeMs: result.executionTimeMs ?? Date.now() - startTime
+          };
+        } catch (rpcError) {
+          const errorMessage = rpcError instanceof Error ? rpcError.message : String(rpcError);
+          const isNotSupported = errorMessage.includes("not found") || errorMessage.includes("not supported") || errorMessage.includes("unknown method");
+          try {
+            const response = await restCall("/sql", {
+              method: "POST",
+              body: JSON.stringify({ query: params.query, params: params.params })
+            });
+            return {
+              rows: response.rows ?? [],
+              columns: response.columns ?? [],
+              rowsAffected: response.rowsAffected,
+              executionTimeMs: Date.now() - startTime
+            };
+          } catch (restError) {
+            if (isNotSupported) {
+              throw new Error(
+                "SQL execution is not supported by this server. The server does not expose sql.execute RPC method or /sql REST endpoint."
+              );
+            }
+            throw restError;
+          }
+        }
+      }
+    },
+    // Required for interface compatibility
+    dup: () => createJsonRpcClient(baseUrl, options),
+    onRpcBroken: (_callback) => {
+    },
+    [Symbol.dispose]: () => {
+    }
+  };
+}
+function getEndpointForType(type) {
+  const typeMap = {
+    Noun: "/nouns",
+    Verb: "/verbs",
+    Action: "/actions",
+    Function: "/functions",
+    Event: "/events",
+    Relationship: "/relationships",
+    Thing: "/things",
+    Workflow: "/workflows"
+  };
+  return typeMap[type] || `/${type}`;
+}
+function $JsonRpcContext(url, options) {
+  return createJsonRpcClient(url, options);
+}
+
+// src/lib/mock-data.ts
+var idCounter = 0;
+function generateId(prefix = "mock") {
+  return `${prefix}_${Date.now().toString(36)}_${(++idCounter).toString(36)}`;
+}
+var mockProperties = {
+  User: [
+    { name: "email", label: "Email", description: "Email address", rangeIncludes: ["string"], domainIncludes: ["User"], required: true, isArray: false },
+    { name: "role", label: "Role", description: "User role", rangeIncludes: ["string"], domainIncludes: ["User"], required: false, isArray: false },
+    { name: "avatar", label: "Avatar", description: "Profile picture URL", rangeIncludes: ["string"], domainIncludes: ["User"], required: false, isArray: false },
+    { name: "status", label: "Status", description: "Account status", rangeIncludes: ["string"], domainIncludes: ["User"], required: false, isArray: false }
+  ],
+  Project: [
+    { name: "description", label: "Description", description: "Project description", rangeIncludes: ["string"], domainIncludes: ["Project"], required: false, isArray: false },
+    { name: "status", label: "Status", description: "Project status", rangeIncludes: ["string"], domainIncludes: ["Project"], required: true, isArray: false },
+    { name: "owner", label: "Owner", description: "Project owner", rangeIncludes: ["User"], domainIncludes: ["Project"], required: true, isArray: false },
+    { name: "tags", label: "Tags", description: "Project tags", rangeIncludes: ["string"], domainIncludes: ["Project"], required: false, isArray: true }
+  ],
+  Task: [
+    { name: "description", label: "Description", description: "Task description", rangeIncludes: ["string"], domainIncludes: ["Task"], required: false, isArray: false },
+    { name: "status", label: "Status", description: "Task status", rangeIncludes: ["string"], domainIncludes: ["Task"], required: true, isArray: false },
+    { name: "priority", label: "Priority", description: "Task priority", rangeIncludes: ["string"], domainIncludes: ["Task"], required: false, isArray: false },
+    { name: "assignee", label: "Assignee", description: "Assigned user", rangeIncludes: ["User"], domainIncludes: ["Task"], required: false, isArray: false },
+    { name: "project", label: "Project", description: "Parent project", rangeIncludes: ["Project"], domainIncludes: ["Task"], required: false, isArray: false },
+    { name: "dueDate", label: "Due Date", description: "Task due date", rangeIncludes: ["date"], domainIncludes: ["Task"], required: false, isArray: false }
+  ],
+  Document: [
+    { name: "content", label: "Content", description: "Document content", rangeIncludes: ["string"], domainIncludes: ["Document"], required: true, isArray: false },
+    { name: "format", label: "Format", description: "Content format", rangeIncludes: ["string"], domainIncludes: ["Document"], required: false, isArray: false },
+    { name: "author", label: "Author", description: "Document author", rangeIncludes: ["User"], domainIncludes: ["Document"], required: false, isArray: false },
+    { name: "tags", label: "Tags", description: "Document tags", rangeIncludes: ["string"], domainIncludes: ["Document"], required: false, isArray: true }
+  ],
+  Function: [
+    { name: "description", label: "Description", description: "Function description", rangeIncludes: ["string"], domainIncludes: ["Function"], required: false, isArray: false },
+    { name: "code", label: "Code", description: "Function code", rangeIncludes: ["string"], domainIncludes: ["Function"], required: true, isArray: false },
+    { name: "runtime", label: "Runtime", description: "Execution runtime", rangeIncludes: ["string"], domainIncludes: ["Function"], required: true, isArray: false },
+    { name: "triggers", label: "Triggers", description: "Event triggers", rangeIncludes: ["string"], domainIncludes: ["Function"], required: false, isArray: true }
+  ],
+  Workflow: [
+    { name: "description", label: "Description", description: "Workflow description", rangeIncludes: ["string"], domainIncludes: ["Workflow"], required: false, isArray: false },
+    { name: "steps", label: "Steps", description: "Workflow steps", rangeIncludes: ["object"], domainIncludes: ["Workflow"], required: true, isArray: true },
+    { name: "status", label: "Status", description: "Workflow status", rangeIncludes: ["string"], domainIncludes: ["Workflow"], required: true, isArray: false }
+  ],
+  Agent: [
+    { name: "description", label: "Description", description: "Agent description", rangeIncludes: ["string"], domainIncludes: ["Agent"], required: false, isArray: false },
+    { name: "model", label: "Model", description: "AI model", rangeIncludes: ["string"], domainIncludes: ["Agent"], required: true, isArray: false },
+    { name: "systemPrompt", label: "System Prompt", description: "Agent system prompt", rangeIncludes: ["string"], domainIncludes: ["Agent"], required: false, isArray: false },
+    { name: "tools", label: "Tools", description: "Available tools", rangeIncludes: ["string"], domainIncludes: ["Agent"], required: false, isArray: true }
+  ]
+};
+var MOCK_TYPES = Object.keys(mockProperties);
+function generateMockSchema(typeName) {
+  const properties = mockProperties[typeName] || [];
+  return {
+    namespace: "default",
+    name: typeName,
+    id: `default/${typeName}`,
+    label: typeName,
+    description: `${typeName} entity type`,
+    parentTypes: ["Thing"],
+    properties,
+    subtypes: []
+  };
+}
+var firstNames = ["Alice", "Bob", "Charlie", "Diana", "Eve", "Frank", "Grace", "Henry", "Iris", "Jack"];
+var lastNames = ["Smith", "Johnson", "Williams", "Brown", "Jones", "Garcia", "Miller", "Davis", "Rodriguez", "Martinez"];
+var projectNames = ["Apollo", "Mercury", "Gemini", "Voyager", "Pioneer", "Horizon", "Nebula", "Cosmos", "Atlas", "Phoenix"];
+var taskPrefixes = ["Implement", "Fix", "Update", "Review", "Design", "Test", "Deploy", "Document", "Refactor", "Optimize"];
+var statuses = ["active", "pending", "completed", "archived"];
+var priorities = ["low", "medium", "high", "critical"];
+var roles = ["admin", "editor", "viewer", "developer"];
+function randomItem(arr) {
+  return arr[Math.floor(Math.random() * arr.length)];
+}
+function randomDate(daysBack = 30) {
+  const date = /* @__PURE__ */ new Date();
+  date.setDate(date.getDate() - Math.floor(Math.random() * daysBack));
+  return date;
+}
+function generateMockUser(id) {
+  const firstName = randomItem(firstNames);
+  const lastName = randomItem(lastNames);
+  const name = `${firstName} ${lastName}`;
+  const now = /* @__PURE__ */ new Date();
+  const created = randomDate(60);
+  return {
+    ns: "default",
+    type: "User",
+    id: id || generateId("user"),
+    ts: now,
+    name,
+    createdAt: created,
+    updatedAt: now,
+    createdBy: "system",
+    data: {
+      "@type": "User",
+      email: `${firstName.toLowerCase()}.${lastName.toLowerCase()}@example.com`,
+      role: randomItem(roles),
+      avatar: `https://api.dicebear.com/7.x/avataaars/svg?seed=${firstName}`,
+      status: randomItem(["active", "inactive"])
+    }
+  };
+}
+function generateMockProject(id) {
+  const name = `Project ${randomItem(projectNames)}`;
+  const now = /* @__PURE__ */ new Date();
+  const created = randomDate(90);
+  return {
+    ns: "default",
+    type: "Project",
+    id: id || generateId("proj"),
+    ts: now,
+    name,
+    createdAt: created,
+    updatedAt: now,
+    createdBy: "system",
+    data: {
+      "@type": "Project",
+      description: `A ${randomItem(["web", "mobile", "API", "data", "ML"])} project focused on ${randomItem(["performance", "scalability", "user experience", "automation", "analytics"])}`,
+      status: randomItem(statuses),
+      owner: `user_${Math.floor(Math.random() * 10)}`,
+      tags: [randomItem(["frontend", "backend", "fullstack"]), randomItem(["react", "node", "python", "go"])]
+    }
+  };
+}
+function generateMockTask(id) {
+  const action = randomItem(taskPrefixes);
+  const target = randomItem(["authentication", "dashboard", "API endpoint", "database schema", "user flow", "notification system", "search feature", "export functionality"]);
+  const name = `${action} ${target}`;
+  const now = /* @__PURE__ */ new Date();
+  const created = randomDate(14);
+  return {
+    ns: "default",
+    type: "Task",
+    id: id || generateId("task"),
+    ts: now,
+    name,
+    createdAt: created,
+    updatedAt: now,
+    createdBy: "system",
+    data: {
+      "@type": "Task",
+      description: `${action} the ${target} to improve ${randomItem(["performance", "reliability", "usability", "security"])}`,
+      status: randomItem(["todo", "in_progress", "review", "done"]),
+      priority: randomItem(priorities),
+      assignee: `user_${Math.floor(Math.random() * 10)}`,
+      dueDate: new Date(Date.now() + Math.random() * 14 * 24 * 60 * 60 * 1e3).toISOString()
+    }
+  };
+}
+function generateMockDocument(id) {
+  const docTypes = ["README", "API Documentation", "Architecture Guide", "User Manual", "Release Notes", "Meeting Notes", "Technical Spec", "Design Document"];
+  const name = randomItem(docTypes);
+  const now = /* @__PURE__ */ new Date();
+  const created = randomDate(30);
+  return {
+    ns: "default",
+    type: "Document",
+    id: id || generateId("doc"),
+    ts: now,
+    name,
+    createdAt: created,
+    updatedAt: now,
+    createdBy: "system",
+    data: {
+      "@type": "Document",
+      content: `# ${name}
+
+This is a sample document with mock content.
+
+## Overview
+
+Lorem ipsum dolor sit amet, consectetur adipiscing elit.`,
+      format: "markdown",
+      author: `user_${Math.floor(Math.random() * 10)}`,
+      tags: [randomItem(["documentation", "guide", "reference"]), randomItem(["v1", "v2", "draft"])]
+    }
+  };
+}
+function generateMockFunction(id) {
+  const funcNames = ["processOrder", "sendNotification", "validateInput", "transformData", "generateReport", "syncData", "handleWebhook", "calculateMetrics"];
+  const name = randomItem(funcNames);
+  const now = /* @__PURE__ */ new Date();
+  const created = randomDate(45);
+  return {
+    ns: "default",
+    type: "Function",
+    id: id || generateId("fn"),
+    ts: now,
+    name,
+    createdAt: created,
+    updatedAt: now,
+    createdBy: "system",
+    data: {
+      "@type": "Function",
+      description: `Handles ${name.replace(/([A-Z])/g, " $1").toLowerCase().trim()} operations`,
+      code: `export default async function ${name}(ctx, args) {
+  // Implementation
+  return { success: true }
+}`,
+      runtime: randomItem(["typescript", "javascript", "python"]),
+      triggers: [randomItem(["http", "schedule", "event", "queue"])]
+    }
+  };
+}
+function generateMockWorkflow(id) {
+  const workflowNames = ["Order Processing", "User Onboarding", "Content Approval", "Data Pipeline", "Release Deploy", "Support Ticket"];
+  const name = randomItem(workflowNames);
+  const now = /* @__PURE__ */ new Date();
+  const created = randomDate(60);
+  return {
+    ns: "default",
+    type: "Workflow",
+    id: id || generateId("wf"),
+    ts: now,
+    name,
+    createdAt: created,
+    updatedAt: now,
+    createdBy: "system",
+    data: {
+      "@type": "Workflow",
+      description: `Automated workflow for ${name.toLowerCase()}`,
+      steps: [
+        { id: "step1", name: "Initialize", type: "function" },
+        { id: "step2", name: "Process", type: "function" },
+        { id: "step3", name: "Notify", type: "notification" }
+      ],
+      status: randomItem(["active", "paused", "draft"])
+    }
+  };
+}
+function generateMockAgent(id) {
+  const agentNames = ["Code Assistant", "Data Analyst", "Support Bot", "Content Writer", "Research Agent", "QA Tester"];
+  const name = randomItem(agentNames);
+  const now = /* @__PURE__ */ new Date();
+  const created = randomDate(30);
+  return {
+    ns: "default",
+    type: "Agent",
+    id: id || generateId("agent"),
+    ts: now,
+    name,
+    createdAt: created,
+    updatedAt: now,
+    createdBy: "system",
+    data: {
+      "@type": "Agent",
+      description: `AI agent specialized in ${name.toLowerCase()} tasks`,
+      model: randomItem(["claude-3-opus", "claude-3-sonnet", "gpt-4", "gpt-4-turbo"]),
+      systemPrompt: `You are a helpful ${name.toLowerCase()} assistant.`,
+      tools: [randomItem(["search", "code", "browse", "analyze"])]
+    }
+  };
+}
+var generators = {
+  User: generateMockUser,
+  Project: generateMockProject,
+  Task: generateMockTask,
+  Document: generateMockDocument,
+  Function: generateMockFunction,
+  Workflow: generateMockWorkflow,
+  Agent: generateMockAgent
+};
+function generateMockThing(type, id) {
+  const generator = generators[type];
+  if (generator) {
+    return generator(id);
+  }
+  const now = /* @__PURE__ */ new Date();
+  return {
+    ns: "default",
+    type,
+    id: id || generateId(type.toLowerCase()),
+    ts: now,
+    name: `${type} ${Math.floor(Math.random() * 1e3)}`,
+    createdAt: randomDate(30),
+    updatedAt: now,
+    createdBy: "system",
+    data: {
+      "@type": type
+    }
+  };
+}
+function generateMockThings(type, count) {
+  return Array.from({ length: count }, () => generateMockThing(type));
+}
+function generateInitialMockData() {
+  return [
+    ...generateMockThings("User", 8),
+    ...generateMockThings("Project", 5),
+    ...generateMockThings("Task", 15),
+    ...generateMockThings("Document", 6),
+    ...generateMockThings("Function", 4),
+    ...generateMockThings("Workflow", 3),
+    ...generateMockThings("Agent", 3)
+  ];
+}
+
+// src/lib/mock-client.ts
+function thingKey(ns, type, id) {
+  return `${ns}:${type}:${id}`;
+}
+async function delay(ms) {
+  if (ms > 0) {
+    await new Promise((resolve) => setTimeout(resolve, ms));
+  }
+}
+function createMockClient(options = {}) {
+  const { delay: delayMs = 100, verbose = false, initialData } = options;
+  const store = {
+    things: /* @__PURE__ */ new Map(),
+    deletedThings: /* @__PURE__ */ new Set()
+  };
+  const data = initialData ?? generateInitialMockData();
+  for (const thing of data) {
+    const key = thingKey(thing.ns, thing.type, thing.id);
+    store.things.set(key, thing);
+  }
+  if (verbose) {
+    console.log(`[MockClient] Initialized with ${store.things.size} things`);
+  }
+  function log(operation, ...args) {
+    if (verbose) {
+      console.log(`[MockClient] ${operation}`, ...args);
+    }
+  }
+  return {
+    /**
+     * Namespace operations
+     */
+    Namespace: {
+      async list(_params) {
+        await delay(delayMs);
+        log("Namespace.list");
+        const namespaces = /* @__PURE__ */ new Set();
+        for (const thing of store.things.values()) {
+          namespaces.add(thing.ns);
+        }
+        namespaces.add("default");
+        return Array.from(namespaces).map((ns) => ({
+          id: ns,
+          name: ns
+        }));
+      }
+    },
+    /**
+     * Schema operations
+     */
+    Schema: {
+      async discover(_params) {
+        await delay(delayMs);
+        log("Schema.discover");
+        const types = /* @__PURE__ */ new Set();
+        for (const thing of store.things.values()) {
+          types.add(thing.type);
+        }
+        for (const type of MOCK_TYPES) {
+          types.add(type);
+        }
+        const typeList = Array.from(types).sort();
+        return {
+          namespaces: ["default"],
+          types: typeList,
+          schemas: typeList
+        };
+      },
+      async get(params) {
+        await delay(delayMs);
+        log("Schema.get", params.type);
+        return generateMockSchema(params.type);
+      }
+    },
+    /**
+     * Thing operations
+     */
+    Thing: {
+      async types(params) {
+        await delay(delayMs);
+        log("Thing.types");
+        const types = /* @__PURE__ */ new Set();
+        for (const thing of store.things.values()) {
+          if (!params.ns || thing.ns === params.ns) {
+            types.add(thing.type);
+          }
+        }
+        for (const type of MOCK_TYPES) {
+          types.add(type);
+        }
+        return Array.from(types).sort().map((name) => ({
+          name,
+          ns: params.ns || "default"
+        }));
+      },
+      async list(params) {
+        await delay(delayMs);
+        log("Thing.list", params);
+        let things = Array.from(store.things.values());
+        if (params.ns) {
+          things = things.filter((t) => t.ns === params.ns);
+        }
+        if (params.type) {
+          things = things.filter((t) => t.type === params.type);
+        }
+        things = things.filter((t) => {
+          const key = thingKey(t.ns, t.type, t.id);
+          return !store.deletedThings.has(key);
+        });
+        things.sort((a, b) => new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime());
+        const total = things.length;
+        const offset = params.offset || 0;
+        const limit = params.limit || 50;
+        things = things.slice(offset, offset + limit);
+        return { data: things, total };
+      },
+      async get(params) {
+        await delay(delayMs);
+        log("Thing.get", params);
+        const key = thingKey(params.ns || "default", params.type, params.id);
+        if (store.deletedThings.has(key)) {
+          return null;
+        }
+        return store.things.get(key) || null;
+      },
+      async create(params) {
+        await delay(delayMs);
+        log("Thing.create", params);
+        const ns = params.ns || "default";
+        const now = /* @__PURE__ */ new Date();
+        const baseThing = generateMockThing(params.type);
+        const thing = {
+          ...baseThing,
+          ns,
+          id: baseThing.id,
+          name: params.name || baseThing.name,
+          createdAt: now,
+          updatedAt: now,
+          ts: now,
+          data: {
+            "@type": params.type,
+            ...params.data
+          }
+        };
+        const key = thingKey(ns, params.type, thing.id);
+        store.things.set(key, thing);
+        return thing;
+      },
+      async update(params) {
+        await delay(delayMs);
+        log("Thing.update", params);
+        const ns = params.ns || "default";
+        const key = thingKey(ns, params.type, params.id);
+        const existing = store.things.get(key);
+        if (!existing || store.deletedThings.has(key)) {
+          throw new Error(`Thing not found: ${key}`);
+        }
+        const now = /* @__PURE__ */ new Date();
+        const updated = {
+          ...existing,
+          updatedAt: now,
+          ts: now,
+          data: {
+            ...existing.data,
+            ...params.data
+          }
+        };
+        store.things.set(key, updated);
+        return updated;
+      },
+      async delete(params) {
+        await delay(delayMs);
+        log("Thing.delete", params);
+        const ns = params.ns || "default";
+        const key = thingKey(ns, params.type, params.id);
+        if (params.hard) {
+          store.things.delete(key);
+        } else {
+          store.deletedThings.add(key);
+        }
+        return { success: true };
+      },
+      async versions(_params) {
+        await delay(delayMs);
+        log("Thing.versions", _params);
+        return [];
+      },
+      async stats(_params) {
+        await delay(delayMs);
+        log("Thing.stats", _params);
+        const byType = {};
+        let total = 0;
+        for (const thing of store.things.values()) {
+          const key = thingKey(thing.ns, thing.type, thing.id);
+          if (store.deletedThings.has(key)) continue;
+          if (_params.ns && thing.ns !== _params.ns) continue;
+          if (_params.type && thing.type !== _params.type) continue;
+          byType[thing.type] = (byType[thing.type] || 0) + 1;
+          total++;
+        }
+        return { total, byType };
+      }
+    },
+    /**
+     * SQL operations (mock implementation)
+     */
+    SQL: {
+      async execute(params) {
+        await delay(delayMs);
+        log("SQL.execute", params.query);
+        const query = params.query.toLowerCase().trim();
+        if (query.startsWith("select")) {
+          const match = query.match(/select\s+\*\s+from\s+(\w+)/i);
+          if (match) {
+            const type = match[1];
+            const things = Array.from(store.things.values()).filter(
+              (t) => t.type.toLowerCase() === type.toLowerCase()
+            );
+            const rows = things.map((t) => ({
+              id: t.id,
+              ns: t.ns,
+              type: t.type,
+              name: t.name,
+              createdAt: t.createdAt,
+              updatedAt: t.updatedAt,
+              data: JSON.stringify(t.data)
+            }));
+            return {
+              rows,
+              columns: [
+                { name: "id", type: "string" },
+                { name: "ns", type: "string" },
+                { name: "type", type: "string" },
+                { name: "name", type: "string" },
+                { name: "createdAt", type: "datetime" },
+                { name: "updatedAt", type: "datetime" },
+                { name: "data", type: "json" }
+              ],
+              rowsAffected: rows.length,
+              executionTimeMs: delayMs
+            };
+          }
+        }
+        return {
+          rows: [],
+          columns: [],
+          rowsAffected: 0,
+          executionTimeMs: delayMs
+        };
+      }
+    },
+    // Required for interface compatibility
+    dup: () => createMockClient(options),
+    onRpcBroken: (_callback) => {
+    },
+    [Symbol.dispose]: () => {
+    },
+    // Mock-specific methods for testing
+    _store: store,
+    _reset: () => {
+      store.things.clear();
+      store.deletedThings.clear();
+      const freshData = initialData ?? generateInitialMockData();
+      for (const thing of freshData) {
+        const key = thingKey(thing.ns, thing.type, thing.id);
+        store.things.set(key, thing);
+      }
+    }
+  };
+}
+function $MockContext(options) {
+  return createMockClient(options);
+}
+
+// src/lib/url-utils.ts
+function deriveRpcUrl(url) {
+  let rpcUrl = url.replace(/^wss:/, "https:").replace(/^ws:/, "http:");
+  rpcUrl = rpcUrl.replace(/\/(sync|rpc)$/, "");
+  rpcUrl = rpcUrl.replace(/\/$/, "");
+  return `${rpcUrl}/rpc`;
+}
+
+// src/lib/fetch-with-timeout.ts
+var DEFAULT_REQUEST_TIMEOUT = 3e4;
+async function fetchWithTimeout(url, options = {}) {
+  const { timeout = DEFAULT_REQUEST_TIMEOUT, signal: existingSignal, ...fetchOptions } = options;
+  const controller = new AbortController();
+  const timeoutId = setTimeout(() => controller.abort(), timeout);
+  const existingAbortHandler = existingSignal ? () => controller.abort(existingSignal.reason) : null;
+  if (existingSignal) {
+    if (existingSignal.aborted) {
+      clearTimeout(timeoutId);
+      controller.abort(existingSignal.reason);
+    } else {
+      existingSignal.addEventListener("abort", existingAbortHandler);
+    }
+  }
+  try {
+    const response = await fetch(url, {
+      ...fetchOptions,
+      signal: controller.signal
+    });
+    return response;
+  } finally {
+    clearTimeout(timeoutId);
+    if (existingSignal && existingAbortHandler) {
+      existingSignal.removeEventListener("abort", existingAbortHandler);
+    }
+  }
+}
+function createFetchWithTimeout(defaultTimeout) {
+  return (url, options = {}) => fetchWithTimeout(url, { timeout: defaultTimeout, ...options });
+}
+function useHealthCheck(config) {
+  const [isConnected, setIsConnected] = useState(false);
+  const [connectionError, setConnectionError] = useState();
+  const [isChecking, setIsChecking] = useState(true);
+  const { apiEndpoint, authToken, requestTimeout, healthCheckRetries = 3 } = config;
+  const abortControllerRef = useRef(null);
+  const performHealthCheck = useCallback(async () => {
+    const response = await fetchWithTimeout(apiEndpoint, {
+      method: "GET",
+      headers: {
+        "Content-Type": "application/json",
+        ...authToken ? { Authorization: `Bearer ${authToken}` } : {}
+      },
+      timeout: requestTimeout ?? DEFAULT_REQUEST_TIMEOUT
+    });
+    if (!response.ok) {
+      throw new Error(`Health check failed: ${response.status}`);
+    }
+  }, [apiEndpoint, authToken, requestTimeout]);
+  const checkConnection = useCallback(async () => {
+    setIsChecking(true);
+    try {
+      await retryWithBackoff(performHealthCheck, {
+        maxRetries: healthCheckRetries,
+        backoffMultiplier: 1e3
+      });
+      setIsConnected(true);
+      setConnectionError(void 0);
+    } catch (error) {
+      setIsConnected(false);
+      setConnectionError(error instanceof Error ? error : new Error("Connection failed"));
+    } finally {
+      setIsChecking(false);
+    }
+  }, [performHealthCheck, healthCheckRetries]);
+  useEffect(() => {
+    abortControllerRef.current = new AbortController();
+    const { signal } = abortControllerRef.current;
+    async function runCheck() {
+      try {
+        await retryWithBackoff(performHealthCheck, {
+          maxRetries: healthCheckRetries,
+          backoffMultiplier: 1e3,
+          signal
+        });
+        if (!signal.aborted) {
+          setIsConnected(true);
+          setConnectionError(void 0);
+          setIsChecking(false);
+        }
+      } catch (error) {
+        if (!signal.aborted) {
+          setIsConnected(false);
+          setConnectionError(error instanceof Error ? error : new Error("Connection failed"));
+          setIsChecking(false);
+        }
+      }
+    }
+    runCheck();
+    return () => {
+      abortControllerRef.current?.abort();
+    };
+  }, [performHealthCheck, healthCheckRetries]);
+  return {
+    isConnected,
+    connectionError,
+    checkConnection,
+    isChecking
+  };
+}
+
+export { $CapnwebContext, $JsonRpcContext, $MockContext, DEFAULT_REQUEST_TIMEOUT, MOCK_TYPES, createCapnwebClient, createFetchWithTimeout, createJsonRpcClient, createMockClient, deriveRpcUrl, fetchWithTimeout, generateInitialMockData, generateMockSchema, generateMockThing, generateMockThings, useHealthCheck };
+//# sourceMappingURL=chunk-OVLO7UOH.js.map
+//# sourceMappingURL=chunk-OVLO7UOH.js.map