@raisindb/client 0.1.16 → 0.1.17

package/dist/index.js

@@ -1,9 +1,7 @@
 "use strict";
-var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -17,19 +15,11 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/index.ts
-var index_exports = {};
-__export(index_exports, {
+var src_exports = {};
+__export(src_exports, {
   AllNodeEventTypes: () => AllNodeEventTypes,
   Archetypes: () => Archetypes,
   AuthManager: () => AuthManager,
@@ -49,6 +39,7 @@ __export(index_exports, {
   DEFAULT_RETRY_BASE_DELAY: () => DEFAULT_RETRY_BASE_DELAY,
   DEFAULT_RETRY_MAX_DELAY: () => DEFAULT_RETRY_MAX_DELAY,
   DEFAULT_RETRY_OPTIONS: () => DEFAULT_RETRY_OPTIONS,
+  DEFAULT_SEND_MESSAGE_INACTIVITY_TIMEOUT_MS: () => DEFAULT_SEND_MESSAGE_INACTIVITY_TIMEOUT_MS,
   Database: () => Database,
   ElementTypes: () => ElementTypes,
   EventHandler: () => EventHandler,
@@ -59,6 +50,7 @@ __export(index_exports, {
   HttpDatabase: () => HttpDatabase,
   HttpFunctionsApi: () => HttpFunctionsApi,
   HttpWorkspaceClient: () => HttpWorkspaceClient,
+  InboxApi: () => InboxApi,
   LocalStorageTokenStorage: () => LocalStorageTokenStorage,
   LogLevel: () => LogLevel,
   MemoryTokenStorage: () => MemoryTokenStorage,
@@ -69,6 +61,7 @@ __export(index_exports, {
   NodeOperations: () => NodeOperations,
   NodeTypes: () => NodeTypes,
   RAISIN_CONTEXT_KEY: () => RAISIN_CONTEXT_KEY,
+  RETRY_STRATEGIES: () => RETRY_STRATEGIES,
   RaisinAbortError: () => RaisinAbortError,
   RaisinAuthError: () => RaisinAuthError,
   RaisinClient: () => RaisinClient,
@@ -104,6 +97,7 @@ __export(index_exports, {
   createFlowAdapter: () => createFlowAdapter,
   createLoader: () => createLoader,
   createRaisinReact: () => createRaisinReact,
+  createRaisinVue: () => createRaisinVue,
   createRequestScopedClient: () => createRequestScopedClient,
   createSSRClient: () => createSSRClient,
   createSqlAdapter: () => createSqlAdapter,
@@ -116,13 +110,18 @@ __export(index_exports, {
   getErrorMessage: () => getErrorMessage,
   getLogLevel: () => getLogLevel,
   getLoggerConfig: () => getLoggerConfig,
+  getRefDisplayName: () => getRefDisplayName,
+  getRefPath: () => getRefPath,
   isEventMessage: () => isEventMessage,
+  isFlowDefinitionContainer: () => isFlowDefinitionContainer,
+  isFlowDefinitionStep: () => isFlowDefinitionStep,
   isHttpClient: () => isHttpClient,
   isResponseEnvelope: () => isResponseEnvelope,
   isRetryableError: () => isRetryableError,
   isTerminalEvent: () => isTerminalEvent,
   isWebSocketClient: () => isWebSocketClient,
   logger: () => logger,
+  normalizeHomePath: () => normalizeHomePath,
   projectPlansFromMessages: () => projectPlansFromMessages,
   rowsToObjects: () => rowsToObjects,
   setLogLevel: () => setLogLevel,
@@ -132,7 +131,7 @@ __export(index_exports, {
   useFlow: () => useFlow,
   withRetry: () => withRetry
 });
-module.exports = __toCommonJS(index_exports);
+module.exports = __toCommonJS(src_exports);
 
 // src/client.ts
 var import_events4 = require("events");
@@ -326,7 +325,8 @@ var Connection = class extends import_events.EventEmitter {
       autoReconnect: options.autoReconnect ?? true,
       heartbeatInterval: options.heartbeatInterval ?? 3e4,
       heartbeatTimeout: options.heartbeatTimeout ?? 5e3,
-      protocols: options.protocols
+      protocols: options.protocols,
+      headers: options.headers
     };
     this.reconnectManager = new ReconnectManager(options.reconnectOptions);
     this.WebSocketImpl = getWebSocketImpl();
@@ -342,10 +342,10 @@ var Connection = class extends import_events.EventEmitter {
     this.setState("connecting" /* Connecting */);
     return new Promise((resolve, reject) => {
       try {
-        this.ws = new this.WebSocketImpl(
-          this.url,
-          this.options.protocols
-        );
+        const isBrowserWebSocket = typeof WebSocket !== "undefined" && this.WebSocketImpl === WebSocket;
+        this.ws = isBrowserWebSocket || !this.options.headers ? new this.WebSocketImpl(this.url, this.options.protocols) : new this.WebSocketImpl(this.url, this.options.protocols, {
+          headers: this.options.headers
+        });
         this.ws.binaryType = "arraybuffer";
         this.ws.onopen = () => {
           this.setState("connected" /* Connected */);
@@ -434,6 +434,16 @@ var Connection = class extends import_events.EventEmitter {
   isConnected() {
     return this.state === "connected" /* Connected */;
   }
+  /**
+   * Whether auto-reconnect is enabled for this connection.
+   *
+   * Used by the client to decide whether requests issued while the
+   * connection is down can be queued (the connection will come back) or
+   * should fail immediately.
+   */
+  isAutoReconnectEnabled() {
+    return this.options.autoReconnect;
+  }
   /**
    * Reconnect to the server
    */
@@ -1010,6 +1020,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
@@ -1200,14 +1218,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(
@@ -1215,22 +1248,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 {
@@ -1265,7 +1300,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)
@@ -1897,7 +1940,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;
@@ -3241,6 +3294,7 @@ var SSEClient = class {
     this._lastEventId = options.lastEventId;
     this.autoReconnect = options.reconnect?.enabled ?? true;
     this.externalSignal = options.signal;
+    this.inactivityTimeoutMs = options.inactivityTimeoutMs;
     this.eventTypeSet = options.eventTypes?.length ? new Set(options.eventTypes) : null;
     this.reconnectManager = new ReconnectManager({
       initialDelay: options.reconnect?.initialDelay ?? 1e3,
@@ -3384,6 +3438,23 @@ var SSEClient = class {
         if (err.name === "AbortError" || err instanceof RaisinAbortError) {
           return;
         }
+        if (err instanceof RaisinTimeoutError && err.code === "SSE_INACTIVITY_TIMEOUT") {
+          logger.warn("SSE inactivity timeout:", err.message);
+          if (!this.autoReconnect) {
+            this.setState("disconnected");
+            onError?.(err);
+            throw err;
+          }
+          this.setState("reconnecting");
+          const scheduled2 = await this.waitForReconnect();
+          if (!scheduled2) {
+            logger.warn("SSE max reconnection attempts reached");
+            this.setState("disconnected");
+            onError?.(err);
+            throw err;
+          }
+          continue;
+        }
         logger.error("SSE connection error:", err.message);
         onError?.(err);
         if (!this.autoReconnect) {
@@ -3432,7 +3503,9 @@ var SSEClient = class {
       fetchOptions.headers["Content-Type"] = "application/json";
       fetchOptions.body = JSON.stringify(this.options.body);
     }
-    const response = await this.fetchImpl(this.url, fetchOptions);
+    const response = await this.withInactivityTimeout(
+      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}` : ""}`;
@@ -3455,7 +3528,7 @@ var SSEClient = class {
     let buffer = "";
     try {
       while (true) {
-        const { done, value } = await reader.read();
+        const { done, value } = await this.withInactivityTimeout(reader.read());
         if (done) break;
         buffer += decoder.decode(value, { stream: true });
         const blocks = buffer.split("\n\n");
@@ -3486,9 +3559,48 @@ var SSEClient = class {
         }
       }
     } finally {
-      reader.releaseLock();
+      try {
+        reader.releaseLock();
+      } catch {
+      }
     }
   }
+  /**
+   * Race a stream operation against the inactivity timeout.
+   *
+   * If no bytes (or response) arrive within `inactivityTimeoutMs`, the
+   * internal connection is aborted and the operation rejects with a
+   * `RaisinTimeoutError` (code `SSE_INACTIVITY_TIMEOUT`). The timer is
+   * effectively reset on every chunk because each `reader.read()` is
+   * wrapped individually.
+   */
+  withInactivityTimeout(promise) {
+    const timeoutMs = this.inactivityTimeoutMs;
+    if (!timeoutMs || timeoutMs <= 0) return promise;
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        promise.catch(() => void 0);
+        this.abortController?.abort();
+        reject(
+          new RaisinTimeoutError(
+            `SSE stream inactive for ${timeoutMs}ms`,
+            "SSE_INACTIVITY_TIMEOUT",
+            timeoutMs
+          )
+        );
+      }, timeoutMs);
+      promise.then(
+        (value) => {
+          clearTimeout(timer);
+          resolve(value);
+        },
+        (error) => {
+          clearTimeout(timer);
+          reject(error);
+        }
+      );
+    });
+  }
   /**
    * Wait for the reconnect manager to schedule a reconnection attempt.
    * Returns true if reconnection was scheduled, false if max attempts reached.
@@ -3513,7 +3625,24 @@ function isRecoveredDoneEvent(event) {
   return typeof done.content !== "string" || done.content.trim().length === 0;
 }
 
+// src/utils/home-path.ts
+var ACCESS_CONTROL_PREFIX = "/raisin:access_control";
+function normalizeHomePath(home) {
+  if (home === null || home === void 0) return null;
+  let path = home.trim();
+  if (path.length === 0) return null;
+  if (path === ACCESS_CONTROL_PREFIX) return "/";
+  if (path.startsWith(`${ACCESS_CONTROL_PREFIX}/`)) {
+    path = path.slice(ACCESS_CONTROL_PREFIX.length);
+  }
+  while (path.length > 1 && path.endsWith("/")) {
+    path = path.slice(0, -1);
+  }
+  return path;
+}
+
 // src/conversations.ts
+var DEFAULT_SEND_MESSAGE_INACTIVITY_TIMEOUT_MS = 12e4;
 var ConversationManager = class {
   constructor(baseUrl, repository, authManager, options = {}, executeSql) {
     this.baseUrl = baseUrl.replace(/\/$/, "");
@@ -3535,10 +3664,11 @@ var ConversationManager = class {
     );
     if (!result?.rows?.[0]) throw new Error("User not authenticated");
     const row = result.rows[0];
-    this.cachedUserHome = row.home;
-    this.cachedUserId = row.user_id || this.cachedUserHome;
-    if (!this.cachedUserHome) throw new Error("User home path not found");
-    return { userId: this.cachedUserId, userHome: this.cachedUserHome };
+    const userHome = normalizeHomePath(row.home);
+    if (!userHome) throw new Error("User home path not found");
+    this.cachedUserHome = userHome;
+    this.cachedUserId = row.user_id || userHome;
+    return { userId: this.cachedUserId, userHome };
   }
   // ==========================================================================
   // Conversation listing
@@ -3733,13 +3863,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");
@@ -3776,6 +3908,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();
       }
@@ -4538,31 +4679,29 @@ var FlowClient = class _FlowClient {
    * 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.
+   * use this method to submit the response. Completion is validated
+   * (caller must be the task's assignee or an admin) and resumes the flow.
    *
-   * @param instanceId - Flow instance ID
-   * @param taskId - The human task node ID
-   * @param response - The human's response data
+   * Note: prefer `InboxApi` for full inbox functionality (listing tasks,
+   * task details); this is a convenience passthrough to the same endpoint.
+   *
+   * @param instanceId - Flow instance ID (unused; kept for API stability)
+   * @param taskId - The inbox task node ID (or path)
+   * @param response - The response data
    *
    * @example
    * ```typescript
    * // Approve a task
-   * await flows.respondToHumanTask('instance-123', 'step-5', {
+   * await flows.respondToHumanTask('instance-123', 'task-abc', {
    *   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) {
+  async respondToHumanTask(_instanceId, taskId, response, options) {
     await this.request({
       method: "POST",
-      path: `/api/flows/${this.repository}/instances/${instanceId}/tasks/${taskId}/respond`,
+      path: `/api/inbox/${this.repository}/tasks/${encodeURIComponent(taskId)}/complete`,
       body: { response },
       signal: options?.signal
     });
@@ -4701,6 +4840,134 @@ var FlowClient = class _FlowClient {
   }
 };
 
+// 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 ?? 3e4;
+  }
+  /**
+   * List the caller's inbox tasks.
+   *
+   * Tasks are sorted pending-first, then by priority (highest first) and
+   * due time (earliest first).
+   */
+  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
+    });
+  }
+  /**
+   * Get a single inbox task by ID (or path).
+   */
+  async getTask(taskId, options) {
+    return this.request({
+      method: "GET",
+      path: `/api/inbox/${this.repository}/tasks/${encodeURIComponent(taskId)}`,
+      signal: options?.signal
+    });
+  }
+  /**
+   * Complete an inbox task.
+   *
+   * 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 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
+   * await inbox.completeTask('task-123', { action: 'approve' });
+   * ```
+   */
+  async completeTask(taskId, response, options) {
+    return this.request({
+      method: "POST",
+      path: `/api/inbox/${this.repository}/tasks/${encodeURIComponent(taskId)}/complete`,
+      body: { response },
+      signal: options?.signal
+    });
+  }
+  // ==========================================================================
+  // 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) {
@@ -4977,8 +5244,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;
@@ -6306,9 +6609,13 @@ var RaisinHttpClient = class extends import_events3.EventEmitter {
         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);
@@ -7196,7 +7503,7 @@ var HttpWorkspaceClient = class {
 };
 
 // src/client.ts
-var RaisinClient = class _RaisinClient extends import_events4.EventEmitter {
+var _RaisinClient = class _RaisinClient extends import_events4.EventEmitter {
   constructor(url, options = {}) {
     super();
     this._currentUser = null;
@@ -7210,23 +7517,41 @@ var RaisinClient = class _RaisinClient extends import_events4.EventEmitter {
     // 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
     });
@@ -7236,6 +7561,14 @@ var RaisinClient = class _RaisinClient extends import_events4.EventEmitter {
     );
     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
@@ -7251,15 +7584,45 @@ var RaisinClient = class _RaisinClient extends import_events4.EventEmitter {
       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 "";
@@ -7267,14 +7630,24 @@ var RaisinClient = class _RaisinClient extends import_events4.EventEmitter {
   }
   /**
    * 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";
     }
@@ -7288,7 +7661,11 @@ var RaisinClient = class _RaisinClient extends import_events4.EventEmitter {
     });
     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 */) {
@@ -7353,19 +7730,36 @@ var RaisinClient = class _RaisinClient extends import_events4.EventEmitter {
         };
         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,
@@ -7374,18 +7768,41 @@ var RaisinClient = class _RaisinClient extends import_events4.EventEmitter {
     });
   }
   /**
-   * 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
@@ -7404,13 +7821,15 @@ var RaisinClient = class _RaisinClient extends import_events4.EventEmitter {
   }
   /**
    * 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") {
@@ -7422,18 +7841,20 @@ var RaisinClient = class _RaisinClient extends import_events4.EventEmitter {
           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();
@@ -7441,11 +7862,14 @@ var RaisinClient = class _RaisinClient extends import_events4.EventEmitter {
         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;
       }
     }
   }
@@ -7561,18 +7985,18 @@ var RaisinClient = class _RaisinClient extends import_events4.EventEmitter {
     }
     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);
@@ -7605,7 +8029,7 @@ var RaisinClient = class _RaisinClient extends import_events4.EventEmitter {
       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);
     }
@@ -7629,18 +8053,18 @@ var RaisinClient = class _RaisinClient extends import_events4.EventEmitter {
   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);
@@ -7671,7 +8095,7 @@ var RaisinClient = class _RaisinClient extends import_events4.EventEmitter {
       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);
     }
@@ -7767,7 +8191,7 @@ var RaisinClient = class _RaisinClient extends import_events4.EventEmitter {
         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 })
@@ -7776,7 +8200,7 @@ var RaisinClient = class _RaisinClient extends import_events4.EventEmitter {
               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);
               }
@@ -7893,7 +8317,7 @@ var RaisinClient = class _RaisinClient extends import_events4.EventEmitter {
     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 })
@@ -7923,7 +8347,7 @@ var RaisinClient = class _RaisinClient extends import_events4.EventEmitter {
       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);
       }
@@ -7936,6 +8360,53 @@ var RaisinClient = class _RaisinClient extends import_events4.EventEmitter {
       return null;
     }
   }
+  /**
+   * Fetch with a timeout derived from `requestTimeout`.
+   *
+   * Aborts the request after `requestTimeout` ms and rejects with a
+   * `RaisinTimeoutError`. If the caller provides its own AbortSignal in
+   * `init.signal`, it is respected: an external abort rejects with the
+   * original AbortError instead of a timeout error.
+   * @internal
+   */
+  async _fetchWithTimeout(url, init = {}) {
+    const timeoutMs = this.options.requestTimeout;
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    const externalSignal = init.signal ?? void 0;
+    if (externalSignal) {
+      if (externalSignal.aborted) {
+        controller.abort();
+      } else {
+        externalSignal.addEventListener("abort", () => controller.abort(), { once: true });
+      }
+    }
+    try {
+      return await fetch(url, { ...init, signal: controller.signal });
+    } catch (error) {
+      if (error instanceof Error && error.name === "AbortError" && !externalSignal?.aborted) {
+        throw new RaisinTimeoutError(
+          `Request to ${url} timed out after ${timeoutMs}ms`,
+          "REQUEST_TIMEOUT",
+          timeoutMs
+        );
+      }
+      throw error;
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+  /**
+   * Normalize a token `expires_at` value to epoch milliseconds.
+   *
+   * Server endpoints are inconsistent: some return seconds, others
+   * milliseconds. Anything above 1e11 can't be a seconds-epoch (year 5138),
+   * so treat it as milliseconds.
+   * @internal
+   */
+  static expiresAtToMs(expiresAt) {
+    return expiresAt > 1e11 ? expiresAt : expiresAt * 1e3;
+  }
   /**
    * Schedule automatic token refresh
    * @internal
@@ -7944,11 +8415,12 @@ var RaisinClient = class _RaisinClient extends import_events4.EventEmitter {
     if (this._refreshTimer) {
       clearTimeout(this._refreshTimer);
     }
-    logger.debug(`[scheduleAutoRefresh] Scheduling refresh in ${Math.round(delayMs / 1e3 / 60)} minutes`);
+    const clamped = Math.min(Math.max(delayMs, 3e4), 2147483647);
+    logger.debug(`[scheduleAutoRefresh] Scheduling refresh in ${Math.round(clamped / 1e3 / 60)} minutes`);
     this._refreshTimer = setTimeout(async () => {
       logger.info("[autoRefresh] Auto-refreshing token...");
       await this.refreshToken();
-    }, delayMs);
+    }, clamped);
   }
   /**
    * Get a database/repository interface
@@ -7972,10 +8444,26 @@ var RaisinClient = class _RaisinClient extends import_events4.EventEmitter {
   }
   /**
    * 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;
@@ -7994,8 +8482,15 @@ var RaisinClient = class _RaisinClient extends import_events4.EventEmitter {
     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(
@@ -8006,6 +8501,42 @@ var RaisinClient = class _RaisinClient extends import_events4.EventEmitter {
     }
     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
    */
@@ -8331,6 +8862,7 @@ var RaisinClient = class _RaisinClient extends import_events4.EventEmitter {
    */
   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);
@@ -8630,7 +9162,7 @@ var RaisinClient = class _RaisinClient extends import_events4.EventEmitter {
     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",
@@ -8685,6 +9217,9 @@ var RaisinClient = class _RaisinClient extends import_events4.EventEmitter {
     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 {
@@ -9019,6 +9554,29 @@ function isTerminalEvent(event) {
   return event.type === "flow_completed" || event.type === "flow_failed";
 }
 
+// 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 getRefPath(ref) {
+  return ref["raisin:path"] || ref["raisin:ref"];
+}
+var RETRY_STRATEGIES = {
+  none: { max_retries: 0, base_delay_ms: 0, max_delay_ms: 0 },
+  quick: { max_retries: 3, base_delay_ms: 1e3, max_delay_ms: 1e4 },
+  standard: { max_retries: 5, base_delay_ms: 2e3, max_delay_ms: 6e4 },
+  aggressive: { max_retries: 10, base_delay_ms: 5e3, max_delay_ms: 12e4 },
+  llm: { max_retries: 5, base_delay_ms: 1e4, max_delay_ms: 12e4 }
+};
+function isFlowDefinitionStep(node) {
+  return node.node_type === "raisin:FlowStep";
+}
+function isFlowDefinitionContainer(node) {
+  return node.node_type === "raisin:FlowContainer";
+}
+
 // src/utils/plan-projection.ts
 function asRecord(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) return null;
@@ -9357,10 +9915,12 @@ var ConversationStore = class {
     }
     switch (event.type) {
       case "text_chunk":
+        this.markStreamingActivity();
         this._streamingText += event.text;
         this.notify();
         break;
       case "thought_chunk":
+        this.markStreamingActivity();
         this.notify();
         break;
       case "assistant_message":
@@ -9369,6 +9929,7 @@ var ConversationStore = class {
         this.notify();
         break;
       case "tool_call_started": {
+        this.markStreamingActivity();
         logger.debug("[ConversationStore] Tool started:", event.functionName);
         const info = {
           id: event.toolCallId,
@@ -9381,6 +9942,7 @@ var ConversationStore = class {
         break;
       }
       case "tool_call_completed": {
+        this.markStreamingActivity();
         logger.debug("[ConversationStore] Tool completed:", event.toolCallId);
         const idx = this._activeToolCalls.findIndex((tc) => tc.id === event.toolCallId);
         if (idx >= 0) {
@@ -9455,6 +10017,7 @@ var ConversationStore = class {
         logger.error("[ConversationStore] Turn failed", event.error);
         this._error = event.error;
         this._isStreaming = false;
+        this._isWaiting = false;
         this._streamingText = "";
         this._activeToolCalls = [];
         this.clearStreamingTimer();
@@ -9492,6 +10055,26 @@ var ConversationStore = class {
       }
     }
   }
+  /**
+   * Agent activity observed while the store thought the turn was over.
+   *
+   * This happens when execution continues WITHOUT a user message — plan
+   * approval in approve_then_auto / step_by_step (approvePlan() returns an
+   * enqueue receipt and the agent starts executing), or agent-initiated
+   * follow-ups. The events arrive over the persistent live subscription
+   * (no history replay), so activity is always "now": re-enter streaming
+   * state so UIs show progress and the end-of-turn handling (done/waiting
+   * → deferred reload) runs again for this continuation.
+   */
+  markStreamingActivity() {
+    if (this._isStreaming) return;
+    logger.debug("[ConversationStore] Agent activity while idle \u2014 re-entering streaming state");
+    this._isStreaming = true;
+    this._isWaiting = false;
+    this._streamingText = "";
+    this.resetStreamingTimer();
+    this.startWatchdog();
+  }
   /**
    * If accumulated streaming text hasn't been captured in an assistant_message,
    * synthesize one.
@@ -9725,6 +10308,14 @@ var ConversationStore = class {
 };
 
 // src/stores/conversation-list-store.ts
+function buildChatsSubscriptionFilters(userHome) {
+  const home = normalizeHomePath(userHome) ?? userHome;
+  return {
+    workspace: "raisin:access_control",
+    path: `${home}/inbox/chats/**`,
+    event_types: ["node:created", "node:updated"]
+  };
+}
 var ConversationListStore = class {
   constructor(options) {
     this.subscribers = /* @__PURE__ */ new Set();
@@ -9870,13 +10461,8 @@ var ConversationListStore = class {
       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"]
-        },
+        buildChatsSubscriptionFilters(userHome),
         async (event) => {
           const eventData = event;
           const nodeId = eventData.payload?.node_id;
@@ -9982,7 +10568,7 @@ function useConversation(react, options) {
 var INITIAL_LIST_SNAPSHOT = {
   conversations: [],
   totalUnreadCount: 0,
-  isLoading: false,
+  isLoading: true,
   error: null
 };
 function useConversationList(react, options) {
@@ -10860,6 +11446,160 @@ function createRaisinReact(react) {
     useFlow: useFlow2
   };
 }
+
+// src/integrations/vue/vue-auth.ts
+function createUseAuth2(vue) {
+  return function useAuth(client) {
+    const adapter = createAuthAdapter(client);
+    const snapshot = vue.ref(adapter.getSnapshot());
+    const unsubscribe = adapter.subscribe((s) => {
+      snapshot.value = s;
+    });
+    vue.onUnmounted(() => {
+      unsubscribe();
+      adapter.destroy();
+    });
+    return {
+      user: vue.computed(() => snapshot.value.user),
+      isAuthenticated: vue.computed(() => snapshot.value.isAuthenticated),
+      isLoading: vue.computed(() => snapshot.value.isLoading),
+      login: adapter.login,
+      register: adapter.register,
+      logout: adapter.logout,
+      initSession: adapter.initSession
+    };
+  };
+}
+
+// src/integrations/vue/vue-connection.ts
+function createUseConnection2(vue) {
+  return function useConnection(client) {
+    const adapter = createConnectionAdapter(client);
+    const snapshot = vue.ref(adapter.getSnapshot());
+    const unsubscribe = adapter.subscribe((s) => {
+      snapshot.value = s;
+    });
+    vue.onUnmounted(() => {
+      unsubscribe();
+      adapter.destroy();
+    });
+    return {
+      state: vue.computed(() => snapshot.value.state),
+      isConnected: vue.computed(() => snapshot.value.isConnected),
+      isReady: vue.computed(() => snapshot.value.isReady),
+      connect: adapter.connect,
+      disconnect: adapter.disconnect
+    };
+  };
+}
+
+// src/integrations/vue/vue-sql.ts
+function createUseSql2(vue) {
+  return function useSql(database, sql, params, options) {
+    const adapter = createSqlAdapter(database, sql, params, options);
+    const snapshot = vue.ref(adapter.getSnapshot());
+    const unsubscribe = adapter.subscribe((s) => {
+      snapshot.value = s;
+    });
+    vue.onUnmounted(() => {
+      unsubscribe();
+      adapter.destroy();
+    });
+    return {
+      data: vue.computed(() => snapshot.value.data),
+      isLoading: vue.computed(() => snapshot.value.isLoading),
+      error: vue.computed(() => snapshot.value.error),
+      refetch: adapter.refetch
+    };
+  };
+}
+
+// src/integrations/vue/vue-subscription.ts
+function createUseSubscription2(vue) {
+  return function useSubscription(database, filters, callback) {
+    const adapter = createSubscriptionAdapter(database, filters, callback);
+    vue.onUnmounted(() => adapter.destroy());
+    return {
+      unsubscribe: () => adapter.destroy()
+    };
+  };
+}
+
+// src/integrations/vue/vue-conversation.ts
+function createUseConversation(vue) {
+  return function useConversation2(options) {
+    const store = new ConversationStore(options);
+    const snapshot = vue.ref(store.getSnapshot());
+    const unsubscribe = store.subscribe((s) => {
+      snapshot.value = s;
+    });
+    vue.onUnmounted(() => {
+      unsubscribe();
+      store.destroy();
+    });
+    return {
+      conversation: vue.computed(() => snapshot.value.conversation),
+      messages: vue.computed(() => snapshot.value.messages),
+      isStreaming: vue.computed(() => snapshot.value.isStreaming),
+      isWaiting: vue.computed(() => snapshot.value.isWaiting),
+      streamingText: vue.computed(() => snapshot.value.streamingText),
+      error: vue.computed(() => snapshot.value.error),
+      activeToolCalls: vue.computed(() => snapshot.value.activeToolCalls),
+      plans: vue.computed(() => snapshot.value.plans),
+      isLoading: vue.computed(() => snapshot.value.isLoading),
+      conversationPath: vue.computed(() => snapshot.value.conversationPath),
+      sendMessage: (content) => store.sendMessage(content),
+      approvePlan: async (planPath) => {
+        await store.approvePlan(planPath);
+      },
+      rejectPlan: async (planPath, feedback) => {
+        await store.rejectPlan(planPath, feedback);
+      },
+      stop: () => store.stop(),
+      loadMessages: () => store.loadMessages(),
+      store
+    };
+  };
+}
+function createUseConversationList(vue) {
+  return function useConversationList2(options) {
+    const store = new ConversationListStore(options);
+    const snapshot = vue.ref(store.getSnapshot());
+    const unsubscribe = store.subscribe((s) => {
+      snapshot.value = s;
+    });
+    store.load().catch((err) => {
+      logger.error("[useConversationList] Initial load failed:", err);
+    });
+    vue.onUnmounted(() => {
+      unsubscribe();
+      store.destroy();
+    });
+    return {
+      conversations: vue.computed(() => snapshot.value.conversations),
+      totalUnreadCount: vue.computed(() => snapshot.value.totalUnreadCount),
+      isLoading: vue.computed(() => snapshot.value.isLoading),
+      error: vue.computed(() => snapshot.value.error),
+      createConversation: (opts) => store.createConversation(opts),
+      deleteConversation: (conversationPath) => store.deleteConversation(conversationPath),
+      markAsRead: (conversationPath) => store.markAsRead(conversationPath),
+      refresh: () => store.load(),
+      store
+    };
+  };
+}
+
+// src/integrations/vue/index.ts
+function createRaisinVue(vue) {
+  return {
+    useAuth: createUseAuth2(vue),
+    useConnection: createUseConnection2(vue),
+    useSql: createUseSql2(vue),
+    useSubscription: createUseSubscription2(vue),
+    useConversation: createUseConversation(vue),
+    useConversationList: createUseConversationList(vue)
+  };
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AllNodeEventTypes,
@@ -10881,6 +11621,7 @@ function createRaisinReact(react) {
   DEFAULT_RETRY_BASE_DELAY,
   DEFAULT_RETRY_MAX_DELAY,
   DEFAULT_RETRY_OPTIONS,
+  DEFAULT_SEND_MESSAGE_INACTIVITY_TIMEOUT_MS,
   Database,
   ElementTypes,
   EventHandler,
@@ -10891,6 +11632,7 @@ function createRaisinReact(react) {
   HttpDatabase,
   HttpFunctionsApi,
   HttpWorkspaceClient,
+  InboxApi,
   LocalStorageTokenStorage,
   LogLevel,
   MemoryTokenStorage,
@@ -10901,6 +11643,7 @@ function createRaisinReact(react) {
   NodeOperations,
   NodeTypes,
   RAISIN_CONTEXT_KEY,
+  RETRY_STRATEGIES,
   RaisinAbortError,
   RaisinAuthError,
   RaisinClient,
@@ -10936,6 +11679,7 @@ function createRaisinReact(react) {
   createFlowAdapter,
   createLoader,
   createRaisinReact,
+  createRaisinVue,
   createRequestScopedClient,
   createSSRClient,
   createSqlAdapter,
@@ -10948,13 +11692,18 @@ function createRaisinReact(react) {
   getErrorMessage,
   getLogLevel,
   getLoggerConfig,
+  getRefDisplayName,
+  getRefPath,
   isEventMessage,
+  isFlowDefinitionContainer,
+  isFlowDefinitionStep,
   isHttpClient,
   isResponseEnvelope,
   isRetryableError,
   isTerminalEvent,
   isWebSocketClient,
   logger,
+  normalizeHomePath,
   projectPlansFromMessages,
   rowsToObjects,
   setLogLevel,
@@ -10964,3 +11713,4 @@ function createRaisinReact(react) {
   useFlow,
   withRetry
 });
+//# sourceMappingURL=index.js.map