@raisindb/client 0.1.5 → 0.1.17

package/dist/index.mjs

@@ -1,366 +1,54 @@
-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-WFBAWOVM.mjs";
+import {
+  RAISIN_CONTEXT_KEY,
+  createConversationAdapter,
+  createConversationListAdapter,
+  createFlowAdapter
+} from "./chunk-VZX3ACSO.mjs";
+import {
+  FlowClient,
+  RaisinAbortError,
+  RaisinAuthError,
+  RaisinConnectionError,
+  RaisinError,
+  RaisinFlowError,
+  RaisinTimeoutError,
+  SSEClient,
+  classifyHttpError
+} from "./chunk-DJDP5CX6.mjs";
+import {
+  createRaisinVue
+} from "./chunk-JRFBP4WK.mjs";
+import {
+  createAuthAdapter,
+  createConnectionAdapter,
+  createSqlAdapter,
+  createSubscriptionAdapter
+} from "./chunk-T2ZSNYFG.mjs";
+import {
+  Connection,
+  ConnectionState,
+  ConversationListStore,
+  ConversationStore,
+  LogLevel,
+  ReconnectManager,
+  configureLogger,
+  getLogLevel,
+  getLoggerConfig,
+  isRecoveredDoneEvent,
+  logger,
+  normalizeHomePath,
+  projectPlansFromMessages,
+  setLogLevel
+} from "./chunk-OLJOZIIU.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";
@@ -881,6 +569,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 +767,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 +797,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 +849,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)
@@ -1768,7 +1489,17 @@ var NodeFileSource = class {
       return;
     }
     if (!this._fsPromises) {
-      this._fsPromises = await import("fs/promises");
+      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;
@@ -3024,398 +2755,40 @@ 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;
+// src/conversations.ts
+var DEFAULT_SEND_MESSAGE_INACTIVITY_TIMEOUT_MS = 12e4;
+var ConversationManager = class {
+  constructor(baseUrl, repository, authManager, options = {}, executeSql) {
+    this.baseUrl = baseUrl.replace(/\/$/, "");
+    this.repository = repository;
+    this.authManager = authManager;
     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;
+    this.requestTimeout = options.requestTimeout ?? 6e4;
+    this.executeSql = executeSql;
   }
-  setState(state) {
-    if (this._state !== state) {
-      this._state = state;
-      this.options.onStateChange?.(state);
+  // ==========================================================================
+  // User context
+  // ==========================================================================
+  async ensureCurrentUser() {
+    if (this.cachedUserId && this.cachedUserHome) {
+      return { userId: this.cachedUserId, userHome: this.cachedUserHome };
     }
+    const result = await this.sqlQuery(
+      `SELECT RAISIN_CURRENT_USER()->>'path'::String as home, RAISIN_CURRENT_USER()->>'id'::String as user_id`
+    );
+    if (!result?.rows?.[0]) throw new Error("User not authenticated");
+    const row = result.rows[0];
+    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
+  // ==========================================================================
   /**
-   * 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 ConversationManager = class {
-  constructor(baseUrl, repository, authManager, options = {}, executeSql) {
-    this.baseUrl = baseUrl.replace(/\/$/, "");
-    this.repository = repository;
-    this.authManager = authManager;
-    this.fetchImpl = options.fetch ?? globalThis.fetch.bind(globalThis);
-    this.requestTimeout = options.requestTimeout ?? 6e4;
-    this.executeSql = executeSql;
-  }
-  // ==========================================================================
-  // User context
-  // ==========================================================================
-  async ensureCurrentUser() {
-    if (this.cachedUserId && this.cachedUserHome) {
-      return { userId: this.cachedUserId, userHome: this.cachedUserHome };
-    }
-    const result = await this.sqlQuery(
-      `SELECT RAISIN_CURRENT_USER()->>'path'::String as home, RAISIN_CURRENT_USER()->>'id'::String as user_id`
-    );
-    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 };
-  }
-  // ==========================================================================
-  // Conversation listing
-  // ==========================================================================
-  /**
-   * List conversations for the current user.
+   * List conversations for the current user.
    */
   async list(options) {
     const workspace = "raisin:access_control";
@@ -3604,13 +2977,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 +3022,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,471 +3516,159 @@ 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)
+  // Internal HTTP request helper
   // ==========================================================================
-  /**
-   * 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 = {};
+  async request(options) {
+    const url = `${this.baseUrl}${options.path}`;
+    const headers = {
+      "Content-Type": "application/json"
+    };
     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 controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.requestTimeout);
+    if (options.signal) {
+      if (options.signal.aborted) {
+        clearTimeout(timeoutId);
+        throw new RaisinAbortError();
+      }
+      options.signal.addEventListener("abort", () => controller.abort(), {
+        once: true
+      });
+    }
     try {
-      for await (const sseEvent of sse) {
-        const event = sseEvent.data;
-        yield event;
-        if (event.type === "flow_completed" || event.type === "flow_failed") {
-          return;
+      const response = await this.fetchImpl(url, {
+        method: options.method,
+        headers,
+        body: options.body ? JSON.stringify(options.body) : void 0,
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      if (!response.ok) {
+        const errorText = await response.text();
+        let errorMessage;
+        try {
+          const errorJson = JSON.parse(errorText);
+          errorMessage = errorJson.message || errorJson.error || errorText;
+        } catch {
+          errorMessage = errorText || `HTTP ${response.status}: ${response.statusText}`;
         }
+        throw classifyHttpError(response.status, errorMessage);
       }
-    } finally {
-      sse.close();
+      const contentType = response.headers.get("content-type");
+      if (contentType?.includes("application/json")) {
+        return await response.json();
+      }
+      return void 0;
+    } catch (error) {
+      clearTimeout(timeoutId);
+      if (error instanceof RaisinAbortError || error instanceof RaisinTimeoutError) {
+        throw error;
+      }
+      if (error instanceof Error && error.name === "AbortError") {
+        if (options.signal?.aborted) {
+          throw new RaisinAbortError();
+        }
+        throw new RaisinTimeoutError(
+          `Request timeout after ${this.requestTimeout}ms`,
+          "REQUEST_TIMEOUT",
+          this.requestTimeout
+        );
+      }
+      throw error;
     }
   }
+};
+
+// src/database.ts
+var Database = class _Database {
+  constructor(repository, context, sendRequest, eventHandler, branch, revision, getUploadManager, getSignAssetUrl, httpOptions) {
+    this.repository = repository;
+    this.branch = branch;
+    this.revision = revision;
+    this._context = {
+      ...context,
+      repository,
+      branch: branch || context.branch,
+      revision: revision || context.revision
+    };
+    this.sendRequest = (payload, requestType, contextOverride, requestOptions) => sendRequest(
+      payload,
+      requestType || "node_create",
+      contextOverride || this._context,
+      requestOptions
+    );
+    this.eventHandler = eventHandler;
+    this.getUploadManager = getUploadManager;
+    this.getSignAssetUrl = getSignAssetUrl;
+    this.httpOptions = httpOptions;
+  }
   /**
-   * 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
-  // ==========================================================================
-  async request(options) {
-    const url = `${this.baseUrl}${options.path}`;
-    const headers = {
-      "Content-Type": "application/json"
-    };
-    const token = this.authManager.getAccessToken();
-    if (token) {
-      headers["Authorization"] = `Bearer ${token}`;
-    }
-    const controller = new AbortController();
-    const timeoutId = setTimeout(() => controller.abort(), this.requestTimeout);
-    if (options.signal) {
-      if (options.signal.aborted) {
-        clearTimeout(timeoutId);
-        throw new RaisinAbortError();
-      }
-      options.signal.addEventListener("abort", () => controller.abort(), { once: true });
-    }
-    try {
-      const response = await this.fetchImpl(url, {
-        method: options.method,
-        headers,
-        body: options.body ? JSON.stringify(options.body) : void 0,
-        signal: controller.signal
-      });
-      clearTimeout(timeoutId);
-      if (!response.ok) {
-        const errorText = await response.text();
-        let errorMessage;
-        try {
-          const errorJson = JSON.parse(errorText);
-          errorMessage = errorJson.message || errorJson.error || errorText;
-        } catch {
-          errorMessage = errorText || `HTTP ${response.status}: ${response.statusText}`;
-        }
-        throw classifyHttpError(response.status, errorMessage);
-      }
-      const contentType = response.headers.get("content-type");
-      if (contentType?.includes("application/json")) {
-        return await response.json();
-      }
-      return void 0;
-    } catch (error) {
-      clearTimeout(timeoutId);
-      if (error instanceof RaisinAbortError || error instanceof RaisinTimeoutError) {
-        throw error;
-      }
-      if (error instanceof Error && error.name === "AbortError") {
-        if (options.signal?.aborted) {
-          throw new RaisinAbortError();
-        }
-        throw new RaisinTimeoutError(
-          `Request timeout after ${this.requestTimeout}ms`,
-          "REQUEST_TIMEOUT",
-          this.requestTimeout
-        );
-      }
-      throw error;
-    }
-  }
-};
-
-// src/database.ts
-var Database = class _Database {
-  constructor(repository, context, sendRequest, eventHandler, branch, revision, getUploadManager, getSignAssetUrl, httpOptions) {
-    this.repository = repository;
-    this.branch = branch;
-    this.revision = revision;
-    this._context = {
-      ...context,
-      repository,
-      branch: branch || context.branch,
-      revision: revision || context.revision
-    };
-    this.sendRequest = (payload, requestType, contextOverride, requestOptions) => sendRequest(
-      payload,
-      requestType || "node_create",
-      contextOverride || this._context,
-      requestOptions
-    );
-    this.eventHandler = eventHandler;
-    this.getUploadManager = getUploadManager;
-    this.getSignAssetUrl = getSignAssetUrl;
-    this.httpOptions = httpOptions;
-  }
-  /**
-   * Get the repository name
+   * Get the repository name
    */
   getRepository() {
     return this.repository;
@@ -4848,8 +3920,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 +3965,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 +4328,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 +4338,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 +4792,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 +4801,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 +5170,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
@@ -6129,7 +5237,7 @@ var UploadManager = class {
 };
 
 // src/http-client.ts
-var RaisinHttpClient = class extends EventEmitter2 {
+var RaisinHttpClient = class extends EventEmitter {
   constructor(baseUrl, options = {}) {
     super();
     this._currentUser = null;
@@ -6177,9 +5285,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 +5481,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 +5526,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;
@@ -7067,7 +6179,7 @@ var HttpWorkspaceClient = class {
 };
 
 // src/client.ts
-var RaisinClient = class _RaisinClient extends EventEmitter3 {
+var _RaisinClient = class _RaisinClient extends EventEmitter2 {
   constructor(url, options = {}) {
     super();
     this._currentUser = null;
@@ -7081,23 +6193,41 @@ 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;
     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 +6237,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 +6260,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 +6306,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 +6337,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 */) {
@@ -7224,19 +6406,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 +6444,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 +6497,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 +6517,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 +6538,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 +6661,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);
@@ -7476,7 +6705,7 @@ var RaisinClient = class _RaisinClient extends EventEmitter3 {
       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 +6729,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);
@@ -7542,7 +6771,7 @@ var RaisinClient = class _RaisinClient extends EventEmitter3 {
       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);
     }
@@ -7638,7 +6867,7 @@ var RaisinClient = class _RaisinClient extends EventEmitter3 {
         if (refreshToken) {
           try {
             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 })
@@ -7647,7 +6876,7 @@ var RaisinClient = class _RaisinClient extends EventEmitter3 {
               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;
+              const expiresInMs = _RaisinClient.expiresAtToMs(tokens.expires_at) - Date.now() - 5 * 60 * 1e3;
               if (expiresInMs > 0) {
                 this.scheduleAutoRefresh(expiresInMs);
               }
@@ -7764,7 +6993,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 })
@@ -7794,7 +7023,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);
       }
@@ -7808,18 +7037,66 @@ var RaisinClient = class _RaisinClient extends EventEmitter3 {
     }
   }
   /**
-   * Schedule automatic token refresh
+   * 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
    */
-  scheduleAutoRefresh(delayMs) {
-    if (this._refreshTimer) {
-      clearTimeout(this._refreshTimer);
+  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 });
+      }
     }
-    logger.debug(`[scheduleAutoRefresh] Scheduling refresh in ${Math.round(delayMs / 1e3 / 60)} minutes`);
-    this._refreshTimer = setTimeout(async () => {
-      logger.info("[autoRefresh] Auto-refreshing token...");
-      await this.refreshToken();
-    }, delayMs);
+    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
+   */
+  scheduleAutoRefresh(delayMs) {
+    if (this._refreshTimer) {
+      clearTimeout(this._refreshTimer);
+    }
+    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();
+    }, clamped);
   }
   /**
    * Get a database/repository interface
@@ -7843,10 +7120,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 +7158,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 +7177,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
    */
@@ -8202,6 +7538,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 +7591,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 +7635,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 +7838,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 +7893,9 @@ var RaisinClient = class _RaisinClient extends EventEmitter3 {
     return _RaisinClient.forSSR(baseUrl, options);
   }
 };
+/** 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 +8180,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 +8230,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 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);
-  });
+function getRefPath(ref) {
+  return ref["raisin:path"] || ref["raisin:ref"];
 }
-
-// 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);
-      }
-    }
-  }
+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 }
 };
-
-// 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
-    };
-  };
+function isFlowDefinitionStep(node) {
+  return node.node_type === "raisin:FlowStep";
 }
-
-// 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 +8272,7 @@ export {
   DEFAULT_RETRY_BASE_DELAY,
   DEFAULT_RETRY_MAX_DELAY,
   DEFAULT_RETRY_OPTIONS,
+  DEFAULT_SEND_MESSAGE_INACTIVITY_TIMEOUT_MS,
   Database,
   ElementTypes,
   EventHandler,
@@ -10761,6 +8283,7 @@ export {
   HttpDatabase,
   HttpFunctionsApi,
   HttpWorkspaceClient,
+  InboxApi,
   LocalStorageTokenStorage,
   LogLevel,
   MemoryTokenStorage,
@@ -10771,6 +8294,7 @@ export {
   NodeOperations,
   NodeTypes,
   RAISIN_CONTEXT_KEY,
+  RETRY_STRATEGIES,
   RaisinAbortError,
   RaisinAuthError,
   RaisinClient,
@@ -10806,6 +8330,7 @@ export {
   createFlowAdapter,
   createLoader,
   createRaisinReact,
+  createRaisinVue,
   createRequestScopedClient,
   createSSRClient,
   createSqlAdapter,
@@ -10818,13 +8343,18 @@ export {
   getErrorMessage,
   getLogLevel,
   getLoggerConfig,
+  getRefDisplayName,
+  getRefPath,
   isEventMessage,
+  isFlowDefinitionContainer,
+  isFlowDefinitionStep,
   isHttpClient,
   isResponseEnvelope,
   isRetryableError,
   isTerminalEvent,
   isWebSocketClient,
   logger,
+  normalizeHomePath,
   projectPlansFromMessages,
   rowsToObjects,
   setLogLevel,
@@ -10834,3 +8364,4 @@ export {
   useFlow,
   withRetry
 };
+//# sourceMappingURL=index.mjs.map