@raisindb/client 0.2.3 → 0.2.5

package/dist/index.mjs

@@ -1,366 +1,57 @@
-var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
-  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
-}) : x)(function(x) {
-  if (typeof require !== "undefined") return require.apply(this, arguments);
-  throw Error('Dynamic require of "' + x + '" is not supported');
-});
+import {
+  createRaisinReact,
+  useConversation,
+  useConversationList,
+  useFlow
+} from "./chunk-QJKYNLT4.mjs";
+import {
+  RAISIN_CONTEXT_KEY,
+  createConversationAdapter,
+  createConversationListAdapter,
+  createFlowAdapter
+} from "./chunk-P44XWTPA.mjs";
+import {
+  FlowClient,
+  RaisinAbortError,
+  RaisinAuthError,
+  RaisinConnectionError,
+  RaisinError,
+  RaisinFlowError,
+  RaisinTimeoutError,
+  SSEClient,
+  classifyHttpError
+} from "./chunk-Q4IBPW2W.mjs";
+import {
+  createRaisinVue
+} from "./chunk-B6EFDYFS.mjs";
+import {
+  createAuthAdapter,
+  createConnectionAdapter,
+  createSqlAdapter,
+  createSubscriptionAdapter
+} from "./chunk-T2ZSNYFG.mjs";
+import {
+  Connection,
+  ConnectionState,
+  ConversationListStore,
+  ConversationStore,
+  LogLevel,
+  ReconnectManager,
+  __privateAdd,
+  __privateGet,
+  __privateSet,
+  configureLogger,
+  getLogLevel,
+  getLoggerConfig,
+  isRecoveredDoneEvent,
+  logger,
+  normalizeHomePath,
+  projectPlansFromMessages,
+  setLogLevel
+} from "./chunk-3KMOXRTK.mjs";
 
 // src/client.ts
-import { EventEmitter as EventEmitter3 } from "events";
-
-// src/connection.ts
-import { EventEmitter } from "events";
-
-// src/utils/reconnect.ts
-var ReconnectManager = class {
-  constructor(options = {}) {
-    this.attempts = 0;
-    this.isReconnecting = false;
-    this.initialDelay = options.initialDelay ?? 1e3;
-    this.maxDelay = options.maxDelay ?? 3e4;
-    this.backoffMultiplier = options.backoffMultiplier ?? 2;
-    this.maxAttempts = options.maxAttempts ?? Infinity;
-    this.jitter = options.jitter ?? true;
-    this.currentDelay = this.initialDelay;
-  }
-  /**
-   * Schedule a reconnection attempt
-   *
-   * @param callback - Function to call when it's time to reconnect
-   * @returns true if reconnection was scheduled, false if max attempts reached
-   */
-  scheduleReconnect(callback) {
-    if (this.attempts >= this.maxAttempts) {
-      return false;
-    }
-    this.cancelReconnect();
-    this.isReconnecting = true;
-    this.attempts++;
-    let delay = this.currentDelay;
-    if (this.jitter) {
-      const jitterRange = delay * 0.25;
-      delay += (Math.random() * 2 - 1) * jitterRange;
-      delay = Math.max(0, Math.round(delay));
-    }
-    this.reconnectTimeout = setTimeout(async () => {
-      try {
-        await callback();
-        this.reset();
-      } catch (error) {
-        this.currentDelay = Math.min(
-          this.currentDelay * this.backoffMultiplier,
-          this.maxDelay
-        );
-      }
-    }, delay);
-    return true;
-  }
-  /**
-   * Cancel any pending reconnection attempt
-   */
-  cancelReconnect() {
-    if (this.reconnectTimeout) {
-      clearTimeout(this.reconnectTimeout);
-      this.reconnectTimeout = void 0;
-    }
-    this.isReconnecting = false;
-  }
-  /**
-   * Reset the reconnection state (call after successful connection)
-   */
-  reset() {
-    this.cancelReconnect();
-    this.currentDelay = this.initialDelay;
-    this.attempts = 0;
-  }
-  /**
-   * Check if currently in reconnection mode
-   */
-  isActive() {
-    return this.isReconnecting;
-  }
-  /**
-   * Get the current number of reconnection attempts
-   */
-  getAttempts() {
-    return this.attempts;
-  }
-  /**
-   * Get the current delay in milliseconds
-   */
-  getCurrentDelay() {
-    return this.currentDelay;
-  }
-  /**
-   * Check if max attempts have been reached
-   */
-  hasReachedMaxAttempts() {
-    return this.attempts >= this.maxAttempts;
-  }
-};
-
-// src/logger.ts
-var LogLevel = /* @__PURE__ */ ((LogLevel3) => {
-  LogLevel3[LogLevel3["Silent"] = 0] = "Silent";
-  LogLevel3[LogLevel3["Error"] = 1] = "Error";
-  LogLevel3[LogLevel3["Warn"] = 2] = "Warn";
-  LogLevel3[LogLevel3["Info"] = 3] = "Info";
-  LogLevel3[LogLevel3["Debug"] = 4] = "Debug";
-  return LogLevel3;
-})(LogLevel || {});
-var config = {
-  level: 1 /* Error */,
-  prefix: "[RaisinDB]"
-};
-function configureLogger(options) {
-  config = { ...config, ...options };
-}
-function getLoggerConfig() {
-  return { ...config };
-}
-function setLogLevel(level) {
-  config.level = level;
-}
-function getLogLevel() {
-  return config.level;
-}
-var logger = {
-  /**
-   * Log debug message (only shown when level >= Debug)
-   */
-  debug(...args) {
-    if (config.level >= 4 /* Debug */) {
-      console.log(config.prefix, ...args);
-    }
-  },
-  /**
-   * Log info message (only shown when level >= Info)
-   */
-  info(...args) {
-    if (config.level >= 3 /* Info */) {
-      console.log(config.prefix, ...args);
-    }
-  },
-  /**
-   * Log warning message (only shown when level >= Warn)
-   */
-  warn(...args) {
-    if (config.level >= 2 /* Warn */) {
-      console.warn(config.prefix, ...args);
-    }
-  },
-  /**
-   * Log error message (only shown when level >= Error)
-   */
-  error(...args) {
-    if (config.level >= 1 /* Error */) {
-      console.error(config.prefix, ...args);
-    }
-  }
-};
-if (typeof globalThis !== "undefined") {
-  globalThis.__raisinDebug = (enable = true) => {
-    setLogLevel(enable ? 4 /* Debug */ : 1 /* Error */);
-    console.log(`[RaisinDB] Debug logging ${enable ? "ENABLED" : "DISABLED"} (includes server handler logs)`);
-  };
-}
-
-// src/connection.ts
-var ConnectionState = /* @__PURE__ */ ((ConnectionState2) => {
-  ConnectionState2["Disconnected"] = "disconnected";
-  ConnectionState2["Connecting"] = "connecting";
-  ConnectionState2["Connected"] = "connected";
-  ConnectionState2["Reconnecting"] = "reconnecting";
-  ConnectionState2["Closed"] = "closed";
-  return ConnectionState2;
-})(ConnectionState || {});
-function getWebSocketImpl() {
-  if (typeof WebSocket !== "undefined") {
-    return WebSocket;
-  }
-  try {
-    const ws = __require("ws");
-    return ws.WebSocket || ws.default || ws;
-  } catch (error) {
-    throw new Error(
-      'WebSocket implementation not found. In Node.js, please install the "ws" package: npm install ws'
-    );
-  }
-}
-var Connection = class extends EventEmitter {
-  constructor(url, options = {}) {
-    super();
-    this.state = "disconnected" /* Disconnected */;
-    this.manualClose = false;
-    this.url = url.replace(/^raisin:\/\//, "ws://").replace(/^raisins:\/\//, "wss://");
-    this.options = {
-      autoReconnect: options.autoReconnect ?? true,
-      heartbeatInterval: options.heartbeatInterval ?? 3e4,
-      heartbeatTimeout: options.heartbeatTimeout ?? 5e3,
-      protocols: options.protocols
-    };
-    this.reconnectManager = new ReconnectManager(options.reconnectOptions);
-    this.WebSocketImpl = getWebSocketImpl();
-  }
-  /**
-   * Connect to the WebSocket server
-   */
-  async connect() {
-    if (this.state === "connected" /* Connected */ || this.state === "connecting" /* Connecting */) {
-      return;
-    }
-    this.manualClose = false;
-    this.setState("connecting" /* Connecting */);
-    return new Promise((resolve, reject) => {
-      try {
-        this.ws = new this.WebSocketImpl(
-          this.url,
-          this.options.protocols
-        );
-        this.ws.binaryType = "arraybuffer";
-        this.ws.onopen = () => {
-          this.setState("connected" /* Connected */);
-          this.reconnectManager.reset();
-          this.startHeartbeat();
-          resolve();
-        };
-        this.ws.onmessage = (event) => {
-          logger.debug(`WebSocket onmessage fired - data type: ${typeof event.data}, is ArrayBuffer: ${event.data instanceof ArrayBuffer}`);
-          this.resetHeartbeat();
-          const data = event.data;
-          logger.debug(`Received binary message - size: ${data.byteLength} bytes`);
-          logger.debug(`Emitting 'message' event to client handlers`);
-          this.emit("message", data);
-        };
-        this.ws.onerror = () => {
-          const error = new Error("WebSocket error occurred");
-          this.emit("error", error);
-          if (this.state === "connecting" /* Connecting */) {
-            reject(error);
-          }
-        };
-        this.ws.onclose = (event) => {
-          this.stopHeartbeat();
-          this.emit("close", event);
-          if (!this.manualClose && this.options.autoReconnect) {
-            this.setState("reconnecting" /* Reconnecting */);
-            this.reconnect();
-          } else {
-            this.setState("disconnected" /* Disconnected */);
-          }
-          if (this.state === "connecting" /* Connecting */) {
-            reject(new Error(`Connection closed: ${event.reason || "Unknown reason"}`));
-          }
-        };
-      } catch (error) {
-        this.setState("disconnected" /* Disconnected */);
-        reject(error);
-      }
-    });
-  }
-  /**
-   * Disconnect from the WebSocket server
-   */
-  disconnect() {
-    this.manualClose = true;
-    this.reconnectManager.cancelReconnect();
-    this.stopHeartbeat();
-    if (this.ws) {
-      this.ws.close(1e3, "Client disconnect");
-      this.ws = void 0;
-    }
-    this.setState("closed" /* Closed */);
-  }
-  /**
-   * Send data through the WebSocket
-   *
-   * @param data - Data to send (Uint8Array for MessagePack)
-   */
-  send(data) {
-    if (this.state !== "connected" /* Connected */ || !this.ws) {
-      throw new Error("Cannot send data: not connected");
-    }
-    if (this.ws.readyState !== 1) {
-      logger.error(`WebSocket not open - readyState: ${this.ws.readyState} (0=CONNECTING, 1=OPEN, 2=CLOSING, 3=CLOSED)`);
-      throw new Error(`Cannot send data: WebSocket not open (readyState: ${this.ws.readyState})`);
-    }
-    logger.debug(`Sending message - size: ${data.length} bytes, readyState: ${this.ws.readyState}`);
-    try {
-      this.ws.send(data);
-      logger.debug(`Message sent successfully`);
-    } catch (error) {
-      logger.error(`Failed to send message:`, error);
-      throw new Error(`Failed to send data: ${error}`);
-    }
-  }
-  /**
-   * Get current connection state
-   */
-  getState() {
-    return this.state;
-  }
-  /**
-   * Check if connected
-   */
-  isConnected() {
-    return this.state === "connected" /* Connected */;
-  }
-  /**
-   * Reconnect to the server
-   */
-  reconnect() {
-    const success = this.reconnectManager.scheduleReconnect(async () => {
-      try {
-        await this.connect();
-      } catch (error) {
-      }
-    });
-    if (!success) {
-      this.setState("disconnected" /* Disconnected */);
-      this.emit("error", new Error("Max reconnection attempts reached"));
-    }
-  }
-  /**
-   * Set connection state and emit event
-   */
-  setState(state) {
-    if (this.state !== state) {
-      this.state = state;
-      this.emit("stateChange", state);
-    }
-  }
-  /**
-   * Start heartbeat mechanism
-   */
-  startHeartbeat() {
-    if (this.options.heartbeatInterval <= 0) {
-      return;
-    }
-    this.stopHeartbeat();
-  }
-  /**
-   * Stop heartbeat mechanism
-   */
-  stopHeartbeat() {
-    if (this.heartbeatTimer) {
-      clearInterval(this.heartbeatTimer);
-      this.heartbeatTimer = void 0;
-    }
-    if (this.heartbeatTimeoutTimer) {
-      clearTimeout(this.heartbeatTimeoutTimer);
-      this.heartbeatTimeoutTimer = void 0;
-    }
-  }
-  /**
-   * Reset heartbeat timeout (called when message received)
-   */
-  resetHeartbeat() {
-    if (this.heartbeatTimeoutTimer) {
-      clearTimeout(this.heartbeatTimeoutTimer);
-      this.heartbeatTimeoutTimer = void 0;
-    }
-  }
-};
+import { EventEmitter as EventEmitter2 } from "events";
 
 // src/utils/request-tracker.ts
 import { v4 as uuidv4 } from "uuid";
@@ -702,6 +393,7 @@ var RequestType = /* @__PURE__ */ ((RequestType2) => {
   RequestType2["NodeReorder"] = "node_reorder";
   RequestType2["NodeMoveChildBefore"] = "node_move_child_before";
   RequestType2["NodeMoveChildAfter"] = "node_move_child_after";
+  RequestType2["NodeApplyChildOrder"] = "node_apply_child_order";
   RequestType2["PropertyGet"] = "property_get";
   RequestType2["PropertyUpdate"] = "property_update";
   RequestType2["RelationAdd"] = "relation_add";
@@ -721,6 +413,8 @@ var RequestType = /* @__PURE__ */ ((RequestType2) => {
   RequestType2["BranchUpdateHead"] = "branch_update_head";
   RequestType2["BranchMerge"] = "branch_merge";
   RequestType2["BranchCompare"] = "branch_compare";
+  RequestType2["BranchDiff"] = "branch_diff";
+  RequestType2["BranchCopyNodes"] = "branch_copy_nodes";
   RequestType2["TagCreate"] = "tag_create";
   RequestType2["TagGet"] = "tag_get";
   RequestType2["TagList"] = "tag_list";
@@ -741,6 +435,7 @@ var RequestType = /* @__PURE__ */ ((RequestType2) => {
   RequestType2["ArchetypeDelete"] = "archetype_delete";
   RequestType2["ArchetypePublish"] = "archetype_publish";
   RequestType2["ArchetypeUnpublish"] = "archetype_unpublish";
+  RequestType2["ArchetypeGetResolved"] = "archetype_get_resolved";
   RequestType2["ElementTypeCreate"] = "element_type_create";
   RequestType2["ElementTypeGet"] = "element_type_get";
   RequestType2["ElementTypeList"] = "element_type_list";
@@ -748,6 +443,7 @@ var RequestType = /* @__PURE__ */ ((RequestType2) => {
   RequestType2["ElementTypeDelete"] = "element_type_delete";
   RequestType2["ElementTypePublish"] = "element_type_publish";
   RequestType2["ElementTypeUnpublish"] = "element_type_unpublish";
+  RequestType2["ElementTypeGetResolved"] = "element_type_get_resolved";
   RequestType2["FullTextSearch"] = "full_text_search";
   RequestType2["VectorSearch"] = "vector_search";
   RequestType2["Subscribe"] = "subscribe";
@@ -772,6 +468,10 @@ var RequestType = /* @__PURE__ */ ((RequestType2) => {
   RequestType2["FlowUnsubscribeEvents"] = "flow_unsubscribe_events";
   RequestType2["FunctionInvoke"] = "function_invoke";
   RequestType2["FunctionInvokeSync"] = "function_invoke_sync";
+  RequestType2["ScheduledInvocationCreate"] = "scheduled_invocation_create";
+  RequestType2["ScheduledInvocationCancel"] = "scheduled_invocation_cancel";
+  RequestType2["ScheduledInvocationList"] = "scheduled_invocation_list";
+  RequestType2["ScheduledInvocationGet"] = "scheduled_invocation_get";
   return RequestType2;
 })(RequestType || {});
 var ResponseStatus = /* @__PURE__ */ ((ResponseStatus2) => {
@@ -881,6 +581,14 @@ var EventHandler = class {
    * If a subscription with identical filters already exists, the callback
    * is added to the existing subscription instead of creating a new one.
    *
+   * Path filter semantics (matched server-side):
+   * - A plain path matches **only that exact node** — there is no implicit
+   *   prefix matching.
+   * - `*` matches exactly one path segment (e.g. `/inbox/*` matches
+   *   `/inbox/a` but not `/inbox/a/b`).
+   * - `**` matches recursively (e.g. `/inbox/**` matches all descendants
+   *   of `/inbox`, but not `/inbox` itself).
+   *
    * @param filters - Event filters
    * @param callback - Callback function for events
    * @returns Subscription object
@@ -1071,14 +779,29 @@ var EventHandler = class {
    * Restore subscriptions after reconnect
    *
    * Re-subscribes to the server with the original filters for all active
-   * subscription entries.
+   * subscription entries. Failed entries are kept (with their callbacks)
+   * and marked pending so a retry call can re-attempt them without
+   * duplicating already-restored subscriptions.
+   *
+   * @param options.retry - When true, only re-attempts entries that failed
+   *   in a previous call (instead of re-subscribing everything)
+   * @throws Error if any subscription could not be restored
    */
-  async restoreSubscriptions() {
-    const entriesToRestore = Array.from(this.filterSubscriptions.entries());
-    this.subscriptions.clear();
-    this.filterSubscriptions.clear();
+  async restoreSubscriptions(options) {
+    if (!options?.retry) {
+      for (const entry of this.filterSubscriptions.values()) {
+        this.subscriptions.delete(entry.serverId);
+        entry.restorePending = true;
+      }
+    }
+    const entriesToRestore = Array.from(this.filterSubscriptions.entries()).filter(([, entry]) => entry.restorePending);
+    let failureCount = 0;
+    let lastError;
     for (const [hash, entry] of entriesToRestore) {
-      if (entry.callbacks.size === 0) continue;
+      if (entry.callbacks.size === 0) {
+        entry.restorePending = false;
+        continue;
+      }
       try {
         const payload = { filters: entry.filters };
         const response = await this.sendRequest(
@@ -1086,22 +809,24 @@ var EventHandler = class {
           "subscribe" /* Subscribe */
         );
         const newServerId = response.subscription_id;
-        this.filterSubscriptions.set(hash, {
-          serverId: newServerId,
-          filters: entry.filters,
-          callbacks: entry.callbacks
-        });
+        entry.serverId = newServerId;
+        entry.restorePending = false;
         this.subscriptions.set(newServerId, hash);
         for (const callback of entry.callbacks) {
           this.callbackToHash.set(callback, hash);
         }
       } catch (error) {
         logger.error("Failed to restore subscription:", error);
-        for (const callback of entry.callbacks) {
-          this.callbackToHash.delete(callback);
-        }
+        failureCount++;
+        lastError = error;
       }
     }
+    if (failureCount > 0) {
+      const message = lastError instanceof Error ? lastError.message : String(lastError);
+      throw new Error(
+        `Failed to restore ${failureCount} subscription(s) after reconnect: ${message}`
+      );
+    }
   }
 };
 var EventSubscriptions = class {
@@ -1136,7 +861,15 @@ var EventSubscriptions = class {
   /**
    * Subscribe to events for a specific path
    *
-   * @param path - Path pattern (supports wildcards like "/folder/*")
+   * Path pattern semantics (matched server-side):
+   * - A plain path matches **only that exact node** — there is no implicit
+   *   prefix matching, so `/folder` does NOT match `/folder/child`.
+   * - `*` matches exactly one path segment: `/folder/*` matches
+   *   `/folder/child` but not `/folder/child/grandchild`.
+   * - `**` matches recursively: `/folder/**` matches every descendant of
+   *   `/folder` (but not `/folder` itself).
+   *
+   * @param path - Path pattern (e.g. "/folder", "/folder/*", "/folder/**")
    * @param callback - Callback function for events
    * @param options - Optional subscription options
    * @param options.includeNode - Include full node data in event payload (default: false)
@@ -1183,6 +916,40 @@ var NodeOperations = class {
     const result = await this.sendRequest(payload);
     return result;
   }
+  /**
+   * Create a node, auto-creating any missing ancestor folders.
+   *
+   * @param options - Node creation options (with optional `parentNodeType`)
+   * @returns Created node
+   */
+  async createDeep(options) {
+    const payload = {
+      node_type: options.type,
+      path: options.path,
+      properties: options.properties ?? {},
+      content: options.content,
+      parent_node_type: options.parentNodeType
+    };
+    const result = await this.sendRequest(payload, "node_create_deep");
+    return result;
+  }
+  /**
+   * Upsert a node by path (create-or-update), auto-creating any missing ancestor folders.
+   *
+   * @param options - Node creation options (with optional `parentNodeType`)
+   * @returns Upserted node
+   */
+  async upsertDeep(options) {
+    const payload = {
+      node_type: options.type,
+      path: options.path,
+      properties: options.properties ?? {},
+      content: options.content,
+      parent_node_type: options.parentNodeType
+    };
+    const result = await this.sendRequest(payload, "node_upsert_deep");
+    return result;
+  }
   /**
    * Update an existing node
    *
@@ -1232,6 +999,75 @@ var NodeOperations = class {
       throw error;
     }
   }
+  /**
+   * List a node's revision history (git-style "file history"), newest first.
+   *
+   * Each entry carries the `revision` (usable with `atRevision()` reads to
+   * fetch the full snapshot), plus when/who and whether the node was deleted
+   * at that revision. Always available regardless of the NodeType `auditable`
+   * flag — it reflects the structural MVCC version history.
+   *
+   * @param id - Node ID
+   * @param options - Optional `{ limit }` to cap the number of revisions
+   * @returns Array of revision entries (newest first)
+   *
+   * @example
+   * ```typescript
+   * const history = await ws.nodes().history(nodeId, { limit: 50 });
+   * for (const rev of history) {
+   *   const snapshot = await ws.atRevision(rev.revision).nodes().get(nodeId);
+   * }
+   * ```
+   */
+  async history(id, options) {
+    const payload = {
+      node_id: id,
+      limit: options?.limit
+    };
+    const result = await this.sendRequest(payload, "node_history");
+    return result ?? [];
+  }
+  /**
+   * List a node's revision history by path (newest first).
+   *
+   * @param path - Node path
+   * @param options - Optional `{ limit }` to cap the number of revisions
+   * @returns Array of revision entries (newest first)
+   */
+  async historyByPath(path, options) {
+    const payload = {
+      path,
+      limit: options?.limit
+    };
+    const result = await this.sendRequest(payload, "node_history");
+    return result ?? [];
+  }
+  /**
+   * Query a node's audit-log entries by ID.
+   *
+   * Audit logs are only produced for NodeTypes marked `auditable`. This is
+   * distinct from {@link history}, which is the always-on structural revision
+   * history available for every node.
+   *
+   * @param id - Node ID
+   * @returns Array of audit-log entries
+   */
+  async auditLog(id) {
+    const payload = { node_id: id };
+    const result = await this.sendRequest(payload, "audit_query");
+    return result ?? [];
+  }
+  /**
+   * Query a node's audit-log entries by path.
+   *
+   * @param path - Node path
+   * @returns Array of audit-log entries
+   */
+  async auditLogByPath(path) {
+    const payload = { path };
+    const result = await this.sendRequest(payload, "audit_query");
+    return result ?? [];
+  }
   /**
    * Query nodes
    *
@@ -1399,7 +1235,7 @@ var NodeOperations = class {
    */
   async rename(nodePath, newName) {
     const payload = {
-      node_path: nodePath,
+      old_path: nodePath,
       new_name: newName
     };
     const result = await this.sendRequest(payload, "node_rename");
@@ -1415,9 +1251,8 @@ var NodeOperations = class {
    */
   async copy(fromPath, toParentPath, newName) {
     const payload = {
-      from_path: fromPath,
-      to_parent_path: toParentPath,
-      deep: false
+      source_path: fromPath,
+      target_parent: toParentPath
     };
     if (newName !== void 0) {
       payload.new_name = newName;
@@ -1435,9 +1270,8 @@ var NodeOperations = class {
    */
   async copyTree(fromPath, toParentPath, newName) {
     const payload = {
-      from_path: fromPath,
-      to_parent_path: toParentPath,
-      deep: true
+      source_path: fromPath,
+      target_parent: toParentPath
     };
     if (newName !== void 0) {
       payload.new_name = newName;
@@ -1494,6 +1328,24 @@ var NodeOperations = class {
     const result = await this.sendRequest(payload, "node_move_child_after");
     return result;
   }
+  /**
+   * Replay a parent's child order from another branch onto the current branch.
+   *
+   * Carries node sibling-order across branches — useful for selective publish
+   * flows, where copying node content (e.g. via SQL) does not move the ordering
+   * index. Only children that exist under the parent on both branches are
+   * reordered. The target branch is the connection's current branch.
+   *
+   * @param parentPath - Parent node path
+   * @param sourceBranch - Branch to copy the child order FROM
+   */
+  async applyChildOrder(parentPath, sourceBranch) {
+    const payload = {
+      parent_path: parentPath,
+      source_branch: sourceBranch
+    };
+    await this.sendRequest(payload, "node_apply_child_order");
+  }
   // ========================================================================
   // Relationship Operations
   // ========================================================================
@@ -1768,10 +1620,20 @@ var NodeFileSource = class {
       return;
     }
     if (!this._fsPromises) {
-      this._fsPromises = await import("fs/promises");
-    }
-    const stats = await this._fsPromises.stat(this._filePath);
-    this._size = stats.size;
+      if (!isNodeEnvironment()) {
+        throw new Error(
+          "NodeFileSource requires Node.js (fs/promises is not available in browsers). In the browser, use a File or Blob object instead."
+        );
+      }
+      const specifier = "fs/promises";
+      this._fsPromises = await import(
+        /* @vite-ignore */
+        /* webpackIgnore: true */
+        specifier
+      );
+    }
+    const stats = await this._fsPromises.stat(this._filePath);
+    this._size = stats.size;
     this._initialized = true;
   }
   /**
@@ -2569,6 +2431,17 @@ var Archetypes = class {
       "archetype_unpublish" /* ArchetypeUnpublish */
     );
   }
+  /**
+   * Get resolved Archetype with full inheritance applied
+   */
+  async getResolved(name) {
+    return this.sendRequest(
+      {
+        name
+      },
+      "archetype_get_resolved" /* ArchetypeGetResolved */
+    );
+  }
 };
 
 // src/element-types.ts
@@ -2656,6 +2529,17 @@ var ElementTypes = class {
       "element_type_unpublish" /* ElementTypeUnpublish */
     );
   }
+  /**
+   * Get resolved ElementType with full inheritance applied
+   */
+  async getResolved(name) {
+    return this.sendRequest(
+      {
+        name
+      },
+      "element_type_get_resolved" /* ElementTypeGetResolved */
+    );
+  }
 };
 
 // src/branches.ts
@@ -2757,6 +2641,102 @@ var Branches = class {
       "branch_compare" /* BranchCompare */
     );
   }
+  /**
+   * Per-node diff of `branch` relative to `baseBranch` (added/modified/deleted).
+   *
+   * Cheaper than reading both branch listings: cost scales with the number of
+   * changed nodes since the branches diverged, not the total content.
+   */
+  async diff(branch, baseBranch) {
+    return this.sendRequest(
+      {
+        branch,
+        base_branch: baseBranch
+      },
+      "branch_diff" /* BranchDiff */
+    );
+  }
+  /**
+   * Copy a node set from `sourceBranch` onto `targetBranch` (branch
+   * promotion): node ids are preserved, so repeated copies update the same
+   * target nodes; all changes land in ONE atomic commit on the target branch.
+   *
+   * Each root's parent path must already exist on the target branch. With
+   * `deleteMissing`, target nodes under the roots that are absent from the
+   * copied source set are pruned (one-way sync).
+   */
+  async copyNodes(sourceBranch, targetBranch, opts) {
+    return this.sendRequest(
+      {
+        source_branch: sourceBranch,
+        target_branch: targetBranch,
+        workspace: opts.workspace,
+        roots: opts.roots,
+        recursive: opts.recursive ?? true,
+        delete_missing: opts.deleteMissing ?? false
+      },
+      "branch_copy_nodes" /* BranchCopyNodes */
+    );
+  }
+};
+
+// src/scheduler.ts
+var SchedulerApi = class {
+  constructor(_context, sendRequest) {
+    this.sendRequest = sendRequest;
+  }
+  /**
+   * Schedule a one-shot invocation of a function or flow at a fixed time.
+   */
+  async schedule(options) {
+    const runAt = options.runAt instanceof Date ? options.runAt.toISOString() : options.runAt;
+    return this.sendRequest(
+      {
+        target_kind: options.targetKind,
+        target_path: options.targetPath,
+        input: options.input ?? {},
+        run_at: runAt,
+        external_key: options.externalKey,
+        branch: options.branch,
+        workspace: options.workspace,
+        max_retries: options.maxRetries
+      },
+      "scheduled_invocation_create" /* ScheduledInvocationCreate */
+    );
+  }
+  /**
+   * Cancel a pending invocation before it fires, by job id or external key.
+   */
+  async cancel(ref) {
+    const payload = typeof ref === "string" ? { job_id: ref } : { job_id: ref.jobId, external_key: ref.externalKey };
+    return this.sendRequest(
+      payload,
+      "scheduled_invocation_cancel" /* ScheduledInvocationCancel */
+    );
+  }
+  /**
+   * List this repository's scheduled invocations.
+   */
+  async list(filter) {
+    const result = await this.sendRequest(
+      {
+        external_key: filter?.externalKey,
+        status: filter?.status
+      },
+      "scheduled_invocation_list" /* ScheduledInvocationList */
+    );
+    return result?.invocations ?? [];
+  }
+  /**
+   * Fetch a single scheduled invocation, by job id or external key.
+   */
+  async get(ref) {
+    const payload = typeof ref === "string" ? { job_id: ref } : { job_id: ref.jobId, external_key: ref.externalKey };
+    return this.sendRequest(
+      payload,
+      "scheduled_invocation_get" /* ScheduledInvocationGet */
+    );
+  }
 };
 
 // src/tags.ts
@@ -3024,367 +3004,8 @@ var HttpFunctionsApi = class {
   }
 };
 
-// src/errors.ts
-var RaisinError = class extends Error {
-  constructor(message, code, details) {
-    super(message);
-    this.name = "RaisinError";
-    this.code = code;
-    this.details = details;
-    if (Error.captureStackTrace) {
-      Error.captureStackTrace(this, this.constructor);
-    }
-  }
-};
-var RaisinConnectionError = class extends RaisinError {
-  constructor(message, code, options) {
-    super(message, code, options?.details);
-    this.name = "RaisinConnectionError";
-    this.status = options?.status;
-  }
-};
-var RaisinAuthError = class extends RaisinError {
-  constructor(message, code, status, details) {
-    super(message, code, details);
-    this.name = "RaisinAuthError";
-    this.status = status;
-  }
-};
-var RaisinFlowError = class extends RaisinError {
-  constructor(message, code, instanceId, details) {
-    super(message, code, details);
-    this.name = "RaisinFlowError";
-    this.instanceId = instanceId;
-  }
-};
-var RaisinTimeoutError = class extends RaisinError {
-  constructor(message, code, timeoutMs, details) {
-    super(message, code, details);
-    this.name = "RaisinTimeoutError";
-    this.timeoutMs = timeoutMs;
-  }
-};
-var RaisinAbortError = class extends RaisinError {
-  constructor(message = "Operation was aborted") {
-    super(message, "ABORTED");
-    this.name = "RaisinAbortError";
-  }
-};
-function classifyHttpError(status, message, details) {
-  if (status === 401) {
-    return new RaisinAuthError(message, "AUTH_UNAUTHORIZED", status, details);
-  }
-  if (status === 403) {
-    return new RaisinAuthError(message, "AUTH_FORBIDDEN", status, details);
-  }
-  if (status === 404) {
-    return new RaisinFlowError(message, "FLOW_NOT_FOUND", void 0, details);
-  }
-  return new RaisinConnectionError(message, "CONNECTION_FAILED", { status, details });
-}
-
-// src/streaming/sse-client.ts
-function parseSSEBlock(block) {
-  let event = "message";
-  let data = "";
-  let id;
-  const lines = block.split("\n");
-  for (const line of lines) {
-    if (line.startsWith("event:")) {
-      event = line.slice(6).trim();
-    } else if (line.startsWith("data:")) {
-      if (data) data += "\n";
-      data += line.slice(5).trim();
-    } else if (line.startsWith("id:")) {
-      id = line.slice(3).trim();
-    }
-  }
-  if (!data) return null;
-  return { event, data, id };
-}
-var SSEClient = class {
-  constructor(url, options = {}) {
-    this.abortController = null;
-    this._state = "disconnected";
-    this.url = url;
-    this.options = options;
-    this.fetchImpl = options.fetch ?? globalThis.fetch.bind(globalThis);
-    this._lastEventId = options.lastEventId;
-    this.autoReconnect = options.reconnect?.enabled ?? true;
-    this.externalSignal = options.signal;
-    this.eventTypeSet = options.eventTypes?.length ? new Set(options.eventTypes) : null;
-    this.reconnectManager = new ReconnectManager({
-      initialDelay: options.reconnect?.initialDelay ?? 1e3,
-      maxDelay: options.reconnect?.maxDelay ?? 3e4,
-      backoffMultiplier: options.reconnect?.backoffMultiplier ?? 2,
-      maxAttempts: options.reconnect?.maxAttempts ?? Infinity
-    });
-  }
-  /** Current connection state */
-  get state() {
-    return this._state;
-  }
-  /**
-   * Returns a promise that resolves once the SSE connection is established.
-   *
-   * Useful for ensuring the connection is ready before triggering events
-   * on the server side (e.g., calling resume before consuming the stream).
-   * If the client is already connected, resolves immediately.
-   */
-  waitUntilConnected() {
-    if (this._state === "connected") return Promise.resolve();
-    return new Promise((resolve, reject) => {
-      const originalOnState = this.options.onStateChange;
-      this.options.onStateChange = (state) => {
-        originalOnState?.(state);
-        if (state === "connected") {
-          this.options.onStateChange = originalOnState;
-          resolve();
-        } else if (state === "disconnected") {
-          this.options.onStateChange = originalOnState;
-          reject(new Error("SSE connection failed"));
-        }
-      };
-    });
-  }
-  /** Last received event ID */
-  get lastEventId() {
-    return this._lastEventId;
-  }
-  setState(state) {
-    if (this._state !== state) {
-      this._state = state;
-      this.options.onStateChange?.(state);
-    }
-  }
-  /**
-   * Connect and consume events via callback.
-   *
-   * @param onEvent - Called for each matching SSE event
-   * @param onError - Called when an error occurs (optional)
-   */
-  async connect(onEvent, onError) {
-    this.close();
-    await this.startStream(onEvent, onError);
-  }
-  /**
-   * Close the SSE connection and stop reconnection attempts.
-   */
-  close() {
-    this.reconnectManager.cancelReconnect();
-    if (this.abortController) {
-      this.abortController.abort();
-      this.abortController = null;
-    }
-    this.setState("disconnected");
-  }
-  /**
-   * AsyncIterable interface: allows `for await (const event of sseClient)`.
-   *
-   * The iterator ends when close() is called or the server closes the stream
-   * (and auto-reconnect is disabled or max attempts are exhausted).
-   */
-  async *[Symbol.asyncIterator]() {
-    const queue = [];
-    let resolve = null;
-    let finished = false;
-    const push = (item) => {
-      if (finished) return;
-      if (resolve) {
-        const r = resolve;
-        resolve = null;
-        r(item);
-      } else {
-        queue.push(item);
-      }
-    };
-    const pull = () => {
-      const queued = queue.shift();
-      if (queued) return Promise.resolve(queued);
-      return new Promise((r) => {
-        resolve = r;
-      });
-    };
-    this.startStream(
-      (event) => push({ done: false, value: event }),
-      (error) => push({ done: true, error })
-    ).then(() => {
-      push({ done: true });
-    }).catch((error) => {
-      push({ done: true, error });
-    });
-    try {
-      while (!finished) {
-        const item = await pull();
-        if (item.done) {
-          finished = true;
-          if (item.error) {
-            throw item.error;
-          }
-          return;
-        }
-        yield item.value;
-      }
-    } finally {
-      finished = true;
-      this.close();
-    }
-  }
-  /**
-   * Core streaming loop: connects, reads the SSE stream, and handles reconnection.
-   */
-  async startStream(onEvent, onError) {
-    while (true) {
-      try {
-        await this.readStream(onEvent);
-        if (!this.autoReconnect || this._state === "disconnected") {
-          return;
-        }
-        this.setState("reconnecting");
-        const scheduled = await this.waitForReconnect();
-        if (!scheduled) {
-          logger.warn("SSE max reconnection attempts reached");
-          this.setState("disconnected");
-          return;
-        }
-      } catch (error) {
-        if (this._state === "disconnected") {
-          return;
-        }
-        const err = error instanceof Error ? error : new Error(String(error));
-        if (err.name === "AbortError" || err instanceof RaisinAbortError) {
-          return;
-        }
-        logger.error("SSE connection error:", err.message);
-        onError?.(err);
-        if (!this.autoReconnect) {
-          this.setState("disconnected");
-          throw err;
-        }
-        this.setState("reconnecting");
-        const scheduled = await this.waitForReconnect();
-        if (!scheduled) {
-          logger.warn("SSE max reconnection attempts reached");
-          this.setState("disconnected");
-          throw err;
-        }
-      }
-    }
-  }
-  /**
-   * Perform a single fetch and read the response body as SSE stream.
-   */
-  async readStream(onEvent) {
-    this.abortController = new AbortController();
-    this.setState("connecting");
-    if (this.externalSignal) {
-      if (this.externalSignal.aborted) {
-        this.abortController.abort();
-      } else {
-        const ctrl = this.abortController;
-        this.externalSignal.addEventListener("abort", () => ctrl.abort(), { once: true });
-      }
-    }
-    const headers = {
-      Accept: "text/event-stream",
-      "Cache-Control": "no-cache",
-      ...this.options.headers
-    };
-    if (this._lastEventId) {
-      headers["Last-Event-ID"] = this._lastEventId;
-    }
-    const method = this.options.method ?? "GET";
-    const fetchOptions = {
-      method,
-      headers,
-      signal: this.abortController.signal
-    };
-    if (method === "POST" && this.options.body !== void 0) {
-      fetchOptions.headers["Content-Type"] = "application/json";
-      fetchOptions.body = JSON.stringify(this.options.body);
-    }
-    const response = await this.fetchImpl(this.url, fetchOptions);
-    if (!response.ok) {
-      const text = await response.text().catch(() => "");
-      const msg = `SSE connection failed: ${response.status} ${response.statusText}${text ? ` - ${text}` : ""}`;
-      if (response.status === 401 || response.status === 403) {
-        throw new RaisinAuthError(
-          msg,
-          response.status === 401 ? "AUTH_UNAUTHORIZED" : "AUTH_FORBIDDEN",
-          response.status
-        );
-      }
-      throw new RaisinConnectionError(msg, "SSE_STREAM_ERROR", { status: response.status });
-    }
-    if (!response.body) {
-      throw new RaisinConnectionError("SSE response has no body", "SSE_STREAM_ERROR");
-    }
-    this.setState("connected");
-    this.reconnectManager.reset();
-    const reader = response.body.getReader();
-    const decoder = new TextDecoder();
-    let buffer = "";
-    try {
-      while (true) {
-        const { done, value } = await reader.read();
-        if (done) break;
-        buffer += decoder.decode(value, { stream: true });
-        const blocks = buffer.split("\n\n");
-        buffer = blocks.pop() ?? "";
-        for (const block of blocks) {
-          const trimmed = block.trim();
-          if (!trimmed) continue;
-          const parsed = parseSSEBlock(trimmed);
-          if (!parsed) continue;
-          if (parsed.id) {
-            this._lastEventId = parsed.id;
-          }
-          if (this.eventTypeSet && !this.eventTypeSet.has(parsed.event)) {
-            continue;
-          }
-          let data;
-          try {
-            data = JSON.parse(parsed.data);
-          } catch {
-            data = parsed.data;
-          }
-          const sseEvent = {
-            type: parsed.event,
-            data,
-            id: parsed.id
-          };
-          onEvent(sseEvent);
-        }
-      }
-    } finally {
-      reader.releaseLock();
-    }
-  }
-  /**
-   * Wait for the reconnect manager to schedule a reconnection attempt.
-   * Returns true if reconnection was scheduled, false if max attempts reached.
-   */
-  waitForReconnect() {
-    return new Promise((resolve) => {
-      const scheduled = this.reconnectManager.scheduleReconnect(() => {
-        resolve(true);
-      });
-      if (!scheduled) {
-        resolve(false);
-      }
-    });
-  }
-};
-
-// src/utils/chat-events.ts
-function isRecoveredDoneEvent(event) {
-  if (event.type !== "done") return false;
-  const done = event;
-  if (done.recovered !== true) return false;
-  return typeof done.content !== "string" || done.content.trim().length === 0;
-}
-
 // src/conversations.ts
+var DEFAULT_SEND_MESSAGE_INACTIVITY_TIMEOUT_MS = 12e4;
 var ConversationManager = class {
   constructor(baseUrl, repository, authManager, options = {}, executeSql) {
     this.baseUrl = baseUrl.replace(/\/$/, "");
@@ -3406,10 +3027,11 @@ var ConversationManager = class {
     );
     if (!result?.rows?.[0]) throw new Error("User not authenticated");
     const row = result.rows[0];
-    this.cachedUserHome = row.home;
-    this.cachedUserId = row.user_id || this.cachedUserHome;
-    if (!this.cachedUserHome) throw new Error("User home path not found");
-    return { userId: this.cachedUserId, userHome: this.cachedUserHome };
+    const userHome = normalizeHomePath(row.home);
+    if (!userHome) throw new Error("User home path not found");
+    this.cachedUserHome = userHome;
+    this.cachedUserId = row.user_id || userHome;
+    return { userId: this.cachedUserId, userHome };
   }
   // ==========================================================================
   // Conversation listing
@@ -3604,13 +3226,15 @@ var ConversationManager = class {
       fetch: this.fetchImpl,
       signal: options?.signal,
       method: "POST",
-      body: { channel: streamTarget.channel, path: streamTarget.path }
+      body: { channel: streamTarget.channel, path: streamTarget.path },
+      inactivityTimeoutMs: options?.inactivityTimeoutMs ?? DEFAULT_SEND_MESSAGE_INACTIVITY_TIMEOUT_MS
     });
     const iterator = sse[Symbol.asyncIterator]();
     let pendingFirst = iterator.next();
     try {
       await sse.waitUntilConnected();
     } catch {
+      pendingFirst?.catch(() => void 0);
       pendingFirst = null;
       sse.close();
       logger.debug("SSE connection failed, falling back to create-only");
@@ -3647,6 +3271,15 @@ var ConversationManager = class {
             return;
           }
         }
+      } catch (error) {
+        if (error instanceof RaisinTimeoutError && error.code === "SSE_INACTIVITY_TIMEOUT") {
+          logger.warn(
+            `[ConversationManager] SSE stream inactive for ${error.timeoutMs}ms, ending turn with synthetic waiting event`
+          );
+          yield { type: "waiting", timestamp: (/* @__PURE__ */ new Date()).toISOString() };
+          return;
+        }
+        throw error;
       } finally {
         sse.close();
       }
@@ -4132,383 +3765,69 @@ var ConversationManager = class {
   }
 };
 
-// src/flow-client.ts
-var FlowClient = class _FlowClient {
-  /**
-   * Create a new FlowClient.
-   *
-   * @param baseUrl - Base HTTP URL of the RaisinDB server (e.g., "http://localhost:8081")
-   * @param repository - Repository name
-   * @param authManager - Auth manager for token access
-   * @param options - Additional options
-   * @param flowsApi - Optional FlowsApi for WebSocket-based flow operations
-   */
-  constructor(baseUrl, repository, authManager, options = {}, flowsApi) {
+// src/inbox.ts
+var InboxApi = class {
+  constructor(baseUrl, repository, authManager, options = {}) {
     this.baseUrl = baseUrl.replace(/\/$/, "");
     this.repository = repository;
     this.authManager = authManager;
     this.fetchImpl = options.fetch ?? fetch;
-    this.requestTimeout = options.requestTimeout ?? 6e4;
-    this.flowsApi = flowsApi;
+    this.requestTimeout = options.requestTimeout ?? 3e4;
   }
   /**
-   * Create a FlowClient from an existing RaisinHttpClient.
+   * List the caller's inbox tasks.
    *
-   * @param httpClient - An authenticated RaisinHttpClient instance
-   * @param baseUrl - Base HTTP URL (same as the one used for the HTTP client)
-   * @param repository - Repository name
-   * @param options - Additional options
+   * Tasks are sorted pending-first, then by priority (highest first) and
+   * due time (earliest first).
    */
-  static fromHttpClient(httpClient, baseUrl, repository, options = {}, flowsApi) {
-    return new _FlowClient(
-      baseUrl,
-      repository,
-      httpClient.getAuthManager(),
-      options,
-      flowsApi
-    );
+  async listTasks(options = {}) {
+    const params = new URLSearchParams();
+    if (options.status) params.set("status", options.status);
+    if (options.assignee) params.set("assignee", options.assignee);
+    const query = params.size > 0 ? `?${params.toString()}` : "";
+    return this.request({
+      method: "GET",
+      path: `/api/inbox/${this.repository}${query}`,
+      signal: options.signal
+    });
   }
-  // ==========================================================================
-  // Flow Execution
-  // ==========================================================================
   /**
-   * Execute a flow by path.
-   *
-   * Creates a FlowInstance and queues it for execution. Returns immediately
-   * with the instance ID - use `streamEvents()` to monitor progress.
-   *
-   * @param flowPath - Path to the raisin:Flow node (e.g., "/flows/my-flow")
-   * @param input - Input data passed to the flow
-   * @returns Flow run response with instance_id and job_id
-   *
-   * @example
-   * ```typescript
-   * const result = await flows.run('/flows/process-order', {
-   *   orderId: 'ord-123',
-   *   items: [{ sku: 'ABC', qty: 2 }],
-   * });
-   * console.log('Instance:', result.instance_id);
-   * ```
+   * Get a single inbox task by ID (or path).
    */
-  async run(flowPath, input = {}, options) {
-    if (this.flowsApi) {
-      return this.flowsApi.run(flowPath, input);
-    }
-    const response = await this.request({
-      method: "POST",
-      path: `/api/flows/${this.repository}/run`,
-      body: { flow_path: flowPath, input },
+  async getTask(taskId, options) {
+    return this.request({
+      method: "GET",
+      path: `/api/inbox/${this.repository}/tasks/${encodeURIComponent(taskId)}`,
       signal: options?.signal
     });
-    return response;
   }
-  // ==========================================================================
-  // Instance Status
-  // ==========================================================================
   /**
-   * Get the current status of a flow instance.
+   * Complete an inbox task.
    *
-   * Returns the instance status, variables, and metadata. Useful for
-   * polling-based approaches where SSE is not reliable (e.g., initial
-   * flow execution where events may be missed).
+   * The caller must be the task's assignee (or an admin). Completion marks
+   * the task done, records who decided, and resumes the owning flow.
    *
-   * @param instanceId - Flow instance ID (from `run()`)
-   * @returns Instance status including variables and flow path
+   * @param taskId - Task node ID (or path)
+   * @param response - The response payload:
+   *   - approval tasks: `{ action: '<option value>', comment?: string }`
+   *   - input tasks: the input value(s) matching the task's input_schema
+   *   - review/action tasks: any acknowledgement payload
    *
    * @example
    * ```typescript
-   * const status = await flows.getInstanceStatus('instance-123');
-   * console.log('Status:', status.status); // 'waiting', 'completed', etc.
+   * await inbox.completeTask('task-123', { action: 'approve' });
    * ```
    */
-  async getInstanceStatus(instanceId, options) {
-    if (this.flowsApi) {
-      return this.flowsApi.getInstanceStatus(instanceId);
-    }
+  async completeTask(taskId, response, options) {
     return this.request({
-      method: "GET",
-      path: `/api/flows/${this.repository}/instances/${instanceId}`,
+      method: "POST",
+      path: `/api/inbox/${this.repository}/tasks/${encodeURIComponent(taskId)}/complete`,
+      body: { response },
       signal: options?.signal
     });
   }
   // ==========================================================================
-  // Event Streaming (SSE)
-  // ==========================================================================
-  /**
-   * Stream real-time execution events for a flow instance via SSE.
-   *
-   * Returns an async iterable that yields FlowExecutionEvent objects.
-   * The stream automatically closes when a terminal event is received
-   * (flow_completed or flow_failed).
-   *
-   * @param instanceId - Flow instance ID (from `run()`)
-   * @returns Async iterable of flow execution events
-   *
-   * @example
-   * ```typescript
-   * const { instance_id } = await flows.run('/flows/my-flow', { key: 'value' });
-   *
-   * for await (const event of flows.streamEvents(instance_id)) {
-   *   switch (event.type) {
-   *     case 'step_started':
-   *       console.log(`Step ${event.node_id} started`);
-   *       break;
-   *     case 'step_completed':
-   *       console.log(`Step ${event.node_id} completed in ${event.duration_ms}ms`);
-   *       break;
-   *     case 'text_chunk':
-   *       process.stdout.write(event.text);
-   *       break;
-   *     case 'flow_completed':
-   *       console.log('Flow done:', event.output);
-   *       break;
-   *     case 'flow_failed':
-   *       console.error('Flow failed:', event.error);
-   *       break;
-   *   }
-   * }
-   * ```
-   */
-  async *streamEvents(instanceId, options) {
-    if (this.flowsApi) {
-      const sub = await this.flowsApi.subscribeEvents(instanceId);
-      try {
-        for await (const event of sub.events) {
-          if (options?.signal?.aborted) throw new RaisinAbortError();
-          yield event;
-          if (event.type === "flow_completed" || event.type === "flow_failed") {
-            return;
-          }
-        }
-      } finally {
-        await sub.unsubscribe();
-      }
-      return;
-    }
-    const url = `${this.baseUrl}/api/flows/${this.repository}/instances/${instanceId}/events`;
-    const headers = {};
-    const token = this.authManager.getAccessToken();
-    if (token) {
-      headers["Authorization"] = `Bearer ${token}`;
-    }
-    const sse = new SSEClient(url, {
-      headers,
-      eventTypes: ["flow-event", "message"],
-      reconnect: { enabled: false },
-      fetch: this.fetchImpl,
-      signal: options?.signal
-    });
-    try {
-      for await (const sseEvent of sse) {
-        const event = sseEvent.data;
-        yield event;
-        if (event.type === "flow_completed" || event.type === "flow_failed") {
-          return;
-        }
-      }
-    } finally {
-      sse.close();
-    }
-  }
-  /**
-   * Create an eagerly-connected event stream for a flow instance.
-   *
-   * Unlike `streamEvents()` (a lazy async generator), this method opens the
-   * SSE connection immediately and waits until it is established before
-   * returning. This is critical for resume flows: you must subscribe to
-   * events BEFORE calling `resume()`, otherwise events emitted between
-   * the resume and the SSE connection are lost.
-   *
-   * @param instanceId - Flow instance ID
-   * @returns Object with an async iterable `events` and a `close()` method
-   */
-  async createEventStream(instanceId, options) {
-    if (this.flowsApi) {
-      const sub = await this.flowsApi.subscribeEvents(instanceId);
-      return {
-        events: sub.events,
-        close: () => {
-          sub.unsubscribe();
-        }
-      };
-    }
-    const url = `${this.baseUrl}/api/flows/${this.repository}/instances/${instanceId}/events`;
-    const headers = {};
-    const token = this.authManager.getAccessToken();
-    if (token) {
-      headers["Authorization"] = `Bearer ${token}`;
-    }
-    const sse = new SSEClient(url, {
-      headers,
-      eventTypes: ["flow-event", "message"],
-      reconnect: { enabled: false },
-      fetch: this.fetchImpl,
-      signal: options?.signal
-    });
-    const iterator = sse[Symbol.asyncIterator]();
-    let pendingFirst = iterator.next();
-    await sse.waitUntilConnected();
-    const events = {
-      [Symbol.asyncIterator]() {
-        return {
-          async next() {
-            let result;
-            if (pendingFirst) {
-              result = await pendingFirst;
-              pendingFirst = null;
-            } else {
-              result = await iterator.next();
-            }
-            if (result.done) return { done: true, value: void 0 };
-            const event = result.value.data;
-            return { done: false, value: event };
-          },
-          async return() {
-            await iterator.return?.();
-            sse.close();
-            return { done: true, value: void 0 };
-          }
-        };
-      }
-    };
-    return { events, close: () => sse.close() };
-  }
-  // ==========================================================================
-  // Flow Resume & Human Task
-  // ==========================================================================
-  /**
-   * Resume a flow instance that is in a waiting state.
-   *
-   * Use this when a flow is waiting for external input (tool results,
-   * external events, etc.). The resume data is passed to the waiting step.
-   *
-   * @param instanceId - Flow instance ID
-   * @param data - Resume data to pass to the waiting step
-   *
-   * @example
-   * ```typescript
-   * await flows.resume('instance-123', {
-   *   tool_name: 'get_weather',
-   *   result: { temperature: 72, conditions: 'sunny' },
-   * });
-   * ```
-   */
-  async resume(instanceId, data, options) {
-    if (this.flowsApi) {
-      await this.flowsApi.resume(instanceId, data);
-      return;
-    }
-    await this.request({
-      method: "POST",
-      path: `/api/flows/${this.repository}/instances/${instanceId}/resume`,
-      body: { resume_data: data },
-      signal: options?.signal
-    });
-  }
-  /**
-   * Respond to a human task within a flow.
-   *
-   * When a flow is waiting on a human_task step (approval, input, review),
-   * use this method to submit the response and resume the flow.
-   *
-   * @param instanceId - Flow instance ID
-   * @param taskId - The human task node ID
-   * @param response - The human's response data
-   *
-   * @example
-   * ```typescript
-   * // Approve a task
-   * await flows.respondToHumanTask('instance-123', 'step-5', {
-   *   action: 'approve',
-   *   comment: 'Looks good!',
-   * });
-   *
-   * // Provide input for an input task
-   * await flows.respondToHumanTask('instance-123', 'step-3', {
-   *   name: 'John Doe',
-   *   email: 'john@example.com',
-   * });
-   * ```
-   */
-  async respondToHumanTask(instanceId, taskId, response, options) {
-    await this.request({
-      method: "POST",
-      path: `/api/flows/${this.repository}/instances/${instanceId}/tasks/${taskId}/respond`,
-      body: { response },
-      signal: options?.signal
-    });
-  }
-  // ==========================================================================
-  // Convenience Methods
-  // ==========================================================================
-  /**
-   * Run a flow and wait for the final result.
-   *
-   * Starts the flow, streams all events, and returns the terminal outcome.
-   * This is a one-shot helper for fire-and-forget flows where you only
-   * care about the final output.
-   *
-   * @param flowPath - Path to the raisin:Flow node
-   * @param input - Input data passed to the flow
-   * @param options - Optional abort signal
-   * @returns The flow outcome including output or error
-   *
-   * @example
-   * ```typescript
-   * const result = await flows.runAndWait('/flows/process-order', { orderId: '123' });
-   * if (result.status === 'completed') {
-   *   console.log('Output:', result.output);
-   * }
-   * ```
-   */
-  async runAndWait(flowPath, input = {}, options) {
-    const { instance_id } = await this.run(flowPath, input, options);
-    for await (const event of this.streamEvents(instance_id, options)) {
-      if (event.type === "flow_completed") {
-        return {
-          instanceId: instance_id,
-          status: "completed",
-          output: event.output
-        };
-      }
-      if (event.type === "flow_failed") {
-        return {
-          instanceId: instance_id,
-          status: "failed",
-          error: event.error
-        };
-      }
-    }
-    return { instanceId: instance_id, status: "failed", error: "Stream ended without terminal event" };
-  }
-  /**
-   * Run a flow and collect all events into an array.
-   *
-   * Starts the flow, streams all events, and returns them as a collected array.
-   * Useful for testing, logging, or post-processing all flow events.
-   *
-   * @param flowPath - Path to the raisin:Flow node
-   * @param input - Input data passed to the flow
-   * @param options - Optional abort signal
-   * @returns The instance ID and all collected events
-   *
-   * @example
-   * ```typescript
-   * const { events } = await flows.runAndCollect('/flows/etl-pipeline', { source: 'db' });
-   * const steps = events.filter(e => e.type === 'step_completed');
-   * console.log(`Completed ${steps.length} steps`);
-   * ```
-   */
-  async runAndCollect(flowPath, input = {}, options) {
-    const { instance_id } = await this.run(flowPath, input, options);
-    const events = [];
-    for await (const event of this.streamEvents(instance_id, options)) {
-      events.push(event);
-    }
-    return { instanceId: instance_id, events };
-  }
-  // ==========================================================================
-  // Internal HTTP request helper
+  // Internal HTTP request helper
   // ==========================================================================
   async request(options) {
     const url = `${this.baseUrl}${options.path}`;
@@ -4526,7 +3845,9 @@ var FlowClient = class _FlowClient {
         clearTimeout(timeoutId);
         throw new RaisinAbortError();
       }
-      options.signal.addEventListener("abort", () => controller.abort(), { once: true });
+      options.signal.addEventListener("abort", () => controller.abort(), {
+        once: true
+      });
     }
     try {
       const response = await this.fetchImpl(url, {
@@ -4761,6 +4082,13 @@ var Database = class _Database {
   tags() {
     return new Tags(this._context, this.sendRequest);
   }
+  /**
+   * Get SchedulerApi for one-shot scheduled invocations (time-based
+   * function/flow runs).
+   */
+  scheduler() {
+    return new SchedulerApi(this._context, this.sendRequest);
+  }
   /**
    * Get FlowsApi for running flows via WebSocket
    */
@@ -4848,8 +4176,44 @@ var Database = class _Database {
     }
     return this._flowClient;
   }
+  /**
+   * Get a pre-configured InboxApi for human-in-the-loop tasks.
+   *
+   * Requires the Database to have been created via `RaisinClient.database()`
+   * (which automatically provides HTTP context).
+   *
+   * @example
+   * ```typescript
+   * const db = client.database('my-repo');
+   * const { tasks } = await db.inbox.listTasks({ status: 'pending' });
+   * await db.inbox.completeTask(tasks[0].id, { action: 'approve' });
+   * ```
+   */
+  get inbox() {
+    if (!this._inboxApi) {
+      if (!this.httpOptions?.httpBaseUrl || !this.httpOptions?.authManager) {
+        throw new Error(
+          "db.inbox requires HTTP context. Use client.database() to get a Database with inbox support."
+        );
+      }
+      this._inboxApi = new InboxApi(
+        this.httpOptions.httpBaseUrl,
+        this.repository,
+        this.httpOptions.authManager
+      );
+    }
+    return this._inboxApi;
+  }
   /**
    * Get EventHandler for subscribing to real-time events
+   *
+   * Path filter semantics for subscriptions (matched server-side):
+   * - A plain path matches **only that exact node** — there is no implicit
+   *   prefix matching.
+   * - `*` matches exactly one path segment (`/inbox/*` matches `/inbox/a`,
+   *   not `/inbox/a/b`).
+   * - `**` matches recursively (`/inbox/**` matches all descendants of
+   *   `/inbox`, but not `/inbox` itself).
    */
   events() {
     return this.eventHandler;
@@ -4857,7 +4221,7 @@ var Database = class _Database {
 };
 
 // src/http-client.ts
-import { EventEmitter as EventEmitter2 } from "events";
+import { EventEmitter } from "events";
 
 // src/upload/types.ts
 var UploadErrorCode = /* @__PURE__ */ ((UploadErrorCode2) => {
@@ -5220,7 +4584,7 @@ var BatchUploader = class {
   /**
    * Create a batch uploader
    */
-  constructor(config2, files, options) {
+  constructor(config, files, options) {
     this.fileStates = /* @__PURE__ */ new Map();
     this.queue = [];
     this.speedTracker = new BatchSpeedTracker();
@@ -5230,7 +4594,7 @@ var BatchUploader = class {
     this.started = false;
     this.resolveWhenResumed = null;
     this.lastBytesUploaded = 0;
-    this.config = config2;
+    this.config = config;
     this.files = files;
     this.options = {
       repository: options.repository,
@@ -5684,7 +5048,7 @@ var Uploader = class {
   /**
    * Create a new Uploader
    */
-  constructor(config2, fileSource, options, uploadId) {
+  constructor(config, fileSource, options, uploadId) {
     this.session = null;
     this.status = "pending";
     this.bytesUploaded = 0;
@@ -5693,10 +5057,10 @@ var Uploader = class {
     this.speedTracker = new SpeedTracker();
     this.pauseRequested = false;
     this.abortController = null;
-    this.baseUrl = config2.baseUrl.replace(/\/$/, "");
-    this.authManager = config2.authManager;
-    this.fetchImpl = config2.fetchImpl ?? fetch;
-    this.requestTimeout = config2.requestTimeout ?? 3e4;
+    this.baseUrl = config.baseUrl.replace(/\/$/, "");
+    this.authManager = config.authManager;
+    this.fetchImpl = config.fetchImpl ?? fetch;
+    this.requestTimeout = config.requestTimeout ?? 3e4;
     this.fileSource = fileSource;
     this.id = uploadId ?? generateUploadId();
     this.options = {
@@ -6062,9 +5426,9 @@ var UploadManager = class {
   /**
    * Create an upload manager
    */
-  constructor(config2) {
+  constructor(config) {
     this.uploads = /* @__PURE__ */ new Map();
-    this.config = config2;
+    this.config = config;
   }
   /**
    * Create a new upload
@@ -6128,10 +5492,194 @@ var UploadManager = class {
   }
 };
 
+// src/http-schema.ts
+var HttpSchemaBase = class {
+  constructor(repository, branch, client) {
+    this.repository = repository;
+    this.branch = branch;
+    this.client = client;
+  }
+  /** Base management URL for this schema kind. */
+  base() {
+    return `/api/management/${this.repository}/${this.branch}/${this.kind}`;
+  }
+  /** List all schemas (or only published ones). */
+  async list(publishedOnly = false) {
+    const path = publishedOnly ? `${this.base()}/published` : this.base();
+    const result = await this.client.managementRequest("GET", path);
+    return Array.isArray(result) ? result : [];
+  }
+  /** Get a single schema by name. */
+  async get(name) {
+    return this.client.managementRequest("GET", `${this.base()}/${encodeURIComponent(name)}`);
+  }
+  /** Get the schema with full inheritance (`extends`) applied. */
+  async getResolved(name) {
+    return this.client.managementRequest(
+      "GET",
+      `${this.base()}/${encodeURIComponent(name)}/resolved`
+    );
+  }
+  /** Create a schema. `name` is folded into the definition body if absent. */
+  async create(name, definition, commit) {
+    return this.client.managementRequest("POST", this.base(), {
+      [this.defField]: { name, ...definition },
+      commit
+    });
+  }
+  /** Update an existing schema. */
+  async update(name, definition, commit) {
+    return this.client.managementRequest(
+      "PUT",
+      `${this.base()}/${encodeURIComponent(name)}`,
+      { [this.defField]: { name, ...definition }, commit }
+    );
+  }
+  /** Delete a schema. */
+  async delete(name, commit) {
+    return this.client.managementRequest(
+      "DELETE",
+      `${this.base()}/${encodeURIComponent(name)}`,
+      commit
+    );
+  }
+  /** Publish a schema. */
+  async publish(name, commit) {
+    return this.client.managementRequest(
+      "POST",
+      `${this.base()}/${encodeURIComponent(name)}/publish`,
+      commit
+    );
+  }
+  /** Unpublish a schema. */
+  async unpublish(name, commit) {
+    return this.client.managementRequest(
+      "POST",
+      `${this.base()}/${encodeURIComponent(name)}/unpublish`,
+      commit
+    );
+  }
+};
+var HttpNodeTypes = class extends HttpSchemaBase {
+  constructor() {
+    super(...arguments);
+    this.kind = "nodetypes";
+    this.defField = "node_type";
+  }
+  /**
+   * Get the resolved NodeType. Unlike archetypes/element types, NodeType
+   * resolution can be workspace-aware (honors workspace NodeType pins).
+   */
+  async getResolved(name, opts) {
+    const query = opts?.workspace ? `?workspace=${encodeURIComponent(opts.workspace)}` : "";
+    return this.client.managementRequest(
+      "GET",
+      `${this.base()}/${encodeURIComponent(name)}/resolved${query}`
+    );
+  }
+};
+var HttpArchetypes = class extends HttpSchemaBase {
+  constructor() {
+    super(...arguments);
+    this.kind = "archetypes";
+    this.defField = "archetype";
+  }
+};
+var HttpElementTypes = class extends HttpSchemaBase {
+  constructor() {
+    super(...arguments);
+    this.kind = "elementtypes";
+    this.defField = "element_type";
+  }
+};
+
+// src/mcp.ts
+var McpClient = class {
+  constructor(transport) {
+    this.transport = transport;
+  }
+  /**
+   * List the tools this MCP server advertises to the calling identity.
+   *
+   * Wraps the `tools/list` JSON-RPC method. The visible set is RLS-scoped to
+   * the authenticated caller (or the anonymous role).
+   *
+   * @returns The advertised tool descriptors.
+   */
+  async listTools() {
+    const result = await this.transport.rpc("tools/list");
+    return { tools: result?.tools ?? [] };
+  }
+  /**
+   * Invoke a tool by name.
+   *
+   * Wraps the `tools/call` JSON-RPC method. The underlying `raisin:Function`
+   * runs RLS-scoped to the calling identity. A domain-level tool failure is
+   * reported via {@link McpCallToolResult.isError} (not thrown); transport and
+   * protocol errors are thrown.
+   *
+   * @param name - Tool name from {@link listTools}.
+   * @param args - Arguments object matching the tool's `inputSchema`.
+   * @returns The tool's content blocks and optional structured content.
+   */
+  async callTool(name, args) {
+    const result = await this.transport.rpc("tools/call", {
+      name,
+      arguments: args ?? {}
+    });
+    return result;
+  }
+  /**
+   * Read a resource by its `raisin://` URI.
+   *
+   * Wraps the `resources/read` JSON-RPC method. JSON-only resources return
+   * their properties as a `text` entry; byte-serving resources return base64
+   * in `blob`.
+   *
+   * @param uri - `raisin://{workspace}/{path}` URI to read.
+   * @returns One content entry per URI read.
+   */
+  async readResource(uri) {
+    const result = await this.transport.rpc("resources/read", {
+      uri
+    });
+    return { contents: result?.contents ?? [] };
+  }
+  /**
+   * Subscribe to change notifications for a resource URI (or URI prefix).
+   *
+   * Wraps the `resources/subscribe` JSON-RPC method, which upgrades to an SSE
+   * stream. The returned {@link McpResourceSubscription} is an async iterable of
+   * {@link McpResourceUpdate}; the server's initial subscription ack is consumed
+   * internally and not yielded. Call `close()` to end the stream.
+   *
+   * @param uri - `raisin://` URI (or prefix) to watch.
+   * @returns A live, closeable subscription.
+   */
+  subscribeResource(uri) {
+    const stream = this.transport.subscribe("resources/subscribe", { uri });
+    return {
+      close: () => stream.close(),
+      async *[Symbol.asyncIterator]() {
+        for await (const frame of stream) {
+          if (frame.method === "notifications/resources/updated") {
+            const params = frame.params ?? {};
+            if (typeof params.uri === "string") {
+              yield { uri: params.uri };
+            }
+          }
+        }
+      }
+    };
+  }
+};
+
 // src/http-client.ts
-var RaisinHttpClient = class extends EventEmitter2 {
+var RaisinHttpClient = class extends EventEmitter {
   constructor(baseUrl, options = {}) {
     super();
+    /** Monotonic JSON-RPC id counter for MCP requests. */
+    this._mcpRequestId = 0;
     this._currentUser = null;
     this._uploadManager = null;
     this.baseUrl = baseUrl.replace(/\/$/, "");
@@ -6177,9 +5725,13 @@ var RaisinHttpClient = class extends EventEmitter2 {
         body: payload,
         skipAuth: true
       });
-      this.authManager.setTokens(response.data);
+      if (response.data.token) {
+        this.authManager.storage.setAccessToken(response.data.token);
+      } else {
+        this.authManager.setTokens(response.data);
+      }
       this._currentUser = {
-        userId: "admin",
+        userId: response.data.user_id ?? "admin",
         anonymous: false
       };
       this.emit("authenticated", response.data);
@@ -6369,14 +5921,14 @@ var RaisinHttpClient = class extends EventEmitter2 {
    * @param config - Repository configuration
    * @returns Repository creation result
    */
-  async createRepository(repositoryId, description, config2) {
+  async createRepository(repositoryId, description, config) {
     const response = await this.request({
       method: "POST",
       path: "/api/repositories",
       body: {
         repository_id: repositoryId,
         description,
-        config: config2
+        config
       }
     });
     return response.data;
@@ -6414,13 +5966,13 @@ var RaisinHttpClient = class extends EventEmitter2 {
    * @param config - New repository configuration
    * @returns Repository update result
    */
-  async updateRepository(repositoryId, description, config2) {
+  async updateRepository(repositoryId, description, config) {
     const response = await this.request({
       method: "PUT",
       path: `/api/repositories/${repositoryId}`,
       body: {
         description,
-        config: config2
+        config
       }
     });
     return response.data;
@@ -6823,6 +6375,107 @@ var RaisinHttpClient = class extends EventEmitter2 {
     });
     return response.data;
   }
+  /**
+   * Send one JSON-RPC request to an MCP server endpoint and return its
+   * unwrapped `result`.
+   *
+   * Calls `POST /mcp/{repo}/{branch}/{slug}` carrying a single JSON-RPC 2.0
+   * message. MCP errors are returned in the JSON-RPC envelope (HTTP `200`), so
+   * this method inspects the body's `error` member and throws on failure.
+   *
+   * @internal Used by {@link McpClient} via the transport built in `mcp()`.
+   */
+  async mcpRpc(repository, branch, slug, method, params) {
+    const id = ++this._mcpRequestId;
+    const response = await this.request({
+      method: "POST",
+      path: `/mcp/${repository}/${branch}/${slug}`,
+      body: {
+        jsonrpc: "2.0",
+        id,
+        method,
+        ...params !== void 0 ? { params } : {}
+      }
+    });
+    const frame = response.data;
+    if (frame?.error) {
+      const err = new Error(frame.error.message || `MCP error ${frame.error.code}`);
+      err.code = frame.error.code;
+      err.data = frame.error.data;
+      throw err;
+    }
+    return frame?.result;
+  }
+  /**
+   * Open the `resources/subscribe` SSE stream for an MCP server endpoint.
+   *
+   * Streams JSON-RPC frames (the subscription ack followed by
+   * `notifications/resources/updated` frames) from
+   * `POST /mcp/{repo}/{branch}/{slug}`.
+   *
+   * @internal Used by {@link McpClient} via the transport built in `mcp()`.
+   */
+  mcpSubscribe(repository, branch, slug, method, params) {
+    const headers = {};
+    if (this.authManager.isAuthenticated()) {
+      const token = this.authManager.getAccessToken();
+      if (token) {
+        headers["Authorization"] = `Bearer ${token}`;
+      }
+    }
+    const sse = new SSEClient(
+      `${this.baseUrl}/mcp/${repository}/${branch}/${slug}`,
+      {
+        method: "POST",
+        body: {
+          jsonrpc: "2.0",
+          id: ++this._mcpRequestId,
+          method,
+          params
+        },
+        headers,
+        fetch: this.fetchImpl,
+        reconnect: { enabled: false }
+      }
+    );
+    return {
+      close: () => sse.close(),
+      async *[Symbol.asyncIterator]() {
+        for await (const event of sse) {
+          yield event.data;
+        }
+      }
+    };
+  }
+  /**
+   * Get an {@link McpClient} for a content-declared MCP server.
+   *
+   * @param slug - The `raisin:McpServer` slug (resolved in the `mcp` workspace).
+   * @param branch - Branch to address; defaults to the client's current branch.
+   */
+  mcp(slug, branch) {
+    const repository = this._context.repository;
+    if (!repository) {
+      throw new Error("mcp() requires a repository; call database(name) first");
+    }
+    const effectiveBranch = branch ?? this.getBranch();
+    const transport = {
+      rpc: (m, p) => this.mcpRpc(repository, effectiveBranch, slug, m, p),
+      subscribe: (m, p) => this.mcpSubscribe(repository, effectiveBranch, slug, m, p)
+    };
+    return new McpClient(transport);
+  }
+  /**
+   * Make a management REST request and return the parsed body.
+   *
+   * @internal Used by the HTTP schema-management helpers
+   * ({@link HttpNodeTypes}/{@link HttpArchetypes}/{@link HttpElementTypes}) to
+   * reuse the client's centralized auth, timeout, and base-URL handling.
+   */
+  async managementRequest(method, path, body) {
+    const response = await this.request({ method, path, body });
+    return response.data;
+  }
   /**
    * Get a simplified database interface for SSR
    * This returns an HTTP-based database client
@@ -6910,6 +6563,36 @@ var HttpDatabase = class _HttpDatabase {
       (repo, name, input) => this.client.invokeFunctionSync(repo, name, input)
     );
   }
+  /**
+   * Get an {@link McpClient} for a content-declared MCP server on this database.
+   *
+   * @param slug - The `raisin:McpServer` slug (resolved in the `mcp` workspace).
+   * @returns A client scoped to `{repo}/{branch}/{slug}`, using this database's
+   *   branch (falling back to the HTTP client's current branch).
+   */
+  mcp(slug) {
+    const transport = {
+      rpc: (m, p) => this.client.mcpRpc(this.repository, this.schemaBranch(), slug, m, p),
+      subscribe: (m, p) => this.client.mcpSubscribe(this.repository, this.schemaBranch(), slug, m, p)
+    };
+    return new McpClient(transport);
+  }
+  /** Effective branch for management calls. */
+  schemaBranch() {
+    return this.branch ?? this.client.getBranch();
+  }
+  /** NodeType management (get/list/getResolved/create/update/delete/publish/unpublish). */
+  nodeTypes() {
+    return new HttpNodeTypes(this.repository, this.schemaBranch(), this.client);
+  }
+  /** Archetype management (get/list/getResolved/create/update/delete/publish/unpublish). */
+  archetypes() {
+    return new HttpArchetypes(this.repository, this.schemaBranch(), this.client);
+  }
+  /** ElementType management (get/list/getResolved/create/update/delete/publish/unpublish). */
+  elementTypes() {
+    return new HttpElementTypes(this.repository, this.schemaBranch(), this.client);
+  }
 };
 var HttpWorkspaceClient = class {
   constructor(repository, workspace, client) {
@@ -7067,10 +6750,13 @@ var HttpWorkspaceClient = class {
 };
 
 // src/client.ts
-var RaisinClient = class _RaisinClient extends EventEmitter3 {
+var _refreshingUser;
+var _RaisinClient = class _RaisinClient extends EventEmitter2 {
   constructor(url, options = {}) {
     super();
     this._currentUser = null;
+    /** In-flight role re-resolve, used to coalesce concurrent refreshCurrentUser() calls. */
+    __privateAdd(this, _refreshingUser, null);
     // Auth state change listeners (Firebase/Supabase pattern)
     this._authListeners = /* @__PURE__ */ new Set();
     this._userChangeListeners = /* @__PURE__ */ new Set();
@@ -7081,23 +6767,43 @@ var RaisinClient = class _RaisinClient extends EventEmitter3 {
     // Reconnection tracking
     this._previousConnectionState = "disconnected" /* Disconnected */;
     this._reconnectedListeners = /* @__PURE__ */ new Set();
+    this._everConnected = false;
+    // Requests queued while the connection is re-establishing.
+    // Flushed after reconnect + re-auth; bounded by MAX_QUEUED_REQUESTS.
+    this._queuedRequests = [];
+    /**
+     * Backoff delays (ms) between subscription-restore retries after reconnect.
+     * @internal - overridable in tests
+     */
+    this._restoreRetryDelaysMs = [1e3, 3e3, 9e3];
     // Upload manager (uses HTTP under the hood)
     this._uploadManager = null;
+    /** In-flight refresh shared by concurrent refreshToken() callers. */
+    this._refreshInFlight = null;
     if (options.logLevel !== void 0) {
       setLogLevel(options.logLevel);
     }
+    const connectionUrl = this.buildConnectionUrl(url, options.repository);
     this.options = {
       requestTimeout: options.requestTimeout ?? 3e4,
-      tenantId: options.tenantId ?? this.extractTenantFromUrl(url),
+      tenantId: options.tenantId ?? this.extractTenantFromUrl(connectionUrl),
       defaultBranch: options.defaultBranch ?? "main"
     };
-    this._httpBaseUrl = options.httpBaseUrl ?? this.deriveHttpUrl(url);
-    this._repository = this.extractRepositoryFromUrl(url);
+    this._httpBaseUrl = options.httpBaseUrl ?? this.deriveHttpUrl(connectionUrl);
+    this._repository = options.repository ?? this.extractRepositoryFromUrl(connectionUrl);
     this._context = {
       tenant_id: this.options.tenantId,
       branch: this.options.defaultBranch
     };
-    this.connection = new Connection(url, options.connection);
+    const explicitTenant = options.tenantId ?? (this.extractTenantFromUrl(url) !== "default" ? this.options.tenantId : void 0);
+    const connectionOptions = {
+      ...options.connection,
+      headers: {
+        ...explicitTenant ? { "x-tenant-id": explicitTenant } : {},
+        ...options.connection?.headers
+      }
+    };
+    this.connection = this.createConnection(connectionUrl, connectionOptions);
     this.requestTracker = new RequestTracker({
       defaultTimeout: this.options.requestTimeout
     });
@@ -7107,6 +6813,14 @@ var RaisinClient = class _RaisinClient extends EventEmitter3 {
     );
     this.setupConnectionHandlers();
   }
+  /**
+   * Create the underlying WebSocket connection.
+   * Seam for tests to inject a fake connection.
+   * @internal
+   */
+  createConnection(url, options) {
+    return new Connection(url, options);
+  }
   /**
    * Derive HTTP URL from WebSocket URL
    * ws://host:port/path -> http://host:port
@@ -7122,15 +6836,45 @@ var RaisinClient = class _RaisinClient extends EventEmitter3 {
       return "http://localhost:8081";
     }
   }
+  /**
+   * Build the WebSocket connection URL.
+   *
+   * When a repository option is provided and the URL carries no path
+   * (e.g. `ws://host:8081`), build the tenant-less `/ws/{repository}`
+   * route internally. URLs that already carry a path are used as-is.
+   */
+  buildConnectionUrl(url, repository) {
+    if (!repository) {
+      return url;
+    }
+    try {
+      const wsUrl = url.replace(/^raisin:\/\//, "ws://").replace(/^raisins:\/\//, "wss://");
+      const parsed = new URL(wsUrl);
+      const hasPath = parsed.pathname.split("/").some((p) => p.length > 0);
+      if (hasPath) {
+        return url;
+      }
+      return `${url.replace(/\/+$/, "")}/ws/${repository}`;
+    } catch {
+      return url;
+    }
+  }
   /**
    * Extract repository from URL
-   * URL format: raisin://host:port/tenant/repository or ws://host:port/tenant/repository
+   * URL forms: /ws/{repo} (tenant-less, preferred), /sys/{tenant}/{repo}
+   * (operator/multi-tenant), /{tenant}/{repo} (legacy).
    */
   extractRepositoryFromUrl(url) {
     try {
       const wsUrl = url.replace(/^raisin:\/\//, "ws://").replace(/^raisins:\/\//, "wss://");
       const parsed = new URL(wsUrl);
       const parts = parsed.pathname.split("/").filter((p) => p.length > 0);
+      if (parts[0] === "ws") {
+        return parts.length > 1 ? parts[1] : "";
+      }
+      if (parts[0] === "sys") {
+        return parts.length > 2 ? parts[2] : "";
+      }
       return parts.length > 1 ? parts[1] : "";
     } catch {
       return "";
@@ -7138,14 +6882,24 @@ var RaisinClient = class _RaisinClient extends EventEmitter3 {
   }
   /**
    * Extract tenant ID from URL
-   * URL format: raisin://host:port/tenant/repository or ws://host:port/tenant/repository
+   * URL forms: /ws/{repo} (tenant-less — no tenant in URL),
+   * /sys/{tenant}/{repo} (canonical), /{tenant}/{repo} (legacy).
+   * When the URL doesn't carry a tenant, fall back to 'default' — the
+   * server's tenant middleware resolves it anyway (production derives the
+   * tenant from the request itself), so an explicit tenantId is optional.
    */
   extractTenantFromUrl(url) {
     try {
       const wsUrl = url.replace(/^raisin:\/\//, "ws://").replace(/^raisins:\/\//, "wss://");
       const parsed = new URL(wsUrl);
       const parts = parsed.pathname.split("/").filter((p) => p.length > 0);
-      return parts.length > 0 ? parts[0] : "default";
+      if (parts[0] === "ws") {
+        return "default";
+      }
+      if (parts[0] === "sys") {
+        return parts.length > 1 ? parts[1] : "default";
+      }
+      return parts.length >= 2 ? parts[0] : "default";
     } catch (error) {
       return "default";
     }
@@ -7159,7 +6913,11 @@ var RaisinClient = class _RaisinClient extends EventEmitter3 {
     });
     this.connection.on("stateChange", (state) => {
       const wasDisconnected = this._previousConnectionState === "disconnected" /* Disconnected */ || this._previousConnectionState === "reconnecting" /* Reconnecting */;
+      if (state === "connected" /* Connected */) {
+        this._everConnected = true;
+      }
       if (state === "disconnected" /* Disconnected */ || state === "closed" /* Closed */) {
+        this._queuedRequests = [];
         this.requestTracker.cancelAll();
       }
       if (state === "connected" /* Connected */ && wasDisconnected && this._previousConnectionState !== "disconnected" /* Disconnected */) {
@@ -7190,8 +6948,13 @@ var RaisinClient = class _RaisinClient extends EventEmitter3 {
       if (isConnectedMessage(message)) {
         this.handleConnectedMessage(message);
       } else if (isEventMessage(message)) {
-        logger.debug(`Routing to event handler`);
-        this.eventHandler.handleEvent(message);
+        if (message.event_type === "permissions:changed") {
+          logger.info("[permissions:changed] server signaled a role/permission change; re-resolving");
+          void this.refreshCurrentUser();
+        } else {
+          logger.debug(`Routing to event handler`);
+          this.eventHandler.handleEvent(message);
+        }
       } else if (isResponseEnvelope(message)) {
         logger.debug(`Routing to response handler - request_id: ${message.request_id}, status: ${message.status}`);
         this.handleResponse(message);
@@ -7224,19 +6987,36 @@ var RaisinClient = class _RaisinClient extends EventEmitter3 {
         };
         logger.debug(`Anonymous user info stored: ${message.user_id}`);
         this._updateReadyState();
+        this._flushQueuedRequests();
         if (hasActiveSubscriptions) {
           this._restoreSubscriptionsAndNotify();
         }
       } else {
         logger.info(`[handleConnectedMessage] Stored token found, auto-authenticating...`);
-        this.autoReauthenticate().then(async () => {
+        this.autoReauthenticate().then(async (authenticated) => {
+          if (authenticated) {
+            this._flushQueuedRequests();
+          } else {
+            this._rejectQueuedRequests(
+              new RaisinAuthError(
+                "Re-authentication failed after reconnect",
+                "AUTH_TOKEN_EXPIRED",
+                401
+              )
+            );
+          }
           if (hasActiveSubscriptions) {
             await this._restoreSubscriptionsAndNotify();
           }
         }).catch((err) => {
           logger.error(`[handleConnectedMessage] Auto-authenticate failed:`, err);
+          this._rejectQueuedRequests(
+            err instanceof Error ? err : new Error("Re-authentication failed after reconnect")
+          );
         });
       }
+    } else {
+      this._flushQueuedRequests();
     }
     this.emit("connected", {
       connectionId: message.connection_id,
@@ -7245,18 +7025,41 @@ var RaisinClient = class _RaisinClient extends EventEmitter3 {
     });
   }
   /**
-   * Restore subscriptions after reconnection and notify listeners
+   * Restore subscriptions after reconnection and notify listeners.
+   *
+   * Retries with backoff (see `_restoreRetryDelaysMs`); on final failure a
+   * `subscription_restore_failed` event is emitted so applications can
+   * resync their state (e.g. reload lists and re-subscribe manually).
    * @internal
    */
   async _restoreSubscriptionsAndNotify() {
-    try {
-      logger.info("[_restoreSubscriptionsAndNotify] Restoring subscriptions...");
-      await this.eventHandler.restoreSubscriptions();
-      logger.info("[_restoreSubscriptionsAndNotify] Subscriptions restored successfully");
-      this._emitReconnected();
-    } catch (error) {
-      logger.error("[_restoreSubscriptionsAndNotify] Failed to restore subscriptions:", error);
+    const delays = this._restoreRetryDelaysMs;
+    let lastError;
+    for (let attempt = 0; attempt <= delays.length; attempt++) {
+      try {
+        logger.info(
+          `[_restoreSubscriptionsAndNotify] Restoring subscriptions (attempt ${attempt + 1}/${delays.length + 1})...`
+        );
+        await this.eventHandler.restoreSubscriptions({ retry: attempt > 0 });
+        logger.info("[_restoreSubscriptionsAndNotify] Subscriptions restored successfully");
+        this._emitReconnected();
+        return;
+      } catch (error) {
+        lastError = error;
+        logger.error(
+          `[_restoreSubscriptionsAndNotify] Restore attempt ${attempt + 1} failed:`,
+          error
+        );
+        if (attempt < delays.length) {
+          await new Promise((resolve) => setTimeout(resolve, delays[attempt]));
+        }
+      }
     }
+    logger.error("[_restoreSubscriptionsAndNotify] Giving up after retries; events may be stale");
+    this.emit(
+      "subscription_restore_failed",
+      lastError instanceof Error ? lastError : new Error(String(lastError))
+    );
   }
   /**
    * Emit reconnected event to all listeners
@@ -7275,13 +7078,15 @@ var RaisinClient = class _RaisinClient extends EventEmitter3 {
   }
   /**
    * Auto-reauthenticate with stored JWT on reconnection
+   *
+   * @returns true if the session was re-authenticated, false otherwise
    * @internal
    */
   async autoReauthenticate() {
     const token = this.authManager.storage.getAccessToken();
     if (!token) {
       logger.warn("[autoReauthenticate] No stored token");
-      return;
+      return false;
     }
     const payload = AuthManager.parseToken(token);
     if (payload?.exp && typeof payload.exp === "number") {
@@ -7293,18 +7098,20 @@ var RaisinClient = class _RaisinClient extends EventEmitter3 {
           this.authManager.clear();
           this._currentUser = null;
           this._emitAuthEvent("SESSION_EXPIRED");
-          return;
+          return false;
         }
         const newToken = this.authManager.storage.getAccessToken();
         if (newToken) {
           await this.authenticate({ type: "jwt", token: newToken });
+          return true;
         }
-        return;
+        return false;
       }
     }
     try {
       await this.authenticate({ type: "jwt", token });
       logger.info("[autoReauthenticate] Successfully re-authenticated");
+      return true;
     } catch (err) {
       logger.error("[autoReauthenticate] Failed to authenticate:", err);
       const refreshed = await this.refreshToken();
@@ -7312,11 +7119,14 @@ var RaisinClient = class _RaisinClient extends EventEmitter3 {
         const newToken = this.authManager.storage.getAccessToken();
         if (newToken) {
           await this.authenticate({ type: "jwt", token: newToken });
+          return true;
         }
+        return false;
       } else {
         this.authManager.clear();
         this._currentUser = null;
         this._emitAuthEvent("SESSION_EXPIRED");
+        return false;
       }
     }
   }
@@ -7432,18 +7242,18 @@ var RaisinClient = class _RaisinClient extends EventEmitter3 {
     }
     const url = `${this._httpBaseUrl}/auth/${repository}/login`;
     logger.debug("[loginWithEmail] POST", url);
-    const response = await fetch(url, {
+    const response = await this._fetchWithTimeout(url, {
       method: "POST",
       headers: { "Content-Type": "application/json" },
       body: JSON.stringify({ email, password })
     });
     if (!response.ok) {
       const error = await response.json().catch(() => ({ message: response.statusText }));
-      const authError = {
-        code: error.code || "LOGIN_FAILED",
-        message: error.message || "Login failed"
-      };
-      throw authError;
+      throw new RaisinAuthError(
+        error.message || "Login failed",
+        error.code || "LOGIN_FAILED",
+        response.status
+      );
     }
     const tokens = await response.json();
     logger.info("[loginWithEmail] HTTP login successful, user_id:", tokens.identity.id);
@@ -7472,11 +7282,11 @@ var RaisinClient = class _RaisinClient extends EventEmitter3 {
     }
     this._currentUser = {
       userId: user.id,
-      roles: [],
+      roles: this._currentUser?.roles ?? [],
       anonymous: false,
       node: userNode ?? void 0
     };
-    const expiresInMs = tokens.expires_at * 1e3 - Date.now() - 5 * 60 * 1e3;
+    const expiresInMs = _RaisinClient.expiresAtToMs(tokens.expires_at) - Date.now() - 5 * 60 * 1e3;
     if (expiresInMs > 0) {
       this.scheduleAutoRefresh(expiresInMs);
     }
@@ -7500,18 +7310,18 @@ var RaisinClient = class _RaisinClient extends EventEmitter3 {
   async registerWithEmail(email, password, repository, displayName) {
     logger.info("[registerWithEmail] Starting registration...");
     const url = `${this._httpBaseUrl}/auth/${repository}/register`;
-    const response = await fetch(url, {
+    const response = await this._fetchWithTimeout(url, {
       method: "POST",
       headers: { "Content-Type": "application/json" },
       body: JSON.stringify({ email, password, display_name: displayName })
     });
     if (!response.ok) {
       const error = await response.json().catch(() => ({ message: response.statusText }));
-      const authError = {
-        code: error.code || "REGISTRATION_FAILED",
-        message: error.message || "Registration failed"
-      };
-      throw authError;
+      throw new RaisinAuthError(
+        error.message || "Registration failed",
+        error.code || "REGISTRATION_FAILED",
+        response.status
+      );
     }
     const tokens = await response.json();
     logger.info("[registerWithEmail] Registration successful, user_id:", tokens.identity.id);
@@ -7538,11 +7348,11 @@ var RaisinClient = class _RaisinClient extends EventEmitter3 {
     }
     this._currentUser = {
       userId: user.id,
-      roles: [],
+      roles: this._currentUser?.roles ?? [],
       anonymous: false,
       node: userNode ?? void 0
     };
-    const expiresInMs = tokens.expires_at * 1e3 - Date.now() - 5 * 60 * 1e3;
+    const expiresInMs = _RaisinClient.expiresAtToMs(tokens.expires_at) - Date.now() - 5 * 60 * 1e3;
     if (expiresInMs > 0) {
       this.scheduleAutoRefresh(expiresInMs);
     }
@@ -7634,39 +7444,18 @@ var RaisinClient = class _RaisinClient extends EventEmitter3 {
     if (payload && payload.exp && typeof payload.exp === "number") {
       if (payload.exp * 1e3 < Date.now()) {
         logger.info("[initSession] Token expired, attempting refresh...");
-        const refreshToken = this.authManager.storage.getRefreshToken();
-        if (refreshToken) {
-          try {
-            const url = this._repository ? `${this._httpBaseUrl}/auth/${this._repository}/refresh` : `${this._httpBaseUrl}/auth/refresh`;
-            const response = await fetch(url, {
-              method: "POST",
-              headers: { "Content-Type": "application/json" },
-              body: JSON.stringify({ refresh_token: refreshToken })
-            });
-            if (response.ok) {
-              const tokens = await response.json();
-              this.authManager.storage.setAccessToken(tokens.access_token);
-              this.authManager.storage.setRefreshToken(tokens.refresh_token);
-              const expiresInMs = tokens.expires_at * 1e3 - Date.now() - 5 * 60 * 1e3;
-              if (expiresInMs > 0) {
-                this.scheduleAutoRefresh(expiresInMs);
-              }
-              logger.info("[initSession] Token refreshed successfully");
-            } else {
-              logger.warn("[initSession] Token refresh failed, clearing session");
-              this.authManager.clear();
-              return null;
-            }
-          } catch (err) {
-            logger.warn("[initSession] Token refresh error:", err);
-            this.authManager.clear();
-            return null;
-          }
-        } else {
+        if (!this.authManager.storage.getRefreshToken()) {
           logger.warn("[initSession] No refresh token, clearing session");
           this.authManager.clear();
           return null;
         }
+        const refreshed = await this.refreshToken();
+        if (!refreshed) {
+          logger.warn("[initSession] Token refresh failed, clearing session");
+          this.authManager.clear();
+          return null;
+        }
+        logger.info("[initSession] Token refreshed successfully");
       }
     }
     try {
@@ -7700,7 +7489,7 @@ var RaisinClient = class _RaisinClient extends EventEmitter3 {
         }
         this._currentUser = {
           userId: user.id,
-          roles: [],
+          roles: this._currentUser?.roles ?? [],
           anonymous: false,
           node: userNode ?? void 0
         };
@@ -7756,6 +7545,16 @@ var RaisinClient = class _RaisinClient extends EventEmitter3 {
    * @throws Error if no refresh token is stored or refresh fails
    */
   async refreshToken() {
+    if (this._refreshInFlight) {
+      logger.debug("[refreshToken] Refresh already in flight, awaiting it");
+      return this._refreshInFlight;
+    }
+    this._refreshInFlight = this._refreshToken().finally(() => {
+      this._refreshInFlight = null;
+    });
+    return this._refreshInFlight;
+  }
+  async _refreshToken() {
     const refreshToken = this.authManager.storage.getRefreshToken();
     if (!refreshToken) {
       logger.warn("[refreshToken] No refresh token available");
@@ -7764,7 +7563,7 @@ var RaisinClient = class _RaisinClient extends EventEmitter3 {
     try {
       logger.info("[refreshToken] Refreshing access token...");
       const url = this._repository ? `${this._httpBaseUrl}/auth/${this._repository}/refresh` : `${this._httpBaseUrl}/auth/refresh`;
-      const response = await fetch(url, {
+      const response = await this._fetchWithTimeout(url, {
         method: "POST",
         headers: { "Content-Type": "application/json" },
         body: JSON.stringify({ refresh_token: refreshToken })
@@ -7772,6 +7571,11 @@ var RaisinClient = class _RaisinClient extends EventEmitter3 {
       if (!response.ok) {
         const errorText = await response.text();
         logger.error("[refreshToken] Refresh failed:", response.status, errorText);
+        if (/TOKEN_REUSE_DETECTED|TOKEN_FAMILY_MISMATCH/.test(errorText)) {
+          logger.error(
+            "[refreshToken] Session revoked by the server as a suspected token replay. If this happened on a normal page load, two refreshes raced on the same token."
+          );
+        }
         if (response.status === 401 || response.status === 403) {
           this.authManager.clear();
           this._currentUser = null;
@@ -7794,7 +7598,7 @@ var RaisinClient = class _RaisinClient extends EventEmitter3 {
       if (this.authManager.storage instanceof LocalStorageTokenStorage) {
         this.authManager.storage.setUser(user);
       }
-      const expiresInMs = tokens.expires_at * 1e3 - Date.now() - 5 * 60 * 1e3;
+      const expiresInMs = _RaisinClient.expiresAtToMs(tokens.expires_at) - Date.now() - 5 * 60 * 1e3;
       if (expiresInMs > 0) {
         this.scheduleAutoRefresh(expiresInMs);
       }
@@ -7807,6 +7611,53 @@ var RaisinClient = class _RaisinClient extends EventEmitter3 {
       return null;
     }
   }
+  /**
+   * Fetch with a timeout derived from `requestTimeout`.
+   *
+   * Aborts the request after `requestTimeout` ms and rejects with a
+   * `RaisinTimeoutError`. If the caller provides its own AbortSignal in
+   * `init.signal`, it is respected: an external abort rejects with the
+   * original AbortError instead of a timeout error.
+   * @internal
+   */
+  async _fetchWithTimeout(url, init = {}) {
+    const timeoutMs = this.options.requestTimeout;
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    const externalSignal = init.signal ?? void 0;
+    if (externalSignal) {
+      if (externalSignal.aborted) {
+        controller.abort();
+      } else {
+        externalSignal.addEventListener("abort", () => controller.abort(), { once: true });
+      }
+    }
+    try {
+      return await fetch(url, { ...init, signal: controller.signal });
+    } catch (error) {
+      if (error instanceof Error && error.name === "AbortError" && !externalSignal?.aborted) {
+        throw new RaisinTimeoutError(
+          `Request to ${url} timed out after ${timeoutMs}ms`,
+          "REQUEST_TIMEOUT",
+          timeoutMs
+        );
+      }
+      throw error;
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+  /**
+   * Normalize a token `expires_at` value to epoch milliseconds.
+   *
+   * Server endpoints are inconsistent: some return seconds, others
+   * milliseconds. Anything above 1e11 can't be a seconds-epoch (year 5138),
+   * so treat it as milliseconds.
+   * @internal
+   */
+  static expiresAtToMs(expiresAt) {
+    return expiresAt > 1e11 ? expiresAt : expiresAt * 1e3;
+  }
   /**
    * Schedule automatic token refresh
    * @internal
@@ -7815,11 +7666,12 @@ var RaisinClient = class _RaisinClient extends EventEmitter3 {
     if (this._refreshTimer) {
       clearTimeout(this._refreshTimer);
     }
-    logger.debug(`[scheduleAutoRefresh] Scheduling refresh in ${Math.round(delayMs / 1e3 / 60)} minutes`);
+    const clamped = Math.min(Math.max(delayMs, 3e4), 2147483647);
+    logger.debug(`[scheduleAutoRefresh] Scheduling refresh in ${Math.round(clamped / 1e3 / 60)} minutes`);
     this._refreshTimer = setTimeout(async () => {
       logger.info("[autoRefresh] Auto-refreshing token...");
       await this.refreshToken();
-    }, delayMs);
+    }, clamped);
   }
   /**
    * Get a database/repository interface
@@ -7843,10 +7695,26 @@ var RaisinClient = class _RaisinClient extends EventEmitter3 {
   }
   /**
    * Send a request to the server
+   *
+   * If the connection is temporarily down (connecting/reconnecting, or
+   * disconnected with auto-reconnect enabled), the request is queued and
+   * flushed once the connection is re-established and re-authenticated.
+   * Queued requests are still subject to their own request timeout, and the
+   * queue is bounded (overflow rejects immediately).
    */
   async sendRequestInternal(payload, requestType, contextOverride, requestOptions) {
-    if (!this.connection.isConnected()) {
-      throw new Error("Not connected to server");
+    const connected = this.connection.isConnected();
+    if (!connected) {
+      const state = this.connection.getState();
+      const willReconnect = state === "connecting" /* Connecting */ || state === "reconnecting" /* Reconnecting */ || state === "disconnected" /* Disconnected */ && this._everConnected && this.connection.isAutoReconnectEnabled();
+      if (!willReconnect) {
+        throw new Error("Not connected to server");
+      }
+      if (this._queuedRequests.length >= _RaisinClient.MAX_QUEUED_REQUESTS) {
+        throw new Error(
+          `Request queue is full (${_RaisinClient.MAX_QUEUED_REQUESTS} requests pending while reconnecting)`
+        );
+      }
     }
     const requestId = this.requestTracker.generateRequestId();
     const context = contextOverride || this._context;
@@ -7865,8 +7733,15 @@ var RaisinClient = class _RaisinClient extends EventEmitter3 {
     try {
       const encoded = encodeMessage(request);
       logger.debug(`Encoded request - ID: ${requestId}, type: ${requestType}, size: ${encoded.length} bytes`);
-      this.connection.send(encoded);
-      logger.debug(`Request sent - ID: ${requestId}`);
+      if (connected) {
+        this.connection.send(encoded);
+        logger.debug(`Request sent - ID: ${requestId}`);
+      } else {
+        this._queuedRequests.push({ requestId, encoded });
+        logger.debug(
+          `Request queued while reconnecting - ID: ${requestId}, queue size: ${this._queuedRequests.length}`
+        );
+      }
     } catch (error) {
       logger.error(`Failed to send request - ID: ${requestId}:`, error);
       this.requestTracker.rejectRequest(
@@ -7877,6 +7752,42 @@ var RaisinClient = class _RaisinClient extends EventEmitter3 {
     }
     return responsePromise;
   }
+  /**
+   * Flush requests queued while the connection was re-establishing.
+   * Called after the connection is connected and (re-)authenticated.
+   * @internal
+   */
+  _flushQueuedRequests() {
+    if (this._queuedRequests.length === 0) return;
+    const queued = this._queuedRequests;
+    this._queuedRequests = [];
+    logger.info(`[_flushQueuedRequests] Flushing ${queued.length} queued request(s)`);
+    for (const { requestId, encoded } of queued) {
+      if (!this.requestTracker.hasPendingRequest(requestId)) continue;
+      try {
+        this.connection.send(encoded);
+      } catch (error) {
+        this.requestTracker.rejectRequest(
+          requestId,
+          error instanceof Error ? error : new Error("Failed to send queued request")
+        );
+      }
+    }
+  }
+  /**
+   * Reject all requests queued while the connection was re-establishing
+   * (e.g. re-authentication failed after reconnect).
+   * @internal
+   */
+  _rejectQueuedRequests(error) {
+    if (this._queuedRequests.length === 0) return;
+    const queued = this._queuedRequests;
+    this._queuedRequests = [];
+    logger.warn(`[_rejectQueuedRequests] Rejecting ${queued.length} queued request(s): ${error.message}`);
+    for (const { requestId } of queued) {
+      this.requestTracker.rejectRequest(requestId, error);
+    }
+  }
   /**
    * Get the HTTP base URL derived from the WebSocket URL
    */
@@ -7954,6 +7865,44 @@ var RaisinClient = class _RaisinClient extends EventEmitter3 {
   getCurrentUser() {
     return this._currentUser;
   }
+  /**
+   * Re-resolve the current user's EFFECTIVE roles from the server and refresh
+   * `getCurrentUser()`.
+   *
+   * Roles are deliberately not embedded in the JWT (they are resolved live
+   * server-side), so when an admin changes a user's roles/groups the token does
+   * not change — the client must re-ask. This re-runs the WS JWT auth handshake
+   * (which returns freshly resolved effective roles), updates `_currentUser`, and
+   * emits `USER_UPDATED` so role-gated UI can react without a reload.
+   *
+   * Called automatically when the server pushes `permissions:changed` after an
+   * access-control write, and exposed for on-demand refresh. Safe no-op when not
+   * authenticated.
+   */
+  async refreshCurrentUser() {
+    if (__privateGet(this, _refreshingUser)) return __privateGet(this, _refreshingUser);
+    const token = this.authManager.storage.getAccessToken();
+    if (!token) return;
+    __privateSet(this, _refreshingUser, (async () => {
+      const before = JSON.stringify(this._currentUser?.roles ?? null);
+      const prevNode = this._currentUser?.node;
+      try {
+        await this.authenticate({ type: "jwt", token });
+        if (this._currentUser && prevNode && !this._currentUser.node) {
+          this._currentUser.node = prevNode;
+        }
+        const after = JSON.stringify(this._currentUser?.roles ?? null);
+        if (after !== before) {
+          this._emitAuthEvent("USER_UPDATED");
+        }
+      } catch (err) {
+        logger.warn("[refreshCurrentUser] role re-resolve failed:", err);
+      } finally {
+        __privateSet(this, _refreshingUser, null);
+      }
+    })());
+    return __privateGet(this, _refreshingUser);
+  }
   /**
    * Get current user ID
    *
@@ -8162,7 +8111,10 @@ var RaisinClient = class _RaisinClient extends EventEmitter3 {
   _emitAuthEvent(event) {
     const session = {
       user: this.getStoredUser(),
-      accessToken: this.authManager.storage.getAccessToken()
+      accessToken: this.authManager.storage.getAccessToken(),
+      // Surface effective roles so role-gated consumers can react to
+      // SIGNED_IN / USER_UPDATED without calling getCurrentUser() themselves.
+      roles: this._currentUser?.roles ?? null
     };
     const change = { event, session };
     for (const callback of this._authListeners) {
@@ -8202,6 +8154,7 @@ var RaisinClient = class _RaisinClient extends EventEmitter3 {
    */
   async _subscribeToUserHome(repository, userHome) {
     await this._unsubscribeFromUserHome();
+    userHome = normalizeHomePath(userHome) ?? userHome;
     try {
       const db = this.database(repository);
       const pathParts = userHome.split("/").filter((p) => p.length > 0);
@@ -8254,12 +8207,12 @@ var RaisinClient = class _RaisinClient extends EventEmitter3 {
    * @param config - Repository configuration
    * @returns Repository creation result
    */
-  async createRepository(repositoryId, description, config2) {
+  async createRepository(repositoryId, description, config) {
     return this.sendRequestInternal(
       {
         repository_id: repositoryId,
         description,
-        config: config2
+        config
       },
       "repository_create" /* RepositoryCreate */
     );
@@ -8298,12 +8251,12 @@ var RaisinClient = class _RaisinClient extends EventEmitter3 {
    * @param config - New repository configuration
    * @returns Repository update result
    */
-  async updateRepository(repositoryId, description, config2) {
+  async updateRepository(repositoryId, description, config) {
     return this.sendRequestInternal(
       {
         repository_id: repositoryId,
         description,
-        config: config2
+        config
       },
       "repository_update" /* RepositoryUpdate */
     );
@@ -8501,7 +8454,7 @@ var RaisinClient = class _RaisinClient extends EventEmitter3 {
     const branch = options.branch ?? this._context.branch ?? "main";
     const pathWithProperty = options.propertyPath ? `${options.path}@${options.propertyPath}` : options.path;
     const endpoint = `/api/repository/${options.repository}/${branch}/head/${options.workspace}${pathWithProperty}/raisin:sign`;
-    const response = await fetch(`${this._httpBaseUrl}${endpoint}`, {
+    const response = await this._fetchWithTimeout(`${this._httpBaseUrl}${endpoint}`, {
       method: "POST",
       headers: {
         "Content-Type": "application/json",
@@ -8556,6 +8509,10 @@ var RaisinClient = class _RaisinClient extends EventEmitter3 {
     return _RaisinClient.forSSR(baseUrl, options);
   }
 };
+_refreshingUser = new WeakMap();
+/** Hard cap on requests held while reconnecting; overflow rejects immediately. */
+_RaisinClient.MAX_QUEUED_REQUESTS = 100;
+var RaisinClient = _RaisinClient;
 
 // src/node-builder.ts
 var NodeBuilder = class _NodeBuilder {
@@ -8840,17 +8797,17 @@ var NodeEventType = {
 var AllNodeEventTypes = Object.values(NodeEventType);
 
 // src/integrations/react-router.ts
-function createSSRClient(config2) {
-  const client = RaisinClient.forSSR(config2.httpBaseUrl, config2.httpOptions);
-  if (config2.credentials) {
+function createSSRClient(config) {
+  const client = RaisinClient.forSSR(config.httpBaseUrl, config.httpOptions);
+  if (config.credentials) {
   }
   return client;
 }
-function createLoader(config2, loaderFn) {
+function createLoader(config, loaderFn) {
   return async (args) => {
-    const client = createSSRClient(config2);
-    if (config2.credentials) {
-      await client.authenticate(config2.credentials);
+    const client = createSSRClient(config);
+    if (config.credentials) {
+      await client.authenticate(config.credentials);
     }
     try {
       return await loaderFn(client, args);
@@ -8890,1846 +8847,27 @@ function isTerminalEvent(event) {
   return event.type === "flow_completed" || event.type === "flow_failed";
 }
 
-// src/utils/plan-projection.ts
-function asRecord(value) {
-  if (!value || typeof value !== "object" || Array.isArray(value)) return null;
-  return value;
-}
-function asString(value) {
-  return typeof value === "string" && value.length > 0 ? value : void 0;
-}
-function parsePlanTasks(rawTasks) {
-  if (!Array.isArray(rawTasks)) return [];
-  return rawTasks.map((rawTask, index) => {
-    if (typeof rawTask === "string") {
-      return {
-        title: rawTask,
-        status: "pending"
-      };
-    }
-    const task = asRecord(rawTask);
-    if (!task) return null;
-    return {
-      taskId: asString(task.task_id) ?? asString(task.id),
-      title: asString(task.title) ?? `Task ${index + 1}`,
-      status: asString(task.status) ?? "pending",
-      description: asString(task.description),
-      priority: asString(task.priority)
-    };
-  }).filter((task) => task !== null);
-}
-function upsertTask(plan, nextTask) {
-  const existingIndex = plan.tasks.findIndex(
-    (task) => nextTask.taskId && task.taskId === nextTask.taskId || !nextTask.taskId && task.title === nextTask.title
-  );
-  if (existingIndex === -1) {
-    plan.tasks.push(nextTask);
-    return;
-  }
-  plan.tasks[existingIndex] = {
-    ...plan.tasks[existingIndex],
-    ...nextTask
-  };
+// src/types/flow-definition.ts
+function getRefDisplayName(ref) {
+  const path = ref["raisin:path"] || ref["raisin:ref"];
+  const segments = path.split("/").filter(Boolean);
+  return segments[segments.length - 1] || path;
 }
-function ensurePlan(plans, key, fallbackTitle, timestamp) {
-  const existing = plans.get(key);
-  if (existing) {
-    if (timestamp) existing.updatedAt = timestamp;
-    return existing;
-  }
-  const created = {
-    key,
-    title: fallbackTitle,
-    status: "pending_approval",
-    requiresApproval: true,
-    tasks: [],
-    updatedAt: timestamp
-  };
-  plans.set(key, created);
-  return created;
+function getRefPath(ref) {
+  return ref["raisin:path"] || ref["raisin:ref"];
 }
-function projectPlansFromMessages(messages) {
-  const ordered = [...messages].sort((a, b) => {
-    const aTime = Date.parse(a.timestamp || "");
-    const bTime = Date.parse(b.timestamp || "");
-    return (Number.isNaN(aTime) ? 0 : aTime) - (Number.isNaN(bTime) ? 0 : bTime);
-  });
-  const plans = /* @__PURE__ */ new Map();
-  for (const message of ordered) {
-    const timestamp = message.timestamp;
-    const data = asRecord(message.data);
-    if (message.messageType === "ai_plan" && data) {
-      const planPath = asString(data.plan_path);
-      const planId = asString(data.plan_id);
-      const key = planPath || planId || message.path || message.id || `plan:${timestamp}`;
-      const plan = ensurePlan(
-        plans,
-        key,
-        asString(data.title) || message.content || "Plan",
-        timestamp
-      );
-      plan.planPath = planPath ?? plan.planPath;
-      plan.planId = planId ?? plan.planId;
-      plan.title = asString(data.title) || plan.title;
-      plan.status = asString(data.status) || plan.status;
-      plan.requiresApproval = Boolean(data.requires_approval) || plan.status === "pending_approval";
-      plan.sourceMessagePath = message.path ?? plan.sourceMessagePath;
-      const parsedTasks = parsePlanTasks(data.tasks);
-      if (parsedTasks.length > 0) {
-        plan.tasks = parsedTasks;
-      }
-    }
-    if (message.messageType === "ai_task_update" && data) {
-      const planPath = asString(data.plan_path);
-      const planId = asString(data.plan_id);
-      const key = planPath || planId;
-      if (!key) continue;
-      const plan = ensurePlan(plans, key, "Plan", timestamp);
-      plan.planPath = planPath ?? plan.planPath;
-      plan.planId = planId ?? plan.planId;
-      plan.status = asString(data.plan_status) || plan.status;
-      plan.requiresApproval = plan.status === "pending_approval";
-      const taskUpdate = {
-        taskId: asString(data.task_id),
-        title: asString(data.task_title) || asString(data.title) || "Task",
-        status: asString(data.status) || "pending"
-      };
-      upsertTask(plan, taskUpdate);
-    }
-    if (Array.isArray(message.children)) {
-      for (const child of message.children) {
-        if (child.type !== "plan") continue;
-        const key = child.path || message.path || message.id || `plan-child:${child.id}:${timestamp}`;
-        const plan = ensurePlan(plans, key, child.planTitle || message.content || "Plan", timestamp);
-        plan.title = child.planTitle || plan.title;
-        plan.status = child.status || plan.status;
-        plan.requiresApproval = plan.status === "pending_approval";
-        if (Array.isArray(child.tasks) && child.tasks.length > 0) {
-          plan.tasks = child.tasks.map((task) => ({
-            taskId: task.id,
-            title: task.title,
-            status: task.status
-          }));
-        }
-      }
-    }
-  }
-  return [...plans.values()].sort((a, b) => {
-    const aTime = Date.parse(a.updatedAt || "");
-    const bTime = Date.parse(b.updatedAt || "");
-    return (Number.isNaN(bTime) ? 0 : bTime) - (Number.isNaN(aTime) ? 0 : aTime);
-  });
+var RETRY_STRATEGIES = {
+  none: { max_retries: 0, base_delay_ms: 0, max_delay_ms: 0 },
+  quick: { max_retries: 3, base_delay_ms: 1e3, max_delay_ms: 1e4 },
+  standard: { max_retries: 5, base_delay_ms: 2e3, max_delay_ms: 6e4 },
+  aggressive: { max_retries: 10, base_delay_ms: 5e3, max_delay_ms: 12e4 },
+  llm: { max_retries: 5, base_delay_ms: 1e4, max_delay_ms: 12e4 }
+};
+function isFlowDefinitionStep(node) {
+  return node.node_type === "raisin:FlowStep";
 }
-
-// src/stores/conversation-store.ts
-var ConversationStore = class {
-  constructor(options) {
-    this.subscribers = /* @__PURE__ */ new Set();
-    // Persistent SSE subscription
-    this.subscription = null;
-    this._messages = [];
-    this._isStreaming = false;
-    this._isWaiting = false;
-    this._streamingText = "";
-    this._error = null;
-    this._activeToolCalls = [];
-    this._isLoading = false;
-    this._conversationType = null;
-    this._streamingTimer = null;
-    this._watchdogTimer = null;
-    this.manager = options.database.conversations;
-    this._conversationPath = options.conversationPath ?? null;
-    this.createOptions = options.createOptions;
-    this.onEvent = options.onEvent;
-    this._streamingTimeoutMs = options.streamingTimeoutMs ?? 12e4;
-    this._watchdogIntervalMs = options.watchdogIntervalMs ?? 3e4;
-    if (this._conversationPath) {
-      this.ensureSubscription();
-    }
-  }
-  // ==========================================================================
-  // Subscription
-  // ==========================================================================
-  /**
-   * Subscribe to state changes.
-   * Returns an unsubscribe function.
-   */
-  subscribe(callback) {
-    this.subscribers.add(callback);
-    callback(this.getSnapshot());
-    return () => {
-      this.subscribers.delete(callback);
-    };
-  }
-  /**
-   * Get the current state snapshot.
-   */
-  getSnapshot() {
-    return {
-      conversation: this._conversationPath ? { conversationPath: this._conversationPath, type: this._conversationType || "ai_chat" } : null,
-      messages: [...this._messages],
-      isStreaming: this._isStreaming,
-      isWaiting: this._isWaiting,
-      streamingText: this._streamingText,
-      error: this._error,
-      activeToolCalls: [...this._activeToolCalls],
-      plans: projectPlansFromMessages(this._messages),
-      isLoading: this._isLoading,
-      conversationPath: this._conversationPath
-    };
-  }
-  // ==========================================================================
-  // Actions
-  // ==========================================================================
-  /**
-   * Send a user message and stream the AI response.
-   *
-   * If no conversation exists yet and `createOptions` was provided,
-   * the conversation is created automatically on the first call.
-   */
-  async sendMessage(content) {
-    if (this._isStreaming) {
-      logger.warn("[ConversationStore] Cannot send message while streaming");
-      return;
-    }
-    logger.info("[ConversationStore] Sending message", { path: this._conversationPath });
-    this._error = null;
-    if (!this._conversationPath) {
-      if (!this.createOptions) {
-        throw new Error("No conversationPath and no createOptions provided");
-      }
-      try {
-        const convo = await this.manager.create({
-          participant: this.createOptions.participant,
-          input: this.createOptions.input
-        });
-        this._conversationPath = convo.conversationPath;
-        this._conversationType = convo.type;
-        for (const event of convo.initialEvents ?? []) {
-          this.onEvent?.(event);
-          this.handleEvent(event);
-        }
-        this.notify();
-      } catch (err) {
-        this._error = err instanceof Error ? err.message : String(err);
-        this.notify();
-        return;
-      }
-    }
-    const userMessage = {
-      role: "user",
-      content,
-      timestamp: (/* @__PURE__ */ new Date()).toISOString()
-    };
-    this._messages.push(userMessage);
-    this._isStreaming = true;
-    this._isWaiting = false;
-    this._streamingText = "";
-    this._activeToolCalls = [];
-    this.resetStreamingTimer();
-    this.startWatchdog();
-    this.notify();
-    try {
-      this.ensureSubscription();
-      await this.subscription.waitUntilConnected();
-      await this.manager.createUserMessage(this._conversationPath, content);
-    } catch (err) {
-      logger.error("[ConversationStore] Send failed", err);
-      this._error = err instanceof Error ? err.message : String(err);
-      this._isStreaming = false;
-      this.clearStreamingTimer();
-      this.stopWatchdog();
-      this.notify();
-    }
-  }
-  /**
-   * Load messages from the persisted node tree.
-   * Useful for loading history on page reload.
-   */
-  async loadMessages() {
-    if (!this._conversationPath) return [];
-    this._isLoading = true;
-    this.notify();
-    try {
-      const messages = await this.manager.getMessages(this._conversationPath);
-      logger.debug(`[ConversationStore] Loaded ${messages.length} messages`);
-      if (messages.length > 0) {
-        this._messages = messages;
-        this._activeToolCalls = [];
-      }
-      return messages;
-    } finally {
-      this._isLoading = false;
-      this.notify();
-    }
-  }
-  /**
-   * Approve a pending plan.
-   */
-  async approvePlan(planPath) {
-    await this.manager.approvePlan(planPath);
-  }
-  /**
-   * Reject a pending plan.
-   */
-  async rejectPlan(planPath, feedback) {
-    await this.manager.rejectPlan(planPath, feedback);
-  }
-  /**
-   * Mark a single message as read.
-   */
-  async markMessageAsRead(messagePath) {
-    await this.manager.markMessageAsRead(messagePath);
-  }
-  /**
-   * Stop the current streaming response.
-   */
-  stop() {
-    this._isStreaming = false;
-    this.clearStreamingTimer();
-    this.stopWatchdog();
-    this.notify();
-  }
-  /**
-   * Clean up the store and release resources.
-   */
-  destroy() {
-    this.stop();
-    this.clearStreamingTimer();
-    this.stopWatchdog();
-    this.subscription?.unsubscribe();
-    this.subscription = null;
-    this.subscribers.clear();
-  }
-  /**
-   * Get the conversation path.
-   */
-  getConversationPath() {
-    return this._conversationPath;
-  }
-  // ==========================================================================
-  // Internal
-  // ==========================================================================
-  ensureSubscription() {
-    if (this.subscription) return;
-    if (!this._conversationPath) return;
-    this.subscription = this.manager.subscribe(
-      this._conversationPath,
-      (event) => {
-        this.onEvent?.(event);
-        this.handleEvent(event);
-      }
-    );
-  }
-  handleEvent(event) {
-    logger.debug("[ConversationStore] SSE:", event.type);
-    if (this._isStreaming) {
-      this.resetStreamingTimer();
-    }
-    switch (event.type) {
-      case "text_chunk":
-        this._streamingText += event.text;
-        this.notify();
-        break;
-      case "thought_chunk":
-        this.notify();
-        break;
-      case "assistant_message":
-        this._messages.push(event.message);
-        this._streamingText = "";
-        this.notify();
-        break;
-      case "tool_call_started": {
-        logger.debug("[ConversationStore] Tool started:", event.functionName);
-        const info = {
-          id: event.toolCallId,
-          functionName: event.functionName,
-          arguments: event.arguments,
-          status: "running"
-        };
-        this._activeToolCalls.push(info);
-        this.notify();
-        break;
-      }
-      case "tool_call_completed": {
-        logger.debug("[ConversationStore] Tool completed:", event.toolCallId);
-        const idx = this._activeToolCalls.findIndex((tc) => tc.id === event.toolCallId);
-        if (idx >= 0) {
-          this._activeToolCalls[idx] = {
-            ...this._activeToolCalls[idx],
-            status: event.error ? "failed" : "completed",
-            result: event.result,
-            durationMs: event.durationMs
-          };
-        }
-        this.notify();
-        break;
-      }
-      case "waiting": {
-        logger.info("[ConversationStore] Waiting for input");
-        this.flushStreamingText(event.timestamp);
-        this._isStreaming = false;
-        this._isWaiting = true;
-        this._activeToolCalls = [];
-        this.clearStreamingTimer();
-        this.stopWatchdog();
-        this.notify();
-        this.deferredReload();
-        break;
-      }
-      case "done": {
-        if (isRecoveredDoneEvent(event)) {
-          logger.debug("[ConversationStore] Ignoring recovered done event");
-          this.reconcileRecoveredDone();
-          break;
-        }
-        const doneEvent = event;
-        if (doneEvent.dispatchPhase && doneEvent.dispatchPhase !== "terminal") {
-          logger.debug("[ConversationStore] Ignoring non-terminal done event");
-          break;
-        }
-        logger.info("[ConversationStore] Turn done");
-        this.flushStreamingText(event.timestamp);
-        if (doneEvent.content && !this.lastMessageIsAssistant()) {
-          this._messages.push({
-            role: doneEvent.role || "assistant",
-            content: doneEvent.content,
-            timestamp: event.timestamp,
-            senderDisplayName: doneEvent.senderDisplayName,
-            finishReason: doneEvent.finishReason
-          });
-        }
-        this._isStreaming = false;
-        this._isWaiting = true;
-        this._activeToolCalls = [];
-        this.clearStreamingTimer();
-        this.stopWatchdog();
-        this.notify();
-        this.deferredReload();
-        break;
-      }
-      case "completed": {
-        this.flushStreamingText(event.timestamp);
-        if (event.messages && event.messages.length > 0) {
-          this._messages = event.messages;
-        }
-        this._isStreaming = false;
-        this._isWaiting = false;
-        this._activeToolCalls = [];
-        this.clearStreamingTimer();
-        this.stopWatchdog();
-        this.notify();
-        this.deferredReload();
-        break;
-      }
-      case "failed":
-        logger.error("[ConversationStore] Turn failed", event.error);
-        this._error = event.error;
-        this._isStreaming = false;
-        this._streamingText = "";
-        this._activeToolCalls = [];
-        this.clearStreamingTimer();
-        this.stopWatchdog();
-        this.notify();
-        break;
-      case "conversation_created":
-        this._conversationPath = event.conversationPath;
-        this.notify();
-        break;
-      case "message_saved":
-        this.silentReload().catch(() => {
-        });
-        this.notify();
-        break;
-      case "message_delivered":
-        this._messages.push(event.message);
-        this.notify();
-        break;
-      case "log": {
-        const logEvent = event;
-        const currentLevel = getLogLevel();
-        const levelMap = {
-          debug: 4 /* Debug */,
-          info: 3 /* Info */,
-          warn: 2 /* Warn */,
-          error: 1 /* Error */
-        };
-        const eventLevel = levelMap[logEvent.level] ?? 4 /* Debug */;
-        if (currentLevel >= eventLevel) {
-          const fn = logEvent.level === "error" ? console.error : logEvent.level === "warn" ? console.warn : logEvent.level === "debug" ? console.debug : console.info;
-          fn("[server]", logEvent.message);
-        }
-        break;
-      }
-    }
-  }
-  /**
-   * If accumulated streaming text hasn't been captured in an assistant_message,
-   * synthesize one.
-   */
-  flushStreamingText(timestamp) {
-    if (this._streamingText && !this.lastMessageIsAssistant()) {
-      this._messages.push({
-        role: "assistant",
-        content: this._streamingText,
-        timestamp
-      });
-    }
-    this._streamingText = "";
-  }
-  lastMessageIsAssistant() {
-    const last = this._messages[this._messages.length - 1];
-    return last?.role === "assistant";
-  }
-  /**
-   * After a turn completes, reload canonical messages from the node tree
-   * to catch any events missed during SSE gaps.
-   */
-  deferredReload() {
-    if (!this._conversationPath) return;
-    logger.debug("[ConversationStore] Scheduling deferred reload");
-    const attemptReload = (delay, retriesLeft) => {
-      setTimeout(async () => {
-        try {
-          const prevCount = this._messages.length;
-          await this.silentReload();
-          if (this._messages.length === prevCount && retriesLeft > 0) {
-            attemptReload(delay * 2, retriesLeft - 1);
-          }
-        } catch {
-        }
-      }, delay);
-    };
-    attemptReload(500, 2);
-  }
-  async silentReload() {
-    if (!this._conversationPath) return;
-    try {
-      const fresh = await this.manager.getMessages(this._conversationPath);
-      if (fresh.length === 0) return;
-      let matchCount = 0;
-      const limit = Math.min(this._messages.length, fresh.length);
-      for (let i = 0; i < limit; i++) {
-        if (this._messages[i].role !== fresh[i].role || this._messages[i].content !== fresh[i].content) break;
-        matchCount++;
-      }
-      if (matchCount === this._messages.length && fresh.length === matchCount) {
-        for (let i = 0; i < matchCount; i++) {
-          const f = fresh[i];
-          const e = this._messages[i];
-          if (f.id) e.id = f.id;
-          if (f.path) e.path = f.path;
-          if (f.messageType) e.messageType = f.messageType;
-          if (f.data) e.data = f.data;
-          if (f.children) e.children = f.children;
-          if (f.finishReason) e.finishReason = f.finishReason;
-        }
-        await this.rebuildToolCallState();
-        return;
-      }
-      if (matchCount === this._messages.length && fresh.length > matchCount) {
-        for (let i = matchCount; i < fresh.length; i++) {
-          this._messages.push(fresh[i]);
-        }
-        for (let i = 0; i < matchCount; i++) {
-          const f = fresh[i];
-          const e = this._messages[i];
-          if (f.id) e.id = f.id;
-          if (f.path) e.path = f.path;
-          if (f.messageType) e.messageType = f.messageType;
-          if (f.data) e.data = f.data;
-          if (f.children) e.children = f.children;
-        }
-        await this.rebuildToolCallState();
-        this.notify();
-        return;
-      }
-      if (matchCount === fresh.length && fresh.length < this._messages.length) {
-        for (let i = 0; i < matchCount; i++) {
-          const f = fresh[i];
-          const e = this._messages[i];
-          if (f.id) e.id = f.id;
-          if (f.path) e.path = f.path;
-          if (f.messageType) e.messageType = f.messageType;
-          if (f.data) e.data = f.data;
-          if (f.children) e.children = f.children;
-        }
-        await this.rebuildToolCallState();
-        return;
-      }
-      this._messages = fresh;
-      await this.rebuildToolCallState();
-      this.notify();
-    } catch (err) {
-      logger.debug("[ConversationStore] Silent reload failed:", err);
-    }
-  }
-  // ==========================================================================
-  // Streaming timeout (Fix A) — auto-recover on SSE inactivity
-  // ==========================================================================
-  resetStreamingTimer() {
-    this.clearStreamingTimer();
-    if (!this._isStreaming) return;
-    this._streamingTimer = setTimeout(() => {
-      if (this._isStreaming) {
-        logger.warn("[ConversationStore] Streaming timeout \u2014 no SSE activity for", this._streamingTimeoutMs, "ms");
-        this.recoverFromHang();
-      }
-    }, this._streamingTimeoutMs);
-  }
-  clearStreamingTimer() {
-    if (this._streamingTimer) {
-      clearTimeout(this._streamingTimer);
-      this._streamingTimer = null;
-    }
-  }
-  // ==========================================================================
-  // Activity watchdog (Fix B) — periodic backend health check
-  // ==========================================================================
-  startWatchdog() {
-    this.stopWatchdog();
-    if (!this._conversationPath) return;
-    this._watchdogTimer = setInterval(async () => {
-      if (!this._isStreaming || !this._conversationPath) {
-        this.stopWatchdog();
-        return;
-      }
-      try {
-        const health = await this.manager.checkTurnHealth(this._conversationPath);
-        if (health === "done" && this._isStreaming) {
-          logger.warn("[ConversationStore] Watchdog detected completed turn while still streaming \u2014 recovering");
-          this.recoverFromHang();
-        }
-      } catch {
-      }
-    }, this._watchdogIntervalMs);
-  }
-  stopWatchdog() {
-    if (this._watchdogTimer) {
-      clearInterval(this._watchdogTimer);
-      this._watchdogTimer = null;
-    }
-  }
-  // ==========================================================================
-  // Hang recovery (shared by timeout + watchdog)
-  // ==========================================================================
-  recoverFromHang() {
-    logger.info("[ConversationStore] Recovering from hang");
-    this.clearStreamingTimer();
-    this.stopWatchdog();
-    this._isStreaming = false;
-    this._isWaiting = true;
-    this._streamingText = "";
-    this.notify();
-    this.silentReload().catch(() => {
-    });
-  }
-  /**
-   * Reconcile a recovered done event against persisted state.
-   * If the backend turn is actually complete, finalize the local state.
-   * Otherwise keep streaming active and let normal events continue.
-   */
-  reconcileRecoveredDone() {
-    if (!this._conversationPath) return;
-    void this.manager.checkTurnHealth(this._conversationPath).then((health) => {
-      if (health !== "done") return;
-      if (!this._isStreaming) return;
-      this._isStreaming = false;
-      this._isWaiting = true;
-      this._activeToolCalls = [];
-      this.clearStreamingTimer();
-      this.stopWatchdog();
-      this.notify();
-      this.deferredReload();
-    }).catch(() => {
-    });
-  }
-  // ==========================================================================
-  // Tool call state rebuild (Fix C) — reconstruct from node tree on reload
-  // ==========================================================================
-  async rebuildToolCallState() {
-    if (!this._conversationPath) {
-      this._activeToolCalls = [];
-      return;
-    }
-    try {
-      const pendingCalls = await this.manager.getActiveToolCalls(this._conversationPath);
-      if (pendingCalls.length > 0) {
-        this._activeToolCalls = pendingCalls.map((tc) => ({
-          id: tc.id,
-          functionName: tc.name,
-          arguments: void 0,
-          status: "running"
-        }));
-        if (!this._isStreaming) {
-          this._isStreaming = true;
-          this.resetStreamingTimer();
-          this.startWatchdog();
-        }
-      } else {
-        this._activeToolCalls = [];
-        if (this._isStreaming) {
-          const lastMsg = this._messages[this._messages.length - 1];
-          const isLastAssistantDone = lastMsg?.role === "assistant" && (lastMsg.dispatchPhase ? lastMsg.dispatchPhase === "terminal" : !!lastMsg.finishReason && lastMsg.finishReason !== "tool_calls");
-          if (isLastAssistantDone) {
-            this._isStreaming = false;
-            this._isWaiting = true;
-            this.clearStreamingTimer();
-            this.stopWatchdog();
-          }
-        }
-      }
-    } catch {
-      this._activeToolCalls = [];
-    }
-  }
-  notify() {
-    const snapshot = this.getSnapshot();
-    for (const sub of this.subscribers) {
-      try {
-        sub(snapshot);
-      } catch (err) {
-        logger.error("Error in conversation store subscriber:", err);
-      }
-    }
-  }
-};
-
-// src/stores/conversation-list-store.ts
-var ConversationListStore = class {
-  constructor(options) {
-    this.subscribers = /* @__PURE__ */ new Set();
-    // Internal state
-    this._conversations = [];
-    this._isLoading = false;
-    this._error = null;
-    // Cached ConversationStore instances
-    this._stores = /* @__PURE__ */ new Map();
-    // Real-time subscription
-    this._realtimeSubscription = null;
-    this.database = options.database;
-    this.type = options.type;
-    this.realtime = options.realtime ?? false;
-  }
-  // ==========================================================================
-  // Subscription
-  // ==========================================================================
-  subscribe(callback) {
-    this.subscribers.add(callback);
-    callback(this.getSnapshot());
-    return () => {
-      this.subscribers.delete(callback);
-    };
-  }
-  getSnapshot() {
-    return {
-      conversations: [...this._conversations],
-      totalUnreadCount: this._conversations.reduce((sum, c) => sum + (c.unreadCount ?? 0), 0),
-      isLoading: this._isLoading,
-      error: this._error
-    };
-  }
-  // ==========================================================================
-  // Actions
-  // ==========================================================================
-  /**
-   * Load conversations from the server.
-   */
-  async load() {
-    this._isLoading = true;
-    this._error = null;
-    this.notify();
-    try {
-      const conversations = await this.database.conversations.list({
-        type: this.type
-      });
-      logger.debug(`[ConversationListStore] Loaded ${conversations.length} conversations`);
-      this._conversations = conversations;
-      if (this.realtime) {
-        this.startRealtimeSubscription();
-      }
-    } catch (err) {
-      logger.error("[ConversationListStore] Failed to load conversations", err);
-      this._error = err instanceof Error ? err.message : String(err);
-    } finally {
-      this._isLoading = false;
-      this.notify();
-    }
-  }
-  /**
-   * Create a new conversation.
-   */
-  async createConversation(options) {
-    const convo = await this.database.conversations.create(options);
-    const listItem = {
-      id: convo.id,
-      type: convo.type,
-      conversationPath: convo.conversationPath,
-      conversationWorkspace: convo.conversationWorkspace,
-      agentRef: convo.agentRef,
-      participants: convo.participants,
-      unreadCount: 0,
-      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-    };
-    this._conversations = [listItem, ...this._conversations];
-    this.notify();
-    return listItem;
-  }
-  /**
-   * Delete a conversation.
-   */
-  async deleteConversation(conversationPath) {
-    const store = this._stores.get(conversationPath);
-    if (store) {
-      store.destroy();
-      this._stores.delete(conversationPath);
-    }
-    await this.database.conversations.delete(conversationPath);
-    this._conversations = this._conversations.filter((c) => c.conversationPath !== conversationPath);
-    this.notify();
-  }
-  /**
-   * Mark a conversation as read.
-   */
-  async markAsRead(conversationPath) {
-    await this.database.conversations.markAsRead(conversationPath);
-    this._conversations = this._conversations.map(
-      (c) => c.conversationPath === conversationPath ? { ...c, unreadCount: 0 } : c
-    );
-    this.notify();
-  }
-  /**
-   * Get or create a ConversationStore for a specific conversation.
-   * Caches instances so repeated calls return the same store.
-   */
-  getConversationStore(conversationPath, overrides) {
-    let store = this._stores.get(conversationPath);
-    if (!store) {
-      store = new ConversationStore({
-        database: this.database,
-        conversationPath,
-        ...overrides
-      });
-      this._stores.set(conversationPath, store);
-    }
-    return store;
-  }
-  /**
-   * Clean up all resources.
-   */
-  destroy() {
-    this._realtimeSubscription?.unsubscribe();
-    this._realtimeSubscription = null;
-    for (const store of this._stores.values()) {
-      store.destroy();
-    }
-    this._stores.clear();
-    this.subscribers.clear();
-  }
-  // ==========================================================================
-  // Internal
-  // ==========================================================================
-  async startRealtimeSubscription() {
-    if (this._realtimeSubscription) return;
-    logger.debug("[ConversationListStore] Starting realtime subscription");
-    try {
-      const workspace = this.database.workspace("raisin:access_control");
-      const events = workspace.events();
-      const result = await this.database.executeSql(
-        `SELECT RAISIN_CURRENT_USER()->>'path'::String as home`
-      );
-      const rows = result.rows;
-      const userHome = rows?.[0]?.home;
-      if (!userHome) return;
-      const chatsPath = `${userHome}/inbox/chats`;
-      this._realtimeSubscription = await events.subscribe(
-        {
-          workspace: "raisin:access_control",
-          path: chatsPath,
-          event_types: ["node:created", "node:updated"]
-        },
-        async (event) => {
-          const eventData = event;
-          const nodeId = eventData.payload?.node_id;
-          if (!nodeId) return;
-          try {
-            const nodeResult = await this.database.executeSql(
-              `SELECT id, path, node_type, properties, created_at, updated_at FROM 'raisin:access_control' WHERE id = $1 LIMIT 1`,
-              [nodeId]
-            );
-            const row = nodeResult.rows?.[0];
-            if (!row || row.node_type !== "raisin:Conversation") return;
-            const convPath = row.path;
-            const props = row.properties ?? {};
-            const item = {
-              id: row.id,
-              type: props.conversation_type ?? "ai_chat",
-              conversationPath: convPath,
-              conversationWorkspace: "raisin:access_control",
-              agentRef: props.agent_ref,
-              participants: props.participants,
-              unreadCount: props.unread_count ?? 0,
-              lastMessage: props.last_message,
-              updatedAt: row.updated_at ?? row.created_at
-            };
-            const existingIdx = this._conversations.findIndex((c) => c.conversationPath === convPath);
-            if (existingIdx >= 0) {
-              this._conversations.splice(existingIdx, 1);
-            }
-            this._conversations = [item, ...this._conversations];
-            this.notify();
-          } catch (err) {
-            logger.debug("Failed to process conversation event:", err);
-          }
-        }
-      );
-    } catch (err) {
-      logger.debug("Failed to start realtime subscription:", err);
-    }
-  }
-  notify() {
-    const snapshot = this.getSnapshot();
-    for (const sub of this.subscribers) {
-      try {
-        sub(snapshot);
-      } catch (err) {
-        logger.error("Error in conversation list store subscriber:", err);
-      }
-    }
-  }
-};
-
-// src/integrations/react-conversation.ts
-var INITIAL_SNAPSHOT = {
-  conversation: null,
-  messages: [],
-  isStreaming: false,
-  isWaiting: false,
-  streamingText: "",
-  error: null,
-  activeToolCalls: [],
-  plans: [],
-  isLoading: false,
-  conversationPath: null
-};
-function useConversation(react, options) {
-  const { useState, useEffect, useRef, useCallback } = react;
-  const [snapshot, setSnapshot] = useState(INITIAL_SNAPSHOT);
-  const storeRef = useRef(null);
-  useEffect(() => {
-    const store = new ConversationStore(options);
-    storeRef.current = store;
-    const unsubscribe = store.subscribe((next) => setSnapshot(next));
-    return () => {
-      unsubscribe();
-      store.destroy();
-      storeRef.current = null;
-    };
-  }, [options.conversationPath]);
-  const sendMessage = useCallback(async (content) => {
-    await storeRef.current?.sendMessage(content);
-  }, []);
-  const approvePlan = useCallback(async (planPath) => {
-    await storeRef.current?.approvePlan(planPath);
-  }, []);
-  const rejectPlan = useCallback(async (planPath, feedback) => {
-    await storeRef.current?.rejectPlan(planPath, feedback);
-  }, []);
-  const stop = useCallback(() => {
-    storeRef.current?.stop();
-  }, []);
-  const loadMessages = useCallback(async () => {
-    return await storeRef.current?.loadMessages() ?? [];
-  }, []);
-  return {
-    ...snapshot,
-    sendMessage,
-    approvePlan,
-    rejectPlan,
-    stop,
-    loadMessages
-  };
-}
-var INITIAL_LIST_SNAPSHOT = {
-  conversations: [],
-  totalUnreadCount: 0,
-  isLoading: false,
-  error: null
-};
-function useConversationList(react, options) {
-  const { useState, useEffect, useRef, useCallback } = react;
-  const [snapshot, setSnapshot] = useState(INITIAL_LIST_SNAPSHOT);
-  const storeRef = useRef(null);
-  useEffect(() => {
-    const store = new ConversationListStore(options);
-    storeRef.current = store;
-    const unsubscribe = store.subscribe((next) => setSnapshot(next));
-    store.load();
-    return () => {
-      unsubscribe();
-      store.destroy();
-      storeRef.current = null;
-    };
-  }, [options.type, options.realtime]);
-  const createConversation = useCallback(async (opts) => {
-    return storeRef.current.createConversation(opts);
-  }, []);
-  const deleteConversation = useCallback(async (conversationPath) => {
-    await storeRef.current?.deleteConversation(conversationPath);
-  }, []);
-  const markAsRead = useCallback(async (conversationPath) => {
-    await storeRef.current?.markAsRead(conversationPath);
-  }, []);
-  return {
-    ...snapshot,
-    createConversation,
-    deleteConversation,
-    markAsRead
-  };
-}
-
-// src/integrations/svelte-conversation.ts
-function createConversationAdapter(options) {
-  const store = new ConversationStore(options);
-  return {
-    /** The underlying ConversationStore instance */
-    store,
-    /** Get the current snapshot */
-    getSnapshot: () => store.getSnapshot(),
-    /** Subscribe to snapshot changes. Returns unsubscribe function. */
-    subscribe: (cb) => store.subscribe(cb),
-    /** Send a user message */
-    sendMessage: (content) => store.sendMessage(content),
-    /** Load persisted messages */
-    loadMessages: () => store.loadMessages(),
-    /** Approve a pending plan */
-    approvePlan: (planPath) => store.approvePlan(planPath),
-    /** Reject a pending plan */
-    rejectPlan: (planPath, feedback) => store.rejectPlan(planPath, feedback),
-    /** Mark a message as read */
-    markMessageAsRead: (messagePath) => store.markMessageAsRead(messagePath),
-    /** Stop streaming */
-    stop: () => store.stop(),
-    /** Get the conversation path */
-    getConversationPath: () => store.getConversationPath(),
-    /** Destroy the store and release resources */
-    destroy: () => store.destroy()
-  };
-}
-function createConversationListAdapter(options) {
-  const store = new ConversationListStore(options);
-  return {
-    /** The underlying ConversationListStore instance */
-    store,
-    /** Get the current snapshot */
-    getSnapshot: () => store.getSnapshot(),
-    /** Subscribe to snapshot changes. Returns unsubscribe function. */
-    subscribe: (cb) => store.subscribe(cb),
-    /** Load conversations from the server */
-    load: () => store.load(),
-    /** Create a new conversation */
-    createConversation: (opts) => store.createConversation(opts),
-    /** Delete a conversation */
-    deleteConversation: (path) => store.deleteConversation(path),
-    /** Mark a conversation as read */
-    markAsRead: (path) => store.markAsRead(path),
-    /** Get or create a ConversationStore for a specific path */
-    getConversationStore: (path) => store.getConversationStore(path),
-    /** Destroy the store and release resources */
-    destroy: () => store.destroy()
-  };
-}
-
-// src/integrations/svelte/svelte-auth.ts
-function createAuthAdapter(client) {
-  let snapshot = {
-    user: client.getStoredUser(),
-    isAuthenticated: client.getStoredUser() !== null,
-    isLoading: false
-  };
-  const listeners = /* @__PURE__ */ new Set();
-  function emit() {
-    for (const cb of listeners) cb(snapshot);
-  }
-  function update(partial) {
-    snapshot = { ...snapshot, ...partial };
-    emit();
-  }
-  const unsubAuth = client.onAuthStateChange(({ event, session }) => {
-    if (event === "SIGNED_IN" || event === "TOKEN_REFRESHED" || event === "USER_UPDATED") {
-      update({ user: session.user, isAuthenticated: true });
-    } else if (event === "SIGNED_OUT" || event === "SESSION_EXPIRED") {
-      update({ user: null, isAuthenticated: false });
-    }
-  });
-  const unsubUser = client.onUserChange(({ node }) => {
-    if (!snapshot.user) return;
-    update({
-      user: {
-        ...snapshot.user,
-        home: node.path,
-        displayName: node.properties.display_name ?? snapshot.user.displayName,
-        avatarUrl: node.properties.avatar_url ?? snapshot.user.avatarUrl
-      }
-    });
-  });
-  return {
-    subscribe(cb) {
-      listeners.add(cb);
-      return () => {
-        listeners.delete(cb);
-      };
-    },
-    getSnapshot: () => snapshot,
-    async login(email, password, repository) {
-      update({ isLoading: true });
-      try {
-        return await client.loginWithEmail(email, password, repository);
-      } finally {
-        update({ isLoading: false });
-      }
-    },
-    async register(email, password, repository, displayName) {
-      update({ isLoading: true });
-      try {
-        return await client.registerWithEmail(email, password, repository, displayName);
-      } finally {
-        update({ isLoading: false });
-      }
-    },
-    async logout(options) {
-      update({ isLoading: true });
-      try {
-        await client.logout(options);
-      } finally {
-        update({ isLoading: false });
-      }
-    },
-    async initSession(repository) {
-      update({ isLoading: true });
-      try {
-        return await client.initSession(repository);
-      } finally {
-        update({ isLoading: false });
-      }
-    },
-    destroy() {
-      unsubAuth();
-      unsubUser();
-      listeners.clear();
-    }
-  };
-}
-
-// src/integrations/svelte/svelte-connection.ts
-function createConnectionAdapter(client) {
-  let snapshot = {
-    state: client.getConnectionState(),
-    isConnected: client.getConnectionState() === "connected" /* Connected */,
-    isReady: client.isReady()
-  };
-  const listeners = /* @__PURE__ */ new Set();
-  function emit() {
-    for (const cb of listeners) cb(snapshot);
-  }
-  const unsubConn = client.onConnectionStateChange((newState) => {
-    snapshot = {
-      state: newState,
-      isConnected: newState === "connected" /* Connected */,
-      isReady: snapshot.isReady
-    };
-    emit();
-  });
-  const unsubReady = client.onReadyStateChange((ready) => {
-    snapshot = { ...snapshot, isReady: ready };
-    emit();
-  });
-  return {
-    subscribe(cb) {
-      listeners.add(cb);
-      return () => {
-        listeners.delete(cb);
-      };
-    },
-    getSnapshot: () => snapshot,
-    async connect() {
-      await client.connect();
-    },
-    disconnect() {
-      client.disconnect();
-    },
-    destroy() {
-      unsubConn();
-      unsubReady();
-      listeners.clear();
-    }
-  };
-}
-
-// src/integrations/svelte/svelte-sql.ts
-function rowsToObjects2(result) {
-  return result.rows;
-}
-function createSqlAdapter(database, sql, params, options) {
-  let snapshot = {
-    data: null,
-    isLoading: false,
-    error: null
-  };
-  const listeners = /* @__PURE__ */ new Set();
-  let destroyed = false;
-  function emit() {
-    for (const cb of listeners) cb(snapshot);
-  }
-  function update(partial) {
-    snapshot = { ...snapshot, ...partial };
-    emit();
-  }
-  async function fetchData() {
-    if (destroyed) return;
-    update({ isLoading: true, error: null });
-    try {
-      const result = await database.executeSql(sql, params);
-      if (!destroyed) {
-        update({ data: rowsToObjects2(result), isLoading: false });
-      }
-    } catch (err) {
-      if (!destroyed) {
-        update({
-          error: err instanceof Error ? err : new Error(String(err)),
-          isLoading: false
-        });
-      }
-    }
-  }
-  const cleanups = [];
-  const enabled = options?.enabled !== false;
-  if (enabled) {
-    fetchData();
-  }
-  const refetchOnReconnect = options?.refetchOnReconnect !== false;
-  if (enabled && refetchOnReconnect) {
-    const client = database._client;
-    if (client?.onReconnected) {
-      const unsub = client.onReconnected(() => {
-        fetchData();
-      });
-      cleanups.push(unsub);
-    }
-  }
-  const realtime = options?.realtime;
-  if (enabled && realtime) {
-    let unsubscribe;
-    let cancelled = false;
-    database.events().subscribe(
-      {
-        workspace: realtime.workspace,
-        event_types: realtime.eventTypes,
-        path: realtime.path,
-        node_type: realtime.nodeType
-      },
-      () => {
-        fetchData();
-      }
-    ).then((sub) => {
-      if (cancelled) {
-        sub.unsubscribe();
-      } else {
-        unsubscribe = () => sub.unsubscribe();
-      }
-    });
-    cleanups.push(() => {
-      cancelled = true;
-      unsubscribe?.();
-    });
-  }
-  return {
-    subscribe(cb) {
-      listeners.add(cb);
-      return () => {
-        listeners.delete(cb);
-      };
-    },
-    getSnapshot: () => snapshot,
-    refetch: fetchData,
-    destroy() {
-      destroyed = true;
-      for (const cleanup of cleanups) cleanup();
-      listeners.clear();
-    }
-  };
-}
-
-// src/integrations/svelte/svelte-subscription.ts
-function createSubscriptionAdapter(database, filters, callback) {
-  let unsubscribe;
-  let cancelled = false;
-  database.events().subscribe(filters, (event) => {
-    if (!cancelled) callback(event);
-  }).then((sub) => {
-    if (cancelled) {
-      sub.unsubscribe();
-    } else {
-      unsubscribe = () => sub.unsubscribe();
-    }
-  });
-  return {
-    destroy() {
-      cancelled = true;
-      unsubscribe?.();
-    }
-  };
-}
-
-// src/integrations/svelte/svelte-flow.ts
-function createFlowAdapter(options) {
-  let snapshot = {
-    events: [],
-    status: "idle",
-    isRunning: false,
-    error: null,
-    output: null,
-    instanceId: null
-  };
-  const listeners = /* @__PURE__ */ new Set();
-  let aborted = false;
-  function emit() {
-    for (const cb of listeners) cb(snapshot);
-  }
-  function update(partial) {
-    snapshot = { ...snapshot, ...partial };
-    if ("status" in partial) {
-      snapshot.isRunning = snapshot.status === "running";
-    }
-    emit();
-  }
-  let flowClient = null;
-  if (options.database) {
-    flowClient = options.database.flow;
-  } else if (options.baseUrl && options.repository && options.authManager) {
-    flowClient = new FlowClient(
-      options.baseUrl,
-      options.repository,
-      options.authManager,
-      options.clientOptions,
-      options.flowsApi
-    );
-  }
-  return {
-    subscribe(cb) {
-      listeners.add(cb);
-      return () => {
-        listeners.delete(cb);
-      };
-    },
-    getSnapshot: () => snapshot,
-    async run(flowPath, input = {}) {
-      if (!flowClient) return;
-      aborted = false;
-      update({
-        events: [],
-        error: null,
-        output: null,
-        status: "running"
-      });
-      try {
-        const result = await flowClient.run(flowPath, input);
-        update({ instanceId: result.instance_id });
-        for await (const event of flowClient.streamEvents(result.instance_id)) {
-          if (aborted) break;
-          update({ events: [...snapshot.events, event] });
-          if (event.type === "flow_waiting") {
-            update({ status: "waiting" });
-          } else if (event.type === "flow_completed") {
-            update({ output: event.output, status: "completed" });
-          } else if (event.type === "flow_failed") {
-            update({ error: event.error, status: "failed" });
-          }
-        }
-      } catch (err) {
-        update({
-          error: err instanceof Error ? err.message : String(err),
-          status: "failed"
-        });
-      }
-    },
-    async resume(data) {
-      if (!flowClient || !snapshot.instanceId) return;
-      update({ status: "running", error: null });
-      try {
-        const stream = await flowClient.createEventStream(snapshot.instanceId);
-        await flowClient.resume(snapshot.instanceId, data);
-        for await (const event of stream.events) {
-          if (aborted) break;
-          update({ events: [...snapshot.events, event] });
-          if (event.type === "flow_waiting") {
-            update({ status: "waiting" });
-            stream.close();
-            return;
-          } else if (event.type === "flow_completed") {
-            update({ output: event.output, status: "completed" });
-            stream.close();
-            return;
-          } else if (event.type === "flow_failed") {
-            update({ error: event.error, status: "failed" });
-            stream.close();
-            return;
-          }
-        }
-        stream.close();
-      } catch (err) {
-        update({
-          error: err instanceof Error ? err.message : String(err),
-          status: "failed"
-        });
-      }
-    },
-    reset() {
-      aborted = true;
-      update({
-        events: [],
-        status: "idle",
-        error: null,
-        output: null,
-        instanceId: null
-      });
-    },
-    destroy() {
-      aborted = true;
-      listeners.clear();
-    }
-  };
-}
-
-// src/integrations/svelte/svelte-context.ts
-var RAISIN_CONTEXT_KEY = /* @__PURE__ */ Symbol("raisin");
-
-// src/integrations/react-flow.ts
-function useFlow(react, options) {
-  const { useState, useEffect, useRef, useCallback } = react;
-  const [events, setEvents] = useState([]);
-  const [status, setStatus] = useState("idle");
-  const [error, setError] = useState(null);
-  const [output, setOutput] = useState(null);
-  const [instanceId, setInstanceId] = useState(null);
-  const clientRef = useRef(null);
-  const abortRef = useRef(false);
-  useEffect(() => {
-    if (options.database) {
-      clientRef.current = options.database.flow;
-    } else if (options.baseUrl && options.repository && options.authManager) {
-      clientRef.current = new FlowClient(
-        options.baseUrl,
-        options.repository,
-        options.authManager,
-        options.clientOptions,
-        options.flowsApi
-      );
-    }
-    return () => {
-      abortRef.current = true;
-      clientRef.current = null;
-    };
-  }, [options.database, options.baseUrl, options.repository]);
-  const run = useCallback(async (flowPath, input = {}) => {
-    const client = clientRef.current;
-    if (!client) return;
-    abortRef.current = false;
-    setEvents([]);
-    setError(null);
-    setOutput(null);
-    setStatus("running");
-    try {
-      const result = await client.run(flowPath, input);
-      setInstanceId(result.instance_id);
-      for await (const event of client.streamEvents(result.instance_id)) {
-        if (abortRef.current) break;
-        setEvents((prev) => [...prev, event]);
-        if (event.type === "flow_waiting") {
-          setStatus("waiting");
-        } else if (event.type === "flow_completed") {
-          setOutput(event.output);
-          setStatus("completed");
-        } else if (event.type === "flow_failed") {
-          setError(event.error);
-          setStatus("failed");
-        }
-      }
-    } catch (err) {
-      setError(err instanceof Error ? err.message : String(err));
-      setStatus("failed");
-    }
-  }, []);
-  const resume = useCallback(async (data) => {
-    const client = clientRef.current;
-    if (!client || !instanceId) return;
-    setStatus("running");
-    setError(null);
-    try {
-      const stream = await client.createEventStream(instanceId);
-      await client.resume(instanceId, data);
-      for await (const event of stream.events) {
-        if (abortRef.current) break;
-        setEvents((prev) => [...prev, event]);
-        if (event.type === "flow_waiting") {
-          setStatus("waiting");
-          stream.close();
-          return;
-        } else if (event.type === "flow_completed") {
-          setOutput(event.output);
-          setStatus("completed");
-          stream.close();
-          return;
-        } else if (event.type === "flow_failed") {
-          setError(event.error);
-          setStatus("failed");
-          stream.close();
-          return;
-        }
-      }
-      stream.close();
-    } catch (err) {
-      setError(err instanceof Error ? err.message : String(err));
-      setStatus("failed");
-    }
-  }, [instanceId]);
-  const reset = useCallback(() => {
-    abortRef.current = true;
-    setEvents([]);
-    setStatus("idle");
-    setError(null);
-    setOutput(null);
-    setInstanceId(null);
-  }, []);
-  return {
-    events,
-    status,
-    isRunning: status === "running",
-    error,
-    output,
-    instanceId,
-    run,
-    resume,
-    reset
-  };
-}
-
-// src/integrations/react/use-auth.ts
-function createUseAuth(react, context) {
-  return function useAuth() {
-    const { useState, useEffect, useRef, useCallback, useContext } = react;
-    const ctx = useContext(context);
-    if (!ctx) {
-      throw new Error("useAuth must be used within a <RaisinProvider>");
-    }
-    const { client } = ctx;
-    const [user, setUser] = useState(client.getStoredUser());
-    const [isLoading, setIsLoading] = useState(false);
-    const mountedRef = useRef(true);
-    useEffect(() => {
-      mountedRef.current = true;
-      const unsubAuth = client.onAuthStateChange(({ event, session }) => {
-        if (!mountedRef.current) return;
-        if (event === "SIGNED_IN" || event === "TOKEN_REFRESHED" || event === "USER_UPDATED") {
-          setUser(session.user);
-        } else if (event === "SIGNED_OUT" || event === "SESSION_EXPIRED") {
-          setUser(null);
-        }
-      });
-      const unsubUser = client.onUserChange(({ node }) => {
-        if (!mountedRef.current) return;
-        setUser((prev) => {
-          if (!prev) return prev;
-          return {
-            ...prev,
-            home: node.path,
-            displayName: node.properties.display_name ?? prev.displayName,
-            avatarUrl: node.properties.avatar_url ?? prev.avatarUrl
-          };
-        });
-      });
-      return () => {
-        mountedRef.current = false;
-        unsubAuth();
-        unsubUser();
-      };
-    }, [client]);
-    const login = useCallback(async (email, password, repository) => {
-      setIsLoading(true);
-      try {
-        const result = await client.loginWithEmail(email, password, repository);
-        return result;
-      } finally {
-        if (mountedRef.current) setIsLoading(false);
-      }
-    }, [client]);
-    const register = useCallback(async (email, password, repository, displayName) => {
-      setIsLoading(true);
-      try {
-        const result = await client.registerWithEmail(email, password, repository, displayName);
-        return result;
-      } finally {
-        if (mountedRef.current) setIsLoading(false);
-      }
-    }, [client]);
-    const logout = useCallback(async (options) => {
-      setIsLoading(true);
-      try {
-        await client.logout(options);
-      } finally {
-        if (mountedRef.current) setIsLoading(false);
-      }
-    }, [client]);
-    const initSession = useCallback(async (repository) => {
-      setIsLoading(true);
-      try {
-        const result = await client.initSession(repository);
-        return result;
-      } finally {
-        if (mountedRef.current) setIsLoading(false);
-      }
-    }, [client]);
-    return {
-      user,
-      isAuthenticated: user !== null,
-      isLoading,
-      login,
-      register,
-      logout,
-      initSession
-    };
-  };
-}
-
-// src/integrations/react/use-connection.ts
-function createUseConnection(react, context) {
-  return function useConnection() {
-    const { useState, useEffect, useCallback, useContext } = react;
-    const ctx = useContext(context);
-    if (!ctx) {
-      throw new Error("useConnection must be used within a <RaisinProvider>");
-    }
-    const { client } = ctx;
-    const [state, setState] = useState(client.getConnectionState());
-    const [isReady, setIsReady] = useState(client.isReady());
-    useEffect(() => {
-      const unsubConn = client.onConnectionStateChange((newState) => {
-        setState(newState);
-      });
-      const unsubReady = client.onReadyStateChange((ready) => {
-        setIsReady(ready);
-      });
-      return () => {
-        unsubConn();
-        unsubReady();
-      };
-    }, [client]);
-    const connect = useCallback(async () => {
-      await client.connect();
-    }, [client]);
-    const disconnect = useCallback(() => {
-      client.disconnect();
-    }, [client]);
-    return {
-      state,
-      isConnected: state === "connected" /* Connected */,
-      isReady,
-      connect,
-      disconnect
-    };
-  };
-}
-
-// src/integrations/react/use-sql.ts
-function rowsToObjects3(result) {
-  return result.rows;
-}
-function createUseSql(react, context) {
-  return function useSql(sql, params, options) {
-    const { useState, useEffect, useRef, useCallback, useContext } = react;
-    const ctx = useContext(context);
-    if (!ctx) {
-      throw new Error("useSql must be used within a <RaisinProvider>");
-    }
-    const { client, repository: defaultRepo } = ctx;
-    const [data, setData] = useState(null);
-    const [isLoading, setIsLoading] = useState(false);
-    const [error, setError] = useState(null);
-    const mountedRef = useRef(true);
-    const enabled = options?.enabled !== false;
-    const repo = options?.repository ?? defaultRepo;
-    const refetchOnReconnect = options?.refetchOnReconnect !== false;
-    const realtime = options?.realtime;
-    const paramsKey = params ? JSON.stringify(params) : "";
-    const fetchData = useCallback(async () => {
-      if (!repo) return;
-      setIsLoading(true);
-      setError(null);
-      try {
-        const db = client.database(repo);
-        const result = await db.executeSql(sql, params);
-        if (mountedRef.current) {
-          setData(rowsToObjects3(result));
-        }
-      } catch (err) {
-        if (mountedRef.current) {
-          setError(err instanceof Error ? err : new Error(String(err)));
-        }
-      } finally {
-        if (mountedRef.current) {
-          setIsLoading(false);
-        }
-      }
-    }, [client, repo, sql, paramsKey]);
-    useEffect(() => {
-      mountedRef.current = true;
-      if (enabled) {
-        fetchData();
-      }
-      return () => {
-        mountedRef.current = false;
-      };
-    }, [enabled, fetchData]);
-    useEffect(() => {
-      if (!enabled || !refetchOnReconnect) return;
-      const unsub = client.onReconnected(() => {
-        fetchData();
-      });
-      return unsub;
-    }, [client, enabled, refetchOnReconnect, fetchData]);
-    useEffect(() => {
-      if (!enabled || !realtime || !repo) return;
-      const db = client.database(repo);
-      let unsubscribe;
-      db.events().subscribe(
-        {
-          workspace: realtime.workspace,
-          event_types: realtime.eventTypes,
-          path: realtime.path,
-          node_type: realtime.nodeType
-        },
-        () => {
-          fetchData();
-        }
-      ).then((sub) => {
-        unsubscribe = () => sub.unsubscribe();
-      });
-      return () => {
-        unsubscribe?.();
-      };
-    }, [client, enabled, repo, realtime?.workspace, realtime?.path, realtime?.nodeType, fetchData]);
-    return {
-      data,
-      isLoading,
-      error,
-      refetch: fetchData
-    };
-  };
-}
-
-// src/integrations/react/use-subscription.ts
-function createUseSubscription(react, context) {
-  return function useSubscription(options, callback) {
-    const { useEffect, useRef, useContext } = react;
-    const ctx = useContext(context);
-    if (!ctx) {
-      throw new Error("useSubscription must be used within a <RaisinProvider>");
-    }
-    const { client, repository } = ctx;
-    const callbackRef = useRef(callback);
-    callbackRef.current = callback;
-    const enabled = options.enabled !== false;
-    useEffect(() => {
-      if (!enabled || !repository || !options.workspace) return;
-      const db = client.database(repository);
-      let unsubscribe;
-      let cancelled = false;
-      db.events().subscribe(
-        {
-          workspace: options.workspace,
-          event_types: options.event_types,
-          path: options.path,
-          node_type: options.node_type,
-          include_node: options.include_node
-        },
-        (event) => {
-          if (!cancelled) {
-            callbackRef.current(event);
-          }
-        }
-      ).then((sub) => {
-        if (cancelled) {
-          sub.unsubscribe();
-        } else {
-          unsubscribe = () => sub.unsubscribe();
-        }
-      });
-      return () => {
-        cancelled = true;
-        unsubscribe?.();
-      };
-    }, [client, repository, enabled, options.workspace, options.path, options.node_type, options.include_node]);
-  };
-}
-
-// src/integrations/react/index.ts
-function createRaisinReact(react) {
-  const RaisinContext = react.createContext(null);
-  function RaisinProvider(props) {
-    const { client, repository, children } = props;
-    const value = react.useMemo(
-      () => ({ client, repository }),
-      [client, repository]
-    );
-    return react.createElement(
-      RaisinContext.Provider,
-      { value },
-      children
-    );
-  }
-  function useRaisinClient() {
-    const ctx = react.useContext(RaisinContext);
-    if (!ctx) {
-      throw new Error("useRaisinClient must be used within a <RaisinProvider>");
-    }
-    return ctx.client;
-  }
-  function useDatabase(repository) {
-    const ctx = react.useContext(RaisinContext);
-    if (!ctx) {
-      throw new Error("useDatabase must be used within a <RaisinProvider>");
-    }
-    const repo = repository ?? ctx.repository;
-    if (!repo) {
-      throw new Error("useDatabase requires a repository \u2014 pass it as an argument or set it on <RaisinProvider>");
-    }
-    return react.useMemo(() => ctx.client.database(repo), [ctx.client, repo]);
-  }
-  const useAuth = createUseAuth(react, RaisinContext);
-  const useConnection = createUseConnection(react, RaisinContext);
-  const useSql = createUseSql(react, RaisinContext);
-  const useSubscription = createUseSubscription(react, RaisinContext);
-  function useConversation2(options) {
-    return useConversation(react, options);
-  }
-  function useConversationList2(options) {
-    return useConversationList(react, options);
-  }
-  function useFlow2(options) {
-    return useFlow(react, options);
-  }
-  return {
-    RaisinProvider,
-    useRaisinClient,
-    useDatabase,
-    useAuth,
-    useConnection,
-    useSql,
-    useSubscription,
-    useConversation: useConversation2,
-    useConversationList: useConversationList2,
-    useFlow: useFlow2
-  };
+function isFlowDefinitionContainer(node) {
+  return node.node_type === "raisin:FlowContainer";
 }
 export {
   AllNodeEventTypes,
@@ -10751,6 +8889,7 @@ export {
   DEFAULT_RETRY_BASE_DELAY,
   DEFAULT_RETRY_MAX_DELAY,
   DEFAULT_RETRY_OPTIONS,
+  DEFAULT_SEND_MESSAGE_INACTIVITY_TIMEOUT_MS,
   Database,
   ElementTypes,
   EventHandler,
@@ -10758,11 +8897,16 @@ export {
   FlowClient,
   FlowsApi,
   FunctionsApi,
+  HttpArchetypes,
   HttpDatabase,
+  HttpElementTypes,
   HttpFunctionsApi,
+  HttpNodeTypes,
   HttpWorkspaceClient,
+  InboxApi,
   LocalStorageTokenStorage,
   LogLevel,
+  McpClient,
   MemoryTokenStorage,
   NodeBuilder,
   NodeEventType,
@@ -10771,6 +8915,7 @@ export {
   NodeOperations,
   NodeTypes,
   RAISIN_CONTEXT_KEY,
+  RETRY_STRATEGIES,
   RaisinAbortError,
   RaisinAuthError,
   RaisinClient,
@@ -10785,6 +8930,7 @@ export {
   ResponseStatus,
   RetryBuilder,
   SSEClient,
+  SchedulerApi,
   SqlQuery,
   Tags,
   Transaction,
@@ -10806,6 +8952,7 @@ export {
   createFlowAdapter,
   createLoader,
   createRaisinReact,
+  createRaisinVue,
   createRequestScopedClient,
   createSSRClient,
   createSqlAdapter,
@@ -10818,13 +8965,18 @@ export {
   getErrorMessage,
   getLogLevel,
   getLoggerConfig,
+  getRefDisplayName,
+  getRefPath,
   isEventMessage,
+  isFlowDefinitionContainer,
+  isFlowDefinitionStep,
   isHttpClient,
   isResponseEnvelope,
   isRetryableError,
   isTerminalEvent,
   isWebSocketClient,
   logger,
+  normalizeHomePath,
   projectPlansFromMessages,
   rowsToObjects,
   setLogLevel,
@@ -10834,3 +8986,4 @@ export {
   useFlow,
   withRetry
 };
+//# sourceMappingURL=index.mjs.map