@deepagents/context 7.1.1 → 7.1.3

package/dist/index.js

@@ -175,7 +175,7 @@ function fitsFragmentData(value, visited) {
   if (Array.isArray(value)) {
     return value.every((item) => fitsFragmentData(item, visited));
   }
-  if (value instanceof Promise) return true;
+  if (value instanceof Promise) return false;
   if (Symbol.asyncIterator in value || Symbol.iterator in value) return true;
   if (isFragment(value)) return fitsFragmentData(value.data, visited);
   return Object.values(value).every((item) => fitsFragmentData(item, visited));
@@ -2647,6 +2647,7 @@ import {
   isStaticToolUIPart as isStaticToolUIPart2,
   validateUIMessages
 } from "ai";
+import pMemoize2 from "p-memoize";
 
 // packages/context/src/lib/ui-message-guards.ts
 function isRecord2(value) {
@@ -2679,75 +2680,63 @@ function mergeReply(segments) {
     parts: segments.flatMap((segment) => segment.parts)
   };
 }
-var ChainSummaryBuilder = class {
-  #turn = 0;
-  #messageCount = 0;
-  #lastMessageAt;
-  #lastMessage;
-  #lastAssistantMessage;
-  #lastAssistantMessages = [];
-  #replies = [];
-  #replyClosed = true;
-  #firedOnceIds = /* @__PURE__ */ new Set();
-  ingestStored(msg) {
-    this.#messageCount++;
+function summarizeChain(stored, pending) {
+  let turn = 0;
+  let lastMessageAt;
+  let lastMessage;
+  const assistantMessages = [];
+  let reply = [];
+  const replies = [reply];
+  const firedOnceIds = /* @__PURE__ */ new Set();
+  for (const msg of stored) {
     if (msg.name === "assistant") {
       const message3 = requireUIMessage(
         msg.data,
         `Stored assistant message "${msg.id}"`
       );
-      this.#lastAssistantMessage = message3;
-      this.#lastAssistantMessages.push(message3);
-      const open = this.#replies.at(-1);
-      if (open && !this.#replyClosed) open.push(message3);
-      else {
-        this.#replies.push([message3]);
-        this.#replyClosed = false;
-      }
-      return;
-    }
-    if (msg.name !== "user") {
-      return;
+      assistantMessages.push(message3);
+      reply.push(message3);
+      continue;
     }
+    if (msg.name !== "user") continue;
     const message2 = requireUIMessage(
       msg.data,
       `Stored user message "${msg.id}"`
     );
     if (isSyntheticReminderMessage(message2)) {
       for (const id of message2.metadata.synthetic.onceIds ?? []) {
-        this.#firedOnceIds.add(id);
+        firedOnceIds.add(id);
       }
-      return;
+      continue;
     }
-    for (const id of getReminderOnceIds(message2)) this.#firedOnceIds.add(id);
-    this.#turn++;
-    this.#lastMessageAt = msg.createdAt;
-    this.#lastMessage = message2;
-    this.#replyClosed = true;
+    for (const id of getReminderOnceIds(message2)) firedOnceIds.add(id);
+    turn++;
+    lastMessageAt = msg.createdAt;
+    lastMessage = message2;
+    reply = [];
+    replies.push(reply);
   }
-  ingestPending(fragment2) {
-    this.#messageCount++;
-    if (fragment2.name !== "user") return;
+  for (const fragment2 of pending) {
+    if (fragment2.name !== "user") continue;
     const encoded = fragment2.codec?.encode();
-    if (isUIMessage(encoded) && isSyntheticReminderMessage(encoded)) return;
-    this.#turn++;
+    if (isUIMessage(encoded) && isSyntheticReminderMessage(encoded)) continue;
+    turn++;
   }
-  build() {
-    return {
-      turn: this.#turn,
-      messageCount: this.#messageCount,
-      lastMessageAt: this.#lastMessageAt,
-      lastMessage: this.#lastMessage,
-      lastAssistantMessage: this.#lastAssistantMessage,
-      lastAssistantMessages: this.#lastAssistantMessages,
-      lastAssistantReplies: this.#replies.map(mergeReply),
-      firedOnceIds: this.#firedOnceIds
-    };
-  }
-};
+  return {
+    turn,
+    messageCount: stored.length + pending.length,
+    lastMessageAt,
+    lastMessage,
+    lastAssistantMessage: assistantMessages.at(-1),
+    lastAssistantMessages: assistantMessages,
+    lastAssistantReplies: replies.filter((segments) => segments.length > 0).map(mergeReply),
+    firedOnceIds
+  };
+}
 
 // packages/context/src/lib/estimate.ts
 import { encode } from "gpt-tokenizer";
+import pMemoize from "p-memoize";
 import { z as z2 } from "zod";
 var defaultTokenizer = {
   encode(text) {
@@ -2789,14 +2778,17 @@ function inputPricePerMillion(model) {
 }
 var ModelsRegistry = class {
   #cache = /* @__PURE__ */ new Map();
-  #loaded = false;
   #tokenizers = /* @__PURE__ */ new Map();
   #defaultTokenizer = defaultTokenizer;
+  /** Fetches once; concurrent calls share the fetch, and a failed one runs again. */
+  #load = pMemoize(() => this.#fetchModels());
   /**
    * Load models data from models.dev API
    */
   async load() {
-    if (this.#loaded) return;
+    await this.#load();
+  }
+  async #fetchModels() {
     const response = await fetch("https://models.dev/api.json");
     if (!response.ok) {
       throw new Error(`Failed to fetch models: ${response.statusText}`);
@@ -2815,7 +2807,6 @@ var ModelsRegistry = class {
         this.#cache.set(`${providerId}:${modelId}`, info);
       }
     }
-    this.#loaded = true;
   }
   /**
    * Get model info by ID
@@ -3059,20 +3050,6 @@ function pushLimited2(collected, chunk, maxItems, resolverName) {
   collected.push(chunk);
 }
 
-// packages/context/src/lib/resolvers/promise-resolver.ts
-var PromiseResolver = class {
-  name = "PromiseResolver";
-  canResolve(value) {
-    return value instanceof Promise;
-  }
-  async resolve(value, _ctx) {
-    if (!this.canResolve(value)) {
-      throw new TypeError(`${this.name} cannot resolve a ${typeof value}`);
-    }
-    return value;
-  }
-};
-
 // packages/context/src/lib/resolvers/loader-resolver.ts
 var FragmentLoaderResolver = class {
   #resolvers;
@@ -3207,7 +3184,6 @@ function defaultResolvers() {
     new AsyncResolver(),
     new GeneratorResolver(),
     new FunctionResolver(),
-    new PromiseResolver(),
     new IterableResolver()
   ];
 }
@@ -3224,14 +3200,14 @@ var HeadConflictError = class extends Error {
 var SavePipeline = class _SavePipeline {
   #engine;
   #pending;
-  #shouldBranch = true;
-  constructor(engine, pending) {
+  #shouldBranch;
+  constructor(engine, pending, shouldBranch) {
     this.#engine = engine;
     this.#pending = pending;
-  }
-  async applyUpdateBranching(shouldBranch) {
     this.#shouldBranch = shouldBranch;
-    if (!shouldBranch) return this;
+  }
+  async applyUpdateBranching() {
+    if (!this.#shouldBranch) return this;
     for (const fragment2 of this.#pending) {
       if (!fragment2.id) continue;
       const existing = await this.#engine.store.getMessage(fragment2.id);
@@ -3323,7 +3299,10 @@ var SavePipeline = class _SavePipeline {
 };
 
 // packages/context/src/lib/store/sqlite.store.ts
-import { DatabaseSync } from "node:sqlite";
+import { transaction } from "@zukhruf/sqlite-transaction";
+import {
+  DatabaseSync
+} from "node:sqlite";
 import { z as z4 } from "zod";
 
 // packages/context/src/lib/store/columns.ts
@@ -3472,92 +3451,82 @@ function toMessage(row) {
     createdAt: row.createdAt
   };
 }
+var SearchQuerySyntaxError = class extends Error {
+  constructor(query, options) {
+    super(
+      `The search query ${JSON.stringify(query)} is not valid FTS5 syntax. Put a term that has characters such as - or : in double quotes: "well-known" finds the term well-known.`,
+      options
+    );
+    this.name = "SearchQuerySyntaxError";
+  }
+};
+function isFts5QueryError(error) {
+  return error instanceof Error && "errcode" in error && error.errcode === 1 && /^(fts5: syntax error near |no such column: |unterminated string$|unknown special query: |expected integer, got )/.test(
+    error.message
+  );
+}
 var SqliteContextStore = class extends ContextStore {
   #db;
-  #statements = /* @__PURE__ */ new Map();
-  /**
-   * Get or create a prepared statement.
-   * Statements are cached for the lifetime of the store to avoid
-   * repeated SQL parsing and compilation overhead.
-   */
-  #stmt(sql) {
-    let stmt = this.#statements.get(sql);
-    if (!stmt) {
-      stmt = this.#db.prepare(sql);
-      this.#statements.set(sql, stmt);
-    }
-    return stmt;
-  }
+  #sql;
   constructor(pathOrDb) {
     super();
     this.#db = typeof pathOrDb === "string" ? new DatabaseSync(pathOrDb) : pathOrDb;
     this.#db.exec(ddl_sqlite_default);
-  }
-  /**
-   * Execute a function within a transaction.
-   * Automatically commits on success or rolls back on error.
-   */
-  #useTransaction(fn, mode = "deferred") {
-    this.#db.exec(
-      mode === "immediate" ? "BEGIN IMMEDIATE" : "BEGIN TRANSACTION"
-    );
-    try {
-      const result = fn();
-      this.#db.exec("COMMIT");
-      return result;
-    } catch (error) {
-      try {
-        this.#db.exec("ROLLBACK");
-      } catch {
-      }
-      throw error;
-    }
+    this.#sql = this.#db.createTagStore();
   }
   // ==========================================================================
   // Chat Operations
   // ==========================================================================
   async createChat(chat2) {
-    return this.#useTransaction(() => {
-      const created = storedChat.parse(
-        this.#db.prepare(
-          `INSERT INTO chats (id, userId, title, metadata)
+    return transaction(
+      this.#db,
+      () => {
+        const created = storedChat.parse(
+          this.#db.prepare(
+            `INSERT INTO chats (id, userId, title, metadata)
            VALUES (?, ?, ?, ?)
            RETURNING *`
-        ).get(
-          chat2.id,
-          chat2.userId,
-          chat2.title ?? null,
-          chat2.metadata ? JSON.stringify(chat2.metadata) : null
-        )
-      );
-      this.#db.prepare(
-        `INSERT INTO branches (id, chatId, name, headMessageId, isActive, createdAt)
+          ).get(
+            chat2.id,
+            chat2.userId,
+            chat2.title ?? null,
+            chat2.metadata ? JSON.stringify(chat2.metadata) : null
+          )
+        );
+        this.#db.prepare(
+          `INSERT INTO branches (id, chatId, name, headMessageId, isActive, createdAt)
            VALUES (?, ?, 'main', NULL, 1, ?)`
-      ).run(crypto.randomUUID(), chat2.id, Date.now());
-      return created;
-    });
+        ).run(crypto.randomUUID(), chat2.id, Date.now());
+        return created;
+      },
+      { mode: "deferred" }
+    );
   }
   async upsertChat(chat2) {
-    return this.#useTransaction(() => {
-      const upserted = storedChat.parse(
-        this.#db.prepare(
-          `INSERT INTO chats (id, userId, title, metadata)
+    return transaction(
+      this.#db,
+      () => {
+        const upserted = storedChat.parse(
+          this.#db.prepare(
+            `INSERT INTO chats (id, userId, title, metadata)
            VALUES (?, ?, ?, ?)
            ON CONFLICT(id) DO UPDATE SET id = excluded.id
            RETURNING *`
-        ).get(
-          chat2.id,
-          chat2.userId,
-          chat2.title ?? null,
-          chat2.metadata ? JSON.stringify(chat2.metadata) : null
-        )
-      );
-      this.#db.prepare(
-        `INSERT OR IGNORE INTO branches (id, chatId, name, headMessageId, isActive, createdAt)
+          ).get(
+            chat2.id,
+            chat2.userId,
+            chat2.title ?? null,
+            chat2.metadata ? JSON.stringify(chat2.metadata) : null
+          )
+        );
+        this.#db.prepare(
+          `INSERT OR IGNORE INTO branches (id, chatId, name, headMessageId, isActive, createdAt)
            VALUES (?, ?, 'main', NULL, 1, ?)`
-      ).run(crypto.randomUUID(), chat2.id, Date.now());
-      return upserted;
-    });
+        ).run(crypto.randomUUID(), chat2.id, Date.now());
+        return upserted;
+      },
+      { mode: "deferred" }
+    );
   }
   #getChat(chatId) {
     return storedChat.optional().parse(this.#db.prepare("SELECT * FROM chats WHERE id = ?").get(chatId));
@@ -3566,30 +3535,36 @@ var SqliteContextStore = class extends ContextStore {
     return this.#getChat(chatId);
   }
   async updateChat(chatId, update) {
-    return this.#useTransaction(() => {
-      const current = this.#getChat(chatId);
-      if (!current) {
-        throw new Error(`updateChat: chat "${chatId}" not found`);
-      }
-      const updates = update(current);
-      if (updates === void 0) return current;
-      const setClauses = ["updatedAt = strftime('%s', 'now') * 1000"];
-      const params = [];
-      if (updates.title !== void 0) {
-        setClauses.push("title = ?");
-        params.push(updates.title);
-      }
-      if (updates.metadata !== void 0) {
-        setClauses.push("metadata = ?");
-        params.push(JSON.stringify(updates.metadata));
-      }
-      params.push(chatId);
-      return storedChat.parse(
-        this.#db.prepare(
-          `UPDATE chats SET ${setClauses.join(", ")} WHERE id = ? RETURNING *`
-        ).get(...params)
-      );
-    }, "immediate");
+    return transaction(
+      this.#db,
+      () => {
+        const current = this.#getChat(chatId);
+        if (!current) {
+          throw new Error(`updateChat: chat "${chatId}" not found`);
+        }
+        const updates = update(current);
+        if (updates === void 0) return current;
+        const setClauses = [
+          "updatedAt = strftime('%s', 'now') * 1000"
+        ];
+        const params = [];
+        if (updates.title !== void 0) {
+          setClauses.push("title = ?");
+          params.push(updates.title);
+        }
+        if (updates.metadata !== void 0) {
+          setClauses.push("metadata = ?");
+          params.push(JSON.stringify(updates.metadata));
+        }
+        params.push(chatId);
+        return storedChat.parse(
+          this.#db.prepare(
+            `UPDATE chats SET ${setClauses.join(", ")} WHERE id = ? RETURNING *`
+          ).get(...params)
+        );
+      },
+      { mode: "immediate" }
+    );
   }
   async listChats(options) {
     const params = [];
@@ -3636,25 +3611,29 @@ var SqliteContextStore = class extends ContextStore {
     );
   }
   async deleteChat(chatId, options) {
-    return this.#useTransaction(() => {
-      const messageIds = z4.array(idRow).parse(
-        this.#db.prepare("SELECT id FROM messages WHERE chatId = ?").all(chatId)
-      );
-      let sql = "DELETE FROM chats WHERE id = ?";
-      const params = [chatId];
-      if (options?.userId !== void 0) {
-        sql += " AND userId = ?";
-        params.push(options.userId);
-      }
-      const result = this.#db.prepare(sql).run(...params);
-      if (result.changes > 0 && messageIds.length > 0) {
-        const placeholders = messageIds.map(() => "?").join(", ");
-        this.#db.prepare(
-          `DELETE FROM messages_fts WHERE messageId IN (${placeholders})`
-        ).run(...messageIds.map((m) => m.id));
-      }
-      return result.changes > 0;
-    });
+    return transaction(
+      this.#db,
+      () => {
+        const messageIds = z4.array(idRow).parse(
+          this.#db.prepare("SELECT id FROM messages WHERE chatId = ?").all(chatId)
+        );
+        let sql = "DELETE FROM chats WHERE id = ?";
+        const params = [chatId];
+        if (options?.userId !== void 0) {
+          sql += " AND userId = ?";
+          params.push(options.userId);
+        }
+        const result = this.#db.prepare(sql).run(...params);
+        if (result.changes > 0 && messageIds.length > 0) {
+          const placeholders = messageIds.map(() => "?").join(", ");
+          this.#db.prepare(
+            `DELETE FROM messages_fts WHERE messageId IN (${placeholders})`
+          ).run(...messageIds.map((m) => m.id));
+        }
+        return result.changes > 0;
+      },
+      { mode: "deferred" }
+    );
   }
   // ==========================================================================
   // Message Operations (Graph Nodes)
@@ -3663,59 +3642,48 @@ var SqliteContextStore = class extends ContextStore {
     if (message2.parentId === message2.id) {
       throw new Error(`Message ${message2.id} cannot be its own parent`);
     }
-    this.#stmt(
-      `INSERT INTO messages (id, chatId, parentId, name, type, data, createdAt)
-       VALUES (?, ?, ?, ?, ?, ?, ?)
+    this.#sql.run`INSERT INTO messages (id, chatId, parentId, name, type, data, createdAt)
+       VALUES (${message2.id}, ${message2.chatId}, ${message2.parentId}, ${message2.name}, ${message2.type ?? null}, ${JSON.stringify(message2.data)}, ${message2.createdAt})
        ON CONFLICT(id) DO UPDATE SET
          name = excluded.name,
          type = excluded.type,
-         data = excluded.data`
-    ).run(
-      message2.id,
-      message2.chatId,
-      message2.parentId,
-      message2.name,
-      message2.type ?? null,
-      JSON.stringify(message2.data),
-      message2.createdAt
-    );
+         data = excluded.data`;
     const content = typeof message2.data === "string" ? message2.data : JSON.stringify(message2.data);
-    this.#stmt(`DELETE FROM messages_fts WHERE messageId = ?`).run(message2.id);
-    this.#stmt(
-      `INSERT INTO messages_fts(messageId, chatId, name, content)
-       VALUES (?, ?, ?, ?)`
-    ).run(message2.id, message2.chatId, message2.name, content);
+    this.#sql.run`DELETE FROM messages_fts WHERE messageId = ${message2.id}`;
+    this.#sql.run`INSERT INTO messages_fts(messageId, chatId, name, content)
+       VALUES (${message2.id}, ${message2.chatId}, ${message2.name}, ${content})`;
   }
   async addMessage(message2) {
     this.#insertMessage(message2);
   }
   async addMessages(messages) {
     if (messages.length === 0) return;
-    this.#useTransaction(() => {
-      for (const message2 of messages) {
-        this.#insertMessage(message2);
-      }
-    });
+    transaction(
+      this.#db,
+      () => {
+        for (const message2 of messages) {
+          this.#insertMessage(message2);
+        }
+      },
+      { mode: "deferred" }
+    );
   }
   async setMessageParent(messageId, parentId) {
     if (parentId === messageId) {
       throw new Error(`Message ${messageId} cannot be its own parent`);
     }
-    const result = this.#stmt(
-      "UPDATE messages SET parentId = ? WHERE id = ?"
-    ).run(parentId, messageId);
+    const result = this.#sql.run`UPDATE messages SET parentId = ${parentId} WHERE id = ${messageId}`;
     if (result.changes === 0) {
       throw new Error(`Message ${messageId} not found`);
     }
   }
   async getMessage(messageId) {
-    return storedMessage.optional().parse(this.#stmt("SELECT * FROM messages WHERE id = ?").get(messageId));
+    return storedMessage.optional().parse(this.#sql.get`SELECT * FROM messages WHERE id = ${messageId}`);
   }
   async getMessageChain(headId) {
     return z4.array(storedMessage).parse(
-      this.#stmt(
-        `WITH RECURSIVE chain AS (
-        SELECT *, 0 as depth FROM messages WHERE id = ?
+      this.#sql.all`WITH RECURSIVE chain AS (
+        SELECT *, 0 as depth FROM messages WHERE id = ${headId}
         UNION ALL
         SELECT m.*, c.depth + 1 FROM messages m
         INNER JOIN chain c ON m.id = c.parentId
@@ -3723,14 +3691,11 @@ var SqliteContextStore = class extends ContextStore {
       )
       SELECT * FROM chain
       ORDER BY depth DESC`
-      ).all(headId)
     );
   }
   async hasChildren(messageId) {
     const row = hasChildrenRow.parse(
-      this.#stmt(
-        "SELECT EXISTS(SELECT 1 FROM messages WHERE parentId = ?) as hasChildren"
-      ).get(messageId)
+      this.#sql.get`SELECT EXISTS(SELECT 1 FROM messages WHERE parentId = ${messageId}) as hasChildren`
     );
     return row.hasChildren === 1;
   }
@@ -3768,9 +3733,7 @@ var SqliteContextStore = class extends ContextStore {
   }
   async getActiveBranch(chatId) {
     return storedBranch.optional().parse(
-      this.#stmt(
-        "SELECT * FROM branches WHERE chatId = ? AND isActive = 1"
-      ).get(chatId)
+      this.#sql.get`SELECT * FROM branches WHERE chatId = ${chatId} AND isActive = 1`
     );
   }
   async setActiveBranch(chatId, branchId) {
@@ -3778,9 +3741,7 @@ var SqliteContextStore = class extends ContextStore {
     this.#db.prepare("UPDATE branches SET isActive = 1 WHERE id = ?").run(branchId);
   }
   async updateBranchHead(branchId, messageId, expectedHeadMessageId) {
-    const result = this.#stmt(
-      "UPDATE branches SET headMessageId = ? WHERE id = ? AND headMessageId IS ?"
-    ).run(messageId, branchId, expectedHeadMessageId);
+    const result = this.#sql.run`UPDATE branches SET headMessageId = ${messageId} WHERE id = ${branchId} AND headMessageId IS ${expectedHeadMessageId}`;
     return result.changes > 0;
   }
   async listBranches(chatId) {
@@ -3876,7 +3837,15 @@ var SqliteContextStore = class extends ContextStore {
     }
     sql += " ORDER BY fts.rank LIMIT ?";
     params.push(limit);
-    return z4.array(searchResult).parse(this.#db.prepare(sql).all(...params));
+    const statement2 = this.#db.prepare(sql);
+    try {
+      return z4.array(searchResult).parse(statement2.all(...params));
+    } catch (error) {
+      if (isFts5QueryError(error)) {
+        throw new SearchQuerySyntaxError(query, { cause: error });
+      }
+      throw error;
+    }
   }
   // ==========================================================================
   // Visualization Operations
@@ -4101,6 +4070,25 @@ function mergeTerminalToolParts(message2, liveParts) {
   parts.push(...remaining.values());
   return { ...message2, parts };
 }
+var UNOPENED = {
+  chat: null,
+  branchName: "main",
+  headMessageId: void 0
+};
+var OpenChat = class {
+  chat;
+  branch;
+  constructor(chat2, branch) {
+    this.chat = chat2;
+    this.branch = branch;
+  }
+  get branchName() {
+    return this.branch.name;
+  }
+  get headMessageId() {
+    return this.branch.headMessageId ?? void 0;
+  }
+};
 var ContextEngine = class _ContextEngine {
   /** Non-message fragments (role, hints, etc.) - not persisted in graph */
   #fragments = [];
@@ -4109,23 +4097,13 @@ var ContextEngine = class _ContextEngine {
   #store;
   #chatId;
   #userId;
-  #branchName;
-  #branch = null;
-  #chatData = null;
-  #initialized = false;
-  /** Initial metadata to merge on first initialization */
-  #initialMetadata;
+  /** What this engine knows of its chat: nothing until the first store call opens it. */
+  #session = UNOPENED;
+  /** Opens the chat once; concurrent first calls share it, and a failed open runs again. */
+  #open;
   #loaderResolver;
   /** Retained so forked children inherit the parent's resolver chain */
   #resolvers;
-  get #activeBranch() {
-    if (!this.#branch) {
-      throw new Error(
-        "Branch not initialized. Call #ensureInitialized() first."
-      );
-    }
-    return this.#branch;
-  }
   get #renderableFragments() {
     return this.#fragments.filter((f) => !isConditionalReminder(f));
   }
@@ -4139,38 +4117,30 @@ var ContextEngine = class _ContextEngine {
     this.#store = options.store;
     this.#chatId = options.chatId;
     this.#userId = options.userId;
-    this.#branchName = "main";
-    this.#initialMetadata = options.metadata;
+    this.#open = pMemoize2(() => this.#openChat(options.metadata));
     this.#resolvers = options.resolvers;
     this.#loaderResolver = new FragmentLoaderResolver(
       options.resolvers ?? defaultResolvers()
     );
   }
   /**
-   * Initialize the chat and branch if they don't exist.
+   * Creates the chat if it is new, checks its owner, merges the initial
+   * metadata, and reads the active branch.
    */
-  async #ensureInitialized() {
-    if (this.#initialized) {
-      return;
-    }
-    this.#chatData = await this.#store.upsertChat({
+  async #openChat(metadata) {
+    let chat2 = await this.#store.upsertChat({
       id: this.#chatId,
       userId: this.#userId
     });
-    if (this.#chatData.userId !== this.#userId) {
+    if (chat2.userId !== this.#userId) {
       throw new Error(
-        `chat "${this.#chatId}" belongs to user "${this.#chatData.userId}", not "${this.#userId}"`
+        `chat "${this.#chatId}" belongs to user "${chat2.userId}", not "${this.#userId}"`
       );
     }
-    if (this.#initialMetadata) {
-      const initialMetadata = this.#initialMetadata;
-      this.#chatData = await this.#store.updateChat(
-        this.#chatId,
-        ({ metadata }) => ({
-          metadata: { ...metadata, ...initialMetadata }
-        })
-      );
-      this.#initialMetadata = void 0;
+    if (metadata) {
+      chat2 = await this.#store.updateChat(this.#chatId, (stored) => ({
+        metadata: { ...stored.metadata, ...metadata }
+      }));
     }
     const branch = await this.#store.getActiveBranch(this.#chatId);
     if (!branch) {
@@ -4178,20 +4148,21 @@ var ContextEngine = class _ContextEngine {
         `Active branch not found for chat "${this.#chatId}" after upsertChat`
       );
     }
-    this.#branch = branch;
-    this.#branchName = branch.name;
-    this.#initialized = true;
+    const open = new OpenChat(chat2, branch);
+    this.#session = open;
+    return open;
   }
   /**
    * Create a new branch from a specific message.
    * Shared logic between rewind() and btw().
    */
-  async #createBranchFrom(messageId, switchTo) {
+  async #createBranchFrom(open, messageId, switchTo) {
     const branches = await this.#store.listBranches(this.#chatId);
+    const baseName = open.branch.name;
     const samePrefix = branches.filter(
-      (it) => it.name === this.#branchName || it.name.startsWith(`${this.#branchName}-v`)
+      (it) => it.name === baseName || it.name.startsWith(`${baseName}-v`)
     );
-    const newBranchName = `${this.#branchName}-v${samePrefix.length + 1}`;
+    const newBranchName = `${baseName}-v${samePrefix.length + 1}`;
     const newBranch = {
       id: crypto.randomUUID(),
       chatId: this.#chatId,
@@ -4203,8 +4174,7 @@ var ContextEngine = class _ContextEngine {
     await this.#store.createBranch(newBranch);
     if (switchTo) {
       await this.#store.setActiveBranch(this.#chatId, newBranch.id);
-      this.#branch = { ...newBranch, isActive: true };
-      this.#branchName = newBranchName;
+      open.branch = { ...newBranch, isActive: true };
       this.#pendingMessages = [];
     }
     const chain = await this.#store.getMessageChain(messageId);
@@ -4236,47 +4206,40 @@ var ContextEngine = class _ContextEngine {
    * Get the current branch name.
    */
   get branch() {
-    return this.#branchName;
+    return this.#session.branchName;
   }
   /**
    * Get the current branch head message ID.
    * Returns undefined if no messages have been saved yet.
    */
   get headMessageId() {
-    return this.#branch?.headMessageId ?? void 0;
+    return this.#session.headMessageId;
   }
   /**
    * Get metadata for the current chat.
    * Returns null if the chat hasn't been initialized yet.
    */
   get chat() {
-    return this.#chatData;
+    return this.#session.chat;
   }
   /**
    * Count user turns in the conversation and return the previous saved user message context.
    * Includes persisted messages and pending messages in the turn count.
    */
   async #getChainContext(pending = this.#pendingMessages) {
-    await this.#ensureInitialized();
-    const builder = new ChainSummaryBuilder();
-    if (this.#branch?.headMessageId) {
-      const chain = await this.#store.getMessageChain(
-        this.#branch.headMessageId
-      );
-      for (const msg of chain) builder.ingestStored(msg);
-    }
-    for (const fragment2 of pending) builder.ingestPending(fragment2);
-    return builder.build();
+    const open = await this.#open();
+    const stored = open.branch.headMessageId ? await this.#store.getMessageChain(open.branch.headMessageId) : [];
+    return summarizeChain(stored, pending);
   }
   async getTurnCount() {
     const { turn } = await this.#getChainContext();
     return turn;
   }
   async firstUserMessage() {
-    await this.#ensureInitialized();
-    if (this.#branch?.headMessageId) {
+    const open = await this.#open();
+    if (open.branch.headMessageId) {
       const chain = await this.#store.getMessageChain(
-        this.#branch.headMessageId
+        open.branch.headMessageId
       );
       for (const msg of chain) {
         if (msg.name === "user") {
@@ -4305,7 +4268,7 @@ var ContextEngine = class _ContextEngine {
    * @throws if the pending tail is missing an id (programming error).
    */
   async headMessage() {
-    await this.#ensureInitialized();
+    const open = await this.#open();
     if (this.#pendingMessages.length > 0) {
       const tail = this.#pendingMessages[this.#pendingMessages.length - 1];
       if (!tail.id) {
@@ -4315,8 +4278,8 @@ var ContextEngine = class _ContextEngine {
       }
       return { id: tail.id, name: tail.name };
     }
-    if (this.#branch?.headMessageId) {
-      const msg = await this.#store.getMessage(this.#branch.headMessageId);
+    if (open.branch.headMessageId) {
+      const msg = await this.#store.getMessage(open.branch.headMessageId);
       if (msg) return { id: msg.id, name: msg.name };
     }
     return void 0;
@@ -4336,12 +4299,12 @@ var ContextEngine = class _ContextEngine {
    * For id-lookup use `headMessage()` instead — that one keeps placeholders.
    */
   async getMessages() {
-    await this.#ensureInitialized();
+    const open = await this.#open();
     const messages = [];
     const indexById = /* @__PURE__ */ new Map();
-    if (this.#branch?.headMessageId) {
+    if (open.branch.headMessageId) {
       const chain = await this.#store.getMessageChain(
-        this.#branch.headMessageId
+        open.branch.headMessageId
       );
       for (const msg of chain) {
         const data = requireUIMessage(msg.data, `Stored message "${msg.id}"`);
@@ -4452,7 +4415,7 @@ var ContextEngine = class _ContextEngine {
    * ```
    */
   async resolve(options) {
-    await this.#ensureInitialized();
+    await this.#open();
     await this.#loaderResolver.resolve(this.#fragments, {
       sandbox: options.sandbox,
       context: this,
@@ -4477,15 +4440,19 @@ var ContextEngine = class _ContextEngine {
    * ```
    */
   async save(options) {
-    await this.#ensureInitialized();
+    const open = await this.#open();
     if (this.#pendingMessages.length === 0) {
-      return { headMessageId: this.#branch?.headMessageId ?? void 0 };
+      return { headMessageId: open.branch.headMessageId ?? void 0 };
     }
     const pending = this.#pendingMessages;
     this.#pendingMessages = [];
-    const pipeline = new SavePipeline(this.#asSavePipelineEngine(), pending);
+    const pipeline = new SavePipeline(
+      this.#asSavePipelineEngine(open),
+      pending,
+      options?.branch ?? true
+    );
     try {
-      await pipeline.applyUpdateBranching(options?.branch ?? true);
+      await pipeline.applyUpdateBranching();
       await this.#foldUserReminders(pending);
       return await pipeline.persist();
     } catch (error) {
@@ -4726,13 +4693,14 @@ var ContextEngine = class _ContextEngine {
     return this.#fragments.filter(isConditionalReminder).map((fragment2) => fragment2.metadata.reminder).filter((config) => config.target === target);
   }
   #buildBaseWhenCtx(chain) {
-    const rawUsage = this.#chatData?.metadata?.usage;
-    const usage = isLanguageModelUsage(rawUsage) ? rawUsage : void 0;
-    const elapsed = chain.lastMessageAt !== void 0 ? Date.now() - chain.lastMessageAt : void 0;
-    const chatData = this.#chatData;
-    if (!chatData) {
+    const session = this.#session;
+    if (!(session instanceof OpenChat)) {
       throw new Error("ContextEngine must be initialized before reminders run");
     }
+    const chatData = session.chat;
+    const rawUsage = chatData.metadata?.usage;
+    const usage = isLanguageModelUsage(rawUsage) ? rawUsage : void 0;
+    const elapsed = chain.lastMessageAt !== void 0 ? Date.now() - chain.lastMessageAt : void 0;
     return {
       turn: chain.turn,
       messageCount: chain.messageCount,
@@ -4740,7 +4708,7 @@ var ContextEngine = class _ContextEngine {
       lastMessage: chain.lastMessage,
       chat: chatData,
       usage,
-      branch: this.#branchName,
+      branch: session.branchName,
       elapsed
     };
   }
@@ -4861,36 +4829,36 @@ var ContextEngine = class _ContextEngine {
     }
     return { texts, onceIds: [...onceIds] };
   }
-  #asSavePipelineEngine() {
+  #asSavePipelineEngine(open) {
     return {
       store: this.#store,
       chatId: this.#chatId,
       getActiveBranch: () => ({
-        id: this.#activeBranch.id,
-        headMessageId: this.#activeBranch.headMessageId
+        id: open.branch.id,
+        headMessageId: open.branch.headMessageId
       }),
       commitHead: async (headMessageId, expectedHeadMessageId) => {
         const committed = await this.#store.updateBranchHead(
-          this.#activeBranch.id,
+          open.branch.id,
           headMessageId,
           expectedHeadMessageId
         );
         if (committed) {
-          this.#activeBranch.headMessageId = headMessageId;
+          open.branch.headMessageId = headMessageId;
         }
         return committed;
       },
       refreshBranch: async () => {
         const fresh = await this.#store.getBranch(
           this.#chatId,
-          this.#activeBranch.name
+          open.branch.name
         );
         if (!fresh) {
           throw new Error(
-            `Branch "${this.#activeBranch.name}" not found for chat "${this.#chatId}"`
+            `Branch "${open.branch.name}" not found for chat "${this.#chatId}"`
           );
         }
-        this.#branch = fresh;
+        open.branch = fresh;
         return { id: fresh.id, headMessageId: fresh.headMessageId };
       },
       rewindForUpdate: (parentId) => this.#rewindForUpdate(parentId)
@@ -4909,7 +4877,7 @@ var ContextEngine = class _ContextEngine {
    * @returns Estimate result with token counts, costs, and per-fragment breakdown
    */
   async estimate(modelId, options = {}) {
-    await this.#ensureInitialized();
+    const open = await this.#open();
     await this.#loaderResolver.resolve(this.#fragments, {
       sandbox: options.sandbox,
       context: this,
@@ -4938,9 +4906,9 @@ var ContextEngine = class _ContextEngine {
         cost
       });
     }
-    if (this.#branch?.headMessageId) {
+    if (open.branch.headMessageId) {
       const chain = await this.#store.getMessageChain(
-        this.#branch.headMessageId
+        open.branch.headMessageId
       );
       for (const msg of chain) {
         const content = estimateMessageContent(msg.data);
@@ -5012,7 +4980,7 @@ var ContextEngine = class _ContextEngine {
    * ```
    */
   async rewind(messageId) {
-    await this.#ensureInitialized();
+    const open = await this.#open();
     const message2 = await this.#store.getMessage(messageId);
     if (!message2) {
       throw new Error(`Message "${messageId}" not found`);
@@ -5020,7 +4988,7 @@ var ContextEngine = class _ContextEngine {
     if (message2.chatId !== this.#chatId) {
       throw new Error(`Message "${messageId}" belongs to a different chat`);
     }
-    return this.#createBranchFrom(messageId, true);
+    return this.#createBranchFrom(open, messageId, true);
   }
   /**
    * Create a checkpoint at the current position.
@@ -5042,15 +5010,15 @@ var ContextEngine = class _ContextEngine {
    * ```
    */
   async checkpoint(name) {
-    await this.#ensureInitialized();
-    if (!this.#branch?.headMessageId) {
+    const open = await this.#open();
+    if (!open.branch.headMessageId) {
       throw new Error("Cannot create checkpoint: no messages in conversation");
     }
     const checkpoint = {
       id: crypto.randomUUID(),
       chatId: this.#chatId,
       name,
-      messageId: this.#branch.headMessageId,
+      messageId: open.branch.headMessageId,
       createdAt: Date.now()
     };
     await this.#store.createCheckpoint(checkpoint);
@@ -5078,7 +5046,7 @@ var ContextEngine = class _ContextEngine {
    * ```
    */
   async restore(name) {
-    await this.#ensureInitialized();
+    await this.#open();
     const checkpoint = await this.#store.getCheckpoint(this.#chatId, name);
     if (!checkpoint) {
       throw new Error(
@@ -5103,14 +5071,13 @@ var ContextEngine = class _ContextEngine {
    * ```
    */
   async switchBranch(name) {
-    await this.#ensureInitialized();
+    const open = await this.#open();
     const branch = await this.#store.getBranch(this.#chatId, name);
     if (!branch) {
       throw new Error(`Branch "${name}" not found in chat "${this.#chatId}"`);
     }
     await this.#store.setActiveBranch(this.#chatId, branch.id);
-    this.#branch = { ...branch, isActive: true };
-    this.#branchName = name;
+    open.branch = { ...branch, isActive: true };
     this.#pendingMessages = [];
   }
   /**
@@ -5145,11 +5112,11 @@ var ContextEngine = class _ContextEngine {
    * ```
    */
   async btw() {
-    await this.#ensureInitialized();
-    if (!this.#branch?.headMessageId) {
+    const open = await this.#open();
+    if (!open.branch.headMessageId) {
       throw new Error("Cannot create btw branch: no messages in conversation");
     }
-    return this.#createBranchFrom(this.#branch.headMessageId, false);
+    return this.#createBranchFrom(open, open.branch.headMessageId, false);
   }
   /**
    * Update metadata for the current chat.
@@ -5165,14 +5132,11 @@ var ContextEngine = class _ContextEngine {
    * ```
    */
   async updateChat(updates) {
-    await this.#ensureInitialized();
-    this.#chatData = await this.#store.updateChat(
-      this.#chatId,
-      ({ metadata }) => ({
-        title: updates.title,
-        metadata: updates.metadata === void 0 ? void 0 : { ...metadata, ...updates.metadata }
-      })
-    );
+    const open = await this.#open();
+    open.chat = await this.#store.updateChat(this.#chatId, ({ metadata }) => ({
+      title: updates.title,
+      metadata: updates.metadata === void 0 ? void 0 : { ...metadata, ...updates.metadata }
+    }));
   }
   /**
    * Track token usage for the current chat.
@@ -5188,20 +5152,17 @@ var ContextEngine = class _ContextEngine {
    * ```
    */
   async trackUsage(usage) {
-    await this.#ensureInitialized();
-    this.#chatData = await this.#store.updateChat(
-      this.#chatId,
-      ({ metadata }) => {
-        const storedUsage = metadata?.usage;
-        const currentUsage = isLanguageModelUsage(storedUsage) ? storedUsage : void 0;
-        return {
-          metadata: {
-            ...metadata,
-            usage: mergeLanguageModelUsage(currentUsage, usage)
-          }
-        };
-      }
-    );
+    const open = await this.#open();
+    open.chat = await this.#store.updateChat(this.#chatId, ({ metadata }) => {
+      const storedUsage = metadata?.usage;
+      const currentUsage = isLanguageModelUsage(storedUsage) ? storedUsage : void 0;
+      return {
+        metadata: {
+          ...metadata,
+          usage: mergeLanguageModelUsage(currentUsage, usage)
+        }
+      };
+    });
   }
   /**
    * Consolidate context fragments (no-op for now).
@@ -5267,7 +5228,7 @@ var ContextEngine = class _ContextEngine {
    * ```
    */
   async inspect(options) {
-    await this.#ensureInitialized();
+    const open = await this.#open();
     const { renderer } = options;
     const estimateResult = await this.estimate(options.modelId, {
       renderer,
@@ -5276,9 +5237,9 @@ var ContextEngine = class _ContextEngine {
     });
     const rendered = renderer.render(this.#renderableFragments);
     const persistedMessages = [];
-    if (this.#branch?.headMessageId) {
+    if (open.branch.headMessageId) {
       const chain = await this.#store.getMessageChain(
-        this.#branch.headMessageId
+        open.branch.headMessageId
       );
       persistedMessages.push(...chain);
     }
@@ -5294,7 +5255,7 @@ var ContextEngine = class _ContextEngine {
       graph,
       meta: {
         chatId: this.#chatId,
-        branch: this.#branchName,
+        branch: open.branch.name,
         timestamp: Date.now()
       }
     };
@@ -10740,7 +10701,7 @@ async function assertMicrosandboxBash(vm) {
 function normalizeMicrosandboxError(error, sdk) {
   const err = toError2(error);
   if (err instanceof MicrosandboxSandboxError) return err;
-  if (err instanceof sdk.LibkrunfwNotFoundError) {
+  if (err instanceof sdk.LibkrunfwNotFoundError || err instanceof sdk.RuntimeNotInstalledError || err instanceof sdk.RuntimeIncompleteError) {
     return new MicrosandboxNotAvailableError(err);
   }
   if (err instanceof sdk.MicrosandboxError) {
@@ -11244,6 +11205,16 @@ function soul() {
   return fragment("soul_protocol", ...children);
 }
 
+// packages/context/src/lib/store/postgres-schema-lock.ts
+function lockSchemaDDL(ddl, schema) {
+  if (schema !== void 0 && !/^[a-zA-Z_]\w*$/.test(schema)) {
+    throw new Error(`Invalid schema name: "${schema}"`);
+  }
+  const key = schema === void 0 ? `coalesce(current_schema(), '')` : `'${schema}'`;
+  return `SELECT pg_advisory_xact_lock(hashtextextended('deepagents:schema-ddl:' || ${key}, 0));
+${ddl}`;
+}
+
 // packages/context/src/lib/store/postgres.store.ts
 import { createRequire } from "node:module";
 import { z as z14 } from "zod";
@@ -11458,7 +11429,6 @@ var PostgresContextStore = class _PostgresContextStore extends ContextStore {
   #pool;
   #schema;
   #ownsPool;
-  #isInitialized = false;
   constructor(options) {
     super();
     const schema = options.schema ?? "public";
@@ -11488,24 +11458,25 @@ var PostgresContextStore = class _PostgresContextStore extends ContextStore {
   #t(name) {
     return `"${this.#schema}"."${name}"`;
   }
-  async initialize() {
-    const ddl = storeDDL(this.#schema);
-    await this.#pool.query(ddl);
-    this.#isInitialized = true;
-  }
-  #ensureInitialized() {
-    if (!this.#isInitialized) {
-      throw new Error(
-        "PostgresContextStore not initialized. Call await store.initialize() after construction."
-      );
+  /** Opens the store: creates its schema objects before it returns. */
+  static async create(options) {
+    const store = new _PostgresContextStore(options);
+    try {
+      await store.#initialize();
+    } catch (error) {
+      await store.close();
+      throw error;
     }
+    return store;
+  }
+  async #initialize() {
+    await this.#pool.query(lockSchemaDDL(storeDDL(this.#schema), this.#schema));
   }
   /**
    * Execute a function within a transaction.
    * Automatically commits on success or rolls back on error.
    */
   async #useTransaction(fn) {
-    this.#ensureInitialized();
     const client = await this.#pool.connect();
     try {
       await client.query("BEGIN");
@@ -11523,7 +11494,6 @@ var PostgresContextStore = class _PostgresContextStore extends ContextStore {
    * Execute a query using the pool (no transaction).
    */
   async #query(sql, params) {
-    this.#ensureInitialized();
     const result = await this.#pool.query(sql, params);
     return result.rows;
   }
@@ -12072,6 +12042,11 @@ IF NOT EXISTS (SELECT * FROM sys.indexes WHERE name = 'idx_${schema}_branches_ch
 IF NOT EXISTS (SELECT * FROM sys.indexes WHERE name = 'idx_${schema}_branches_chatId_isActive' AND object_id = OBJECT_ID('[${schema}].[branches]'))
   CREATE INDEX [idx_${schema}_branches_chatId_isActive] ON [${schema}].[branches](chatId, isActive);
 
+-- Deleting a message checks this foreign key. Without the index the check
+-- scans every chat's branches and waits on rows another chat delete holds.
+IF NOT EXISTS (SELECT * FROM sys.indexes WHERE name = 'idx_${schema}_branches_headMessageId' AND object_id = OBJECT_ID('[${schema}].[branches]'))
+  CREATE INDEX [idx_${schema}_branches_headMessageId] ON [${schema}].[branches](headMessageId);
+
 IF OBJECT_ID('[${schema}].[checkpoints]', 'U') IS NULL
 BEGIN
   CREATE TABLE [${schema}].[checkpoints] (
@@ -12122,6 +12097,38 @@ END;
 `;
 }
 
+// packages/context/src/lib/store/sqlserver-schema-lock.ts
+async function withSqlServerSchemaLock(mssql, pool, schema, run) {
+  const holder = new mssql.Transaction(pool);
+  await holder.begin();
+  let result;
+  try {
+    const lock = new mssql.Request(holder);
+    lock.input(
+      "resource",
+      mssql.NVarChar(255),
+      `deepagents:schema-ddl:${schema}`
+    );
+    const { recordset } = await lock.query(`
+      DECLARE @status int;
+      EXEC @status = sp_getapplock @Resource = @resource, @LockMode = 'Exclusive', @LockOwner = 'Transaction', @LockTimeout = -1;
+      SELECT @status AS status;
+    `);
+    if (recordset[0].status < 0) {
+      throw new Error(
+        `Could not lock the DDL of schema "${schema}": sp_getapplock returned ${recordset[0].status}.`
+      );
+    }
+    result = await run();
+  } catch (error) {
+    await holder.rollback().catch(() => {
+    });
+    throw error;
+  }
+  await holder.rollback();
+  return result;
+}
+
 // packages/context/src/lib/store/sqlserver.store.ts
 var chatColumns3 = z15.object({
   id: z15.string(),
@@ -12225,7 +12232,6 @@ var SqlServerContextStore = class _SqlServerContextStore extends ContextStore {
   #pool;
   #schema;
   #ownsPool;
-  #isInitialized = false;
   constructor(options) {
     super();
     const schema = options.schema ?? "dbo";
@@ -12255,50 +12261,59 @@ var SqlServerContextStore = class _SqlServerContextStore extends ContextStore {
   #t(name) {
     return `[${this.#schema}].[${name}]`;
   }
-  async initialize() {
+  /** Opens the store: connects a pool it owns and creates its schema objects before it returns. */
+  static async create(options) {
+    const store = new _SqlServerContextStore(options);
+    try {
+      await store.#initialize();
+    } catch (error) {
+      await store.close();
+      throw error;
+    }
+    return store;
+  }
+  async #initialize() {
     if (this.#ownsPool) {
       await this.#pool.connect();
     }
-    const schemaReq = this.#pool.request();
-    schemaReq.input("schema", this.#schema);
-    await schemaReq.query(`
-      IF NOT EXISTS (SELECT * FROM sys.schemas WHERE name = @schema)
-      BEGIN
-        DECLARE @sql NVARCHAR(MAX) = N'CREATE SCHEMA ' + QUOTENAME(@schema);
-        EXEC sp_executesql @sql;
-      END
-    `);
-    const ddl = storeDDL2(this.#schema);
-    const batches = ddl.split(/\bGO\b/i).filter((b) => b.trim());
-    for (const batch of batches) {
-      if (batch.trim()) {
-        await this.#pool.request().batch(batch);
+    await withSqlServerSchemaLock(
+      _SqlServerContextStore.#requireMssql(),
+      this.#pool,
+      this.#schema,
+      async () => {
+        const schemaReq = this.#pool.request();
+        schemaReq.input("schema", this.#schema);
+        await schemaReq.query(`
+          IF NOT EXISTS (SELECT * FROM sys.schemas WHERE name = @schema)
+          BEGIN
+            DECLARE @sql NVARCHAR(MAX) = N'CREATE SCHEMA ' + QUOTENAME(@schema);
+            EXEC sp_executesql @sql;
+          END
+        `);
+        const ddl = storeDDL2(this.#schema);
+        const batches = ddl.split(/\bGO\b/i).filter((b) => b.trim());
+        for (const batch of batches) {
+          if (batch.trim()) {
+            await this.#pool.request().batch(batch);
+          }
+        }
       }
-    }
-    this.#isInitialized = true;
-  }
-  #ensureInitialized() {
-    if (!this.#isInitialized) {
-      throw new Error(
-        "SqlServerContextStore not initialized. Call await store.initialize() after construction."
-      );
-    }
+    );
   }
   /**
    * Execute a function within a transaction.
    * Automatically commits on success or rolls back on error.
    */
   async #useTransaction(fn) {
-    this.#ensureInitialized();
     const mssql = _SqlServerContextStore.#requireMssql();
-    const transaction = new mssql.Transaction(this.#pool);
+    const transaction3 = new mssql.Transaction(this.#pool);
     try {
-      await transaction.begin();
-      const result = await fn(transaction);
-      await transaction.commit();
+      await transaction3.begin();
+      const result = await fn(transaction3);
+      await transaction3.commit();
       return result;
     } catch (error) {
-      await transaction.rollback();
+      await transaction3.rollback();
       throw error;
     }
   }
@@ -12307,7 +12322,6 @@ var SqlServerContextStore = class _SqlServerContextStore extends ContextStore {
    * Converts positional params to SQL Server named params (@p0, @p1, ...).
    */
   async #query(sql, params) {
-    this.#ensureInitialized();
     const request = this.#pool.request();
     params?.forEach((value, index) => {
       request.input(`p${index}`, value);
@@ -12334,9 +12348,9 @@ var SqlServerContextStore = class _SqlServerContextStore extends ContextStore {
   // Chat Operations
   // ==========================================================================
   async createChat(chat2) {
-    return this.#useTransaction(async (transaction) => {
+    return this.#useTransaction(async (transaction3) => {
       const mssql = _SqlServerContextStore.#requireMssql();
-      const request = transaction.request();
+      const request = transaction3.request();
       request.input("p0", mssql.NVarChar, chat2.id);
       request.input("p1", mssql.NVarChar, chat2.userId);
       request.input("p2", mssql.NVarChar, chat2.title ?? null);
@@ -12351,7 +12365,7 @@ var SqlServerContextStore = class _SqlServerContextStore extends ContextStore {
         VALUES (@p0, @p1, @p2, @p3)
       `);
       const created = storedChat3.parse(result.recordset[0]);
-      const branchRequest = transaction.request();
+      const branchRequest = transaction3.request();
       branchRequest.input("p0", mssql.NVarChar, crypto.randomUUID());
       branchRequest.input("p1", mssql.NVarChar, chat2.id);
       branchRequest.input("p2", mssql.BigInt, Date.now());
@@ -12363,9 +12377,9 @@ var SqlServerContextStore = class _SqlServerContextStore extends ContextStore {
     });
   }
   async upsertChat(chat2) {
-    return this.#useTransaction(async (transaction) => {
+    return this.#useTransaction(async (transaction3) => {
       const mssql = _SqlServerContextStore.#requireMssql();
-      const request = transaction.request();
+      const request = transaction3.request();
       request.input("p0", mssql.NVarChar, chat2.id);
       request.input("p1", mssql.NVarChar, chat2.userId);
       request.input("p2", mssql.NVarChar, chat2.title ?? null);
@@ -12387,7 +12401,7 @@ var SqlServerContextStore = class _SqlServerContextStore extends ContextStore {
         OUTPUT INSERTED.*;
       `);
       const upserted = storedChat3.parse(result.recordset[0]);
-      const branchRequest = transaction.request();
+      const branchRequest = transaction3.request();
       branchRequest.input("p0", mssql.NVarChar, crypto.randomUUID());
       branchRequest.input("p1", mssql.NVarChar, chat2.id);
       branchRequest.input("p2", mssql.BigInt, Date.now());
@@ -12410,9 +12424,9 @@ var SqlServerContextStore = class _SqlServerContextStore extends ContextStore {
     return chat2;
   }
   async updateChat(chatId, update) {
-    return this.#useTransaction(async (transaction) => {
+    return this.#useTransaction(async (transaction3) => {
       const mssql = _SqlServerContextStore.#requireMssql();
-      const read = transaction.request();
+      const read = transaction3.request();
       read.input("chatId", mssql.NVarChar, chatId);
       const result = await read.query(`
         SELECT *
@@ -12429,7 +12443,7 @@ var SqlServerContextStore = class _SqlServerContextStore extends ContextStore {
         "updatedAt = DATEDIFF_BIG(ms, '1970-01-01', GETUTCDATE())"
       ];
       let paramIndex = 0;
-      const write = transaction.request();
+      const write = transaction3.request();
       if (updates.title !== void 0) {
         const name = `p${paramIndex++}`;
         setClauses.push(`title = @${name}`);
@@ -12494,9 +12508,9 @@ var SqlServerContextStore = class _SqlServerContextStore extends ContextStore {
     );
   }
   async deleteChat(chatId, options) {
-    return this.#useTransaction(async (transaction) => {
+    return this.#useTransaction(async (transaction3) => {
       const mssql = _SqlServerContextStore.#requireMssql();
-      const request = transaction.request();
+      const request = transaction3.request();
       request.input("p0", mssql.NVarChar, chatId);
       let sql = `DELETE FROM ${this.#t("chats")} WHERE id = @p0`;
       if (options?.userId !== void 0) {
@@ -12514,9 +12528,9 @@ var SqlServerContextStore = class _SqlServerContextStore extends ContextStore {
     if (message2.parentId === message2.id) {
       throw new Error(`Message ${message2.id} cannot be its own parent`);
     }
-    await this.#useTransaction(async (transaction) => {
+    await this.#useTransaction(async (transaction3) => {
       const mssql = _SqlServerContextStore.#requireMssql();
-      const request = transaction.request();
+      const request = transaction3.request();
       request.input("p0", mssql.NVarChar, message2.id);
       request.input("p1", mssql.NVarChar, message2.chatId);
       request.input("p2", mssql.NVarChar, message2.parentId);
@@ -12535,7 +12549,7 @@ var SqlServerContextStore = class _SqlServerContextStore extends ContextStore {
           VALUES (@p0, @p1, @p2, @p3, @p4, @p5, @p6);
       `);
       const content = typeof message2.data === "string" ? message2.data : JSON.stringify(message2.data);
-      const ftsRequest = transaction.request();
+      const ftsRequest = transaction3.request();
       ftsRequest.input("p0", mssql.NVarChar, message2.id);
       ftsRequest.input("p1", mssql.NVarChar, message2.chatId);
       ftsRequest.input("p2", mssql.NVarChar, message2.name);
@@ -12643,14 +12657,14 @@ var SqlServerContextStore = class _SqlServerContextStore extends ContextStore {
     return branch;
   }
   async setActiveBranch(chatId, branchId) {
-    await this.#useTransaction(async (transaction) => {
+    await this.#useTransaction(async (transaction3) => {
       const mssql = _SqlServerContextStore.#requireMssql();
-      const deactivateRequest = transaction.request();
+      const deactivateRequest = transaction3.request();
       deactivateRequest.input("p0", mssql.NVarChar, chatId);
       await deactivateRequest.query(
         `UPDATE ${this.#t("branches")} SET isActive = 0 WHERE chatId = @p0`
       );
-      const activateRequest = transaction.request();
+      const activateRequest = transaction3.request();
       activateRequest.input("p0", mssql.NVarChar, branchId);
       await activateRequest.query(
         `UPDATE ${this.#t("branches")} SET isActive = 1 WHERE id = @p0`
@@ -12713,9 +12727,9 @@ var SqlServerContextStore = class _SqlServerContextStore extends ContextStore {
   // Checkpoint Operations
   // ==========================================================================
   async createCheckpoint(checkpoint) {
-    await this.#useTransaction(async (transaction) => {
+    await this.#useTransaction(async (transaction3) => {
       const mssql = _SqlServerContextStore.#requireMssql();
-      const request = transaction.request();
+      const request = transaction3.request();
       request.input("p0", mssql.NVarChar, checkpoint.id);
       request.input("p1", mssql.NVarChar, checkpoint.chatId);
       request.input("p2", mssql.NVarChar, checkpoint.name);
@@ -13159,7 +13173,9 @@ function staticPartText(part, options) {
 }
 
 // packages/context/src/lib/stream/postgres-notify-change-source.ts
+import { EventEmitter, on } from "node:events";
 import { createRequire as createRequire3 } from "node:module";
+import pMemoize3 from "p-memoize";
 import { z as z16 } from "zod";
 
 // packages/context/src/lib/stream/ddl.stream.postgres-notify.ts
@@ -13220,28 +13236,73 @@ EXECUTE FUNCTION "${schema}"."notify_stream_status_update"();
 }
 
 // packages/context/src/lib/stream/postgres-notify-change-source.ts
+var NOT_LISTENING = {
+  release: () => Promise.resolve(),
+  fail: () => {
+  }
+};
+var Listening = class {
+  #client;
+  #handlers;
+  constructor(client, handlers) {
+    this.#client = client;
+    this.#handlers = handlers;
+    client.on("notification", handlers.notification);
+    client.on("error", handlers.error);
+    client.on("end", handlers.end);
+  }
+  /** Stops listening and returns the connection to the pool. */
+  async release(channel) {
+    this.#detach();
+    try {
+      await this.#client.query(`UNLISTEN ${quoteIdentifier(channel)}`);
+    } finally {
+      this.#client.release();
+    }
+  }
+  /** Gives a broken connection back for the pool to destroy. */
+  fail(error) {
+    this.#detach();
+    this.#client.release(error);
+  }
+  #detach() {
+    this.#client.off("notification", this.#handlers.notification);
+    this.#client.off("error", this.#handlers.error);
+    this.#client.off("end", this.#handlers.end);
+  }
+};
+var ChangeDelivery = class {
+  change;
+  constructor(change) {
+    this.change = change;
+  }
+};
 var PostgresNotifyChangeSource = class _PostgresNotifyChangeSource {
   #pool;
   #schema;
   #channel;
   #ownsPool;
-  #listener;
-  #listenPromise;
-  #isInitialized = false;
-  #isClosing = false;
-  #isClosed = false;
-  #subscribers = /* @__PURE__ */ new Map();
-  #onNotification = (message2) => {
-    this.#handleNotification(message2);
-  };
-  #onListenerError = (error) => {
-    this.#failListener(error);
-  };
-  #onListenerEnd = () => {
-    if (!this.#isClosing) {
-      this.#failListener(
-        new Error("PostgreSQL stream notification listener ended")
-      );
+  /** Aborts when close() starts: every subscription ends, and no LISTEN connection opens. */
+  #closed = new AbortController();
+  /** Emits `stream:<id>` with a ChangeDelivery; `error` fails every subscription. */
+  #changes = new EventEmitter().setMaxListeners(0);
+  #subscriptions = 0;
+  #listener = NOT_LISTENING;
+  /** Concurrent subscribers share one LISTEN setup; a failed one runs again. */
+  #listen = pMemoize3(() => this.#openListener(), { cache: false });
+  #handlers = {
+    notification: (message2) => {
+      this.#handleNotification(message2);
+    },
+    error: (error) => {
+      this.#failListener(error);
+    },
+    end: () => {
+      if (!this.#closed.signal.aborted) {
+        this.#failListener(
+          new Error("PostgreSQL stream notification listener ended")
+        );
+      }
     }
   };
   constructor(options) {
@@ -13270,98 +13331,78 @@ var PostgresNotifyChangeSource = class _PostgresNotifyChangeSource {
       );
     }
   }
-  async initialize() {
-    await this.#pool.query(
-      postgresStreamNotifyDDL(this.#schema, this.#channel)
-    );
-    this.#isInitialized = true;
+  /** Opens the source: installs the notify triggers before it returns. */
+  static async create(options) {
+    const source = new _PostgresNotifyChangeSource(options);
+    try {
+      await source.#pool.query(
+        lockSchemaDDL(
+          postgresStreamNotifyDDL(source.#schema, source.#channel),
+          source.#schema
+        )
+      );
+    } catch (error) {
+      await source.close();
+      throw error;
+    }
+    return source;
   }
   async *subscribe(streamId, signal) {
-    this.#ensureInitialized();
-    this.#ensureOpen();
-    const queue = new ChangeQueue();
-    this.#addSubscriber(streamId, queue);
-    const cleanup = () => {
-      queue.close();
-      this.#removeSubscriber(streamId, queue);
-    };
-    signal.addEventListener("abort", cleanup, { once: true });
+    if (this.#closed.signal.aborted) {
+      throw new Error("PostgresNotifyChangeSource is closed.");
+    }
+    if (signal.aborted) return;
+    const changes = on(this.#changes, `stream:${streamId}`, {
+      signal: AbortSignal.any([signal, this.#closed.signal])
+    });
+    this.#subscriptions += 1;
     try {
       await this.#ensureListening();
-      if (signal.aborted || this.#isClosed) return;
+      if (signal.aborted || this.#closed.signal.aborted) return;
       yield { kind: "tick" };
-      while (!signal.aborted && !this.#isClosed) {
-        const change = await queue.next(signal);
-        if (!change) return;
-        yield change;
+      for await (const [delivery] of changes) {
+        if (delivery instanceof ChangeDelivery) yield delivery.change;
       }
+    } catch (error) {
+      if (error instanceof Error && error.name === "AbortError") return;
+      throw error;
     } finally {
-      signal.removeEventListener("abort", cleanup);
-      cleanup();
+      this.#subscriptions -= 1;
+      await changes.return?.();
       await this.#releaseListenerIfIdle();
     }
   }
   async close() {
-    if (this.#isClosed) return;
-    this.#isClosed = true;
-    this.#isClosing = true;
-    for (const subscribers of this.#subscribers.values()) {
-      for (const subscriber of subscribers) {
-        subscriber.close();
-      }
-    }
-    this.#subscribers.clear();
-    if (this.#listenPromise) {
-      try {
-        await this.#listenPromise;
-      } catch {
-      }
+    if (this.#closed.signal.aborted) return;
+    this.#closed.abort();
+    try {
+      await this.#listen();
+    } catch {
     }
     await this.#releaseListener();
     if (this.#ownsPool) {
       await this.#pool.end();
     }
   }
-  #ensureInitialized() {
-    if (!this.#isInitialized) {
-      throw new Error(
-        "PostgresNotifyChangeSource not initialized. Call await source.initialize() after construction."
-      );
-    }
+  async #ensureListening() {
+    if (this.#listener instanceof Listening) return;
+    await this.#listen();
   }
-  #ensureOpen() {
-    if (this.#isClosed) {
-      throw new Error("PostgresNotifyChangeSource is closed.");
+  async #openListener() {
+    if (this.#closed.signal.aborted) return;
+    const client = await this.#pool.connect();
+    const listening = new Listening(client, this.#handlers);
+    try {
+      await client.query(`LISTEN ${quoteIdentifier(this.#channel)}`);
+    } catch (error) {
+      listening.fail(true);
+      throw error;
     }
-  }
-  async #ensureListening() {
-    this.#ensureOpen();
-    if (this.#listener) return;
-    if (this.#listenPromise) return this.#listenPromise;
-    this.#listenPromise = (async () => {
-      const listener = await this.#pool.connect();
-      let success = false;
-      try {
-        listener.on("notification", this.#onNotification);
-        listener.on("error", this.#onListenerError);
-        listener.on("end", this.#onListenerEnd);
-        await listener.query(`LISTEN ${quoteIdentifier(this.#channel)}`);
-        if (this.#isClosed) {
-          return;
-        }
-        this.#listener = listener;
-        success = true;
-      } finally {
-        this.#listenPromise = void 0;
-        if (!success) {
-          listener.off("notification", this.#onNotification);
-          listener.off("error", this.#onListenerError);
-          listener.off("end", this.#onListenerEnd);
-          listener.release(true);
-        }
-      }
-    })();
-    return this.#listenPromise;
+    if (this.#closed.signal.aborted) {
+      listening.fail(true);
+      return;
+    }
+    this.#listener = listening;
   }
   #handleNotification(message2) {
     if (message2.channel !== this.#channel || !message2.payload) return;
@@ -13369,125 +13410,28 @@ var PostgresNotifyChangeSource = class _PostgresNotifyChangeSource {
     if (!payload) return;
     if (payload.schema !== this.#schema) return;
     if (payload.kind !== "chunks" && payload.kind !== "status") return;
-    const subscribers = this.#subscribers.get(payload.streamId);
-    if (!subscribers) return;
     const change = payload.kind === "chunks" ? { kind: "chunks" } : { kind: "status" };
-    for (const subscriber of subscribers) {
-      subscriber.push(change);
-    }
+    this.#changes.emit(
+      `stream:${payload.streamId}`,
+      new ChangeDelivery(change)
+    );
   }
   #failListener(error) {
     const listener = this.#listener;
-    this.#listener = void 0;
-    this.#listenPromise = void 0;
-    if (listener) {
-      listener.off("notification", this.#onNotification);
-      listener.off("error", this.#onListenerError);
-      listener.off("end", this.#onListenerEnd);
-      listener.release(error);
-    }
-    for (const subscribers of this.#subscribers.values()) {
-      for (const subscriber of subscribers) {
-        subscriber.fail(error);
-      }
+    this.#listener = NOT_LISTENING;
+    listener.fail(error);
+    if (this.#changes.listenerCount("error") > 0) {
+      this.#changes.emit("error", error);
     }
-    this.#subscribers.clear();
   }
   async #releaseListenerIfIdle() {
-    if (this.#subscribers.size > 0) return;
+    if (this.#subscriptions > 0) return;
     await this.#releaseListener();
   }
   async #releaseListener() {
     const listener = this.#listener;
-    if (!listener) return;
-    this.#listener = void 0;
-    listener.off("notification", this.#onNotification);
-    listener.off("error", this.#onListenerError);
-    listener.off("end", this.#onListenerEnd);
-    try {
-      await listener.query(`UNLISTEN ${quoteIdentifier(this.#channel)}`);
-    } finally {
-      listener.release();
-    }
-  }
-  #addSubscriber(streamId, subscriber) {
-    let subscribers = this.#subscribers.get(streamId);
-    if (!subscribers) {
-      subscribers = /* @__PURE__ */ new Set();
-      this.#subscribers.set(streamId, subscribers);
-    }
-    subscribers.add(subscriber);
-  }
-  #removeSubscriber(streamId, subscriber) {
-    const subscribers = this.#subscribers.get(streamId);
-    if (!subscribers) return;
-    subscribers.delete(subscriber);
-    if (subscribers.size === 0) {
-      this.#subscribers.delete(streamId);
-    }
-  }
-};
-var ChangeQueue = class {
-  #values = [];
-  #waiters = /* @__PURE__ */ new Set();
-  #closed = false;
-  #error;
-  push(value) {
-    if (this.#closed) return;
-    const waiter = this.#waiters.values().next().value;
-    if (waiter) {
-      this.#waiters.delete(waiter);
-      waiter.resolve(value);
-      return;
-    }
-    this.#values.push(value);
-  }
-  fail(error) {
-    if (this.#closed) return;
-    this.#closed = true;
-    this.#error = error;
-    this.#values = [];
-    for (const waiter of this.#waiters) {
-      waiter.reject(error);
-    }
-    this.#waiters.clear();
-  }
-  close() {
-    if (this.#closed) return;
-    this.#closed = true;
-    this.#values = [];
-    for (const waiter of this.#waiters) {
-      waiter.resolve(void 0);
-    }
-    this.#waiters.clear();
-  }
-  async next(signal) {
-    if (this.#error) throw this.#error;
-    if (this.#closed || signal.aborted) return void 0;
-    if (this.#values.length > 0) {
-      return this.#values.shift();
-    }
-    return new Promise((resolve3, reject) => {
-      const waiter = { resolve: resolve3, reject };
-      const cleanup = () => {
-        this.#waiters.delete(waiter);
-        signal.removeEventListener("abort", onAbort);
-      };
-      const onAbort = () => {
-        cleanup();
-        resolve3(void 0);
-      };
-      waiter.resolve = (value) => {
-        cleanup();
-        resolve3(value);
-      };
-      waiter.reject = (error) => {
-        cleanup();
-        reject(error);
-      };
-      this.#waiters.add(waiter);
-      signal.addEventListener("abort", onAbort, { once: true });
-    });
+    this.#listener = NOT_LISTENING;
+    await listener.release(this.#channel);
   }
 };
 var notificationPayload = z16.object({
@@ -13610,8 +13554,6 @@ var PostgresStreamStore = class _PostgresStreamStore extends StreamStore {
   #pool;
   #schema;
   #ownsPool;
-  #isInitialized = false;
-  #isClosed = false;
   constructor(options) {
     super();
     const schema = options.schema ?? "public";
@@ -13639,26 +13581,28 @@ var PostgresStreamStore = class _PostgresStreamStore extends StreamStore {
   #t(name) {
     return `"${this.#schema}"."${name}"`;
   }
-  async initialize() {
-    await this.#pool.query(postgresStreamDDL(this.#schema));
-    this.#isInitialized = true;
+  /** Opens the store: creates its tables before it returns. */
+  static async create(options) {
+    const store = new _PostgresStreamStore(options);
+    try {
+      await store.#initialize();
+    } catch (error) {
+      await store.close();
+      throw error;
+    }
+    return store;
+  }
+  async #initialize() {
+    await this.#pool.query(
+      lockSchemaDDL(postgresStreamDDL(this.#schema), this.#schema)
+    );
   }
   async close() {
-    if (this.#isClosed) return;
-    this.#isClosed = true;
-    if (this.#ownsPool) {
+    if (this.#ownsPool && !this.#pool.ending) {
       await this.#pool.end();
     }
   }
-  #ensureInitialized() {
-    if (!this.#isInitialized) {
-      throw new Error(
-        "PostgresStreamStore not initialized. Call await store.initialize() after construction."
-      );
-    }
-  }
   async #query(sql, params) {
-    this.#ensureInitialized();
     const result = await this.#pool.query(sql, params);
     return result.rows;
   }
@@ -13666,7 +13610,6 @@ var PostgresStreamStore = class _PostgresStreamStore extends StreamStore {
     return z18.array(row).parse(await this.#query(sql, params));
   }
   async #useTransaction(fn) {
-    this.#ensureInitialized();
     const client = await this.#pool.connect();
     try {
       await client.query("BEGIN");
@@ -13945,7 +13888,10 @@ function assertIdentifier2(value, label) {
 }
 
 // packages/context/src/lib/stream/sqlite.stream-store.ts
-import { DatabaseSync as DatabaseSync2 } from "node:sqlite";
+import { transaction as transaction2 } from "@zukhruf/sqlite-transaction";
+import {
+  DatabaseSync as DatabaseSync2
+} from "node:sqlite";
 import { z as z19 } from "zod";
 
 // packages/context/src/lib/stream/ddl.stream.sqlite.sql
@@ -13971,57 +13917,27 @@ var chunkRow2 = z19.object({
 });
 var SqliteStreamStore = class extends StreamStore {
   #db;
-  #statements = /* @__PURE__ */ new Map();
-  #closed = false;
-  #stmt(sql) {
-    let stmt = this.#statements.get(sql);
-    if (!stmt) {
-      stmt = this.#db.prepare(sql);
-      this.#statements.set(sql, stmt);
-    }
-    return stmt;
-  }
+  #sql;
   close() {
-    if (this.#closed) return;
-    this.#closed = true;
-    this.#statements.clear();
+    if (!this.#db.isOpen) return;
     this.#db.close();
   }
   constructor(pathOrDb) {
     super();
     this.#db = typeof pathOrDb === "string" ? new DatabaseSync2(pathOrDb) : pathOrDb;
     this.#db.exec(ddl_stream_sqlite_default);
+    this.#sql = this.#db.createTagStore();
   }
   async createStream(stream) {
-    this.#stmt(
-      `INSERT INTO streams (id, status, createdAt, startedAt, finishedAt, cancelRequestedAt, error)
-       VALUES (?, ?, ?, ?, ?, ?, ?)`
-    ).run(
-      stream.id,
-      stream.status,
-      stream.createdAt,
-      stream.startedAt,
-      stream.finishedAt,
-      stream.cancelRequestedAt,
-      stream.error
-    );
+    this.#sql.run`INSERT INTO streams (id, status, createdAt, startedAt, finishedAt, cancelRequestedAt, error)
+       VALUES (${stream.id}, ${stream.status}, ${stream.createdAt}, ${stream.startedAt}, ${stream.finishedAt}, ${stream.cancelRequestedAt}, ${stream.error})`;
   }
   async upsertStream(stream) {
     const created = streamRow.optional().parse(
-      this.#stmt(
-        `INSERT INTO streams (id, status, createdAt, startedAt, finishedAt, cancelRequestedAt, error)
-       VALUES (?, ?, ?, ?, ?, ?, ?)
+      this.#sql.get`INSERT INTO streams (id, status, createdAt, startedAt, finishedAt, cancelRequestedAt, error)
+       VALUES (${stream.id}, ${stream.status}, ${stream.createdAt}, ${stream.startedAt}, ${stream.finishedAt}, ${stream.cancelRequestedAt}, ${stream.error})
        ON CONFLICT(id) DO NOTHING
        RETURNING *`
-      ).get(
-        stream.id,
-        stream.status,
-        stream.createdAt,
-        stream.startedAt,
-        stream.finishedAt,
-        stream.cancelRequestedAt,
-        stream.error
-      )
     );
     if (created) {
       return { stream: created, created: true };
@@ -14035,137 +13951,107 @@ var SqliteStreamStore = class extends StreamStore {
     return { stream: existing, created: false };
   }
   async getStream(streamId) {
-    return streamRow.optional().parse(this.#stmt("SELECT * FROM streams WHERE id = ?").get(streamId));
+    return streamRow.optional().parse(this.#sql.get`SELECT * FROM streams WHERE id = ${streamId}`);
   }
   async getStreamStatus(streamId) {
-    const row = statusRow2.optional().parse(
-      this.#stmt("SELECT status FROM streams WHERE id = ?").get(streamId)
-    );
+    const row = statusRow2.optional().parse(this.#sql.get`SELECT status FROM streams WHERE id = ${streamId}`);
     return row?.status;
   }
   async listStreamIds(options) {
-    let sql = "SELECT id FROM streams";
-    const params = [];
-    if (options?.status) {
-      sql += " WHERE status = ?";
-      params.push(options.status);
-    }
-    sql += " ORDER BY createdAt ASC, id ASC";
-    const rows = z19.array(idRow5).parse(this.#stmt(sql).all(...params));
+    const rows = z19.array(idRow5).parse(
+      options?.status ? this.#sql.all`SELECT id FROM streams WHERE status = ${options.status} ORDER BY createdAt ASC, id ASC` : this.#sql.all`SELECT id FROM streams ORDER BY createdAt ASC, id ASC`
+    );
     return rows.map((row) => row.id);
   }
   async updateStream(streamId, update) {
-    return this.#transaction(() => {
-      const stream = streamRow.optional().parse(this.#stmt("SELECT * FROM streams WHERE id = ?").get(streamId));
-      if (!stream) {
-        throw new Error(`updateStream: stream "${streamId}" not found`);
-      }
-      const updates = update(stream);
-      if (updates === void 0) return { stream, updated: false };
-      const setClauses = [];
-      const params = [];
-      const set = (column, value) => {
-        setClauses.push(`${column} = ?`);
-        params.push(value);
-      };
-      if (updates.status !== void 0) set("status", updates.status);
-      if (updates.startedAt !== void 0) set("startedAt", updates.startedAt);
-      if (updates.finishedAt !== void 0) {
-        set("finishedAt", updates.finishedAt);
-      }
-      if (updates.cancelRequestedAt !== void 0) {
-        set("cancelRequestedAt", updates.cancelRequestedAt);
-      }
-      if (updates.error !== void 0) set("error", updates.error);
-      if (setClauses.length === 0) return { stream, updated: false };
-      params.push(streamId);
-      const next = streamRow.parse(
-        this.#stmt(
-          `UPDATE streams SET ${setClauses.join(", ")} WHERE id = ? RETURNING *`
-        ).get(...params)
-      );
-      return { stream: next, updated: true };
-    });
+    return transaction2(
+      this.#db,
+      () => {
+        const stream = streamRow.optional().parse(this.#sql.get`SELECT * FROM streams WHERE id = ${streamId}`);
+        if (!stream) {
+          throw new Error(`updateStream: stream "${streamId}" not found`);
+        }
+        const updates = update(stream);
+        if (updates === void 0) return { stream, updated: false };
+        const setClauses = [];
+        const params = [];
+        const set = (column, value) => {
+          setClauses.push(`${column} = ?`);
+          params.push(value);
+        };
+        if (updates.status !== void 0) set("status", updates.status);
+        if (updates.startedAt !== void 0)
+          set("startedAt", updates.startedAt);
+        if (updates.finishedAt !== void 0) {
+          set("finishedAt", updates.finishedAt);
+        }
+        if (updates.cancelRequestedAt !== void 0) {
+          set("cancelRequestedAt", updates.cancelRequestedAt);
+        }
+        if (updates.error !== void 0) set("error", updates.error);
+        if (setClauses.length === 0) return { stream, updated: false };
+        params.push(streamId);
+        const next = streamRow.parse(
+          this.#db.prepare(
+            `UPDATE streams SET ${setClauses.join(", ")} WHERE id = ? RETURNING *`
+          ).get(...params)
+        );
+        return { stream: next, updated: true };
+      },
+      { mode: "immediate" }
+    );
   }
   async updateStreamStatus(streamId, status, options) {
     const now = Date.now();
     switch (status) {
       case "running":
-        this.#stmt(
-          `UPDATE streams SET status = ?, startedAt = ?
-            WHERE id = ? AND status = 'queued'`
-        ).run(status, now, streamId);
+        this.#sql.run`UPDATE streams SET status = ${status}, startedAt = ${now}
+            WHERE id = ${streamId} AND status = 'queued'`;
         break;
       case "completed":
-        this.#stmt(
-          `UPDATE streams SET status = ?, finishedAt = ?
-            WHERE id = ? AND status IN ('queued', 'running')`
-        ).run(status, now, streamId);
+        this.#sql.run`UPDATE streams SET status = ${status}, finishedAt = ${now}
+            WHERE id = ${streamId} AND status IN ('queued', 'running')`;
         break;
       case "failed":
-        this.#stmt(
-          `UPDATE streams SET status = ?, finishedAt = ?, error = ?
-            WHERE id = ? AND status IN ('queued', 'running')`
-        ).run(status, now, options?.error ?? null, streamId);
+        this.#sql.run`UPDATE streams SET status = ${status}, finishedAt = ${now}, error = ${options?.error ?? null}
+            WHERE id = ${streamId} AND status IN ('queued', 'running')`;
         break;
       case "cancelled":
-        this.#stmt(
-          `UPDATE streams SET status = ?, cancelRequestedAt = ?, finishedAt = ?
-            WHERE id = ? AND status IN ('queued', 'running')`
-        ).run(status, now, now, streamId);
+        this.#sql.run`UPDATE streams SET status = ${status}, cancelRequestedAt = ${now}, finishedAt = ${now}
+            WHERE id = ${streamId} AND status IN ('queued', 'running')`;
         break;
       default:
-        this.#stmt(
-          `UPDATE streams SET status = ?
-            WHERE id = ? AND status = 'queued'`
-        ).run(status, streamId);
+        this.#sql.run`UPDATE streams SET status = ${status}
+            WHERE id = ${streamId} AND status = 'queued'`;
     }
   }
   async appendChunks(chunks) {
     if (chunks.length === 0) return;
     const failures = collectStreamFailures(chunks);
-    this.#transaction(() => {
-      for (const chunk of chunks) {
-        this.#stmt(
-          `INSERT INTO stream_chunks (streamId, seq, data, createdAt)
-           VALUES (?, ?, ?, ?)`
-        ).run(
-          chunk.streamId,
-          chunk.seq,
-          JSON.stringify(chunk.data),
-          chunk.createdAt
-        );
-      }
-      const failedAt = Date.now();
-      for (const failure of failures) {
-        const result = this.#stmt(
-          `UPDATE streams SET status = ?, finishedAt = ?, error = ?
-            WHERE id = ? AND status IN ('queued', 'running')`
-        ).run("failed", failedAt, failure.error, failure.streamId);
-        if (result.changes !== 1) {
-          const existing = this.#stmt(
-            "SELECT id FROM streams WHERE id = ?"
-          ).get(failure.streamId);
-          if (!existing) {
-            throw new Error(`Stream "${failure.streamId}" not found`);
+    transaction2(
+      this.#db,
+      () => {
+        for (const chunk of chunks) {
+          this.#sql.run`INSERT INTO stream_chunks (streamId, seq, data, createdAt)
+           VALUES (${chunk.streamId}, ${chunk.seq}, ${JSON.stringify(chunk.data)}, ${chunk.createdAt})`;
+        }
+        const failedAt = Date.now();
+        for (const failure of failures) {
+          const result = this.#sql.run`UPDATE streams SET status = 'failed', finishedAt = ${failedAt}, error = ${failure.error}
+            WHERE id = ${failure.streamId} AND status IN ('queued', 'running')`;
+          if (result.changes !== 1) {
+            const existing = this.#sql.get`SELECT id FROM streams WHERE id = ${failure.streamId}`;
+            if (!existing) {
+              throw new Error(`Stream "${failure.streamId}" not found`);
+            }
           }
         }
-      }
-    });
+      },
+      { mode: "immediate" }
+    );
   }
   async getChunks(streamId, fromSeq, limit) {
-    let sql = "SELECT * FROM stream_chunks WHERE streamId = ?";
-    const params = [streamId];
-    if (fromSeq !== void 0) {
-      sql += " AND seq >= ?";
-      params.push(fromSeq);
-    }
-    sql += " ORDER BY seq ASC";
-    if (limit !== void 0) {
-      sql += " LIMIT ?";
-      params.push(limit);
-    }
-    const rows = z19.array(chunkRow2).parse(this.#stmt(sql).all(...params));
+    const rows = z19.array(chunkRow2).parse(this.#chunkRows(streamId, fromSeq, limit));
     return Promise.all(
       rows.map(async (row) => ({
         streamId: row.streamId,
@@ -14175,50 +14061,50 @@ var SqliteStreamStore = class extends StreamStore {
       }))
     );
   }
+  #chunkRows(streamId, fromSeq, limit) {
+    if (fromSeq !== void 0 && limit !== void 0) {
+      return this.#sql.all`SELECT * FROM stream_chunks WHERE streamId = ${streamId} AND seq >= ${fromSeq} ORDER BY seq ASC LIMIT ${limit}`;
+    }
+    if (fromSeq !== void 0) {
+      return this.#sql.all`SELECT * FROM stream_chunks WHERE streamId = ${streamId} AND seq >= ${fromSeq} ORDER BY seq ASC`;
+    }
+    if (limit !== void 0) {
+      return this.#sql.all`SELECT * FROM stream_chunks WHERE streamId = ${streamId} ORDER BY seq ASC LIMIT ${limit}`;
+    }
+    return this.#sql.all`SELECT * FROM stream_chunks WHERE streamId = ${streamId} ORDER BY seq ASC`;
+  }
   async deleteStream(streamId) {
-    this.#stmt("DELETE FROM streams WHERE id = ?").run(streamId);
+    this.#sql.run`DELETE FROM streams WHERE id = ${streamId}`;
   }
   async reopenStream(streamId) {
-    return this.#transaction(() => {
-      const row = statusRow2.optional().parse(this.#stmt("SELECT * FROM streams WHERE id = ?").get(streamId));
-      if (!row) {
-        throw new Error(`Stream "${streamId}" not found`);
-      }
-      if (row.status !== "completed" && row.status !== "failed" && row.status !== "cancelled") {
-        throw new Error(
-          `Cannot reopen stream "${streamId}" with status "${row.status}". Only terminal streams can be reopened.`
-        );
-      }
-      this.#stmt("DELETE FROM streams WHERE id = ?").run(streamId);
-      const now = Date.now();
-      this.#stmt(
-        `INSERT INTO streams (id, status, createdAt, startedAt, finishedAt, cancelRequestedAt, error)
-         VALUES (?, ?, ?, ?, ?, ?, ?)`
-      ).run(streamId, "queued", now, null, null, null, null);
-      return {
-        id: streamId,
-        status: "queued",
-        createdAt: now,
-        startedAt: null,
-        finishedAt: null,
-        cancelRequestedAt: null,
-        error: null
-      };
-    });
-  }
-  #transaction(callback) {
-    this.#db.exec("BEGIN IMMEDIATE");
-    try {
-      const result = callback();
-      this.#db.exec("COMMIT");
-      return result;
-    } catch (error) {
-      try {
-        this.#db.exec("ROLLBACK");
-      } catch {
-      }
-      throw error;
-    }
+    return transaction2(
+      this.#db,
+      () => {
+        const row = statusRow2.optional().parse(this.#sql.get`SELECT * FROM streams WHERE id = ${streamId}`);
+        if (!row) {
+          throw new Error(`Stream "${streamId}" not found`);
+        }
+        if (row.status !== "completed" && row.status !== "failed" && row.status !== "cancelled") {
+          throw new Error(
+            `Cannot reopen stream "${streamId}" with status "${row.status}". Only terminal streams can be reopened.`
+          );
+        }
+        this.#sql.run`DELETE FROM streams WHERE id = ${streamId}`;
+        const now = Date.now();
+        this.#sql.run`INSERT INTO streams (id, status, createdAt, startedAt, finishedAt, cancelRequestedAt, error)
+         VALUES (${streamId}, 'queued', ${now}, NULL, NULL, NULL, NULL)`;
+        return {
+          id: streamId,
+          status: "queued",
+          createdAt: now,
+          startedAt: null,
+          finishedAt: null,
+          cancelRequestedAt: null,
+          error: null
+        };
+      },
+      { mode: "immediate" }
+    );
   }
 };
 
@@ -14684,8 +14570,8 @@ export {
   PostgresContextStore,
   PostgresNotifyChangeSource,
   PostgresStreamStore,
-  PromiseResolver,
   RuntimeStrategy,
+  SearchQuerySyntaxError,
   SqlServerContextStore,
   SqliteContextStore,
   SqliteStreamStore,
@@ -14792,6 +14678,7 @@ export {
   isSyntheticReminderMessage,
   lastAssistantLength,
   localeReminder,
+  lockSchemaDDL,
   mapGenerateErrorToCode,
   mergeMessageMetadata,
   mergeReminderMetadata,