@raisindb/client 0.1.0 → 0.1.1

package/dist/index.js

@@ -1,10 +1,11 @@
 "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 __typeError = (msg) => {
+  throw TypeError(msg);
+};
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -17,19 +18,17 @@ 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);
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
 
 // src/index.ts
-var index_exports = {};
-__export(index_exports, {
+var src_exports = {};
+__export(src_exports, {
+  AgentRunsApi: () => AgentRunsApi,
+  AgentRunsWsApi: () => AgentRunsWsApi,
   AllNodeEventTypes: () => AllNodeEventTypes,
   Archetypes: () => Archetypes,
   AuthManager: () => AuthManager,
@@ -49,6 +48,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,
@@ -56,19 +56,27 @@ __export(index_exports, {
   FlowClient: () => FlowClient,
   FlowsApi: () => FlowsApi,
   FunctionsApi: () => FunctionsApi,
+  HttpArchetypes: () => HttpArchetypes,
   HttpDatabase: () => HttpDatabase,
+  HttpElementTypes: () => HttpElementTypes,
   HttpFunctionsApi: () => HttpFunctionsApi,
+  HttpNodeTypes: () => HttpNodeTypes,
   HttpWorkspaceClient: () => HttpWorkspaceClient,
+  IdentityAuthApi: () => IdentityAuthApi,
+  InboxApi: () => InboxApi,
   LocalStorageTokenStorage: () => LocalStorageTokenStorage,
   LogLevel: () => LogLevel,
+  McpClient: () => McpClient,
   MemoryTokenStorage: () => MemoryTokenStorage,
   NodeBuilder: () => NodeBuilder,
+  NodeDevApi: () => NodeDevApi,
   NodeEventType: () => NodeEventType,
   NodeFileSource: () => NodeFileSource,
   NodeHelpers: () => NodeHelpers,
   NodeOperations: () => NodeOperations,
   NodeTypes: () => NodeTypes,
   RAISIN_CONTEXT_KEY: () => RAISIN_CONTEXT_KEY,
+  RETRY_STRATEGIES: () => RETRY_STRATEGIES,
   RaisinAbortError: () => RaisinAbortError,
   RaisinAuthError: () => RaisinAuthError,
   RaisinClient: () => RaisinClient,
@@ -83,6 +91,7 @@ __export(index_exports, {
   ResponseStatus: () => ResponseStatus,
   RetryBuilder: () => RetryBuilder,
   SSEClient: () => SSEClient,
+  SchedulerApi: () => SchedulerApi,
   SqlQuery: () => SqlQuery,
   Tags: () => Tags,
   Transaction: () => Transaction,
@@ -90,6 +99,7 @@ __export(index_exports, {
   UploadErrorCode: () => UploadErrorCode,
   UploadManager: () => UploadManager,
   Uploader: () => Uploader,
+  VisitorChatError: () => VisitorChatError,
   WorkspaceClient: () => WorkspaceClient,
   WorkspaceManager: () => WorkspaceManager,
   calculateChunkCount: () => calculateChunkCount,
@@ -104,35 +114,45 @@ __export(index_exports, {
   createFlowAdapter: () => createFlowAdapter,
   createLoader: () => createLoader,
   createRaisinReact: () => createRaisinReact,
+  createRaisinVue: () => createRaisinVue,
   createRequestScopedClient: () => createRequestScopedClient,
   createSSRClient: () => createSSRClient,
   createSqlAdapter: () => createSqlAdapter,
   createSqlHandler: () => createSqlHandler,
   createSubscriptionAdapter: () => createSubscriptionAdapter,
   decodeMessage: () => decodeMessage,
+  defaultVisitorSessionStore: () => defaultVisitorSessionStore,
   encodeMessage: () => encodeMessage,
   getChunkRange: () => getChunkRange,
   getContentType: () => getContentType,
   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,
+  newControlId: () => newControlId,
+  normalizeHomePath: () => normalizeHomePath,
   projectPlansFromMessages: () => projectPlansFromMessages,
+  readTokensFromFragment: () => readTokensFromFragment,
   rowsToObjects: () => rowsToObjects,
   setLogLevel: () => setLogLevel,
   sleep: () => sleep,
+  subjectOf: () => subjectOf,
   useConversation: () => useConversation,
   useConversationList: () => useConversationList,
   useFlow: () => useFlow,
   withRetry: () => withRetry
 });
-module.exports = __toCommonJS(index_exports);
+module.exports = __toCommonJS(src_exports);
 
 // src/client.ts
 var import_events4 = require("events");
@@ -326,7 +346,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 +363,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 +455,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
    */
@@ -677,7 +708,7 @@ var LocalStorageTokenStorage = class {
 function isJwtCredentials(credentials) {
   return "type" in credentials && credentials.type === "jwt";
 }
-var AuthManager = class {
+var AuthManager = class _AuthManager {
   constructor(storage) {
     this.expiresAt = null;
     this._storage = storage ?? new MemoryTokenStorage();
@@ -700,6 +731,31 @@ var AuthManager = class {
     this.expiresAt = Date.now() + expiresInMs;
     this.scheduleTokenRefresh(expiresInMs);
   }
+  /**
+   * Learn a bare token's expiry FROM THE TOKEN.
+   *
+   * `setTokens` is the only other writer of `expiresAt`, and it needs a whole
+   * `AuthenticateResponse`. Several paths hold nothing but a JWT string — a
+   * session restored from storage, `authenticate({type:'jwt'})`,
+   * `setIdentityTokens(token)` — and left `expiresAt` null. `isTokenExpired()`
+   * reads null as EXPIRED, so `isAuthenticated()` answered false for the whole
+   * life of every restored session, i.e. every page load after the first.
+   *
+   * It failed silently, and it had already been routed around three times
+   * rather than fixed: both HTTP send paths were made to stop consulting
+   * `isAuthenticated()` (see `request()` and `mcpStream()` in http-client),
+   * and Studio grew its own token parse to tell a 404 apart from a logged-out
+   * read. This is the missing writer those workarounds existed for.
+   *
+   * Same 60s safety margin as `setTokens`, so both writers agree on when a
+   * token stops counting as good.
+   *
+   * @param token - A JWT held in storage or handed to us
+   */
+  adoptToken(token) {
+    const exp = _AuthManager.parseToken(token)?.exp;
+    this.expiresAt = typeof exp === "number" ? exp * 1e3 - 6e4 : null;
+  }
   /**
    * Get current access token
    */
@@ -818,6 +874,7 @@ var RequestType = /* @__PURE__ */ ((RequestType2) => {
   RequestType2["NodeUpdate"] = "node_update";
   RequestType2["NodeDelete"] = "node_delete";
   RequestType2["NodeGet"] = "node_get";
+  RequestType2["NodeGetByLocalizedPath"] = "node_get_by_localized_path";
   RequestType2["NodeQuery"] = "node_query";
   RequestType2["NodeQueryByPath"] = "node_query_by_path";
   RequestType2["NodeQueryByProperty"] = "node_query_by_property";
@@ -831,6 +888,7 @@ var RequestType = /* @__PURE__ */ ((RequestType2) => {
   RequestType2["NodeReorder"] = "node_reorder";
   RequestType2["NodeMoveChildBefore"] = "node_move_child_before";
   RequestType2["NodeMoveChildAfter"] = "node_move_child_after";
+  RequestType2["NodeApplyChildOrder"] = "node_apply_child_order";
   RequestType2["PropertyGet"] = "property_get";
   RequestType2["PropertyUpdate"] = "property_update";
   RequestType2["RelationAdd"] = "relation_add";
@@ -850,6 +908,8 @@ var RequestType = /* @__PURE__ */ ((RequestType2) => {
   RequestType2["BranchUpdateHead"] = "branch_update_head";
   RequestType2["BranchMerge"] = "branch_merge";
   RequestType2["BranchCompare"] = "branch_compare";
+  RequestType2["BranchDiff"] = "branch_diff";
+  RequestType2["BranchCopyNodes"] = "branch_copy_nodes";
   RequestType2["TagCreate"] = "tag_create";
   RequestType2["TagGet"] = "tag_get";
   RequestType2["TagList"] = "tag_list";
@@ -870,6 +930,7 @@ var RequestType = /* @__PURE__ */ ((RequestType2) => {
   RequestType2["ArchetypeDelete"] = "archetype_delete";
   RequestType2["ArchetypePublish"] = "archetype_publish";
   RequestType2["ArchetypeUnpublish"] = "archetype_unpublish";
+  RequestType2["ArchetypeGetResolved"] = "archetype_get_resolved";
   RequestType2["ElementTypeCreate"] = "element_type_create";
   RequestType2["ElementTypeGet"] = "element_type_get";
   RequestType2["ElementTypeList"] = "element_type_list";
@@ -877,6 +938,7 @@ var RequestType = /* @__PURE__ */ ((RequestType2) => {
   RequestType2["ElementTypeDelete"] = "element_type_delete";
   RequestType2["ElementTypePublish"] = "element_type_publish";
   RequestType2["ElementTypeUnpublish"] = "element_type_unpublish";
+  RequestType2["ElementTypeGetResolved"] = "element_type_get_resolved";
   RequestType2["FullTextSearch"] = "full_text_search";
   RequestType2["VectorSearch"] = "vector_search";
   RequestType2["Subscribe"] = "subscribe";
@@ -899,8 +961,23 @@ var RequestType = /* @__PURE__ */ ((RequestType2) => {
   RequestType2["FlowCancel"] = "flow_cancel";
   RequestType2["FlowSubscribeEvents"] = "flow_subscribe_events";
   RequestType2["FlowUnsubscribeEvents"] = "flow_unsubscribe_events";
+  RequestType2["AgentRunCreate"] = "agent_run_create";
+  RequestType2["AgentRunGet"] = "agent_run_get";
+  RequestType2["AgentRunBySubject"] = "agent_run_by_subject";
+  RequestType2["AgentRunList"] = "agent_run_list";
+  RequestType2["AgentRunEvents"] = "agent_run_events";
+  RequestType2["AgentRunSubscribe"] = "agent_run_subscribe";
+  RequestType2["AgentRunUnsubscribe"] = "agent_run_unsubscribe";
+  RequestType2["AgentRunControl"] = "agent_run_control";
+  RequestType2["AgentRunChildren"] = "agent_run_children";
   RequestType2["FunctionInvoke"] = "function_invoke";
   RequestType2["FunctionInvokeSync"] = "function_invoke_sync";
+  RequestType2["ScheduledInvocationCreate"] = "scheduled_invocation_create";
+  RequestType2["ScheduledInvocationCancel"] = "scheduled_invocation_cancel";
+  RequestType2["ScheduledInvocationList"] = "scheduled_invocation_list";
+  RequestType2["ScheduledInvocationGet"] = "scheduled_invocation_get";
+  RequestType2["VisitorChatStart"] = "visitor_chat_start";
+  RequestType2["VisitorChatSend"] = "visitor_chat_send";
   return RequestType2;
 })(RequestType || {});
 var ResponseStatus = /* @__PURE__ */ ((ResponseStatus2) => {
@@ -1010,6 +1087,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
@@ -1176,7 +1261,8 @@ var EventHandler = class {
     this.filterSubscriptions.set(hash, {
       serverId: subscriptionId,
       filters: {},
-      callbacks: /* @__PURE__ */ new Set([callback])
+      callbacks: /* @__PURE__ */ new Set([callback]),
+      synthetic: true
     });
     this.subscriptions.set(subscriptionId, hash);
     this.callbackToHash.set(callback, hash);
@@ -1200,14 +1286,30 @@ 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()) {
+        if (entry.synthetic) continue;
+        this.subscriptions.delete(entry.serverId);
+        entry.restorePending = true;
+      }
+    }
+    const entriesToRestore = Array.from(this.filterSubscriptions.entries()).filter(([, entry]) => entry.restorePending && !entry.synthetic);
+    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 +1317,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 +1369,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)
@@ -1312,6 +1424,40 @@ var NodeOperations = class {
     const result = await this.sendRequest(payload);
     return result;
   }
+  /**
+   * Create a node, auto-creating any missing ancestor folders.
+   *
+   * @param options - Node creation options (with optional `parentNodeType`)
+   * @returns Created node
+   */
+  async createDeep(options) {
+    const payload = {
+      node_type: options.type,
+      path: options.path,
+      properties: options.properties ?? {},
+      content: options.content,
+      parent_node_type: options.parentNodeType
+    };
+    const result = await this.sendRequest(payload, "node_create_deep");
+    return result;
+  }
+  /**
+   * Upsert a node by path (create-or-update), auto-creating any missing ancestor folders.
+   *
+   * @param options - Node creation options (with optional `parentNodeType`)
+   * @returns Upserted node
+   */
+  async upsertDeep(options) {
+    const payload = {
+      node_type: options.type,
+      path: options.path,
+      properties: options.properties ?? {},
+      content: options.content,
+      parent_node_type: options.parentNodeType
+    };
+    const result = await this.sendRequest(payload, "node_upsert_deep");
+    return result;
+  }
   /**
    * Update an existing node
    *
@@ -1361,6 +1507,96 @@ var NodeOperations = class {
       throw error;
     }
   }
+  /**
+   * List a node's revision history (git-style "file history"), newest first.
+   *
+   * Each entry carries the `revision` (usable with `atRevision()` reads to
+   * fetch the full snapshot), plus when/who and whether the node was deleted
+   * at that revision. Always available regardless of the NodeType `auditable`
+   * flag — it reflects the structural MVCC version history.
+   *
+   * @param id - Node ID
+   * @param options - Optional `{ limit }` to cap the number of revisions
+   * @returns Array of revision entries (newest first)
+   *
+   * @example
+   * ```typescript
+   * const history = await ws.nodes().history(nodeId, { limit: 50 });
+   * for (const rev of history) {
+   *   const snapshot = await ws.atRevision(rev.revision).nodes().get(nodeId);
+   * }
+   * ```
+   */
+  async history(id, options) {
+    const payload = {
+      node_id: id,
+      limit: options?.limit
+    };
+    const result = await this.sendRequest(payload, "node_history");
+    return result ?? [];
+  }
+  /**
+   * Get a node by its localized URL path (plan Phase 12).
+   *
+   * @param locale - Locale code (`fr`, `fr-CA`)
+   * @param path - The node's path in that locale (`/produits/chaise`)
+   * @returns The translated node with `canonical_path`,
+   *   `canonical_localized_path`, hreflang `alternates` and a `redirect`
+   *   hint, or `null` when nothing resolves (missing, hidden in the locale
+   *   or not readable — the same answer)
+   *
+   * @example
+   * ```typescript
+   * const hit = await ws.nodes().getByLocalizedPath('fr', '/produits/chaise');
+   * if (hit?.redirect) redirect301(`/fr${hit.canonical_localized_path}`);
+   * ```
+   */
+  async getByLocalizedPath(locale, path) {
+    const payload = { locale, path };
+    const result = await this.sendRequest(payload, "node_get_by_localized_path");
+    return result ?? null;
+  }
+  /**
+   * List a node's revision history by path (newest first).
+   *
+   * @param path - Node path
+   * @param options - Optional `{ limit }` to cap the number of revisions
+   * @returns Array of revision entries (newest first)
+   */
+  async historyByPath(path, options) {
+    const payload = {
+      path,
+      limit: options?.limit
+    };
+    const result = await this.sendRequest(payload, "node_history");
+    return result ?? [];
+  }
+  /**
+   * Query a node's audit-log entries by ID.
+   *
+   * Audit logs are only produced for NodeTypes marked `auditable`. This is
+   * distinct from {@link history}, which is the always-on structural revision
+   * history available for every node.
+   *
+   * @param id - Node ID
+   * @returns Array of audit-log entries
+   */
+  async auditLog(id) {
+    const payload = { node_id: id };
+    const result = await this.sendRequest(payload, "audit_query");
+    return result ?? [];
+  }
+  /**
+   * Query a node's audit-log entries by path.
+   *
+   * @param path - Node path
+   * @returns Array of audit-log entries
+   */
+  async auditLogByPath(path) {
+    const payload = { path };
+    const result = await this.sendRequest(payload, "audit_query");
+    return result ?? [];
+  }
   /**
    * Query nodes
    *
@@ -1383,15 +1619,8 @@ var NodeOperations = class {
    * @returns Node or null if not found
    */
   async getByPath(path) {
-    try {
-      const result = await this.query({
-        query: { path },
-        limit: 1
-      });
-      return result.length > 0 ? result[0] : null;
-    } catch (error) {
-      return null;
-    }
+    const result = await this.sendRequest({ path }, "node_query_by_path");
+    return result ?? null;
   }
   /**
    * Query nodes by property
@@ -1402,14 +1631,12 @@ var NodeOperations = class {
    * @returns Array of nodes
    */
   async queryByProperty(propertyName, propertyValue, limit) {
-    return this.query({
-      query: {
-        properties: {
-          [propertyName]: propertyValue
-        }
-      },
+    const payload = {
+      query: { [propertyName]: propertyValue },
       limit
-    });
+    };
+    const result = await this.sendRequest(payload, "node_query_by_property");
+    return result;
   }
   /**
    * Query nodes by type
@@ -1420,7 +1647,7 @@ var NodeOperations = class {
    */
   async queryByType(nodeType, limit) {
     return this.query({
-      query: { node_type: nodeType },
+      query: { type: nodeType },
       limit
     });
   }
@@ -1455,17 +1682,40 @@ var NodeOperations = class {
   // Tree Operations
   // ========================================================================
   /**
-   * List children of a parent node
+   * List children of a parent node, in editorial (drag-and-drop) order.
    *
    * @param parentPath - Path of the parent node
    * @returns Array of child nodes
    */
   async listChildren(parentPath) {
+    const { items } = await this.listChildrenPage(parentPath);
+    return items;
+  }
+  /**
+   * List one page of a parent's children, in editorial order.
+   *
+   * Pagination is keyset-based: pass the previous response's `nextCursor` back as
+   * `cursor` to get the following page. `nextCursor` is `null` on the last page.
+   * Treat the cursor as opaque — do not parse or construct it.
+   *
+   * @param parentPath - Path of the parent node
+   * @param options - `cursor` from a previous page, and page `limit`
+   */
+  async listChildrenPage(parentPath, options = {}) {
     const payload = {
       parent_path: parentPath
     };
+    if (options.cursor !== void 0) payload.cursor = options.cursor;
+    if (options.limit !== void 0) payload.limit = options.limit;
     const result = await this.sendRequest(payload, "node_list_children");
-    return result;
+    if (Array.isArray(result)) {
+      return { items: result, nextCursor: null };
+    }
+    const page = result;
+    return {
+      items: page.nodes ?? [],
+      nextCursor: page.next_cursor == null ? null : JSON.stringify(page.next_cursor)
+    };
   }
   /**
    * Get a node tree starting from a root node
@@ -1476,7 +1726,7 @@ var NodeOperations = class {
    */
   async getTree(rootPath, maxDepth) {
     const payload = {
-      root_path: rootPath
+      parent_path: rootPath
     };
     if (maxDepth !== void 0) {
       payload.max_depth = maxDepth;
@@ -1493,7 +1743,7 @@ var NodeOperations = class {
    */
   async getTreeFlat(rootPath, maxDepth) {
     const payload = {
-      root_path: rootPath
+      parent_path: rootPath
     };
     if (maxDepth !== void 0) {
       payload.max_depth = maxDepth;
@@ -1528,7 +1778,7 @@ var NodeOperations = class {
    */
   async rename(nodePath, newName) {
     const payload = {
-      node_path: nodePath,
+      old_path: nodePath,
       new_name: newName
     };
     const result = await this.sendRequest(payload, "node_rename");
@@ -1544,9 +1794,8 @@ var NodeOperations = class {
    */
   async copy(fromPath, toParentPath, newName) {
     const payload = {
-      from_path: fromPath,
-      to_parent_path: toParentPath,
-      deep: false
+      source_path: fromPath,
+      target_parent: toParentPath
     };
     if (newName !== void 0) {
       payload.new_name = newName;
@@ -1564,9 +1813,8 @@ var NodeOperations = class {
    */
   async copyTree(fromPath, toParentPath, newName) {
     const payload = {
-      from_path: fromPath,
-      to_parent_path: toParentPath,
-      deep: true
+      source_path: fromPath,
+      target_parent: toParentPath
     };
     if (newName !== void 0) {
       payload.new_name = newName;
@@ -1575,53 +1823,72 @@ var NodeOperations = class {
     return result;
   }
   /**
-   * Reorder a node by setting a new order key
+   * Move a child to a specific position among its siblings.
    *
-   * @param nodePath - Node path
-   * @param orderKey - New order key (base62-encoded fractional index)
-   * @returns Reordered node
+   * Positions are 0-based; a position past the end appends. The server owns the
+   * fractional order key — you name a position, it mints the key.
+   *
+   * @param parentPath - Parent node path
+   * @param childName - Name of the child to move (not a full path)
+   * @param position - Target 0-based position among the parent's children
+   * @returns The reordered node, carrying its newly assigned `order_key`
    */
-  async reorder(nodePath, orderKey) {
+  async reorder(parentPath, childName, position) {
     const payload = {
-      node_path: nodePath,
-      order_key: orderKey
+      parent_path: parentPath,
+      child_name: childName,
+      position
     };
     const result = await this.sendRequest(payload, "node_reorder");
     return result;
   }
   /**
-   * Move a child node before a reference sibling
+   * Move a child so it sits immediately before one of its siblings.
    *
    * @param parentPath - Parent node path
-   * @param childPath - Child node path to move
-   * @param referencePath - Reference sibling path to position before
-   * @returns Moved node
+   * @param childName - Name of the child to move (not a full path)
+   * @param beforeChildName - Name of the sibling to sit before
    */
-  async moveChildBefore(parentPath, childPath, referencePath) {
+  async moveChildBefore(parentPath, childName, beforeChildName) {
     const payload = {
       parent_path: parentPath,
-      child_path: childPath,
-      reference_path: referencePath
+      child_name: childName,
+      before_child_name: beforeChildName
     };
-    const result = await this.sendRequest(payload, "node_move_child_before");
-    return result;
+    await this.sendRequest(payload, "node_move_child_before");
   }
   /**
-   * Move a child node after a reference sibling
+   * Move a child so it sits immediately after one of its siblings.
    *
    * @param parentPath - Parent node path
-   * @param childPath - Child node path to move
-   * @param referencePath - Reference sibling path to position after
-   * @returns Moved node
+   * @param childName - Name of the child to move (not a full path)
+   * @param afterChildName - Name of the sibling to sit after
    */
-  async moveChildAfter(parentPath, childPath, referencePath) {
+  async moveChildAfter(parentPath, childName, afterChildName) {
     const payload = {
       parent_path: parentPath,
-      child_path: childPath,
-      reference_path: referencePath
+      child_name: childName,
+      after_child_name: afterChildName
     };
-    const result = await this.sendRequest(payload, "node_move_child_after");
-    return result;
+    await this.sendRequest(payload, "node_move_child_after");
+  }
+  /**
+   * Replay a parent's child order from another branch onto the current branch.
+   *
+   * Carries node sibling-order across branches — useful for selective publish
+   * flows, where copying node content (e.g. via SQL) does not move the ordering
+   * index. Only children that exist under the parent on both branches are
+   * reordered. The target branch is the connection's current branch.
+   *
+   * @param parentPath - Parent node path
+   * @param sourceBranch - Branch to copy the child order FROM
+   */
+  async applyChildOrder(parentPath, sourceBranch) {
+    const payload = {
+      parent_path: parentPath,
+      source_branch: sourceBranch
+    };
+    await this.sendRequest(payload, "node_apply_child_order");
   }
   // ========================================================================
   // Relationship Operations
@@ -1897,7 +2164,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;
@@ -2506,7 +2783,8 @@ function createSqlHandler(sendRequest) {
 
 // src/node-types.ts
 var NodeTypes = class {
-  constructor(_context, sendRequest) {
+  constructor(context, sendRequest) {
+    this.context = context;
     this.sendRequest = sendRequest;
   }
   /**
@@ -2590,14 +2868,25 @@ var NodeTypes = class {
     );
   }
   /**
-   * Validate a node against its NodeType
+   * Validate a node against its NodeType.
+   *
+   * The server validates in the context of a workspace (workspace-level
+   * allow-lists and unique checks), so one is required. Pass it here, or
+   * create the database with a workspace already in its context.
    */
-  async validate(node) {
+  async validate(node, workspace) {
+    const ws = workspace ?? this.context.workspace;
+    if (!ws) {
+      throw new Error(
+        "nodeTypes().validate() requires a workspace: pass it as the second argument"
+      );
+    }
     return this.sendRequest(
       {
         node
       },
-      "node_type_validate" /* NodeTypeValidate */
+      "node_type_validate" /* NodeTypeValidate */,
+      { ...this.context, workspace: ws }
     );
   }
   /**
@@ -2698,6 +2987,17 @@ var Archetypes = class {
       "archetype_unpublish" /* ArchetypeUnpublish */
     );
   }
+  /**
+   * Get resolved Archetype with full inheritance applied
+   */
+  async getResolved(name) {
+    return this.sendRequest(
+      {
+        name
+      },
+      "archetype_get_resolved" /* ArchetypeGetResolved */
+    );
+  }
 };
 
 // src/element-types.ts
@@ -2785,6 +3085,17 @@ var ElementTypes = class {
       "element_type_unpublish" /* ElementTypeUnpublish */
     );
   }
+  /**
+   * Get resolved ElementType with full inheritance applied
+   */
+  async getResolved(name) {
+    return this.sendRequest(
+      {
+        name
+      },
+      "element_type_get_resolved" /* ElementTypeGetResolved */
+    );
+  }
 };
 
 // src/branches.ts
@@ -2886,6 +3197,110 @@ var Branches = class {
       "branch_compare" /* BranchCompare */
     );
   }
+  /**
+   * Per-node diff of `branch` relative to `baseBranch` (added/modified/deleted).
+   *
+   * Cheaper than reading both branch listings: cost scales with the number of
+   * changed nodes since the branches diverged, not the total content.
+   */
+  async diff(branch, baseBranch) {
+    return this.sendRequest(
+      {
+        branch,
+        base_branch: baseBranch
+      },
+      "branch_diff" /* BranchDiff */
+    );
+  }
+  /**
+   * Copy a node set from `sourceBranch` onto `targetBranch` (branch
+   * promotion): node ids are preserved, so repeated copies update the same
+   * target nodes; all changes land in ONE atomic commit on the target branch.
+   *
+   * Each root's parent path must already exist on the target branch. With
+   * `deleteMissing`, target nodes under the roots that are absent from the
+   * copied source set are pruned (one-way sync).
+   *
+   * `sourceRevision` pins the read to a point in time. A promotion of a large
+   * set is not instantaneous, so without it the copy reads each node when its
+   * turn comes and a writer working in parallel lands partly inside the result
+   * — a torn snapshot. Pass the revision captured when the operation was
+   * decided (see `getHead`) to copy exactly that state. The target branch is
+   * always resolved at its head: the pin says WHAT to copy, never where.
+   */
+  async copyNodes(sourceBranch, targetBranch, opts) {
+    return this.sendRequest(
+      {
+        source_branch: sourceBranch,
+        target_branch: targetBranch,
+        workspace: opts.workspace,
+        roots: opts.roots,
+        recursive: opts.recursive ?? true,
+        delete_missing: opts.deleteMissing ?? false,
+        source_revision: opts.sourceRevision ?? null
+      },
+      "branch_copy_nodes" /* BranchCopyNodes */
+    );
+  }
+};
+
+// src/scheduler.ts
+var SchedulerApi = class {
+  constructor(_context, sendRequest) {
+    this.sendRequest = sendRequest;
+  }
+  /**
+   * Schedule a one-shot invocation of a function or flow at a fixed time.
+   */
+  async schedule(options) {
+    const runAt = options.runAt instanceof Date ? options.runAt.toISOString() : options.runAt;
+    return this.sendRequest(
+      {
+        target_kind: options.targetKind,
+        target_path: options.targetPath,
+        input: options.input ?? {},
+        run_at: runAt,
+        external_key: options.externalKey,
+        branch: options.branch,
+        workspace: options.workspace,
+        max_retries: options.maxRetries
+      },
+      "scheduled_invocation_create" /* ScheduledInvocationCreate */
+    );
+  }
+  /**
+   * Cancel a pending invocation before it fires, by job id or external key.
+   */
+  async cancel(ref) {
+    const payload = typeof ref === "string" ? { job_id: ref } : { job_id: ref.jobId, external_key: ref.externalKey };
+    return this.sendRequest(
+      payload,
+      "scheduled_invocation_cancel" /* ScheduledInvocationCancel */
+    );
+  }
+  /**
+   * List this repository's scheduled invocations.
+   */
+  async list(filter) {
+    const result = await this.sendRequest(
+      {
+        external_key: filter?.externalKey,
+        status: filter?.status
+      },
+      "scheduled_invocation_list" /* ScheduledInvocationList */
+    );
+    return result?.invocations ?? [];
+  }
+  /**
+   * Fetch a single scheduled invocation, by job id or external key.
+   */
+  async get(ref) {
+    const payload = typeof ref === "string" ? { job_id: ref } : { job_id: ref.jobId, external_key: ref.externalKey };
+    return this.sendRequest(
+      payload,
+      "scheduled_invocation_get" /* ScheduledInvocationGet */
+    );
+  }
 };
 
 // src/tags.ts
@@ -3064,29 +3479,440 @@ function createAsyncQueue() {
   };
 }
 
-// src/functions-api.ts
-var FunctionsApi = class {
-  constructor(repository, context, sendRequest) {
-    this.context = { ...context, repository };
-    this.sendRequest = sendRequest;
+// src/agent-run-children.ts
+function spawnBody(o) {
+  return {
+    objective: o.objective,
+    budgets: o.budgets,
+    on_exceeded: o.onExceeded,
+    spawn_key: o.spawnKey,
+    subject: o.subject,
+    as_agent: o.asAgent,
+    agent_ref: o.agentRef,
+    input: o.input ?? null,
+    executor_config: o.executorConfig,
+    reducer: o.reducer,
+    inherit_reducer: o.inheritReducer ?? false
+  };
+}
+function checkpointBody(o) {
+  return {
+    fence: o.fence,
+    operation_id: o.operationId,
+    reason: o.reason,
+    summary: o.summary,
+    transcript_cutoff: o.transcriptCutoff,
+    state: o.state,
+    large_refs: o.largeRefs ?? []
+  };
+}
+
+// src/agent-runs.ts
+function createRunBody(options) {
+  return {
+    subject: options.subject,
+    branch: options.branch,
+    agent_ref: options.agentRef,
+    create_key: options.createKey,
+    budgets: options.budgets,
+    input: options.input ?? null,
+    reducer: options.reducer,
+    executor_config: options.executorConfig,
+    control_capability: options.controlCapability,
+    as_agent: options.asAgent
+  };
+}
+function subjectOf(subject) {
+  if (typeof subject !== "string") return subject;
+  const cut = subject.indexOf(":/");
+  if (cut <= 0) throw new Error(`subject must be "workspace:/path", got "${subject}"`);
+  return { workspace: subject.slice(0, cut), path: subject.slice(cut + 1) };
+}
+var controlCounter = 0;
+function newControlId(prefix = "ctl") {
+  controlCounter += 1;
+  const rand = Math.random().toString(36).slice(2, 10);
+  return `${prefix}-${Date.now().toString(36)}-${controlCounter}-${rand}`;
+}
+var AgentRunsApi = class {
+  constructor(repository, transport) {
+    this.repository = repository;
+    this.transport = transport;
+  }
+  base(runId, rest = "") {
+    const repo = encodeURIComponent(this.repository);
+    const run = runId ? `/${encodeURIComponent(runId)}` : "";
+    return `/api/agent-runs/${repo}${run}${rest}`;
+  }
+  /** Create a run, or get back the subject's live run. */
+  create(options) {
+    return this.transport.request("POST", this.base(), createRunBody(options));
+  }
+  /** Every run about `subject` you may see, newest (the live one) first. */
+  bySubject(subject, limit = 20) {
+    const s = subjectOf(subject);
+    const q = new URLSearchParams({ subject: `${s.workspace}:${s.path ?? ""}`, limit: String(limit) });
+    if (s.node_id) q.set("subject_node_id", s.node_id);
+    return this.transport.request("GET", `${this.base()}?${q.toString()}`);
+  }
+  /** Read a run (record + effective projection). */
+  get(runId) {
+    return this.transport.request("GET", this.base(runId));
+  }
+  /** Your runs in one status (default "running"). */
+  list(status = "running", limit = 50) {
+    return this.transport.request("GET", `${this.base()}?status=${status}&limit=${limit}`);
+  }
+  /** Durable events after `afterSeq` (gap-free; page with the last seq). */
+  events(runId, afterSeq = 0, limit = 500) {
+    return this.transport.request("GET", this.base(runId, `/events?after_seq=${afterSeq}&limit=${limit}`));
+  }
+  /** Any control. Retrying with the same `controlId` is a no-op. */
+  control(runId, command, controlId = newControlId(command.command), capability) {
+    return this.transport.request("POST", this.base(runId, "/control"), {
+      control_id: controlId,
+      command,
+      capability
+    });
+  }
+  stop(runId, reason, controlId) {
+    return this.control(runId, { command: "stop", reason }, controlId);
+  }
+  pause(runId, controlId) {
+    return this.control(runId, { command: "pause" }, controlId);
+  }
+  resume(runId, controlId) {
+    return this.control(runId, { command: "resume" }, controlId);
+  }
+  /** Queue input for the run's next safe boundary. */
+  steer(runId, input, controlId) {
+    return this.control(runId, { command: "steer", input }, controlId);
+  }
+  /** Decide an approval request; the digest ties it to one changeset. */
+  approve(runId, requestId, subjectDigest, reject, controlId) {
+    const decision = reject ? { decision: "reject", reason: reject.reason } : { decision: "approve" };
+    return this.control(
+      runId,
+      { command: "approve", request_id: requestId, decision, subject_digest: subjectDigest },
+      controlId
+    );
+  }
+  /** Answer an input request. */
+  answer(runId, requestId, value, controlId) {
+    return this.control(runId, { command: "provide_input", request_id: requestId, value }, controlId);
   }
   /**
-   * Invoke a server-side function by name (async).
-   *
-   * Queues a `FunctionExecution` job and returns the execution and job IDs
-   * immediately. The function runs asynchronously on the server.
-   *
-   * @param functionName - Name of the function to invoke
-   * @param input - Input data passed to the function
-   * @returns Execution ID and job ID for tracking
+   * Stream the run's events: replay after `afterSeq`, then live. Ends after
+   * the run's terminal event. Resume after a disconnect with the last `seq`.
    */
-  async invoke(functionName, input, options) {
-    const effectiveRequestTimeoutMs = options?.requestTimeoutMs;
-    let effectiveWaitTimeoutMs = options?.waitTimeoutMs;
-    if (options?.waitForResult) {
-      const transportTimeoutBudget = effectiveRequestTimeoutMs ?? 3e4;
-      effectiveWaitTimeoutMs = Math.min(
-        effectiveWaitTimeoutMs ?? transportTimeoutBudget,
+  async *stream(runId, afterSeq = 0, signal) {
+    const response = await this.transport.fetch(
+      this.transport.url(this.base(runId, `/stream?after_seq=${afterSeq}`)),
+      { headers: { ...this.transport.headers(), Accept: "text/event-stream" }, signal }
+    );
+    if (!response.ok || !response.body) {
+      throw new Error(`agent run stream failed: ${response.status} ${await response.text()}`);
+    }
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    for (; ; ) {
+      const { value, done } = await reader.read();
+      if (done) return;
+      buffer += decoder.decode(value, { stream: true });
+      let cut;
+      while ((cut = buffer.indexOf("\n\n")) >= 0) {
+        const block = buffer.slice(0, cut);
+        buffer = buffer.slice(cut + 2);
+        let event = "message";
+        let data = "";
+        for (const line of block.split("\n")) {
+          if (line.startsWith("event:")) event = line.slice(6).trim();
+          else if (line.startsWith("data:")) data += line.slice(5).trim();
+        }
+        if (event === "end") return;
+        if (event === "error") throw new Error(`agent run stream error: ${data}`);
+        if (event === "run-event" && data) yield JSON.parse(data);
+      }
+    }
+  }
+  // ---- client-driven runs -------------------------------------------------
+  /** Take the lease of a queued client-driven run. */
+  acquire(runId) {
+    return this.transport.request("POST", this.base(runId, "/lease/acquire"), {});
+  }
+  renew(runId, fence) {
+    return this.transport.request("POST", this.base(runId, "/lease/renew"), { fence });
+  }
+  release(runId, fence) {
+    return this.transport.request("POST", this.base(runId, "/lease/release"), { fence });
+  }
+  /** Begin an operation; returns the active operation (its `op_id`). */
+  begin(runId, fence, op) {
+    return this.transport.request("POST", this.base(runId, "/operations"), { fence, ...op });
+  }
+  /** Record an operation's result. */
+  finish(runId, fence, opId, result) {
+    return this.transport.request("POST", this.base(runId, "/operations/finish"), { fence, op_id: opId, ...result });
+  }
+  /** Open approval/input requests and wait (`kind: "approval" | "input"`). */
+  wait(runId, fence, requests) {
+    return this.transport.request("POST", this.base(runId, "/wait"), { fence, requests });
+  }
+  /** End a client-driven run. */
+  complete(runId, fence, status, outcome) {
+    return this.transport.request("POST", this.base(runId, "/complete"), { fence, status, outcome });
+  }
+  // ── Child runs, mailbox, checkpoints, usage ──────────────────────────────
+  /** Spawn a child with a typed objective; its budgets come out of this run's. */
+  spawnChild(runId, options) {
+    const q = options.branch ? `?branch=${encodeURIComponent(options.branch)}` : "";
+    return this.transport.request("POST", this.base(runId, `/children${q}`), spawnBody(options));
+  }
+  /** Every child of a run: the parent's link plus the child's live status. */
+  children(runId) {
+    return this.transport.request("GET", this.base(runId, "/children"));
+  }
+  /** Inspect one child: record, events after `afterSeq`, usage, checkpoint. */
+  inspectChild(runId, childId, afterSeq = 0, limit = 200) {
+    const rest = `/children/${encodeURIComponent(childId)}?after_seq=${afterSeq}&limit=${limit}`;
+    return this.transport.request("GET", this.base(runId, rest));
+  }
+  /** Message, steer, interrupt or resume a child (idempotent per `controlId`). */
+  controlChild(runId, childId, action, controlId = newControlId(action.action)) {
+    const rest = `/children/${encodeURIComponent(childId)}/control`;
+    return this.transport.request("POST", this.base(runId, rest), { control_id: controlId, ...action });
+  }
+  messageChild(runId, childId, message, controlId) {
+    return this.controlChild(runId, childId, { action: "message", message }, controlId);
+  }
+  steerChild(runId, childId, input, controlId) {
+    return this.controlChild(runId, childId, { action: "steer", input }, controlId);
+  }
+  interruptChild(runId, childId, reason, mode = "stop", controlId) {
+    return this.controlChild(runId, childId, { action: "interrupt", mode, reason }, controlId);
+  }
+  /** A client-driven parent waits (under its lease) for a child's hand-back. */
+  waitChild(runId, childId, fence, expiresAtMs) {
+    const rest = `/children/${encodeURIComponent(childId)}/wait`;
+    return this.transport.request("POST", this.base(runId, rest), { fence, expires_at_ms: expiresAtMs });
+  }
+  /** Unacknowledged mailbox items (hand-backs and child messages). */
+  mailbox(runId) {
+    return this.transport.request("GET", this.base(runId, "/mailbox"));
+  }
+  /** Acknowledge mailbox items up to `upTo`. */
+  ackMailbox(runId, upTo) {
+    return this.transport.request("POST", this.base(runId, "/mailbox/ack"), { up_to: upTo });
+  }
+  /** A child posts a message to its parent's mailbox (idempotent per id). */
+  postToParent(runId, messageId, message) {
+    return this.transport.request("POST", this.base(runId, "/post-to-parent"), { message_id: messageId, message });
+  }
+  /** Write a structured checkpoint (compaction keeps state, not prose). */
+  checkpoint(runId, options) {
+    return this.transport.request("POST", this.base(runId, "/checkpoints"), checkpointBody(options));
+  }
+  /** Read a checkpoint (default: latest) with its structured state. */
+  readCheckpoint(runId, checkpointNo) {
+    return this.transport.request("GET", this.base(runId, `/checkpoints/${checkpointNo ?? "latest"}`));
+  }
+  /** Usage accounting: own, children, reserved, spare. */
+  usage(runId) {
+    return this.transport.request("GET", this.base(runId, "/usage"));
+  }
+};
+
+// src/agent-runs-ws.ts
+var TERMINAL = ["completed", "failed", "stopped"];
+var AgentRunsWsApi = class {
+  constructor(context, sendRequest, eventHandler) {
+    this.context = context;
+    this.sendRequest = sendRequest;
+    this.eventHandler = eventHandler;
+  }
+  call(type, payload) {
+    return this.sendRequest(payload, type, this.context);
+  }
+  /** Create a run, or get back the subject's live run. */
+  create(options) {
+    return this.call("agent_run_create" /* AgentRunCreate */, createRunBody(options));
+  }
+  /** Read a run (record + effective projection). */
+  get(runId) {
+    return this.call("agent_run_get" /* AgentRunGet */, { run_id: runId });
+  }
+  /**
+   * Every run about `subject` (a conversation, a document) you may see,
+   * newest first — the live run, if there is one, comes first.
+   */
+  bySubject(subject, limit = 20) {
+    return this.call("agent_run_by_subject" /* AgentRunBySubject */, { ...subjectOf(subject), limit });
+  }
+  /** The newest run of `subject`, or null. */
+  async latest(subject) {
+    const [first] = await this.bySubject(subject, 1);
+    return first ?? null;
+  }
+  /** Your runs in one status (default "running"). */
+  list(status = "running", limit = 50) {
+    return this.call("agent_run_list" /* AgentRunList */, { status, limit });
+  }
+  /** Durable events after `afterSeq`. */
+  events(runId, afterSeq = 0, limit = 500) {
+    return this.call("agent_run_events" /* AgentRunEvents */, { run_id: runId, after_seq: afterSeq, limit });
+  }
+  /** The children a run spawned, with their current status. */
+  children(runId) {
+    return this.call("agent_run_children" /* AgentRunChildren */, { run_id: runId });
+  }
+  /** Any control. Retrying with the same `controlId` is a no-op. */
+  control(runId, command, controlId = newControlId(command.command), capability) {
+    return this.call("agent_run_control" /* AgentRunControl */, { run_id: runId, control_id: controlId, command, capability });
+  }
+  stop(runId, reason, controlId) {
+    return this.control(runId, { command: "stop", reason }, controlId);
+  }
+  pause(runId, controlId) {
+    return this.control(runId, { command: "pause" }, controlId);
+  }
+  resume(runId, controlId) {
+    return this.control(runId, { command: "resume" }, controlId);
+  }
+  /** Queue input for the run's next safe boundary. */
+  steer(runId, input, controlId) {
+    return this.control(runId, { command: "steer", input }, controlId);
+  }
+  /** Decide an approval request; the digest ties it to one changeset. */
+  approve(runId, requestId, subjectDigest, reject, controlId) {
+    const decision = reject ? { decision: "reject", reason: reject.reason } : { decision: "approve" };
+    return this.control(runId, { command: "approve", request_id: requestId, decision, subject_digest: subjectDigest }, controlId);
+  }
+  /** Answer an input request. */
+  answer(runId, requestId, value, controlId) {
+    return this.control(runId, { command: "provide_input", request_id: requestId, value }, controlId);
+  }
+  /**
+   * Follow a run: replay after `afterSeq`, then live, until the run ends.
+   *
+   * Events that reach the socket before the subscription is known here are
+   * not lost: the durable log is read once the listener is in place, live
+   * events are held until that read is merged, and every seq is delivered
+   * exactly once, in order.
+   */
+  async subscribe(runId, options = {}) {
+    let last = options.afterSeq ?? 0;
+    let ready = false;
+    let closed = false;
+    const held = [];
+    const buffer = [];
+    const waiters = [];
+    let resolveDone;
+    const done = new Promise((r) => resolveDone = r);
+    const close = (ended) => {
+      if (closed) return;
+      closed = true;
+      if (ended) options.onEnd?.(last);
+      for (const w of waiters.splice(0)) w({ value: void 0, done: true });
+      resolveDone();
+    };
+    const deliver = (ev) => {
+      if (closed || ev.seq <= last) return;
+      last = ev.seq;
+      options.onEvent?.(ev);
+      const w = waiters.shift();
+      if (w) w({ value: ev, done: false });
+      else buffer.push(ev);
+    };
+    const listener = (message) => {
+      if (message.event_type === "agent_run_end") {
+        if (ready) close(true);
+        else held.push({ seq: Number.MAX_SAFE_INTEGER });
+        return;
+      }
+      const ev = message.payload;
+      if (ready) deliver(ev);
+      else held.push(ev);
+    };
+    const response = await this.call("agent_run_subscribe" /* AgentRunSubscribe */, {
+      run_id: runId,
+      after_seq: last
+    });
+    const subscriptionId = response.subscription_id;
+    this.eventHandler.addFlowEventListener(subscriptionId, listener);
+    const unsubscribe = async () => {
+      this.eventHandler.removeFlowEventListener(subscriptionId);
+      close(false);
+      await this.call("agent_run_unsubscribe" /* AgentRunUnsubscribe */, { subscription_id: subscriptionId }).catch(() => void 0);
+    };
+    options.signal?.addEventListener("abort", () => void unsubscribe(), { once: true });
+    for (; ; ) {
+      const page = await this.events(runId, last, 500);
+      page.forEach(deliver);
+      if (page.length < 500) break;
+    }
+    ready = true;
+    const endSeen = held.some((e) => e.seq === Number.MAX_SAFE_INTEGER);
+    held.filter((e) => e.seq !== Number.MAX_SAFE_INTEGER).sort((a, b) => a.seq - b.seq).forEach(deliver);
+    if (endSeen) close(true);
+    else {
+      const view = await this.get(runId).catch(() => null);
+      const finalized = !view?.run?.domain || view.run.domain.finalized !== false;
+      if (view && TERMINAL.includes(view.status) && finalized) {
+        const tail = await this.events(runId, last, 500).catch(() => []);
+        tail.forEach(deliver);
+        this.eventHandler.removeFlowEventListener(subscriptionId);
+        close(true);
+      }
+    }
+    void done.then(() => this.eventHandler.removeFlowEventListener(subscriptionId));
+    return {
+      get lastSeq() {
+        return last;
+      },
+      done,
+      unsubscribe,
+      [Symbol.asyncIterator]() {
+        return {
+          next: () => {
+            const ev = buffer.shift();
+            if (ev) return Promise.resolve({ value: ev, done: false });
+            if (closed) return Promise.resolve({ value: void 0, done: true });
+            return new Promise((r) => waiters.push(r));
+          },
+          return: async () => {
+            await unsubscribe();
+            return { value: void 0, done: true };
+          }
+        };
+      }
+    };
+  }
+};
+
+// src/functions-api.ts
+var FunctionsApi = class {
+  constructor(repository, context, sendRequest) {
+    this.context = { ...context, repository };
+    this.sendRequest = sendRequest;
+  }
+  /**
+   * Invoke a server-side function by name (async).
+   *
+   * Queues a `FunctionExecution` job and returns the execution and job IDs
+   * immediately. The function runs asynchronously on the server.
+   *
+   * @param functionName - Name of the function to invoke
+   * @param input - Input data passed to the function
+   * @returns Execution ID and job ID for tracking
+   */
+  async invoke(functionName, input, options) {
+    const effectiveRequestTimeoutMs = options?.requestTimeoutMs;
+    let effectiveWaitTimeoutMs = options?.waitTimeoutMs;
+    if (options?.waitForResult) {
+      const transportTimeoutBudget = effectiveRequestTimeoutMs ?? 3e4;
+      effectiveWaitTimeoutMs = Math.min(
+        effectiveWaitTimeoutMs ?? transportTimeoutBudget,
         transportTimeoutBudget
       );
     }
@@ -3153,6 +3979,104 @@ var HttpFunctionsApi = class {
   }
 };
 
+// src/search-api.ts
+var ASK_FUNCTION = "ask";
+var DEFAULT_LIMIT = 8;
+var MAX_LIMIT = 50;
+var SearchApi = class {
+  constructor(runSql, runFunction) {
+    this.runSql = runSql;
+    this.runFunction = runFunction;
+  }
+  /**
+   * Find the passages that match a query, by meaning and by keyword at once.
+   *
+   * No model is involved, so this is the call for a search box, a "related
+   * content" list, or anything assembling its own context.
+   */
+  async search(query, options) {
+    if (!query || !query.trim()) {
+      throw new Error("search(query) requires a non-empty query");
+    }
+    if (!options || !options.workspaces || !options.workspaces.trim()) {
+      throw new Error(
+        "search() requires `workspaces` \u2014 name a workspace, a list, a glob, or 'ALL READABLE'. An unscoped search on a public site is how draft content reaches a visitor."
+      );
+    }
+    const limit = Math.min(
+      Math.max(Math.floor(options.limit ?? DEFAULT_LIMIT), 1),
+      MAX_LIMIT
+    );
+    const distance = Number.isFinite(options.maxDistance) ? `, max_distance => ${Number(options.maxDistance)}` : "";
+    const sql = `
+      SELECT node_id, path, name, score, chunk_index, chunk_text, chunk_text_source
+      FROM HYBRID_SEARCH($1, ${limit},
+                         workspaces => $2,
+                         granularity => 'chunk'${distance})
+    `;
+    const result = await this.runSql(sql, [query.trim(), options.workspaces.trim()]);
+    const rows = result?.rows ?? [];
+    return rows.map((row) => ({
+      path: String(row.path ?? ""),
+      nodeId: String(row.node_id ?? ""),
+      name: String(row.name ?? ""),
+      // `0` is a real chunk index — a document that was never split — so it
+      // must not be collapsed into "missing" by a falsy check.
+      chunkIndex: row.chunk_index == null ? 0 : Number(row.chunk_index),
+      text: String(row.chunk_text ?? ""),
+      textIsExact: row.chunk_text_source === "exact",
+      score: Number(row.score ?? 0)
+    })).filter((passage) => passage.text.length > 0);
+  }
+  /**
+   * Answer a question from the stored content, with citations.
+   *
+   * Retrieves, judges whether what came back answers the question, rewrites the
+   * query once if it does not, and answers from those passages only.
+   */
+  async ask(question, options) {
+    if (!question || !question.trim()) {
+      throw new Error("ask(question) requires a non-empty question");
+    }
+    if (!options || !options.workspaces || !options.workspaces.trim()) {
+      throw new Error(
+        "ask() requires `workspaces` \u2014 name a workspace, a list, a glob, or 'ALL READABLE'. An answer is quoted back to whoever asked, so the corpus it may be drawn from is stated, never assumed."
+      );
+    }
+    const raw = await this.runFunction(ASK_FUNCTION, {
+      question: question.trim(),
+      workspaces: options.workspaces.trim(),
+      limit: options.limit,
+      model: options.model,
+      use_graph: options.useGraph
+    });
+    if (raw && typeof raw === "object" && "error" in raw && raw.error) {
+      throw new Error(`ask failed: ${String(raw.error)}`);
+    }
+    const citations = Array.isArray(raw?.citations) ? raw.citations : [];
+    return {
+      answer: String(raw?.answer ?? ""),
+      // Absent counts as NOT grounded. This flag is the one a caller branches
+      // on before showing an answer, so an unexpected response shape must fail
+      // towards "we found nothing", never towards "trust this".
+      grounded: raw?.grounded === true,
+      citations: citations.map((c) => ({
+        marker: Number(c.marker ?? 0),
+        path: String(c.path ?? ""),
+        nodeId: String(c.node_id ?? ""),
+        name: String(c.title ?? ""),
+        chunkIndex: c.chunk_index == null ? 0 : Number(c.chunk_index),
+        textIsExact: c.text_is_exact === true
+      })),
+      attempts: Array.isArray(raw?.attempts) ? raw.attempts.map((a) => ({
+        query: String(a.query ?? ""),
+        passages: Number(a.passages ?? 0)
+      })) : [],
+      model: String(raw?.model ?? "")
+    };
+  }
+};
+
 // src/errors.ts
 var RaisinError = class extends Error {
   constructor(message, code, details) {
@@ -3241,6 +4165,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 +4309,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 +4374,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 +4399,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 +4430,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,9 +4496,27 @@ 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) {
+  constructor(baseUrl, repository, authManager, options = {}, executeSql, visitor) {
+    this.visitor = visitor;
     this.baseUrl = baseUrl.replace(/\/$/, "");
     this.repository = repository;
     this.authManager = authManager;
@@ -3535,10 +4536,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
@@ -3635,6 +4637,45 @@ var ConversationManager = class {
       ]
     };
   }
+  /**
+   * Start (or resume) an ANONYMOUS conversation with an agent — a public
+   * website's chat, without login.
+   *
+   * Works on an anonymous connection only, and only with an agent that allows
+   * anonymous visitors (`anonymous.enabled: true` on its raisin:AIAgent). The
+   * server keeps the conversation in an ephemeral visitor session that only
+   * this browser session can read; the session secret is kept in
+   * sessionStorage (override with `options.store`), so a reload continues the
+   * same conversation. Then use `sendMessage`, `getMessages`, `subscribe` and
+   * `ConversationStore` / `useConversation` exactly as for a signed-in user.
+   *
+   * @example
+   * ```typescript
+   * const convo = await db.conversations.startAnonymous('/agents/website-assistant');
+   * for await (const ev of db.conversations.sendMessage(convo.conversationPath, 'Hello')) {
+   *   if (ev.type === 'text_chunk') append(ev.text);
+   *   if (ev.type === 'failed') showLimit(ev.code); // e.g. RATE_LIMITED, LIMIT_REACHED
+   * }
+   * ```
+   */
+  async startAnonymous(agent, options) {
+    if (!this.visitor) {
+      throw new Error("Anonymous chat needs a WebSocket database: use client.database(repo).");
+    }
+    return this.visitor.start(this.normalizeAgentPath(agent), options);
+  }
+  /** Forget the stored anonymous session for `agent` (the next start begins a new one). */
+  forgetAnonymous(agent, options) {
+    this.visitor?.forget(this.normalizeAgentPath(agent), options);
+  }
+  /** Whether this tab remembers an anonymous conversation with `agent`. */
+  hasStoredAnonymous(agent, options) {
+    return this.visitor?.remembers(this.normalizeAgentPath(agent), options) ?? false;
+  }
+  /** Whether `conversationPath` is an anonymous conversation of this client. */
+  isAnonymous(conversationPath) {
+    return this.visitor?.isAnonymous(conversationPath) ?? false;
+  }
   /**
    * Open an existing conversation by path.
    * Returns null if not found.
@@ -3680,6 +4721,7 @@ var ConversationManager = class {
    * Mark a conversation as read by setting unread_count to 0.
    */
   async markAsRead(conversationPath) {
+    if (this.isAnonymous(conversationPath)) return;
     const workspace = "raisin:access_control";
     await this.sqlQuery(
       `UPDATE '${workspace}' SET properties = jsonb_set(properties, '{unread_count}', '0'::jsonb) WHERE path = $1 AND node_type = 'raisin:Conversation'`,
@@ -3690,6 +4732,7 @@ var ConversationManager = class {
    * Mark a single message as read by the current user.
    */
   async markMessageAsRead(messagePath) {
+    if (messagePath.startsWith("/visitors/")) return;
     const workspace = "raisin:access_control";
     const now = (/* @__PURE__ */ new Date()).toISOString();
     await this.sqlQuery(
@@ -3714,6 +4757,18 @@ var ConversationManager = class {
    */
   async *sendMessage(conversationPath, content, options) {
     const shouldStream = options?.stream !== false;
+    if (this.visitor?.isAnonymous(conversationPath)) {
+      if (!shouldStream) {
+        await this.visitor.post(conversationPath, content);
+        yield { type: "waiting", timestamp: (/* @__PURE__ */ new Date()).toISOString() };
+        return;
+      }
+      yield* this.visitor.stream(conversationPath, content, {
+        signal: options?.signal,
+        inactivityTimeoutMs: options?.inactivityTimeoutMs ?? DEFAULT_SEND_MESSAGE_INACTIVITY_TIMEOUT_MS
+      });
+      return;
+    }
     logger.debug("[ConversationManager] Starting SSE stream for message send");
     if (!shouldStream) {
       await this.createUserMessage(conversationPath, content);
@@ -3733,13 +4788,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 +4833,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();
       }
@@ -3790,10 +4856,23 @@ var ConversationManager = class {
    */
   async createUserMessage(conversationPath, content) {
     logger.debug("[ConversationManager] Creating user message", { path: conversationPath });
+    if (this.visitor?.isAnonymous(conversationPath)) {
+      await this.visitor.post(conversationPath, content);
+      return;
+    }
     const workspace = "raisin:access_control";
+    const properties = await this.loadConversationProperties(conversationPath, workspace);
+    const flowInstanceId = typeof properties?.flow_instance_id === "string" ? properties.flow_instance_id.trim() : "";
+    if (flowInstanceId) {
+      await this.httpRequest({
+        method: "POST",
+        path: `/api/flows/${this.repository}/instances/${encodeURIComponent(flowInstanceId)}/resume`,
+        body: { resume_data: { message: content } }
+      });
+      return;
+    }
     const { userId, userHome } = await this.ensureCurrentUser();
     const messageId = crypto.randomUUID();
-    const properties = await this.loadConversationProperties(conversationPath, workspace);
     const participants = Array.isArray(properties?.participants) ? properties.participants : [];
     let recipientId = participants.find(
       (p) => typeof p === "string" && p.length > 0 && p !== userId && p !== userHome
@@ -3832,6 +4911,12 @@ var ConversationManager = class {
    * initiated messages, etc.). Auto-reconnects on disconnect.
    */
   subscribe(conversationPath, onEvent, options) {
+    if (this.visitor?.isAnonymous(conversationPath)) {
+      const stop = this.visitor.listen(conversationPath, onEvent);
+      options?.signal?.addEventListener("abort", stop, { once: true });
+      return { unsubscribe: stop, waitUntilConnected: async () => {
+      } };
+    }
     logger.info("[ConversationManager] Subscribing to SSE", { path: conversationPath });
     const sseUrl = `${this.baseUrl}/api/conversations/${this.repository}/events`;
     const headers = {};
@@ -3998,7 +5083,17 @@ var ConversationManager = class {
         tasks.push({
           id: row.id,
           title: row.properties?.title ?? row.name,
-          status: row.properties?.status ?? "pending"
+          status: row.properties?.status ?? "pending",
+          delegation: row.properties?.delegation_id ? {
+            id: row.properties.delegation_id,
+            status: row.properties.delegation_status ?? "unknown",
+            agentRef: row.properties.delegated_agent_ref?.["raisin:path"] ?? row.properties.delegated_agent_ref?.["raisin:ref"] ?? (typeof row.properties.delegated_agent_ref === "string" ? row.properties.delegated_agent_ref : void 0),
+            flowInstanceId: row.properties.delegation_flow_instance_id ?? void 0,
+            branch: row.properties.delegation_branch ?? void 0,
+            baseBranch: row.properties.delegation_base_branch ?? void 0,
+            result: row.properties.delegation_result,
+            error: row.properties.delegation_error ?? void 0
+          } : void 0
         });
         tasksByPlan.set(planPath, tasks);
         continue;
@@ -4255,12 +5350,278 @@ var ConversationManager = class {
   }
   async ensureFolderNode(workspace, path, title) {
     await this.sqlQuery(
-      `UPSERT INTO '${workspace}' (path, node_type, properties) VALUES ($1, 'raisin:Folder', $2::jsonb)`,
+      `UPSERT INTO '${workspace}' (path, node_type, properties) VALUES ($1, 'raisin:AclFolder', $2::jsonb)`,
       [path, JSON.stringify({ title })]
     );
   }
 };
 
+// src/visitor-chat.ts
+function defaultVisitorSessionStore() {
+  const memory = /* @__PURE__ */ new Map();
+  const storage = () => {
+    try {
+      return typeof sessionStorage !== "undefined" ? sessionStorage : null;
+    } catch {
+      return null;
+    }
+  };
+  return {
+    get(key) {
+      try {
+        return storage()?.getItem(key) ?? memory.get(key) ?? null;
+      } catch {
+        return memory.get(key) ?? null;
+      }
+    },
+    set(key, value) {
+      memory.set(key, value);
+      try {
+        storage()?.setItem(key, value);
+      } catch {
+      }
+    },
+    remove(key) {
+      memory.delete(key);
+      try {
+        storage()?.removeItem(key);
+      } catch {
+      }
+    }
+  };
+}
+var VisitorChatError = class extends Error {
+  constructor(message, code) {
+    super(message);
+    this.name = "VisitorChatError";
+    this.code = code;
+  }
+};
+var REBIND_CODES = /* @__PURE__ */ new Set(["NO_SESSION", "UNKNOWN_CONVERSATION"]);
+function asError(err) {
+  const e = err;
+  return new VisitorChatError(e?.message ?? String(err), e?.code ?? "UNAVAILABLE");
+}
+var VisitorChat = class {
+  constructor(repository, send, events, onReconnected) {
+    this.repository = repository;
+    this.send = send;
+    this.events = events;
+    this.byPath = /* @__PURE__ */ new Map();
+    this.token = null;
+    onReconnected?.(() => {
+      void this.rebindAll();
+    });
+  }
+  /** Whether `conversationPath` is a visitor conversation started here. */
+  isAnonymous(conversationPath) {
+    return this.byPath.has(conversationPath);
+  }
+  storeOf(options) {
+    if (options.store === false) return null;
+    return options.store ?? defaultVisitorSessionStore();
+  }
+  keyOf(agent, options) {
+    return options.storageKey ?? `raisindb:visitor:${this.repository}:${agent}`;
+  }
+  /** Start (or resume) a visitor conversation with `agent` (`/agents/<name>`). */
+  async start(agent, options = {}) {
+    const store = this.storeOf(options);
+    const key = this.keyOf(agent, options);
+    const sessionToken = options.sessionToken ?? this.token ?? store?.get(`${key}:session`) ?? void 0;
+    const conversationId = options.newConversation ? void 0 : options.conversationId ?? store?.get(`${key}:conversation`) ?? void 0;
+    let res;
+    try {
+      res = await this.send(
+        { agent, session_token: sessionToken, conversation_id: conversationId },
+        "visitor_chat_start"
+      );
+    } catch (err) {
+      const e = asError(err);
+      if ((conversationId || sessionToken) && !options.conversationId && !options.sessionToken && ["UNKNOWN_CONVERSATION", "INVALID_CONVERSATION", "SESSION_EXPIRED", "SESSION_MISMATCH"].includes(e.code)) {
+        store?.remove(`${key}:conversation`);
+        if (e.code !== "UNKNOWN_CONVERSATION" && e.code !== "INVALID_CONVERSATION") {
+          store?.remove(`${key}:session`);
+          this.token = null;
+        }
+        return this.start(agent, { ...options, newConversation: true });
+      }
+      throw e;
+    }
+    const token = res.session_token ?? sessionToken ?? this.token;
+    if (!token) throw new VisitorChatError("the server returned no session", "UNAVAILABLE");
+    this.token = token;
+    store?.set(`${key}:session`, token);
+    store?.set(`${key}:conversation`, res.conversation_id);
+    const path = res.conversation_path;
+    let entry = this.byPath.get(path);
+    if (!entry) {
+      entry = {
+        agent: res.agent,
+        conversationId: res.conversation_id,
+        subscriptionId: res.subscription_id,
+        listeners: /* @__PURE__ */ new Set(),
+        options
+      };
+      this.byPath.set(path, entry);
+    }
+    this.route(entry);
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    return {
+      id: res.conversation_id,
+      type: "ai_chat",
+      agentRef: res.agent,
+      conversationPath: path,
+      conversationWorkspace: res.conversation_workspace,
+      anonymous: true,
+      conversationId: res.conversation_id,
+      sessionToken: token,
+      limits: res.limits,
+      initialEvents: [{ type: "waiting", timestamp: now }]
+    };
+  }
+  /** Route the server's forwarded events for this conversation to its listeners. */
+  route(entry) {
+    this.events.removeFlowEventListener(entry.subscriptionId);
+    this.events.addFlowEventListener(entry.subscriptionId, (msg) => {
+      const event = msg.payload;
+      if (!event || typeof event.type !== "string") return;
+      for (const listener of entry.listeners) {
+        try {
+          listener(event);
+        } catch (err) {
+          logger.error("[VisitorChat] listener failed", err);
+        }
+      }
+    });
+  }
+  /** Re-prove the session on a new connection, for every conversation started here. */
+  async rebindAll() {
+    for (const entry of this.byPath.values()) {
+      try {
+        await this.send(
+          { agent: entry.agent, session_token: this.token, conversation_id: entry.conversationId },
+          "visitor_chat_start"
+        );
+        this.route(entry);
+      } catch (err) {
+        logger.warn("[VisitorChat] could not resume a conversation after reconnect", err);
+      }
+    }
+  }
+  /** Listen to a visitor conversation's events. Returns an unsubscribe function. */
+  listen(conversationPath, listener) {
+    const entry = this.require(conversationPath);
+    entry.listeners.add(listener);
+    return () => {
+      entry.listeners.delete(listener);
+    };
+  }
+  require(conversationPath) {
+    const entry = this.byPath.get(conversationPath);
+    if (!entry) {
+      throw new VisitorChatError(
+        "not a visitor conversation of this client; call startAnonymous first",
+        "UNKNOWN_CONVERSATION"
+      );
+    }
+    return entry;
+  }
+  /** Make sure this connection is bound (after a reconnect nothing else may read the home). */
+  async ensureBound(conversationPath) {
+    const entry = this.require(conversationPath);
+    await this.send(
+      { agent: entry.agent, session_token: this.token, conversation_id: entry.conversationId },
+      "visitor_chat_start"
+    ).catch((err) => {
+      throw asError(err);
+    });
+  }
+  /** Send one visitor message. Events arrive through {@link listen}. */
+  async post(conversationPath, text) {
+    const entry = this.require(conversationPath);
+    const once = async () => await this.send(
+      { conversation_id: entry.conversationId, text },
+      "visitor_chat_send"
+    );
+    try {
+      const res = await once();
+      return { messageId: res.message_id, messagesLeft: res.messages_left };
+    } catch (err) {
+      const e = asError(err);
+      if (!REBIND_CODES.has(e.code)) throw e;
+      await this.ensureBound(conversationPath);
+      this.route(entry);
+      const res = await once().catch((again) => {
+        throw asError(again);
+      });
+      return { messageId: res.message_id, messagesLeft: res.messages_left };
+    }
+  }
+  /**
+   * Send one visitor message and stream the turn: `text_chunk`,
+   * `tool_call_started`, `tool_call_completed`, … until `done`. A refusal
+   * ends the stream with `failed` (its `code` says why). No event for
+   * `inactivityTimeoutMs` ends it with a synthetic `waiting`.
+   */
+  async *stream(conversationPath, text, options = {}) {
+    const queue = [];
+    let wake = null;
+    const push = (event) => {
+      queue.push(event);
+      wake?.();
+    };
+    const stop = this.listen(conversationPath, push);
+    const onAbort = () => push({ type: "failed", error: "aborted", code: "ABORTED", timestamp: (/* @__PURE__ */ new Date()).toISOString() });
+    options.signal?.addEventListener("abort", onAbort, { once: true });
+    const timeout = options.inactivityTimeoutMs ?? 12e4;
+    try {
+      try {
+        await this.post(conversationPath, text);
+      } catch (err) {
+        const e = asError(err);
+        yield { type: "failed", error: e.message, code: e.code, timestamp: (/* @__PURE__ */ new Date()).toISOString() };
+        return;
+      }
+      for (; ; ) {
+        if (!queue.length) {
+          const idle = await new Promise((resolve) => {
+            const timer = timeout > 0 ? setTimeout(() => resolve(true), timeout) : null;
+            wake = () => {
+              if (timer) clearTimeout(timer);
+              resolve(false);
+            };
+          });
+          wake = null;
+          if (idle && !queue.length) {
+            yield { type: "waiting", timestamp: (/* @__PURE__ */ new Date()).toISOString() };
+            return;
+          }
+        }
+        const event = queue.shift();
+        yield event;
+        if (event.type === "done" || event.type === "failed" || event.type === "waiting") return;
+      }
+    } finally {
+      stop();
+      options.signal?.removeEventListener("abort", onAbort);
+    }
+  }
+  /** Whether the store remembers a conversation with `agent`. */
+  remembers(agent, options = {}) {
+    const store = this.storeOf(options);
+    return !!store?.get(`${this.keyOf(agent, options)}:conversation`);
+  }
+  /** Forget the stored session (e.g. a "new chat" button that should start a new session). */
+  forget(agent, options = {}) {
+    const store = this.storeOf(options);
+    const key = this.keyOf(agent, options);
+    store?.remove(`${key}:session`);
+    store?.remove(`${key}:conversation`);
+    this.token = null;
+  }
+};
+
 // src/flow-client.ts
 var FlowClient = class _FlowClient {
   /**
@@ -4538,31 +5899,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 +6060,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) {
@@ -4890,6 +6377,13 @@ var Database = class _Database {
   tags() {
     return new Tags(this._context, this.sendRequest);
   }
+  /**
+   * Get SchedulerApi for one-shot scheduled invocations (time-based
+   * function/flow runs).
+   */
+  scheduler() {
+    return new SchedulerApi(this._context, this.sendRequest);
+  }
   /**
    * Get FlowsApi for running flows via WebSocket
    */
@@ -4904,6 +6398,16 @@ var Database = class _Database {
     }
     return this._flowsApi;
   }
+  /**
+   * Durable agent runs over this WebSocket connection: find a subject's run,
+   * follow it live (gap-free, resumable), control it, list its children.
+   */
+  runs() {
+    if (!this._runsApi) {
+      this._runsApi = new AgentRunsWsApi(this._context, this.sendRequest, this.eventHandler);
+    }
+    return this._runsApi;
+  }
   /**
    * Get FunctionsApi for invoking server-side functions via WebSocket
    */
@@ -4917,6 +6421,73 @@ var Database = class _Database {
     }
     return this._functionsApi;
   }
+  /**
+   * The retrieval implementation behind {@link search} and {@link ask}.
+   *
+   * Private: callers get the two verbs, not the object, so how retrieval is
+   * served stays ours to change.
+   */
+  searchApi() {
+    if (!this._searchApi) {
+      this._searchApi = new SearchApi(
+        (sql, params) => this.executeSql(sql, params),
+        async (name, input) => {
+          const run = await this.functions().invoke(name, input, {
+            waitForResult: true
+          });
+          return run?.result ?? run;
+        }
+      );
+    }
+    return this._searchApi;
+  }
+  /**
+   * Find the passages matching a query, by meaning and by keyword at once.
+   *
+   * No model is involved — this is the call for a search box or for assembling
+   * your own context. Returns one entry per PASSAGE, so several may come from
+   * one document.
+   *
+   * @example
+   * ```typescript
+   * const passages = await db.search('how much notice to terminate', {
+   *   workspaces: 'stories',
+   * });
+   * passages[0].text;        // the passage itself
+   * passages[0].chunkIndex;  // where in the document it came from
+   * ```
+   */
+  async search(query, options) {
+    return this.searchApi().search(query, options);
+  }
+  /**
+   * Answer a question from the stored content, with citations.
+   *
+   * Retrieves, judges whether what came back answers the question, rewrites the
+   * query once if it does not, and answers from those passages only. Check
+   * `grounded` before showing the answer: when it is false nothing relevant was
+   * found and the model was never asked.
+   *
+   * `workspaces` is required, the same as on {@link search}: an answer is
+   * quoted back to whoever asked, so the corpus it may be drawn from is stated
+   * rather than assumed. One name, a comma-separated list, a glob, or
+   * `'ALL READABLE'`.
+   *
+   * A method rather than `functions().invoke('ask', ...)` on purpose — see the
+   * note at the top of `search-api.ts`. `invoke` is the escape hatch for
+   * functions YOU wrote.
+   *
+   * @example
+   * ```typescript
+   * const { answer, citations, grounded } = await db.ask(
+   *   'How much notice do we have to give?',
+   *   { workspaces: 'stories, handbook' },   // one name, a list, a glob, or 'ALL READABLE'
+   * );
+   * ```
+   */
+  async ask(question, options) {
+    return this.searchApi().ask(question, options);
+  }
   /**
    * Get a pre-configured ConversationManager for managing conversations.
    *
@@ -4943,7 +6514,13 @@ var Database = class _Database {
         this.repository,
         this.httpOptions.authManager,
         {},
-        (query, params) => this.executeSql(query, params)
+        (query, params) => this.executeSql(query, params),
+        new VisitorChat(
+          this.repository,
+          (payload, requestType) => this.sendRequest(payload, requestType),
+          this.eventHandler,
+          this.httpOptions.onReconnected
+        )
       );
     }
     return this._conversationManager;
@@ -4977,8 +6554,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;
@@ -6257,10 +7870,375 @@ var UploadManager = class {
   }
 };
 
+// src/http-schema.ts
+var HttpSchemaBase = class {
+  constructor(repository, branch, client) {
+    this.repository = repository;
+    this.branch = branch;
+    this.client = client;
+  }
+  /** Base management URL for this schema kind. */
+  base() {
+    return `/api/management/${this.repository}/${this.branch}/${this.kind}`;
+  }
+  /** List all schemas (or only published ones). */
+  async list(publishedOnly = false) {
+    const path = publishedOnly ? `${this.base()}/published` : this.base();
+    const result = await this.client.managementRequest("GET", path);
+    return Array.isArray(result) ? result : [];
+  }
+  /** Get a single schema by name. */
+  async get(name) {
+    return this.client.managementRequest("GET", `${this.base()}/${encodeURIComponent(name)}`);
+  }
+  /** Get the schema with full inheritance (`extends`) applied. */
+  async getResolved(name) {
+    return this.client.managementRequest(
+      "GET",
+      `${this.base()}/${encodeURIComponent(name)}/resolved`
+    );
+  }
+  /** Create a schema. `name` is folded into the definition body if absent. */
+  async create(name, definition, commit) {
+    return this.client.managementRequest("POST", this.base(), {
+      [this.defField]: { name, ...definition },
+      commit
+    });
+  }
+  /** Update an existing schema. */
+  async update(name, definition, commit) {
+    return this.client.managementRequest(
+      "PUT",
+      `${this.base()}/${encodeURIComponent(name)}`,
+      { [this.defField]: { name, ...definition }, commit }
+    );
+  }
+  /** Delete a schema. */
+  async delete(name, commit) {
+    return this.client.managementRequest(
+      "DELETE",
+      `${this.base()}/${encodeURIComponent(name)}`,
+      commit
+    );
+  }
+  /** Publish a schema. */
+  async publish(name, commit) {
+    return this.client.managementRequest(
+      "POST",
+      `${this.base()}/${encodeURIComponent(name)}/publish`,
+      commit
+    );
+  }
+  /** Unpublish a schema. */
+  async unpublish(name, commit) {
+    return this.client.managementRequest(
+      "POST",
+      `${this.base()}/${encodeURIComponent(name)}/unpublish`,
+      commit
+    );
+  }
+};
+var HttpNodeTypes = class extends HttpSchemaBase {
+  constructor() {
+    super(...arguments);
+    this.kind = "nodetypes";
+    this.defField = "node_type";
+  }
+  /**
+   * Get the resolved NodeType. Unlike archetypes/element types, NodeType
+   * resolution can be workspace-aware (honors workspace NodeType pins).
+   */
+  async getResolved(name, opts) {
+    const query = opts?.workspace ? `?workspace=${encodeURIComponent(opts.workspace)}` : "";
+    return this.client.managementRequest(
+      "GET",
+      `${this.base()}/${encodeURIComponent(name)}/resolved${query}`
+    );
+  }
+};
+var HttpArchetypes = class extends HttpSchemaBase {
+  constructor() {
+    super(...arguments);
+    this.kind = "archetypes";
+    this.defField = "archetype";
+  }
+};
+var HttpElementTypes = class extends HttpSchemaBase {
+  constructor() {
+    super(...arguments);
+    this.kind = "elementtypes";
+    this.defField = "element_type";
+  }
+};
+
+// src/mcp.ts
+var McpClient = class {
+  constructor(transport) {
+    this.transport = transport;
+  }
+  /**
+   * List the tools this MCP server advertises to the calling identity.
+   *
+   * Wraps the `tools/list` JSON-RPC method. The visible set is RLS-scoped to
+   * the authenticated caller (or the anonymous role).
+   *
+   * @returns The advertised tool descriptors.
+   */
+  async listTools() {
+    const result = await this.transport.rpc("tools/list");
+    return { tools: result?.tools ?? [] };
+  }
+  /**
+   * Invoke a tool by name.
+   *
+   * Wraps the `tools/call` JSON-RPC method. The underlying `raisin:Function`
+   * runs RLS-scoped to the calling identity. A domain-level tool failure is
+   * reported via {@link McpCallToolResult.isError} (not thrown); transport and
+   * protocol errors are thrown.
+   *
+   * @param name - Tool name from {@link listTools}.
+   * @param args - Arguments object matching the tool's `inputSchema`.
+   * @returns The tool's content blocks and optional structured content.
+   */
+  async callTool(name, args) {
+    const result = await this.transport.rpc("tools/call", {
+      name,
+      arguments: args ?? {}
+    });
+    return result;
+  }
+  /**
+   * Read a resource by its `raisin://` URI.
+   *
+   * Wraps the `resources/read` JSON-RPC method. JSON-only resources return
+   * their properties as a `text` entry; byte-serving resources return base64
+   * in `blob`.
+   *
+   * @param uri - `raisin://{workspace}/{path}` URI to read.
+   * @returns One content entry per URI read.
+   */
+  async readResource(uri) {
+    const result = await this.transport.rpc("resources/read", {
+      uri
+    });
+    return { contents: result?.contents ?? [] };
+  }
+  /**
+   * Subscribe to change notifications for a resource URI (or URI prefix).
+   *
+   * Opens a `subscriptions/listen` stream (SSE) with a `resourceSubscriptions`
+   * filter naming the URI. The returned {@link McpResourceSubscription} is an
+   * async iterable of {@link McpResourceUpdate}; the server's acknowledgement
+   * frame and the closing response are consumed internally and not yielded.
+   * Call `close()` to end the stream.
+   *
+   * @param uri - `raisin://` URI (or prefix) to watch.
+   * @returns A live, closeable subscription.
+   */
+  subscribeResource(uri) {
+    const stream = this.transport.subscribe("subscriptions/listen", {
+      notifications: { resourceSubscriptions: [uri] }
+    });
+    return {
+      close: () => stream.close(),
+      async *[Symbol.asyncIterator]() {
+        for await (const frame of stream) {
+          if (frame.method === "notifications/resources/updated") {
+            const params = frame.params ?? {};
+            if (typeof params.uri === "string") {
+              yield { uri: params.uri };
+            }
+          }
+        }
+      }
+    };
+  }
+};
+
+// src/identity-auth.ts
+var IdentityAuthApi = class {
+  constructor(repository, transport) {
+    this.repository = repository;
+    this.transport = transport;
+  }
+  get base() {
+    return `/auth/${encodeURIComponent(this.repository)}`;
+  }
+  /**
+   * Ask RaisinDB to email a sign-in link.
+   *
+   * The reply is an acknowledgement, never a token — the token only exists in
+   * the email. It also resolves for an address that has no account, because a
+   * response that differed would turn this endpoint into an account-existence
+   * oracle.
+   */
+  async sendMagicLink(email, options) {
+    return this.transport({
+      method: "POST",
+      path: `${this.base}/magic-link`,
+      body: { email, redirect_url: options?.redirectUrl },
+      skipAuth: true
+    });
+  }
+  /**
+   * Exchange a magic-link token for a session.
+   *
+   * Most applications never call this: following the emailed link hits
+   * RaisinDB directly, which verifies and 302s to the redirect URL with the
+   * tokens in the URL **fragment** (so they stay out of server logs and out
+   * of the Referer header) — see {@link readTokensFromFragment}. Call this
+   * only when handling the token yourself, and note it is single-use.
+   */
+  async verifyMagicLink(token) {
+    return this.transport({
+      method: "GET",
+      path: `${this.base}/magic-link/verify?token=${encodeURIComponent(token)}`,
+      skipAuth: true
+    });
+  }
+  /**
+   * Sign in with email and password, where the repository enables it.
+   *
+   * `rememberMe` chooses the lifetime of the sign-in: the session AND its refresh
+   * token last 30 days with it and 24 hours without (both configurable per tenant:
+   * `refresh_token_duration_days`, `refresh_token_session_hours`). Refreshing never
+   * extends a session past that.
+   */
+  async login(email, password, options) {
+    return this.transport({
+      method: "POST",
+      path: `${this.base}/login`,
+      body: { email, password, remember_me: options?.rememberMe ?? false },
+      skipAuth: true
+    });
+  }
+  /** Create an account with email and password. */
+  async register(email, password, options) {
+    return this.transport({
+      method: "POST",
+      path: `${this.base}/register`,
+      body: { email, password, display_name: options?.displayName },
+      skipAuth: true
+    });
+  }
+  /** Trade a refresh token for a fresh pair. */
+  async refresh(refreshToken) {
+    return this.transport({
+      method: "POST",
+      path: `${this.base}/refresh`,
+      body: { refresh_token: refreshToken },
+      skipAuth: true
+    });
+  }
+  /**
+   * Which sign-in methods to render.
+   *
+   * Ask rather than hard-code: magic link and password are per-repository
+   * configuration, and a button for a disabled method is a dead end.
+   */
+  async providers() {
+    return this.transport({
+      method: "GET",
+      path: `${this.base}/providers`,
+      skipAuth: true
+    });
+  }
+  /** Who the current token belongs to in this repository. */
+  async me() {
+    return this.transport({ method: "GET", path: `${this.base}/me` });
+  }
+};
+function readTokensFromFragment(hashOrUrl) {
+  const hash = hashOrUrl.includes("#") ? hashOrUrl.slice(hashOrUrl.indexOf("#") + 1) : hashOrUrl;
+  if (!hash) return null;
+  const params = new URLSearchParams(hash);
+  const accessToken = params.get("access_token");
+  if (!accessToken) return null;
+  return { accessToken, refreshToken: params.get("refresh_token") };
+}
+
+// src/node-dev.ts
+var NodeDevApi = class {
+  constructor(repository, transport) {
+    this.repository = repository;
+    this.transport = transport;
+  }
+  /** Call any method by name (the typed helpers below all use this). */
+  call(method, request) {
+    const branch = typeof request.branch === "string" ? `?branch=${encodeURIComponent(request.branch)}` : "";
+    return this.transport.request(
+      "POST",
+      `/api/node-dev/${encodeURIComponent(this.repository)}/${method}${branch}`,
+      request
+    );
+  }
+  changeset(o) {
+    const { idempotencyKey, ...rest } = o;
+    return { ...rest, idempotency_key: idempotencyKey };
+  }
+  stat(target, o = {}) {
+    return this.call("stat", { ...o, target });
+  }
+  read(target, o = {}) {
+    return this.call("read", { ...o, target });
+  }
+  list(target, o = {}) {
+    return this.call("list", { ...o, target });
+  }
+  diff(target, from, to, o = {}) {
+    return this.call("diff", { ...o, target, from, to });
+  }
+  /** Changes inside the roots after `since` (a cursor from a previous call). */
+  watch(since, o = {}) {
+    return this.call("watch", { ...o, since });
+  }
+  dryRun(o) {
+    return this.call("dry_run", this.changeset(o));
+  }
+  propose(o) {
+    return this.call(
+      "propose",
+      this.changeset(o)
+    );
+  }
+  getChangeset(changesetId, o = {}) {
+    return this.call("get_changeset", { ...o, changeset_id: changesetId });
+  }
+  listChangesets(o = {}) {
+    return this.call("list_changesets", { ...o });
+  }
+  /** Commit; pass the reviewed digest to bind the commit to that approval. */
+  commit(changesetId, expectedDigest, o = {}) {
+    return this.call("commit", { ...o, changeset_id: changesetId, expected_digest: expectedDigest });
+  }
+  discard(changesetId, o = {}) {
+    return this.call("discard", { ...o, changeset_id: changesetId });
+  }
+  /** Propose and commit in one call. */
+  apply(o) {
+    return this.call("apply", this.changeset(o));
+  }
+  forkBranch(name, o = {}) {
+    return this.call("fork_branch", { ...o, name });
+  }
+  diffBranch(base = "main", o = {}) {
+    return this.call("diff_branch", { ...o, base });
+  }
+  mergeBranch(target, o = {}) {
+    const { dryRun, ...rest } = o;
+    return this.call("merge_branch", { ...rest, target, dry_run: dryRun });
+  }
+  discardBranch(o = {}) {
+    return this.call("discard_branch", { ...o });
+  }
+};
+
 // src/http-client.ts
 var RaisinHttpClient = class extends import_events3.EventEmitter {
   constructor(baseUrl, options = {}) {
     super();
+    /** Monotonic JSON-RPC id counter for MCP requests. */
+    this._mcpRequestId = 0;
     this._currentUser = null;
     this._uploadManager = null;
     this.baseUrl = baseUrl.replace(/\/$/, "");
@@ -6288,6 +8266,7 @@ var RaisinHttpClient = class extends import_events3.EventEmitter {
   async authenticate(credentials, repository) {
     if (isJwtCredentials(credentials)) {
       this.authManager.storage.setAccessToken(credentials.token);
+      this.authManager.adoptToken(credentials.token);
       if (repository) {
         try {
           const userInfo = await this.fetchCurrentUser(repository);
@@ -6306,9 +8285,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);
@@ -6649,6 +8632,66 @@ var RaisinHttpClient = class extends import_events3.EventEmitter {
     return this.authManager;
   }
   // ============================================================================
+  // Identity Authentication
+  // ============================================================================
+  /**
+   * Identity authentication (magic link, password, providers) for one
+   * repository.
+   *
+   * Identities are per repository — their home nodes and roles live there — so
+   * the repository is required rather than inferred from client state, which
+   * would silently sign somebody into whichever one happened to be current.
+   *
+   * ```ts
+   * const auth = client.auth('studio');
+   * await auth.sendMagicLink('a@example.com', {
+   *   redirectUrl: 'https://app.example.com/account/callback',
+   * });
+   * // …on the callback route:
+   * const tokens = readTokensFromFragment(window.location.hash);
+   * if (tokens) client.setIdentityTokens(tokens.accessToken, tokens.refreshToken);
+   * ```
+   */
+  auth(repository) {
+    return new IdentityAuthApi(repository, async (options) => {
+      const response = await this.request({
+        method: options.method,
+        path: options.path,
+        body: options.body,
+        skipAuth: options.skipAuth
+      });
+      return response.data;
+    });
+  }
+  /**
+   * Adopt an identity's tokens for every subsequent call on this client.
+   *
+   * Takes the loose form so it serves both callers: the whole result of a
+   * sign-in, and the pair recovered from a redirect fragment (which carries no
+   * identity object and may carry no refresh token).
+   */
+  setIdentityTokens(accessTokenOrResult, refreshToken) {
+    if (typeof accessTokenOrResult === "string") {
+      this.authManager.storage.setAccessToken(accessTokenOrResult);
+      this.authManager.adoptToken(accessTokenOrResult);
+      if (refreshToken) this.authManager.storage.setRefreshToken(refreshToken);
+      return;
+    }
+    const result = accessTokenOrResult;
+    this.authManager.setTokens({
+      access_token: result.access_token,
+      refresh_token: result.refresh_token,
+      // The server reports an absolute expiry; AuthManager schedules from a
+      // duration. Deriving it here keeps the refresh timer honest instead of
+      // leaving it unset, which reads as "never expires".
+      expires_in: Math.max(0, result.expires_at - Math.floor(Date.now() / 1e3))
+    });
+  }
+  /** Forget the current identity's tokens. */
+  clearIdentityTokens() {
+    this.authManager.clear();
+  }
+  // ============================================================================
   // Upload Methods
   // ============================================================================
   /**
@@ -6850,7 +8893,7 @@ var RaisinHttpClient = class extends import_events3.EventEmitter {
       "Content-Type": "application/json",
       ...options.headers
     };
-    if (!options.skipAuth && this.authManager.isAuthenticated()) {
+    if (!options.skipAuth) {
       const token = this.authManager.getAccessToken();
       if (token) {
         headers["Authorization"] = `Bearer ${token}`;
@@ -6915,6 +8958,33 @@ var RaisinHttpClient = class extends import_events3.EventEmitter {
    * @param input - Input data passed to the function
    * @returns Execution ID and job ID for tracking
    */
+  /**
+   * Durable agent runs of `repository`: create, read, control, stream, and
+   * drive them directly (see {@link AgentRunsApi}).
+   */
+  agentRuns(repository) {
+    return new AgentRunsApi(repository, {
+      request: async (method, path, body) => (await this.request({ method, path, body })).data,
+      url: (path) => `${this.baseUrl}${path}`,
+      headers: () => {
+        const token = this.authManager.getAccessToken();
+        const headers = {};
+        if (token) headers["Authorization"] = `Bearer ${token}`;
+        return headers;
+      },
+      fetch: this.fetchImpl
+    });
+  }
+  /**
+   * The node-development surface of `repository`: typed reads, atomic
+   * changesets with review and idempotency, branch worktrees (see
+   * {@link NodeDevApi}).
+   */
+  nodeDev(repository) {
+    return new NodeDevApi(repository, {
+      request: async (method, path, body) => (await this.request({ method, path, body })).data
+    });
+  }
   async invokeFunction(repository, functionName, input, options) {
     const requestTimeoutMs = options?.requestTimeoutMs ?? this.options.requestTimeout;
     let waitTimeoutMs = options?.waitTimeoutMs;
@@ -6952,6 +9022,105 @@ var RaisinHttpClient = class extends import_events3.EventEmitter {
     });
     return response.data;
   }
+  /**
+   * Send one JSON-RPC request to an MCP server endpoint and return its
+   * unwrapped `result`.
+   *
+   * Calls `POST /mcp/{repo}/{branch}/{slug}` carrying a single JSON-RPC 2.0
+   * message. MCP errors are returned in the JSON-RPC envelope (HTTP `200`), so
+   * this method inspects the body's `error` member and throws on failure.
+   *
+   * @internal Used by {@link McpClient} via the transport built in `mcp()`.
+   */
+  async mcpRpc(repository, branch, slug, method, params) {
+    const id = ++this._mcpRequestId;
+    const response = await this.request({
+      method: "POST",
+      path: `/mcp/${repository}/${branch}/${slug}`,
+      body: {
+        jsonrpc: "2.0",
+        id,
+        method,
+        ...params !== void 0 ? { params } : {}
+      }
+    });
+    const frame = response.data;
+    if (frame?.error) {
+      const err = new Error(frame.error.message || `MCP error ${frame.error.code}`);
+      err.code = frame.error.code;
+      err.data = frame.error.data;
+      throw err;
+    }
+    return frame?.result;
+  }
+  /**
+   * Open the `subscriptions/listen` SSE stream for an MCP server endpoint.
+   *
+   * Streams JSON-RPC frames (the subscription ack followed by
+   * `notifications/resources/updated` frames) from
+   * `POST /mcp/{repo}/{branch}/{slug}`.
+   *
+   * @internal Used by {@link McpClient} via the transport built in `mcp()`.
+   */
+  mcpSubscribe(repository, branch, slug, method, params) {
+    const headers = {};
+    const token = this.authManager.getAccessToken();
+    if (token) {
+      headers["Authorization"] = `Bearer ${token}`;
+    }
+    const sse = new SSEClient(
+      `${this.baseUrl}/mcp/${repository}/${branch}/${slug}`,
+      {
+        method: "POST",
+        body: {
+          jsonrpc: "2.0",
+          id: ++this._mcpRequestId,
+          method,
+          params
+        },
+        headers,
+        fetch: this.fetchImpl,
+        reconnect: { enabled: false }
+      }
+    );
+    return {
+      close: () => sse.close(),
+      async *[Symbol.asyncIterator]() {
+        for await (const event of sse) {
+          yield event.data;
+        }
+      }
+    };
+  }
+  /**
+   * Get an {@link McpClient} for a content-declared MCP server.
+   *
+   * @param slug - The `raisin:McpServer` slug (resolved in the `mcp` workspace).
+   * @param branch - Branch to address; defaults to the client's current branch.
+   */
+  mcp(slug, branch) {
+    const repository = this._context.repository;
+    if (!repository) {
+      throw new Error("mcp() requires a repository; call database(name) first");
+    }
+    const effectiveBranch = branch ?? this.getBranch();
+    const transport = {
+      rpc: (m, p) => this.mcpRpc(repository, effectiveBranch, slug, m, p),
+      subscribe: (m, p) => this.mcpSubscribe(repository, effectiveBranch, slug, m, p)
+    };
+    return new McpClient(transport);
+  }
+  /**
+   * Make a management REST request and return the parsed body.
+   *
+   * @internal Used by the HTTP schema-management helpers
+   * ({@link HttpNodeTypes}/{@link HttpArchetypes}/{@link HttpElementTypes}) to
+   * reuse the client's centralized auth, timeout, and base-URL handling.
+   */
+  async managementRequest(method, path, body) {
+    const response = await this.request({ method, path, body });
+    return response.data;
+  }
   /**
    * Get a simplified database interface for SSR
    * This returns an HTTP-based database client
@@ -6979,19 +9148,6 @@ var HttpDatabase = class _HttpDatabase {
   getBranch() {
     return this.branch;
   }
-  /**
-   * Create a new HttpDatabase instance scoped to a specific branch.
-   *
-   * @param branch - Branch name
-   * @returns New HttpDatabase instance with branch context
-   *
-   * @example
-   * ```typescript
-   * const db = client.database('my-repo');
-   * const staging = db.onBranch('staging');
-   * const result = await staging.executeSql('SELECT * FROM content');
-   * ```
-   */
   onBranch(branch) {
     return new _HttpDatabase(this.repository, this.client, branch);
   }
@@ -7032,12 +9188,107 @@ var HttpDatabase = class _HttpDatabase {
   /**
    * Get FunctionsApi for invoking server-side functions via HTTP
    */
-  functions() {
-    return new HttpFunctionsApi(
-      this.repository,
-      (repo, name, input, options) => this.client.invokeFunction(repo, name, input, options),
-      (repo, name, input) => this.client.invokeFunctionSync(repo, name, input)
-    );
+  /** Durable agent runs of this repository. */
+  agentRuns() {
+    return this.client.agentRuns(this.repository);
+  }
+  /** The node-development surface of this repository. */
+  nodeDev() {
+    return this.client.nodeDev(this.repository);
+  }
+  functions() {
+    return new HttpFunctionsApi(
+      this.repository,
+      (repo, name, input, options) => this.client.invokeFunction(repo, name, input, options),
+      (repo, name, input) => this.client.invokeFunctionSync(repo, name, input)
+    );
+  }
+  /**
+   * The retrieval implementation behind {@link search} and {@link ask}.
+   *
+   * The SAME `SearchApi` the WebSocket client uses, handed this transport's SQL
+   * and function runners. Retrieval is one behaviour — the query shape, the
+   * limit clamp, the required scope, the `grounded` fail-closed mapping — and a
+   * second copy written against HTTP would drift from the first the moment
+   * either is touched. Only the two runners differ.
+   */
+  searchApi() {
+    if (!this._searchApi) {
+      this._searchApi = new SearchApi(
+        (sql, params) => this.executeSql(sql, params),
+        async (name, input) => {
+          const run = await this.functions().invoke(name, input, {
+            waitForResult: true
+          });
+          return run?.result ?? run;
+        }
+      );
+    }
+    return this._searchApi;
+  }
+  /**
+   * Find the passages matching a query, by meaning and by keyword at once.
+   *
+   * Available on this HTTP client as well as the WebSocket one, because this is
+   * the client a server-side route handler reaches for — and a route handler is
+   * exactly where retrieval belongs when the page is public: the browser must
+   * not hold a credential that can read the repository.
+   *
+   * @example
+   * ```typescript
+   * const passages = await db.search('how much notice to terminate', {
+   *   workspaces: 'stories',
+   * });
+   * ```
+   */
+  async search(query, options) {
+    return this.searchApi().search(query, options);
+  }
+  /**
+   * Answer a question from the stored content, with citations.
+   *
+   * Check `grounded` before showing the answer: when it is false nothing
+   * relevant was retrieved and the model was never asked.
+   *
+   * @example
+   * ```typescript
+   * const { answer, citations, grounded } = await db.ask(question, {
+   *   workspaces: 'stories, handbook',
+   * });
+   * ```
+   */
+  async ask(question, options) {
+    return this.searchApi().ask(question, options);
+  }
+  /**
+   * Get an {@link McpClient} for a content-declared MCP server on this database.
+   *
+   * @param slug - The `raisin:McpServer` slug (resolved in the `mcp` workspace).
+   * @returns A client scoped to `{repo}/{branch}/{slug}`, using this database's
+   *   branch (falling back to the HTTP client's current branch).
+   */
+  mcp(slug) {
+    const transport = {
+      rpc: (m, p) => this.client.mcpRpc(this.repository, this.schemaBranch(), slug, m, p),
+      subscribe: (m, p) => this.client.mcpSubscribe(this.repository, this.schemaBranch(), slug, m, p)
+    };
+    return new McpClient(transport);
+  }
+  /** Effective branch for management calls. */
+  schemaBranch() {
+    return this.branch ?? this.client.getBranch();
+  }
+  /** NodeType management (get/list/getResolved/create/update/delete/publish/unpublish). */
+  nodeTypes() {
+    return new HttpNodeTypes(this.repository, this.schemaBranch(), this.client);
+  }
+  /** Archetype management (get/list/getResolved/create/update/delete/publish/unpublish). */
+  archetypes() {
+    return new HttpArchetypes(this.repository, this.schemaBranch(), this.client);
+  }
+  /** ElementType management (get/list/getResolved/create/update/delete/publish/unpublish). */
+  elementTypes() {
+    return new HttpElementTypes(this.repository, this.schemaBranch(), this.client);
   }
 };
 var HttpWorkspaceClient = class {
@@ -7196,10 +9447,13 @@ var HttpWorkspaceClient = class {
 };
 
 // src/client.ts
-var RaisinClient = class _RaisinClient extends import_events4.EventEmitter {
+var _refreshingUser;
+var _RaisinClient = class _RaisinClient extends import_events4.EventEmitter {
   constructor(url, options = {}) {
     super();
     this._currentUser = null;
+    /** In-flight role re-resolve, used to coalesce concurrent refreshCurrentUser() calls. */
+    __privateAdd(this, _refreshingUser, null);
     // Auth state change listeners (Firebase/Supabase pattern)
     this._authListeners = /* @__PURE__ */ new Set();
     this._userChangeListeners = /* @__PURE__ */ new Set();
@@ -7210,23 +9464,44 @@ 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;
+    /** In-flight refresh shared by concurrent refreshToken() callers. */
+    this._refreshInFlight = null;
     if (options.logLevel !== void 0) {
       setLogLevel(options.logLevel);
     }
+    const connectionUrl = this.buildConnectionUrl(url, options.repository);
     this.options = {
       requestTimeout: options.requestTimeout ?? 3e4,
-      tenantId: options.tenantId ?? this.extractTenantFromUrl(url),
+      tenantId: options.tenantId ?? this.extractTenantFromUrl(connectionUrl),
       defaultBranch: options.defaultBranch ?? "main"
     };
-    this._httpBaseUrl = options.httpBaseUrl ?? this.deriveHttpUrl(url);
-    this._repository = this.extractRepositoryFromUrl(url);
+    this._tokenRefresher = options.tokenRefresher;
+    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 +9511,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 +9534,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 +9580,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 +9611,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 */) {
@@ -7319,8 +9646,13 @@ var RaisinClient = class _RaisinClient extends import_events4.EventEmitter {
       if (isConnectedMessage(message)) {
         this.handleConnectedMessage(message);
       } else if (isEventMessage(message)) {
-        logger.debug(`Routing to event handler`);
-        this.eventHandler.handleEvent(message);
+        if (message.event_type === "permissions:changed") {
+          logger.info("[permissions:changed] server signaled a role/permission change; re-resolving");
+          void this.refreshCurrentUser();
+        } else {
+          logger.debug(`Routing to event handler`);
+          this.eventHandler.handleEvent(message);
+        }
       } else if (isResponseEnvelope(message)) {
         logger.debug(`Routing to response handler - request_id: ${message.request_id}, status: ${message.status}`);
         this.handleResponse(message);
@@ -7353,19 +9685,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 +9723,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 +9776,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 +9796,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 +9817,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;
       }
     }
   }
@@ -7495,6 +9874,7 @@ var RaisinClient = class _RaisinClient extends import_events4.EventEmitter {
   async authenticate(credentials) {
     if (isJwtCredentials(credentials)) {
       logger.info("[authenticate] Starting JWT authentication...");
+      this.authManager.adoptToken(credentials.token);
       const payload = { token: credentials.token };
       const response = await this.sendRequestInternal(
         payload,
@@ -7561,18 +9941,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);
@@ -7601,11 +9981,11 @@ var RaisinClient = class _RaisinClient extends import_events4.EventEmitter {
     }
     this._currentUser = {
       userId: user.id,
-      roles: [],
+      roles: this._currentUser?.roles ?? [],
       anonymous: false,
       node: userNode ?? void 0
     };
-    const expiresInMs = tokens.expires_at * 1e3 - Date.now() - 5 * 60 * 1e3;
+    const expiresInMs = _RaisinClient.expiresAtToMs(tokens.expires_at) - Date.now() - 5 * 60 * 1e3;
     if (expiresInMs > 0) {
       this.scheduleAutoRefresh(expiresInMs);
     }
@@ -7629,18 +10009,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);
@@ -7667,11 +10047,11 @@ var RaisinClient = class _RaisinClient extends import_events4.EventEmitter {
     }
     this._currentUser = {
       userId: user.id,
-      roles: [],
+      roles: this._currentUser?.roles ?? [],
       anonymous: false,
       node: userNode ?? void 0
     };
-    const expiresInMs = tokens.expires_at * 1e3 - Date.now() - 5 * 60 * 1e3;
+    const expiresInMs = _RaisinClient.expiresAtToMs(tokens.expires_at) - Date.now() - 5 * 60 * 1e3;
     if (expiresInMs > 0) {
       this.scheduleAutoRefresh(expiresInMs);
     }
@@ -7763,39 +10143,18 @@ var RaisinClient = class _RaisinClient extends import_events4.EventEmitter {
     if (payload && payload.exp && typeof payload.exp === "number") {
       if (payload.exp * 1e3 < Date.now()) {
         logger.info("[initSession] Token expired, attempting refresh...");
-        const refreshToken = this.authManager.storage.getRefreshToken();
-        if (refreshToken) {
-          try {
-            const url = this._repository ? `${this._httpBaseUrl}/auth/${this._repository}/refresh` : `${this._httpBaseUrl}/auth/refresh`;
-            const response = await fetch(url, {
-              method: "POST",
-              headers: { "Content-Type": "application/json" },
-              body: JSON.stringify({ refresh_token: refreshToken })
-            });
-            if (response.ok) {
-              const tokens = await response.json();
-              this.authManager.storage.setAccessToken(tokens.access_token);
-              this.authManager.storage.setRefreshToken(tokens.refresh_token);
-              const expiresInMs = tokens.expires_at * 1e3 - Date.now() - 5 * 60 * 1e3;
-              if (expiresInMs > 0) {
-                this.scheduleAutoRefresh(expiresInMs);
-              }
-              logger.info("[initSession] Token refreshed successfully");
-            } else {
-              logger.warn("[initSession] Token refresh failed, clearing session");
-              this.authManager.clear();
-              return null;
-            }
-          } catch (err) {
-            logger.warn("[initSession] Token refresh error:", err);
-            this.authManager.clear();
-            return null;
-          }
-        } else {
+        if (!this.authManager.storage.getRefreshToken()) {
           logger.warn("[initSession] No refresh token, clearing session");
           this.authManager.clear();
           return null;
         }
+        const refreshed = await this.refreshToken();
+        if (!refreshed) {
+          logger.warn("[initSession] Token refresh failed, clearing session");
+          this.authManager.clear();
+          return null;
+        }
+        logger.info("[initSession] Token refreshed successfully");
       }
     }
     try {
@@ -7829,7 +10188,7 @@ var RaisinClient = class _RaisinClient extends import_events4.EventEmitter {
         }
         this._currentUser = {
           userId: user.id,
-          roles: [],
+          roles: this._currentUser?.roles ?? [],
           anonymous: false,
           node: userNode ?? void 0
         };
@@ -7885,6 +10244,17 @@ var RaisinClient = class _RaisinClient extends import_events4.EventEmitter {
    * @throws Error if no refresh token is stored or refresh fails
    */
   async refreshToken() {
+    if (this._refreshInFlight) {
+      logger.debug("[refreshToken] Refresh already in flight, awaiting it");
+      return this._refreshInFlight;
+    }
+    this._refreshInFlight = this._refreshToken().finally(() => {
+      this._refreshInFlight = null;
+    });
+    return this._refreshInFlight;
+  }
+  async _refreshToken() {
+    if (this._tokenRefresher) return this._refreshViaHook(this._tokenRefresher);
     const refreshToken = this.authManager.storage.getRefreshToken();
     if (!refreshToken) {
       logger.warn("[refreshToken] No refresh token available");
@@ -7893,7 +10263,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 })
@@ -7901,6 +10271,11 @@ var RaisinClient = class _RaisinClient extends import_events4.EventEmitter {
       if (!response.ok) {
         const errorText = await response.text();
         logger.error("[refreshToken] Refresh failed:", response.status, errorText);
+        if (/TOKEN_REUSE_DETECTED|TOKEN_FAMILY_MISMATCH/.test(errorText)) {
+          logger.error(
+            "[refreshToken] Session revoked by the server as a suspected token replay. If this happened on a normal page load, two refreshes raced on the same token."
+          );
+        }
         if (response.status === 401 || response.status === 403) {
           this.authManager.clear();
           this._currentUser = null;
@@ -7923,7 +10298,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 +10311,78 @@ var RaisinClient = class _RaisinClient extends import_events4.EventEmitter {
       return null;
     }
   }
+  /** `refreshToken()` through `ClientOptions.tokenRefresher` (the session is not the page's to renew). */
+  async _refreshViaHook(hook) {
+    try {
+      const res = await hook();
+      const accessToken = typeof res === "string" ? res : res?.accessToken;
+      if (!accessToken) {
+        this.authManager.clear();
+        this._currentUser = null;
+        this.emit("auth_error", new Error("Token refresh failed - session expired"));
+        return null;
+      }
+      this.authManager.storage.setAccessToken(accessToken);
+      this.authManager.adoptToken(accessToken);
+      const exp = typeof res === "object" && res?.expiresAt ? _RaisinClient.expiresAtToMs(res.expiresAt) : (AuthManager.parseToken(accessToken)?.exp ?? 0) * 1e3;
+      const inMs = exp - Date.now() - 6e4;
+      if (exp && inMs > 0) this.scheduleAutoRefresh(inMs);
+      const user = this._currentUser ? { id: this._currentUser.userId, email: "", displayName: null, avatarUrl: null, emailVerified: false, home: null } : { id: "", email: "", displayName: null, avatarUrl: null, emailVerified: false, home: null };
+      this._emitAuthEvent("TOKEN_REFRESHED");
+      this.emit("token_refreshed", user);
+      return user;
+    } catch (err) {
+      logger.error("[refreshToken] tokenRefresher failed:", err);
+      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 +10391,18 @@ 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);
+      const user = await this.refreshToken();
+      if (!user) {
+        logger.error("[autoRefresh] Refresh failed, clearing session");
+        this.authManager.clear();
+        this._currentUser = null;
+        this._emitAuthEvent("SESSION_EXPIRED");
+      }
+    }, clamped);
   }
   /**
    * Get a database/repository interface
@@ -7967,15 +10421,35 @@ var RaisinClient = class _RaisinClient extends import_events4.EventEmitter {
       void 0,
       () => this.getUploadManager(),
       (options) => this.signAssetUrl(options),
-      { httpBaseUrl: this._httpBaseUrl, authManager: this.authManager }
+      {
+        httpBaseUrl: this._httpBaseUrl,
+        authManager: this.authManager,
+        onReconnected: (callback) => this.onReconnected(callback)
+      }
     );
   }
   /**
    * 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 +10468,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 +10487,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
    */
@@ -8083,6 +10600,44 @@ var RaisinClient = class _RaisinClient extends import_events4.EventEmitter {
   getCurrentUser() {
     return this._currentUser;
   }
+  /**
+   * Re-resolve the current user's EFFECTIVE roles from the server and refresh
+   * `getCurrentUser()`.
+   *
+   * Roles are deliberately not embedded in the JWT (they are resolved live
+   * server-side), so when an admin changes a user's roles/groups the token does
+   * not change — the client must re-ask. This re-runs the WS JWT auth handshake
+   * (which returns freshly resolved effective roles), updates `_currentUser`, and
+   * emits `USER_UPDATED` so role-gated UI can react without a reload.
+   *
+   * Called automatically when the server pushes `permissions:changed` after an
+   * access-control write, and exposed for on-demand refresh. Safe no-op when not
+   * authenticated.
+   */
+  async refreshCurrentUser() {
+    if (__privateGet(this, _refreshingUser)) return __privateGet(this, _refreshingUser);
+    const token = this.authManager.storage.getAccessToken();
+    if (!token) return;
+    __privateSet(this, _refreshingUser, (async () => {
+      const before = JSON.stringify(this._currentUser?.roles ?? null);
+      const prevNode = this._currentUser?.node;
+      try {
+        await this.authenticate({ type: "jwt", token });
+        if (this._currentUser && prevNode && !this._currentUser.node) {
+          this._currentUser.node = prevNode;
+        }
+        const after = JSON.stringify(this._currentUser?.roles ?? null);
+        if (after !== before) {
+          this._emitAuthEvent("USER_UPDATED");
+        }
+      } catch (err) {
+        logger.warn("[refreshCurrentUser] role re-resolve failed:", err);
+      } finally {
+        __privateSet(this, _refreshingUser, null);
+      }
+    })());
+    return __privateGet(this, _refreshingUser);
+  }
   /**
    * Get current user ID
    *
@@ -8291,7 +10846,10 @@ var RaisinClient = class _RaisinClient extends import_events4.EventEmitter {
   _emitAuthEvent(event) {
     const session = {
       user: this.getStoredUser(),
-      accessToken: this.authManager.storage.getAccessToken()
+      accessToken: this.authManager.storage.getAccessToken(),
+      // Surface effective roles so role-gated consumers can react to
+      // SIGNED_IN / USER_UPDATED without calling getCurrentUser() themselves.
+      roles: this._currentUser?.roles ?? null
     };
     const change = { event, session };
     for (const callback of this._authListeners) {
@@ -8331,6 +10889,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 +11189,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 +11244,10 @@ var RaisinClient = class _RaisinClient extends import_events4.EventEmitter {
     return _RaisinClient.forSSR(baseUrl, options);
   }
 };
+_refreshingUser = new WeakMap();
+/** Hard cap on requests held while reconnecting; overflow rejects immediately. */
+_RaisinClient.MAX_QUEUED_REQUESTS = 100;
+var RaisinClient = _RaisinClient;
 
 // src/node-builder.ts
 var NodeBuilder = class _NodeBuilder {
@@ -8772,7 +11335,12 @@ var NodeBuilder = class _NodeBuilder {
     return this;
   }
   /**
-   * Set the order key
+   * Set the order key.
+   *
+   * @deprecated The server owns editorial ordering: the order key is assigned by
+   * the ordering index on write, so any value set here is overwritten. To place a
+   * node, create it (it appends to the end of its parent) then call
+   * `nodes.reorder()`, `nodes.moveChildBefore()` or `nodes.moveChildAfter()`.
    */
   orderKey(orderKey) {
     this.node.order_key = orderKey;
@@ -8852,10 +11420,10 @@ var NodeBuilder = class _NodeBuilder {
     if (!this.node.node_type) {
       throw new Error("Node type is required");
     }
+    if (this.node.order_key === void 0) this.node.order_key = "";
     if (!this.node.children) this.node.children = [];
     if (!this.node.relations) this.node.relations = [];
     if (!this.node.properties) this.node.properties = {};
-    if (!this.node.order_key) this.node.order_key = "a";
     if (typeof this.node.version !== "number") this.node.version = 1;
     return this.node;
   }
@@ -8937,8 +11505,8 @@ var NodeHelpers = class {
       node_type: "MockType",
       properties: {},
       children: [],
+      order_key: "",
       relations: [],
-      order_key: "a",
       version: 1,
       ...overrides
     };
@@ -9019,6 +11587,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;
@@ -9038,15 +11629,35 @@ function parsePlanTasks(rawTasks) {
     }
     const task = asRecord(rawTask);
     if (!task) return null;
+    const delegation = asRecord(task.delegation);
     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)
+      priority: asString(task.priority),
+      delegation: delegation ? {
+        id: asString(delegation.id),
+        status: asString(delegation.status) ?? "unknown",
+        agentRef: asString(delegation.agent_ref) ?? asString(delegation.agentRef),
+        flowInstanceId: asString(delegation.flow_instance_id) ?? asString(delegation.flowInstanceId),
+        branch: asString(delegation.branch),
+        baseBranch: asString(delegation.base_branch) ?? asString(delegation.baseBranch),
+        result: delegation.result,
+        error: asString(delegation.error)
+      } : void 0
     };
   }).filter((task) => task !== null);
 }
+var TERMINAL_TASK_STATUSES = /* @__PURE__ */ new Set(["completed", "cancelled"]);
+var TERMINAL_PLAN_STATUSES = /* @__PURE__ */ new Set(["completed", "failed", "cancelled"]);
+function setPlanStatus(plan, nextStatus) {
+  if (!nextStatus) return;
+  if (TERMINAL_PLAN_STATUSES.has(plan.status) && !TERMINAL_PLAN_STATUSES.has(nextStatus)) {
+    return;
+  }
+  plan.status = nextStatus;
+}
 function upsertTask(plan, nextTask) {
   const existingIndex = plan.tasks.findIndex(
     (task) => nextTask.taskId && task.taskId === nextTask.taskId || !nextTask.taskId && task.title === nextTask.title
@@ -9055,8 +11666,12 @@ function upsertTask(plan, nextTask) {
     plan.tasks.push(nextTask);
     return;
   }
+  const existing = plan.tasks[existingIndex];
+  if (TERMINAL_TASK_STATUSES.has(existing.status) && !TERMINAL_TASK_STATUSES.has(nextTask.status)) {
+    return;
+  }
   plan.tasks[existingIndex] = {
-    ...plan.tasks[existingIndex],
+    ...existing,
     ...nextTask
   };
 }
@@ -9100,7 +11715,7 @@ function projectPlansFromMessages(messages) {
       plan.planPath = planPath ?? plan.planPath;
       plan.planId = planId ?? plan.planId;
       plan.title = asString(data.title) || plan.title;
-      plan.status = asString(data.status) || plan.status;
+      setPlanStatus(plan, asString(data.status));
       plan.requiresApproval = Boolean(data.requires_approval) || plan.status === "pending_approval";
       plan.sourceMessagePath = message.path ?? plan.sourceMessagePath;
       const parsedTasks = parsePlanTasks(data.tasks);
@@ -9116,7 +11731,7 @@ function projectPlansFromMessages(messages) {
       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;
+      setPlanStatus(plan, asString(data.plan_status));
       plan.requiresApproval = plan.status === "pending_approval";
       const taskUpdate = {
         taskId: asString(data.task_id),
@@ -9137,12 +11752,28 @@ function projectPlansFromMessages(messages) {
           plan.tasks = child.tasks.map((task) => ({
             taskId: task.id,
             title: task.title,
-            status: task.status
+            status: task.status,
+            delegation: task.delegation ? {
+              id: task.delegation.id,
+              status: task.delegation.status,
+              agentRef: task.delegation.agentRef,
+              flowInstanceId: task.delegation.flowInstanceId,
+              branch: task.delegation.branch,
+              baseBranch: task.delegation.baseBranch,
+              result: task.delegation.result,
+              error: task.delegation.error
+            } : void 0
           }));
         }
       }
     }
   }
+  for (const plan of plans.values()) {
+    if (!TERMINAL_PLAN_STATUSES.has(plan.status) && plan.tasks.length > 0 && plan.tasks.every((task) => TERMINAL_TASK_STATUSES.has(task.status))) {
+      plan.status = "completed";
+      plan.requiresApproval = false;
+    }
+  }
   return [...plans.values()].sort((a, b) => {
     const aTime = Date.parse(a.updatedAt || "");
     const bTime = Date.parse(b.updatedAt || "");
@@ -9174,6 +11805,34 @@ var ConversationStore = class {
     this._watchdogIntervalMs = options.watchdogIntervalMs ?? 3e4;
     if (this._conversationPath) {
       this.ensureSubscription();
+    } else if (this.createOptions?.anonymous) {
+      void this.resumeAnonymous();
+    }
+  }
+  anonymousOptions() {
+    const a = this.createOptions?.anonymous;
+    if (!a) return null;
+    return a === true ? {} : a;
+  }
+  /**
+   * Resume the visitor conversation this tab already has (the session secret
+   * and conversation id live in sessionStorage), and load its history. A tab
+   * without one starts nothing until the first message.
+   */
+  async resumeAnonymous() {
+    const opts = this.anonymousOptions();
+    if (!opts || !this.createOptions || this._conversationPath) return;
+    const agent = this.createOptions.participant;
+    try {
+      if (!this.manager.hasStoredAnonymous(agent, opts)) return;
+      const convo = await this.manager.startAnonymous(agent, opts);
+      if (this._conversationPath) return;
+      this._conversationPath = convo.conversationPath;
+      this._conversationType = convo.type;
+      this.ensureSubscription();
+      await this.loadMessages();
+    } catch (err) {
+      logger.debug("[ConversationStore] No visitor conversation to resume", err);
     }
   }
   // ==========================================================================
@@ -9228,7 +11887,8 @@ var ConversationStore = class {
         throw new Error("No conversationPath and no createOptions provided");
       }
       try {
-        const convo = await this.manager.create({
+        const anonymous = this.anonymousOptions();
+        const convo = anonymous ? await this.manager.startAnonymous(this.createOptions.participant, anonymous) : await this.manager.create({
           participant: this.createOptions.participant,
           input: this.createOptions.input
         });
@@ -9357,10 +12017,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 +12031,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 +12044,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 +12119,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 +12157,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 +12410,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 +12563,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 +12670,7 @@ function useConversation(react, options) {
 var INITIAL_LIST_SNAPSHOT = {
   conversations: [],
   totalUnreadCount: 0,
-  isLoading: false,
+  isLoading: true,
   error: null
 };
 function useConversationList(react, options) {
@@ -10860,8 +13548,164 @@ 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 = {
+  AgentRunsApi,
+  AgentRunsWsApi,
   AllNodeEventTypes,
   Archetypes,
   AuthManager,
@@ -10881,6 +13725,7 @@ function createRaisinReact(react) {
   DEFAULT_RETRY_BASE_DELAY,
   DEFAULT_RETRY_MAX_DELAY,
   DEFAULT_RETRY_OPTIONS,
+  DEFAULT_SEND_MESSAGE_INACTIVITY_TIMEOUT_MS,
   Database,
   ElementTypes,
   EventHandler,
@@ -10888,19 +13733,27 @@ function createRaisinReact(react) {
   FlowClient,
   FlowsApi,
   FunctionsApi,
+  HttpArchetypes,
   HttpDatabase,
+  HttpElementTypes,
   HttpFunctionsApi,
+  HttpNodeTypes,
   HttpWorkspaceClient,
+  IdentityAuthApi,
+  InboxApi,
   LocalStorageTokenStorage,
   LogLevel,
+  McpClient,
   MemoryTokenStorage,
   NodeBuilder,
+  NodeDevApi,
   NodeEventType,
   NodeFileSource,
   NodeHelpers,
   NodeOperations,
   NodeTypes,
   RAISIN_CONTEXT_KEY,
+  RETRY_STRATEGIES,
   RaisinAbortError,
   RaisinAuthError,
   RaisinClient,
@@ -10915,6 +13768,7 @@ function createRaisinReact(react) {
   ResponseStatus,
   RetryBuilder,
   SSEClient,
+  SchedulerApi,
   SqlQuery,
   Tags,
   Transaction,
@@ -10922,6 +13776,7 @@ function createRaisinReact(react) {
   UploadErrorCode,
   UploadManager,
   Uploader,
+  VisitorChatError,
   WorkspaceClient,
   WorkspaceManager,
   calculateChunkCount,
@@ -10936,31 +13791,42 @@ function createRaisinReact(react) {
   createFlowAdapter,
   createLoader,
   createRaisinReact,
+  createRaisinVue,
   createRequestScopedClient,
   createSSRClient,
   createSqlAdapter,
   createSqlHandler,
   createSubscriptionAdapter,
   decodeMessage,
+  defaultVisitorSessionStore,
   encodeMessage,
   getChunkRange,
   getContentType,
   getErrorMessage,
   getLogLevel,
   getLoggerConfig,
+  getRefDisplayName,
+  getRefPath,
   isEventMessage,
+  isFlowDefinitionContainer,
+  isFlowDefinitionStep,
   isHttpClient,
   isResponseEnvelope,
   isRetryableError,
   isTerminalEvent,
   isWebSocketClient,
   logger,
+  newControlId,
+  normalizeHomePath,
   projectPlansFromMessages,
+  readTokensFromFragment,
   rowsToObjects,
   setLogLevel,
   sleep,
+  subjectOf,
   useConversation,
   useConversationList,
   useFlow,
   withRetry
 });
+//# sourceMappingURL=index.js.map