@superatomai/sdk-web 0.0.5

package/dist/index.cjs

@@ -0,0 +1,1611 @@
+'use strict';
+
+var zod = require('zod');
+
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var ExpressionSchema = zod.z.object({
+  $exp: zod.z.string(),
+  $deps: zod.z.array(zod.z.string()).optional()
+});
+var BindingSchema = zod.z.object({
+  $bind: zod.z.string(),
+  $transform: zod.z.array(
+    zod.z.object({
+      name: zod.z.string(),
+      args: zod.z.array(zod.z.any()).optional()
+    })
+  ).optional()
+});
+var ForDirectiveSchema = zod.z.object({
+  in: zod.z.union([ExpressionSchema, BindingSchema, zod.z.string()]),
+  as: zod.z.string(),
+  key: zod.z.string().optional(),
+  index: zod.z.string().optional()
+});
+var QuerySpecSchema = zod.z.object({
+  graphql: zod.z.string().optional(),
+  sql: zod.z.string().optional(),
+  variables: zod.z.record(zod.z.string(), zod.z.any()).optional(),
+  params: zod.z.record(zod.z.string(), zod.z.any()).optional(),
+  key: zod.z.string().optional(),
+  refetchPolicy: zod.z.enum(["cache-first", "network-only", "cache-and-network"]).optional(),
+  dependencies: zod.z.array(zod.z.string()).optional()
+});
+var UIElementSchema = zod.z.lazy(
+  () => zod.z.object({
+    id: zod.z.string(),
+    type: zod.z.string(),
+    key: zod.z.union([zod.z.string(), ExpressionSchema]).optional(),
+    props: zod.z.record(zod.z.string(), zod.z.any()).optional(),
+    query: QuerySpecSchema.optional(),
+    if: ExpressionSchema.optional(),
+    elseIf: ExpressionSchema.optional(),
+    for: ForDirectiveSchema.optional(),
+    "link-to": zod.z.union([
+      zod.z.string(),
+      ExpressionSchema,
+      BindingSchema,
+      zod.z.object({
+        ui: zod.z.union([zod.z.string(), ExpressionSchema, BindingSchema]),
+        params: zod.z.record(zod.z.string(), zod.z.any()).optional()
+      })
+    ]).optional(),
+    _meta: zod.z.object({
+      id: zod.z.string().optional(),
+      version: zod.z.string().optional(),
+      created: zod.z.string().optional(),
+      lastModified: zod.z.string().optional()
+    }).optional(),
+    children: zod.z.any().optional(),
+    else: UIElementSchema.optional(),
+    slots: zod.z.record(zod.z.string(), zod.z.union([UIElementSchema, zod.z.array(UIElementSchema)])).optional(),
+    platform: zod.z.object({
+      web: zod.z.any().optional(),
+      ios: zod.z.any().optional(),
+      android: zod.z.any().optional()
+    }).optional()
+  })
+);
+var UIComponentSchema = zod.z.object({
+  id: zod.z.string(),
+  name: zod.z.string().optional(),
+  props: zod.z.record(zod.z.string(), zod.z.any()).optional(),
+  states: zod.z.record(zod.z.string(), zod.z.any()).optional(),
+  methods: zod.z.record(
+    zod.z.string(),
+    zod.z.object({
+      fn: zod.z.string(),
+      params: zod.z.record(zod.z.string(), zod.z.any()).optional()
+    })
+  ).optional(),
+  effects: zod.z.array(
+    zod.z.object({
+      fn: zod.z.string(),
+      deps: zod.z.array(zod.z.string()).optional()
+    })
+  ).optional(),
+  data: zod.z.record(zod.z.string(), zod.z.any()).optional(),
+  render: UIElementSchema,
+  query: QuerySpecSchema.optional()
+});
+var DSLRendererPropsSchema = zod.z.object({
+  dsl: UIComponentSchema,
+  data: zod.z.record(zod.z.string(), zod.z.any()).optional(),
+  context: zod.z.record(zod.z.string(), zod.z.any()).optional()
+});
+var ExpressionSchema2 = zod.z.object({
+  $exp: zod.z.string(),
+  $deps: zod.z.array(zod.z.string()).optional()
+});
+var BindingSchema2 = zod.z.object({
+  $bind: zod.z.string(),
+  $transform: zod.z.array(
+    zod.z.object({
+      name: zod.z.string(),
+      args: zod.z.array(zod.z.any()).optional()
+    })
+  ).optional()
+});
+var ForDirectiveSchema2 = zod.z.object({
+  in: zod.z.union([ExpressionSchema2, BindingSchema2, zod.z.string()]),
+  as: zod.z.string(),
+  key: zod.z.string().optional(),
+  index: zod.z.string().optional()
+});
+var QuerySpecSchema2 = zod.z.object({
+  graphql: zod.z.string().optional(),
+  sql: zod.z.string().optional(),
+  variables: zod.z.record(zod.z.string(), zod.z.any()).optional(),
+  params: zod.z.record(zod.z.string(), zod.z.any()).optional(),
+  key: zod.z.string().optional(),
+  refetchPolicy: zod.z.enum(["cache-first", "network-only", "cache-and-network"]).optional(),
+  dependencies: zod.z.array(zod.z.string()).optional()
+});
+var UIElementSchema2 = zod.z.lazy(
+  () => zod.z.object({
+    id: zod.z.string(),
+    type: zod.z.string(),
+    key: zod.z.union([zod.z.string(), ExpressionSchema2]).optional(),
+    props: zod.z.record(zod.z.string(), zod.z.any()).optional(),
+    query: QuerySpecSchema2.optional(),
+    if: ExpressionSchema2.optional(),
+    elseIf: ExpressionSchema2.optional(),
+    for: ForDirectiveSchema2.optional(),
+    "link-to": zod.z.union([
+      zod.z.string(),
+      ExpressionSchema2,
+      BindingSchema2,
+      zod.z.object({
+        ui: zod.z.union([zod.z.string(), ExpressionSchema2, BindingSchema2]),
+        params: zod.z.record(zod.z.string(), zod.z.any()).optional()
+      })
+    ]).optional(),
+    _meta: zod.z.object({
+      id: zod.z.string().optional(),
+      version: zod.z.string().optional(),
+      created: zod.z.string().optional(),
+      lastModified: zod.z.string().optional()
+    }).optional(),
+    children: zod.z.any().optional(),
+    else: UIElementSchema2.optional(),
+    slots: zod.z.record(zod.z.string(), zod.z.union([UIElementSchema2, zod.z.array(UIElementSchema2)])).optional(),
+    platform: zod.z.object({
+      web: zod.z.any().optional(),
+      ios: zod.z.any().optional(),
+      android: zod.z.any().optional()
+    }).optional()
+  })
+);
+var UIComponentSchema2 = zod.z.object({
+  id: zod.z.string(),
+  name: zod.z.string().optional(),
+  props: zod.z.record(zod.z.string(), zod.z.any()).optional(),
+  states: zod.z.record(zod.z.string(), zod.z.any()).optional(),
+  methods: zod.z.record(
+    zod.z.string(),
+    zod.z.object({
+      fn: zod.z.string(),
+      params: zod.z.record(zod.z.string(), zod.z.any()).optional()
+    })
+  ).optional(),
+  effects: zod.z.array(
+    zod.z.object({
+      fn: zod.z.string(),
+      deps: zod.z.array(zod.z.string()).optional()
+    })
+  ).optional(),
+  data: zod.z.record(zod.z.string(), zod.z.any()).optional(),
+  render: UIElementSchema2,
+  query: QuerySpecSchema2.optional()
+});
+var DSLRendererPropsSchema2 = zod.z.object({
+  dsl: UIComponentSchema2,
+  data: zod.z.record(zod.z.string(), zod.z.any()).optional(),
+  context: zod.z.record(zod.z.string(), zod.z.any()).optional()
+});
+
+// src/schemas.ts
+var MessageParticipantSchema = zod.z.object({
+  id: zod.z.string().optional(),
+  type: zod.z.string().optional()
+});
+var MessageSchema = zod.z.object({
+  id: zod.z.string(),
+  type: zod.z.string(),
+  from: MessageParticipantSchema,
+  to: MessageParticipantSchema.optional(),
+  payload: zod.z.unknown()
+});
+var AuthLoginPayloadSchema = zod.z.object({
+  login_data: zod.z.string()
+  // Base64 encoded login data (username + SHA-1 hashed password)
+});
+var AuthLoginRequestMessageSchema = zod.z.object({
+  id: zod.z.string(),
+  type: zod.z.literal("AUTH_LOGIN_REQ"),
+  from: MessageParticipantSchema,
+  to: MessageParticipantSchema.optional(),
+  payload: AuthLoginPayloadSchema
+});
+var AuthLoginResponsePayloadSchema = zod.z.object({
+  success: zod.z.boolean(),
+  error: zod.z.string().optional(),
+  data: zod.z.unknown().optional()
+  // User ID or additional auth data
+});
+var AuthLoginResponseMessageSchema = zod.z.object({
+  id: zod.z.string(),
+  type: zod.z.literal("AUTH_LOGIN_RES"),
+  from: MessageParticipantSchema,
+  to: MessageParticipantSchema.optional(),
+  payload: AuthLoginResponsePayloadSchema
+});
+var AuthVerifyPayloadSchema = zod.z.object({
+  token: zod.z.string()
+  // Base64 encoded authentication token
+});
+var AuthVerifyRequestMessageSchema = zod.z.object({
+  id: zod.z.string(),
+  type: zod.z.literal("AUTH_VERIFY_REQ"),
+  from: MessageParticipantSchema,
+  to: MessageParticipantSchema.optional(),
+  payload: AuthVerifyPayloadSchema
+});
+var AuthVerifyResponsePayloadSchema = zod.z.object({
+  success: zod.z.boolean(),
+  error: zod.z.string().optional(),
+  data: zod.z.unknown().optional()
+});
+var AuthVerifyResponseMessageSchema = zod.z.object({
+  id: zod.z.string(),
+  type: zod.z.literal("AUTH_VERIFY_RES"),
+  from: MessageParticipantSchema,
+  to: MessageParticipantSchema.optional(),
+  payload: AuthVerifyResponsePayloadSchema
+});
+var UserPromptRequestPayloadSchema = zod.z.object({
+  prompt: zod.z.string(),
+  SA_RUNTIME: zod.z.object({
+    threadId: zod.z.string(),
+    uiBlockId: zod.z.string()
+  }).optional()
+});
+var UserPromptRequestMessageSchema = zod.z.object({
+  id: zod.z.string(),
+  type: zod.z.literal("USER_PROMPT_REQ"),
+  from: MessageParticipantSchema,
+  to: MessageParticipantSchema.optional(),
+  payload: UserPromptRequestPayloadSchema
+});
+var ComponentSchema = zod.z.object({
+  id: zod.z.string(),
+  name: zod.z.string(),
+  type: zod.z.string(),
+  description: zod.z.string(),
+  props: zod.z.object({
+    query: zod.z.string().optional(),
+    title: zod.z.string().optional(),
+    description: zod.z.string().optional(),
+    config: zod.z.record(zod.z.string(), zod.z.unknown()).optional()
+  }),
+  category: zod.z.string().optional(),
+  keywords: zod.z.array(zod.z.string()).optional()
+});
+var UserPromptResponsePayloadSchema = zod.z.object({
+  success: zod.z.boolean(),
+  error: zod.z.string().optional(),
+  data: zod.z.object({
+    component: ComponentSchema.optional()
+  }).optional(),
+  uiBlockId: zod.z.string().optional(),
+  threadId: zod.z.string().optional()
+});
+var UserPromptResponseMessageSchema = zod.z.object({
+  id: zod.z.string(),
+  type: zod.z.literal("USER_PROMPT_RES"),
+  from: MessageParticipantSchema,
+  to: MessageParticipantSchema.optional(),
+  payload: UserPromptResponsePayloadSchema
+});
+var UserPromptSuggestionsRequestPayloadSchema = zod.z.object({
+  prompt: zod.z.string(),
+  limit: zod.z.number().int().positive().default(5)
+});
+var UserPromptSuggestionsRequestMessageSchema = zod.z.object({
+  id: zod.z.string(),
+  type: zod.z.literal("USER_PROMPT_SUGGESTIONS_REQ"),
+  from: MessageParticipantSchema,
+  to: MessageParticipantSchema.optional(),
+  payload: UserPromptSuggestionsRequestPayloadSchema
+});
+var UserPromptSuggestionsResponsePayloadSchema = zod.z.object({
+  success: zod.z.boolean(),
+  error: zod.z.string().optional(),
+  data: zod.z.object({
+    prompt: zod.z.string(),
+    suggestions: zod.z.array(ComponentSchema),
+    count: zod.z.number(),
+    message: zod.z.string().optional()
+  }).optional()
+});
+var UserPromptSuggestionsResponseMessageSchema = zod.z.object({
+  id: zod.z.string(),
+  type: zod.z.literal("USER_PROMPT_SUGGESTIONS_RES"),
+  from: MessageParticipantSchema,
+  to: MessageParticipantSchema.optional(),
+  payload: UserPromptSuggestionsResponsePayloadSchema
+});
+var BundleRequestPayloadSchema = zod.z.object({});
+var BundleRequestMessageSchema = zod.z.object({
+  id: zod.z.string(),
+  type: zod.z.literal("BUNDLE_REQ"),
+  from: MessageParticipantSchema,
+  to: MessageParticipantSchema.optional(),
+  payload: BundleRequestPayloadSchema
+});
+var BundleChunkPayloadSchema = zod.z.object({
+  chunk: zod.z.string(),
+  chunkIndex: zod.z.number(),
+  totalChunks: zod.z.number(),
+  isComplete: zod.z.boolean(),
+  progress: zod.z.number()
+});
+var BundleChunkMessageSchema = zod.z.object({
+  id: zod.z.string(),
+  type: zod.z.literal("BUNDLE_CHUNK"),
+  from: MessageParticipantSchema,
+  to: MessageParticipantSchema.optional(),
+  payload: BundleChunkPayloadSchema
+});
+var BundleErrorPayloadSchema = zod.z.object({
+  error: zod.z.string()
+});
+var BundleErrorMessageSchema = zod.z.object({
+  id: zod.z.string(),
+  type: zod.z.literal("BUNDLE_RES"),
+  from: MessageParticipantSchema,
+  to: MessageParticipantSchema.optional(),
+  payload: BundleErrorPayloadSchema
+});
+var DataRequestPayloadSchema = zod.z.object({
+  collection: zod.z.string(),
+  op: zod.z.string(),
+  params: zod.z.record(zod.z.string(), zod.z.unknown()).optional(),
+  SA_RUNTIME: zod.z.record(zod.z.string(), zod.z.unknown()).optional()
+});
+var DataRequestMessageSchema = zod.z.object({
+  id: zod.z.string(),
+  type: zod.z.literal("DATA_REQ"),
+  from: MessageParticipantSchema,
+  to: MessageParticipantSchema.optional(),
+  payload: DataRequestPayloadSchema
+});
+var DataResponsePayloadSchema = zod.z.object({
+  collection: zod.z.string(),
+  op: zod.z.string(),
+  data: zod.z.unknown(),
+  executionMs: zod.z.number().optional(),
+  error: zod.z.string().optional()
+});
+var DataResponseMessageSchema = zod.z.object({
+  id: zod.z.string(),
+  type: zod.z.literal("DATA_RES"),
+  from: MessageParticipantSchema,
+  to: MessageParticipantSchema.optional(),
+  payload: DataResponsePayloadSchema
+});
+var UILogEntrySchema = zod.z.object({
+  timestamp: zod.z.number(),
+  level: zod.z.enum(["info", "error", "warn", "debug"]),
+  message: zod.z.string(),
+  type: zod.z.enum(["explanation", "query", "general"]).optional(),
+  data: zod.z.record(zod.z.string(), zod.z.unknown()).optional()
+});
+var UILogsPayloadSchema = zod.z.object({
+  logs: zod.z.array(UILogEntrySchema)
+});
+var UILogsMessageSchema = zod.z.object({
+  id: zod.z.string(),
+  // uiBlockId
+  type: zod.z.literal("UI_LOGS"),
+  from: MessageParticipantSchema,
+  to: MessageParticipantSchema.optional(),
+  payload: UILogsPayloadSchema
+});
+var UsersRequestPayloadSchema = zod.z.object({
+  operation: zod.z.enum(["create", "update", "delete", "getAll", "getOne"]),
+  data: zod.z.object({
+    username: zod.z.string().optional(),
+    password: zod.z.string().optional()
+  }).optional()
+});
+var UsersRequestMessageSchema = zod.z.object({
+  id: zod.z.string(),
+  type: zod.z.literal("USERS"),
+  from: MessageParticipantSchema,
+  to: MessageParticipantSchema.optional(),
+  payload: UsersRequestPayloadSchema
+});
+var UsersResponsePayloadSchema = zod.z.object({
+  success: zod.z.boolean(),
+  error: zod.z.string().optional(),
+  data: zod.z.object({
+    username: zod.z.string().optional(),
+    message: zod.z.string().optional(),
+    users: zod.z.array(zod.z.object({
+      username: zod.z.string(),
+      wsIds: zod.z.array(zod.z.string())
+    })).optional(),
+    user: zod.z.object({
+      username: zod.z.string(),
+      wsIds: zod.z.array(zod.z.string())
+    }).optional(),
+    count: zod.z.number().optional()
+  }).optional()
+});
+zod.z.object({
+  id: zod.z.string(),
+  type: zod.z.literal("USERS_RES"),
+  from: MessageParticipantSchema,
+  to: MessageParticipantSchema.optional(),
+  payload: UsersResponsePayloadSchema
+});
+var DashboardsRequestPayloadSchema = zod.z.object({
+  operation: zod.z.enum(["create", "update", "delete", "getAll", "getOne"]),
+  data: zod.z.object({
+    dashboardId: zod.z.string().optional(),
+    dashboard: DSLRendererPropsSchema.optional()
+  }).optional()
+});
+var DashboardsRequestMessageSchema = zod.z.object({
+  id: zod.z.string(),
+  type: zod.z.literal("DASHBOARDS"),
+  from: MessageParticipantSchema,
+  to: MessageParticipantSchema.optional(),
+  payload: DashboardsRequestPayloadSchema
+});
+var DashboardsResponsePayloadSchema = zod.z.object({
+  success: zod.z.boolean(),
+  error: zod.z.string().optional(),
+  data: zod.z.object({
+    dashboardId: zod.z.string().optional(),
+    dashboard: DSLRendererPropsSchema.optional(),
+    dashboards: zod.z.array(zod.z.object({
+      dashboardId: zod.z.string(),
+      dashboard: DSLRendererPropsSchema
+    })).optional(),
+    count: zod.z.number().optional(),
+    message: zod.z.string().optional()
+  }).optional()
+});
+zod.z.object({
+  id: zod.z.string(),
+  type: zod.z.literal("DASHBOARDS_RES"),
+  from: MessageParticipantSchema,
+  to: MessageParticipantSchema.optional(),
+  payload: DashboardsResponsePayloadSchema
+});
+var ReportsRequestPayloadSchema = zod.z.object({
+  operation: zod.z.enum(["create", "update", "delete", "getAll", "getOne"]),
+  data: zod.z.object({
+    reportId: zod.z.string().optional(),
+    report: DSLRendererPropsSchema2.optional()
+  }).optional()
+});
+var ReportsRequestMessageSchema = zod.z.object({
+  id: zod.z.string(),
+  type: zod.z.literal("REPORTS"),
+  from: MessageParticipantSchema,
+  to: MessageParticipantSchema.optional(),
+  payload: ReportsRequestPayloadSchema
+});
+var ReportsResponsePayloadSchema = zod.z.object({
+  success: zod.z.boolean(),
+  error: zod.z.string().optional(),
+  data: zod.z.object({
+    reportId: zod.z.string().optional(),
+    report: DSLRendererPropsSchema2.optional(),
+    reports: zod.z.array(zod.z.object({
+      reportId: zod.z.string(),
+      report: DSLRendererPropsSchema2
+    })).optional(),
+    count: zod.z.number().optional(),
+    message: zod.z.string().optional()
+  }).optional()
+});
+zod.z.object({
+  id: zod.z.string(),
+  type: zod.z.literal("REPORTS_RES"),
+  from: MessageParticipantSchema,
+  to: MessageParticipantSchema.optional(),
+  payload: ReportsResponsePayloadSchema
+});
+var ClientConfigSchema = zod.z.object({
+  userId: zod.z.string(),
+  projectId: zod.z.string(),
+  baseUrl: zod.z.string().default("wss://ws.superatom.ai/websocket"),
+  type: zod.z.string().default("runtime"),
+  maxReconnectAttempts: zod.z.number().min(0).default(Infinity),
+  initialReconnectDelay: zod.z.number().min(0).default(1e3),
+  maxReconnectDelay: zod.z.number().min(0).default(3e4),
+  defaultTimeout: zod.z.number().min(0).default(3e4),
+  debug: zod.z.boolean().default(false)
+});
+
+// src/services/index.ts
+var services_exports = {};
+__export(services_exports, {
+  BindingSchema: () => BindingSchema,
+  DSLRendererPropsSchema: () => DSLRendererPropsSchema,
+  ExpressionSchema: () => ExpressionSchema,
+  ForDirectiveSchema: () => ForDirectiveSchema,
+  QuerySpecSchema: () => QuerySpecSchema,
+  UIComponentSchema: () => UIComponentSchema,
+  UIElementSchema: () => UIElementSchema,
+  createDashboard: () => createDashboard,
+  createReport: () => createReport,
+  createUser: () => createUser,
+  deleteDashboard: () => deleteDashboard,
+  deleteReport: () => deleteReport,
+  deleteUser: () => deleteUser,
+  getAllDashboards: () => getAllDashboards,
+  getAllReports: () => getAllReports,
+  getAllUsers: () => getAllUsers,
+  getComponentSuggestions: () => getComponentSuggestions,
+  getDashboard: () => getDashboard,
+  getReport: () => getReport,
+  getUser: () => getUser,
+  requestBundle: () => requestBundle,
+  requestData: () => requestData,
+  sendAuthLoginRequest: () => sendAuthLoginRequest,
+  sendAuthVerifyRequest: () => sendAuthVerifyRequest,
+  sendUserPromptRequest: () => sendUserPromptRequest,
+  sendUserPromptSuggestionsRequest: () => sendUserPromptSuggestionsRequest,
+  updateDashboard: () => updateDashboard,
+  updateReport: () => updateReport,
+  updateUser: () => updateUser
+});
+
+// src/services/auth.ts
+async function sendAuthLoginRequest(client, loginDataBase64, timeout) {
+  const messageId = `login_${Date.now()}`;
+  const message = AuthLoginRequestMessageSchema.parse({
+    id: messageId,
+    type: "AUTH_LOGIN_REQ",
+    from: {
+      type: "runtime"
+    },
+    to: {
+      type: "data-agent"
+    },
+    payload: {
+      login_data: loginDataBase64
+    }
+  });
+  const response = await client.sendWithResponse(message, timeout);
+  return response;
+}
+async function sendAuthVerifyRequest(client, token, timeout) {
+  const messageId = `verify_${Date.now()}`;
+  const message = AuthVerifyRequestMessageSchema.parse({
+    id: messageId,
+    type: "AUTH_VERIFY_REQ",
+    from: {
+      type: "runtime"
+    },
+    to: {
+      type: "data-agent"
+    },
+    payload: {
+      token
+    }
+  });
+  const response = await client.sendWithResponse(message, timeout);
+  return response;
+}
+
+// src/services/userPrompt.ts
+async function sendUserPromptRequest(client, prompt, threadId, uiBlockId, timeout) {
+  const messageId = `msg_${Date.now()}`;
+  const message = UserPromptRequestMessageSchema.parse({
+    id: messageId,
+    type: "USER_PROMPT_REQ",
+    from: {
+      type: "runtime"
+    },
+    to: {
+      type: "data-agent"
+    },
+    payload: {
+      prompt,
+      SA_RUNTIME: {
+        threadId,
+        uiBlockId
+      }
+    }
+  });
+  const response = await client.sendWithResponse(message, timeout);
+  return response;
+}
+async function sendUserPromptSuggestionsRequest(client, prompt, limit = 5, timeout) {
+  if (!prompt || prompt.trim().length === 0) {
+    return null;
+  }
+  const messageId = `suggestions_${Date.now()}`;
+  const message = UserPromptSuggestionsRequestMessageSchema.parse({
+    id: messageId,
+    type: "USER_PROMPT_SUGGESTIONS_REQ",
+    from: {
+      type: "runtime"
+    },
+    to: {
+      type: "data-agent"
+    },
+    payload: {
+      prompt,
+      limit
+    }
+  });
+  const response = await client.sendWithResponse(message, timeout);
+  return response;
+}
+
+// src/services/bundle.ts
+async function requestBundle(client, options) {
+  const messageId = `msg_${Date.now()}_${Math.random().toString(36).substring(7)}`;
+  const message = BundleRequestMessageSchema.parse({
+    id: messageId,
+    type: "BUNDLE_REQ",
+    from: { type: "runtime" },
+    to: { type: "data-agent" },
+    payload: {}
+  });
+  const chunks = [];
+  let totalChunks = 0;
+  const unsubscribe = client.onMessage((msg) => {
+    try {
+      if (msg.type === "BUNDLE_CHUNK" && msg.id?.startsWith(messageId)) {
+        const chunkMessage = BundleChunkMessageSchema.parse(msg);
+        const payload = chunkMessage.payload;
+        chunks[payload.chunkIndex] = payload.chunk;
+        totalChunks = payload.totalChunks;
+        if (options?.onProgress) {
+          options.onProgress(payload.progress);
+        }
+      }
+    } catch (error) {
+      console.error("[SuperAtom] Failed to parse bundle chunk:", error);
+    }
+  });
+  client.send(message);
+  const timeout = options?.timeout ?? 6e4;
+  const startTime = Date.now();
+  return new Promise((resolve, reject) => {
+    const checkInterval = setInterval(() => {
+      if (Date.now() - startTime > timeout) {
+        clearInterval(checkInterval);
+        unsubscribe();
+        reject(new Error(`Bundle request timeout after ${timeout}ms`));
+        return;
+      }
+      if (totalChunks > 0 && chunks.length === totalChunks) {
+        clearInterval(checkInterval);
+        unsubscribe();
+        const bundle = chunks.join("");
+        resolve(bundle);
+      }
+    }, 100);
+  });
+}
+
+// src/services/data.ts
+async function requestData(client, options) {
+  const messageId = `msg_${Date.now()}_${Math.random().toString(36).substring(7)}`;
+  const message = DataRequestMessageSchema.parse({
+    id: messageId,
+    type: "DATA_REQ",
+    from: { type: "runtime" },
+    to: { type: "data-agent" },
+    payload: {
+      collection: options.collection,
+      op: options.operation,
+      params: options.params
+    }
+  });
+  const response = await client.sendWithResponse(message, options.timeout);
+  const payload = response.payload;
+  return {
+    data: payload.data,
+    error: payload.error,
+    executionMs: payload.executionMs
+  };
+}
+
+// src/services/component.ts
+async function getComponentSuggestions(client, query, options) {
+  const messageId = `msg_${Date.now()}_${Math.random().toString(36).substring(7)}`;
+  const message = {
+    id: messageId,
+    type: "USER_PROMPT_REQ",
+    to: { type: "data-agent" },
+    payload: {
+      prompt: query
+    }
+  };
+  const response = await client.sendWithResponse(message, options?.timeout);
+  const payload = response.payload;
+  return {
+    component: payload.component,
+    error: payload.error
+  };
+}
+
+// src/services/users.ts
+async function createUser(client, username, password, timeout) {
+  const messageId = `users_create_${Date.now()}`;
+  const message = UsersRequestMessageSchema.parse({
+    id: messageId,
+    type: "USERS",
+    from: { type: "admin" },
+    to: { type: "data-agent" },
+    payload: {
+      operation: "create",
+      data: {
+        username,
+        password
+      }
+    }
+  });
+  const response = await client.sendWithResponse(message, timeout);
+  const payload = response.payload;
+  return {
+    success: payload.success,
+    error: payload.error,
+    message: payload.data?.message,
+    username: payload.data?.username
+  };
+}
+async function updateUser(client, username, password, timeout) {
+  const messageId = `users_update_${Date.now()}`;
+  const message = UsersRequestMessageSchema.parse({
+    id: messageId,
+    type: "USERS",
+    from: { type: "admin" },
+    to: { type: "data-agent" },
+    payload: {
+      operation: "update",
+      data: {
+        username,
+        password
+      }
+    }
+  });
+  const response = await client.sendWithResponse(message, timeout);
+  const payload = response.payload;
+  return {
+    success: payload.success,
+    error: payload.error,
+    message: payload.data?.message,
+    username: payload.data?.username
+  };
+}
+async function deleteUser(client, username, timeout) {
+  const messageId = `users_delete_${Date.now()}`;
+  const message = UsersRequestMessageSchema.parse({
+    id: messageId,
+    type: "USERS",
+    from: { type: "admin" },
+    to: { type: "data-agent" },
+    payload: {
+      operation: "delete",
+      data: {
+        username
+      }
+    }
+  });
+  const response = await client.sendWithResponse(message, timeout);
+  const payload = response.payload;
+  return {
+    success: payload.success,
+    error: payload.error,
+    message: payload.data?.message,
+    username: payload.data?.username
+  };
+}
+async function getAllUsers(client, timeout) {
+  const messageId = `users_getall_${Date.now()}`;
+  const message = UsersRequestMessageSchema.parse({
+    id: messageId,
+    type: "USERS",
+    from: { type: "admin" },
+    to: { type: "data-agent" },
+    payload: {
+      operation: "getAll"
+    }
+  });
+  const response = await client.sendWithResponse(message, timeout);
+  const payload = response.payload;
+  return {
+    success: payload.success,
+    error: payload.error,
+    users: payload.data?.users,
+    count: payload.data?.count,
+    message: payload.data?.message
+  };
+}
+async function getUser(client, username, timeout) {
+  const messageId = `users_getone_${Date.now()}`;
+  const message = UsersRequestMessageSchema.parse({
+    id: messageId,
+    type: "USERS",
+    from: { type: "admin" },
+    to: { type: "data-agent" },
+    payload: {
+      operation: "getOne",
+      data: {
+        username
+      }
+    }
+  });
+  const response = await client.sendWithResponse(message, timeout);
+  const payload = response.payload;
+  return {
+    success: payload.success,
+    error: payload.error,
+    user: payload.data?.user,
+    message: payload.data?.message
+  };
+}
+
+// src/services/dashboards/index.ts
+async function createDashboard(client, dashboardId, dashboard, timeout) {
+  const messageId = `dashboards_create_${Date.now()}`;
+  const message = DashboardsRequestMessageSchema.parse({
+    id: messageId,
+    type: "DASHBOARDS",
+    from: { type: "admin" },
+    to: { type: "data-agent" },
+    payload: {
+      operation: "create",
+      data: {
+        dashboardId,
+        dashboard
+      }
+    }
+  });
+  const response = await client.sendWithResponse(message, timeout);
+  const payload = response.payload;
+  return {
+    success: payload.success,
+    error: payload.error,
+    message: payload.data?.message,
+    dashboardId: payload.data?.dashboardId,
+    dashboard: payload.data?.dashboard
+  };
+}
+async function updateDashboard(client, dashboardId, dashboard, timeout) {
+  const messageId = `dashboards_update_${Date.now()}`;
+  const message = DashboardsRequestMessageSchema.parse({
+    id: messageId,
+    type: "DASHBOARDS",
+    from: { type: "admin" },
+    to: { type: "data-agent" },
+    payload: {
+      operation: "update",
+      data: {
+        dashboardId,
+        dashboard
+      }
+    }
+  });
+  const response = await client.sendWithResponse(message, timeout);
+  const payload = response.payload;
+  return {
+    success: payload.success,
+    error: payload.error,
+    message: payload.data?.message,
+    dashboardId: payload.data?.dashboardId,
+    dashboard: payload.data?.dashboard
+  };
+}
+async function deleteDashboard(client, dashboardId, timeout) {
+  const messageId = `dashboards_delete_${Date.now()}`;
+  const message = DashboardsRequestMessageSchema.parse({
+    id: messageId,
+    type: "DASHBOARDS",
+    from: { type: "admin" },
+    to: { type: "data-agent" },
+    payload: {
+      operation: "delete",
+      data: {
+        dashboardId
+      }
+    }
+  });
+  const response = await client.sendWithResponse(message, timeout);
+  const payload = response.payload;
+  return {
+    success: payload.success,
+    error: payload.error,
+    message: payload.data?.message,
+    dashboardId: payload.data?.dashboardId
+  };
+}
+async function getAllDashboards(client, timeout) {
+  const messageId = `dashboards_getall_${Date.now()}`;
+  const message = DashboardsRequestMessageSchema.parse({
+    id: messageId,
+    type: "DASHBOARDS",
+    from: { type: "admin" },
+    to: { type: "data-agent" },
+    payload: {
+      operation: "getAll"
+    }
+  });
+  const response = await client.sendWithResponse(message, timeout);
+  const payload = response.payload;
+  return {
+    success: payload.success,
+    error: payload.error,
+    dashboards: payload.data?.dashboards,
+    count: payload.data?.count,
+    message: payload.data?.message
+  };
+}
+async function getDashboard(client, dashboardId, timeout) {
+  const messageId = `dashboards_getone_${Date.now()}`;
+  const message = DashboardsRequestMessageSchema.parse({
+    id: messageId,
+    type: "DASHBOARDS",
+    from: { type: "admin" },
+    to: { type: "data-agent" },
+    payload: {
+      operation: "getOne",
+      data: {
+        dashboardId
+      }
+    }
+  });
+  const response = await client.sendWithResponse(message, timeout);
+  const payload = response.payload;
+  return {
+    success: payload.success,
+    error: payload.error,
+    dashboardId: payload.data?.dashboardId,
+    dashboard: payload.data?.dashboard,
+    message: payload.data?.message
+  };
+}
+
+// src/services/reports/index.ts
+async function createReport(client, reportId, report, timeout) {
+  const messageId = `reports_create_${Date.now()}`;
+  const message = ReportsRequestMessageSchema.parse({
+    id: messageId,
+    type: "REPORTS",
+    from: { type: "admin" },
+    to: { type: "data-agent" },
+    payload: {
+      operation: "create",
+      data: {
+        reportId,
+        report
+      }
+    }
+  });
+  const response = await client.sendWithResponse(message, timeout);
+  const payload = response.payload;
+  return {
+    success: payload.success,
+    error: payload.error,
+    message: payload.data?.message,
+    reportId: payload.data?.reportId,
+    report: payload.data?.report
+  };
+}
+async function updateReport(client, reportId, report, timeout) {
+  const messageId = `reports_update_${Date.now()}`;
+  const message = ReportsRequestMessageSchema.parse({
+    id: messageId,
+    type: "REPORTS",
+    from: { type: "admin" },
+    to: { type: "data-agent" },
+    payload: {
+      operation: "update",
+      data: {
+        reportId,
+        report
+      }
+    }
+  });
+  const response = await client.sendWithResponse(message, timeout);
+  const payload = response.payload;
+  return {
+    success: payload.success,
+    error: payload.error,
+    message: payload.data?.message,
+    reportId: payload.data?.reportId,
+    report: payload.data?.report
+  };
+}
+async function deleteReport(client, reportId, timeout) {
+  const messageId = `reports_delete_${Date.now()}`;
+  const message = ReportsRequestMessageSchema.parse({
+    id: messageId,
+    type: "REPORTS",
+    from: { type: "admin" },
+    to: { type: "data-agent" },
+    payload: {
+      operation: "delete",
+      data: {
+        reportId
+      }
+    }
+  });
+  const response = await client.sendWithResponse(message, timeout);
+  const payload = response.payload;
+  return {
+    success: payload.success,
+    error: payload.error,
+    message: payload.data?.message,
+    reportId: payload.data?.reportId
+  };
+}
+async function getAllReports(client, timeout) {
+  const messageId = `reports_getall_${Date.now()}`;
+  const message = ReportsRequestMessageSchema.parse({
+    id: messageId,
+    type: "REPORTS",
+    from: { type: "admin" },
+    to: { type: "data-agent" },
+    payload: {
+      operation: "getAll"
+    }
+  });
+  const response = await client.sendWithResponse(message, timeout);
+  const payload = response.payload;
+  return {
+    success: payload.success,
+    error: payload.error,
+    reports: payload.data?.reports,
+    count: payload.data?.count,
+    message: payload.data?.message
+  };
+}
+async function getReport(client, reportId, timeout) {
+  const messageId = `reports_getone_${Date.now()}`;
+  const message = ReportsRequestMessageSchema.parse({
+    id: messageId,
+    type: "REPORTS",
+    from: { type: "admin" },
+    to: { type: "data-agent" },
+    payload: {
+      operation: "getOne",
+      data: {
+        reportId
+      }
+    }
+  });
+  const response = await client.sendWithResponse(message, timeout);
+  const payload = response.payload;
+  return {
+    success: payload.success,
+    error: payload.error,
+    reportId: payload.data?.reportId,
+    report: payload.data?.report,
+    message: payload.data?.message
+  };
+}
+
+// src/client.ts
+var SuperatomClient = class {
+  constructor(config) {
+    this.socket = null;
+    this.reconnectAttempts = 0;
+    this.reconnectTimer = null;
+    this.shouldReconnect = true;
+    this.messageHandlers = /* @__PURE__ */ new Set();
+    this.connectionHandlers = /* @__PURE__ */ new Set();
+    this.disconnectionHandlers = /* @__PURE__ */ new Set();
+    this.errorHandlers = /* @__PURE__ */ new Set();
+    this.connectPromise = null;
+    this.connectResolve = null;
+    const parsed = ClientConfigSchema.parse(config);
+    this.config = parsed;
+  }
+  /**
+   * Get WebSocket URL with query parameters
+   */
+  getWebSocketUrl() {
+    const params = new URLSearchParams({
+      userId: this.config.userId,
+      projectId: this.config.projectId,
+      type: this.config.type
+    });
+    return `${this.config.baseUrl}?${params.toString()}`;
+  }
+  /**
+   * Calculate reconnection delay with exponential backoff
+   */
+  calculateReconnectDelay() {
+    const delay = Math.min(
+      this.config.initialReconnectDelay * Math.pow(2, this.reconnectAttempts),
+      this.config.maxReconnectDelay
+    );
+    return delay + Math.random() * 1e3;
+  }
+  /**
+   * Schedule reconnection attempt
+   */
+  scheduleReconnect() {
+    if (!this.shouldReconnect) {
+      return;
+    }
+    if (this.reconnectAttempts >= this.config.maxReconnectAttempts) {
+      const error = new Error("Max reconnection attempts reached");
+      this.log("error", error.message);
+      this.errorHandlers.forEach((handler) => handler(error));
+      return;
+    }
+    const delay = this.calculateReconnectDelay();
+    this.log("info", `Scheduling reconnection attempt ${this.reconnectAttempts + 1} in ${delay}ms`);
+    this.reconnectTimer = setTimeout(() => {
+      this.reconnectAttempts++;
+      this.connect();
+    }, delay);
+  }
+  /**
+   * Setup WebSocket event handlers
+   */
+  setupSocketHandlers() {
+    if (!this.socket) {
+      return;
+    }
+    this.socket.onopen = () => {
+      this.log("info", "Connected to SuperAtom");
+      this.reconnectAttempts = 0;
+      if (this.connectResolve) {
+        this.connectResolve();
+        this.connectResolve = null;
+      }
+      this.connectionHandlers.forEach((handler) => handler());
+    };
+    this.socket.onmessage = (event) => {
+      try {
+        const parsed = JSON.parse(event.data);
+        const message = MessageSchema.parse(parsed);
+        this.messageHandlers.forEach((handler) => handler(message));
+      } catch (error) {
+        this.log("error", "Failed to parse message:", error);
+        const err = error instanceof Error ? error : new Error("Parse error");
+        this.errorHandlers.forEach((handler) => handler(err));
+      }
+    };
+    this.socket.onclose = (event) => {
+      this.log("info", "Disconnected from SuperAtom", {
+        code: event.code,
+        reason: event.reason,
+        wasClean: event.wasClean
+      });
+      this.disconnectionHandlers.forEach((handler) => handler());
+      if (this.shouldReconnect && !event.wasClean) {
+        this.scheduleReconnect();
+      }
+    };
+    this.socket.onerror = (error) => {
+      this.log("error", "WebSocket error:", error);
+      this.errorHandlers.forEach((handler) => handler(error));
+    };
+  }
+  /**
+   * Connect to SuperAtom WebSocket server
+   * Returns a Promise that resolves when the connection is established
+   * The Promise never rejects - failures are logged silently and auto-reconnect is triggered
+   */
+  connect() {
+    if (this.socket?.readyState === WebSocket.OPEN) {
+      this.log("warn", "Already connected");
+      return Promise.resolve();
+    }
+    if (this.socket?.readyState === WebSocket.CONNECTING && this.connectPromise) {
+      this.log("warn", "Connection already in progress");
+      return this.connectPromise;
+    }
+    this.connectPromise = new Promise((resolve) => {
+      this.connectResolve = resolve;
+    });
+    try {
+      this.socket = new WebSocket(this.getWebSocketUrl());
+      this.setupSocketHandlers();
+    } catch (error) {
+      this.log("error", "Failed to create WebSocket:", error);
+      const err = error instanceof Error ? error : new Error("Connection failed");
+      this.errorHandlers.forEach((handler) => handler(err));
+      this.scheduleReconnect();
+    }
+    return this.connectPromise;
+  }
+  /**
+   * Disconnect from WebSocket server
+   */
+  disconnect() {
+    this.shouldReconnect = false;
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+    if (this.socket) {
+      this.socket.close(1e3, "Client disconnect");
+      this.socket = null;
+    }
+    this.reconnectAttempts = 0;
+  }
+  /**
+   * Update client configuration
+   */
+  updateConfig(config) {
+    const merged = { ...this.config, ...config };
+    const parsed = ClientConfigSchema.parse(merged);
+    this.config = parsed;
+  }
+  /**
+   * Reconnect with new configuration
+   * Disconnects from existing connection and reconnects with updated config
+   * Returns a Promise that resolves when the new connection is established
+   */
+  reconnectWithConfig(config) {
+    this.updateConfig(config);
+    if (this.socket) {
+      this.disconnect();
+    }
+    this.shouldReconnect = true;
+    return this.connect();
+  }
+  /**
+   * Send a message to the server
+   */
+  send(message) {
+    if (!this.socket || this.socket.readyState !== WebSocket.OPEN) {
+      throw new Error("WebSocket is not connected");
+    }
+    const fullMessage = {
+      ...message,
+      from: message.from || { type: "runtime" }
+    };
+    try {
+      this.socket.send(JSON.stringify(fullMessage));
+    } catch (error) {
+      this.log("error", "Failed to send message:", error);
+      throw error;
+    }
+  }
+  /**
+   * Send a message and wait for a response with the same ID
+   * Uses closure-based approach - no global state management needed
+   */
+  async sendWithResponse(message, timeout) {
+    const messageId = message.id || `msg_${Date.now()}_${Math.random().toString(36).substring(7)}`;
+    const messageWithId = { ...message, id: messageId };
+    const timeoutMs = timeout ?? this.config.defaultTimeout;
+    this.send(messageWithId);
+    return new Promise((resolve, reject) => {
+      let isResolved = false;
+      const responseHandler = (msg) => {
+        if (msg.id === messageId && !isResolved) {
+          isResolved = true;
+          clearTimeout(timer);
+          unsubscribe();
+          resolve(msg);
+        }
+      };
+      const unsubscribe = this.onMessage(responseHandler);
+      const timer = setTimeout(() => {
+        if (!isResolved) {
+          isResolved = true;
+          unsubscribe();
+          reject(new Error(`Request timeout after ${timeoutMs}ms`));
+        }
+      }, timeoutMs);
+    });
+  }
+  /**
+   * Register message handler
+   */
+  onMessage(handler) {
+    this.messageHandlers.add(handler);
+    return () => this.messageHandlers.delete(handler);
+  }
+  /**
+   * Register connection handler
+   */
+  onConnect(handler) {
+    this.connectionHandlers.add(handler);
+    return () => this.connectionHandlers.delete(handler);
+  }
+  /**
+   * Register disconnection handler
+   */
+  onDisconnect(handler) {
+    this.disconnectionHandlers.add(handler);
+    return () => this.disconnectionHandlers.delete(handler);
+  }
+  /**
+   * Register error handler
+   */
+  onError(handler) {
+    this.errorHandlers.add(handler);
+    return () => this.errorHandlers.delete(handler);
+  }
+  /**
+   * Check if client is connected
+   */
+  isConnected() {
+    return this.socket?.readyState === WebSocket.OPEN;
+  }
+  /**
+   * Get current reconnection attempts
+   */
+  getReconnectAttempts() {
+    return this.reconnectAttempts;
+  }
+  /**
+   * Send a message and wait for response with timeout (alias for sendWithResponse)
+   */
+  async ask(message, options) {
+    return this.sendWithResponse(message, options?.timeout);
+  }
+  // ==================== Service Methods ====================
+  // These methods delegate to service functions for better code organization
+  /**
+   * Send authentication login request
+   * Delegates to auth service
+   */
+  async sendAuthLoginRequest(loginDataBase64, timeout) {
+    this.log("info", "Sending auth login request");
+    return sendAuthLoginRequest(this, loginDataBase64, timeout);
+  }
+  /**
+   * Send authentication verify request
+   * Delegates to auth service
+   */
+  async sendAuthVerifyRequest(token, timeout) {
+    this.log("info", "Sending auth verify request");
+    return sendAuthVerifyRequest(this, token, timeout);
+  }
+  /**
+   * Send a user prompt request
+   * Delegates to user prompt service
+   */
+  async sendUserPromptRequest(prompt, threadId, uiBlockId, timeout) {
+    this.log("info", "Sending user prompt request");
+    return sendUserPromptRequest(this, prompt, threadId, uiBlockId, timeout);
+  }
+  /**
+   * Send a user prompt suggestions request
+   * Delegates to user prompt service
+   */
+  async sendUserPromptSuggestionsRequest(prompt, limit = 5, timeout) {
+    this.log("info", "Sending user prompt suggestions request");
+    return sendUserPromptSuggestionsRequest(this, prompt, limit, timeout);
+  }
+  /**
+   * Request bundle from server
+   * Delegates to bundle service
+   */
+  async requestBundle(options) {
+    this.log("info", "Requesting bundle from server");
+    return requestBundle(this, options);
+  }
+  /**
+   * Request data from a collection
+   * Delegates to data service
+   */
+  async requestData(options) {
+    this.log("info", `Requesting data from collection: ${options.collection}, operation: ${options.operation}`);
+    return requestData(this, options);
+  }
+  /**
+   * Get AI-powered component suggestions based on a query
+   * Delegates to component service
+   */
+  async getComponentSuggestions(query, options) {
+    this.log("info", "Requesting component suggestions for query:", query);
+    return getComponentSuggestions(this, query, options);
+  }
+  // ==================== User Management Methods ====================
+  // These methods delegate to user service for admin user CRUD operations
+  /**
+   * Create a new user
+   * Delegates to users service
+   */
+  async createUser(username, password, timeout) {
+    this.log("info", "Creating user:", username);
+    return createUser(this, username, password, timeout);
+  }
+  /**
+   * Update an existing user
+   * Delegates to users service
+   */
+  async updateUser(username, password, timeout) {
+    this.log("info", "Updating user:", username);
+    return updateUser(this, username, password, timeout);
+  }
+  /**
+   * Delete a user
+   * Delegates to users service
+   */
+  async deleteUser(username, timeout) {
+    this.log("info", "Deleting user:", username);
+    return deleteUser(this, username, timeout);
+  }
+  /**
+   * Get all users
+   * Delegates to users service
+   */
+  async getAllUsers(timeout) {
+    this.log("info", "Fetching all users");
+    return getAllUsers(this, timeout);
+  }
+  /**
+   * Get a specific user by username
+   * Delegates to users service
+   */
+  async getUser(username, timeout) {
+    this.log("info", "Fetching user:", username);
+    return getUser(this, username, timeout);
+  }
+  // ==================== Dashboard Management Methods ====================
+  // These methods delegate to dashboard service for admin dashboard CRUD operations
+  /**
+   * Create a new dashboard
+   * Delegates to dashboards service
+   */
+  async createDashboard(dashboardId, dashboard, timeout) {
+    this.log("info", "Creating dashboard:", dashboardId);
+    return createDashboard(this, dashboardId, dashboard, timeout);
+  }
+  /**
+   * Update an existing dashboard
+   * Delegates to dashboards service
+   */
+  async updateDashboard(dashboardId, dashboard, timeout) {
+    this.log("info", "Updating dashboard:", dashboardId);
+    return updateDashboard(this, dashboardId, dashboard, timeout);
+  }
+  /**
+   * Delete a dashboard
+   * Delegates to dashboards service
+   */
+  async deleteDashboard(dashboardId, timeout) {
+    this.log("info", "Deleting dashboard:", dashboardId);
+    return deleteDashboard(this, dashboardId, timeout);
+  }
+  /**
+   * Get all dashboards
+   * Delegates to dashboards service
+   */
+  async getAllDashboards(timeout) {
+    this.log("info", "Fetching all dashboards");
+    return getAllDashboards(this, timeout);
+  }
+  /**
+   * Get a specific dashboard by ID
+   * Delegates to dashboards service
+   */
+  async getDashboard(dashboardId, timeout) {
+    this.log("info", "Fetching dashboard:", dashboardId);
+    return getDashboard(this, dashboardId, timeout);
+  }
+  // ==================== Report Management Methods ====================
+  // These methods delegate to report service for admin report CRUD operations
+  /**
+   * Create a new report
+   * Delegates to reports service
+   */
+  async createReport(reportId, report, timeout) {
+    this.log("info", "Creating report:", reportId);
+    return createReport(this, reportId, report, timeout);
+  }
+  /**
+   * Update an existing report
+   * Delegates to reports service
+   */
+  async updateReport(reportId, report, timeout) {
+    this.log("info", "Updating report:", reportId);
+    return updateReport(this, reportId, report, timeout);
+  }
+  /**
+   * Delete a report
+   * Delegates to reports service
+   */
+  async deleteReport(reportId, timeout) {
+    this.log("info", "Deleting report:", reportId);
+    return deleteReport(this, reportId, timeout);
+  }
+  /**
+   * Get all reports
+   * Delegates to reports service
+   */
+  async getAllReports(timeout) {
+    this.log("info", "Fetching all reports");
+    return getAllReports(this, timeout);
+  }
+  /**
+   * Get a specific report by ID
+   * Delegates to reports service
+   */
+  async getReport(reportId, timeout) {
+    this.log("info", "Fetching report:", reportId);
+    return getReport(this, reportId, timeout);
+  }
+  /**
+   * Internal logging
+   */
+  log(level, ...args) {
+    if (!this.config.debug && level === "debug") {
+      return;
+    }
+    console[level]("[SuperAtom]", ...args);
+  }
+};
+
+// src/setup.ts
+function setup(components) {
+  if (typeof window === "undefined") {
+    throw new Error("setup() can only be called in a browser environment");
+  }
+  window.SUPERATOM = window.SUPERATOM || {};
+  window.SA = window.SUPERATOM;
+  window.SUPERATOM.COMPONENTS = components;
+  if (window.SUPERATOM.runtime?.componentsLoaded) {
+    window.SUPERATOM.runtime.componentsLoaded();
+  }
+}
+function getComponents() {
+  if (typeof window === "undefined") {
+    return void 0;
+  }
+  return window.SUPERATOM?.COMPONENTS;
+}
+function getComponent(name) {
+  if (typeof window === "undefined") {
+    return void 0;
+  }
+  return window.SUPERATOM?.COMPONENTS?.[name];
+}
+function hasComponents() {
+  if (typeof window === "undefined") {
+    return false;
+  }
+  return !!window.SUPERATOM?.COMPONENTS;
+}
+
+// src/index.ts
+var SDK_VERSION = "0.1.0";
+
+exports.AuthLoginPayloadSchema = AuthLoginPayloadSchema;
+exports.AuthLoginRequestMessageSchema = AuthLoginRequestMessageSchema;
+exports.AuthLoginResponseMessageSchema = AuthLoginResponseMessageSchema;
+exports.AuthLoginResponsePayloadSchema = AuthLoginResponsePayloadSchema;
+exports.AuthVerifyPayloadSchema = AuthVerifyPayloadSchema;
+exports.AuthVerifyRequestMessageSchema = AuthVerifyRequestMessageSchema;
+exports.AuthVerifyResponseMessageSchema = AuthVerifyResponseMessageSchema;
+exports.AuthVerifyResponsePayloadSchema = AuthVerifyResponsePayloadSchema;
+exports.BundleChunkMessageSchema = BundleChunkMessageSchema;
+exports.BundleChunkPayloadSchema = BundleChunkPayloadSchema;
+exports.BundleErrorMessageSchema = BundleErrorMessageSchema;
+exports.BundleErrorPayloadSchema = BundleErrorPayloadSchema;
+exports.BundleRequestMessageSchema = BundleRequestMessageSchema;
+exports.BundleRequestPayloadSchema = BundleRequestPayloadSchema;
+exports.ClientConfigSchema = ClientConfigSchema;
+exports.ComponentSchema = ComponentSchema;
+exports.DataRequestMessageSchema = DataRequestMessageSchema;
+exports.DataRequestPayloadSchema = DataRequestPayloadSchema;
+exports.DataResponseMessageSchema = DataResponseMessageSchema;
+exports.DataResponsePayloadSchema = DataResponsePayloadSchema;
+exports.MessageParticipantSchema = MessageParticipantSchema;
+exports.MessageSchema = MessageSchema;
+exports.SDK_VERSION = SDK_VERSION;
+exports.SuperatomClient = SuperatomClient;
+exports.UILogEntrySchema = UILogEntrySchema;
+exports.UILogsMessageSchema = UILogsMessageSchema;
+exports.UILogsPayloadSchema = UILogsPayloadSchema;
+exports.UserPromptRequestMessageSchema = UserPromptRequestMessageSchema;
+exports.UserPromptRequestPayloadSchema = UserPromptRequestPayloadSchema;
+exports.UserPromptResponseMessageSchema = UserPromptResponseMessageSchema;
+exports.UserPromptResponsePayloadSchema = UserPromptResponsePayloadSchema;
+exports.UserPromptSuggestionsRequestMessageSchema = UserPromptSuggestionsRequestMessageSchema;
+exports.UserPromptSuggestionsRequestPayloadSchema = UserPromptSuggestionsRequestPayloadSchema;
+exports.UserPromptSuggestionsResponseMessageSchema = UserPromptSuggestionsResponseMessageSchema;
+exports.UserPromptSuggestionsResponsePayloadSchema = UserPromptSuggestionsResponsePayloadSchema;
+exports.getComponent = getComponent;
+exports.getComponents = getComponents;
+exports.hasComponents = hasComponents;
+exports.services = services_exports;
+exports.setup = setup;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map